Merge remote-tracking branch 'origin/perf/spawn-lists-borrowed' into integ/w2

# Conflicts:
#	crates/horizon-client/src/game.rs

.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
-```

.dockerignore

@@ -2,6 +2,7 @@
 target/
 .local/
 **/node_modules/
+website/
 benchmarks/
 packs/
 mods/

.gitattributes

@@ -1,6 +0,0 @@
-# Generated files that tests compare byte for byte with what they generate: LF on every OS, also
-# where Git for Windows' core.autocrlf would check them out with CRLF.
-docs/launcher-commands.md text eol=lf
-docs/horizon-ctl-commands.md text eol=lf
-crates/horizon-theme/tokens.css text eol=lf
-docs/api/*-reference.md text eol=lf

.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 --history

.github/CODEOWNERS

@@ -6,6 +6,7 @@
 /.github/                                @ludovic111
 /tools/ci/                               @ludovic111
 /tools/release_train.py                  @ludovic111
+/tools/release_channels.py               @ludovic111
 /crates/horizon-release-sign/            @ludovic111
 /crates/horizon-server/src/update.rs     @ludovic111
 /crates/horizon-server/Cargo.toml        @ludovic111

.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/release-line.txt

@@ -1 +0,0 @@
-0.2

.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

@@ -3,8 +3,7 @@ name: checks
 # check main requires, so it never has a condition: a skipped job counts as passed, and every run of this workflow
 # must report a real verify (a pull request that changes no Rust finishes it in seconds instead).
 # parity: the vanilla harnesses a pull request's changes can affect, on the Mac mini's runner, which holds the
-# maintainer's own Minecraft files (Horizon never downloads the game); .github/workflows/parity.yml. Only for a pull
-# request that changes a harness, oracle, probe or the runner: the rest are checked on main by parity-main. A fork's pull
+# maintainer's own Minecraft files (Horizon never downloads the game); .github/workflows/parity.yml. A fork's pull
 # request runs it only when a maintainer adds the run-parity label (.github/workflows/run-parity.yml), so labels
 # never start this workflow. See docs/release-flow.md.
 on:
@@ -19,10 +18,6 @@ concurrency:
   # A new push to a pull request replaces its running checks; main's runs all finish (releases follow them).
   group: checks-${{ github.event.pull_request.number || github.sha }}
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-env:
-  # Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
-  HORIZON_TELEMETRY_URL: "off"
-
 jobs:
   verify:
     runs-on: ubuntu-latest
@@ -51,7 +46,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'
@@ -65,88 +60,15 @@ jobs:
           cargo +stable clippy --workspace --all-targets -- -D warnings
           # The server build (released as horizon-engine): the game without sound or controllers.
           cargo +stable clippy -p horizon-client --all-targets --no-default-features -- -D warnings
-      # Libraries, binaries and integration tests, then doc tests: not the ~275 examples, which clippy above already
-      # type-checks and the parity job builds and runs (they were most of this step's build and link time).
       - name: Test Rust core and voxel kernel correctness
         if: steps.rust.outputs.required != 'false'
-        run: |
-          cargo +stable test --workspace --lib --bins --tests
-          # 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
-  # The launcher is its own workspace (launcher/Cargo.toml), so verify's cargo runs never build it. A pull request that
-  # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
-  # alone and break it together (#2059 and the registry ratings did, 2026-10-26).
-  launcher:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Does this pull request change the launcher or a crate it builds?
-        if: github.event_name == 'pull_request'
-        id: launcher
-        env:
-          BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
-        run: python3 tools/ci/rust_changes.py --launcher "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
-      - name: Install Rust and the headers GPUI links against
-        if: steps.launcher.outputs.required != 'false'
-        run: |
-          sudo apt-get update && sudo apt-get install -y --no-install-recommends libxkbcommon-x11-dev libwayland-dev \
-            libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev libudev-dev
-          rustup toolchain install stable --profile minimal --component rustfmt --component clippy
-      - uses: Swatinem/rust-cache@v2
-        if: steps.launcher.outputs.required != 'false'
-        with:
-          workspaces: launcher
-          shared-key: launcher
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-      - name: Check the launcher's formatting, lint and tests
-        if: steps.launcher.outputs.required != 'false'
-        working-directory: launcher
-        run: |
-          cargo +stable fmt --check
-          cargo +stable clippy --all-targets --locked -- -D warnings
-          cargo +stable test --locked --lib
-  # Most pull requests leave the harnesses to parity-main, which runs them on main a batch of merges at a time
-  # (.github/workflows/parity-main.yml; releases wait for it). A pull request still runs them itself when it changes
-  # a harness, an oracle, a probe or the runner, or carries the run-parity label (run-parity.yml, when it is added).
-  parity-scope:
-    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
-    outputs:
-      run: ${{ steps.scope.outputs.run }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          fetch-depth: 0
-          persist-credentials: false
-      - id: scope
-        env:
-          BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          LABELS: ${{ join(github.event.pull_request.labels.*.name, ' ') }}
-        run: |
-          changed=$(git diff --name-only "$(git merge-base "$BASE_SHA" HEAD)" HEAD)
-          harness=$(grep -E '^(tools/test_[a-z0-9_]+_parity\.py|tools/(parity[a-z_]*|lab)\.py|tools/parity_hosts\.json|mods/horizon/src/test/|crates/[^/]+/examples/|crates/horizon-client/src/game/[a-z_]*(fixture|harness)\.rs|\.github/workflows/parity[a-z-]*\.yml)' <<< "$changed" || true)
-          if [ -n "$harness" ] || [[ " $LABELS " == *" run-parity "* ]]; then
-            echo "run=true" >> "$GITHUB_OUTPUT"
-            echo "The pull request runs its harnesses: ${harness:-label run-parity}"
-          else
-            echo "run=false" >> "$GITHUB_OUTPUT"
-            echo "No harness, oracle, probe or runner change: parity-main checks this on main"
-          fi
+        run: cargo +stable test --workspace
   parity:
-    needs: parity-scope
-    if: needs.parity-scope.outputs.run == 'true'
+    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
     uses: ./.github/workflows/parity.yml
     with:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
-      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
   # Horizon never downloads the game. These jobs need a self-hosted Linux runner
   # (label horizon-game) holding the maintainer's own copy: the official launcher's
   # game directory in HORIZON_MINECRAFT_DIR and the pinned server jar in
@@ -499,7 +421,7 @@ jobs:
         env:
           RUSTUP_TOOLCHAIN: stable
         run: python tools/test_float_log_parity.py
-  jfr-analysis:
+  portable-mod:
     if: github.event_name == 'workflow_dispatch'
     runs-on: [self-hosted, linux, horizon-game]
     steps:
@@ -511,7 +433,101 @@ jobs:
         with:
           distribution: temurin
           java-version: '25'
+      - name: Compile original mod and test metrics
+        run: python tools/build_mod.py
       - name: Verify streaming JFR analysis against the JDK exporter
         run: python tools/test_jfr.py
       - name: Verify ZGC pause and allocation event interpretation
         run: python tools/test_jfr.py --gc zgc
+      - name: Build pinned portable packs
+        run: python tools/build_pack.py
+      - name: Measure isolated worker pacing on this platform
+        run: python -c "from tools.build_mod import benchmark_workers; benchmark_workers()"
+      - name: Measure isolated debounce queue polling
+        run: python -c "from tools.build_mod import benchmark_debounce; benchmark_debounce()"
+      - name: Measure wakeable idle queue latency
+        run: python -c "from tools.build_mod import benchmark_idle; benchmark_idle()"
+      - name: Measure object allocations with compact headers off and on
+        run: python -c "from tools.build_mod import benchmark_headers; benchmark_headers()"
+      - name: Test pack integrity and comparisons
+        run: python -m unittest discover -s tests -v
+      - name: Start recommended OpenGL macOS clients and verify framebuffer readback
+        if: runner.os == 'macOS'
+        run: |
+          python tools/test_client_graphics.py --native-display
+          cp dist/client-graphics-smoke.json dist/client-graphics-macos-title.json
+          python tools/test_client_graphics.py --native-display --world
+          cp dist/client-graphics-smoke.json dist/client-graphics-macos-world.json
+      - name: Compile the private dispatch fixture
+        run: python -c "from tools.build_mod import build_dispatch_fixture; build_dispatch_fixture()"
+      - name: Compile the private integrated-server graphics fixture
+        run: python -c "from tools.build_mod import build_integration_fixture; build_integration_fixture('server-graphics', 'dev.horizonlab.metrics.ServerGraphicsIntegration', fixture_dependencies={})"
+      - name: Compile the private tick-manager state fixture
+        run: python -c "from tools.build_mod import build_integration_fixture; build_integration_fixture('tick-state', 'dev.horizonlab.metrics.TickStateIntegration')"
+      - name: Compile the private terrain tick membership fixture
+        run: python -c "from tools.build_mod import build_tick_dedup_fixture; build_tick_dedup_fixture()"
+      - name: Compile the private culling whitelist fixture
+        run: python -c "from tools.build_mod import build_culling_empty_fixture; build_culling_empty_fixture()"
+      - name: Compile the private culling ray geometry fixture
+        run: python -c "from tools.build_mod import build_integration_fixture; build_integration_fixture('culling-rays', 'dev.horizonlab.dispatch.CullingRayIntegration', ['entityculling'], ['CullingRayAccess'])"
+      - name: Compile the private terrain position lookup fixture
+        run: python -c "from tools.build_mod import build_integration_fixture; build_integration_fixture('terrain-position', 'dev.horizonlab.dispatch.PositionIntegration')"
+      - name: Compile the private terrain quad reuse fixture
+        run: python -c "from tools.build_mod import build_integration_fixture; build_integration_fixture('quad-reuse', 'dev.horizonlab.dispatch.QuadReuseIntegration')"
+      - name: Compile the private object-size agent and terrain quad fixture
+        run: python -c "from tools.test_quad_sizes import build_agent; from tools.build_mod import build_integration_fixture; build_agent(); build_integration_fixture('quad-size', 'dev.horizonlab.dispatch.QuadSizeIntegration')"
+      - name: Compile the private terrain read shutdown fixture
+        run: python -c "from tools.build_mod import build_integration_fixture; build_integration_fixture('terrain-read', 'dev.horizonlab.dispatch.TerrainReadIntegration')"
+      - name: Install headless graphics libraries for applied-hook checks
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install -y xvfb libgl1 libegl1 libvulkan1 mesa-vulkan-drivers libasound2t64 libxkbcommon0
+      - name: Verify integrated-server graphics report against the actual device
+        run: python tools/test_server_graphics.py ${{ runner.os == 'macOS' && '--native-display' || '' }}
+      - name: Exercise the applied dispatcher hooks and upstream rejection path
+        if: runner.os == 'Linux'
+        run: python tools/test_dispatch.py
+      - name: Verify applied tick membership transitions and allocation
+        if: runner.os == 'Linux'
+        run: python tools/test_tick_dedup.py
+      - name: Verify live culling whitelist registration and empty iteration
+        if: runner.os == 'Linux'
+        run: python tools/test_culling_empty.py
+      - name: Compare applied culling ray geometry and provider queries
+        if: runner.os == 'Linux'
+        run: python tools/test_culling_rays.py
+      - name: Verify actual full-data position lookup equivalence
+        if: runner.os == 'Linux'
+        run: python tools/test_terrain_position.py
+      - name: Verify actual terrain quad geometry and allocation
+        if: runner.os == 'Linux'
+        run: python tools/test_quad_reuse.py
+      - name: Measure actual builder and quad shallow sizes in both header modes
+        if: runner.os == 'Linux'
+        run: python tools/test_quad_sizes.py
+      - name: Verify interrupted DH reads and preserved shared futures
+        if: runner.os == 'Linux'
+        run: python tools/test_terrain_read.py
+      - name: Upload original mod and pack manifests only
+        uses: actions/upload-artifact@v4
+        with:
+          name: horizon-linux
+          path: |
+            dist/*.mrpack
+            dist/horizon-*.jar
+            dist/worker-pacing-benchmark.txt
+            dist/debounce-queue-benchmark.txt
+            dist/idle-queue-benchmark.txt
+            dist/object-header-benchmark.txt
+            dist/dispatch-integration.json
+            dist/tick-dedup-integration.json
+            dist/culling-empty-integration.json
+            dist/terrain-read-integration.json
+            dist/culling-rays-integration.json
+            dist/terrain-position-integration.json
+            dist/quad-reuse-integration.json
+            dist/quad-size-integration.json
+            dist/server-graphics-smoke.json
+            dist/client-graphics-smoke.json
+            dist/client-graphics-macos-title.json
+            dist/client-graphics-macos-world.json
+          retention-days: 3

.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

@@ -8,7 +8,8 @@ name: launcher
 # feature. The version and the tag are given to the build (HORIZON_LAUNCHER_VERSION, HORIZON_LAUNCHER_TAG): no bump
 # commits.
 # Never marked latest. Pushes to launcher branches only build. RELEASES_PAUSED=1 stops releases.
-# macOS: with the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
+# macOS: Apple Silicon, and Intel cross-built for x86_64-apple-darwin on the same runner, its tests and smoke test
+# under Rosetta 2 (#1161). With the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
 # Developer ID, notarized and stapled, from the runner's signing keychain (packaging/macos/README.md);
 # unset (forks), they are signed ad hoc.
 #   gh workflow run launcher --ref <branch>                    # dry run: builds everything, publishes nothing
@@ -49,10 +50,6 @@ concurrency:
   group: launcher-${{ github.ref == 'refs/heads/main' && 'release' || github.ref }}
   cancel-in-progress: false
 
-env:
-  # Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
-  HORIZON_TELEMETRY_URL: "off"
-
 jobs:
   decide:
     runs-on: ubuntu-latest
@@ -105,6 +102,13 @@ jobs:
             mac: true
             asset: horizon-launcher-macos-arm64.zip
             binary: horizon-launcher
+            mac_arch: arm64
+          - name: macos-x64
+            mac: true
+            target: x86_64-apple-darwin
+            asset: horizon-launcher-macos-x64.zip
+            binary: horizon-launcher
+            mac_arch: x64
           - name: windows
             os: windows-latest
             asset: horizon-launcher-windows-x64.zip
@@ -117,6 +121,8 @@ jobs:
     timeout-minutes: ${{ matrix.mac && 60 || 40 }}
     env:
       RUSTFLAGS: ${{ matrix.rustflags }}
+      # Where cargo puts the launcher: target/release, or target/<target>/release for another target.
+      BIN: ${{ matrix.target && format('target/{0}/release', matrix.target) || 'target/release' }}
       # Horizon's Azure app for Microsoft sign-in (docs/microsoft-account.md): a repository
       # variable, not a secret. Unset, the launcher says sign-in is not configured.
       HORIZON_MSA_CLIENT_ID: ${{ vars.HORIZON_MSA_CLIENT_ID }}
@@ -140,6 +146,8 @@ jobs:
           # parity jobs, and nothing they leave may end up in a launcher release (target/ is rebuilt from scratch).
           clean: true
       - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
         if: runner.environment == 'github-hosted'
         with:
@@ -160,17 +168,17 @@ jobs:
             echo "LAUNCHER_FEATURES=gpui/runtime_shaders" >> "$GITHUB_ENV"
           fi
       # Every test target (the library, the binary, tests/), on each system the launcher ships for.
-      - run: cargo test --release --locked ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
-      - run: cargo build --release --locked ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
+      - run: cargo test --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
+      - run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
       - name: The version is the release's
         run: |
-          out=$(target/release/${{ matrix.binary }} --version)
+          out=$("$BIN/${{ matrix.binary }}" --version)
           echo "$out"
           expected="${HORIZON_LAUNCHER_VERSION:-$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)}"
           [[ "$out" == "horizon-launcher $expected" ]] || { echo "::error::expected horizon-launcher $expected"; exit 1; }
       - name: Only system libraries
         run: |
-          file=target/release/${{ matrix.binary }}
+          file="$BIN/${{ matrix.binary }}"
           case "$RUNNER_OS" in
             Windows) python ../tools/check_imports.py "$file" ;;
             macOS) others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true)
@@ -185,18 +193,27 @@ jobs:
           export HORIZON_LAUNCHER_HOME="${RUNNER_TEMP//\\//}/horizon-launcher-smoke"
           export HORIZON_HOME="$HORIZON_LAUNCHER_HOME/game"
           rm -rf "$HORIZON_LAUNCHER_HOME"
-          launcher="$PWD/target/release/${{ matrix.binary }}"
+          launcher="$PWD/$BIN/${{ matrix.binary }}"
           # GitHub's API rate-limits shared runner addresses now and then: try a few times.
           retry() { for i in 1 2 3 4; do "$@" && return 0; sleep $((i * 15)); done; return 1; }
           retry "$launcher" versions
+          "$launcher" links --json
+          "$launcher" menu-style classic
+          grep -qx 'menuStyle:classic' "$HORIZON_HOME/horizon.txt"
+          "$launcher" menu-style horizon
+          # A new platform's launcher can come out before any stable game release has its build (Intel Macs, #1161):
+          # then there is nothing to install yet.
+          stable_build='import json, sys; sys.exit(not any(r["available_here"] and r["channel"] == "stable" for r in json.load(sys.stdin)))'
+          if ! retry "$launcher" --json versions | ${{ runner.os == 'Windows' && 'python' || 'python3' }} -c "$stable_build"; then
+            echo "::warning::No stable game release has a build for ${{ matrix.name }} yet: install not tested"
+            rm -rf "$HORIZON_LAUNCHER_HOME"
+            exit 0
+          fi
           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; }
@@ -224,11 +241,11 @@ jobs:
             # Developer ID): packaging/macos.
             python3 -m venv "$RUNNER_TEMP/dmg" && "$RUNNER_TEMP/dmg/bin/pip" install --quiet dmgbuild==1.6.5
             version=${HORIZON_LAUNCHER_VERSION:-$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)}
-            DMGBUILD="$RUNNER_TEMP/dmg/bin/dmgbuild" ../packaging/macos/package.sh target/release/${{ matrix.binary }} "$version" out
+            DMGBUILD="$RUNNER_TEMP/dmg/bin/dmgbuild" ../packaging/macos/package.sh "$BIN/${{ matrix.binary }}" "$version" out ${{ matrix.mac_arch }}
             rm -rf out/Horizon.app
           else
             mkdir -p dist
-            cp target/release/${{ matrix.binary }} dist/
+            cp "$BIN/${{ matrix.binary }}" dist/
             if [[ "${{ matrix.asset }}" == *.tar.gz ]]; then
               (cd dist && tar czf ../out/${{ matrix.asset }} ${{ matrix.binary }})
             else

.github/workflows/mod-registry.yml

@@ -1,34 +0,0 @@
-name: mod-registry
-# The submission service is its own workspace (crates/horizon-mod-registry), so the checks job doesn't build
-# it: this one does, when it or horizon-mods (the checks it shares with the launcher and the game) changes.
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'crates/horizon-mods/**'
-      - 'crates/horizon-mod-registry/**'
-      - '.github/workflows/mod-registry.yml'
-  pull_request:
-    paths:
-      - 'crates/horizon-mods/**'
-      - 'crates/horizon-mod-registry/**'
-      - '.github/workflows/mod-registry.yml'
-permissions:
-  contents: read
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    defaults:
-      run:
-        working-directory: crates/horizon-mod-registry
-    steps:
-      - uses: actions/checkout@v4
-      - run: rustup toolchain install stable --profile minimal --component rustfmt --component clippy
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: crates/horizon-mod-registry
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-      - run: cargo +stable fmt --check
-      - run: cargo +stable clippy --all-targets --locked -- -D warnings
-      - run: cargo +stable test --locked

.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/nightly.yml

@@ -8,7 +8,7 @@ name: nightly audit
 #   gh workflow run "nightly audit" -f dry_run=true    # the audit, without touching issues
 on:
   schedule:
-    # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:07 in Paris today.
+    # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:00 in Paris.
     - cron: '7 1 * * *'
     - cron: '7 2 * * *'
   workflow_dispatch:
@@ -23,27 +23,17 @@ permissions:
 concurrency:
   group: nightly-audit
   cancel-in-progress: false
-env:
-  # Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
-  HORIZON_TELEMETRY_URL: "off"
-
 jobs:
   audit:
-    # The Mac mini's runners only: the audit compares with the previous one, so it stays on one platform.
-    runs-on: [self-hosted, horizon-game, macOS]
-    timeout-minutes: 240  # every harness (~80 min) plus lan_integration (~40 min an attempt under load, retried)
+    runs-on: [self-hosted, horizon-game]
+    timeout-minutes: 150
     steps:
-      - name: 03:07 in Paris
+      - name: 03:00 in Paris
         id: when
-        env:
-          SCHEDULE: ${{ github.event.schedule }}
         run: |
-          # Which cron is 03:07 in Paris, from Paris's offset today: GitHub can start a schedule hours late, so the
-          # clock at start time can't tell (on 2026-10-26 both started after 04:00 Paris and both skipped).
-          offset=$(TZ=Europe/Paris date +%z)
-          ours=$([ "$offset" = +0200 ] && echo '7 1 * * *' || echo '7 2 * * *')
-          if [[ "${{ github.event_name }}" == schedule && "$SCHEDULE" != "$ours" ]]; then
-            echo "Paris is at UTC${offset} today: the '$ours' schedule runs the audit."
+          hour=$(TZ=Europe/Paris date +%H)
+          if [[ "${{ github.event_name }}" == schedule && "$hour" != 03 ]]; then
+            echo "It is ${hour}:00 in Paris: the other schedule runs the audit."
             echo "run=false" >> "$GITHUB_OUTPUT"
           else
             echo "run=true" >> "$GITHUB_OUTPUT"
@@ -71,8 +61,7 @@ jobs:
         run: |
           echo "since=$(date +%Y-%m-%dT%H:%M:%S)" >> "$GITHUB_OUTPUT"
           set +e
-          # lan_integration (the whole lan_e2e suite) takes ~2,400 s under load, past the usual 1,800.
-          python3 tools/parity.py --all --timeout 3000 2>&1 | tee "$RUNNER_TEMP/audit.log"
+          python3 tools/parity.py --all --timeout 1800 2>&1 | tee "$RUNNER_TEMP/audit.log"
           echo "exit=${PIPESTATUS[0]}" >> "$GITHUB_OUTPUT"
           { echo '```'; tail -40 "$RUNNER_TEMP/audit.log"; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
       - name: Issues for the harnesses that regressed

.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/parity-main.yml

@@ -1,77 +0,0 @@
-name: parity-main
-# The vanilla harnesses on main, a batch of merges at a time (docs/release-flow.md#parity-on-main), on the Mac mini's
-# runner. One run at a time: merges that land while a run goes on wait in one pending run (GitHub keeps only the
-# newest), which checks every merge since main's last green parity-main (tools/parity_main.py base). On a failure it
-# bisects the failing harnesses over those merges and comments on the pull request that broke them. Releases ship
-# only a commit whose parity-main passed (tools/release_train.py), so nothing a harness catches reaches players.
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-permissions:
-  contents: read
-  # The comment on the merge that broke a harness.
-  pull-requests: write
-  # tools/parity_main.py base reads earlier runs.
-  actions: read
-concurrency:
-  group: parity-main
-  cancel-in-progress: false
-env:
-  # Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
-  HORIZON_TELEMETRY_URL: "off"
-
-jobs:
-  parity-main:
-    # A Mac mini runner of its own (ludovics-mac-mini-2 holds only this label since 2026-10-26): behind PR parity jobs
-    # this run waited 2 h while every merge replaced the pending one, and on the release runner a release then waited
-    # behind the next run. PR parity jobs have ludovics-mac-mini and playhorizon. Not playhorizon: its 4 CPUs
-    # make a core-crate run several times longer, and a failure here bisects and comments on merges.
-    runs-on: [self-hosted, macOS, horizon-parity-main]
-    timeout-minutes: 240  # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.sha }}
-          fetch-depth: 0
-          persist-credentials: false
-          # Keeps .local/ (parity state, probe builds, oracle results) and target/ between runs.
-          clean: false
-      - uses: dtolnay/rust-toolchain@stable
-      - name: Tools from the runner
-        run: bash tools/ci/runner-env.sh
-      - name: Vanilla data, and resources prepared by this preparer
-        run: bash tools/ci/vanilla-data.sh
-      - name: Main's last green parity-main
-        id: base
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: echo "sha=$(python3 tools/parity_main.py base)" >> "$GITHUB_OUTPUT"
-      - name: The harnesses the merges since then can affect
-        id: harnesses
-        # A failure here is judged by the next step: the run passes when every failed harness passes again at HEAD.
-        continue-on-error: true
-        env:
-          PARITY_HOSTS: ''
-          BASE_SHA: ${{ steps.base.outputs.sha }}
-        run: |
-          echo "Merges since ${BASE_SHA}:"
-          git log --first-parent --format='  %h %s' "$BASE_SHA..HEAD"
-          python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400
-      - name: A flake, or the merge that broke them
-        if: steps.harnesses.outcome == 'failure'
-        env:
-          GH_TOKEN: ${{ github.token }}
-          PARITY_HOSTS: ''
-          BASE_SHA: ${{ steps.base.outputs.sha }}
-        run: |
-          rm -rf .local/parity-main-logs && cp -R .local/parity-runner/logs .local/parity-main-logs 2>/dev/null || true
-          python3 tools/parity_main.py bisect "$BASE_SHA" --comment
-      - name: Logs of the failed harnesses
-        if: steps.harnesses.outcome == 'failure'
-        uses: actions/upload-artifact@v4
-        with:
-          name: parity-main-logs
-          path: .local/parity-main-logs/
-          if-no-files-found: ignore
-          retention-days: 7

.github/workflows/parity.yml

@@ -1,6 +1,6 @@
 name: parity
-# The vanilla harnesses a pull request's changes can affect, on the Mac mini's runner or playhorizon's, which hold the
-# maintainer's own Minecraft files (Horizon never downloads the game). Called by ci.yml for pull requests from this repository
+# The vanilla harnesses a pull request's changes can affect, on the Mac mini's runner, which holds the maintainer's
+# own Minecraft files (Horizon never downloads the game). Called by ci.yml for pull requests from this repository
 # and by run-parity.yml when a maintainer labels a fork's pull request run-parity. See docs/release-flow.md.
 on:
   workflow_call:
@@ -13,79 +13,32 @@ on:
         description: The commit to check out and test
         type: string
         required: true
-      full:
-        description: >-
-          The pull request carries the full-parity label (a change every harness reaches, such as a crate split): it
-          runs on playhorizon's runner only, so the Mac mini's runners stay free for the others. While that runner is
-          busy the job waits for it.
-        type: boolean
-        default: false
 permissions:
   contents: read
-env:
-  # Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
-  HORIZON_TELEMETRY_URL: "off"
-
 jobs:
   parity:
-    runs-on: ${{ inputs.full && fromJSON('["self-hosted", "horizon-game", "playhorizon"]') || fromJSON('["self-hosted", "horizon-game"]') }}
-    # A change to core crates reruns ~350 harnesses: ~60-90 min on the Mac mini; on playhorizon (4 of its 8 vCPUs, 4
-    # harnesses at a time) up to a few hours, and any pull request's job may land there.
-    timeout-minutes: ${{ inputs.full && 360 || 180 }}
+    runs-on: [self-hosted, horizon-game]
+    timeout-minutes: 120  # a change to core crates reruns ~300 harnesses: ~60-90 min on the Mac mini
     steps:
       - uses: actions/checkout@v4
         with:
-          # The commit the event names: a fork's later pushes need another run-parity label. The next step merges
-          # main into it.
+          # The commit the event names: a fork's later pushes need another run-parity label.
           ref: ${{ inputs.head }}
           fetch-depth: 0
           persist-credentials: false
           # Keeps .local/ (parity state, probe builds, oracle results) and target/ between runs.
           clean: false
-      - name: The head merged into main (what merging it would land)
-        id: merge
-        env:
-          BASE_SHA: ${{ inputs.base }}
-          HEAD_SHA: ${{ inputs.head }}
-        run: |
-          # Harness fixes and game fixes that reached main since the branch was made then apply here too: a head
-          # tested alone failed harnesses already fixed on main (server_knockback before #2114, mob_ai's heap before
-          # #2270, save_roundtrip before #2212). Selection then compares with this main, so it sees only the pull
-          # request's own changes. A head that conflicts with main is tested alone.
-          set -euo pipefail
-          git merge --abort 2>/dev/null || true
-          git fetch -q --no-tags origin +refs/heads/main:refs/remotes/origin/main
-          main=$(git rev-parse origin/main)
-          if git -c user.name=parity -c user.email=parity@localhost merge -q --no-edit --no-ff "$main" >/dev/null 2>&1; then
-            echo "base=$main" >> "$GITHUB_OUTPUT"
-            echo "Tested: head ${HEAD_SHA:0:9} merged into main ${main:0:9}" | tee -a "$GITHUB_STEP_SUMMARY"
-          else
-            git merge --abort
-            echo "base=$BASE_SHA" >> "$GITHUB_OUTPUT"
-            echo "::warning::head ${HEAD_SHA:0:9} conflicts with main ${main:0:9}: tested alone, without main's fixes"
-            echo "Tested: head ${HEAD_SHA:0:9} alone (it conflicts with main ${main:0:9})" | tee -a "$GITHUB_STEP_SUMMARY"
-          fi
       - uses: dtolnay/rust-toolchain@stable
       - name: Tools from the runner
         run: bash tools/ci/runner-env.sh
       - name: Vanilla data, and resources prepared by this preparer
         run: bash tools/ci/vanilla-data.sh
-      - name: The prepared output is the one the preparer's OUTPUT_VERSION says
-        env:
-          BASE_SHA: ${{ steps.merge.outputs.base }}
-        run: |
-          # A head made before OUTPUT_VERSION (#1947) that conflicts with main has neither the tool nor the number.
-          if [ ! -f tools/prepare_output.py ] || ! grep -q OUTPUT_VERSION crates/horizon-prepare/src/lib.rs; then
-            echo "This head's preparer has no OUTPUT_VERSION: nothing to check"
-            exit 0
-          fi
-          python3 tools/prepare_output.py check --cache --base "$BASE_SHA"
       - name: The version constants are the pinned jar's
         run: python3 tools/gen_version_consts.py --check
       - name: The harnesses this change can affect
         env:
           PARITY_HOSTS: ''
-          BASE_SHA: ${{ steps.merge.outputs.base }}
+          BASE_SHA: ${{ inputs.base }}
         run: python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400  # world_spawn takes ~1480 s on a busy runner
       - name: Logs of the failed harnesses
         if: failure()

.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/promote.yml

@@ -0,0 +1,52 @@
+name: promote
+# Beta game releases become stable (docs/release-flow.md, "Channels"): every 30 minutes tools/release_channels.py
+# promotes the newest beta that has been out 6 hours, passed its release smoke test and isn't covered by an issue
+# labelled release-blocker. By hand, from GitHub's app too (Actions > promote > Run workflow):
+#   gh workflow run promote -f tag=v2026.10.19.03               # that beta now, without the wait
+#   gh workflow run promote -f tag=v2026.10.19.03 -f force=true  # even blocked or without its smoke test
+#   gh workflow run promote -f dry_run=true                      # say what would be promoted
+# Holding betas back: label an issue release-blocker. While it is open it holds every beta; closed as completed it
+# still holds the betas published before it closed. The issue's text is never read (its author could edit it).
+# When the oldest waiting beta is 24 hours old, an issue "Promotion to stable has stalled" says so; it closes itself
+# after the next promotion.
+on:
+  schedule:
+    - cron: '13,43 * * * *'
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: The beta to promote now (empty = the newest beta that is due)
+        type: string
+        default: ''
+      force:
+        description: Promote that tag even if a release-blocker covers it or its smoke test didn't run
+        type: boolean
+        default: false
+      dry_run:
+        description: Say what would be promoted, change nothing
+        type: boolean
+        default: false
+permissions:
+  contents: write
+  issues: write
+concurrency:
+  group: promote
+  cancel-in-progress: false
+jobs:
+  promote:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # The notes of a promoted release cover every pull request since the last stable one.
+          fetch-depth: 0
+          # gh uses GH_TOKEN below; nothing needs git credentials on disk.
+          persist-credentials: false
+      - name: Promote
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ inputs.tag }}
+          FORCE: ${{ inputs.force && 'yes' || '' }}
+          DRY_RUN: ${{ (inputs.dry_run || github.ref != 'refs/heads/main') && 'yes' || '' }}
+        run: python3 tools/release_channels.py promote ${TAG:+--tag "$TAG"} ${FORCE:+--force} ${DRY_RUN:+--dry-run}

.github/workflows/release.yml

@@ -1,19 +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:
+# a release when pull requests merged since the last one changed what players run and the newest merged 15 minutes
+# ago (the oldest an hour ago, if merges never pause), or at once for a pull request labelled release-now.
+# RELEASES_PAUSED=1 (repository variable) stops them.
+# 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): Apple Silicon, and
+# Intel cross-built there for x86_64-apple-darwin and checked under Rosetta 2 (#1161), 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 a beta (a pre-release) that promote.yml makes
+# stable after 6 hours. 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).
-    workflows: [checks, parity-main]
+    workflows: [checks]
     types: [completed]
     branches: [main]
   schedule:
@@ -21,24 +24,17 @@ 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 +45,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
@@ -63,28 +60,320 @@ jobs:
         env:
           GH_TOKEN: ${{ github.token }}
           RELEASES_PAUSED: ${{ vars.RELEASES_PAUSED }}
-          # The commit whose checks or parity-main just passed; a dry run builds the branch it was started on;
-          # otherwise main's newest commit with green checks and parity-main.
+          # The commit whose checks just passed; a dry run builds the branch it was started on; otherwise
+          # main's newest commit with green checks.
           HEAD_SHA: ${{ github.event.workflow_run.head_sha || (steps.mode.outputs.dry_run == 'true' && github.sha) || '' }}
           FORCE: ${{ inputs.force && 'yes' || '' }}
         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.
+  build:
     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'
+    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
+          # Intel Macs: built on the same runner for another target; its checks and smoke test run the x86_64
+          # programs under Rosetta 2.
+          - name: macos-x64
+            mac: true
+            target: x86_64-apple-darwin
+            dir: horizon-macos-x64
+            asset: horizon-macos-x64.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 }}
+      # Where cargo puts the programs: target/release, or target/<target>/release for another target.
+      BIN: ${{ matrix.target && format('target/{0}/release', matrix.target) || 'target/release' }}
+    defaults:
+      run:
+        shell: bash
     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
+          # 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
+        with:
+          targets: ${{ matrix.target }}
+      - 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
+        run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} -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: |
-          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"
+          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
+            test -f "$BIN/$binary${{ matrix.exe }}" || { echo "::error::$BIN/$binary${{ matrix.exe }} is missing"; exit 1; }
+          done
+      - name: 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" "$BIN/$binary"
+            codesign --verify --strict --verbose=2 "$BIN/$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="$BIN/$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=$BIN
+          "$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/$BIN/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: a beta becomes stable only with it (tools/release_channels.py).
+          cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json"
+      # One smoke-test.json per release, the Apple Silicon build's; the Intel build must pass its own run too.
+      - uses: actions/upload-artifact@v4
+        if: runner.environment == 'self-hosted' && !matrix.target
+        with:
+          name: smoke-test.json
+          path: ${{ runner.temp }}/smoke-test.json
+          if-no-files-found: error
+          retention-days: 3
+      - name: Package
+        run: |
+          set -euo pipefail
+          cargo run --locked -p xtask -- package "$BIN/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).
+          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 != ''
+        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-macos-x64.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
+    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: 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)
+          smoke=(); [[ -f dist/smoke-test.json ]] && smoke=(dist/smoke-test.json)
+          # A beta (pre-release): promote.yml makes it stable and latest after 6 hours (docs/release-flow.md).
+          gh release create "$TAG" --target "${{ needs.decide.outputs.head }}" --title "$(cat notes/title.txt)" \
+            --notes-file notes/body.md --prerelease --latest=false dist/horizon-linux-x86_64.tar.gz \
+            dist/horizon-windows-x64.zip dist/horizon-macos-arm64.zip dist/horizon-macos-x64.zip \
+            dist/horizon-server-linux-x86_64.tar.gz dist/SHA256SUMS "${signature[@]}" "${smoke[@]}"
+      - 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 }}: $(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,20 +5,12 @@ 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).
-  HORIZON_TELEMETRY_URL: "off"
-
 jobs:
   parity:
     if: github.event.label.name == 'run-parity'
@@ -26,4 +18,3 @@ jobs:
     with:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
-      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}

.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

.gitignore

@@ -31,6 +31,3 @@
 /.horizon-cache/
 /crash-reports/
 /debug/
-
-# Release-only compiled original exporter bundle.
-/exporters/

AGENTS.md

@@ -1,193 +0,0 @@
-# Horizon: a map for agents
-
-Minecraft: Java Edition 26.3 rewritten in Rust (wgpu). Vanilla is the specification wherever it has the
-feature. Read [CONTRIBUTING.md](CONTRIBUTING.md) once; this page tells you where things are.
-Feature → files → harness for the most-changed areas: [docs/architecture.md](docs/architecture.md).
-
-## Rules that bite
-
-- **Never commit Mojang's files**: game jars, assets, decompiled source, prepared resources (`.local/`).
-  `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit.
-- **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
-  folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
-  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
-  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.
-- **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
-  `🤖 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
-  they would change the vanilla look.
-- Small PRs (< ~500 lines). Labels: `feature` (players get something new), `skip-release` (they see no
-  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
-
-Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-server` are separate workspaces.
-
-| 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-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` |
-| `horizon-assets` | Resource decoding: block-state and item models, baking, atlases |
-| `horizon-prepare` | Builds `.local/horizon-client/26.3` from the player's own Minecraft install (runs the Java exporters) |
-| `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-anticheat` | The dedicated server's anticheat, off by default: `[anticheat]` settings, violation levels, the checks' rules; the hub runs them (`lan/anticheat.rs`) ([docs/anticheat.md](docs/anticheat.md)) |
-| `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-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 |
-| `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website |
-| `horizon-telemetry`, `horizon-telemetry-server`, `horizon-bench` | Opt-in data collection, its ingest server, the benchmark report format |
-| `horizon-dualsense`, `horizon-threads`, `horizon-release-sign`, `horizon-bots`, `xtask` | DualSense output, thread priorities, signed release checksums, load-test bots, repo tasks |
-| `launcher/` | GPUI launcher: `main.rs` (UI), `backend.rs` (installs, updates), `cli.rs`, `mcp.rs`, `*_page.rs` |
-
-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
-reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` and `crates/horizon-theme/tokens.css` from main.
-
-## Build and test fast
-
-```sh
-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 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/agent_control_e2e.py         # horizon-ctl / MCP end to end
-```
-
-- Harnesses and the game need the vanilla data in `.local/` (`minecraft/`, `horizon-client/26.3`, `datagen/`,
-  `tools/`): see [docs/parity-workflow.md](docs/parity-workflow.md). Without it, pr_ready lists the
-  harnesses for CI.
-- A harness = `tools/test_<name>_parity.py` (324 of them) + a Java oracle (`mods/horizon/src/test/java/dev/horizonlab/parity/Vanilla*Oracle.java`)
-  + a Rust probe: `crates/<crate>/examples/<name>_{probe,fixture}.rs` (horizon-world 175, horizon-client 104),
-  or the game binary with a fixture env var (`game/dispense_fixture.rs`, `game/sculk_fixture.rs`,
-  `game/command_harness.rs`, `game/net_harness.rs`). Copy a nearby harness for a new one.
-- Probes build into `.local/parity-target/`; harnesses find binaries via `lab.cargo_target()`, never `target/`.
-- 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`).
-- 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`,
-  then `horizon-ctl --socket … state|keys|turn|command|screenshot|quit`
-  ([docs/horizon-ctl-commands.md](docs/horizon-ctl-commands.md)).
-
-## 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`
-  ([docs/decompilation-status.md](docs/decompilation-status.md)).
-- A harness runs the oracle against the real 26.3 jars and the Rust probe on the same inputs, then compares
-  their JSON. Oracle runs are cached by `tools/parity_shim.py`; `--fresh` reruns them.
-- Mirror vanilla's `Math` calls with `horizon_core::jmath`, and vanilla's RNG with `horizon_core::random`:
-  random draws must happen in vanilla's order.
-
-## 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
-`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` |
-| 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` |
-| 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` |
-| Multiplayer client | L: `net.rs` (network thread); G: `remote.rs` (`fn handle_packet`, `fn tick_remote`), `remote_*.rs` (mob data, objects, projectiles, vehicles, stations) |
-| LAN host / server side | L: `lan/` (`conn.rs` handshake + login threads, `hub.rs` + `hub/` play state, `chunks.rs`, `entity.rs`, `tracking.rs`, `guest.rs`, `playerdata.rs`); G: `lan.rs` (`LanHost`), `lan_actions.rs` (`fn as_guest`, `fn tick_guests`), `lan_*.rs` per feature, `lan_entities.rs` (tracked entities) |
-| 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`, `horizon-anticheat` (L: `lan/anticheat.rs`) |
-| 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` |
-| 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)) |
-| Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
-| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |
-
-## How `Game` is organised
-
-- `struct Game` (game.rs, ~290 fields) holds everything. Its methods are spread over ~180 files: game.rs keeps
-  the core (tick, render, input, inventory, world open/close) and each `game/<feature>.rs` adds an
-  `impl Game<'_>` block for one feature, with its own state types. Fields are private to the bin.
-- Find a feature's code: `grep -rn "fn tick_<thing>\|fn <verb>_<thing>" crates/horizon-client/src/game*`;
-  the file is usually `game/<thing>s.rs`. Who calls it: grep the name in game.rs's `fn tick` / `fn tick_world`.
-- Fields that say which mode runs: `remote` (this window is a client of a server: multiplayer, LAN guest, or
-  single player on its server thread), `lan` (`LanHost`: this world is open to the network), `integrated`
-  (the window's own server thread), `serving` (this `Game` *is* that server thread), `options.dedicated`.
-  `fn tick` returns `tick_remote()` when `remote` is set; nothing else of the local simulation runs.
-- A server's players run through the same gameplay code as the local player: `as_guest` swaps the guest's
-  state (position, inventory, mode, mining, item use) into `Game` for one call (`game/lan_actions.rs`), and
-  `levels.rs` swaps whole dimensions in the same way. Changes reach clients through the block log, level
-  events and the entity tracker (`lan/tracking.rs`, `game/lan_entities.rs`).
-- Shared read-only data: `Resources` (`res`: blocks, items, recipes, mob types, biomes) and `PackResources`
-  (`pack`), both in game.rs.
-
-## The two single-player paths
-
-1. **Server thread (default since #1514):** `game/integrated.rs` runs a second `Game` (`serving`) on a
-   "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.
-
-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:
-
-```sh
-cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T               # server thread
-python3 tools/lan_e2e.py --check <name>                  # host on its server thread, guest is a server client
-python3 tools/parity.py dedicated_server server_entities server_player_damage
-```
-
-## Docs worth knowing
-
-[docs/parity-workflow.md](docs/parity-workflow.md) (runner, gate, shards, scopes) ·
-[docs/native-client.md](docs/native-client.md) (options, controls, horizon-ctl) ·
-[docs/server-levels.md](docs/server-levels.md) (levels per dimension) ·
-[docs/rust-parity.md](docs/rust-parity.md) (what is ported) · [docs/known-issues.md](docs/known-issues.md) ·
-[docs/release-flow.md](docs/release-flow.md) · [docs/README.md](docs/README.md) (index).

CLAUDE.md

@@ -1 +0,0 @@
-AGENTS.md

CONTRIBUTING.md

@@ -4,13 +4,8 @@ Thanks for helping. Horizon is Minecraft: Java Edition 26.3 rewritten in Rust, a
 everything is that **it plays exactly like vanilla**. This page is the short version of how we work; questions are
 welcome on [Discord](https://discord.gg/HcTeMZxe5E).
 
-This repository holds the game and the launcher, plus the tools, tests and docs that build, check and release them.
-The website (playhorizon.dev) is built in a separate repository from this one's README, `docs/api/` and roadmap. Anything else (videos, Discord and other community material) lives elsewhere.
-
-**Where to start: [playhorizon.dev/hub](https://playhorizon.dev/hub).** It shows what is being done now and next
-([ROADMAP.md](ROADMAP.md) in the repository), the work board, good first tasks, and the forms to report a bug or
-suggest something. A pull request for a roadmap item carries its `roadmap:<id>` label; ideas go to the suggestion
-queue (the hub, or `/suggest` on Discord) rather than to issues, which are for bugs.
+This repository holds the game, the launcher and the website, plus the tools, tests and docs that build, check and
+release them. Anything else (videos, Discord and other community material) lives elsewhere.
 
 ## Build it
 
@@ -44,17 +39,6 @@ probe against Horizon, and compares their outputs. There are about 290 of them.
 
 Never commit game files, decompiled source or prepared resources (`.local/`): `tools/check_public_tree.py` rejects
 them (`git config core.hooksPath .githooks` runs it before every commit).
-The pre-push hook checks the full history reachable from the branches and tags being pushed. Run
-`python3 tools/check_public_tree.py --history` to audit the history of all local refs.
-
-## Only original code
-
-Horizon's code is written from Minecraft 26.3 itself and from public documentation, never from another mod, loader
-or renderer. Don't read, copy, translate or paraphrase the source of Iris, OptiFine, Sodium or any other project,
-and don't send code an AI tool wrote from it. Their user documentation and file formats are fine to read, and their
-packs and mods are fine to run and observe. Shader packs were removed on 24 October 2026 (#1561) because their code
-had been written from another project's source; they come back only as a clean-room rewrite from a written
-description of the pack format.
 
 ## Before asking for review
 
@@ -74,19 +58,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 +66,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 +82,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

@@ -1,37 +1,6 @@
 [workspace]
-exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = [
-    "crates/horizon-core",
-    "crates/horizon-dualsense",
-    "crates/horizon-threads",
-    "crates/horizon-hdr",
-    "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-anticheat",
-    "crates/horizon-server",
-    "crates/horizon-bots",
-    "crates/horizon-assets",
-    "crates/horizon-protocol",
-    "crates/horizon-theme",
-    "crates/horizon-prepare",
-    "crates/horizon-telemetry",
-    "crates/horizon-bench",
-    "crates/horizon-friends",
-    "crates/horizon-relay",
-    "crates/horizon-mods",
-    "crates/cargo-horizon-mod",
-    "crates/horizon-port-pack",
-    "crates/horizon-shaders",
-    "crates/horizon-shader-api",
-    "crates/horizon-release-sign",
-    "xtask",
-]
+exclude = ["launcher", "crates/horizon-telemetry-server", "third_party/wgpu-hal"]
+members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/voxel-kernels", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-shaderpack", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "xtask"]
 resolver = "2"
 
 [workspace.package]
@@ -50,10 +19,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,23 +15,22 @@
   <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="ROADMAP.md"><b>Roadmap</b></a> ·
+  <a href="https://github.com/ludovic111/horizon/releases"><b>Release notes</b></a> ·
   <a href="#project-status"><b>Project status</b></a> ·
   <a href="#contributing"><b>Contributing</b></a>
 </p>
 
 # 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 (Intel Macs from the next release) 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 JDK, for the one-time preparation; and a GPU with Vulkan on Linux and Windows, or a Mac on macOS 11 or later. 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 +45,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, shader packs and data packs:** resource packs work, Java shader packs run their full-screen effects (experimental), and data packs load functions, predicates and item modifiers.
+- **Playing with others:** invite friends from the pause menu 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:
 
@@ -58,8 +56,8 @@ Screenshots, captured in the Rust client itself with vanilla assets and no mods
     <td colspan="2"><img src="docs/media/sunset.webp" alt="Sunset over a savanna river valley and a plains village"></td>
   </tr>
   <tr>
-    <td width="50%"><img src="docs/media/survival.webp" alt="Survival at dusk: a zombie walks up, with the hotbar, health, hunger and experience"></td>
-    <td width="50%"><img src="docs/media/settings.webp" alt="Vanilla's Video Settings screen with Horizon's own buttons at the top: Horizon Graphics and Advanced Graphics"></td>
+    <td width="50%"><img src="docs/media/menu-title.webp" alt="Horizon's title screen over a veiled snowy landscape"></td>
+    <td width="50%"><img src="docs/media/settings.webp" alt="The Video settings in their Simple view: a preset, render distance, field of view, framerate, VSync and GUI scale, each with what it costs"></td>
   </tr>
   <tr>
     <td width="50%"><img src="docs/media/village.webp" alt="A plains village among savanna hills, with farms, villagers and an iron golem"></td>
@@ -94,13 +92,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
@@ -111,10 +109,6 @@ Everything prepared lands in the gitignored `.local/`. It is derived from the ga
 
 The client starts on the title screen. Command-line options (`--world`, `--seed`, `--creative`, `--render-distance`, `--dedicated`), controls, scripting through `horizon-ctl` and the architecture are described in [the native client guide](docs/native-client.md). The rest of the developer documentation is indexed in [docs/README.md](docs/README.md), including [the parity workflow](docs/parity-workflow.md).
 
-## Roadmap
-
-What is being done now, what comes next and where you can help, in plain words and in technical detail: [ROADMAP.md](ROADMAP.md). [playhorizon.dev/hub](https://playhorizon.dev/hub) shows it with the work board, the journal of what shipped and how to help.
-
 ## Contributing
 
 Issues and pull requests are welcome: see [CONTRIBUTING.md](CONTRIBUTING.md) for how we work (vanilla first, small pull requests, labels), or [the contributing guide](https://playhorizon.dev/docs/contributing) on the site. Questions and ideas: [Discord](https://discord.gg/HcTeMZxe5E). Before opening a pull request, run the self-check and paste the block it prints:
@@ -128,8 +122,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 +134,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 +153,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
 

ROADMAP.md

@@ -1,916 +0,0 @@
-# Horizon roadmap
-
-<!-- Generated by tools/roadmap.py from roadmap/roadmap.toml: edit that file, then run `python3 tools/roadmap.py build`. -->
-
-What is being done on Horizon, what comes next and where you can help. There are no dates: things are Now, Next or Later. Each item is said in plain words, with the technical picture folded under it. The same roadmap, with a Simple / Technical switch, the board, the journal and how to help, is on [playhorizon.dev/hub](https://playhorizon.dev/hub). Pull requests carry the `roadmap:<id>` label of their item.
-
-## At a glance
-
-Horizon is Minecraft: Java Edition 26.3 rewritten from scratch in Rust, so it runs faster on the same computer. Single player, LAN, servers, resource packs and Horizon's own mods work today, on your own copy of the game.
-
-**Being done now**
-
-- **Steady frames at long render distances**: Making Horizon faster than vanilla on every computer, with smooth camera movement even at 32 chunks, by spreading the work better over the processor's cores.
-- **Modpacks' world generation, natively**: Making the world-generation mods of popular modpacks (new structures, YUNG's dungeons and mineshafts, packs built on Lithostitched) generate their worlds in Horizon, natively and fast.
-- **Single player as a server: the last differences**: Single player now runs a small server in the background, as vanilla does. We are fixing what still behaves differently there; every fix also works for LAN and server players.
-- **Vanilla parity: the player-visible gaps, closed**: Every method of the Java game is tracked with where Horizon does it, and the differences players can see are being closed, list by list: mobs, blocks, items, screens, rendering, servers.
-- **Mods**: Mods for Horizon, as one line of work led by the modding team: native mods the launcher builds into your game, mods on servers, mod screens and settings, tools for mod makers, the registry and machines.
-
-**Next**: Fresh benchmarks against vanilla; Faster world creation and entry on small CPUs; Low-end computers: Steam Deck, old Macs, 8 GB; Native upscaling; Server console, bans and a full admin API; Hosting polish: Windows service, safe updates; One single-player path: remove the in-frame world; Faster block lookups; Playing on servers: everything shows as it should; Shader packs, written again from scratch; A new launcher design; Splitscreen.
-
-**How to help**: Play it and tell us what differs from vanilla (Discord or GitHub), run the benchmark on your computer, vote for what you want next, or pick one of the Help wanted items.
-
-**Developers**: Read CONTRIBUTING.md, pick a Help wanted item or a To do card, check vanilla's code for the behaviour, and paste the block `python3 tools/pr_ready.py` prints in your pull request.
-
-## Now
-
-### Performance
-
-#### Steady frames at long render distances
-
-Making Horizon faster than vanilla on every computer, with smooth camera movement even at 32 chunks, by spreading the work better over the processor's cores.
-
-Owner: [ludovic111](https://github.com/ludovic111) · Tracking: [#3909](https://github.com/horizon-rust/horizon/issues/3909)
-
-<details><summary>Technical</summary>
-
-Frame pacing at render distance 32 ([#678](https://github.com/horizon-rust/horizon/issues/678)): long frames come from work competing with the render thread. In review: no main-thread tick stutter at high render distances ([#3827](https://github.com/horizon-rust/horizon/issues/3827)), each proto chunk's light view built once ([#3815](https://github.com/horizon-rust/horizon/issues/3815)), video memory handed back by the vertex arena ([#3466](https://github.com/horizon-rust/horizon/issues/3466)), chunk batches assembled on helper threads ([#3036](https://github.com/horizon-rust/horizon/issues/3036)), free structure starts in the generation workers ([#1760](https://github.com/horizon-rust/horizon/issues/1760)). Still open: far terrain at 48 to 64 chunks ([#718](https://github.com/horizon-rust/horizon/issues/718)) and CPU-bound fields of block entities ([#717](https://github.com/horizon-rust/horizon/issues/717)). Every change shows before and after numbers from `tools/perf_bench.py` against vanilla 26.3 ([docs/benchmark.md](docs/benchmark.md)).
-
-</details>
-
-#### Servers that hold 20 TPS with 50 to 100 players
-
-Servers that keep 20 ticks per second with 50 to 100 players. Today Horizon holds it up to 50 bots and drops to about 10 at 100.
-
-Owner: [ludovic111](https://github.com/ludovic111) · Tracking: [#3910](https://github.com/horizon-rust/horizon/issues/3910)
-
-<details><summary>Technical</summary>
-
-Measured against vanilla on equal work ([docs/server.md](docs/server.md), Scale): Horizon is ahead with few players and when exploring, but vanilla's tick is shorter with 25 to 50 players near spawn. Ideas on the list: send entity changes instead of rebuilding every entity each tick (about 15 percent), fewer memory reads in random ticks and collision scans, cheaper item collision checks, mob AI and natural spawning. The bot benchmark (`horizon-bots`) is the proof.
-
-More: [#3847](https://github.com/horizon-rust/horizon/issues/3847) · [#2608](https://github.com/horizon-rust/horizon/issues/2608)
-
-</details>
-
-### Modpacks
-
-#### Modpacks' world generation, natively
-
-Making the world-generation mods of popular modpacks (new structures, YUNG's dungeons and mineshafts, packs built on Lithostitched) generate their worlds in Horizon, natively and fast.
-
-Owner: [ThatCakeIsAPie](https://github.com/ThatCakeIsAPie) · Tracking: [#3913](https://github.com/horizon-rust/horizon/issues/3913)
-
-<details><summary>Technical</summary>
-
-`horizon-port-pack` carries a pack's data-driven content over, and 26.2 data packs are upgraded to 26.3's format ([#3369](https://github.com/horizon-rust/horizon/issues/3369)). In review: worlds taller than 32 sections and each level's shape from its dimension type ([#3480](https://github.com/horizon-rust/horizon/issues/3480), [#3488](https://github.com/horizon-rust/horizon/issues/3488)), data-pack biomes in local and remote worlds ([#3491](https://github.com/horizon-rust/horizon/issues/3491)), block state providers ([#3802](https://github.com/horizon-rust/horizon/issues/3802)), surface rules by biome id ([#3366](https://github.com/horizon-rust/horizon/issues/3366)), Lithostitched's pool and processor modifiers ([#1777](https://github.com/horizon-rust/horizon/issues/1777)). Mods whose Java code does more than world generation don't run ([docs/modpacks.md](docs/modpacks.md)).
-
-</details>
-
-### Mods and API
-
-#### Mods
-
-Mods for Horizon, as one line of work led by the modding team: native mods the launcher builds into your game, mods on servers, mod screens and settings, tools for mod makers, the registry and machines.
-
-Owner: [levzzz5154](https://github.com/levzzz5154) · Tracking: [#3911](https://github.com/horizon-rust/horizon/issues/3911)
-
-<details><summary>Technical</summary>
-
-One item for all modding work ([#3911](https://github.com/horizon-rust/horizon/issues/3911)), led by levzzz5154 with vladislav_hagen; the order between the parts is theirs. Native mods on stable hook points (game/native_hooks.rs, [#3345](https://github.com/horizon-rust/horizon/issues/3345), [#3346](https://github.com/horizon-rust/horizon/issues/3346), [#3434](https://github.com/horizon-rust/horizon/issues/3434), [#3435](https://github.com/horizon-rust/horizon/issues/3435)) built by the launcher ([#3388](https://github.com/horizon-rust/horizon/issues/3388), [#3855](https://github.com/horizon-rust/horizon/issues/3855)); server-side hooks ([#3878](https://github.com/horizon-rust/horizon/issues/3878), [#3706](https://github.com/horizon-rust/horizon/issues/3706)); mod-owned screens, input and drawing; tools for mod makers (templates, `native.py check`); the registry ([#1634](https://github.com/horizon-rust/horizon/issues/1634), [#1642](https://github.com/horizon-rust/horizon/issues/1642), [#1659](https://github.com/horizon-rust/horizon/issues/1659)); machines with inventories and menus ([#1189](https://github.com/horizon-rust/horizon/issues/1189)); mods that read and change the world through the server. [docs/native-mods.md](docs/native-mods.md).
-
-More: [#3351](https://github.com/horizon-rust/horizon/issues/3351) · [#3353](https://github.com/horizon-rust/horizon/issues/3353) · [#3360](https://github.com/horizon-rust/horizon/issues/3360) · [#1596](https://github.com/horizon-rust/horizon/issues/1596) · [#1635](https://github.com/horizon-rust/horizon/issues/1635)
-
-</details>
-
-### Gameplay parity
-
-#### Single player as a server: the last differences
-
-Single player now runs a small server in the background, as vanilla does. We are fixing what still behaves differently there; every fix also works for LAN and server players.
-
-Owner: [ludovic111](https://github.com/ludovic111) · Tracking: [#3914](https://github.com/horizon-rust/horizon/issues/3914)
-
-<details><summary>Technical</summary>
-
-Since [#1514](https://github.com/horizon-rust/horizon/issues/1514) single player runs on the server thread (`game/integrated.rs`) and the window joins it as a client; `--in-frame` keeps the old path. The open `[server-thread]` issues list the gaps. In review: breeding's advancement and statistic ([#3873](https://github.com/horizon-rust/horizon/issues/3873)), the client's menu when the server replaces the player ([#3841](https://github.com/horizon-rust/horizon/issues/3841)), splashes when falling in water ([#3621](https://github.com/horizon-rust/horizon/issues/3621)). [docs/server-levels.md](docs/server-levels.md).
-
-</details>
-
-### Launcher
-
-#### Minecraft Java instances in the launcher
-
-Play the real Java game from the Horizon launcher too: vanilla and modded instances, any version, mods from Modrinth filtered to what fits, and your instances imported from other launchers.
-
-Owner: [ludovic111](https://github.com/ludovic111) · Tracking: [#3915](https://github.com/horizon-rust/horizon/issues/3915)
-
-<details><summary>Technical</summary>
-
-For an account that owns the game: any version downloaded with the Java it needs ([#3406](https://github.com/horizon-rust/horizon/issues/3406)), Java instances, the version list and the CLI ([#3395](https://github.com/horizon-rust/horizon/issues/3395)), the start command read from the version JSON ([#3419](https://github.com/horizon-rust/horizon/issues/3419)). Next: Play for a Java instance, Fabric and Quilt, then NeoForge and Forge; Modrinth with compatibility filtering and dependencies; imports from Prism, MultiMC, the CurseForge app, the Modrinth App, ATLauncher and the official launcher, each from its documented on-disk format.
-
-More: [#3506](https://github.com/horizon-rust/horizon/issues/3506)
-
-</details>
-
-### Code and tools
-
-#### A leaner codebase that builds faster
-
-Cleaning up Horizon's code: removing what nothing uses and making it quicker to build, so fixes and new features land faster.
-
-Owner: [ludovic111](https://github.com/ludovic111) · Tracking: [#3916](https://github.com/horizon-rust/horizon/issues/3916)
-
-<details><summary>Technical</summary>
-
-A review of the whole tree: dead code and stubs removed ([#1432](https://github.com/horizon-rust/horizon/issues/1432), [#1658](https://github.com/horizon-rust/horizon/issues/1658)), one probe binary per crate ([#1453](https://github.com/horizon-rust/horizon/issues/1453), [#1454](https://github.com/horizon-rust/horizon/issues/1454)), shared harness helpers ([#1448](https://github.com/horizon-rust/horizon/issues/1448)), clippy clean on the whole tree ([#1707](https://github.com/horizon-rust/horizon/issues/1707)). [docs/architecture.md](docs/architecture.md) maps each feature to its files and harnesses.
-
-</details>
-
-#### Vanilla parity: the player-visible gaps, closed
-
-Every method of the Java game is tracked with where Horizon does it, and the differences players can see are being closed, list by list: mobs, blocks, items, screens, rendering, servers.
-
-Owner: [kacpherek](https://github.com/kacpherek) · Tracking: [#3912](https://github.com/horizon-rust/horizon/issues/3912)
-
-<details><summary>Technical</summary>
-
-The port ledger ([tools/port_ledger.py](tools/port_ledger.py), tools/port_map/, [#3139](https://github.com/horizon-rust/horizon/issues/3139)) gives every 26.3 method a verdict and links the harnesses that cover it ([#3526](https://github.com/horizon-rust/horizon/issues/3526)). The player-visible gaps are ten lists, one per area ([#3512](https://github.com/horizon-rust/horizon/issues/3512) to [#3521](https://github.com/horizon-rust/horizon/issues/3521)); a fix translates the vanilla method, ticks its row and carries the `parity` label. Start from .claude/skills/vanilla-parity.
-
-More: [#3513](https://github.com/horizon-rust/horizon/issues/3513) · [#3514](https://github.com/horizon-rust/horizon/issues/3514) · [#3515](https://github.com/horizon-rust/horizon/issues/3515) · [#3516](https://github.com/horizon-rust/horizon/issues/3516) · [#3517](https://github.com/horizon-rust/horizon/issues/3517) · [#3518](https://github.com/horizon-rust/horizon/issues/3518) · [#3519](https://github.com/horizon-rust/horizon/issues/3519) · [#3520](https://github.com/horizon-rust/horizon/issues/3520)
-
-</details>
-
-## Next
-
-### Performance
-
-#### Fresh benchmarks against vanilla
-
-New public numbers comparing Horizon with vanilla on many kinds of computers, measured the same way every time, with a history that shows what each release changed.
-
-<details><summary>Technical</summary>
-
-Redo the comparison after the current performance work ([#1073](https://github.com/horizon-rust/horizon/issues/1073)); reliability, coverage and presentation ([#1346](https://github.com/horizon-rust/horizon/issues/1346)); a scene must count as loaded only once its first chunk arrives ([#1749](https://github.com/horizon-rust/horizon/issues/1749)). Next: a performance history across releases (an automatic comparison of each release with the last, on a timeline), more report fields (server TPS and MSPT, power, battery drain, temperature, throttling) and more hardware (a MacBook on battery, low-end laptops, community reports). Players' reports come in through `--benchmark` and `horizon-launcher data benchmark` ([docs/benchmark.md](docs/benchmark.md)).
-
-</details>
-
-#### Faster world creation and entry on small CPUs
-
-Creating a world and joining it should be quick even on a four-thread laptop, where a fresh world at 32 chunks can make you wait minutes for the first terrain.
-
-<details><summary>Technical</summary>
-
-Cut the per-column generation cost (noise sampling, surface rules, aquifers) and the lock convoy on structure starts, and leave one core free for the rest of the game as vanilla does ([#1760](https://github.com/horizon-rust/horizon/issues/1760) and [#1778](https://github.com/horizon-rust/horizon/issues/1778), in review, are listed under 'Steady frames at long render distances'). Still to profile on small CPUs: the first seconds of a fresh world deliver no chunk, and fluids remesh for about a minute after loading. Measured with `tools/perf_bench.py` ([docs/benchmark.md](docs/benchmark.md), [docs/profiling.md](docs/profiling.md)).
-
-</details>
-
-#### Low-end computers: Steam Deck, old Macs, 8 GB
-
-Horizon should run well on small machines: integrated graphics, the Steam Deck, older Macs and 8 GB of memory, with a battery mode that saves power on laptops.
-
-<details><summary>Technical</summary>
-
-Partly done: an opt-in 60 FPS cap with fewer workers on battery, Far Detail Reduced for integrated GPUs and animated textures on the GPU (both shipped). Left: measured targets and fixes per class of machine (memory use, worker counts, startup) on a Steam Deck, old Intel and Apple Silicon Macs and 8 GB computers, reported on the Benchmarks page.
-
-More: [docs/benchmark.md](docs/benchmark.md) · [https://playhorizon.dev/docs/performance](https://playhorizon.dev/docs/performance)
-
-</details>
-
-#### Native upscaling
-
-Draw the game at a lower resolution and sharpen it to your screen's size, in the way of FSR or DLSS, to gain frames on weaker graphics cards. An optional graphics setting.
-
-<details><summary>Technical</summary>
-
-A render-scale setting below the window size with an upscaler of our own that runs on every wgpu backend. Proof: frame time against native resolution on integrated GPUs, and screenshots for image quality. Issue [#1403](https://github.com/horizon-rust/horizon/issues/1403).
-
-More: [#3762](https://github.com/horizon-rust/horizon/issues/3762) · [#3763](https://github.com/horizon-rust/horizon/issues/3763) · [#3764](https://github.com/horizon-rust/horizon/issues/3764)
-
-</details>
-
-#### Faster block lookups
-
-Speeding up the code that reads and writes the blocks of the world, which almost everything in the game goes through: generation, lighting, meshing and ticking.
-
-<details><summary>Technical</summary>
-
-`PalettedContainer` and `PackedStorage` find an entry's word by multiply and shift instead of an integer division ([#1790](https://github.com/horizon-rust/horizon/issues/1790), [#1794](https://github.com/horizon-rust/horizon/issues/1794)); meshing looks up baked models by index, not by name ([#1747](https://github.com/horizon-rust/horizon/issues/1747)). Each change keeps the paletted storage harnesses identical and shows its microbenchmark ([docs/performance/paletted-container-access-results.md](docs/performance/paletted-container-access-results.md)).
-
-</details>
-
-### Servers and multiplayer
-
-#### Server console, bans and a full admin API
-
-Manage a server from a console, ban and pardon players, and drive it from other tools through a full admin API and an MCP server for AI agents.
-
-<details><summary>Technical</summary>
-
-`horizon-server console` (a text interface), `ban`, `pardon`, `ban-ip` and `mcp` over stdio. Admin API additions: the player list, kick, ban, op and whitelist, an SSE stream of logs and events, a text metrics endpoint, config GET and PATCH, backup delete and download. The panel's later features (bans, worlds, server.properties import, logs and crash reports, modpacks) and vanilla's management protocol (the JSON-RPC over WebSocket that the `management-server-*` keys configure), so vanilla's tools can manage a Horizon server. [docs/server.md](docs/server.md), [docs/api/server.md](docs/api/server.md).
-
-</details>
-
-#### Hosting polish: Windows service, safe updates
-
-Smoother hosting: a real Windows service, a backup before every update, backups that keep the world and each player's state, and a changed view distance or message without a restart.
-
-<details><summary>Technical</summary>
-
-A Windows service wrapper instead of the logon scheduled task; `backups.before_update`; hot reload of config for view distance and the message of the day (needs engine support); backups that keep world and player state ([#1808](https://github.com/horizon-rust/horizon/issues/1808), a contributor's draft, in review). [docs/hosting.md](docs/hosting.md), docs/server.md.
-
-</details>
-
-#### Playing on servers: everything shows as it should
-
-When you play on a server, other players, mobs, items and menus look and behave as in vanilla: skins, poses, item names, inventories and server networks.
-
-<details><summary>Technical</summary>
-
-Client-of-a-server fixes in `game/remote*.rs` and `horizon-protocol`: mobs' aggressive and item-use flags ([#1802](https://github.com/horizon-rust/horizon/issues/1802), [#1798](https://github.com/horizon-rust/horizon/issues/1798)), ghost items after a remote menu ([#1795](https://github.com/horizon-rust/horizon/issues/1795)), skins ([#1652](https://github.com/horizon-rust/horizon/issues/1652)), cookies and transfer packets for proxy networks ([#1650](https://github.com/horizon-rust/horizon/issues/1650)), firework boosts ([#1671](https://github.com/horizon-rust/horizon/issues/1671)), living-entity attributes and simulation distance ([#1731](https://github.com/horizon-rust/horizon/issues/1731)), styled item names ([#1702](https://github.com/horizon-rust/horizon/issues/1702)), primed TNT between updates ([#1710](https://github.com/horizon-rust/horizon/issues/1710)).
-
-</details>
-
-### Gameplay parity
-
-#### One single-player path: remove the in-frame world
-
-Single player will have one way to run, the server thread, so every fix works everywhere and there are fewer bugs. The older in-frame mode goes once everything passes without it.
-
-<details><summary>Technical</summary>
-
-`--in-frame` (also `--no-server-thread` and `HORIZON_SERVER_THREAD=0`) still ticks the world inside the window's `Game`, and most harnesses test that path. Delete it once `lan_e2e --server-thread` and the parity harnesses pass on the server thread, which also halves the bug surface. See also 'Single player as a server' and [docs/server-levels.md](docs/server-levels.md).
-
-</details>
-
-#### Splitscreen
-
-Play with a friend on the same screen, each with a controller.
-
-Owner: [martipops](https://github.com/martipops)
-
-<details><summary>Technical</summary>
-
-Issue [#2054](https://github.com/horizon-rust/horizon/issues/2054), built by martipops as a series: up to 16 local players on the server thread's multiplayer ([#3541](https://github.com/horizon-rust/horizon/issues/3541)), each controller driving its own player ([#3794](https://github.com/horizon-rust/horizon/issues/3794)), joining with a controller ([#3801](https://github.com/horizon-rust/horizon/issues/3801)), players in windows of their own ([#3825](https://github.com/horizon-rust/horizon/issues/3825)) and the profile page ([#3826](https://github.com/horizon-rust/horizon/issues/3826)).
-
-More: [#3777](https://github.com/horizon-rust/horizon/issues/3777)
-
-</details>
-
-### Rendering
-
-#### Shader packs, written again from scratch
-
-Shader packs were removed and are being rebuilt from scratch. They come back, off by default, once the best-known packs draw properly.
-
-<details><summary>Technical</summary>
-
-A clean-room rewrite in `horizon-shaderpack`, from the packs' public format documentation only: reading packs, the preprocessor and `.properties` files are merged ([#1584](https://github.com/horizon-rust/horizon/issues/1584), [#1585](https://github.com/horizon-rust/horizon/issues/1585), [#1586](https://github.com/horizon-rust/horizon/issues/1586)); translating programs to WGSL through naga, buffers, uniforms and the terrain, entity, sky, weather and hand stages are in review ([#1698](https://github.com/horizon-rust/horizon/issues/1698) to [#1801](https://github.com/horizon-rust/horizon/issues/1801)).
-
-More: [#1561](https://github.com/horizon-rust/horizon/issues/1561) · [#1771](https://github.com/horizon-rust/horizon/issues/1771) · [#1786](https://github.com/horizon-rust/horizon/issues/1786)
-
-</details>
-
-### Launcher
-
-#### A new launcher design
-
-A redesigned launcher: every button where you expect it, the fewest clicks to play, add an instance or add mods, smooth animations, and instant startup.
-
-Owner: [ludovic111](https://github.com/ludovic111)
-
-<details><summary>Technical</summary>
-
-Based on the site concept by the Team (Bricolage Grotesque, a night sky and an animated pixel sunset). Screens and flows are designed first, then small PRs; tokens in [crates/horizon-theme](crates/horizon-theme) and rules in [docs/design-system.md](docs/design-system.md), the game's vanilla look unchanged. Measured before and after: startup, frame time and idle CPU/GPU, reduced motion honoured. Mods screens separate Horizon native mods from Java mods; a running instance can be stopped from the launcher.
-
-More: [#3635](https://github.com/horizon-rust/horizon/issues/3635) · [#3636](https://github.com/horizon-rust/horizon/issues/3636) · [#3637](https://github.com/horizon-rust/horizon/issues/3637)
-
-</details>
-
-## Later
-
-### Performance
-
-#### Exact far terrain from real chunks
-
-Far terrain drawn from the world you really built and explored, caves and builds included, not only a preview from the seed.
-
-<details><summary>Technical</summary>
-
-Keep a 3D mip store on disk built from real chunks, drawn by the GPU beside the seed preview for areas nobody has visited. Written from scratch and measured before it is kept. Builds on Far Detail and the far-terrain levels of detail already shipped; the open work on them is [#718](https://github.com/horizon-rust/horizon/issues/718).
-
-</details>
-
-#### A batch of targeted optimisations
-
-Several smaller speed-ups, each measured: idle block entities that sleep, cheaper particles, faster structure placement, high-rate mice and very large texture packs.
-
-<details><summary>Technical</summary>
-
-Block entities and hoppers that skip work when idle (the hopper item scan is already skipped when no item is near); a particle frustum test first (also a parity gap), then particle quads built on the GPU; jigsaw shortcuts that skip blocked connectors and pool elements known not to fit, with layouts unchanged (trial chambers and ancient cities first); batched raw mouse input on Windows for 8000 Hz mice; a better atlas packer for huge resource packs (a 64x pack builds a 704 MiB atlas for 452 MiB of textures); sign-heavy scenes ([#1461](https://github.com/horizon-rust/horizon/issues/1461)). Profile first, keep what pays, show before and after numbers.
-
-More: [docs/profiling.md](docs/profiling.md)
-
-</details>
-
-### Modpacks
-
-#### Older Fabric and Forge mods
-
-Recognise mods built for versions before 26.1 in the mod browser, so they can be checked and carried over like newer ones.
-
-<details><summary>Technical</summary>
-
-A mapping table from intermediary and SRG names so pre-26.1 jars can be classified, and a rename for mod ids with dashes (`fabric-api`); the port step then treats them like newer jars ([docs/mod-browser.md](docs/mod-browser.md)).
-
-</details>
-
-#### A modpack's own resource and shader packs
-
-Importing a modpack also brings the resource packs and shader packs it ships with, where Horizon can use them.
-
-<details><summary>Technical</summary>
-
-Porting a pack carries data, assets and worldgen today; the resource packs and shader packs bundled with it are left out. Resource packs can be carried as they are; shader packs go through the converter ([docs/modpacks.md](docs/modpacks.md)).
-
-</details>
-
-#### Whole modpacks, such as ATM10, rewritten
-
-Rewriting a complete big modpack for Horizon so it runs far better than the original. Not a priority now: the work above comes first.
-
-<details><summary>Technical</summary>
-
-The project's first goal for modpacks: support them ten times better than vanilla and port any of them. It was set aside in favour of compatibility through the browser. What exists: ATM10's world generates and 42 of its 496 mods are carried at least in part ([docs/modpacks.md](docs/modpacks.md)). It depends on 'Mods with code' and the native mod API.
-
-</details>
-
-#### Running Java mods that aren't rewritten
-
-Run Java mods that nobody has rewritten for Horizon yet, through a bridge or a converter. Hard and not started: the Convert button and native rewrites come first.
-
-<details><summary>Technical</summary>
-
-Earlier research ([#527](https://github.com/horizon-rust/horizon/issues/527), closed) found that Java mods can't simply run, because they call Minecraft's own classes. Option to look at again: a bridge for simple Fabric mods.
-
-</details>
-
-#### CurseForge in the mod browser (coming soon)
-
-Coming soon: search and download CurseForge mods and modpacks from the launcher, as you can with Modrinth today.
-
-<details><summary>Technical</summary>
-
-The mod browser lists CurseForge as coming soon ([docs/mod-browser.md](docs/mod-browser.md)): it needs CurseForge API access. Meanwhile packs import from a CurseForge zip or instance folder, and jars only CurseForge hosts come from the player's own instance ([docs/modpacks.md](docs/modpacks.md)).
-
-</details>
-
-#### A Convert to Rust button for what isn't rewritten yet
-
-When a mod, shader pack or modpack hasn't been rewritten for Horizon, one button converts what can be converted, so you don't have to wait for the rewrite.
-
-<details><summary>Technical</summary>
-
-Generalise the mod browser's Port step (`horizon-port-pack`: the data, assets, worldgen and block and item definitions of Java mods, .mrpack and CurseForge zips) to every kind of content: code mods as native mods (see 'Mods with code') and shader packs, converting an Iris/OptiFine pack into Horizon's format. The browser says what works before the install. Java code itself does not run ([docs/modpacks.md](docs/modpacks.md), [docs/mod-browser.md](docs/mod-browser.md)).
-
-</details>
-
-#### Mods with code: machines, magic, mobs
-
-Making mods that add machines, magic and mobs work in Horizon, in steps, starting with machines. They are most of what a big modpack is made of.
-
-<details><summary>Technical</summary>
-
-333 of the 496 mods in a big pack (ATM10) contain code. Issue [#1854](https://github.com/horizon-rust/horizon/issues/1854) ranks the gaps (ticking block entities, networking, rendering, menus, inventories) that unlock them in tiers, with machines first as the recommended path. Code mods are native mods now ([docs/native-mods.md](docs/native-mods.md)): each port is a horizon-mixins bundle. The path isn't started yet ([docs/modpacks.md](docs/modpacks.md)).
-
-</details>
-
-#### Data packs in the mod browser
-
-Search and install data packs from the launcher's mod browser, for the world you choose, as you do mods and resource packs.
-
-<details><summary>Technical</summary>
-
-A Datapacks tab beside Mods and Resource packs: install into a chosen world's datapacks folder, with the same checks and 'works in Horizon' notes as the other kinds ([docs/mod-browser.md](docs/mod-browser.md)).
-
-</details>
-
-### Servers and multiplayer
-
-#### Ely.by and other sign-in providers
-
-Sign in with other account providers, such as Ely.by or any Yggdrasil-compatible one, beside Microsoft.
-
-<details><summary>Technical</summary>
-
-Issue [#1270](https://github.com/horizon-rust/horizon/issues/1270) asks for Ely.by and Yggdrasil-compatible servers with an account selector in the launcher. It builds on the Microsoft sign-in ([docs/microsoft-account.md](docs/microsoft-account.md)).
-
-</details>
-
-#### Join servers on older versions
-
-Join servers that run older Minecraft versions, such as 1.21 or 1.8 PvP servers, from Horizon.
-
-<details><summary>Technical</summary>
-
-Asked often in the suggestion queue. Horizon speaks 26.3's protocol; the path is a native protocol adapter in Rust that translates older versions' packets, not a downloaded Java proxy. Java instances in the launcher already play any version with the real game.
-
-More: [#3023](https://github.com/horizon-rust/horizon/issues/3023)
-
-</details>
-
-#### Online-mode checks for Play with Friends
-
-Friends who join through an invite code could prove who they are with their Microsoft account, as on online-mode servers.
-
-<details><summary>Technical</summary>
-
-Play with Friends joins over an encrypted tunnel with an invite code ([docs/play-with-friends.md](docs/play-with-friends.md), 'Identity'). Online-mode checks against Mojang's session servers can be added on top of the same tunnel; they need Microsoft sign-in first, which is coming soon. Play with Friends stays self-hosted between players, with no relay run by the project.
-
-</details>
-
-#### Prepare a version without Java
-
-Set up Horizon, a server first, without Java on your computer: published tables are combined with your own copy of the game.
-
-<details><summary>Technical</summary>
-
-Today `horizon-prepare` runs Mojang's exporters with Java. Issue [#1750](https://github.com/horizon-rust/horizon/issues/1750) proposes publishing the computed version tables once from CI and assembling the rest locally from the player's own jar and assets, provided the tables hold no Mojang content; a contributor offered a pull request, and it would help phones too. A server-only prepare from `server.jar` alone is the first step ([docs/server.md](docs/server.md)).
-
-</details>
-
-#### Guided hosting with Tailscale and an invite button
-
-In the launcher, a guide and a button to host a server and invite friends over Tailscale, so nobody has to open ports on a router.
-
-<details><summary>Technical</summary>
-
-On the Servers page (create, start, back up, update and invite are shipped) add a Tailscale setup that explains and checks each step, and an invite button that hands friends what they need to join over the tailnet. Buttons first, no docs needed, with the details in an Advanced section. Remote access over Tailscale is already described in [docs/server.md](docs/server.md).
-
-More: [docs/hosting.md](docs/hosting.md)
-
-</details>
-
-#### An official Docker image for servers
-
-An official image to run a Horizon dedicated server in Docker with one command, your own copy of the game files mounted in.
-
-<details><summary>Technical</summary>
-
-The repository has the Dockerfile (`packaging/server/Dockerfile`: a multi-stage build on Debian bookworm-slim, user `horizon`, volume `/data`, port 25565, game files mounted read-only, `HORIZON_EULA` and friends answering the first-start questions), and anyone can build it ([docs/hosting.md](docs/hosting.md), section 9). Left: publish the image to a public registry from the release workflow, tagged per release, so it follows the same checks, and update the docs and the launcher. The image never holds Mojang's files.
-
-More: [docs/server.md](docs/server.md)
-
-</details>
-
-#### A server you install with one command
-
-Install and run a Horizon dedicated server from a terminal with a single command, no launcher needed, for VPSes and headless machines.
-
-<details><summary>Technical</summary>
-
-A player's idea (#horizon-ideas). `horizon-server` already runs headless; left: an install script (Linux/macOS shell, Windows PowerShell) that fetches the signed release, checks it, asks for or points at the player's own game files and starts the server, documented in [docs/hosting.md](docs/hosting.md).
-
-</details>
-
-#### Ready-made setups for hosting panels
-
-Install a Horizon server from the panels hosts use, such as Pterodactyl and AMP, the usual way for each panel.
-
-<details><summary>Technical</summary>
-
-Asked in the suggestion queue for Pterodactyl eggs and AMP templates. Builds on the one-command install ('A server you install with one command') and horizon-server's server.toml ([docs/hosting.md](docs/hosting.md)).
-
-</details>
-
-### Mods and API
-
-#### Scripts for mods
-
-Small mods written as scripts, in the style of KubeJS, with no compiler.
-
-<details><summary>Technical</summary>
-
-Waits for native mods to settle: a script layer over the native hook points is to be designed.
-
-More: [docs/native-mods.md](docs/native-mods.md)
-
-</details>
-
-#### Orbital Laser on the normal game
-
-The community mod Orbital Laser, made for a fork of Horizon, running on the normal game as a native mod and listed in the registry.
-
-<details><summary>Technical</summary>
-
-A native port (a horizon-mixins bundle, docs/native-mods.md) of [https://github.com/Stink-O/orbital-laser](https://github.com/Stink-O/orbital-laser) (MIT), which today runs through its author's fork. Tested in the game, and listed in the registry.
-
-</details>
-
-#### Native versions of popular client mods
-
-Built-in versions of the client mods players ask for: block info on hover, a world map, inventory tweaks and schematic overlays.
-
-<details><summary>Technical</summary>
-
-Done: a mod list and menu, minimap, zoom, keystrokes, an FPS counter and a recipe viewer, as native mods (horizon-mods/native/). Asked for: an angled world map that shows hills, overhangs and caves, inventory tweaks (drag and scroll to move items), block info tooltips and schematic overlays.
-
-More: [docs/extras.md](docs/extras.md) · [docs/native-mods.md](docs/native-mods.md)
-
-</details>
-
-#### Create-style physics as a native mod
-
-Contraptions and physics like the Create and Aeronautics mods, as a mod for Horizon rather than part of the base game.
-
-<details><summary>Technical</summary>
-
-Issue [#805](https://github.com/horizon-rust/horizon/issues/805) (porting QOL mods) closed with this answer: it would come as a native Horizon mod.
-
-</details>
-
-#### Proximity voice chat as a native mod
-
-Hear nearby players talk, as with the voice chat mods of other Minecraft versions, as a Horizon mod.
-
-<details><summary>Technical</summary>
-
-A native mod ([docs/native-mods.md](docs/native-mods.md)). It needs a way to carry voice between players and an audio path in the game before anything can be built.
-
-</details>
-
-### Gameplay parity
-
-#### Every Minecraft version, prepared automatically
-
-Every past and future Minecraft version prepared for Horizon automatically. When Mojang releases one, Horizon follows it, and every system is checked against it again.
-
-<details><summary>Technical</summary>
-
-The port pipeline ([docs/version-ports.md](docs/version-ports.md), `tools/version_port.py`) detects a release, prepares it, diffs its classes against the pinned 26.3, regenerates the data-driven tables, runs every parity harness on it and writes a port report that becomes issues. The goal is as little human work as possible for any version, past or future. Detection and the first slices are merged; the scheduled agent that runs it every day isn't installed yet. Two versions in one build are out of scope.
-
-</details>
-
-#### Controllers: tested on real pads, and in the launcher
-
-Make controller support solid: tested with real PlayStation and Xbox pads and a Steam Deck, and usable in the launcher too.
-
-<details><summary>Technical</summary>
-
-The game side is merged ([docs/controllers.md](docs/controllers.md)): pads read with gilrs, menus, rumble, glyphs, remapping and DualSense adaptive triggers, lightbar and haptics, but not yet confirmed on real pads or a Steam Deck (DualSense haptics stay behind a switch until then). Left: a test pass on real hardware, and the same focus navigation in the GPUI launcher.
-
-</details>
-
-#### The full debug screen
-
-Vanilla's complete F3 screen: debug options, a profiler chart, ten-second captures and an atlas dump.
-
-<details><summary>Technical</summary>
-
-Today F3 shows position, chunk, light, biome and FPS ([docs/native-client.md](docs/native-client.md)). Vanilla also has F3+F6 debug options with profiles, F3+1 the profiler pie, F3+L a ten-second capture and F3+S the atlas dump ([#562](https://github.com/horizon-rust/horizon/issues/562) asked for the F3 editor).
-
-</details>
-
-#### Pistons push players and mobs
-
-Pistons and slime blocks will push players, mobs and items as in vanilla. Today moving blocks pass through them.
-
-<details><summary>Technical</summary>
-
-Port `PistonMovingBlockEntity.moveCollidedEntities` and `moveStuckEntities` (honey), the slime bounce and `Entity.limitPistonMovement` for `MoverType.PISTON`, in single player and for a server's players. Issues [#1496](https://github.com/horizon-rust/horizon/issues/1496), [#1609](https://github.com/horizon-rust/horizon/issues/1609), [#1608](https://github.com/horizon-rust/horizon/issues/1608), [#1704](https://github.com/horizon-rust/horizon/issues/1704), [#1758](https://github.com/horizon-rust/horizon/issues/1758).
-
-</details>
-
-#### Villages and combat, exactly as in vanilla
-
-Villages and fights behaving as in vanilla: iron golems defending villages, villagers remembering their homes, mace smashes and knockback.
-
-<details><summary>Technical</summary>
-
-Villages: iron golem village goals, villager memories across saves, villager age, job-site claiming on dedicated servers, flower offers ([#1639](https://github.com/horizon-rust/horizon/issues/1639) is one report). Combat: the mobs' `attack_knockback` attribute, mace smash logic, the hit knockback source on the host, the fire burnout biome tag. Each is checked against vanilla by a harness ([docs/rust-parity.md](docs/rust-parity.md)).
-
-</details>
-
-#### Choose the audio output device
-
-Pick the speakers or headphones Horizon plays through, in Music & Sounds.
-
-<details><summary>Technical</summary>
-
-An output device list in Music & Sounds, falling back to the system default. [#1035](https://github.com/horizon-rust/horizon/issues/1035) started it: a player on an older Windows computer had no sound at all, and a device choice is how such cases are found and fixed.
-
-</details>
-
-#### Play in your language
-
-Item names, container titles and server messages follow the language you pick, as in vanilla. Today parts of the game stay in English.
-
-<details><summary>Technical</summary>
-
-Translatable components resolved through the selected language for items, containers and server text ([#1806](https://github.com/horizon-rust/horizon/issues/1806)), on top of the bundled languages the prepared resources carry ([#1594](https://github.com/horizon-rust/horizon/issues/1594)). Left: the client's own screens ([#1672](https://github.com/horizon-rust/horizon/issues/1672)) and the main menu with zh_cn.
-
-</details>
-
-### Rendering
-
-#### A light default shader pack
-
-A small built-in look (tone mapping, colour grade, a cheap vignette) that costs almost nothing, for players who want a nicer picture without a heavy pack.
-
-<details><summary>Technical</summary>
-
-An opt-in, composite-only pack on the native shader API, under about 0.3 ms at 1080p, shown on the Shader Packs page. Pack option sliders and profiles, and a Failed row with the full error, belong with it.
-
-More: [docs/shaders.md](docs/shaders.md)
-
-</details>
-
-#### Optional ray tracing
-
-An optional ray-tracing mode for graphics cards that support it (RTX and recent AMD): shadows, water reflections and global lighting on top of the vanilla look.
-
-<details><summary>Technical</summary>
-
-A spike with ray-traced sun shadows, off by default, is a draft ([#1180](https://github.com/horizon-rust/horizon/issues/1180)). Reflections, global illumination, Apple M3 and newer if it is cheap, and a performance report per card come after.
-
-</details>
-
-#### HDR monitors
-
-Output for HDR monitors: brighter highlights and richer colour where your screen supports it.
-
-<details><summary>Technical</summary>
-
-Issue [#1441](https://github.com/horizon-rust/horizon/issues/1441). Needs a surface format and a tone-mapping path per backend, and tests on real HDR screens on Windows, macOS and Linux.
-
-</details>
-
-#### MSAA, anisotropic filtering, exclusive fullscreen
-
-More graphics options: multisample anti-aliasing, anisotropic filtering and an exclusive fullscreen mode. Today Horizon has FXAA and borderless fullscreen.
-
-<details><summary>Technical</summary>
-
-Not implemented ([docs/graphics.md](docs/graphics.md)). Anisotropic filtering needs linear magnification in wgpu, which blurs close blocks, so close-up sharpness has to be kept first; MSAA would sit beside FXAA, and SMAA or TAA are asked for too; exclusive fullscreen where the backend supports it.
-
-</details>
-
-#### Well-known shader looks, rewritten for Horizon
-
-Popular shader packs rewritten in Horizon's format, so good packs exist from the start. Only packs whose licence is open source and compatible with ours are rewritten, never anything else.
-
-<details><summary>Technical</summary>
-
-The first candidates are Photon, Chocapic13 and MakeUp Ultra Fast, each only after its licence is read and recorded: a pack is rewritten only if it is open source and compatible with Horizon's licence, and the rewrite is written from the shader format's documentation and the look on screen, not from anyone's code. Today only the Golden Hour example exists (`[crates/horizon-shader-api/packs/golden_hour](crates/horizon-shader-api/packs/golden_hour)`).
-
-More: [docs/shaders.md](docs/shaders.md)
-
-</details>
-
-### Launcher
-
-#### Lean installs that use less disk
-
-Smaller installs: Horizon keeps one shared copy of the prepared game files and removes what only the preparation needed.
-
-<details><summary>Technical</summary>
-
-A shared resource store keyed by the preparer's digest, no prepare intermediates left behind, the current and the previous version kept, and an automatic clean-up. Not started.
-
-</details>
-
-#### A visible beta label
-
-A clear 'beta' label in the launcher and the game, so nobody is surprised that Horizon is still being built.
-
-<details><summary>Technical</summary>
-
-Show Beta in the launcher's header and about page, on the game's title screen and on the website, beside the version number ([docs/versioning.md](docs/versioning.md)).
-
-</details>
-
-### Platforms
-
-#### Horizon on Linux ARM64
-
-Game and launcher builds for 64-bit ARM Linux computers.
-
-<details><summary>Technical</summary>
-
-Issue [#1709](https://github.com/horizon-rust/horizon/issues/1709): aarch64 builds of the game and the launcher in the release workflow, tested on a real ARM machine with its Vulkan driver. The server build already drops audio and controllers (`--no-default-features`).
-
-</details>
-
-#### Horizon on Windows ARM64
-
-A native Horizon for Windows on ARM computers, such as Snapdragon laptops.
-
-<details><summary>Technical</summary>
-
-Releases are x64 for Windows and Linux and arm64 for macOS. Needs an aarch64-pc-windows-msvc build in the release workflow and a machine to test on.
-
-More: [docs/release-flow.md](docs/release-flow.md)
-
-</details>
-
-#### Android, iOS and the browser
-
-Versions of Horizon for Android, iOS and web browsers. Nothing official yet; contributors have started the first pieces.
-
-<details><summary>Technical</summary>
-
-No official build. Android was first closed as not planned, with touch controls, a mobile interface, packaging and loading the player's own assets all missing; the roadmap now includes it, iOS and a build for the browser as long-term goals. First pieces from contributors: `horizon-dualsense` compiling on iOS ([#1813](https://github.com/horizon-rust/horizon/issues/1813)) and helper-thread limits on Android ([#1751](https://github.com/horizon-rust/horizon/issues/1751)). Preparing without Java ([#1750](https://github.com/horizon-rust/horizon/issues/1750)) matters here too. Horizon ships none of Mojang's files on any platform.
-
-</details>
-
-#### Horizon on Intel Macs
-
-Builds of the game and the launcher for Macs with an Intel processor.
-
-<details><summary>Technical</summary>
-
-x86_64 game and launcher builds, picked per processor ([#1171](https://github.com/horizon-rust/horizon/issues/1171)). Before it ships it needs a run on a real Intel Mac: Rosetta on Apple Silicon only proves the CPU code. Requests: [#1161](https://github.com/horizon-rust/horizon/issues/1161), [#1792](https://github.com/horizon-rust/horizon/issues/1792).
-
-</details>
-
-#### Wayland and Hyprland polish
-
-Fixes for Linux desktops that use Wayland and Hyprland: fullscreen, the clipboard, the GUI scale after a restart and the like.
-
-<details><summary>Technical</summary>
-
-Open: the GUI Scale is clamped to 2 after a restart under Hyprland, while XWayland keeps it ([#1866](https://github.com/horizon-rust/horizon/issues/1866)). Earlier reports covered fullscreen dropping on menu clicks, the clipboard and a white overlay ([#1007](https://github.com/horizon-rust/horizon/issues/1007), closed). Checked on a real Wayland session.
-
-</details>
-
-#### AppImage and a Nix flake
-
-Install Horizon on any Linux distribution as an AppImage, and on NixOS through a Nix flake.
-
-<details><summary>Technical</summary>
-
-A player's idea (#horizon-ideas). An AppImage of the launcher and game from the release workflow, and a flake.nix packaging the release binaries with their runtime libraries (Vulkan loader, X11/Wayland, ALSA), the way horizon-parity's NixOS setup runs them today.
-
-</details>
-
-### Horizon extras
-
-#### A complete video studio inside the game
-
-Record, replay and edit videos without leaving the game: record in a keypress, replay a session, cut and finish the video. One of Horizon's original goals.
-
-<details><summary>Technical</summary>
-
-Three stages. Recording: capture gameplay in a keypress with an encoder thread and little frame-time cost. Replay: a replay mode for recorded sessions. Editing: cuts, camera paths, titles and export. None of it exists yet; the agent-control socket ([docs/agent-control.md](docs/agent-control.md)) already lets tools drive the game for scripted shots.
-
-</details>
-
-#### Game menus in the launcher's style
-
-An optional look for the game's own menus and options that matches the Horizon launcher. Off by default: the vanilla menus stay as they are.
-
-<details><summary>Technical</summary>
-
-A player's idea (#horizon-ideas). A built-in resource pack or a Horizon setting that restyles the title, pause and options screens with the launcher's design tokens (crates/horizon-theme), following [docs/design-system.md](docs/design-system.md); off by default because it changes the vanilla look.
-
-</details>
-
-### AI and agents
-
-#### An optional AI teammate
-
-An optional AI teammate you can talk to by voice. It plays beside you, helps or finishes the game with you, runs on your computer first, and exists only if you turn it on. The No AI switch hides it.
-
-<details><summary>Technical</summary>
-
-Draft pull requests: the companion ([#1068](https://github.com/horizon-rust/horizon/issues/1068)), its safety modes and their evaluation ([#1069](https://github.com/horizon-rust/horizon/issues/1069)) and a route that finishes the game ([#1070](https://github.com/horizon-rust/horizon/issues/1070)). In the drafts: a companion that follows, fights, mines, crafts, sleeps and respawns; chat and push-to-talk voice, with speech recognition and a choice of voices; presets (very strong, helper, beat the game); a guard model with Clean, Kid and Salty modes; perception levels from Fair to All-knowing; hardware detection with a simple mode and an Advanced tab; local models first, cloud keys optional. The No AI switch is already in the game. Left: the speedrun route doesn't finish the game reliably yet, voices for more languages, and the safety evaluation, which must pass before it ships.
-
-</details>
-
-#### A versioned agent-control protocol
-
-A stable, documented way for AI agents and scripts to drive the game and the launcher, with versions and an event stream so tools keep working as Horizon changes.
-
-<details><summary>Technical</summary>
-
-`hello` answers with the API version, the release and the features; `horizon-ctl --api`; MCP serverInfo; reply schemas generated into the reference; a `test.` namespace for hooks; transcript compatibility tests; `subscribe` as a stream of events on one connection; Horizon option files by key and saved-server commands. Agent control itself (`horizon-ctl`, both MCP servers, the No AI switch) is done: [docs/agent-control.md](docs/agent-control.md), [docs/api/agent-control.md](docs/api/agent-control.md).
-
-More: [docs/api/stability.md](docs/api/stability.md)
-
-</details>
-
-#### Port mods with your own AI agent
-
-You can port a mod to Horizon with your own AI agent on your own computer. Horizon documents how and gives you the tools, but provides no hosted agents.
-
-<details><summary>Technical</summary>
-
-A player runs their own agent locally with `horizon-ctl` and the MCP servers ([docs/agent-control.md](docs/agent-control.md)), `cargo horizon-mod`, `horizon-port-pack` and the parity harnesses as the check. Horizon writes the guide (playhorizon.dev/docs/agents, [docs/modpacks.md](docs/modpacks.md)) and runs no agents, accounts or keys for players. The No AI switch turns all of it off.
-
-More: [https://playhorizon.dev/docs/agents](https://playhorizon.dev/docs/agents)
-
-</details>
-
-### Community
-
-#### A video series about Horizon
-
-A series of videos about how Horizon is made and what is new, with each upload announced on Discord.
-
-<details><summary>Technical</summary>
-
-Kira already shows new uploads in a read-only Discord channel (done). The series follows each stage of the project: a script, edits, titles and a thumbnail per video.
-
-</details>
-
-#### Horizon on X (coming soon)
-
-Coming soon: an official Horizon account on X, used to announce releases and the weekly summary.
-
-<details><summary>Technical</summary>
-
-Kira already posts the roadmap items marked `announce = true` when they ship, and the weekly summary, as soon as the account's credentials exist ([roadmap/README.md](roadmap/README.md), 'The journal'). Waiting for the account itself.
-
-</details>
-
-### Code and tools
-
-#### Pipeline protection and a GitHub App for agents
-
-Safer releases: changes to the release machinery need the owner's review, and AI agents use a smaller identity of their own instead of a personal account.
-
-<details><summary>Technical</summary>
-
-`.github/CODEOWNERS` lists the workflows, the release and signing tools, the update-checking code and the installers ([#1015](https://github.com/horizon-rust/horizon/issues/1015)); the branch protection that makes it count waits for the `horizon-agent` GitHub App, which reads and writes code, pull requests and issues but can't change settings, workflows, secrets or members, and whose tokens last an hour. It needs the owner to create the App and switch the protection on ([docs/security.md](docs/security.md)).
-
-</details>
-
-#### Signed updates everywhere, installers included
-
-Every download Horizon makes is checked against the project's signature, including the first install with install.sh and install.ps1.
-
-<details><summary>Technical</summary>
-
-Releases carry signed checksums, and the launcher and `horizon-server update` refuse anything unsigned ([#1011](https://github.com/horizon-rust/horizon/issues/1011), [#1014](https://github.com/horizon-rust/horizon/issues/1014)). Left: the first install through `install.sh` and `install.ps1` still trusts only the checksum GitHub publishes, because verifying Ed25519 signatures needs OpenSSL 3, which macOS doesn't ship ([docs/security.md](docs/security.md)).
-
-</details>
-
-## Help wanted
-
-### Performance
-
-#### Benchmark your computer
-
-Run Horizon's built-in benchmark and share the report: every new computer makes the performance work more accurate. No coding needed.
-
-<details><summary>Technical</summary>
-
-`horizon-launcher play --arg=--benchmark --arg=standard` writes a JSON report; `horizon-launcher data benchmark <report>` shows what would be sent and uploads it (playhorizon.dev/docs/performance). Results from three installs with the same hardware appear on the Benchmarks page. Example: [#1711](https://github.com/horizon-rust/horizon/issues/1711).
-
-More: [https://playhorizon.dev/docs/performance](https://playhorizon.dev/docs/performance)
-
-</details>
-
-### Gameplay parity
-
-#### End city banners keep their pattern
-
-Banners in End cities show as plain magenta instead of with their pattern.
-
-<details><summary>Technical</summary>
-
-Compare the banner block entities the End city templates place with vanilla's (`EndCityPieces`, the templates' block entity NBT, `BannerBlockEntity`'s patterns), in `crates/horizon-world/src/worldgen/structure/`. Issue [#1438](https://github.com/horizon-rust/horizon/issues/1438); possibly related: [#526](https://github.com/horizon-rust/horizon/issues/526).
-
-</details>
-
-#### Enchanted loot in End cities
-
-Armour and tools in End city chests should come enchanted, as in vanilla.
-
-<details><summary>Technical</summary>
-
-`loot.rs` implements `enchant_with_levels`: find why the End city chest table's rolls come out bare, and compare them with vanilla's for a few seeds. Issues [#1437](https://github.com/horizon-rust/horizon/issues/1437), [#1660](https://github.com/horizon-rust/horizon/issues/1660).
-
-</details>
-
-## Recently shipped
-
-- **Chickens flap while they fall** (v0.2.67): Chickens should flap their wings while they fall, not stand still in the air. [#1706](https://github.com/horizon-rust/horizon/issues/1706) · [#1892](https://github.com/horizon-rust/horizon/issues/1892)
-- **Ctrl+Backspace and scroll bars in menus** (v0.2.67): Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be draggable. [#1764](https://github.com/horizon-rust/horizon/issues/1764) · [#1782](https://github.com/horizon-rust/horizon/issues/1782) · [#1884](https://github.com/horizon-rust/horizon/issues/1884) · [#1931](https://github.com/horizon-rust/horizon/issues/1931)
-- **A pointing hand over buttons** (v0.2.67): The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3. [#1347](https://github.com/horizon-rust/horizon/issues/1347) · [#1897](https://github.com/horizon-rust/horizon/issues/1897)
-- **Chat settings and team prefixes** (v0.2.67): The Hidden and Commands Only chat settings should hide chat, and team prefixes should appear before names in chat. [#1376](https://github.com/horizon-rust/horizon/issues/1376) · [#1378](https://github.com/horizon-rust/horizon/issues/1378) · [#1932](https://github.com/horizon-rust/horizon/issues/1932) · [#1841](https://github.com/horizon-rust/horizon/issues/1841)
-- **Cooldowns drawn on items** (v0.2.67): After you throw an ender pearl, its slot should show the cooldown sweeping away, as in vanilla. [#1763](https://github.com/horizon-rust/horizon/issues/1763) · [#1933](https://github.com/horizon-rust/horizon/issues/1933)
-- **Pre-generate an area with /pregen** (v0.2.67): A /pregen command that builds an area of the world ahead of time, so players don't wait for new terrain when they explore. [#1805](https://github.com/horizon-rust/horizon/issues/1805)
-- **Horizon's own shader format and kit** (v0.2.70): Horizon's own way to make shader packs, with tools to write and test them. Every pack is checked before it runs, and the registry will list them. [#1820](https://github.com/horizon-rust/horizon/issues/1820) · [#1822](https://github.com/horizon-rust/horizon/issues/1822) · [#1861](https://github.com/horizon-rust/horizon/issues/1861) · [#1863](https://github.com/horizon-rust/horizon/issues/1863) · [#1855](https://github.com/horizon-rust/horizon/issues/1855) · [docs/shaders.md](docs/shaders.md) · [docs/api/shaders.md](docs/api/shaders.md)
-- **Discord Rich Presence** (v0.2.58): Your Discord profile can show that you are playing Horizon, with a switch to turn it off. [#1787](https://github.com/horizon-rust/horizon/issues/1787) · [#1788](https://github.com/horizon-rust/horizon/issues/1788)
-- **Server dialogs and login screens** (v0.2.67): Servers that show dialogs, such as the register and login screens of AuthMe, will work in Horizon. [#1720](https://github.com/horizon-rust/horizon/issues/1720) · [#1734](https://github.com/horizon-rust/horizon/issues/1734) · [#1735](https://github.com/horizon-rust/horizon/issues/1735)
-- **Microsoft sign-in** (launcher@0.2.17): Sign in with your Microsoft account in the launcher to play on online-mode servers. [docs/microsoft-account.md](docs/microsoft-account.md) · [#2879](https://github.com/horizon-rust/horizon/issues/2879)
-- **OpenGL for old computers** (v0.2.63): Horizon now starts on old PCs whose graphics card has no Vulkan or DirectX 12 driver: it switches to OpenGL by itself, and Options > Graphics can pick OpenGL by hand. [#1917](https://github.com/horizon-rust/horizon/issues/1917) · [#1920](https://github.com/horizon-rust/horizon/issues/1920) · [#1936](https://github.com/horizon-rust/horizon/issues/1936)
-- **Server resource packs** (v0.2.48): Servers can send you their resource pack: Horizon asks, downloads it and applies it, like vanilla. [#1562](https://github.com/horizon-rust/horizon/issues/1562) · [#1569](https://github.com/horizon-rust/horizon/issues/1569) · [#1570](https://github.com/horizon-rust/horizon/issues/1570)
-- **Single player on its own server thread** (v0.2.39): Single player runs on a server thread, as vanilla does, so the world keeps ticking smoothly while the window draws. [#1514](https://github.com/horizon-rust/horizon/issues/1514) · [docs/server-levels.md](docs/server-levels.md)
-- **GPU occlusion culling on Macs** (v0.2.17): On Macs the GPU now skips terrain hidden behind hills and caves: 8 to 48% more frames per second at 32 chunks on an M4 Pro. [#1434](https://github.com/horizon-rust/horizon/issues/1434)
-- **Animated textures on the GPU** (v0.2.5): Water, lava and other animated blocks are now animated by the graphics card: 1.7 to 2.4 times better 1% lows on Intel graphics. [#1239](https://github.com/horizon-rust/horizon/issues/1239)
-- **Far Detail for integrated graphics** (v0.2.5): An optional Reduced setting for far terrain, suggested on integrated graphics, that saves 2 to 4 ms of GPU time per frame. [#1199](https://github.com/horizon-rust/horizon/issues/1199) · [#1029](https://github.com/horizon-rust/horizon/issues/1029)
-- **The launcher's mod browser** (launcher@0.2.0): Search Modrinth for mods, modpacks and resource packs from the launcher; it says before installing what works in Horizon. [#1154](https://github.com/horizon-rust/horizon/issues/1154) · [#1242](https://github.com/horizon-rust/horizon/issues/1242) · [#1243](https://github.com/horizon-rust/horizon/issues/1243) · [#1246](https://github.com/horizon-rust/horizon/issues/1246) · [docs/mod-browser.md](docs/mod-browser.md)
-- **A blocky, Minecraft-like launcher** (launcher@0.2.0): The launcher got a new blocky look in Horizon's purple, in dark and light. [#1269](https://github.com/horizon-rust/horizon/issues/1269) · [docs/design-system.md](docs/design-system.md)
-- **Dynamic lights** (v2026.10.22): An optional extra: torches you hold, drop or set on fire light up what is around them. [#1162](https://github.com/horizon-rust/horizon/issues/1162)
-- **Host a server from the launcher** (launcher-v0.15.0): The launcher's Servers page creates, starts, backs up and updates a Horizon server with buttons, and invites friends. [#1026](https://github.com/horizon-rust/horizon/issues/1026) · [docs/hosting.md](docs/hosting.md)

THIRD_PARTY_NOTICES.md

@@ -1,60 +1,38 @@
 # Third-party notices
 
+## CullLeaves
+
+The optional leaf and mangrove-root face-culling behavior is adapted from
+[CullLeaves](https://github.com/TeamMidnightDust/CullLeaves) by MidnightDust.
+Its MIT license is reproduced below.
+
+```text
+MIT License
+
+Copyright (c) 2020 MidnightDust
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
 ## wgpu-hal
 
 `third_party/wgpu-hal` is [wgpu-hal](https://github.com/gfx-rs/wgpu) 30.0.1 by the gfx-rs
 developers, with one upstream fix applied
 ([gfx-rs/wgpu#10124](https://github.com/gfx-rs/wgpu/pull/10124)). It is licensed under MIT or
 Apache-2.0; both licenses are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
-
-## Pixelify Sans
-
-`crates/horizon-theme/fonts/PixelifySans-*.ttf` is [Pixelify Sans](https://github.com/eifetx/Pixelify-Sans)
-by The Pixelify Sans Project Authors, licensed under the SIL Open Font License 1.1
-(`crates/horizon-theme/fonts/OFL-PixelifySans.txt`).
-
-## Pixelarticons
-
-`crates/horizon-theme/icons/pixel/*.svg` are icons from
-[Pixelarticons](https://github.com/halfmage/pixelarticons) by Gerrit Halfmann, under the MIT
-license (`crates/horizon-theme/icons/pixel/LICENSE-pixelarticons.txt`). `star.svg` is Horizon's own, drawn on
-the same grid.
-
-## AMD FidelityFX SDK (FSR 3.1 frame generation)
-
-`crates/horizon-client-render/src/gfx/frame_gen/optical_flow.wgsl` is a port to WGSL of the
-optical flow shaders of the [AMD FidelityFX SDK](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK)
-1.1.4 (`sdk/include/FidelityFX/gpu/opticalflow`, at commit
-[c6efa6bf7f20](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/tree/c6efa6bf7f2027b3ec94f28578bb5965eabb9e55)),
-and `optical_flow.rs` follows the SDK's `sdk/src/components/opticalflow/ffx_opticalflow.cpp`
-(its passes, their order and their dispatch sizes). Copyright (C) 2024 Advanced Micro Devices,
-Inc., under the MIT license, whose text heads both files. AMD and FidelityFX are AMD's
-trademarks; Horizon is not affiliated with AMD.
-
-## Mod loader logos
-
-The launcher shows the logo of the mod loader an instance plays with.
-
-- `launcher/assets/logos/quilt.png` is the Quilt mini icon (`brand/128png/quilt_mini_icon_transparent.png`)
-  from [QuiltMC/art](https://github.com/QuiltMC/art), by the Quilt Project, dedicated to the public
-  domain under [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/).
-- `launcher/assets/logos/neoforge.png` is NeoForged's icon (`art/neoforged_icon_16x16.png`) from
-  [neoforged/.github](https://github.com/neoforged/.github/tree/main/art), © the NeoForged team,
-  created by Ridanisaurus, under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). It is
-  unmodified (the launcher scales it up by whole pixels).
-- Fabric's and Forge's icons are not shipped: neither publishes a license for its logo. The launcher
-  fetches them from their own sites when an instance needs them
-  ([fabric-loader's icon](https://github.com/FabricMC/fabric-loader/blob/master/src/main/resources/assets/fabricloader/icon.png),
-  [files.minecraftforge.net's](https://files.minecraftforge.net/)).
-
-Each logo belongs to its project. Showing it says which loader an instance runs; it does not mean
-the project endorses Horizon.
-
-## Sign in with Microsoft
-
-The launcher's sign-in buttons follow Microsoft's published branding guidelines for apps that sign in
-with Microsoft accounts
-([Sign in with Microsoft branding](https://learn.microsoft.com/en-us/entra/identity-platform/howto-add-branding-in-apps)).
-The four-square Microsoft symbol in `launcher/src/microsoft.rs` reproduces the squares, positions and
-colours of Microsoft's official `ms-symbollockup_mssymbol_19.svg` from that page, unmodified. Microsoft
-and its logo are trademarks of the Microsoft group of companies; Horizon is not endorsed by Microsoft.

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

@@ -131,8 +131,8 @@ average) and reached the ThinkPad over the tailnet.
   It ran with Paper's defaults except `connection-throttle: -1` in `bukkit.yml`. Every bot connects from one
   address, and the default throttle (4 s) refused all but the first. Paperclip patched the pinned server jar
   from its cache. Same Java and heap.
-- Fabric + Lithium: the pinned server jar on Fabric loader 0.19.5 (`tools/benchmark-deps/fabric.lock.json`) with Lithium
-  `mc26.3-0.26.2-fabric` (`tools/benchmark-deps/mods.lock.json`, checked against its SHA-512). Lithium needs no Fabric API.
+- Fabric + Lithium: the pinned server jar on Fabric loader 0.19.5 (`packs/fabric.lock.json`) with Lithium
+  `mc26.3-0.26.2-fabric` (`packs/mods.lock.json`, checked against its SHA-512). Lithium needs no Fabric API.
   Same Java and heap.
 
 The Paper and Fabric jars are dev-only downloads into `.local/server-bench/jars` and are never committed or
@@ -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: 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"] }
 serde_json = "1.0.151"
 
 [lints]

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

@@ -1,192 +0,0 @@
-//! `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.
-use horizon_mods::{
-    Package,
-    index::{self, Facts, Kind},
-};
-use serde_json::{Value, json};
-use std::path::Path;
-
-pub struct Report {
-    pub kind: Kind,
-    pub facts: Facts,
-    pub sha256: String,
-    pub size: u64,
-    pub signed: bool,
-}
-
-impl Report {
-    pub fn json(&self) -> Value {
-        let requires: Vec<Value> = self
-            .facts
-            .requires
-            .iter()
-            .map(|r| json!({"id": r.id, "version": r.version, "sha256": r.sha256}))
-            .collect();
-        json!({
-            "kind": self.kind.name(),
-            "id": self.facts.id,
-            "version": self.facts.version,
-            "api": self.facts.api,
-            "side": self.facts.side,
-            "capabilities": self.facts.capabilities,
-            "api_level": self.facts.api_level,
-            "game": self.facts.game,
-            "requires": requires,
-            "sha256": self.sha256,
-            "size": self.size,
-            "signed": self.signed,
-        })
-    }
-
-    pub fn text(&self) -> String {
-        let f = &self.facts;
-        let mut out = format!(
-            "{} {} ({}",
-            f.id.as_deref().unwrap_or("resource pack"),
-            f.version.as_deref().unwrap_or(""),
-            self.kind.name()
-        );
-        if let Some(side) = f.side {
-            let side = serde_json::to_value(side).unwrap_or_default();
-            out += &format!(", API {}, {}", f.api, side.as_str().unwrap_or("?"));
-        } else if self.kind == Kind::Shader {
-            out += &format!(", shader API {}", f.api);
-        } else if !f.api.is_empty() {
-            out += &format!(", format {}", f.api);
-        }
-        if let Some(game) = &f.game {
-            out += &format!(", for {game}");
-        }
-        let signed = if self.signed {
-            "signature verified"
-        } else {
-            "unsigned"
-        };
-        out += &format!(
-            ")\n  {} bytes, SHA-256 {}, {signed}\n",
-            self.size, self.sha256
-        );
-        if let Some(level) = f.api_level {
-            out += &format!("  needs mod API level {level} or newer\n");
-        }
-        for c in &f.capabilities {
-            out += &format!("  may {}\n", c.describe());
-        }
-        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 {
-            out += "  no code: content only, nothing to run\n";
-        }
-        out
-    }
-}
-
-/// The kind a file's extension says.
-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),
-        _ => None,
-    }
-}
-
-/// Checks the file at `path` as `kind`; `key` and `signature` (the
-/// `.minisig` text) check its signature.
-pub fn check(
-    path: &Path,
-    kind: Kind,
-    key: Option<&str>,
-    signature: Option<&str>,
-) -> Result<Report, String> {
-    let size = std::fs::metadata(path)
-        .map_err(|e| format!("{}: {e}", path.display()))?
-        .len();
-    if size > index::MAX_FILE {
-        return Err(format!("over {} MiB", index::MAX_FILE >> 20));
-    }
-    index::open(&kind)?;
-    let facts = index::inspect(&kind, path)?;
-    let signed = match (key, signature) {
-        (Some(key), Some(sig)) => {
-            index::verify_signature(key, sig, path)?;
-            true
-        }
-        (None, None) => false,
-        _ => return Err("--key and --signature go together".into()),
-    };
-    if kind == Kind::Mod {
-        content_only(path)?;
-    }
-    Ok(Report {
-        kind,
-        facts,
-        sha256: index::sha256_file(path)?,
-        size,
-        signed,
-    })
-}
-
-/// 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(),
-        ),
-        None => Ok(()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn fixture(name: &str) -> std::path::PathBuf {
-        Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../horizon-mods/tests/index")
-            .join(name)
-    }
-
-    #[test]
-    fn checks_each_kind_its_own_way() {
-        let pack = fixture("cozy-1.0.0.hpack");
-        let report = check(&pack, kind_of(&pack).unwrap(), None, None).unwrap();
-        assert_eq!(report.facts.requires[0].id, "coords_hud");
-        assert!(
-            report
-                .text()
-                .contains("cozy 1.0.0 (modpack, format 1, for 26.3)")
-        );
-        // A mod with WebAssembly code is refused: code mods are native.
-        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();
-        let key = key.lines().last().unwrap();
-        let e = check(&hmod, Kind::Mod, Some(key), Some(&sig))
-            .err()
-            .unwrap();
-        assert!(e.contains("native mod"), "{e}");
-        let e = check(
-            &hmod,
-            Kind::Mod,
-            Some(key),
-            Some("untrusted comment: x\nRUQ=\n"),
-        )
-        .err()
-        .unwrap();
-        assert!(e.contains("signature"), "{e}");
-        let e = check(&pack, Kind::Shader, None, None).err().unwrap();
-        assert!(e.contains("horizon-shaders.toml"), "{e}");
-        assert!(check(&pack, Kind::Mod, None, None).is_err());
-    }
-}

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

@@ -1,23 +1,21 @@
-//! `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> [--name "Name"] [--sdk-path <dir>]`: a mod crate from the template.
+//! - `build [--debug]`: the `.hmod` in `target/horizon-mod/`.
 //! - `run [--game <horizon-client>] [-- <game args>]`: build, then play with
-//!   the mod.
-//! - `check <file> [--json]`: what the registry checks of a submission
-//!   (`.hmod`, `.hnmod`, `.hpack`, resource pack `.zip`, `.hshader`).
-//! - `registry build|review|check|list`: the registry repository's CI.
-use horizon_mods::{Capability, Content, Manifest, Package, manifest::MANIFEST};
-mod check;
-mod registry;
-
+//!   the mod; run `build` again and the game reloads it.
+use horizon_mods::{
+    Manifest, Package,
+    manifest::{MANIFEST, component_imports, componentize},
+};
 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\" }";
+
 fn main() -> ExitCode {
     // Cargo runs `cargo-horizon-mod horizon-mod <args>`.
     let mut args: Vec<String> = std::env::args().skip(1).collect();
@@ -26,13 +24,11 @@ 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("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> | build [--debug] | run [--game <horizon-client>] [-- <game args>]".into()),
     };
     match result {
         Ok(()) => ExitCode::SUCCESS,
@@ -73,63 +69,32 @@ 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);
-    // A block copying a vanilla one, with its model, name, loot, recipe and tag.
+    let sdk = match flag(args, "--sdk-path") {
+        Some(p) => {
+            let p = std::fs::canonicalize(p).map_err(|e| format!("--sdk-path {p}: {e}"))?;
+            format!("{{ path = {:?} }}", p.display().to_string())
+        }
+        None => SDK_GIT.to_string(),
+    };
+    let fill = |t: &str| {
+        t.replace("{crate}", &id.replace('_', "-"))
+            .replace("{id}", &id)
+            .replace("{name}", &name)
+            .replace("{sdk}", &sdk)
+    };
     let files = [
-        (
-            MANIFEST,
-            include_str!("../template/content/horizon-mod.toml"),
-        ),
-        (
-            "data/{id}/horizon/block/glowing_amethyst.json",
-            include_str!("../template/content/block.json"),
-        ),
-        (
-            "assets/{id}/blockstates/glowing_amethyst.json",
-            include_str!("../template/content/blockstate.json"),
-        ),
-        (
-            "assets/{id}/models/block/glowing_amethyst.json",
-            include_str!("../template/content/model.json"),
-        ),
-        (
-            "assets/{id}/items/glowing_amethyst.json",
-            include_str!("../template/content/item.json"),
-        ),
-        (
-            "assets/{id}/lang/en_us.json",
-            include_str!("../template/content/lang.json"),
-        ),
-        (
-            "data/{id}/loot_table/blocks/glowing_amethyst.json",
-            include_str!("../template/content/loot.json"),
-        ),
-        (
-            "data/{id}/recipe/glowing_amethyst.json",
-            include_str!("../template/content/recipe.json"),
-        ),
-        (
-            "data/minecraft/tags/block/mineable/pickaxe.json",
-            include_str!("../template/content/pickaxe.json"),
-        ),
+        ("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")),
     ];
-    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 {
-        let file = fill(file);
-        let file = file.as_str();
         let to = dir.join(file);
         std::fs::create_dir_all(to.parent().expect("a file in the mod"))
             .map_err(|e| e.to_string())?;
         std::fs::write(&to, fill(text)).map_err(|e| format!("{}: {e}", to.display()))?;
     }
-    let manifest =
-        Manifest::parse(&std::fs::read_to_string(dir.join(MANIFEST)).map_err(|e| e.to_string())?)?;
-    Content::read(dir, &manifest)?;
+    Manifest::parse(&std::fs::read_to_string(dir.join(MANIFEST)).map_err(|e| e.to_string())?)?;
     println!(
         "Created {} (mod id {id}). Next: cd {path} && cargo horizon-mod run",
         dir.display()
@@ -137,82 +102,65 @@ 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("."))
-}
-
-fn build_in(root: &Path) -> Result<PathBuf, String> {
-    let manifest_text = std::fs::read_to_string(root.join(MANIFEST))
+/// Builds the crate in the current folder and packs `target/horizon-mod/<id>.hmod`.
+fn build(release: bool) -> Result<PathBuf, String> {
+    let manifest_text = std::fs::read_to_string(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());
+    let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
+    let mut cmd = Command::new(cargo);
+    cmd.args([
+        "build",
+        "--lib",
+        "--target",
+        TARGET,
+        "--message-format=json-render-diagnostics",
+    ]);
+    if release {
+        cmd.arg("--release");
     }
-    if !manifest.capabilities.contains(&Capability::Registries) {
+    let out = cmd
+        .stderr(Stdio::inherit())
+        .output()
+        .map_err(|e| e.to_string())?;
+    if !out.status.success() {
         return Err(format!(
-            "a content mod has capability registries in {MANIFEST}"
+            "cargo build failed (is the target installed? rustup target add {TARGET})"
         ));
     }
-    // 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()?;
-    let mut files = Vec::with_capacity(content.files.len());
-    for name in &content.files {
-        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 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())?)?;
+    // The game refuses a component importing capabilities the manifest lacks.
+    manifest.check_imports(component_imports(&wasm)?.iter().map(String::as_str))?;
+    let target_dir = core.ancestors().nth(3).ok_or("unexpected target folder")?;
+    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)?;
-    std::fs::write(&partial, bytes).map_err(|e| e.to_string())?;
+    std::fs::write(&partial, Package::write(&manifest_text, &wasm)?).map_err(|e| e.to_string())?;
     std::fs::rename(&partial, &path).map_err(|e| e.to_string())?;
     Ok(path)
 }
 
-/// `check <file>`: the registry's checks of a submission, printed; fails
-/// when one does.
-fn check(args: &[String]) -> Result<(), String> {
-    let file = args
-        .first()
-        .filter(|a| !a.starts_with("--"))
-        .ok_or("cargo horizon-mod check <file>")?;
-    let path = Path::new(file);
-    let kind = match flag(args, "--kind") {
-        Some(k) => horizon_mods::index::Kind::from(k.to_string()),
-        None => check::kind_of(path)
-            .ok_or("pass --kind mod|modpack|resourcepack: the extension doesn't say")?,
-    };
-    let signature = flag(args, "--signature")
-        .map(|p| std::fs::read_to_string(p).map_err(|e| format!("{p}: {e}")))
-        .transpose()?;
-    let report = check::check(path, kind, flag(args, "--key"), signature.as_deref());
-    if args.iter().any(|a| a == "--json") {
-        let json = match &report {
-            Ok(r) => serde_json::json!({"ok": true, "report": r.json()}),
-            Err(e) => serde_json::json!({"ok": false, "error": e}),
-        };
-        println!("{json}");
-    }
-    let report = report?;
-    if !args.iter().any(|a| a == "--json") {
-        print!("{}", report.text());
-    }
-    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)
@@ -232,43 +180,21 @@ mod tests {
     use super::*;
 
     #[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()));
-        let path = dir.join("gems");
-        let new_args = [
-            path.display().to_string(),
-            "--template".into(),
-            "content".into(),
-        ];
-        new(&new_args).unwrap();
-        assert!(!path.join("Cargo.toml").exists());
-        let hmod = build_in(&path).unwrap();
-        assert_eq!(hmod, path.join("target/horizon-mod/gems.hmod"));
-        let package = Package::read(&hmod).unwrap();
-        assert!(package.wasm.is_none());
-        let content = Content::read(&hmod, &package.manifest).unwrap();
-        assert!(
-            content
-                .files
-                .contains(&"data/gems/horizon/block/glowing_amethyst.json".into())
+    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")
         );
-        assert_eq!(content.files.len(), 8, "{:?}", content.files);
-        let report = check::check(&hmod, check::kind_of(&hmod).unwrap(), None, None).unwrap();
+        let cargo = std::fs::read_to_string(path.join("Cargo.toml")).unwrap();
+        assert!(cargo.contains("name = \"my-mod\"") && cargo.contains(SDK_GIT));
         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"));
-        assert!(
-            new(&[
-                dir.join("x").display().to_string(),
-                "--template".into(),
-                "lua".into()
-            ])
-            .is_err()
+            new(&[path.display().to_string()]).is_err(),
+            "never overwrites"
         );
         std::fs::remove_dir_all(&dir).unwrap();
     }

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

@@ -1,229 +0,0 @@
-//! `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
-//! workflow downloads the files and publishes what this writes.
-use horizon_mods::index::{
-    FILE_HOST,
-    registry::{self, Sources},
-};
-use std::path::Path;
-
-/// Where the registry's site is published (its icons).
-const SITE: &str = "https://horizon-rust.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]
-       cargo horizon-mod registry check <base checkout> <head checkout> --files <dir>
-       cargo horizon-mod registry list <checkout>
-       cargo horizon-mod registry release <checkout> <id> <file> --tag <tag> --published <YYYY-MM-DD> [--notes <file>] [--signature <file>] [--game <version>]
-       cargo horizon-mod registry page <checkout> <id> <horizon-registry.toml>";
-
-fn flag<'a>(args: &'a [String], name: &str) -> Option<&'a str> {
-    super::flag(args, name)
-}
-
-fn positional(args: &[String]) -> Vec<&str> {
-    let mut out = Vec::new();
-    let mut skip = false;
-    for a in args {
-        if skip {
-            skip = false;
-        } else if a == "--json" {
-        } else if a.starts_with("--") {
-            skip = true;
-        } else {
-            out.push(a.as_str());
-        }
-    }
-    out
-}
-
-fn lines(errors: Vec<String>) -> String {
-    format!("{} problem(s):\n  {}", errors.len(), errors.join("\n  "))
-}
-
-pub fn main(args: &[String]) -> Result<(), String> {
-    let rest = args.get(1..).unwrap_or_default();
-    let pos = positional(rest);
-    match args.first().map(String::as_str) {
-        Some("build") => {
-            let [checkout] = pos[..] else {
-                return Err(USAGE.into());
-            };
-            let (files, out) = (flag(rest, "--files"), flag(rest, "--out"));
-            let (Some(files), Some(out)) = (files, out) else {
-                return Err(USAGE.into());
-            };
-            let generated = flag(rest, "--generated")
-                .map(str::to_owned)
-                .or_else(|| std::env::var("REGISTRY_GENERATED").ok())
-                .unwrap_or_default();
-            let index = registry::build(&Sources {
-                registry: Path::new(checkout),
-                files: Path::new(files),
-                release: flag(rest, "--release").unwrap_or(FILE_HOST),
-                site: flag(rest, "--site").unwrap_or(SITE),
-                generated,
-            })
-            .map_err(lines)?;
-            let text = serde_json::to_string_pretty(&index).map_err(|e| e.to_string())?;
-            std::fs::write(out, text + "\n").map_err(|e| format!("{out}: {e}"))?;
-            println!(
-                "Wrote {out}: {} project(s), {} taken down",
-                index.projects.len(),
-                index.revoked.len()
-            );
-            Ok(())
-        }
-        Some("review") => {
-            let [base, head] = pos[..] else {
-                return Err(USAGE.into());
-            };
-            let author = flag(rest, "--author").ok_or(USAGE)?;
-            let (base, _) = registry::load(Path::new(base)).map_err(lines)?;
-            let (head, _) = registry::load(Path::new(head)).map_err(lines)?;
-            let review = registry::review(&base, &head, author);
-            if rest.iter().any(|a| a == "--json") {
-                let json = serde_json::json!({"errors": review.errors, "notes": review.notes});
-                println!("{json}");
-            } else {
-                for n in &review.notes {
-                    println!("note: {n}");
-                }
-                for e in &review.errors {
-                    println!("error: {e}");
-                }
-            }
-            if review.errors.is_empty() {
-                Ok(())
-            } else {
-                Err(format!(
-                    "{} change(s) the registry refuses",
-                    review.errors.len()
-                ))
-            }
-        }
-        // `check` (and its trial run) on each file `head` lists and `base`
-        // doesn't: a pull request's new files.
-        Some("check") => {
-            let [base, head] = pos[..] else {
-                return Err(USAGE.into());
-            };
-            let files = Path::new(flag(rest, "--files").ok_or(USAGE)?);
-            let old: Vec<String> = match registry::load(Path::new(base)) {
-                Ok((entries, _)) => entries
-                    .iter()
-                    .flat_map(|e| e.versions.iter().map(|v| v.sha256.clone()))
-                    .collect(),
-                // The first pull request has no entries to compare with.
-                Err(_) => Vec::new(),
-            };
-            let (entries, _) = registry::load(Path::new(head)).map_err(lines)?;
-            let mut failed = 0;
-            for e in &entries {
-                for v in e.versions.iter().filter(|v| !old.contains(&v.sha256)) {
-                    println!("{} {} ({}):", e.id, v.version, v.file);
-                    let report = crate::check::check(
-                        &files.join(&v.sha256),
-                        e.kind.clone(),
-                        e.key.as_deref(),
-                        v.signature.as_deref(),
-                    );
-                    match report {
-                        Ok(r) => print!("{}", r.text()),
-                        Err(err) => {
-                            failed += 1;
-                            println!("  error: {err}");
-                        }
-                    }
-                }
-            }
-            if failed == 0 {
-                Ok(())
-            } else {
-                Err(format!("{failed} file(s) failed their check"))
-            }
-        }
-        // The files CI must download for `build`: `<sha256> <id> <version> <file>`.
-        Some("list") => {
-            let [checkout] = pos[..] else {
-                return Err(USAGE.into());
-            };
-            let (entries, _) = registry::load(Path::new(checkout)).map_err(lines)?;
-            for e in &entries {
-                for v in &e.versions {
-                    println!("{} {} {} {}", v.sha256, e.id, v.version, v.file);
-                }
-            }
-            Ok(())
-        }
-        // A release of a project's repository, downloaded: the checks of a submission, then the
-        // version as the index lists it (JSON on stdout), for the registry's release sync.
-        Some("release") => {
-            let [checkout, id, file] = pos[..] else {
-                return Err(USAGE.into());
-            };
-            let (tag, published) = (
-                flag(rest, "--tag").ok_or(USAGE)?,
-                flag(rest, "--published").ok_or(USAGE)?,
-            );
-            let read = |name: &str| {
-                flag(rest, name)
-                    .map(|p| std::fs::read_to_string(p).map_err(|e| format!("{p}: {e}")))
-                    .transpose()
-            };
-            let (notes, signature) = (read("--notes")?, read("--signature")?);
-            let entry = entry_of(checkout, id)?;
-            let path = Path::new(file);
-            let cache = registry::Cache::read(Path::new(checkout), id)?;
-            let entry = entry.resolved(&cache.page);
-            let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-            crate::check::check(
-                path,
-                entry.kind.clone(),
-                entry.key.as_deref(),
-                signature.as_deref(),
-            )?;
-            let version = registry::release_version(
-                &entry,
-                &registry::Release {
-                    tag,
-                    published,
-                    notes: notes.as_deref().unwrap_or(""),
-                    asset: flag(rest, "--name").unwrap_or(name),
-                    game: flag(rest, "--game").unwrap_or("26.3"),
-                    signature: signature.as_deref(),
-                },
-                path,
-            )?;
-            println!(
-                "{}",
-                serde_json::to_string(&version).map_err(|e| e.to_string())?
-            );
-            Ok(())
-        }
-        // The page file of a project's repository, checked against its entry: the page as JSON.
-        Some("page") => {
-            let [checkout, id, file] = pos[..] else {
-                return Err(USAGE.into());
-            };
-            let entry = entry_of(checkout, id)?;
-            let text = std::fs::read_to_string(file).map_err(|e| format!("{file}: {e}"))?;
-            let page = registry::page(&entry, &text)?;
-            println!(
-                "{}",
-                serde_json::to_string(&page).map_err(|e| e.to_string())?
-            );
-            Ok(())
-        }
-        _ => Err(USAGE.into()),
-    }
-}
-
-/// `mods/<id>.toml` of the checkout, which must name a repository.
-fn entry_of(checkout: &str, id: &str) -> Result<registry::Entry, String> {
-    let (entries, _) = registry::load(Path::new(checkout)).map_err(lines)?;
-    entries
-        .into_iter()
-        .find(|e| e.id == id && e.repo.is_some())
-        .ok_or_else(|| format!("{id}: no entry with a repo"))
-}

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/content/block.json

@@ -1,4 +0,0 @@
-{
-  "template": "minecraft:amethyst_block",
-  "properties": { "hardness": 2.0, "light": 7 }
-}

crates/cargo-horizon-mod/template/content/blockstate.json

@@ -1,5 +0,0 @@
-{
-  "variants": {
-    "": { "model": "{id}:block/glowing_amethyst" }
-  }
-}

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

@@ -1,10 +0,0 @@
-id = "{id}"
-name = "{name}"
-version = "0.1.0"
-description = ""
-authors = []
-# A content mod: blocks and items from data/ and assets/, no code (API 0.2).
-api = "0.2"
-side = "both"
-# registries: "May add blocks and items to your worlds".
-capabilities = ["registries"]

crates/cargo-horizon-mod/template/content/item.json

@@ -1,3 +0,0 @@
-{
-  "model": { "type": "minecraft:model", "model": "{id}:block/glowing_amethyst" }
-}

crates/cargo-horizon-mod/template/content/lang.json

@@ -1,3 +0,0 @@
-{
-  "block.{id}.glowing_amethyst": "Glowing Amethyst"
-}

crates/cargo-horizon-mod/template/content/loot.json

@@ -1,11 +0,0 @@
-{
-  "type": "minecraft:block",
-  "pools": [
-    {
-      "condition": { "type": "minecraft:survives_explosion" },
-      "entries": [{ "type": "minecraft:item", "name": "{id}:glowing_amethyst" }],
-      "rolls": 1
-    }
-  ],
-  "random_sequence": "{id}:blocks/glowing_amethyst"
-}

crates/cargo-horizon-mod/template/content/model.json

@@ -1,4 +0,0 @@
-{
-  "parent": "minecraft:block/cube_all",
-  "textures": { "all": "minecraft:block/amethyst_block" }
-}

crates/cargo-horizon-mod/template/content/pickaxe.json

@@ -1,3 +0,0 @@
-{
-  "values": ["{id}:glowing_amethyst"]
-}

crates/cargo-horizon-mod/template/content/recipe.json

@@ -1,6 +0,0 @@
-{
-  "type": "minecraft:crafting_shapeless",
-  "category": "building",
-  "ingredients": ["minecraft:amethyst_block", "minecraft:glowstone_dust"],
-  "result": { "id": "{id}:glowing_amethyst" }
-}

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/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/horizon-anticheat/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "horizon-anticheat"
-version = "0.1.0"
-edition.workspace = true
-license.workspace = true
-rust-version = "1.85"
-description = "The dedicated server's anticheat: its [anticheat] settings, violation levels and the checks' rules, with no game state (docs/anticheat.md)"
-
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-toml = "1.1"
-
-[lints]
-workspace = true

crates/horizon-anticheat/src/lib.rs

@@ -1,303 +0,0 @@
-//! The dedicated server's anticheat (docs/anticheat.md), without the game: the `[anticheat]` section of
-//! `server.toml`, each player's violation levels, and the rules of the checks. The server's hub
-//! (`horizon_client::lan`) feeds it what players send and carries out what it decides.
-//!
-//! It is off unless the owner turns it on. A check that fails *flags* the player: its violation level
-//! (VL) rises by the flag's weight and falls back by `decay` a second. From `setback` on, the move or
-//! action is cancelled (the player is sent back where the server last had them); from `alert` on,
-//! online operators and the console are told; from `kick` on, the player is disconnected. Nothing bans.
-//! Any threshold at 0 turns that action off.
-//!
-//! The checks are written from vanilla 26.3's own rules and from what cheats are publicly described to
-//! do, never from another anticheat's code.
-
-use serde::{Deserialize, Serialize};
-
-pub mod timer;
-
-/// What one check's violation level leads to.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Actions {
-    pub setback: f32,
-    pub alert: f32,
-    pub kick: f32,
-    /// Violation level lost each second.
-    pub decay: f32,
-}
-
-macro_rules! checks {
-    ($(
-        $(#[$doc:meta])*
-        $field:ident: $Check:ident => $Config:ident [$setback:expr, $alert:expr, $kick:expr, $decay:expr] {
-            $( $(#[$xdoc:meta])* $extra:ident: $ty:ty = $default:expr, )*
-        }
-    )*) => {
-        /// Every check, in the order of the players' violation levels.
-        #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-        pub enum Check { $($Check,)* }
-
-        impl Check {
-            pub const ALL: &[Check] = &[$(Check::$Check,)*];
-            /// Its name in `server.toml` and in alerts.
-            pub fn name(self) -> &'static str {
-                match self { $(Check::$Check => stringify!($field),)* }
-            }
-        }
-
-        $(
-            $(#[$doc])*
-            #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-            #[serde(default, deny_unknown_fields)]
-            pub struct $Config {
-                pub enabled: bool,
-                pub setback: f32,
-                pub alert: f32,
-                pub kick: f32,
-                pub decay: f32,
-                $( $(#[$xdoc])* pub $extra: $ty, )*
-            }
-
-            impl Default for $Config {
-                fn default() -> Self {
-                    Self {
-                        enabled: true,
-                        setback: $setback,
-                        alert: $alert,
-                        kick: $kick,
-                        decay: $decay,
-                        $($extra: $default,)*
-                    }
-                }
-            }
-        )*
-
-        /// `server.toml`'s `[anticheat]`: off by default.
-        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-        #[serde(default, deny_unknown_fields)]
-        pub struct Config {
-            pub enabled: bool,
-            /// Tell online operators of an alert in their chat (the console and the log always are).
-            pub alerts: bool,
-            /// The permission level a player needs to see alerts.
-            pub alert_level: u8,
-            /// Every flag, one line each, relative to the server's folder; empty: no file.
-            pub log: String,
-            $(pub $field: $Config,)*
-        }
-
-        impl Default for Config {
-            fn default() -> Self {
-                Self {
-                    enabled: false,
-                    alerts: true,
-                    alert_level: 2,
-                    log: "logs/anticheat.log".into(),
-                    $($field: $Config::default(),)*
-                }
-            }
-        }
-
-        impl Config {
-            /// Whether `check` runs: the anticheat and the check both on.
-            pub fn runs(&self, check: Check) -> bool {
-                self.enabled && match check { $(Check::$Check => self.$field.enabled,)* }
-            }
-
-            pub fn actions(&self, check: Check) -> Actions {
-                match check {
-                    $(Check::$Check => {
-                        let c = &self.$field;
-                        Actions { setback: c.setback, alert: c.alert, kick: c.kick, decay: c.decay }
-                    })*
-                }
-            }
-        }
-    };
-}
-
-checks! {
-    /// Timer: more client ticks than the server's clock allows (a sped-up game). Vanilla's client ends
-    /// every tick with ServerboundClientTickEndPacket, at the server's tick rate; each one spends a tick's
-    /// time from a balance that wall-clock time fills, capped so a pause can't be saved up for a burst.
-    timer: Timer => TimerConfig [2.0, 5.0, 20.0, 0.02] {
-        /// How far ahead of the clock, in milliseconds, a client may get before it is flagged.
-        tolerance_ms: f64 = 300.0,
-        /// The most time, in milliseconds, a quiet connection banks for the ticks that follow (a lag
-        /// spike's backlog arrives at once).
-        max_lag_ms: f64 = 1000.0,
-    }
-
-    /// Ground: a move that says it ends on the ground with nothing there to stand on: no-fall (claiming
-    /// the ground to skip fall damage) and walking on water. The claim is always dropped, so vanilla's
-    /// fall damage follows; from `setback` on the player is also sent back.
-    ground: Ground => GroundConfig [5.0, 15.0, 60.0, 2.0] {}
-}
-
-/// How many checks there are.
-pub const CHECKS: usize = Check::ALL.len();
-
-impl Config {
-    /// The `[anticheat]` section of a whole `server.toml`; the default (off) when it has none.
-    pub fn from_server_toml(text: &str) -> Result<Self, String> {
-        #[derive(Deserialize)]
-        struct File {
-            #[serde(default)]
-            anticheat: Config,
-        }
-        // Other sections are the supervisor's to check: only this one is read here.
-        let mut table: toml::Table = toml::from_str(text).map_err(|e| e.to_string())?;
-        let mut only = toml::Table::new();
-        if let Some(section) = table.remove("anticheat") {
-            only.insert("anticheat".into(), section);
-        }
-        let file: File = only
-            .try_into()
-            .map_err(|e: toml::de::Error| format!("[anticheat]: {e}"))?;
-        file.anticheat.check()?;
-        Ok(file.anticheat)
-    }
-
-    /// Thresholds can't be negative.
-    pub fn check(&self) -> Result<(), String> {
-        for &c in Check::ALL {
-            let a = self.actions(c);
-            if [a.setback, a.alert, a.kick, a.decay]
-                .iter()
-                .any(|v| !v.is_finite() || *v < 0.0)
-            {
-                return Err(format!(
-                    "anticheat.{}: setback, alert, kick and decay are numbers from 0 up",
-                    c.name()
-                ));
-            }
-        }
-        Ok(())
-    }
-}
-
-/// What a flag leads to.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Verdict {
-    /// The check's violation level after the flag.
-    pub vl: f32,
-    /// Cancel the move or action.
-    pub setback: bool,
-    /// Tell operators and the console (at most once a second per check).
-    pub alert: bool,
-    pub kick: bool,
-}
-
-/// One player's anticheat state. Clean players cost nothing: levels only change when a check flags.
-#[derive(Clone, Debug, Default)]
-pub struct Player {
-    vl: [f32; CHECKS],
-    /// The server tick of each check's last flag (its decay runs from there).
-    flagged: [u64; CHECKS],
-    /// The server tick of each check's last alert.
-    alerted: [Option<u64>; CHECKS],
-    pub timer: timer::Balance,
-    /// The server tick and height where the ground last held the player.
-    pub ground: Option<(u64, f64)>,
-}
-
-impl Player {
-    /// The check's violation level at `tick`, with its decay since the last flag.
-    pub fn vl(&self, config: &Config, check: Check, tick: u64) -> f32 {
-        let i = check as usize;
-        let seconds = tick.saturating_sub(self.flagged[i]) as f32 / 20.0;
-        (self.vl[i] - config.actions(check).decay * seconds).max(0.0)
-    }
-
-    /// `check` failed with this weight at server tick `tick`.
-    pub fn flag(&mut self, config: &Config, check: Check, weight: f32, tick: u64) -> Verdict {
-        let i = check as usize;
-        let a = config.actions(check);
-        let vl = self.vl(config, check, tick) + weight;
-        self.vl[i] = vl;
-        self.flagged[i] = tick;
-        let reached = |threshold: f32| threshold > 0.0 && vl >= threshold;
-        let alert = reached(a.alert) && self.alerted[i].is_none_or(|t| tick >= t + 20);
-        if alert {
-            self.alerted[i] = Some(tick);
-        }
-        Verdict {
-            vl,
-            setback: reached(a.setback),
-            alert,
-            kick: reached(a.kick),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn on() -> Config {
-        Config {
-            enabled: true,
-            ..Config::default()
-        }
-    }
-
-    #[test]
-    fn off_by_default_and_without_a_section() {
-        assert!(!Config::default().enabled);
-        let c = Config::from_server_toml("[server]\nport = 25565\n").unwrap();
-        assert_eq!(c, Config::default());
-        assert!(!c.runs(Check::Timer));
-        assert!(!c.runs(Check::Ground));
-    }
-
-    #[test]
-    fn reads_its_section() {
-        let text = "[server]\nport = 1\n[anticheat]\nenabled = true\n[anticheat.timer]\nkick = 0\ntolerance_ms = 500\n";
-        let c = Config::from_server_toml(text).unwrap();
-        assert!(c.runs(Check::Timer));
-        assert_eq!(c.timer.kick, 0.0);
-        assert_eq!(c.timer.tolerance_ms, 500.0);
-        assert_eq!(c.timer.alert, TimerConfig::default().alert);
-        let off = "[anticheat]\nenabled = true\n[anticheat.timer]\nenabled = false\n";
-        assert!(!Config::from_server_toml(off).unwrap().runs(Check::Timer));
-    }
-
-    #[test]
-    fn refuses_unknown_keys_and_negative_levels() {
-        assert!(Config::from_server_toml("[anticheat]\nenable = true\n").is_err());
-        assert!(Config::from_server_toml("[anticheat.timer]\nkick = -1\n").is_err());
-    }
-
-    #[test]
-    fn levels_rise_decay_and_act_in_order() {
-        let mut c = on();
-        c.timer = TimerConfig {
-            setback: 2.0,
-            alert: 3.0,
-            kick: 5.0,
-            decay: 1.0,
-            ..TimerConfig::default()
-        };
-        let mut p = Player::default();
-        let v = p.flag(&c, Check::Timer, 1.0, 100);
-        assert_eq!((v.setback, v.alert, v.kick), (false, false, false));
-        let v = p.flag(&c, Check::Timer, 1.0, 100);
-        assert_eq!((v.vl, v.setback, v.alert), (2.0, true, false));
-        let v = p.flag(&c, Check::Timer, 1.0, 100);
-        assert!(v.alert && !v.kick);
-        // At most one alert a second.
-        assert!(!p.flag(&c, Check::Timer, 0.5, 110).alert);
-        // 3 at tick 110 (half a level gone, half added); two seconds later two more are gone.
-        assert_eq!(p.vl(&c, Check::Timer, 150), 1.0);
-        assert_eq!(p.vl(&c, Check::Timer, 10_000), 0.0);
-        let v = p.flag(&c, Check::Timer, 5.0, 10_000);
-        assert!(v.kick && v.alert);
-    }
-
-    #[test]
-    fn zero_turns_an_action_off() {
-        let mut c = on();
-        c.timer.kick = 0.0;
-        let mut p = Player::default();
-        assert!(!p.flag(&c, Check::Timer, 1000.0, 1).kick);
-    }
-}

crates/horizon-anticheat/src/timer.rs

@@ -1,111 +0,0 @@
-//! The timer check's balance: how far a client's ticks are behind (positive) or ahead (negative) of the
-//! server's clock, in milliseconds.
-//!
-//! The server adds the wall-clock time of each of its ticks, and every ServerboundClientTickEndPacket
-//! takes away the length of one tick at the server's tick rate (vanilla's client ticks at that rate,
-//! `TickRateManager.millisecondsPerTick`). The balance is capped at `max_lag_ms` *after* the tick's
-//! packets are counted: a slow server tick that handles a second of packets at once also added that
-//! second, and a quiet connection banks at most `max_lag_ms` for the burst that ends a lag spike.
-
-use crate::TimerConfig;
-
-#[derive(Clone, Debug, Default)]
-pub struct Balance {
-    pub ms: f64,
-}
-
-impl Balance {
-    /// The start of a server tick that came `elapsed_ms` after the previous one.
-    pub fn elapse(&mut self, elapsed_ms: f64, config: &TimerConfig) {
-        self.ms = self.ms.min(config.max_lag_ms) + elapsed_ms;
-    }
-
-    /// One client tick ended, at a tick rate of `tick_rate` a second. Some(how far ahead, in ms) when the
-    /// client is further ahead than the tolerance; the balance starts again from zero then, so a
-    /// sustained speed-up is flagged again each time it gets that far ahead.
-    pub fn tick_end(&mut self, tick_rate: f32, config: &TimerConfig) -> Option<f64> {
-        self.ms -= 1000.0 / f64::from(tick_rate.max(1.0));
-        if self.ms < -config.tolerance_ms {
-            let ahead = -self.ms;
-            self.ms = 0.0;
-            return Some(ahead);
-        }
-        None
-    }
-
-    /// The tick rate changed or the player arrived: start again.
-    pub fn reset(&mut self) {
-        self.ms = 0.0;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// `seconds` of server ticks of `server_ms` each, with `per_tick` client ticks handled in each.
-    fn run(b: &mut Balance, server_ms: f64, per_tick: f64, seconds: f64) -> usize {
-        let c = TimerConfig::default();
-        let mut owed = 0.0;
-        let mut flags = 0;
-        for _ in 0..(seconds * 1000.0 / server_ms) as usize {
-            b.elapse(server_ms, &c);
-            owed += per_tick;
-            while owed >= 1.0 {
-                owed -= 1.0;
-                flags += usize::from(b.tick_end(20.0, &c).is_some());
-            }
-        }
-        flags
-    }
-
-    #[test]
-    fn a_vanilla_client_is_never_flagged() {
-        let mut b = Balance::default();
-        assert_eq!(run(&mut b, 50.0, 1.0, 600.0), 0);
-        // A server that runs at 10 ticks a second handles two client ticks in each.
-        assert_eq!(run(&mut b, 100.0, 2.0, 600.0), 0);
-    }
-
-    #[test]
-    fn a_slow_server_tick_with_its_backlog_is_not_flagged() {
-        let (mut b, c) = (Balance::default(), TimerConfig::default());
-        b.elapse(3000.0, &c);
-        for _ in 0..60 {
-            assert_eq!(b.tick_end(20.0, &c), None);
-        }
-    }
-
-    #[test]
-    fn a_short_network_stall_is_not_flagged() {
-        let (mut b, c) = (Balance::default(), TimerConfig::default());
-        // 800 ms with nothing arriving, then the 16 ticks sent meanwhile.
-        for _ in 0..16 {
-            b.elapse(50.0, &c);
-        }
-        b.elapse(50.0, &c);
-        for _ in 0..17 {
-            assert_eq!(b.tick_end(20.0, &c), None);
-        }
-    }
-
-    #[test]
-    fn a_sped_up_client_is_flagged_again_and_again() {
-        let mut b = Balance::default();
-        // 10 % faster: 5 ms ahead each tick, 300 ms after 3 s, so close to 20 flags a minute.
-        let flags = run(&mut b, 50.0, 1.1, 60.0);
-        assert!((15..=20).contains(&flags), "{flags}");
-        // Twice as fast: a flag every 7 ticks.
-        assert!(run(&mut Balance::default(), 50.0, 2.0, 10.0) >= 25);
-    }
-
-    #[test]
-    fn a_pause_cant_be_saved_for_a_burst() {
-        let (mut b, c) = (Balance::default(), TimerConfig::default());
-        for _ in 0..200 {
-            b.elapse(50.0, &c);
-        }
-        let flagged = (0..60).any(|_| b.tick_end(20.0, &c).is_some());
-        assert!(flagged);
-    }
-}

crates/horizon-assets/src/blockstate/choice.rs

@@ -4,15 +4,15 @@ use crate::json::{Result, error};
 use horizon_core::random::RandomSource;
 
 #[derive(Clone, Debug)]
-enum Choice<T> {
-    Single(T),
+enum Choice {
+    Single(Variant),
     Weighted {
-        variants: Vec<T>,
+        variants: Vec<Variant>,
         ends: Vec<i32>,
         total: i32,
     },
 }
-impl Choice<Variant> {
+impl Choice {
     fn new(value: &VariantSet) -> Result<Self> {
         match value {
             VariantSet::Single(value) => Ok(Self::Single(value.clone())),
@@ -41,23 +41,7 @@ impl Choice<Variant> {
             }
         }
     }
-}
-impl<T> Choice<T> {
-    fn map<U>(&self, f: &mut impl FnMut(&T) -> U) -> Choice<U> {
-        match self {
-            Self::Single(value) => Choice::Single(f(value)),
-            Self::Weighted {
-                variants,
-                ends,
-                total,
-            } => Choice::Weighted {
-                variants: variants.iter().map(&mut *f).collect(),
-                ends: ends.clone(),
-                total: *total,
-            },
-        }
-    }
-    fn select(&self, random: &mut impl RandomSource) -> &T {
+    fn select(&self, random: &mut impl RandomSource) -> &Variant {
         match self {
             Self::Single(value) => value,
             Self::Weighted {
@@ -76,11 +60,10 @@ impl<T> Choice<T> {
 }
 /// Compile once per definition and share across its bound block states. Prefix
 /// sums avoid rebuilding weight totals or scanning all entries during selection.
-/// `map` swaps each variant for what it stands for (its baked model).
 #[derive(Clone, Debug)]
-pub struct CompiledChoices<T = Variant> {
-    variants: Vec<Choice<T>>,
-    multipart: Vec<Choice<T>>,
+pub struct CompiledChoices {
+    variants: Vec<Choice>,
+    multipart: Vec<Choice>,
 }
 impl CompiledChoices {
     pub fn new(definition: &BlockStateDefinition) -> Result<Self> {
@@ -99,19 +82,10 @@ impl CompiledChoices {
                 .collect::<Result<_>>()?,
         })
     }
-}
-impl<T> CompiledChoices<T> {
-    /// The same choices, with `f` of each variant in its place.
-    pub fn map<U>(&self, mut f: impl FnMut(&T) -> U) -> CompiledChoices<U> {
-        CompiledChoices {
-            variants: self.variants.iter().map(|c| c.map(&mut f)).collect(),
-            multipart: self.multipart.iter().map(|c| c.map(&mut f)).collect(),
-        }
-    }
     /// The variant `particleMaterial` comes from: the first entry of a weighted
     /// list (`WeightedVariants`) and, for a multipart root, of its first
     /// selector whether or not that selector applies (`MultiPartModel`).
-    pub fn particle_variant(&self, selected: &SelectedModels) -> Option<&T> {
+    pub fn particle_variant(&self, selected: &SelectedModels) -> Option<&Variant> {
         let choice = match selected {
             SelectedModels::Variant(index) => self.variants.get(*index)?,
             SelectedModels::Multipart(_) => self.multipart.first()?,
@@ -121,23 +95,14 @@ impl<T> CompiledChoices<T> {
             Choice::Weighted { variants, .. } => variants.first()?,
         })
     }
-    /// Append selected variants without allocating intermediate part lists.
+    /// Append selected variants without allocating intermediate part lists. A
+    /// multipart root consumes nextLong even for an empty selected subset, then
+    /// resets the same random source to that seed before each selected part.
     pub fn collect<'a>(
         &'a self,
         selected: &SelectedModels,
         random: &mut impl RandomSource,
-        output: &mut Vec<&'a T>,
-    ) -> Result<()> {
-        self.for_each(selected, random, |v| output.push(v))
-    }
-    /// Each selected variant, in order. A multipart root consumes nextLong
-    /// even for an empty selected subset, then resets the same random source
-    /// to that seed before each selected part.
-    pub fn for_each<'a>(
-        &'a self,
-        selected: &SelectedModels,
-        random: &mut impl RandomSource,
-        mut f: impl FnMut(&'a T),
+        output: &mut Vec<&'a Variant>,
     ) -> Result<()> {
         match selected {
             SelectedModels::Variant(index) => {
@@ -145,7 +110,7 @@ impl<T> CompiledChoices<T> {
                     .variants
                     .get(*index)
                     .ok_or_else(|| error("invalid variant selection"))?;
-                f(choice.select(random));
+                output.push(choice.select(random));
             }
             SelectedModels::Multipart(indices) => {
                 if indices.iter().any(|index| *index >= self.multipart.len()) {
@@ -154,7 +119,7 @@ impl<T> CompiledChoices<T> {
                 let seed = random.next_long();
                 for index in indices {
                     random.set_seed(seed);
-                    f(self.multipart[*index].select(random));
+                    output.push(self.multipart[*index].select(random));
                 }
             }
         }

crates/horizon-assets/src/item_model.rs

@@ -1031,22 +1031,19 @@ pub struct ItemModels {
 }
 
 impl ItemModels {
-    /// The stack's components: its item's defaults with the stack's patch on top. A stack
-    /// with no patch (most stacks a screen draws) borrows the defaults instead of copying them.
-    pub fn components(&self, stack: &StackView) -> std::borrow::Cow<'_, Components> {
-        static NONE: Components = BTreeMap::new();
-        let prototype = self.prototypes.get(&stack.item).unwrap_or(&NONE);
-        if stack.patch.is_empty() {
-            return std::borrow::Cow::Borrowed(prototype);
-        }
-        let mut out = prototype.clone();
+    pub fn components(&self, stack: &StackView) -> Components {
+        let mut out = self
+            .prototypes
+            .get(&stack.item)
+            .cloned()
+            .unwrap_or_default();
         for (key, value) in &stack.patch {
             match value {
                 Some(v) => out.insert(key.clone(), v.clone()),
                 None => out.remove(key),
             };
         }
-        std::borrow::Cow::Owned(out)
+        out
     }
     /// `ItemModelResolver.updateForTopItem`.
     pub fn resolve(&self, stack: &StackView, ctx: &Context, env: &dyn ItemEnv) -> ResolvedItem {

crates/horizon-bench/Cargo.toml

@@ -8,5 +8,3 @@ description = "The benchmark report format (docs/benchmark-report.md), shared by
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-# The hardware probes shared with telemetry (cores, clocks, drive, VRAM, power, form).
-horizon-telemetry = { path = "../horizon-telemetry", default-features = false }

crates/horizon-bench/src/hardware.rs

@@ -1,7 +1,8 @@
 //! The machine a report was measured on. CPU, RAM and OS are detected here; the GPU and the display
 //! come from the program that rendered (the game knows its adapter, the launcher its window).
 
-use horizon_telemetry::system::command_output as output;
+use std::process::Command;
+
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
@@ -15,22 +16,8 @@ pub struct Hardware {
     pub cpu: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub cpu_threads: Option<usize>,
-    /// Physical cores.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub cpu_cores: Option<u16>,
-    /// Base and top boost clock, where the OS gives them.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub cpu_base_mhz: Option<u32>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub cpu_boost_mhz: Option<u32>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub ram_mb: Option<u64>,
-    /// The drive under the game folder: `nvme`, `ssd` or `hdd`.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub storage: Option<String>,
-    /// `laptop` or `desktop`.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub form: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub gpu: Option<Gpu>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -46,9 +33,6 @@ pub struct Gpu {
     pub backend: String,
     /// `integrated`, `discrete`, `virtual`, `cpu`, `other`.
     pub kind: String,
-    /// Its own memory in MiB (rounded to 256), for a discrete GPU whose driver says.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub vram_mb: Option<u32>,
 }
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
@@ -63,50 +47,17 @@ pub struct Display {
 
 impl Hardware {
     pub fn detect() -> Hardware {
-        let probes = probes();
         Hardware {
             os: std::env::consts::OS.to_owned(),
             os_version: os_version(),
             arch: std::env::consts::ARCH.to_owned(),
             cpu: cpu(),
             cpu_threads: std::thread::available_parallelism().ok().map(|n| n.get()),
-            cpu_cores: probes.cores,
-            cpu_base_mhz: probes.base,
-            cpu_boost_mhz: probes.boost,
             ram_mb: ram_bytes().map(|b| b >> 20),
-            storage: None,
-            form: probes.form,
             gpu: None,
             display: None,
         }
     }
-
-    /// [`Hardware::detect`] with the kind of drive `game_dir` is on.
-    pub fn detect_in(game_dir: &std::path::Path) -> Hardware {
-        Hardware {
-            storage: horizon_telemetry::system::storage(game_dir).map(str::to_owned),
-            ..Hardware::detect()
-        }
-    }
-}
-
-/// What the telemetry probes read (`horizon_telemetry::system`).
-struct Probes {
-    cores: Option<u16>,
-    base: Option<u32>,
-    boost: Option<u32>,
-    form: Option<String>,
-}
-
-fn probes() -> Probes {
-    let s = horizon_telemetry::payload::System::detect();
-    let some = |n: u32| (n > 0).then_some(n);
-    Probes {
-        cores: (s.cores > 0).then_some(s.cores),
-        base: some(s.cpu_base_mhz),
-        boost: some(s.cpu_boost_mhz),
-        form: (!s.form.is_empty()).then_some(s.form),
-    }
 }
 
 /// The one-minute load average: above about the number of threads the machine was busy.
@@ -131,7 +82,25 @@ pub fn load_average() -> Option<f64> {
 
 /// `ac` or `battery`; `None` where it can't be read (and on machines without a battery on Linux).
 pub fn power_source() -> Option<&'static str> {
-    horizon_telemetry::system::power()
+    if cfg!(target_os = "macos") {
+        let batt = output("pmset", &["-g", "batt"])?;
+        return Some(if batt.contains("'Battery Power'") {
+            "battery"
+        } else {
+            "ac"
+        });
+    }
+    let mut on_battery = None;
+    for entry in std::fs::read_dir("/sys/class/power_supply").ok()?.flatten() {
+        let read =
+            |name: &str| std::fs::read_to_string(entry.path().join(name)).unwrap_or_default();
+        match read("type").trim() {
+            "Mains" if read("online").trim() == "1" => return Some("ac"),
+            "Battery" => on_battery = Some("battery"),
+            _ => {}
+        }
+    }
+    on_battery
 }
 
 /// Resident memory of a process, in bytes (macOS, Linux).
@@ -172,6 +141,12 @@ pub fn cpu_seconds(pid: u32) -> Option<f64> {
     Some(ticks / 100.0)
 }
 
+fn output(program: &str, args: &[&str]) -> Option<String> {
+    let out = Command::new(program).args(args).output().ok()?;
+    let text = String::from_utf8(out.stdout).ok()?.trim().to_owned();
+    (out.status.success() && !text.is_empty()).then_some(text)
+}
+
 #[cfg(target_os = "macos")]
 fn os_version() -> Option<String> {
     output("sw_vers", &["-productVersion"])

crates/horizon-bench/src/lib.rs

@@ -245,19 +245,13 @@ pub struct Report {
 impl Report {
     /// An empty report for this machine, created now.
     pub fn new(kind: Kind, app: App) -> Report {
-        Self::with_hardware(kind, app, Hardware::detect())
-    }
-
-    /// Starts a report using supplied hardware, without running system probes.
-    /// Interactive apps can collect the remaining machine details after their first frame.
-    pub fn with_hardware(kind: Kind, app: App, hardware: Hardware) -> Report {
         Report {
             format: FORMAT.to_owned(),
             version: VERSION,
             kind,
             created: utc_now(),
             app,
-            hardware,
+            hardware: Hardware::detect(),
             conditions: Conditions::default(),
             metrics: BTreeMap::new(),
             frames: Vec::new(),

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,75 +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
-  --height H             blocks above spawn the bots fly at (walk, explore, idle); default 24
-  --ground               claim the ground in every move (with --height 0 on a flat world: walking
-                         on it; higher, or over water: a no-fall or jesus cheat, to test an anticheat)
-  --timer F              cheat, to test an anticheat: tick F times as fast as vanilla's client (1.5: 30 Hz)
   --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",
         }
     }
 }
@@ -128,19 +81,8 @@ 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,
-    height: f64,
-    ground: bool,
     name: String,
-    /// The `minecraft:brand` to send, if any.
-    brand: Option<String>,
     report: Option<String>,
-    /// How many times as fast as vanilla's 20 Hz the bots tick (a timer cheat above 1).
-    timer: f64,
 }
 
 fn options() -> Result<Options, String> {
@@ -154,16 +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,
-        height: 24.0,
-        ground: false,
         name: "Bot".into(),
         report: None,
-        brand: None,
-        timer: 1.0,
     };
     let mut args = std::env::args().skip(1);
     while let Some(arg) = args.next() {
@@ -171,14 +105,6 @@ fn options() -> Result<Options, String> {
             print!("{HELP}");
             std::process::exit(0);
         }
-        if arg == "--no-read" {
-            o.no_read = true;
-            continue;
-        }
-        if arg == "--ground" {
-            o.ground = 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() {
@@ -196,42 +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),
-            "--height" => o.height = value.parse().map_err(|_| number("blocks"))?,
-            "--timer" => {
-                o.timer = value.parse().map_err(|_| number("a speed, like 1.5"))?;
-                if !(o.timer >= 0.1 && o.timer <= 20.0) {
-                    return Err(format!("--timer {value}: use 0.1 to 20"));
-                }
-            }
             _ => 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
         ));
     }
@@ -258,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.
@@ -282,11 +173,6 @@ impl Random {
     }
 }
 
-/// One bot thread that panics poisons the locks it held; the others and the report go on.
-fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
-    m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
-}
-
 fn raw(id: i32, write: impl FnOnce(&mut Writer)) -> Vec<u8> {
     let mut w = Writer::new();
     w.varint(id);
@@ -294,89 +180,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()
 }
@@ -444,19 +247,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 {
@@ -484,9 +274,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())
@@ -540,22 +329,16 @@ fn read(
 ) {
     use ids::play::clientbound as cb;
     use ids::play::serverbound as sb;
-    let send = |body: Vec<u8>| lock(&writer).send(&body);
+    let send = |body: Vec<u8>| writer.lock().unwrap().send(&body);
     let mut seen = HashSet::new();
     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) => {
                 if bot.online.swap(false, Ordering::SeqCst) {
-                    *lock(&bot.error) = Some(e.to_string());
+                    *bot.error.lock().unwrap() = Some(e.to_string());
                 }
                 return;
             }
@@ -573,7 +356,7 @@ fn read(
             cb::LEVEL_CHUNK_WITH_LIGHT => {
                 bot.chunks.fetch_add(1, Ordering::Relaxed);
                 if let (Ok(x), Ok(z)) = (r.i32(), r.i32()) {
-                    if !lock(&bot.held).insert((x, z)) {
+                    if !bot.held.lock().unwrap().insert((x, z)) {
                         bot.resent.fetch_add(1, Ordering::Relaxed);
                     }
                     if seen.insert((x, z)) {
@@ -585,27 +368,12 @@ fn read(
             cb::FORGET_LEVEL_CHUNK => {
                 if let Ok(play::Clientbound::ForgetLevelChunk(p)) =
                     play::Clientbound::decode(id, &body)
-                    && lock(&bot.held).remove(&(p.pos[0], p.pos[1]))
+                    && bot.held.lock().unwrap().remove(&(p.pos[0], p.pos[1]))
                 {
                     bot.forgotten.fetch_add(1, Ordering::Relaxed);
                 }
                 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(())
@@ -621,7 +389,7 @@ fn read(
             }
             cb::PLAYER_POSITION => match play::Clientbound::decode(id, &body) {
                 Ok(play::Clientbound::PlayerPosition(p)) => {
-                    let mut at = lock(&bot.teleport);
+                    let mut at = bot.teleport.lock().unwrap();
                     let previous = at.unwrap_or([0.0; 3]);
                     // Relative flags: X 1, Y 2, Z 4.
                     let pos: [f64; 3] = std::array::from_fn(|i| {
@@ -652,7 +420,7 @@ fn read(
             },
             cb::DISCONNECT | cb::START_CONFIGURATION => {
                 bot.online.store(false, Ordering::SeqCst);
-                *lock(&bot.error) = Some(if id == cb::DISCONNECT {
+                *bot.error.lock().unwrap() = Some(if id == cb::DISCONNECT {
                     format!(
                         "disconnected: {}",
                         String::from_utf8_lossy(&body)
@@ -687,13 +455,12 @@ fn run_bot(
     let connection = match join(&o, &name) {
         Ok(c) => c,
         Err(e) => {
-            *lock(&bot.error) = Some(e);
+            *bot.error.lock().unwrap() = Some(e);
             return;
         }
     };
     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());
@@ -702,12 +469,12 @@ fn run_bot(
     use ids::play::serverbound as sb;
     // Wait for the spawn position.
     let spawn = loop {
-        if let Some(at) = *lock(&bot.teleport) {
+        if let Some(at) = *bot.teleport.lock().unwrap() {
             break at;
         }
         if !bot.online.load(Ordering::SeqCst) || asked.elapsed() > Duration::from_secs(60) {
-            if lock(&bot.error).is_none() {
-                *lock(&bot.error) = Some("no spawn position within 60 s".into());
+            if bot.error.lock().unwrap().is_none() {
+                *bot.error.lock().unwrap() = Some("no spawn position within 60 s".into());
             }
             return;
         }
@@ -715,82 +482,32 @@ fn run_bot(
     };
     bot.joined_after_ms
         .store(asked.elapsed().as_millis() as u64, Ordering::SeqCst);
-    let send = |body: Vec<u8>| lock(&writer).send(&body).is_ok();
+    let send = |body: Vec<u8>| writer.lock().unwrap().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] + o.height;
+    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) {
+        if until.lock().unwrap().is_some_and(|u| Instant::now() >= u)
+            || !bot.online.load(Ordering::SeqCst)
+        {
             break;
         }
         // A teleport from the server wins over where the bot thought it was.
-        if let Some(at) = lock(&bot.teleport).take() {
+        if let Some(at) = bot.teleport.lock().unwrap().take() {
             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 !bot.held.lock().unwrap().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);
@@ -809,37 +526,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;
@@ -848,28 +535,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 || o.ground),
+                flags: 0,
             })
             .encode(),
         ) && send(raw(sb::CLIENT_TICK_END, |_| {}));
@@ -877,7 +548,7 @@ fn run_bot(
             bot.online.store(false, Ordering::SeqCst);
             break;
         }
-        next += Duration::from_secs_f64(0.05 / o.timer);
+        next += Duration::from_millis(50);
         let now = Instant::now();
         if next > now {
             thread::sleep(next - now);
@@ -887,25 +558,14 @@ fn run_bot(
     }
     // Offline first, so the reader doesn't count the closed connection as a failure.
     bot.online.store(false, Ordering::SeqCst);
-    lock(&writer).shutdown();
+    writer.lock().unwrap().shutdown();
 }
 
 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,
@@ -952,10 +612,13 @@ fn main() {
         let total = |f: fn(&Bot) -> &AtomicU64| -> u64 {
             bots.iter().map(|b| f(b).load(Ordering::Relaxed)).sum()
         };
-        let failed = bots.iter().filter(|b| lock(&b.error).is_some()).count();
+        let failed = bots
+            .iter()
+            .filter(|b| b.error.lock().unwrap().is_some())
+            .count();
         if first.is_none() && online > 0 {
             first = Some(Instant::now());
-            *lock(&until) = Some(Instant::now() + Duration::from_secs(o.seconds));
+            *until.lock().unwrap() = Some(Instant::now() + Duration::from_secs(o.seconds));
         }
         println!(
             "{}",
@@ -973,10 +636,10 @@ fn main() {
             })
         );
         previous_chunks = chunks;
-        let over = lock(&until).is_some_and(|u| Instant::now() >= u);
+        let over = until.lock().unwrap().is_some_and(|u| Instant::now() >= u);
         let all_failed = failed == o.bots;
         if over || all_failed || (first.is_none() && start.elapsed() > Duration::from_secs(120)) {
-            *lock(&until) = Some(Instant::now());
+            *until.lock().unwrap() = Some(Instant::now());
             break;
         }
     }
@@ -1006,9 +669,7 @@ fn main() {
             "forgotten": b.forgotten.load(Ordering::Relaxed),
             "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),
+            "error": *b.error.lock().unwrap(),
         })).collect::<Vec<_>>(),
     });
     if o.report.as_deref() == Some("-") {

crates/horizon-client-core/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "horizon-client-core"
-version = "0.1.0"
-edition.workspace = true
-license.workspace = true
-rust-version = "1.90"
-description = "The client's lowest layer: chat text and translations, SNBT and NBT paths, the scoreboard, boss bars, game rules and the registry and particle tables commands name"
-
-[dependencies]
-horizon-world = { path = "../horizon-world" }
-serde_json = { version = "1.0.151", features = ["raw_value"] }
-
-[lints]
-workspace = true

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

@@ -1,552 +0,0 @@
-//! 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 serde_json::{Map, Value};
-
-/// `SnbtGrammar`, enough for components: compounds, lists, quoted and
-/// unquoted strings, numbers (with type suffixes) and booleans. Returns the
-/// value and the bytes consumed.
-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) {
-        while self.i < self.s.len() && self.s[self.i].is_ascii_whitespace() {
-            self.i += 1;
-        }
-    }
-    fn peek(&self) -> Option<u8> {
-        self.s.get(self.i).copied()
-    }
-    fn expect(&mut self, c: u8) -> Result<(), String> {
-        self.ws();
-        if self.peek() == Some(c) {
-            self.i += 1;
-            Ok(())
-        } else {
-            Err(format!("expected '{}'", c as char))
-        }
-    }
-    fn value(&mut self) -> Result<Value, String> {
-        self.ws();
-        match self.peek() {
-            Some(b'{') => {
-                if self.depth >= SNBT_MAX_DEPTH {
-                    return Err(format!("tag nesting too deep at {}", self.i));
-                }
-                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.depth += 1;
-                let v = self.array();
-                self.depth -= 1;
-                v
-            }
-            Some(b'"' | b'\'') => Ok(Value::String(self.string()?)),
-            Some(_) => {
-                let word = self.unquoted();
-                if word.is_empty() {
-                    return Err("expected a value".into());
-                }
-                Ok(match word.as_str() {
-                    "true" => Value::Bool(true),
-                    "false" => Value::Bool(false),
-                    _ => {
-                        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),
-                            }
-                        }
-                    }
-                })
-            }
-            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() {
-            if c.is_ascii_alphanumeric() || matches!(c, b'_' | b'-' | b'.' | b'+') {
-                self.i += 1;
-            } else {
-                break;
-            }
-        }
-        String::from_utf8_lossy(&self.s[start..self.i]).into_owned()
-    }
-    fn string(&mut self) -> Result<String, String> {
-        self.ws();
-        let Some(q @ (b'"' | b'\'')) = self.peek() else {
-            return Ok(self.unquoted());
-        };
-        self.i += 1;
-        let mut out = Vec::new();
-        while let Some(c) = self.peek() {
-            self.i += 1;
-            match c {
-                b'\\' => {
-                    let Some(e) = self.peek() else { break };
-                    self.i += 1;
-                    out.push(match e {
-                        b'n' => b'\n',
-                        b't' => b'\t',
-                        other => other,
-                    });
-                }
-                c if c == q => return Ok(String::from_utf8_lossy(&out).into_owned()),
-                c => out.push(c),
-            }
-        }
-        Err("unterminated string".into())
-    }
-}
-/// The style fields of a component object.
-fn object_style(o: &serde_json::Map<String, Value>) -> Style {
-    let mut style = Style::default();
-    if let Some(c) = o.get("color").and_then(Value::as_str) {
-        style.color = named_color(c).or_else(|| {
-            c.strip_prefix('#')
-                .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");
-    style.underlined = flag("underlined");
-    style.strikethrough = flag("strikethrough");
-    style.obfuscated = flag("obfuscated");
-    style.font = o.get("font").and_then(crate::text::font_id);
-    // ClickEvent.CODEC: the actions a chat line acts on here. A component
-    // from a server never opens a file.
-    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())));
-            }
-            _ => {}
-        }
-    }
-    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 {
-    to_text_with(v, resolve, &mut |_| None)
-}
-/// `to_text` with a hook resolving other contents (`nbt`) from the object.
-pub fn to_text_with(
-    v: &Value,
-    resolve: &mut dyn FnMut(&str) -> Text,
-    contents: &mut dyn FnMut(&serde_json::Map<String, Value>) -> Option<Text>,
-) -> Text {
-    match v {
-        Value::String(s) => Text::literal(s.clone()),
-        Value::Number(n) => Text::literal(n.to_string()),
-        Value::Bool(b) => Text::literal(b.to_string()),
-        // A list is its first element with the rest as siblings.
-        Value::Array(list) => {
-            let Some((first, rest)) = list.split_first() else {
-                return Text::empty();
-            };
-            let mut base = to_text_with(first, resolve, contents);
-            // The siblings take the first component's own style, even when
-            // its text is empty.
-            let style = match first {
-                Value::Object(o) => object_style(o),
-                _ => base
-                    .spans
-                    .first()
-                    .map(|s| s.style.clone())
-                    .unwrap_or_default(),
-            };
-            for sibling in rest {
-                base.push(to_text_with(sibling, resolve, contents).with_style(&style));
-            }
-            base
-        }
-        Value::Object(o) => {
-            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()),
-                    other => Text::literal(other.to_string()),
-                }
-            } else if let Some(key) = o.get("translate").and_then(Value::as_str) {
-                let args: Vec<Text> = o
-                    .get("with")
-                    .and_then(Value::as_array)
-                    .map(|a| {
-                        a.iter()
-                            .map(|x| to_text_with(x, resolve, contents))
-                            .collect()
-                    })
-                    .unwrap_or_default();
-                let translated = Text::translate(key, &args);
-                match o.get("fallback").and_then(Value::as_str) {
-                    Some(fallback) if translated.plain() == key => Text::translate(fallback, &args),
-                    _ => translated,
-                }
-            } else if let Some(sel) = o.get("selector").and_then(Value::as_str) {
-                resolve(sel)
-            } else if let Some(key) = o.get("keybind").and_then(Value::as_str) {
-                crate::key_display::display_name(key)
-            } else {
-                Text::empty()
-            };
-            let mut out = content.with_style(&style);
-            for extra in o
-                .get("extra")
-                .and_then(Value::as_array)
-                .into_iter()
-                .flatten()
-            {
-                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
-            }
-        }
-        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";
-        let (v, n) = parse_snbt(input).unwrap();
-        assert_eq!(&input[n..], " rest");
-        let t = to_text(&v, &mut |_| Text::empty());
-        assert_eq!(t.plain(), "Hi there");
-        assert_eq!(t.spans[1].style.color, named_color("red"));
-        let (v, _) = parse_snbt("[\"a\",{\"text\":\"b\"}]").unwrap();
-        assert_eq!(to_text(&v, &mut |_| Text::empty()).plain(), "ab");
-    }
-
-    #[test]
-    fn the_font_is_inherited_and_kept() {
-        let (v, _) =
-            parse_snbt(r#"{text:"a",font:"alt",extra:["b",{text:"c",font:"minecraft:uniform"}]}"#)
-                .unwrap();
-        let t = to_text(&v, &mut |_| Text::empty());
-        let fonts: Vec<_> = t.chars().map(|(_, s)| s.font.clone()).collect();
-        let (alt, uniform) = (
-            Some("minecraft:alt".into()),
-            Some("minecraft:uniform".into()),
-        );
-        assert_eq!(fonts, [alt.clone(), alt, uniform]);
-        // Back to JSON with the field, which a re-read keeps.
-        let again = to_text(&t.component(), &mut |_| Text::empty());
-        let kept: Vec<_> = again.chars().map(|(_, s)| s.font.clone()).collect();
-        assert_eq!(kept, fonts);
-        // Not an identifier: no font.
-        let (v, _) = parse_snbt(r#"{text:"a",font:"Bad Font"}"#).unwrap();
-        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

@@ -1,35 +0,0 @@
-//! Resource identifiers (`Identifier`).
-
-/// Identifier.parse: `ns:path` or `path`, validated.
-pub fn parse_identifier(raw: &str) -> Option<String> {
-    let (ns, path) = match raw.split_once(':') {
-        Some(("", path)) => ("minecraft", path),
-        Some((ns, path)) => (ns, path),
-        None => ("minecraft", raw),
-    };
-    let ns_ok = ns != ".."
-        && ns
-            .chars()
-            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-'));
-    let path_ok = path.chars().all(|c| {
-        c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-' | '/')
-    });
-    (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/key_display.rs

@@ -1,107 +0,0 @@
-//! Key display names (`InputConstants.Key.getDisplayName`), shared by key
-//! mappings and `keybind` text components.
-use crate::text::Text;
-use std::{collections::BTreeMap, sync::RwLock};
-
-/// The keys that write a symbol, with what they write on a US layout.
-const SYMBOLS: [(&str, &str); 11] = [
-    ("key.keyboard.minus", "-"),
-    ("key.keyboard.equal", "="),
-    ("key.keyboard.left.bracket", "["),
-    ("key.keyboard.right.bracket", "]"),
-    ("key.keyboard.backslash", "\\"),
-    ("key.keyboard.semicolon", ";"),
-    ("key.keyboard.apostrophe", "'"),
-    ("key.keyboard.grave.accent", "`"),
-    ("key.keyboard.comma", ","),
-    ("key.keyboard.period", "."),
-    ("key.keyboard.slash", "/"),
-];
-
-/// What the player's keyboard layout writes on each key that writes
-/// something, by key name, as the window reported it (`learn_layout`).
-static LAYOUT: RwLock<BTreeMap<String, String>> = RwLock::new(BTreeMap::new());
-
-/// The keyboard layout writes `text` on the key `key` (`key.keyboard.q`):
-/// its name from now on, as `SDL_GetKeyFromScancode` names it with SDL's
-/// default keycode options. Only letter and symbol keys take it; a letter
-/// key keeps its Latin letter on a non-Latin layout (`latin_letters`), and
-/// the number row keeps its digits (`french_numbers`).
-pub fn learn_layout(key: &str, text: &str) {
-    let Some(rest) = key.strip_prefix("key.keyboard.") else {
-        return;
-    };
-    let mut chars = text.chars();
-    let (Some(c), None) = (chars.next(), chars.next()) else {
-        return;
-    };
-    let letter_key = rest.len() == 1 && rest.as_bytes()[0].is_ascii_lowercase();
-    let latin = c.is_ascii() || ('\u{C0}'..='\u{24F}').contains(&c);
-    if c.is_control()
-        || c.is_whitespace()
-        || !(letter_key || SYMBOLS.iter().any(|(k, _)| *k == key))
-        || (letter_key && c.is_alphabetic() && !latin)
-    {
-        return;
-    }
-    if let Ok(mut layout) = LAYOUT.write() {
-        layout.insert(key.to_owned(), c.to_uppercase().collect());
-    }
-}
-
-/// InputConstants.Key.getDisplayName: what the layout writes on the key,
-/// upper-case, else the US layout's character, else by translation.
-pub fn display_name(key: &str) -> Text {
-    if let Some(label) = LAYOUT.read().ok().and_then(|l| l.get(key).cloned()) {
-        return Text::literal(label);
-    }
-    if let Some(rest) = key.strip_prefix("key.keyboard.")
-        && rest.chars().count() == 1
-    {
-        let c = rest.to_uppercase();
-        return Text::literal(c);
-    }
-    if let Some((_, s)) = SYMBOLS.iter().find(|(k, _)| *k == key) {
-        return Text::literal(*s);
-    }
-    if let Some(n) = key.strip_prefix("key.mouse.")
-        && n.parse::<u32>().is_ok()
-        && !crate::lang::has(key)
-    {
-        return Text::translate("key.mouse", &[Text::literal(n)]);
-    }
-    Text::translate(key, &[])
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn keys_show_what_the_layout_writes() {
-        // The layout table is shared: these keys are this test's alone.
-        assert_eq!(display_name("key.keyboard.q").plain(), "Q");
-        // AZERTY: A on the Q key, M on the semicolon key, a dead ^ on the
-        // left bracket, a comma on the M key.
-        learn_layout("key.keyboard.q", "a");
-        learn_layout("key.keyboard.semicolon", "m");
-        learn_layout("key.keyboard.left.bracket", "^");
-        learn_layout("key.keyboard.m", ",");
-        assert_eq!(display_name("key.keyboard.q").plain(), "A");
-        assert_eq!(display_name("key.keyboard.semicolon").plain(), "M");
-        assert_eq!(display_name("key.keyboard.left.bracket").plain(), "^");
-        assert_eq!(display_name("key.keyboard.m").plain(), ",");
-        // The number row keeps its digits; a Cyrillic letter, nothing
-        // printable and keys that write nothing are left alone.
-        learn_layout("key.keyboard.1", "&");
-        learn_layout("key.keyboard.f", "а");
-        learn_layout("key.keyboard.g", "\u{8}");
-        learn_layout("key.keyboard.tab", "\t");
-        learn_layout("key.keyboard.h", "ab");
-        assert_eq!(display_name("key.keyboard.1").plain(), "1");
-        assert_eq!(display_name("key.keyboard.f").plain(), "F");
-        assert_eq!(display_name("key.keyboard.g").plain(), "G");
-        assert_eq!(display_name("key.keyboard.h").plain(), "H");
-        assert_eq!(display_name("key.keyboard.slash").plain(), "/");
-    }
-}

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

@@ -1,28 +0,0 @@
-//! 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`, ...).
-#![forbid(unsafe_code)]
-pub mod block_entity_nbt;
-pub mod bossbar;
-pub mod component;
-pub mod fastutil_order;
-pub mod gamerules;
-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

@@ -1,221 +0,0 @@
-//! Particle types (`ParticleTypes`): the vanilla particle types with a client
-//! implementation, by registry name, and their per-type flags.
-
-macro_rules! particle_types {
-    ($($variant:ident = $name:literal),* $(,)?) => {
-        /// Vanilla particle types with a client implementation here.
-        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-        pub enum ParticleType { $($variant),* }
-        impl ParticleType {
-            pub const ALL: &'static [ParticleType] = &[$(ParticleType::$variant),*];
-            /// Registry path (`minecraft:<name>`), also the sprite-set file name.
-            pub fn name(self) -> &'static str {
-                match self { $(ParticleType::$variant => $name),* }
-            }
-            pub fn from_name(name: &str) -> Option<Self> {
-                let name = name.strip_prefix("minecraft:").unwrap_or(name);
-                match name { $($name => Some(ParticleType::$variant),)* _ => None }
-            }
-        }
-    };
-}
-particle_types! {
-    Block = "block",
-    BlockCrumble = "block_crumble",
-    Trail = "trail",
-    DustPillar = "dust_pillar",
-    FallingDust = "falling_dust",
-    Smoke = "smoke",
-    LargeSmoke = "large_smoke",
-    WhiteSmoke = "white_smoke",
-    Flame = "flame",
-    SoulFireFlame = "soul_fire_flame",
-    CopperFireFlame = "copper_fire_flame",
-    SmallFlame = "small_flame",
-    Lava = "lava",
-    DrippingWater = "dripping_water",
-    FallingWater = "falling_water",
-    DrippingLava = "dripping_lava",
-    FallingLava = "falling_lava",
-    LandingLava = "landing_lava",
-    DrippingHoney = "dripping_honey",
-    FallingHoney = "falling_honey",
-    LandingHoney = "landing_honey",
-    FallingNectar = "falling_nectar",
-    FallingSporeBlossom = "falling_spore_blossom",
-    SporeBlossomAir = "spore_blossom_air",
-    DrippingObsidianTear = "dripping_obsidian_tear",
-    FallingObsidianTear = "falling_obsidian_tear",
-    LandingObsidianTear = "landing_obsidian_tear",
-    DrippingDripstoneWater = "dripping_dripstone_water",
-    FallingDripstoneWater = "falling_dripstone_water",
-    DrippingDripstoneLava = "dripping_dripstone_lava",
-    FallingDripstoneLava = "falling_dripstone_lava",
-    Splash = "splash",
-    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",
-    Underwater = "underwater",
-    Portal = "portal",
-    ReversePortal = "reverse_portal",
-    Enchant = "enchant",
-    Nautilus = "nautilus",
-    VaultConnection = "vault_connection",
-    Crit = "crit",
-    EnchantedHit = "enchanted_hit",
-    DamageIndicator = "damage_indicator",
-    Heart = "heart",
-    AngryVillager = "angry_villager",
-    HappyVillager = "happy_villager",
-    Composter = "composter",
-    Mycelium = "mycelium",
-    Dolphin = "dolphin",
-    EggCrack = "egg_crack",
-    Poof = "poof",
-    Explosion = "explosion",
-    ExplosionEmitter = "explosion_emitter",
-    CampfireCosySmoke = "campfire_cosy_smoke",
-    CampfireSignalSmoke = "campfire_signal_smoke",
-    Note = "note",
-    Dust = "dust",
-    TotemOfUndying = "totem_of_undying",
-    Firework = "firework",
-    EndRod = "end_rod",
-    Ash = "ash",
-    WhiteAsh = "white_ash",
-    CrimsonSpore = "crimson_spore",
-    WarpedSpore = "warped_spore",
-    CherryLeaves = "cherry_leaves",
-    PaleOakLeaves = "pale_oak_leaves",
-    TintedLeaves = "tinted_leaves",
-    Effect = "effect",
-    InstantEffect = "instant_effect",
-    EntityEffect = "entity_effect",
-    Witch = "witch",
-    Infested = "infested",
-    Cloud = "cloud",
-    Sneeze = "sneeze",
-    Snowflake = "snowflake",
-    Soul = "soul",
-    SculkSoul = "sculk_soul",
-    DragonBreath = "dragon_breath",
-    Gust = "gust",
-    SmallGust = "small_gust",
-    GustEmitterLarge = "gust_emitter_large",
-    GustEmitterSmall = "gust_emitter_small",
-    DustColorTransition = "dust_color_transition",
-    SculkCharge = "sculk_charge",
-    SculkChargePop = "sculk_charge_pop",
-    Shriek = "shriek",
-    SonicBoom = "sonic_boom",
-    Vibration = "vibration",
-    SweepAttack = "sweep_attack",
-    Glow = "glow",
-    WaxOn = "wax_on",
-    WaxOff = "wax_off",
-    ElectricSpark = "electric_spark",
-    Scrape = "scrape",
-    SquidInk = "squid_ink",
-    GlowSquidInk = "glow_squid_ink",
-    Item = "item",
-    ItemSlime = "item_slime",
-    ItemSnowball = "item_snowball",
-    ItemCobweb = "item_cobweb",
-    SulfurCubeGoo = "sulfur_cube_goo",
-    Flash = "flash",
-    Firefly = "firefly",
-    TrialSpawnerDetection = "trial_spawner_detection",
-    TrialSpawnerDetectionOminous = "trial_spawner_detection_ominous",
-    TrialOmen = "trial_omen",
-    RaidOmen = "raid_omen",
-    OminousSpawning = "ominous_spawning",
-    Spit = "spit",
-    Fishing = "fishing",
-    DustPlume = "dust_plume",
-    RedPoplarLeaves = "red_poplar_leaves",
-    OrangePoplarLeaves = "orange_poplar_leaves",
-    YellowPoplarLeaves = "yellow_poplar_leaves",
-    PauseMobGrowth = "pause_mob_growth",
-    ResetMobGrowth = "reset_mob_growth",
-    BlockMarker = "block_marker",
-}
-impl ParticleType {
-    /// `ParticleType.getOverrideLimiter` (`ParticleTypes.register(name, true)`):
-    /// spawned regardless of distance.
-    pub fn override_limiter(self) -> bool {
-        matches!(
-            self,
-            Self::BlockMarker
-                | Self::Geyser
-                | Self::GeyserBase
-                | Self::GeyserPoof
-                | Self::GeyserPlume
-                | Self::DamageIndicator
-                | Self::ExplosionEmitter
-                | Self::Explosion
-                | Self::Gust
-                | Self::GustEmitterLarge
-                | Self::GustEmitterSmall
-                | Self::SonicBoom
-                | Self::SculkCharge
-                | Self::SculkChargePop
-                | Self::Vibration
-                | Self::Poof
-                | Self::Spit
-                | Self::SquidInk
-                | Self::SweepAttack
-                | Self::CampfireCosySmoke
-                | Self::CampfireSignalSmoke
-                | Self::GlowSquidInk
-                | Self::Glow
-                | Self::WaxOn
-                | Self::WaxOff
-                | Self::ElectricSpark
-                | Self::Scrape
-                | Self::TrialSpawnerDetection
-                | Self::TrialSpawnerDetectionOminous
-                | Self::VaultConnection
-                | Self::OminousSpawning
-        )
-    }
-    /// `SingleQuadParticle.Layer.translucent`: types whose vanilla particle class
-    /// hardcodes the translucent layer, drawn after translucent terrain.
-    /// `TerrainParticle`, `BreakingItemParticle` and `BlockMarker` resolve their
-    /// layer from the sprite instead (`Layer.bySprite`); see the `translucent`
-    /// sprite set on the engine.
-    pub fn translucent_layer(self) -> bool {
-        match self {
-            // CampfireSmokeParticle.
-            Self::CampfireCosySmoke | Self::CampfireSignalSmoke
-            // PlayerCloudParticle.
-            | Self::Cloud | Self::Sneeze
-            // 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,
-            // VibrationSignalParticle, FireflyParticle, OverlayParticle.
-            | Self::SculkCharge | Self::SculkChargePop | Self::Shriek
-            | Self::Vibration | Self::Firefly | Self::Flash
-            // SimpleAnimatedParticle and its subclasses: EndRodParticle,
-            // SparkParticle (firework), SquidInkParticle, TotemParticle.
-            | Self::EndRod | Self::Firework | Self::SquidInk | Self::GlowSquidInk
-            | Self::TotemOfUndying
-            // FlyTowardsPositionParticle: its LifetimeAlpha(0, 0.6, 0.25, 1) is not opaque.
-            | Self::VaultConnection => true,
-            _ => false,
-        }
-    }
-}

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

@@ -1,246 +0,0 @@
-//! Registry contents and source state that commands validate and complete
-//! arguments against (what the server's registry access holds).
-use std::collections::BTreeMap;
-
-/// Registry contents and source state used to validate and complete arguments.
-#[derive(Clone, Debug, Default)]
-pub struct Registries {
-    /// Permission level of the command source.
-    pub permission: u8,
-    pub items: Vec<String>,
-    pub item_tags: Vec<String>,
-    /// Block id -> (property, allowed values).
-    pub blocks: BTreeMap<String, Vec<(String, Vec<String>)>>,
-    pub block_tags: Vec<String>,
-    /// Entity types that `summon` can create.
-    pub summonable: Vec<String>,
-    /// Every entity type (selector `type=`).
-    pub entity_types: Vec<String>,
-    pub effects: Vec<String>,
-    pub enchantments: Vec<String>,
-    pub structures: Vec<String>,
-    pub biomes: Vec<String>,
-    pub dimensions: Vec<String>,
-    pub clocks: Vec<String>,
-    pub timelines: Vec<String>,
-    pub time_markers: Vec<String>,
-    pub advancements: Vec<String>,
-    /// 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>,
-    pub tracked: Vec<String>,
-    /// Loaded datapack functions (`ns:path`) and function tags (`ns:path`).
-    pub functions: Vec<String>,
-    /// `/data ... storage` ids.
-    pub storages: Vec<String>,
-    /// Boss bar ids and datapack predicate ids.
-    pub bossbars: Vec<String>,
-    pub predicates: Vec<String>,
-    pub item_modifiers: Vec<String>,
-    pub schedules: Vec<String>,
-    pub stopwatches: Vec<String>,
-    pub recipes: Vec<String>,
-    pub sounds: Vec<String>,
-    pub damage_types: Vec<String>,
-    pub attributes: Vec<String>,
-    pub loot_tables: Vec<String>,
-    pub templates: Vec<String>,
-    pub random_sequences: Vec<String>,
-    pub datapacks_enabled: Vec<String>,
-    pub datapacks_disabled: Vec<String>,
-    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>,
-    /// Blocks whose default state has a block entity.
-    pub block_entities: std::collections::BTreeSet<String>,
-    /// Block tag -> member blocks.
-    pub block_tag_members: BTreeMap<String, Vec<String>>,
-    /// Data component types with a codec (not transient).
-    pub persistent_components: Vec<String>,
-    /// Recipes `/recipe` can give (not special).
-    pub learnable_recipes: Vec<String>,
-    /// Advancement id -> criterion names.
-    pub advancement_criteria: BTreeMap<String, Vec<String>>,
-    /// World clock -> time markers shown in commands.
-    pub clock_time_markers: BTreeMap<String, Vec<String>>,
-    /// Trigger objectives the source may use (`/trigger` suggestions).
-    pub trigger_objectives: Vec<String>,
-    /// Objectives with the `trigger` criterion -> holder -> whether its score is locked.
-    pub trigger_scores: BTreeMap<String, BTreeMap<String, bool>>,
-}
-/// The ids and tag ids of one registry.
-#[derive(Clone, Debug, Default)]
-pub struct RegistryIds {
-    pub ids: Vec<String>,
-    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
-    /// mob effects, data component types and dialogs, block entities and tag
-    /// members. Registries that data packs reload stay with the game.
-    pub fn fill_from_export(&mut self, r: &serde_json::Value) {
-        fn strings(v: &serde_json::Value) -> Vec<String> {
-            v.as_array()
-                .map(|a| {
-                    a.iter()
-                        .filter_map(|x| x.as_str().map(str::to_owned))
-                        .collect()
-                })
-                .unwrap_or_default()
-        }
-        let fill = |field: &mut Vec<String>, key: &str| {
-            if field.is_empty() {
-                *field = strings(&r[key]);
-            }
-        };
-        fill(&mut self.effects, "effects");
-        fill(&mut self.enchantments, "enchantments");
-        fill(&mut self.attributes, "attributes");
-        fill(&mut self.damage_types, "damage_types");
-        fill(&mut self.templates, "templates");
-        fill(&mut self.persistent_components, "persistent_components");
-        fill(&mut self.learnable_recipes, "learnable_recipes");
-        const RELOADED: [&str; 5] = [
-            "minecraft:advancement",
-            "minecraft:recipe",
-            "minecraft:loot_table",
-            "minecraft:predicate",
-            "minecraft:item_modifier",
-        ];
-        for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
-            if RELOADED.contains(&name.as_str()) || self.by_registry.contains_key(name) {
-                continue;
-            }
-            self.by_registry.insert(
-                name.clone(),
-                RegistryIds {
-                    ids: strings(&entry["ids"]),
-                    tags: strings(&entry["tags"]),
-                },
-            );
-        }
-        if self.block_entities.is_empty() {
-            self.block_entities = strings(&r["block_entities"]).into_iter().collect();
-        }
-        if self.block_tag_members.is_empty() {
-            for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
-                self.block_tag_members.insert(tag.clone(), strings(members));
-            }
-        }
-        if self.clock_time_markers.is_empty() {
-            for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
-                self.clock_time_markers
-                    .insert(clock.clone(), strings(markers));
-            }
-        }
-        if self.advancement_criteria.is_empty() {
-            for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
-                self.advancement_criteria
-                    .insert(id.clone(), strings(criteria));
-            }
-        }
-    }
-    /// The element ids of a registry (sorted).
-    pub fn ids(&self, registry: &str) -> &[String] {
-        if let Some(r) = self.by_registry.get(registry) {
-            return &r.ids;
-        }
-        match registry {
-            "minecraft:item" => &self.items,
-            "minecraft:entity_type" => &self.entity_types,
-            "minecraft:mob_effect" => &self.effects,
-            "minecraft:enchantment" => &self.enchantments,
-            "minecraft:worldgen/structure" => &self.structures,
-            "minecraft:worldgen/biome" => &self.biomes,
-            "minecraft:world_clock" => &self.clocks,
-            "minecraft:timeline" => &self.timelines,
-            "minecraft:attribute" => &self.attributes,
-            "minecraft:damage_type" => &self.damage_types,
-            "minecraft:sound_event" => &self.sounds,
-            "minecraft:predicate" => &self.predicates,
-            "minecraft:item_modifier" => &self.item_modifiers,
-            "minecraft:loot_table" => &self.loot_tables,
-            "minecraft:recipe" => &self.recipes,
-            "minecraft:advancement" => &self.advancements,
-            _ => EMPTY,
-        }
-    }
-    /// The tag ids of a registry (sorted).
-    pub fn tags(&self, registry: &str) -> &[String] {
-        if let Some(r) = self.by_registry.get(registry) {
-            return &r.tags;
-        }
-        match registry {
-            "minecraft:item" => &self.item_tags,
-            "minecraft:block" => &self.block_tags,
-            _ => EMPTY,
-        }
-    }
-}

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

@@ -1,7 +0,0 @@
-//! Sound sources (`SoundSource`), by name.
-
-/// SoundSource names in vanilla order.
-pub const SOUND_SOURCES: [&str; 11] = [
-    "master", "music", "record", "weather", "block", "hostile", "neutral", "player", "ambient",
-    "voice", "ui",
-];

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

@@ -1,24 +0,0 @@
-//! UUIDs as vanilla's four-int form, to and from their text form.
-
-pub fn uuid_text(u: [i32; 4]) -> String {
-    let hex: String = u.iter().map(|v| format!("{:08x}", *v as u32)).collect();
-    format!(
-        "{}-{}-{}-{}-{}",
-        &hex[0..8],
-        &hex[8..12],
-        &hex[12..16],
-        &hex[16..20],
-        &hex[20..32]
-    )
-}
-pub fn uuid_from_text(s: &str) -> Option<[i32; 4]> {
-    let hex: String = s.chars().filter(|c| *c != '-').collect();
-    if hex.len() != 32 {
-        return None;
-    }
-    let mut out = [0i32; 4];
-    for (i, v) in out.iter_mut().enumerate() {
-        *v = u32::from_str_radix(&hex[i * 8..i * 8 + 8], 16).ok()? as i32;
-    }
-    Some(out)
-}

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,69 +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"
-base64 = "0.22"
-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"] }
-sha1 = "0.10"
-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/chat_tests.rs

@@ -1,580 +0,0 @@
-use super::*;
-use crate::{font::Font, hud::Rect};
-use std::{collections::HashMap, path::Path};
-
-/// The Chat option's default: no restriction.
-fn full() -> ChatAbilities {
-    ChatAbilities::new(ChatVisibility::Full)
-}
-
-fn font() -> Font {
-    // The missing-glyph metrics let these tests run without game assets.
-    Font::load(
-        Path::new("/nonexistent-horizon-chat-test-resources"),
-        &HashMap::new(),
-        &[],
-        (1, 1),
-        (0, 0),
-        Rect {
-            u0: 0.0,
-            v0: 0.0,
-            u1: 1.0,
-            v1: 1.0,
-            w: 1,
-            h: 1,
-        },
-    )
-}
-
-fn add(chat: &mut Chat, font: &Font, content: Text) {
-    for content in font.wrap_components(&content, chat.max_width()) {
-        chat.lines.insert(
-            0,
-            Line {
-                added: 0,
-                content,
-                indicator: None,
-            },
-        );
-    }
-}
-
-#[test]
-fn clicking_seed_copies_the_raw_value_only_inside_the_link() {
-    let font = font();
-    for seed in [1, -42, i64::MIN, i64::MAX] {
-        let mut chat = Chat::default();
-        let seed_text = Text::copyable(seed.to_string()).with_color(text::GOLD);
-        assert_eq!(seed_text.plain(), format!("[{seed}]"));
-        assert_eq!(seed_text.spans[0].style.color, Some(text::GOLD));
-        assert_eq!(seed_text.spans[1].style.color, Some(text::GREEN));
-        assert_eq!(seed_text.spans[2].style.color, Some(text::GOLD));
-        add(&mut chat, &font, Text::literal("Seed: ").append(seed_text));
-        let expected = Some(ClickEvent::CopyToClipboard(seed.to_string()));
-        let start = 4.0 + f64::from(font.width("Seed: ["));
-        let end = start + f64::from(font.width(&seed.to_string()));
-        assert_eq!(chat.click_at(&font, 360, start, 315.0), expected);
-        assert_eq!(chat.click_at(&font, 360, end - 0.5, 315.0), expected);
-        for (x, y) in [
-            (start - 0.5, 315.0),
-            (end, 315.0),
-            (3.0, 315.0),
-            (start, 320.0),
-            (start, 310.0),
-        ] {
-            assert_eq!(chat.click_at(&font, 360, x, y), None, "{x}, {y}");
-        }
-    }
-}
-
-#[test]
-fn click_targets_match_rendered_spans_when_scaled_wrapped_and_scrolled() {
-    let font = font();
-    let screenshot = ClickEvent::OpenFile("/tmp/My screenshots/世界.png".into());
-    for scale in [0.5, 0.75, 1.0] {
-        for line_spacing in [0.0, 0.5, 1.0] {
-            let mut chat = Chat::default();
-            chat.options.scale = scale;
-            chat.options.width = 0.0;
-            chat.options.line_spacing = line_spacing;
-            for _ in 0..20 {
-                add(
-                    &mut chat,
-                    &font,
-                    Text::literal("Saved screenshot as ").append(Text::styled(
-                        "2026-10-14_18.55.14.png",
-                        Style {
-                            click: Some(screenshot.clone()),
-                            bold: Some(true),
-                            underlined: Some(true),
-                            ..Style::default()
-                        },
-                    )),
-                );
-            }
-            for scroll in [0, 3, 12] {
-                chat.scroll = scroll;
-                let mut links = 0;
-                for draw in chat.layout(361, 0, true) {
-                    if let GuiDraw::Text { text, x, y, .. } = draw {
-                        let mut at = x as f64;
-                        for (c, style) in text.chars() {
-                            let width = f64::from(font.advance(c, style));
-                            let cursor_x = (4.0 + at + width / 2.0) * scale;
-                            let cursor_y = (y as f64 + 3.0) * scale;
-                            assert_eq!(
-                                chat.click_at(&font, 361, cursor_x, cursor_y),
-                                style.click,
-                                "scale={scale}, spacing={line_spacing}, scroll={scroll}, char={c}"
-                            );
-                            links += usize::from(style.click.is_some());
-                            at += width;
-                        }
-                    }
-                }
-                assert!(links > 0);
-                // The history above the focused viewport is not clickable.
-                let top = ((361 - 40) as f64 / scale).floor()
-                    - chat.lines_per_page(true) as f64 * chat.options.line_height() as f64;
-                assert_eq!(
-                    chat.click_at(&font, 361, 10.0 * scale, (top - 1.0) * scale),
-                    None
-                );
-            }
-        }
-    }
-}
-
-#[test]
-fn locate_coordinates_fill_chat_with_teleport_without_submitting() {
-    let font = font();
-    let m = Measure(&font);
-    let registries = Registries::default();
-    let commands = Commands {
-        dispatcher: crate::command::vanilla::game_dispatcher(),
-        registries: &registries,
-    };
-    // Structures and POIs use relative Y; biome results include absolute Y.
-    for (y, expected) in [
-        (None, "/tp @s -1136 ~ 848"),
-        (Some(73), "/tp @s -1136 73 848"),
-    ] {
-        let link = Text::teleport_link(-1136, y, 848);
-        assert_eq!(link.component()["click_event"]["action"], "suggest_command");
-        assert_eq!(link.component()["click_event"]["command"], expected);
-        let mut chat = Chat::default();
-        add(&mut chat, &font, Text::literal("Found at ").append(link));
-        let mut screen = ChatScreen::new(&m, &commands, "draft", 0, 640, 360, full());
-        let x = 4.0 + f64::from(font.width("Found at "));
-        assert!(!screen.click(&m, &commands, x, 315.0));
-        let Some(ClickEvent::SuggestCommand(command)) = chat.click_at(&font, 360, x, 315.0) else {
-            panic!("locate coordinates must suggest a command");
-        };
-        screen.suggest_command(&m, &commands, &command);
-        assert_eq!(screen.value(), expected);
-        assert_eq!(screen.input.cursor, expected.chars().count());
-        assert_eq!(screen.input.highlight, screen.input.cursor);
-        // Submission is a separate, explicit Enter press.
-        assert_eq!(
-            screen.key(
-                &m,
-                &commands,
-                &[],
-                winit::keyboard::KeyCode::Enter,
-                false,
-                false
-            ),
-            ChatAction::Submit(expected.to_owned())
-        );
-    }
-}
-
-#[test]
-fn history_arrows_recall_messages_and_restore_the_draft() {
-    use winit::keyboard::KeyCode::{ArrowDown, ArrowUp};
-
-    let font = font();
-    let m = Measure(&font);
-    let registries = Registries::default();
-    let commands = Commands {
-        dispatcher: crate::command::vanilla::game_dispatcher(),
-        registries: &registries,
-    };
-    let history = vec!["first message".to_owned(), "latest message".to_owned()];
-    let mut screen = ChatScreen::new(
-        &m,
-        &commands,
-        "unfinished draft",
-        history.len(),
-        640,
-        360,
-        full(),
-    );
-    for (key, expected) in [
-        (ArrowUp, "latest message"),
-        (ArrowUp, "first message"),
-        (ArrowUp, "first message"),
-        (ArrowDown, "latest message"),
-        (ArrowDown, "unfinished draft"),
-        (ArrowDown, "unfinished draft"),
-    ] {
-        assert_eq!(
-            screen.key(&m, &commands, &history, key, false, false),
-            ChatAction::None
-        );
-        assert_eq!(screen.value(), expected);
-    }
-}
-
-#[test]
-fn mod_commands_are_coloured_and_complete_like_vanilla_ones() {
-    let font = font();
-    let m = Measure(&font);
-    // Allow Commands off: a mod's command needs no level.
-    let registries = Registries::default();
-    let vanilla = crate::command::vanilla::game_dispatcher();
-    let modded = vanilla.with_mod_commands(["where", "coords"]);
-    let red = |screen: &ChatScreen| {
-        screen
-            .format(screen.value(), 0)
-            .spans
-            .iter()
-            .any(|s| s.style.color == Some(text::RED))
-    };
-    let typed = |dispatcher: &crate::command::Dispatcher, line: &str| {
-        let c = Commands {
-            dispatcher,
-            registries: &registries,
-        };
-        let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
-        screen.type_text(&m, &c, line);
-        screen
-    };
-    // Unknown without the mod's tree (#456).
-    assert!(red(&typed(vanilla, "/coords")));
-    for line in ["/coords", "/where", "/where me and you"] {
-        assert!(!red(&typed(&modded, line)), "{line}");
-    }
-    let c = Commands {
-        dispatcher: &modded,
-        registries: &registries,
-    };
-    let mut screen = typed(&modded, "/coo");
-    screen.key(&m, &c, &[], winit::keyboard::KeyCode::Tab, false, false);
-    assert_eq!(screen.value(), "/coords");
-}
-
-#[test]
-fn chat_completes_the_servers_custom_completions_with_the_players() {
-    // CommandSuggestions.updateCommandInfo completes chat from
-    // ClientSuggestionProvider.getCustomTabSuggestions: the online players
-    // and what ClientboundCustomChatCompletionsPacket added.
-    use crate::command::{CustomCompletionAction as Action, modify_custom_completions};
-    let font = font();
-    let m = Measure(&font);
-    let mut registries = Registries {
-        players: vec!["Steve".into()],
-        ..Registries::default()
-    };
-    let entries = |e: &[&str]| e.iter().map(|s| s.to_string()).collect::<Vec<_>>();
-    let set = &mut registries.custom_completions;
-    modify_custom_completions(set, Action::from_id(0), &entries(&["Alex", "#trade"]));
-    modify_custom_completions(set, Action::Add, &entries(&["Notch", "Steve"]));
-    modify_custom_completions(set, Action::Remove, &entries(&["Alex"]));
-    // An id past the last action is ADD (OutOfBoundsStrategy.ZERO).
-    modify_custom_completions(set, Action::from_id(7), &entries(&["Zuri"]));
-    assert_eq!(
-        registries
-            .custom_tab_suggestions()
-            .into_iter()
-            .collect::<Vec<_>>(),
-        ["#trade", "Notch", "Steve", "Zuri"]
-    );
-    let completed = |registries: &Registries, line: &str| {
-        let dispatcher = crate::command::vanilla::game_dispatcher();
-        let c = Commands {
-            dispatcher,
-            registries,
-        };
-        let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
-        screen.type_text(&m, &c, line);
-        // Chat shows no list by itself: Tab shows it, Tab again uses it.
-        for _ in 0..2 {
-            screen.key(&m, &c, &[], winit::keyboard::KeyCode::Tab, false, false);
-        }
-        screen.value().to_owned()
-    };
-    assert_eq!(completed(&registries, "hi no"), "hi Notch");
-    assert_eq!(completed(&registries, "sell #tr"), "sell #trade");
-    assert_eq!(completed(&registries, "hi st"), "hi Steve");
-    assert_eq!(completed(&registries, "hi al"), "hi al");
-    // SET replaces them all; the players stay.
-    let set = &mut registries.custom_completions;
-    modify_custom_completions(set, Action::Set, &entries(&["Alex"]));
-    assert_eq!(completed(&registries, "hi no"), "hi no");
-    assert_eq!(completed(&registries, "hi al"), "hi Alex");
-    assert_eq!(completed(&registries, "hi st"), "hi Steve");
-}
-
-#[test]
-fn ask_server_nodes_wait_for_the_servers_completions() {
-    // ClientSuggestionProvider.customSuggestion: an `ask_server` node at the
-    // cursor sends the command so far, and the list is done with the reply.
-    let font = font();
-    let m = Measure(&font);
-    let registries = Registries {
-        permission: 4,
-        ..Registries::default()
-    };
-    let mut d = crate::command::vanilla::game_dispatcher().clone();
-    let child = |d: &crate::command::Dispatcher, n: usize, name: &str| {
-        d.nodes[n]
-            .children
-            .iter()
-            .copied()
-            .find(|&c| d.nodes[c].name() == name)
-            .expect(name)
-    };
-    let id = child(&d, child(&d, child(&d, 0, "bossbar"), "get"), "id");
-    d.nodes[id].suggests = Some(crate::command::Suggests::AskServer);
-    let c = Commands {
-        dispatcher: &d,
-        registries: &registries,
-    };
-    let tab = |screen: &mut ChatScreen| {
-        screen.key(&m, &c, &[], winit::keyboard::KeyCode::Tab, false, false);
-    };
-    let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
-    screen.type_text(&m, &c, "/bossbar get pt");
-    let (request, sent) = screen.take_request().expect("the server is asked");
-    assert_eq!(sent, "/bossbar get pt");
-    assert_eq!(screen.take_request(), None);
-    // Nothing to complete until the reply.
-    tab(&mut screen);
-    assert_eq!(screen.value(), "/bossbar get pt");
-    // A reply to an older request is dropped; the range is in UTF-16 units.
-    let reply = |text: &str| vec![(text.to_owned(), None)];
-    screen.server_suggestions(&m, &c, request - 1, (13, 2), reply("pt6:old"));
-    tab(&mut screen);
-    assert_eq!(screen.value(), "/bossbar get pt");
-    screen.server_suggestions(&m, &c, request, (13, 2), reply("pt6:check"));
-    tab(&mut screen);
-    assert_eq!(screen.value(), "/bossbar get pt6:check");
-    // Without the server's provider the local list is done at once.
-    let local = crate::command::vanilla::game_dispatcher();
-    let c = Commands {
-        dispatcher: local,
-        registries: &registries,
-    };
-    let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
-    screen.type_text(&m, &c, "/bossbar get pt");
-    assert_eq!(screen.take_request(), None);
-}
-
-#[test]
-fn legacy_codes_colour_the_line_or_vanish_without_chat_colours() {
-    let mut chat = Chat::default();
-    let red = Text::literal("\u{a7}cRED");
-    let shown = chat.displayed(&red);
-    assert_eq!(shown.plain(), "RED");
-    assert!(shown.chars().all(|(_, s)| s.color == Some(0xFF5555)));
-    chat.options.colors = false;
-    let shown = chat.displayed(&red);
-    assert_eq!(shown.plain(), "RED");
-    assert!(shown.chars().all(|(_, s)| s.color.is_none()));
-    // A lone section sign or an unknown code stays as written.
-    assert_eq!(
-        chat.displayed(&Text::literal("a\u{a7}zb")).plain(),
-        "a\u{a7}zb"
-    );
-}
-
-#[test]
-fn a_server_component_keeps_its_click_and_hover_events() {
-    let font = font();
-    let json = serde_json::json!({
-        "text": "CLICK", "color": "green", "bold": true,
-        "click_event": {"action": "suggest_command", "command": "/say clicked"},
-        "hover_event": {"action": "show_text", "value": {"text": "Tip", "color": "aqua"}},
-    });
-    let line = crate::component::to_text(&json, &mut |s| Text::literal(s));
-    let mut chat = Chat::default();
-    add(&mut chat, &font, line);
-    let x = 4.0 + f64::from(font.width("CL"));
-    let Some(ClickEvent::SuggestCommand(command)) = chat.click_at(&font, 360, x, 315.0) else {
-        panic!("the line must suggest its command");
-    };
-    assert_eq!(command, "/say clicked");
-    let hover = chat.hover_at(&font, 360, x, 315.0).expect("a hover text");
-    assert_eq!(hover.plain(), "Tip");
-    assert_eq!(hover.spans[0].style.color, Some(text::AQUA));
-    // Past the (bold, so wider) text, nothing.
-    let past = 4.0 + f64::from(font.width("CLICK")) + 20.0;
-    assert!(chat.hover_at(&font, 360, past, 315.0).is_none());
-}
-
-/// `ChatVisiblity`: Commands Only keeps the chat out, Hidden takes the
-/// commands too (`ChatAbilities`), and Enter sends nothing the option hides.
-#[test]
-fn the_chat_option_decides_what_may_be_sent() {
-    let font = font();
-    let m = Measure(&font);
-    let registries = Registries::default();
-    let c = Commands {
-        dispatcher: crate::command::vanilla::game_dispatcher(),
-        registries: &registries,
-    };
-    let enter = |screen: &mut ChatScreen| {
-        screen.key(&m, &c, &[], winit::keyboard::KeyCode::Enter, false, false)
-    };
-    for (visibility, chat, command) in [
-        (ChatVisibility::Full, true, true),
-        (ChatVisibility::System, false, true),
-        (ChatVisibility::Hidden, false, false),
-    ] {
-        let abilities = ChatAbilities::new(visibility);
-        assert_eq!(abilities.allows("hi"), chat, "{visibility:?}");
-        assert_eq!(abilities.allows("/time set day"), command, "{visibility:?}");
-        for (line, allowed) in [("hi", chat), ("/time set day", command)] {
-            let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, abilities);
-            screen.type_text(&m, &c, line);
-            match enter(&mut screen) {
-                ChatAction::Submit(sent) => {
-                    assert!(allowed, "{visibility:?} sent {sent}");
-                    assert_eq!(sent, line);
-                }
-                ChatAction::None => assert!(!allowed, "{visibility:?} kept {line}"),
-                ChatAction::Close => panic!("Enter does not close the chat"),
-            }
-        }
-    }
-}
-
-/// The restriction the option sets is a usage line: red, under the input, for
-/// a command the Chat option takes and for a message it takes.
-#[test]
-fn restricted_input_says_why_it_will_not_send() {
-    let font = font();
-    let m = Measure(&font);
-    let registries = Registries::default();
-    let c = Commands {
-        dispatcher: crate::command::vanilla::game_dispatcher(),
-        registries: &registries,
-    };
-    let usage = |visibility, line: &str| {
-        let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, ChatAbilities::new(visibility));
-        screen.type_text(&m, &c, line);
-        screen.usage.iter().map(|t| t.plain()).collect::<Vec<_>>()
-    };
-    assert_eq!(usage(ChatVisibility::Full, "hi"), Vec::<String>::new());
-    // The font has no language files here, so the line is its key.
-    assert_eq!(
-        usage(ChatVisibility::System, "hi"),
-        ["chat_screen.messages_not_allowed"]
-    );
-    // A command the option allows says nothing about the restriction.
-    assert!(
-        !usage(ChatVisibility::System, "/time set day")
-            .iter()
-            .any(|line| line == "chat_screen.commands_not_allowed")
-    );
-    assert!(
-        usage(ChatVisibility::Hidden, "/time set day")
-            .iter()
-            .any(|line| line == "chat_screen.commands_not_allowed")
-    );
-}
-
-/// `ChatComponent.setVisibleMessageFilter`: a message the Chat option hides
-/// on arrival is dropped; one already in the chat leaves it while the option
-/// hides its kind and comes back when it shows it again.
-#[test]
-fn the_chat_option_filters_the_lines_both_ways() {
-    let font = font();
-    let mut chat = Chat::default();
-    let says = |chat: &mut Chat, text: &str, source| {
-        chat.add_message(&font, Text::literal(text), None, source, 0, false);
-    };
-    let shown =
-        |chat: &Chat| -> Vec<String> { chat.lines.iter().map(|l| l.content.plain()).collect() };
-    says(&mut chat, "player", ChatSource::Player);
-    says(&mut chat, "server", ChatSource::Server);
-    chat.set_abilities(&font, ChatAbilities::new(ChatVisibility::System));
-    assert_eq!(shown(&chat), ["server"]);
-    says(&mut chat, "dropped", ChatSource::Player);
-    chat.set_abilities(&font, ChatAbilities::new(ChatVisibility::Hidden));
-    says(&mut chat, "client", ChatSource::Client);
-    assert_eq!(shown(&chat), ["client"]);
-    chat.set_abilities(&font, ChatAbilities::new(ChatVisibility::Full));
-    assert_eq!(shown(&chat), ["client", "server", "player"]);
-}
-
-/// The in-frame LAN host's chat: a guest's line is a player message, so the
-/// Chat option's player-message permission hides it at Commands Only and
-/// Hidden; command feedback (`/list`, `/tp`) is a system message and stays
-/// at Commands Only.
-#[test]
-fn a_guests_line_follows_the_player_message_permission() {
-    let font = font();
-    let shown = |visibility, source| {
-        let mut chat = Chat::default();
-        chat.set_abilities(&font, ChatAbilities::new(visibility));
-        chat.add_message(&font, Text::literal("line"), None, source, 0, false);
-        chat.messages.len()
-    };
-    for (visibility, player, system) in [
-        (ChatVisibility::Full, 1, 1),
-        (ChatVisibility::System, 0, 1),
-        (ChatVisibility::Hidden, 0, 0),
-    ] {
-        assert_eq!(
-            shown(visibility, ChatSource::Player),
-            player,
-            "{visibility:?}"
-        );
-        assert_eq!(
-            shown(visibility, ChatSource::Server),
-            system,
-            "{visibility:?}"
-        );
-    }
-}
-
-/// `ChatComponent.deleteMessageOrDelay`: a deleted message shows for 60
-/// ticks from when it was added, then becomes the grey italic
-/// `chat.deleted_marker` line with the system bar; the other lines stay.
-#[test]
-fn a_deleted_message_shows_60_ticks_then_becomes_the_marker() {
-    let font = font();
-    let mut chat = Chat::default();
-    let secret = [7; 256];
-    chat.add_signed_message(
-        &font,
-        Text::literal("<Steve> secret"),
-        Some(secret),
-        100,
-        false,
-    );
-    chat.add_signed_message(
-        &font,
-        Text::literal("<Alex> hi"),
-        Some([8; 256]),
-        110,
-        false,
-    );
-    let lines =
-        |chat: &Chat| -> Vec<String> { chat.lines.iter().map(|l| l.content.plain()).collect() };
-    let marker = Chat::deleted_marker().plain();
-    chat.delete_message_with(&font, &secret, 130);
-    assert_eq!(
-        lines(&chat),
-        ["<Alex> hi", "<Steve> secret"],
-        "too new: delayed"
-    );
-    chat.process_deletions(&font, 159);
-    assert_eq!(lines(&chat), ["<Alex> hi", "<Steve> secret"]);
-    chat.process_deletions(&font, 160);
-    assert_eq!(lines(&chat), ["<Alex> hi".to_owned(), marker.clone()]);
-    assert!(chat.deletions.is_empty());
-    let line = &chat.lines[1];
-    assert_eq!(line.indicator, Some(SYSTEM_INDICATOR));
-    assert_eq!(line.added, 100, "the marker keeps the message's time");
-    assert!(
-        line.content
-            .spans
-            .iter()
-            .all(|s| s.style.color == Some(text::GRAY) && s.style.is_italic())
-    );
-    assert_eq!(
-        chat.messages[1].content.translation_key(),
-        Some("chat.deleted_marker")
-    );
-    // A message shown 60 ticks already is replaced at once; an unknown or
-    // already deleted signature changes nothing.
-    chat.delete_message_with(&font, &[8; 256], 170);
-    assert_eq!(lines(&chat), [marker.clone(), marker.clone()]);
-    chat.delete_message_with(&font, &secret, 200);
-    chat.delete_message_with(&font, &[9; 256], 200);
-    assert_eq!(lines(&chat), [marker.clone(), marker]);
-    assert!(chat.deletions.is_empty());
-}

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,564 +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>),
-    /// A block entity of a mod (`native_block_entity`), kept as its saved
-    /// compound for the mod to read and change.
-    Mod(Box<ModBlockEntity>),
-    /// `PotentSulfurBlockEntity` (`game/potent_sulfur.rs`).
-    PotentSulfur(PotentSulfur),
-    /// `StructureBlockEntity` (`structure_block.rs`).
-    StructureBlock(Box<crate::structure_block::StructureBlock>),
-    /// `JigsawBlockEntity` (`jigsaw_block.rs`).
-    JigsawBlock(Box<crate::jigsaw_block::JigsawBlock>),
-    /// `TestBlockEntity` (`test_block.rs`).
-    TestBlock(Box<crate::test_block::TestBlock>),
-    /// `TestInstanceBlockEntity` (`test_instance_block.rs`).
-    TestInstanceBlock(Box<crate::test_instance_block::TestInstanceBlock>),
-}
-/// A mod's block entity: its type id (`mymod:machine`), its saved
-/// compound without `id`, `x`, `y`, `z` and `Items`, its item slots
-/// (`Items`) when its block has a container (`ModContainer`), and the data
-/// slots its menu shows (`ContainerData`: a furnace menu's flame and arrow),
-/// which the mod sets and nothing saves.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct ModBlockEntity {
-    pub id: String,
-    pub nbt: Compound,
-    pub items: Vec<Option<ItemStack>>,
-    pub data: Vec<i32>,
-}
-/// The container of a mod block's block entity, as a `WorldlyContainer`
-/// says it: its slot count, the slots each face reaches
-/// (`getSlotsForFace`, by `Direction`: down, up, north, south, west, east),
-/// and the slots hoppers may put into (`canPlaceItemThroughFace`) and take
-/// from (`canTakeItemThroughFace`); and the vanilla menu that shows its
-/// slots when the block is used, if any (`MOD_MENUS`).
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct ModContainer {
-    pub slots: usize,
-    pub faces: [Vec<usize>; 6],
-    pub inputs: Vec<usize>,
-    pub outputs: Vec<usize>,
-    pub menu: Option<String>,
-}
-/// The vanilla menus a mod container can open, with the slot count each
-/// shows: slot grids, and the furnaces' (input, fuel, result), whose four
-/// data slots draw the flame (`data[0]` of `data[1]`) and the arrow
-/// (`data[2]` of `data[3]`), as `AbstractFurnaceBlockEntity.dataAccess`.
-pub const MOD_MENUS: [(&str, usize); 11] = [
-    ("minecraft:furnace", 3),
-    ("minecraft:blast_furnace", 3),
-    ("minecraft:smoker", 3),
-    ("minecraft:hopper", 5),
-    ("minecraft:generic_3x3", 9),
-    ("minecraft:generic_9x1", 9),
-    ("minecraft:generic_9x2", 18),
-    ("minecraft:generic_9x3", 27),
-    ("minecraft:generic_9x4", 36),
-    ("minecraft:generic_9x5", 45),
-    ("minecraft:generic_9x6", 54),
-];
-/// `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,629 +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, MOD_MENUS, ModBlockEntity, ModContainer,
-    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:structure_block" {
-            // The entity's mode is the state's (`StructureBlock.MODE`); the block's
-            // state is not known here, so a new one starts in its default, SAVE.
-            return Some(Self::StructureBlock(Box::new(
-                crate::structure_block::StructureBlock::new(
-                    crate::structure_block::StructureMode::Save,
-                ),
-            )));
-        }
-        if name == "minecraft:test_block" {
-            // The mode is the state's, which is not known here.
-            return Some(Self::TestBlock(Box::new(
-                crate::test_block::TestBlock::new(crate::test_block::TestBlockMode::Fail),
-            )));
-        }
-        if name == "minecraft:test_instance_block" {
-            return Some(Self::TestInstanceBlock(Box::default()));
-        }
-        if name == "minecraft:jigsaw" {
-            return Some(Self::JigsawBlock(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) -> &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::Mod(m) => &m.id,
-            Self::PotentSulfur(_) => "minecraft:potent_sulfur",
-            Self::StructureBlock(_) => "minecraft:structure_block",
-            Self::JigsawBlock(_) => "minecraft:jigsaw",
-            Self::TestBlock(_) => "minecraft:test_block",
-            Self::TestInstanceBlock(_) => "minecraft:test_instance_block",
-        }
-    }
-    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::StructureBlock(_)
-            | Self::JigsawBlock(_)
-            | Self::TestBlock(_)
-            | Self::TestInstanceBlock(_)
-            | Self::DaylightDetector
-            | Self::Brushable(_) => Vec::new(),
-            Self::Mod(m) => m.items.iter().flatten().cloned().collect(),
-            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::StructureBlock(_)
-            | Self::JigsawBlock(_)
-            | Self::TestBlock(_)
-            | Self::TestInstanceBlock(_)
-            | Self::DaylightDetector
-            | Self::Brushable(_) => &[],
-            Self::Crafter(c) => &c.items,
-            Self::ChiseledBookshelf(b) => &b.items,
-            Self::Shelf(b) => &b.items,
-            Self::Mod(m) => &m.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::StructureBlock(_)
-            | Self::JigsawBlock(_)
-            | Self::TestBlock(_)
-            | Self::TestInstanceBlock(_)
-            | Self::DaylightDetector
-            | Self::Brushable(_) => &mut [],
-            Self::Crafter(c) => &mut c.items,
-            Self::ChiseledBookshelf(b) => &mut b.items,
-            Self::Shelf(b) => &mut b.items,
-            Self::Mod(m) => &mut m.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/entity.wgsl

@@ -1,461 +0,0 @@
-// Entities, dropped items and particles: camera-relative vertices textured
-// from the shared 2D atlas, lit through the same lightmap as terrain.
-struct Globals {
-    view_proj: mat4x4<f32>,
-    fog_color: vec4<f32>,
-    fog: vec4<f32>,
-    sky_color: vec4<f32>,
-    misc: vec4<f32>,
-    inverse_view: mat4x4<f32>,
-    sunrise: vec4<f32>,
-    sun: vec4<f32>,
-    // x: sky fog end, y: cloud fog end
-    fog_ends: vec4<f32>,
-    // Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png.
-    end_portal_sprites: array<vec4<f32>, 2>,
-    // x: vanilla's GameTime ((game time % 24000 + partial tick) / 24000)
-    // y: Nether cardinal lighting, z: how many dynamic_lights are set,
-    // w: the glint scroll clock (`Glint::scroll_ticks`).
-    time: vec4<f32>,
-    crumbling_sprite: vec4<f32>,
-    // Selection outline parameters (read by terrain.wgsl).
-    outline_params: vec4<f32>,
-    // Horizon Extras' dynamic lights: camera-relative position and level (dynamic_light.rs).
-    dynamic_lights: array<vec4<f32>, 16>,
-    sunrise_fan: array<vec4<f32>, 32>,
-}
-@group(0) @binding(0) var<uniform> globals: Globals;
-@group(0) @binding(1) var atlas: texture_2d<f32>;
-@group(0) @binding(2) var atlas_sampler: sampler;
-@group(0) @binding(3) var lightmap: texture_2d<f32>;
-@group(0) @binding(4) var lightmap_sampler: sampler;
-// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler).
-@group(0) @binding(5) var glint_tex: texture_2d<f32>;
-@group(0) @binding(6) var glint_sampler: sampler;
-// The armour layers' GlintSampler: vanilla samples enchanted_glint_armor with
-// the same repeating, linearly filtered sampler as the item glint.
-@group(0) @binding(7) var glint_armor_tex: texture_2d<f32>;
-struct Out {
-    @builtin(position) clip: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-    @location(1) color: vec4<f32>,
-    @location(2) spherical: f32,
-    @location(3) cylindrical: f32,
-    // entity.vsh's overlayColor: the OverlayTexture texel (see overlay_texel).
-    @location(5) overlay_color: vec4<f32>,
-    @location(4) @interpolate(flat) overlay: u32,
-    // Overlay 6: the sprite's v origin and height, for v repeated inside it.
-    @location(6) @interpolate(flat) wrap: vec2<f32>,
-    // Overlays 9 and 10: projection_from_position(gl_Position), the End portal's texProj0.
-    @location(7) proj: vec4<f32>,
-    @location(8) back_color: vec4<f32>,
-    // entity.vsh's lightMapColor, multiplied in after the overlay.
-    @location(9) light_color: vec4<f32>,
-    @location(10) @interpolate(flat) weather_rect: vec4<f32>,
-    // The `GLINT_TEXTURING` sample for overlay 7 (item foil), or the model UV
-    // `ARMOR_ENTITY_GLINT_TEXTURING` scrolls for overlay 36 (armour).
-    @location(11) glint_uv: vec2<f32>,
-    // 1 drops the quad's back-facing pixels (Vertex::normal w = 1), like a culling render type.
-    @location(12) @interpolate(flat) cull: u32,
-    // HDR tier of a light-giving particle (mesher::hdr_tier), from the overlay's
-    // high bits (particles.rs): fs_hdr_mark marks the frame with it.
-    @location(13) @interpolate(flat) tier: u32,
-}
-// Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed.
-fn entity_light(normal: vec3<f32>, nether: bool) -> f32 {
-    let l0 = normalize(vec3(0.2, 1.0, -0.7));
-    let l1 = normalize(vec3(-0.2, select(1.0, -1.0, nether), 0.7));
-    return min(1.0, (max(0.0, dot(l0, normal)) + max(0.0, dot(l1, normal))) * 0.6 + 0.4);
-}
-// The OverlayTexture texel entity.vsh fetches (constants from overlay.rs):
-// the hurt red for overlays 1 and 8, the white row at column 15 for the
-// primed TNT flash (5) and at column overlay - 16 for 16..=31 (a creeper's
-// swelling). Alpha 1 changes nothing.
-fn overlay_texel(overlay: u32) -> vec4<f32> {
-    if overlay == 1u || overlay == 8u { return HURT_OVERLAY; }
-    if overlay == 5u { return vec4(1.0, 1.0, 1.0, WHITE_OVERLAY_ALPHA[15]); }
-    if overlay >= 16u && overlay < 32u { return vec4(1.0, 1.0, 1.0, WHITE_OVERLAY_ALPHA[overlay - 16u]); }
-    return vec4(1.0);
-}
-// Horizon Extras' dynamic lights (dynamic_light.rs): the block light, in the vertex's units
-// (16 per level), a vertex at camera-relative `pos` gets from the frame's light sources, one
-// level less per block. time.z of them are set: none when the extra is off, so no loop runs.
-fn dynamic_block_light(pos: vec3<f32>) -> f32 {
-    let count = min(u32(globals.time.z), 16u);
-    var level = 0.0;
-    for (var i = 0u; i < count; i++) {
-        let l = globals.dynamic_lights[i];
-        level = max(level, l.w - distance(pos, l.xyz));
-    }
-    return level * 16.0;
-}
-fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
-    overlay: u32, color: vec4<f32>, light: vec4<u32>, normal: vec4<f32>) -> Out {
-    var out: Out;
-    out.clip = globals.view_proj * vec4(position, 1.0);
-    out.proj = vec4(out.clip.xy * 0.5 + out.clip.w * 0.5, out.clip.zw);
-    out.uv = uv;
-    let l = vec2(max(f32(light.y), dynamic_block_light(position)), f32(light.x));
-    let lm = textureSampleLevel(lightmap, lightmap_sampler,
-        clamp(l / 256.0 + 0.5 / 16.0, vec2(0.5 / 16.0), vec2(15.5 / 16.0)), 0.0);
-    // Celestial bodies, clouds, beacon beams, End portals and breaking cracks are unlit.
-    let unlit = overlay == 2u || overlay == 4u || overlay == 6u || overlay == 9u || overlay == 10u
-        || overlay == 11u || overlay == 12u;
-    out.light_color = select(lm, vec4(1.0), unlit);
-    // Overlay 6 (beacon beams): the light bytes carry the sprite's v range; 11 and 12
-    // (cracks): the destroy stage sprite's origin.
-    out.wrap = vec2(f32(light.x | (light.y << 8u)), f32(light.z | (light.w << 8u))) / 65535.0;
-    // minecraft_mix_light: the vertex colour times the cardinal light only.
-    var c = color;
-    var back = c;
-    // Normal w: 0 keeps the baked colour, +-127 shades by the normal, and a small positive 1
-    // keeps the baked colour but culls back faces (entitySolid models such as the decorated pot).
-    out.cull = select(0u, 1u, normal.w > 0.0 && normal.w < 0.5);
-    if abs(normal.w) >= 0.5 {
-        c = vec4(c.rgb * entity_light(normal.xyz, globals.time.y != 0.0), c.a);
-        back = select(c, vec4(back.rgb * entity_light(-normal.xyz, globals.time.y != 0.0), back.a), normal.w < 0.0);
-    }
-    out.color = c;
-    out.back_color = back;
-    out.overlay_color = overlay_texel(overlay);
-    // Sky geometry (clouds, celestial bodies) is exempt from render-distance fog.
-    out.spherical = select(length(position), 0.0, overlay >= 2u && overlay <= 4u);
-    out.cylindrical = select(max(length(position.xz), abs(position.y)), 0.0, overlay >= 2u && overlay <= 4u);
-    out.overlay = overlay;
-    out.glint_uv = vec2(0.0);
-    if overlay == 4u { out.spherical = length(position); }
-    return out;
-}
-@vertex fn vs_entity(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
-    @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>,
-    @location(5) normal: vec4<f32>, @location(6) glint_uv: vec2<f32>) -> Out {
-    var out = entity_vertex(position, uv, overlay & 0xffffu, color, light, normal);
-    out.glint_uv = glint_uv;
-    out.tier = overlay >> 16u;
-    return out;
-}
-// Retained bolt-local geometry, translated using the same f64 camera
-// subtraction as the former CPU path before adding each local f32 position.
-// The bolt offset is instance attribute 7: 6 is the entity vertex's glint UV.
-@vertex fn vs_lightning(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
-    @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>, @location(5) normal: vec4<f32>,
-    @location(7) offset: vec3<f32>) -> Out {
-    return entity_vertex(offset + position, uv, overlay, color, light, normal);
-}
-struct CloudInfo {
-    offset: vec4<f32>,
-    colors: array<vec4<f32>, 4>,
-}
-@group(1) @binding(0) var<uniform> cloud: CloudInfo;
-@vertex fn vs_cloud(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
-    @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>, @location(5) normal: vec4<f32>) -> Out {
-    return entity_vertex(position + cloud.offset.xyz, uv, overlay, cloud.colors[light.x], light, normal);
-}
-// rendertype_end_portal.fsh: the layer colours.
-const PORTAL_COLORS = array<vec3<f32>, 16>(
-    vec3(0.022087, 0.098399, 0.110818),
-    vec3(0.011892, 0.095924, 0.089485),
-    vec3(0.027636, 0.101689, 0.100326),
-    vec3(0.046564, 0.109883, 0.114838),
-    vec3(0.064901, 0.117696, 0.097189),
-    vec3(0.063761, 0.086895, 0.123646),
-    vec3(0.084817, 0.111994, 0.166380),
-    vec3(0.097489, 0.154120, 0.091064),
-    vec3(0.106152, 0.131144, 0.195191),
-    vec3(0.097721, 0.110188, 0.187229),
-    vec3(0.133516, 0.138278, 0.148582),
-    vec3(0.070006, 0.243332, 0.235792),
-    vec3(0.196766, 0.142899, 0.214696),
-    vec3(0.047281, 0.315338, 0.321970),
-    vec3(0.204675, 0.390010, 0.302066),
-    vec3(0.080955, 0.314821, 0.661491),
-);
-// textureProj on a repeating texture that lives in the atlas at `rect`.
-fn portal_sample(rect: vec4<f32>, p: vec4<f32>) -> vec3<f32> {
-    let st = fract(p.xy / p.w);
-    return textureSampleLevel(atlas, atlas_sampler, rect.xy + st * rect.zw, 0.0).rgb;
-}
-// texProj0 * end_portal_layer(layer): the row vector through mat4(scale * rotate),
-// translate and SCALE_TRANSLATE in turn.
-fn portal_layer(p: vec4<f32>, layer: f32) -> vec4<f32> {
-    let a = radians((layer * layer * 4321.0 + layer * 9.0) * 2.0);
-    let c = cos(a);
-    let s = sin(a);
-    let k = (4.5 - layer / 4.0) * 2.0;
-    var v = vec4(k * (c * p.x - s * p.y), k * (s * p.x + c * p.y), p.z, p.w);
-    v = vec4(v.x + 17.0 / layer * v.w, v.y + (2.0 + layer / 1.5) * (globals.time.x * 1.5) * v.w, v.z, v.w);
-    return vec4(0.5 * v.x + 0.25 * v.w, 0.5 * v.y + 0.25 * v.w, v.z, v.w);
-}
-fn linear_fog(d: f32, start: f32, end: f32) -> f32 {
-    if d <= start { return 0.0; }
-    if d >= end { return 1.0; }
-    return (d - start) / (end - start);
-}
-// TextureTransform.setupGlintTexturing(0.16), ARMOR_ENTITY_GLINT_TEXTURING.
-// globals.time.w is (Util.getMillis() * glintSpeed * 8) modulo 330000, the
-// common period of both offsets.
-fn armor_glint_uv(model: vec2<f32>) -> vec2<f32> {
-    let ticks = globals.time.w;
-    let offset0 = (ticks % 110000.0) / 110000.0;
-    let offset1 = (ticks % 30000.0) / 30000.0;
-    let angle = 0.17453292;
-    let c = cos(angle);
-    let s = sin(angle);
-    let scaled = model * 0.16;
-    return vec2(scaled.x * c - scaled.y * s - offset0,
-                scaled.x * s + scaled.y * c + offset1);
-}
-// RenderPipelines.GLINT: the source colour is scaled by itself, so `GlintAlpha`
-// is squared along with the sample.
-fn glint_over(color: vec4<f32>, glint: vec4<f32>) -> vec4<f32> {
-    let alpha = globals.fog_ends.w;
-    let g = alpha * glint;
-    return vec4(color.rgb + g.rgb * g.rgb, max(color.a, alpha));
-}
-// CRUMBLING_UV_BEGIN
-fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>, dimensions: vec2<u32>) -> vec2<f32> {
-    let size = vec2<f32>(dimensions);
-    // Undo stage_light's 16-bit quantization before adding local texels. Otherwise
-    // different stages can fall on opposite sides of a nearest-sampling boundary.
-    let origin = round(packed_origin * size);
-    let extent = max(round(sprite_size * size), vec2(1.0));
-    let local = min(floor(fract(uv) * extent), extent - vec2(1.0));
-    return (origin + local + vec2(0.5)) / size;
-}
-// CRUMBLING_UV_END
-@fragment fn fs_entity(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {
-    var uv = in.uv;
-    if in.overlay == 6u { uv.y = in.wrap.x + fract(in.uv.y) * in.wrap.y; }
-    if in.overlay == 11u || in.overlay == 12u {
-        // Each crack's stage sprite origin comes in its light bytes (breaking::stage_light).
-        uv = crumbling_uv(in.uv, in.wrap, globals.crumbling_sprite.zw, textureDimensions(atlas));
-    }
-    var color = textureSample(atlas, atlas_sampler, uv) * select(in.back_color, in.color, front);
-    if in.overlay == 9u || in.overlay == 10u {
-        // rendertype_end_portal: end_sky and PORTAL_LAYERS (15 for portals, 16
-        // for gateways) layers of end_portal.png projected from the screen.
-        let layers = select(15, 16, in.overlay == 10u);
-        var c = portal_sample(globals.end_portal_sprites[0], in.proj) * PORTAL_COLORS[0];
-        for (var i = 0; i < layers; i++) {
-            c += portal_sample(globals.end_portal_sprites[1], portal_layer(in.proj, f32(i + 1))) * PORTAL_COLORS[i];
-        }
-        color = vec4(c, 1.0);
-    } else if in.overlay == 4u {
-        // clouds.fsh: alpha fades out towards the cloud fog end.
-        return vec4(color.rgb, color.a * (1.0 - linear_fog(in.spherical, 0.0, globals.fog_ends.y)));
-    }
-    if color.a < 0.1 || (in.cull != 0u && !front) { discard; }
-    // entity.fsh calculateFinalColor: the overlay (hurt red, TNT white) over the
-    // lit texture, then the lightmap, then the glint and fog.
-    color = vec4(mix(in.overlay_color.rgb, color.rgb, in.overlay_color.a), color.a);
-    color *= in.light_color;
-    if in.overlay == 7u || in.overlay == 8u || in.overlay == 33u {
-        // 33: a translucent item with the glint.
-        // Enchantment glint: item.fsh's GLINT path, sampled from
-        // enchanted_glint_item at the `GLINT_TEXTURING` UV.
-        color = glint_over(color, textureSample(glint_tex, glint_sampler, in.glint_uv));
-    } else if in.overlay == 36u {
-        // Enchanted armour (mobs::render::ARMOR_GLINT): enchanted_glint_armor at the scrolling model UV.
-        color = glint_over(
-            color,
-            textureSample(glint_armor_tex, glint_sampler, armor_glint_uv(in.glint_uv)),
-        );
-    }
-    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
-    return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
-}
-
-// rendertype_outline.fsh: the vertex colour (the team colour; outline vertices carry no
-// normal, so no cardinal light) wherever the texture is not fully clear.
-// rendertype_entity_shadow.fsh: the shadow texture times the vertex colour,
-// then fog, with no alpha cutout, so a faint shadow in dim light still draws.
-@fragment fn fs_entity_shadow(in: Out) -> @location(0) vec4<f32> {
-    var color = textureSample(atlas, atlas_sampler, in.uv) * in.color;
-    color *= in.light_color;
-    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
-    return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
-}
-
-@fragment fn fs_outline(in: Out) -> @location(0) vec4<f32> {
-    if textureSample(atlas, atlas_sampler, in.uv).a == 0.0 { discard; }
-    return vec4(in.color.rgb, 1.0);
-}
-
-// HDR output: a light-giving particle's pixels marked in the frame's alpha the
-// way terrain.wgsl marks a light source's, drawn again after the entities with
-// only alpha written, so its colour stays as blended.
-@fragment fn fs_hdr_mark(in: Out) -> @location(0) vec4<f32> {
-    if in.tier == 0u || textureSample(atlas, atlas_sampler, in.uv).a < 0.1 { discard; }
-    return vec4(0.0, 0.0, 0.0, 0.7 * f32(4u - min(in.tier, 4u)) / 4.0);
-}
-
-fn celestial_color(in: Out) -> vec4<f32> {
-    return textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
-}
-@fragment fn fs_celestial(in: Out) -> @location(0) vec4<f32> {
-    return celestial_color(in);
-}
-
-// The sky's celestial pass (sun, moon, the End sky): fs_celestial's light,
-// premultiplied for an additive (one, one) blend, and as alpha how much of it
-// the texel adds, which the blend takes off the frame's alpha. HDR output
-// (hdr.wgsl) lifts only where that left it low: the sun's and moon's discs, not
-// the dark rest of their quads or the dim End sky.
-@fragment fn fs_sky_celestial(in: Out) -> @location(0) vec4<f32> {
-    let color = celestial_color(in);
-    let added = color.rgb * color.a;
-    return vec4(added, smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b))));
-}
-
-// RenderPipelines.ENERGY_SWIRL (entity.fsh with EMISSIVE and NO_OVERLAY): the sprite, scrolled by
-// the UV and repeated within itself, times the layer colour 0xFF808080, unlit; the pipeline adds
-// it to the frame. The light bytes carry the sprite's origin and the colour bytes its size, both
-// as breaking::stage_light packs them.
-@fragment fn fs_energy_swirl(in: Out) -> @location(0) vec4<f32> {
-    let bytes = round(in.color * 255.0);
-    let size = vec2(bytes.x + bytes.y * 256.0, bytes.z + bytes.w * 256.0) / 65535.0;
-    let color = textureSample(atlas, atlas_sampler, crumbling_uv(in.uv, in.wrap, size, textureDimensions(atlas)));
-    if color.a < 0.1 { discard; }
-    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
-    return vec4(mix(color.rgb * (128.0 / 255.0), globals.fog_color.rgb, f * globals.fog_color.a), color.a);
-}
-
-// RenderPipelines.WATER_MASK: depth only (the pipeline masks the colour off).
-@fragment fn fs_water_mask() -> @location(0) vec4<f32> {
-    return vec4(0.0);
-}
-
-// WEATHER_MATH_BEGIN
-// Unsigned 64-bit helpers (low word first). Snow adds a random double to a
-// float drift before casting to float. Retaining the 53-bit base avoids early
-// rounding, including ties, without requiring optional GPU float64 support.
-fn weather_shr_jam(v: vec2<u32>, n: u32) -> vec2<u32> {
-    if n == 0u { return v; }
-    if n < 32u {
-        return vec2((v.x >> n) | (v.y << (32u - n)) | select(0u, 1u, (v.x << (32u - n)) != 0u), v.y >> n);
-    }
-    if n == 32u { return vec2(v.y | select(0u, 1u, v.x != 0u), 0u); }
-    if n < 64u {
-        return vec2((v.y >> (n - 32u)) | select(0u, 1u, v.x != 0u || (v.y << (64u - n)) != 0u), 0u);
-    }
-    return vec2(select(0u, 1u, any(v != vec2(0u))), 0u);
-}
-fn weather_add64(a: vec2<u32>, b: vec2<u32>) -> vec2<u32> {
-    let lo = a.x + b.x;
-    return vec2(lo, a.y + b.y + select(0u, 1u, lo < a.x));
-}
-fn weather_sub64(a: vec2<u32>, b: vec2<u32>) -> vec2<u32> {
-    return vec2(a.x - b.x, a.y - b.y - select(0u, 1u, a.x < b.x));
-}
-fn weather_double_plus_float(base: vec2<u32>, delta: f32) -> f32 {
-    // The random base is nonnegative and either zero or >= 2^-53.
-    if all(base == vec2(0u)) { return select(delta, 0.0, delta == 0.0); }
-    let db = bitcast<u32>(delta);
-    let mag = db & 0x7fffffffu;
-    let be = i32((base.y >> 20u) & 2047u) - 1023;
-    var de = i32(mag >> 23u) - 127;
-    var dm = (mag & 0x7fffffu) | 0x800000u;
-    if mag < 0x800000u {
-        dm = mag;
-        if dm == 0u { de = -200; }
-        else {
-            let shift = countLeadingZeros(dm) - 8u;
-            dm <<= shift;
-            de = -126 - i32(shift);
-        }
-    }
-    let e = max(be, de);
-    // Leading significand bit at 61, with room for addition and guard bits.
-    var a = vec2(base.x << 9u, ((base.y & 0xfffffu) | 0x100000u) << 9u | (base.x >> 23u));
-    var b = vec2(0u, dm << 6u);
-    a = weather_shr_jam(a, u32(e - be));
-    b = weather_shr_jam(b, u32(e - de));
-    var sign = 0u;
-    var value: vec2<u32>;
-    if (db >> 31u) == 0u { value = weather_add64(a, b); }
-    else if a.y > b.y || (a.y == b.y && a.x >= b.x) { value = weather_sub64(a, b); }
-    else { value = weather_sub64(b, a); sign = 0x80000000u; }
-    if all(value == vec2(0u)) { return 0.0; }
-    let leading = select(31u - countLeadingZeros(value.x), 63u - countLeadingZeros(value.y), value.y != 0u);
-    var exponent = e + i32(leading) - 61;
-    // Normalize the leading bit to 62. After jamming, bit 38 is the guard
-    // bit and bits 0..37 distinguish a tie from a value above the midpoint.
-    let shift = 62u - leading;
-    if shift >= 32u { value = vec2(0u, value.x << (shift - 32u)); }
-    else if shift != 0u { value = vec2(value.x << shift, (value.y << shift) | (value.x >> (32u - shift))); }
-    // Vanilla first rounds the addition to double, then casts to float.
-    // Round at bit 10 (53 retained bits) before the 24-bit rounding below;
-    // otherwise a double-rounding midpoint can select the wrong float.
-    let double_guard = (value.x & 512u) != 0u;
-    let double_sticky = (value.x & 511u) != 0u;
-    let double_odd = (value.x & 1024u) != 0u;
-    value.x &= 0xfffffc00u;
-    if double_guard && (double_sticky || double_odd) {
-        value = weather_add64(value, vec2(1024u, 0u));
-    }
-    if (value.y & 0x80000000u) != 0u {
-        value = weather_shr_jam(value, 1u);
-        exponent += 1;
-    }
-    var mantissa = value.y >> 7u;
-    let guard = (value.y & 64u) != 0u;
-    let sticky = (value.y & 63u) != 0u || value.x != 0u;
-    if guard && (sticky || (mantissa & 1u) != 0u) { mantissa += 1u; }
-    if mantissa >= 0x1000000u { mantissa >>= 1u; exponent += 1; }
-    return bitcast<f32>(sign | (u32(exponent + 127) << 23u) | (mantissa & 0x7fffffu));
-}
-fn weather_phase(animation: vec4<f32>, bases: vec4<u32>, snow: u32, time: vec4<f32>) -> vec2<f32> {
-    if snow == 0u {
-        let ticks = time.x + animation.y;
-        let t = ticks + time.z;
-        let step = -t / 32.0;
-        let offset = step * animation.x;
-        return vec2(0.0, offset % 32.0);
-    }
-    let t = time.x + time.z;
-    let u_time = t * 0.01;
-    let du = u_time * animation.z;
-    let v_time = t * animation.w;
-    let dv = v_time * 0.001;
-    let u = weather_double_plus_float(bases.xy, du);
-    let v = weather_double_plus_float(bases.zw, dv);
-    let fall_time = time.y + time.z;
-    let fall = -fall_time / 512.0;
-    return vec2(u, fall + v);
-}
-// Atlas sampler is nearest with no mipmaps. Clamp the integer texel inside
-// the sprite even when a fractional coordinate rounds up at its far edge.
-fn weather_texel(uv: vec2<f32>, rect: vec4<f32>, dimensions: vec2<u32>) -> vec2<i32> {
-    let size = vec2<f32>(dimensions);
-    let origin = vec2<i32>(round(rect.xy * size));
-    let extent = max(vec2<i32>(round(rect.zw * size)), vec2(1));
-    let local = min(vec2<i32>(floor(fract(uv) * vec2<f32>(extent))), extent - vec2(1));
-    return origin + local;
-}
-// WEATHER_MATH_END
-
-struct WeatherTime { values: vec4<f32> }
-@group(1) @binding(1) var<uniform> weather_time: WeatherTime;
-@vertex fn vs_weather(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
-    @location(2) rect: vec4<f32>, @location(3) animation: vec4<f32>,
-    @location(4) bases: vec4<u32>, @location(5) color: vec4<f32>,
-    @location(6) light: vec4<u32>, @location(7) snow: u32) -> Out {
-    let phase = weather_phase(animation, bases, snow, weather_time.values);
-    var out = entity_vertex(position, uv + phase, 0u, color, light, vec4(0.0));
-    out.weather_rect = rect;
-    return out;
-}
-@fragment fn fs_weather(in: Out) -> @location(0) vec4<f32> {
-    // Repeat within this sprite, never across the atlas. The atlas uses nearest
-    // filtering and no mipmaps, so fractional UVs have no seam derivatives.
-    let texel = weather_texel(in.uv, in.weather_rect, textureDimensions(atlas));
-    var color = textureLoad(atlas, texel, 0) * in.color;
-    if color.a < 0.1 { discard; }
-    color *= in.light_color;
-    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
-    return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
-}

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

@@ -1,867 +0,0 @@
-//! Animated block sprites, drawn on the GPU as vanilla 26.3 draws them:
-//! `SpriteContents.AnimatedTexture` keeps every frame in video memory, and
-//! each tick `animate_sprite_blit` or `animate_sprite_interpolate` draws the
-//! frame shown (mixed with the next one for `interpolate`) into the atlas.
-//!
-//! Every frame's mip chain is uploaded once, at the sprite's own size. A tick
-//! that changes sprites writes one small job per changed sprite and runs one
-//! compute dispatch per mip level (`animate.wgsl`), which repeats the chain
-//! into the array's larger layers by whole pixels and mixes interpolated
-//! frames. Blending on the CPU at the array's size and copying every changed
-//! sprite level by level (a copy command each, a blit each in Mesa) was about
-//! a fifth of the render thread on an integrated GPU.
-//!
-//! Without compute shaders (OpenGL before 4.3, the last fallback) the same
-//! jobs run on the CPU, the same integer mix as `animate.wgsl`, and each
-//! changed level is copied into its layer.
-use super::upload::Uploads;
-use crate::mipmap::Settings;
-use crate::sprites::{FrameBlend, SpriteAnimation};
-use wgpu::util::DeviceExt;
-
-/// Bytes of `animate.wgsl`'s `Job`.
-const JOB_BYTES: usize = 20;
-/// `animate.wgsl`'s workgroup edge.
-const WORKGROUP: u32 = 8;
-
-struct Sprite {
-    animation: SpriteAnimation,
-    /// What its layer shows (`None`: the frame the array was created with,
-    /// rewritten on the first tick).
-    shown: Option<FrameBlend>,
-    /// Its layer in its sprite array.
-    layer: u32,
-    /// Each frame's mip chain: its offset in words in the group's frames.
-    frames: Vec<u32>,
-    /// Edge of the chains' first level.
-    edge: u32,
-    group: usize,
-}
-
-/// The animated sprites of one sprite array whose frames share one buffer.
-struct Group {
-    /// Where its jobs start in `SpriteAnimator::jobs`, in bytes.
-    offset: u64,
-    /// One bind group per mip level of the array (none on the CPU).
-    levels: Vec<wgpu::BindGroup>,
-    /// This tick's jobs.
-    jobs: Vec<u8>,
-    /// Its sprite array and its frames, for the CPU.
-    array: usize,
-    buffer: usize,
-}
-
-/// Where the jobs run.
-enum Writer {
-    Gpu {
-        jobs: wgpu::Buffer,
-        pipeline: wgpu::ComputePipeline,
-    },
-    /// Every frames buffer's words, and the sprite arrays to copy into.
-    Cpu {
-        frames: Vec<Vec<u8>>,
-        textures: Vec<wgpu::Texture>,
-    },
-}
-
-pub(super) struct SpriteAnimator {
-    sprites: Vec<Sprite>,
-    groups: Vec<Group>,
-    writer: Writer,
-    /// Edge of the arrays' layers.
-    size: u32,
-    /// The layers the last `animate` rewrote, counted over all arrays.
-    changed: Vec<u32>,
-}
-
-impl SpriteAnimator {
-    /// `textures` are the sprite arrays, `split` layers each, `size` pixels
-    /// wide; `animations` hold their frames at that size. `compute`: whether
-    /// the device says it runs compute shaders writing storage textures.
-    pub fn new(
-        device: &wgpu::Device,
-        animations: &[SpriteAnimation],
-        size: u32,
-        settings: &[Settings],
-        textures: &[wgpu::Texture],
-        split: u32,
-        compute: bool,
-    ) -> Self {
-        let pipeline = if compute { pipeline(device) } else { None };
-        let limits = device.limits();
-        let limit = if pipeline.is_some() {
-            limits
-                .max_storage_buffer_binding_size
-                .min(limits.max_buffer_size)
-        } else {
-            // Word offsets.
-            u64::from(u32::MAX) * 4
-        };
-        let mut frames: Vec<Vec<u8>> = Vec::new();
-        // Each group's sprite array and frames buffer.
-        let mut keys: Vec<(u32, usize)> = Vec::new();
-        let mut counts: Vec<usize> = Vec::new();
-        let mut sprites = Vec::with_capacity(animations.len());
-        for animation in animations {
-            let pixels: Vec<_> = (0..animation.frame_count())
-                .map(|frame| animation.pixels(frame))
-                .collect();
-            let (chains, edge) = source_chains(&pixels, size, settings, animation.layer);
-            let bytes: u64 = chains.iter().map(|chain| chain.len() as u64).sum();
-            if bytes > limit {
-                log::warn!(
-                    "Horizon: layer {}'s animation ({bytes} bytes) does not fit in a storage buffer; it stays still",
-                    animation.layer
-                );
-                continue;
-            }
-            if frames
-                .last()
-                .is_none_or(|data| data.len() as u64 + bytes > limit)
-            {
-                frames.push(Vec::new());
-            }
-            let buffer = frames.len() - 1;
-            let data = &mut frames[buffer];
-            let offsets = chains
-                .iter()
-                .map(|chain| {
-                    let offset = (data.len() / 4) as u32;
-                    data.extend_from_slice(chain);
-                    offset
-                })
-                .collect();
-            let key = (animation.layer / split, buffer);
-            let group = keys.iter().position(|&k| k == key).unwrap_or_else(|| {
-                keys.push(key);
-                counts.push(0);
-                keys.len() - 1
-            });
-            counts[group] += 1;
-            sprites.push(Sprite {
-                animation: animation.clone(),
-                shown: None,
-                layer: animation.layer % split,
-                frames: offsets,
-                edge,
-                group,
-            });
-        }
-        let Some((pipeline, layout)) = pipeline else {
-            let groups = keys
-                .iter()
-                .zip(&counts)
-                .map(|(&(array, buffer), &count)| Group {
-                    offset: 0,
-                    levels: Vec::new(),
-                    jobs: Vec::with_capacity(count * JOB_BYTES),
-                    array: array as usize,
-                    buffer,
-                })
-                .collect();
-            return Self {
-                sprites,
-                groups,
-                writer: Writer::Cpu {
-                    frames,
-                    textures: textures.to_vec(),
-                },
-                size,
-                changed: Vec::new(),
-            };
-        };
-        let frames: Vec<_> = frames
-            .iter()
-            .map(|data| {
-                device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-                    label: Some("Animated sprite frames"),
-                    contents: data,
-                    usage: wgpu::BufferUsages::STORAGE,
-                })
-            })
-            .collect();
-        let align = u64::from(limits.min_storage_buffer_offset_alignment);
-        let mut offsets = Vec::with_capacity(counts.len());
-        let mut total = 0;
-        for &count in &counts {
-            offsets.push(total);
-            total = (total + (count * JOB_BYTES) as u64).next_multiple_of(align);
-        }
-        let jobs = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Animated sprite jobs"),
-            size: total.max(align),
-            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
-        let groups = keys
-            .iter()
-            .zip(&counts)
-            .zip(offsets)
-            .map(|((&(array, buffer), &count), offset)| {
-                let texture = &textures[array as usize];
-                let levels = (0..texture.mip_level_count())
-                    .map(|level| {
-                        let view = texture.create_view(&wgpu::TextureViewDescriptor {
-                            label: Some("Animated sprites"),
-                            dimension: Some(wgpu::TextureViewDimension::D2Array),
-                            base_mip_level: level,
-                            mip_level_count: Some(1),
-                            ..Default::default()
-                        });
-                        device.create_bind_group(&wgpu::BindGroupDescriptor {
-                            label: Some("Animated sprites"),
-                            layout: &layout,
-                            entries: &[
-                                wgpu::BindGroupEntry {
-                                    binding: 0,
-                                    resource: frames[buffer].as_entire_binding(),
-                                },
-                                wgpu::BindGroupEntry {
-                                    binding: 1,
-                                    resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
-                                        buffer: &jobs,
-                                        offset,
-                                        size: wgpu::BufferSize::new((count * JOB_BYTES) as u64),
-                                    }),
-                                },
-                                wgpu::BindGroupEntry {
-                                    binding: 2,
-                                    resource: wgpu::BindingResource::TextureView(&view),
-                                },
-                            ],
-                        })
-                    })
-                    .collect();
-                Group {
-                    offset,
-                    levels,
-                    jobs: Vec::with_capacity(count * JOB_BYTES),
-                    array: array as usize,
-                    buffer,
-                }
-            })
-            .collect();
-        Self {
-            sprites,
-            groups,
-            writer: Writer::Gpu { jobs, pipeline },
-            size,
-            changed: Vec::new(),
-        }
-    }
-
-    /// Whether the jobs can run on the GPU: compute shaders writing a
-    /// storage texture and reading two storage buffers (not OpenGL before
-    /// 4.3).
-    pub fn compute(adapter: &wgpu::Adapter, device: &wgpu::Device) -> bool {
-        let limits = device.limits();
-        adapter
-            .get_downlevel_capabilities()
-            .flags
-            .contains(wgpu::DownlevelFlags::COMPUTE_SHADERS)
-            && limits.max_storage_textures_per_shader_stage >= 1
-            && limits.max_storage_buffers_per_shader_stage >= 2
-    }
-
-    /// The layers the last `animate` rewrote (for the shader pack atlas).
-    pub fn changed(&self) -> &[u32] {
-        &self.changed
-    }
-
-    /// Show every sprite's frame at `tick`, rewriting only the sprites whose
-    /// frame or mix changed (`SpriteContents.AnimationState.tick`).
-    pub fn animate(
-        &mut self,
-        encoder: &mut wgpu::CommandEncoder,
-        uploads: &mut Uploads,
-        tick: u64,
-    ) {
-        if self.collect(tick) == 0 {
-            return;
-        }
-        let (jobs, pipeline) = match &self.writer {
-            Writer::Gpu { jobs, pipeline } => (jobs, pipeline),
-            Writer::Cpu { frames, textures } => {
-                for group in &mut self.groups {
-                    let (frames, texture) = (&frames[group.buffer], &textures[group.array]);
-                    for job in group.jobs.as_chunks::<JOB_BYTES>().0 {
-                        let (words, _) = job.as_chunks::<4>();
-                        let job: [u32; 5] = std::array::from_fn(|i| u32::from_le_bytes(words[i]));
-                        for level in 0..texture.mip_level_count() {
-                            let width = self.size >> level;
-                            uploads.texture(
-                                encoder,
-                                wgpu::TexelCopyTextureInfo {
-                                    texture,
-                                    mip_level: level,
-                                    origin: wgpu::Origin3d {
-                                        x: 0,
-                                        y: 0,
-                                        z: job[0],
-                                    },
-                                    aspect: wgpu::TextureAspect::All,
-                                },
-                                width,
-                                width,
-                                &mix_level(frames, job, width),
-                            );
-                        }
-                    }
-                    group.jobs.clear();
-                }
-                return;
-            }
-        };
-        for group in &self.groups {
-            uploads.buffer(encoder, jobs, group.offset, &group.jobs);
-        }
-        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
-            label: Some("Animated sprites"),
-            timestamp_writes: None,
-        });
-        pass.set_pipeline(pipeline);
-        for group in &mut self.groups {
-            let count = (group.jobs.len() / JOB_BYTES) as u32;
-            if count == 0 {
-                continue;
-            }
-            for (level, bind) in group.levels.iter().enumerate() {
-                let groups = (self.size >> level).div_ceil(WORKGROUP);
-                pass.set_bind_group(0, bind, &[]);
-                pass.dispatch_workgroups(groups, groups, count);
-            }
-            group.jobs.clear();
-        }
-    }
-
-    /// Queue a job for every sprite whose blend at `tick` differs from what
-    /// its layer shows; the number of jobs.
-    fn collect(&mut self, tick: u64) -> usize {
-        let mut count = 0;
-        self.changed.clear();
-        for sprite in &mut self.sprites {
-            let blend = sprite.animation.blend(tick);
-            if sprite.shown == Some(blend) {
-                continue;
-            }
-            sprite.shown = Some(blend);
-            self.changed.push(sprite.animation.layer);
-            let job = [
-                sprite.layer,
-                sprite.frames[blend.frame],
-                sprite.frames[blend.next],
-                blend.millis,
-                sprite.edge,
-            ];
-            let jobs = &mut self.groups[sprite.group].jobs;
-            for word in job {
-                jobs.extend_from_slice(&word.to_le_bytes());
-            }
-            count += 1;
-        }
-        count
-    }
-}
-
-/// `animate.wgsl`'s pipeline and the bind group layout of its group 0,
-/// unless the device fails to make the pipeline: an OpenGL driver can list
-/// compute shaders among its extensions while wgpu writes the GLSL version
-/// of its core version, which has none (Mesa's `MESA_GL_VERSION_OVERRIDE`,
-/// older drivers). A device lost between the scopes' pushes answers pipeline
-/// creation with a silent placeholder and reports its invalidity only when
-/// the layout is asked for — inside the scopes that error is caught, outside
-/// them it is uncaptured and panics (#3866).
-fn pipeline(device: &wgpu::Device) -> Option<(wgpu::ComputePipeline, wgpu::BindGroupLayout)> {
-    let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
-    let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
-    let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-        label: Some("Animated sprites"),
-        source: wgpu::ShaderSource::Wgsl(include_str!("animate.wgsl").into()),
-    });
-    let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
-        label: Some("Animated sprites"),
-        layout: None,
-        module: &module,
-        entry_point: Some("animate"),
-        compilation_options: Default::default(),
-        cache: None,
-    });
-    let layout = pipeline.get_bind_group_layout(0);
-    let internal = pollster::block_on(internal.pop());
-    match internal.or(pollster::block_on(validation.pop())) {
-        None => Some((pipeline, layout)),
-        Some(e) => {
-            log::warn!("Horizon renderer: animated sprites drawn on the CPU ({e})");
-            None
-        }
-    }
-}
-
-/// `animate.wgsl` on the CPU: one `width` wide level of a job
-/// (`[layer, current, next, millis, edge]`) from `frames`' chains.
-fn mix_level(frames: &[u8], [_, current, next, millis, edge]: [u32; 5], width: u32) -> Vec<u8> {
-    let mut out = Vec::with_capacity((width * width * 4) as usize);
-    for y in 0..width {
-        for x in 0..width {
-            let texel = if width >= edge {
-                let scale = width / edge;
-                y / scale * edge + x / scale
-            } else {
-                4 * (edge * edge - width * width) / 3 + y * width + x
-            };
-            let at = |chain: u32| ((chain + texel) * 4) as usize;
-            let a = &frames[at(current)..at(current) + 4];
-            if millis == 0 {
-                out.extend_from_slice(a);
-                continue;
-            }
-            let b = &frames[at(next)..at(next) + 4];
-            out.extend(a.iter().zip(b).map(|(&a, &b)| {
-                ((u32::from(a) * (1000 - millis) + u32::from(b) * millis + 500) / 1000) as u8
-            }));
-        }
-    }
-    out
-}
-
-/// The mip chain a frame's layer is made of, and its first level's edge.
-/// `mipmap::generate` makes a sprite scaled up by whole pixels to the
-/// array's size from its own size's chain, its first level repeated into the
-/// larger levels: that chain, which the shader repeats. Any other sprite: its
-/// chain at the array's size.
-#[cfg(test)]
-fn source_chain(pixels: &[u8], size: u32, settings: &[Settings], layer: u32) -> (Vec<u8>, u32) {
-    let (mut chains, edge) = source_chains(&[pixels], size, settings, layer);
-    (chains.swap_remove(0), edge)
-}
-
-/// Every frame's chain, laid out as one frame's `source_chain`, but mipmapped as
-/// vanilla's `SpriteContents.increaseMipLevel` does: over the whole animation
-/// sheet (the frames stacked), so `solidify` and the alpha-to-coverage scale
-/// of each level are the sheet's, not each frame's. A frame alone has a
-/// single texel square at its 2x2 level, and its coverage scale could round
-/// a whole far frame transparent (kelp blinking out at distance).
-fn source_chains(
-    frames: &[&[u8]],
-    size: u32,
-    settings: &[Settings],
-    layer: u32,
-) -> (Vec<Vec<u8>>, u32) {
-    let s = settings.get(layer as usize).copied().unwrap_or_default();
-    let edge = if s.native_size.is_power_of_two() && s.native_size < size {
-        s.native_size
-    } else {
-        size
-    };
-    let mut sheet = crate::mipmap::Image {
-        width: edge,
-        height: edge * frames.len() as u32,
-        pixels: Vec::with_capacity((edge * edge) as usize * frames.len()),
-    };
-    for frame in frames {
-        let frame = crate::sprites::resample(frame, size, edge);
-        sheet.pixels.extend_from_slice(frame.as_chunks::<4>().0);
-    }
-    let has_transparent = s.has_transparent || sheet.pixels.iter().any(|p| p[3] == 0);
-    let levels = crate::mipmap::generate(
-        sheet,
-        edge.trailing_zeros(),
-        Settings {
-            has_transparent,
-            ..s
-        },
-    );
-    let chains = (0..frames.len())
-        .map(|frame| {
-            let mut chain = Vec::new();
-            for level in &levels {
-                let texels = (level.width * level.width) as usize;
-                chain.extend(
-                    level.pixels[frame * texels..(frame + 1) * texels]
-                        .iter()
-                        .flatten(),
-                );
-            }
-            chain
-        })
-        .collect();
-    (chains, edge)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::mipmap::Strategy;
-
-    /// `animate.wgsl` on the CPU: `chain` (first level `edge` wide) as the
-    /// full chain of a `size` layer, mixed `millis` thousandths of the way
-    /// towards `next`.
-    fn reference(chain: &[u8], next: &[u8], millis: u32, edge: u32, size: u32) -> Vec<u8> {
-        let levels = size.trailing_zeros() + 1;
-        let mut out = Vec::new();
-        for level in 0..levels {
-            let width = size >> level;
-            for y in 0..width {
-                for x in 0..width {
-                    let texel = if width >= edge {
-                        let scale = width / edge;
-                        y / scale * edge + x / scale
-                    } else {
-                        4 * (edge * edge - width * width) / 3 + y * width + x
-                    } as usize;
-                    for c in 0..4 {
-                        let (a, b) = (
-                            u32::from(chain[texel * 4 + c]),
-                            u32::from(next[texel * 4 + c]),
-                        );
-                        out.push(((a * (1000 - millis) + b * millis + 500) / 1000) as u8);
-                    }
-                }
-            }
-        }
-        out
-    }
-
-    fn frame(size: u32, seed: u32) -> Vec<u8> {
-        (0..size * size)
-            .flat_map(|i| {
-                let v = i
-                    .wrapping_mul(2654435761)
-                    .wrapping_add(seed.wrapping_mul(40503));
-                let alpha = match v >> 29 {
-                    0 => 0,
-                    1 => 77,
-                    _ => 255,
-                };
-                [(v >> 3) as u8, (v >> 11) as u8, (v >> 19) as u8, alpha]
-            })
-            .collect()
-    }
-
-    fn settings(native: u32, strategy: Strategy) -> Settings {
-        Settings {
-            native_size: native,
-            strategy,
-            alpha_cutoff_bias: -0.1,
-            ..Default::default()
-        }
-    }
-
-    #[test]
-    fn source_chains_repeat_into_the_array_chain() {
-        // Sprites scaled up by whole pixels, at the array's size, and of a
-        // size that is not a power of two (scaled up to the next one).
-        for (native, size) in [(16, 16), (16, 64), (8, 32), (32, 64), (1, 16), (24, 32)] {
-            for strategy in [
-                Strategy::Auto,
-                Strategy::Mean,
-                Strategy::Cutout,
-                Strategy::StrictCutout,
-                Strategy::DarkCutout,
-            ] {
-                for item in [false, true] {
-                    let settings = [
-                        Settings::default(),
-                        Settings {
-                            item,
-                            ..settings(native, strategy)
-                        },
-                    ];
-                    let pixels = crate::sprites::resample(&frame(native, 3), native, size);
-                    let (expected, _) = super::super::mip_chain(&pixels, size, &settings, 1, 1);
-                    let (chain, edge) = source_chain(&pixels, size, &settings, 1);
-                    let fits = native.is_power_of_two() && native < size;
-                    assert_eq!(edge, if fits { native } else { size });
-                    assert_eq!(
-                        reference(&chain, &chain, 0, edge, size),
-                        expected,
-                        "{native} in {size}, {strategy:?}, item {item}"
-                    );
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn real_animation_chains_repeat_into_the_array_chain() {
-        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../../.local/horizon-client")
-            .join(horizon_core::VANILLA_VERSION);
-        if !root
-            .join("assets/minecraft/textures/block/water_still.png")
-            .exists()
-        {
-            return;
-        }
-        let mut sprites = crate::sprites::Sprites::default();
-        for name in [
-            "water_still",
-            "water_flow",
-            "lava_still",
-            "fire_0",
-            "nether_portal",
-            "sea_lantern",
-            "prismarine",
-            "magma",
-            "kelp",
-            "straw_bed",
-        ] {
-            sprites
-                .insert(&root, &format!("minecraft:block/{name}"))
-                .unwrap();
-        }
-        sprites.finish();
-        assert_eq!(sprites.size, 64);
-        assert_eq!(sprites.animations.len(), 9);
-        for animation in &sprites.animations {
-            for frame in 0..animation.frame_count() {
-                let pixels = animation.pixels(frame);
-                let (expected, _) =
-                    super::super::mip_chain(pixels, 64, &sprites.mips, animation.layer, 1);
-                let (chain, edge) = source_chain(pixels, 64, &sprites.mips, animation.layer);
-                assert!(edge < 64, "layer {}", animation.layer);
-                assert_eq!(reference(&chain, &chain, 0, edge, 64), expected);
-            }
-        }
-    }
-
-    #[test]
-    fn kelp_frames_share_the_sheet_mips() {
-        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../../.local/horizon-client")
-            .join(horizon_core::VANILLA_VERSION);
-        if !root
-            .join("assets/minecraft/textures/block/kelp.png")
-            .exists()
-        {
-            return;
-        }
-        let mut sprites = crate::sprites::Sprites::default();
-        for name in ["kelp", "kelp_plant", "seagrass", "tall_seagrass_top"] {
-            sprites
-                .insert(&root, &format!("minecraft:block/{name}"))
-                .unwrap();
-        }
-        sprites.finish();
-        // A level drawn nowhere: no texel passes the cutout's alpha test.
-        let blank = |chain: &[u8], edge: u32| {
-            let mut start = 0;
-            let mut level = edge;
-            let mut blank = Vec::new();
-            while level > 0 {
-                let bytes = (level * level * 4) as usize;
-                let texels = &chain[start..start + bytes];
-                blank.push(texels.as_chunks::<4>().0.iter().all(|p| p[3] < 128));
-                start += bytes;
-                level >>= 1;
-            }
-            blank
-        };
-        let mut blinked = 0;
-        for animation in &sprites.animations {
-            let size = sprites.size;
-            let pixels: Vec<_> = (0..animation.frame_count())
-                .map(|f| animation.pixels(f))
-                .collect();
-            let (chains, edge) = source_chains(&pixels, size, &sprites.mips, animation.layer);
-            for (frame, chain) in chains.iter().enumerate() {
-                // The 1x1 level has no texel square to measure coverage on
-                // (vanilla leaves it unscaled); every larger level shows.
-                let levels = blank(chain, edge);
-                assert!(
-                    !levels[..levels.len() - 1].contains(&true),
-                    "layer {} frame {frame}: {levels:?}",
-                    animation.layer
-                );
-                let (alone, _) = source_chain(pixels[frame], size, &sprites.mips, animation.layer);
-                let alone = blank(&alone, edge);
-                blinked += usize::from(alone[..alone.len() - 1].contains(&true));
-            }
-        }
-        // Mipmapped frame by frame, some kelp frames vanished at the 2x2 level.
-        assert!(blinked > 0);
-    }
-
-    #[test]
-    fn rounding_matches_f32_mix_but_for_exact_halves() {
-        // The CPU blend this replaced: f32 mix, then rounded. They differ
-        // only where the exact mix is a half, which f32 rounded either way.
-        for millis in 1..1000u32 {
-            let t = millis as f32 / 1000.0;
-            for a in 0..=255u32 {
-                for b in (0..=255u32).step_by(3) {
-                    let f = ((a as f32 / 255.0) * (1.0 - t) + (b as f32 / 255.0) * t) * 255.0;
-                    let exact = a * (1000 - millis) + b * millis;
-                    let ours = (exact + 500) / 1000;
-                    if exact % 1000 != 500 {
-                        assert_eq!(ours, f.round() as u32, "{a} {b} {millis}");
-                    }
-                }
-            }
-        }
-    }
-
-    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()
-    }
-
-    /// Every layer's full mip chain, layer major.
-    fn read_back(
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        texture: &wgpu::Texture,
-    ) -> Vec<Vec<u8>> {
-        let layers = texture.depth_or_array_layers();
-        let mut out = vec![Vec::new(); layers as usize];
-        for level in 0..texture.mip_level_count() {
-            let edge = texture.width() >> level;
-            let padded = (edge * 4).next_multiple_of(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT);
-            let buffer = device.create_buffer(&wgpu::BufferDescriptor {
-                label: None,
-                size: u64::from(padded * edge * layers),
-                usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
-                mapped_at_creation: false,
-            });
-            let mut encoder = device.create_command_encoder(&Default::default());
-            encoder.copy_texture_to_buffer(
-                wgpu::TexelCopyTextureInfo {
-                    texture,
-                    mip_level: level,
-                    origin: wgpu::Origin3d::ZERO,
-                    aspect: wgpu::TextureAspect::All,
-                },
-                wgpu::TexelCopyBufferInfo {
-                    buffer: &buffer,
-                    layout: wgpu::TexelCopyBufferLayout {
-                        offset: 0,
-                        bytes_per_row: Some(padded),
-                        rows_per_image: Some(edge),
-                    },
-                },
-                wgpu::Extent3d {
-                    width: edge,
-                    height: edge,
-                    depth_or_array_layers: layers,
-                },
-            );
-            queue.submit([encoder.finish()]);
-            buffer
-                .slice(..)
-                .map_async(wgpu::MapMode::Read, |r| r.unwrap());
-            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
-            let data = buffer.slice(..).get_mapped_range().unwrap();
-            for (layer, image) in data.chunks((padded * edge) as usize).enumerate() {
-                for row in image.chunks(padded as usize) {
-                    out[layer].extend_from_slice(&row[..edge as usize * 4]);
-                }
-            }
-        }
-        out
-    }
-
-    #[test]
-    fn gpu_layers_match_the_cpu_chains_every_tick() {
-        layers_match_the_cpu_chains_every_tick(true);
-    }
-
-    /// Without compute shaders (OpenGL before 4.3): the same layers.
-    #[test]
-    fn copied_layers_match_the_cpu_chains_every_tick() {
-        layers_match_the_cpu_chains_every_tick(false);
-    }
-
-    fn layers_match_the_cpu_chains_every_tick(compute: bool) {
-        let Some((device, queue)) = device() else {
-            return;
-        };
-        let size = 32;
-        // Layers 1 and 3: 8-pixel sprites with and without interpolation;
-        // layer 4: one at the array's size. Two layers per array.
-        let clips = [
-            (
-                1,
-                8,
-                r#"{"frametime":3,"interpolate":true,"frames":[0,2,1]}"#,
-            ),
-            (3, 8, r#"{"frametime":2}"#),
-            (4, 32, r#"{"frametime":5,"interpolate":true}"#),
-        ];
-        let mut mips = vec![Settings::default(); 6];
-        let animations: Vec<_> = clips
-            .iter()
-            .map(|&(layer, native, metadata)| {
-                mips[layer as usize] = settings(native, Strategy::Cutout);
-                let frames = (0..3)
-                    .map(|f| crate::sprites::resample(&frame(native, layer * 7 + f), native, size))
-                    .collect();
-                crate::sprites::test_frames(layer, frames, metadata)
-            })
-            .collect();
-        let split = 2;
-        let textures: Vec<_> = (0..3)
-            .map(|_| {
-                device.create_texture(&wgpu::TextureDescriptor {
-                    label: None,
-                    size: wgpu::Extent3d {
-                        width: size,
-                        height: size,
-                        depth_or_array_layers: split,
-                    },
-                    mip_level_count: size.trailing_zeros() + 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format: wgpu::TextureFormat::Rgba8Unorm,
-                    usage: wgpu::TextureUsages::STORAGE_BINDING
-                        | wgpu::TextureUsages::COPY_SRC
-                        | wgpu::TextureUsages::COPY_DST,
-                    view_formats: &[],
-                })
-            })
-            .collect();
-        let mut animator =
-            SpriteAnimator::new(&device, &animations, size, &mips, &textures, split, compute);
-        let mut uploads = Uploads::new(&device);
-        let mut writes = Vec::new();
-        for tick in [0, 0, 1, 2, 3, 4, 7, 7, 12, 30] {
-            let mut encoder = device.create_command_encoder(&Default::default());
-            let shown: Vec<_> = animator.sprites.iter().map(|s| s.shown).collect();
-            animator.animate(&mut encoder, &mut uploads, tick);
-            writes.push(
-                animator
-                    .sprites
-                    .iter()
-                    .zip(shown)
-                    .filter(|(s, shown)| s.shown != *shown)
-                    .count(),
-            );
-            uploads.finish(&encoder);
-            queue.submit([encoder.finish()]);
-            for animation in &animations {
-                let blend = animation.blend(tick);
-                let pixels: Vec<_> = (0..animation.frame_count())
-                    .map(|f| animation.pixels(f))
-                    .collect();
-                let (chains, edge) = source_chains(&pixels, size, &mips, animation.layer);
-                let (current, next) = (&chains[blend.frame], &chains[blend.next]);
-                let layers = read_back(
-                    &device,
-                    &queue,
-                    &textures[(animation.layer / split) as usize],
-                );
-                assert_eq!(
-                    layers[(animation.layer % split) as usize],
-                    reference(current, next, blend.millis, edge, size),
-                    "layer {} at tick {tick}",
-                    animation.layer
-                );
-            }
-        }
-        // Every sprite on the first tick, then only those whose frame or mix
-        // changed since they were written: the interpolated ones every tick
-        // but layer 1 at tick 30 (two 9-tick loops after 12), layer 3 when
-        // its frame turns over (every 2 ticks, but 12 shows 7's frame).
-        assert_eq!(writes, [3, 0, 2, 3, 2, 3, 3, 0, 2, 1]);
-    }
-}

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

@@ -1,48 +0,0 @@
-// Animated block sprites (gfx/animate.rs), as vanilla's animate_sprite_blit
-// and animate_sprite_interpolate shaders draw them: each job writes its
-// frame, or the frame mixed with the next one, into one mip level of its
-// sprite array layer. One invocation per texel; the job is the z coordinate.
-struct Job {
-    layer: u32,
-    // Word offsets of the two frames' mip chains in `frames`.
-    current: u32,
-    next: u32,
-    // Thousandths of the way from `current` to `next` (0: `current` alone).
-    millis: u32,
-    // Edge of the chains' first level.
-    edge: u32,
-}
-@group(0) @binding(0) var<storage, read> frames: array<u32>;
-@group(0) @binding(1) var<storage, read> jobs: array<Job>;
-@group(0) @binding(2) var level: texture_storage_2d_array<rgba8unorm, write>;
-
-fn channels(rgba: u32) -> vec4<u32> {
-    return vec4(rgba & 0xffu, (rgba >> 8u) & 0xffu, (rgba >> 16u) & 0xffu, rgba >> 24u);
-}
-
-@compute @workgroup_size(8, 8)
-fn animate(@builtin(global_invocation_id) id: vec3<u32>) {
-    let size = textureDimensions(level).x;
-    if id.x >= size || id.y >= size {
-        return;
-    }
-    let job = jobs[id.z];
-    // mipmap::generate: the levels at least as large as the chain's first
-    // repeat it by whole pixels, the smaller ones are the chain's own.
-    var texel: u32;
-    if size >= job.edge {
-        let scale = size / job.edge;
-        texel = id.y / scale * job.edge + id.x / scale;
-    } else {
-        // Every level above this one, each a quarter of the one before.
-        texel = 4u * (job.edge * job.edge - size * size) / 3u + id.y * size + id.x;
-    }
-    var color = channels(frames[job.current + texel]);
-    if job.millis > 0u {
-        // mix(current, next, millis / 1000), rounded to the nearest 8-bit
-        // value (halves up) in integers: the same on every GPU.
-        let next = channels(frames[job.next + texel]);
-        color = (color * (1000u - job.millis) + next * job.millis + 500u) / 1000u;
-    }
-    textureStore(level, id.xy, job.layer, vec4<f32>(color) / 255.0);
-}