Flat draws: phase 1's solid lists made on the GPU

In frames drawn flat (Metal at render distance 32, Intel Gen11/12 Vulkan),
the render thread walked every phase 1 section's sides each frame to find the
runs of quads that face the eye, then the flat plan copied them into one index
list. Now each section uploads a row once (where its quads start, how Sides
sorted them), and each frame phase 1 pushes one record per section: the GPU
(gpu_lists.wgsl's flatten_sides) finds the same runs as Sides::visible_from and
writes their indices into a call per pass and arena page, drawn indirect.
Phase 2, translucent quads, tiles, mirrors, shader pack terrain and shadows
keep the CPU lists. HORIZON_GPU_LISTS=0 turns it off.

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

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

@@ -47,7 +47,7 @@ line are in the output) and the Rust fn before changing anything.
   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`.
+  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.
 

.gitattributes

@@ -4,3 +4,8 @@ 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
+# Generated by `cargo run -p xtask -- mod-api`; `--check` compares them byte for byte.
+crates/horizon-client/src/mod_api/generated.rs linguist-generated=true text eol=lf
+crates/horizon-client/src/mod_api/generated_host.rs linguist-generated=true text eol=lf
+crates/horizon-client/src/game/mod_api_host_generated.rs linguist-generated=true text eol=lf
+crates/horizon-client-render/src/gfx/native_render/generated.rs linguist-generated=true text eol=lf

.github/actionlint.yaml

@@ -1,4 +1,3 @@
 self-hosted-runner:
   # The Mac mini's runner (ludovics-mac-mini), which holds the maintainer's own Minecraft files.
-  # windows-11-vs2026-arm is GitHub's Windows ARM64 image (2026-08), newer than actionlint's label list.
-  labels: [horizon-game, ludovics-mac-mini, windows-11-vs2026-arm]
+  labels: [horizon-game, ludovics-mac-mini]

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

@@ -9,9 +9,9 @@ permissions:
   actions: write
 jobs:
   cancel:
-    # One of our small runners (horizon-light), out of GitHub's pool: no checkout, no code of the pull request
+    # One of playhorizon's small runners, out of GitHub's shared pool: no checkout, no code of the pull request
     # (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
     steps:
       - name: Cancel the pull request's unfinished runs
         env:

.github/workflows/cargo-horizon-mod.yml

@@ -1,107 +0,0 @@
-name: cargo-horizon-mod
-# `cargo binstall --git https://github.com/horizon-rust/horizon cargo-horizon-mod` (#2120): binstall reads
-# [package.metadata.binstall] from crates/cargo-horizon-mod/Cargo.toml and downloads the archive this workflow
-# attaches to the tag `cargo-horizon-mod-v<version>`, whose version must be the manifest's. The targets come from
-# tools/horizon_mod_binstall.py, the same file the manifest's template is checked against, so a platform added there
-# is built here and one nobody publishes is caught before it ships. A pull request builds the archives and publishes
-# nothing.
-on:
-  push:
-    tags: ['cargo-horizon-mod-v*']
-  pull_request:
-    paths:
-      - 'crates/cargo-horizon-mod/**'
-      - 'tools/horizon_mod_binstall.py'
-      - '.github/workflows/cargo-horizon-mod.yml'
-permissions:
-  contents: read
-jobs:
-  plan:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    outputs:
-      platforms: ${{ steps.platforms.outputs.platforms }}
-    steps:
-      - uses: actions/checkout@v7
-      - id: platforms
-        run: echo "platforms=$(python3 -c 'import json, tools.horizon_mod_binstall as m; print(json.dumps(m.PLATFORMS))')" >> "$GITHUB_OUTPUT"
-  build:
-    needs: plan
-    name: build ${{ matrix.target }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include: ${{ fromJSON(needs.plan.outputs.platforms) }}
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v7
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.target }}
-      - name: The aarch64 Linux linker
-        if: matrix.target == 'aarch64-unknown-linux-gnu'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc-aarch64-linux-gnu
-          echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc" >> "$GITHUB_ENV"
-      - name: Build
-        run: cargo build --release --locked -p cargo-horizon-mod --target ${{ matrix.target }}
-      - name: It starts
-        if: matrix.run
-        shell: bash
-        run: |
-          set -euo pipefail
-          binary="target/${{ matrix.target }}/release/cargo-horizon-mod"
-          [ -f "$binary.exe" ] && binary="$binary.exe"
-          out=$("$binary" 2>&1 || true)
-          case "$out" in
-            *"usage: cargo horizon-mod"*) ;;
-            *) echo "$out"; echo "::error::$binary does not start"; exit 1 ;;
-          esac
-      - name: Package
-        shell: bash
-        run: |
-          set -euo pipefail
-          binary="target/${{ matrix.target }}/release/cargo-horizon-mod"
-          [ -f "$binary.exe" ] && binary="$binary.exe"
-          mkdir -p dist
-          tar -czf "dist/$(basename "$binary" | sed 's/\.exe$//')-${{ matrix.target }}.tar.gz" -C "$(dirname "$binary")" "$(basename "$binary")"
-      - uses: actions/upload-artifact@v7
-        with:
-          name: cargo-horizon-mod-${{ matrix.target }}
-          path: dist/*.tar.gz
-          if-no-files-found: error
-          retention-days: 3
-  publish:
-    needs: build
-    if: startsWith(github.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/download-artifact@v8
-        with:
-          pattern: cargo-horizon-mod-*
-          path: dist
-          merge-multiple: true
-      - name: The tag and the manifest name the same release and archives
-        run: python3 tools/horizon_mod_binstall.py dist "$GITHUB_REF_NAME"
-      - name: Checksums
-        run: |
-          set -euo pipefail
-          cd dist
-          for file in *.tar.gz; do sha256sum "$file" | cut -d' ' -f1 > "$file.sha256"; done
-      - name: Publish
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          set -euo pipefail
-          notes="\`cargo binstall --git https://github.com/horizon-rust/horizon cargo-horizon-mod\`"
-          if gh release view "$GITHUB_REF_NAME" >/dev/null 2>&1; then
-            gh release upload "$GITHUB_REF_NAME" dist/* --clobber
-          else
-            gh release create "$GITHUB_REF_NAME" dist/* --latest=false --title "cargo-horizon-mod ${GITHUB_REF_NAME#cargo-horizon-mod-v}" --notes "$notes"
-          fi

.github/workflows/ci.yml

@@ -27,24 +27,19 @@ jobs:
   # One job, not one per check: each job takes a runner from the organisation's shared pool, and with every pull request
   # and every merge to main starting this workflow, three jobs a run left the pool's queue tens of minutes deep.
   #
-  # Where (docs/ci-runners.md): our checks runners (label horizon-checks: the desktop's, an isolated user, so a fork's
-  # pull request runs there too) take the pull requests whose number ends in 0 or 1, about what their three runners
-  # can do; GitHub's runners take the others and main's pushes (which also save the Rust cache GitHub's pull request
-  # runs read), so both pools work at once. The repository variable SELF_HOSTED_CI moves them: `all` every job to
-  # ours, `light` (the desktop paused) or `off` every job to GitHub's. On ours the build folder persists
-  # (CARGO_TARGET_DIR, outside the checkout), so the apt packages, Python and the Rust cache steps are GitHub's only.
+  # Where: GitHub's runners. With the repository variable SELF_HOSTED_CI=all (for when that pool is full: their 4 CPUs
+  # are about one GitHub runner, docs/ci-runners.md), main's pushes and this repository's own pull requests run on
+  # playhorizon's checks runners (label playhorizon-ci); a fork's pull request never does (and the runners refuse it
+  # themselves). There the build folder persists (CARGO_TARGET_DIR, outside the checkout), so the apt packages,
+  # Python and the Rust cache steps are GitHub's only.
   verify:
-    runs-on: >-
-      ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && (vars.SELF_HOSTED_CI == 'all' ||
-      github.event_name == 'pull_request' && (endsWith(format('{0}', github.event.pull_request.number), '0') ||
-      endsWith(format('{0}', github.event.pull_request.number), '1'))) &&
-      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
+    runs-on: ${{ vars.SELF_HOSTED_CI == 'all' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) && fromJSON('["self-hosted", "linux", "playhorizon-ci"]') || 'ubuntu-latest' }}
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: actions/setup-python@v7
+      - uses: actions/setup-python@v5
         if: runner.environment == 'github-hosted'
         with:
           python-version: '3.12'
@@ -68,16 +63,6 @@ jobs:
           else
             python tools/check_public_tree.py --history
           fi
-      # Our runners as GitHub's: some Python tests compile Rust with a bare `rustc` (GitHub's image has a default
-      # toolchain, our runners' own rustup homes may not), and the GPU tests find no adapter there, so they return
-      # early. Ours have Mesa's software Vulkan for parity; a backend Linux lacks keeps the tests from it, so a pull
-      # request's verify doesn't depend on which pool took it (#8627: a GPU test that flakes on lavapipe).
-      - name: Our runners as GitHub's (a default Rust toolchain, no GPU)
-        if: runner.environment != 'github-hosted'
-        run: |
-          rustup toolchain install stable --profile minimal --component rustfmt --component clippy
-          rustup default stable
-          echo "WGPU_BACKEND=dx12" >> "$GITHUB_ENV"
       - name: Test offline research tooling
         run: python -m unittest discover -s tests -v
       - name: Install Rust toolchain and the ALSA and udev headers the client links against
@@ -111,22 +96,17 @@ jobs:
         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. Keep the target selection identical to avoid
-          # recompiling the workspace with a different dependency graph.
-          cargo +stable test --workspace --lib --bins --tests mod_content::tests:: -- --ignored
+          # 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: >-
-      ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && (vars.SELF_HOSTED_CI == 'all' ||
-      github.event_name == 'pull_request' && (endsWith(format('{0}', github.event.pull_request.number), '0') ||
-      endsWith(format('{0}', github.event.pull_request.number), '1'))) &&
-      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
+    runs-on: ${{ vars.SELF_HOSTED_CI == 'all' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) && fromJSON('["self-hosted", "linux", "playhorizon-ci"]') || 'ubuntu-latest' }}
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Does this pull request change the launcher or a crate it builds?
@@ -158,101 +138,18 @@ jobs:
         run: |
           cargo +stable fmt --check
           cargo +stable clippy --all-targets --locked -- -D warnings
-          cargo +stable test --locked --lib --bins
-  # Compile and test Windows ARM64 on an actual ARM64 host, and inspect the resulting PE headers. By hand only
-  # (`gh workflow run checks --ref <branch>`): GitHub's runner queue is the bottleneck, and main's runs gate the
-  # releases (tools/release_train.py waits for them), so neither pull requests nor main's pushes start this
-  # 90-minute job. The Nightly and launcher releases build and check these binaries on every run.
-  windows-arm64:
-    name: Windows ARM64 game and launcher
-    if: github.event_name == 'workflow_dispatch'
-    runs-on: windows-11-vs2026-arm
-    timeout-minutes: 90
-    env:
-      RUSTFLAGS: -C target-feature=+crt-static
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          fetch-depth: 0
-      - name: Use every runner core for Cargo
-        shell: pwsh
-        run: |
-          $cores = (Get-CimInstance Win32_Processor | Measure-Object -Property NumberOfLogicalProcessors -Sum).Sum
-          "CARGO_BUILD_JOBS=$cores" >> $env:GITHUB_ENV
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: aarch64-pc-windows-msvc
-      - uses: Swatinem/rust-cache@v2
-        with:
-          shared-key: windows-arm64-game
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: launcher
-          shared-key: windows-arm64-launcher
-      - name: Check LLVM assembler used by ring
-        shell: pwsh
-        run: |
-          $llvmBin = Join-Path $env:ProgramFiles 'LLVM\bin'
-          if (-not (Get-Command clang -ErrorAction SilentlyContinue) -and (Test-Path (Join-Path $llvmBin 'clang.exe'))) {
-            $env:PATH = "$llvmBin;$env:PATH"
-            "PATH=$env:PATH" >> $env:GITHUB_ENV
-          }
-          $clang = Get-Command clang -ErrorAction Stop
-          Write-Output "Using $($clang.Source)"
-          & $clang.Source --version
-      - name: Build the game for native Windows ARM64
-        run: cargo build --release --locked --target aarch64-pc-windows-msvc -p horizon-client -p horizon-client-lib --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
-      - name: Check the game's PE machine
-        run: python tools/check_pe_arch.py arm64 target/aarch64-pc-windows-msvc/release/horizon-client.exe target/aarch64-pc-windows-msvc/release/horizon-ctl.exe target/aarch64-pc-windows-msvc/release/horizon-prepare.exe target/aarch64-pc-windows-msvc/release/horizon-server.exe
-      - name: Check game DLL imports
-        run: python tools/check_imports.py target/aarch64-pc-windows-msvc/release/horizon-client.exe target/aarch64-pc-windows-msvc/release/horizon-ctl.exe target/aarch64-pc-windows-msvc/release/horizon-prepare.exe target/aarch64-pc-windows-msvc/release/horizon-server.exe
-      - name: Start every game executable
-        shell: pwsh
-        run: |
-          $ErrorActionPreference = 'Stop'
-          $client = 'target/aarch64-pc-windows-msvc/release/horizon-client.exe'
-          $output = & $client --help 2>&1
-          if ($LASTEXITCODE -ne 0 -or ($output -join "`n") -notmatch '--resources') { throw 'horizon-client --help failed' }
-          foreach ($binary in @('horizon-ctl.exe', 'horizon-prepare.exe', 'horizon-server.exe')) {
-            $path = "target/aarch64-pc-windows-msvc/release/$binary"
-            $output = & $path --help 2>&1
-            if ($LASTEXITCODE -ne 0 -or -not $output) { throw "$binary --help failed" }
-          }
-          foreach ($binary in @('horizon-prepare.exe', 'horizon-server.exe')) {
-            $path = "target/aarch64-pc-windows-msvc/release/$binary"
-            $output = & $path --version 2>&1
-            if ($LASTEXITCODE -ne 0 -or -not $output) { throw "$binary --version failed" }
-            Write-Output ($output -join "`n")
-          }
-      - name: Test and build the native Windows ARM64 launcher
-        working-directory: launcher
-        run: |
-          cargo test --release --locked --target aarch64-pc-windows-msvc --lib
-          cargo build --release --locked --target aarch64-pc-windows-msvc
-      - name: Check the launcher's PE machine
-        working-directory: launcher
-        run: python ../tools/check_pe_arch.py arm64 target/aarch64-pc-windows-msvc/release/horizon-launcher.exe
-      - name: Check launcher DLL imports and command-line startup
-        working-directory: launcher
-        shell: pwsh
-        run: |
-          $ErrorActionPreference = 'Stop'
-          $launcher = 'target/aarch64-pc-windows-msvc/release/horizon-launcher.exe'
-          python ../tools/check_imports.py $launcher
-          $output = & $launcher --version 2>&1
-          if ($LASTEXITCODE -ne 0 -or -not $output) { throw 'horizon-launcher --version failed' }
-          Write-Output ($output -join "`n")
+          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
-    # A git diff of this repository's own branch: one of our small runners (horizon-light, docs/ci-runners.md).
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    # A git diff of this repository's own branch: one of playhorizon's small runners (docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
     outputs:
       run: ${{ steps.scope.outputs.run }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: ${{ github.event.pull_request.head.sha }}
           fetch-depth: 0
@@ -287,13 +184,13 @@ jobs:
     if: github.event_name == 'workflow_dispatch'
     runs-on: [self-hosted, linux, horizon-game]
     steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-python@v7
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
       - name: Install Rust toolchain
         run: rustup toolchain install stable --profile minimal
-      - uses: actions/setup-java@v6
+      - uses: actions/setup-java@v4
         with:
           distribution: temurin
           java-version: '25'
@@ -635,11 +532,11 @@ jobs:
     if: github.event_name == 'workflow_dispatch'
     runs-on: [self-hosted, linux, horizon-game]
     steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-python@v7
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
-      - uses: actions/setup-java@v6
+      - uses: actions/setup-java@v4
         with:
           distribution: temurin
           java-version: '25'

.github/workflows/claim-command.yml

@@ -29,14 +29,14 @@ jobs:
     # the skipped runs of ordinary comments must not cancel a waiting one.
     concurrency:
       group: claim-${{ github.event.issue.number }}
-    # One of our small runners (horizon-light), out of GitHub's pool: main's script only (docs/ci-runners.md).
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    # One of playhorizon's small runners, out of GitHub's shared pool: main's script only (docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 5
     permissions:
       contents: read
       issues: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: main
           persist-credentials: false
@@ -56,14 +56,14 @@ jobs:
         run: python3 tools/ci/claim_command.py command
   release:
     if: github.event_name != 'issue_comment' && github.repository == 'horizon-rust/horizon'
-    # One of our small runners (horizon-light), out of GitHub's pool: main's script only (docs/ci-runners.md).
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    # One of playhorizon's small runners, out of GitHub's shared pool: main's script only (docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 10
     permissions:
       contents: read
       issues: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: main
           persist-credentials: false

.github/workflows/game-build.yml

@@ -1,6 +1,6 @@
 name: game build
-# Builds the game for every platform from `ref`: the Java exporters, then Linux and the Linux server, Windows x64
-# and ARM64 on GitHub, and macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json): Apple
+# Builds the game for every platform from `ref`: the Java exporters, then Linux and the Linux server and Windows on
+# GitHub, macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json): Apple
 # Silicon, and Intel cross-built there for x86_64-apple-darwin and checked under Rosetta 2 (#1161). Called by
 # release.yml (the releases) and nightly-build.yml (the opt-in Nightly), always from main's copy of this file: the
 # caller's commit, never the one being built. It holds no secrets: signing the checksums is the callers' own job,
@@ -45,7 +45,7 @@ jobs:
     # Three full preparations (two isolated, one batched) besides the compile.
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: ${{ inputs.ref }}
           persist-credentials: false
@@ -73,7 +73,7 @@ jobs:
             ! \( -name '*.class' \( -path 'exporters/server/dev/horizonlab/parity/*' -o -path 'exporters/client/dev/horizonlab/parity/*' \) \))
           [ -z "$stray" ] || { echo "::error::not one of our classes: $stray"; exit 1; }
           python3 tools/check_prepare_exporters.py --binary target/release/horizon-prepare
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         with:
           name: original-exporters
           path: exporters/
@@ -83,10 +83,6 @@ jobs:
   build:
     needs: exporters
     name: build ${{ matrix.name }}
-    # Windows ARM64 and musl are new: a failure never holds the other platforms' release (the signing job
-    # needs this job, and a failed entry of it would fail it). The release steps leave the missing
-    # optional archives out with a warning.
-    continue-on-error: ${{ matrix.name == 'windows-arm64' || matrix.name == 'linux-musl' }}
     strategy:
       fail-fast: false
       matrix:
@@ -98,28 +94,13 @@ jobs:
             # The server build too: packaging/server/install.sh installs it on Linux.
             server_dir: horizon-server-linux-x86_64
             server_asset: horizon-server-linux-x86_64.tar.gz
-          - name: linux-musl
-            os: ubuntu-22.04
-            musl: true
-            dir: horizon-linux-musl-x86_64
-            asset: horizon-linux-musl-x86_64.tar.gz
           - name: windows
             os: windows-latest
             dir: horizon-windows-x64
             asset: horizon-windows-x64.zip
             exe: .exe
-            pe_arch: x64
             # The C runtime linked in, so the game runs without the Visual C++ redistributable.
             rustflags: -C target-feature=+crt-static
-          - name: windows-arm64
-            os: windows-11-vs2026-arm
-            target: aarch64-pc-windows-msvc
-            dir: horizon-windows-arm64
-            asset: horizon-windows-arm64.zip
-            exe: .exe
-            pe_arch: arm64
-            # The ARM64 runner builds and runs native ARM64 executables; keep the C runtime in the archive.
-            rustflags: -C target-feature=+crt-static
           - name: macos
             mac: true
             dir: horizon-macos-arm64
@@ -147,7 +128,7 @@ jobs:
       run:
         shell: bash
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: ${{ inputs.ref }}
           persist-credentials: false
@@ -160,29 +141,21 @@ jobs:
         with:
           targets: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
-        if: runner.environment == 'github-hosted' && !matrix.musl
+        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' && !matrix.musl
+        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
-        if: ${{ !matrix.musl }}
         run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} -p horizon-client -p horizon-client-lib --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
       - name: Every program the release folder takes was built
-        if: ${{ !matrix.musl }}
         run: |
           for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
             test -f "$BIN/$binary${{ matrix.exe }}" || { echo "::error::$BIN/$binary${{ matrix.exe }} is missing"; exit 1; }
           done
-      - name: Verify Windows executable architecture
-        if: runner.os == 'Windows'
-        run: |
-          python tools/check_pe_arch.py "${{ matrix.pe_arch }}" \
-            "$BIN/horizon-client${{ matrix.exe }}" "$BIN/horizon-ctl${{ matrix.exe }}" \
-            "$BIN/horizon-prepare${{ matrix.exe }}" "$BIN/horizon-server${{ matrix.exe }}"
       - name: The signing keychain, unlocked
         if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id
         env:
@@ -200,7 +173,6 @@ jobs:
             codesign --verify --strict --verbose=2 "$BIN/$binary"
           done
       - name: Only system libraries
-        if: ${{ !matrix.musl }}
         # Windows: no non-system DLL (a "DLL not found" dialog on some players' machines). Linux: the standard
         # loader and libraries every desktop distribution has. macOS: only the system's own libraries.
         run: |
@@ -213,17 +185,7 @@ jobs:
               ${{ runner.os == 'Windows' && 'python' || 'python3' }} tools/check_imports.py "$file"
             fi
           done
-      - name: Baseline x86-64 CPUs only
-        # No POPCNT or LZCNT at all (the script says why only those): a C library's count intrinsic killed the
-        # game before main on a Core 2 (#7264). Not the Mac builds: every Intel Mac that runs macOS 11 has both.
-        if: runner.os != 'macOS' && matrix.pe_arch != 'arm64' && !matrix.musl
-        run: |
-          set -euo pipefail
-          rustup component add llvm-tools
-          ${{ runner.os == 'Windows' && 'python' || 'python3' }} tools/check_cpu_baseline.py \
-            $(for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do echo "$BIN/$binary${{ matrix.exe }}"; done)
       - name: Every program starts
-        if: ${{ !matrix.musl }}
         run: |
           set -euo pipefail
           bin=$BIN
@@ -268,26 +230,18 @@ jobs:
           # Published with the release; the publish job checks it again before it publishes anything.
           cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json"
       # One smoke-test.json per build, the Apple Silicon one's; the Intel build must pass its own run too.
-      - uses: actions/upload-artifact@v7
+      - 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
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@v4
         with:
           name: original-exporters
           path: exporters
-      - name: Build, check and package for musl in Alpine
-        if: matrix.musl
-        # Run Docker on the Ubuntu host: JavaScript actions themselves require glibc.
-        run: |
-          docker run --rm -v "$PWD:/work" -w /work \
-            -e HORIZON_VERSION -e HORIZON_NIGHTLY \
-            rust:alpine3.22 sh tools/ci/build-musl.sh
       - name: Package
-        if: ${{ !matrix.musl }}
         run: |
           set -euo pipefail
           cargo run --locked -p xtask -- package "$BIN/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}"
@@ -314,7 +268,7 @@ jobs:
             codesign --verify --strict "dist/${{ matrix.dir }}/$binary"
           done
           packaging/macos/notarize.sh "dist/${{ matrix.asset }}"
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.asset }}
           path: dist/${{ matrix.asset }}
@@ -336,7 +290,7 @@ jobs:
           rm -f "${{ matrix.server_asset }}"
           tar czf "${{ matrix.server_asset }}" "${{ matrix.server_dir }}"
           ls -l "${{ matrix.server_asset }}"
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         if: matrix.server_asset
         with:
           name: ${{ matrix.server_asset }}

.github/workflows/launcher.yml

@@ -1,5 +1,5 @@
 name: launcher
-# Builds the launcher on Linux, macOS, Windows x64 and ARM64, and releases it by itself (docs/release-flow.md): after a
+# Builds the launcher on Linux, macOS and Windows, and releases it by itself (docs/release-flow.md): after a
 # push to main that changes the launcher or a crate it builds in (the paths below),
 # every 10 minutes (a release waiting for merges to settle goes out) and by hand, tools/release_train.py decides as
 # for the game.
@@ -15,9 +15,6 @@ name: launcher
 # under Rosetta 2 (#1161). With the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
 # Developer ID, notarized and stapled, from the runner's signing keychain (packaging/macos/README.md);
 # unset (forks), they are signed ad hoc.
-# Windows ships each architecture's launcher in its ZIP (what a launcher updates itself from) and as
-# horizon-launcher-setup.exe or horizon-launcher-setup-arm64.exe, which opens the per-user installer instead of Home
-# (launcher/src/installer.rs).
 #   gh workflow run launcher --ref <branch>                    # dry run: builds everything, publishes nothing
 #   gh workflow run launcher --ref main -f dry_run=false -f force=true
 
@@ -29,7 +26,6 @@ on:
       - 'launcher/**'
       - 'crates/horizon-bench/**'
       - 'crates/horizon-friends/**'
-      - 'crates/horizon-mcp/**'
       - 'crates/horizon-mods/**'
       - 'crates/horizon-port-pack/**'
       - 'crates/horizon-prepare/**'
@@ -74,7 +70,7 @@ jobs:
       version: ${{ steps.decide.outputs.version }}
       dry_run: ${{ steps.mode.outputs.dry_run }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - id: mode
@@ -103,10 +99,6 @@ jobs:
     needs: decide
     if: needs.decide.outputs.release == 'true'
     name: build ${{ matrix.name }}
-    # Windows ARM64 is new: its failure never holds the other platforms' release (the signing job
-    # needs this job, and a failed entry of it would fail it). The release steps leave the missing
-    # ARM64 files out with a warning.
-    continue-on-error: ${{ matrix.name == 'windows-arm64' }}
     strategy:
       fail-fast: false
       matrix:
@@ -130,20 +122,9 @@ jobs:
             os: windows-latest
             asset: horizon-launcher-windows-x64.zip
             binary: horizon-launcher.exe
-            pe_arch: x64
-            setup_asset: horizon-launcher-setup.exe
             # The C runtime linked in: without it the launcher asks for VCRUNTIME140.dll,
             # which only the Visual C++ redistributable installs.
             rustflags: -C target-feature=+crt-static
-          - name: windows-arm64
-            os: windows-11-vs2026-arm
-            target: aarch64-pc-windows-msvc
-            asset: horizon-launcher-windows-arm64.zip
-            binary: horizon-launcher.exe
-            pe_arch: arm64
-            setup_asset: horizon-launcher-setup-arm64.exe
-            # The C runtime linked in, so the standalone ARM64 launcher needs no redistributable.
-            rustflags: -C target-feature=+crt-static
     runs-on: ${{ matrix.mac && (vars.MAC_RUNNER || 'ludovics-mac-mini') || matrix.os }}
     # Notarizing the app and then the .dmg can take a few minutes each.
     timeout-minutes: ${{ matrix.mac && 60 || 40 }}
@@ -166,7 +147,7 @@ jobs:
         working-directory: launcher
         shell: bash
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: ${{ needs.decide.outputs.head }}
           persist-credentials: false
@@ -193,14 +174,11 @@ jobs:
         run: |
           if ! xcrun metal --version > /dev/null 2>&1; then
             echo "::notice::No Metal toolchain on this runner: GPUI compiles its shaders at run time"
-            echo "LAUNCHER_FEATURES=gpui_platform/runtime_shaders" >> "$GITHUB_ENV"
+            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 ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
       - run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
-      - name: Verify Windows executable architecture
-        if: runner.os == 'Windows'
-        run: python ../tools/check_pe_arch.py "${{ matrix.pe_arch }}" "$BIN/${{ matrix.binary }}"
       - name: The version is the release's
         run: |
           out=$("$BIN/${{ matrix.binary }}" --version)
@@ -231,8 +209,7 @@ jobs:
           "$launcher" links --json
           # The Intel Mac launcher can come out before any game build has its asset (#1161): then there is nothing
           # to install yet. Only that entry skips, and only on a version list that parsed and had no build here
-          # (exit 3); a launcher or a script that fails still fails the step. The Windows ARM64 launcher always has
-          # one: it installs the x64 build where a release has no ARM64 one (backend.rs, GAME_FALLBACK).
+          # (exit 3); a launcher or a script that fails still fails the step.
           if [[ "${{ matrix.name }}" == macos-x64 ]]; then
             versions=$(retry "$launcher" --json versions)
             no_build='import json, sys; sys.exit(3 if not any(r["available_here"] for r in json.load(sys.stdin)) else 0)'
@@ -256,11 +233,6 @@ jobs:
           # release linked to a Nix store is a warning here, not a broken launcher.
           soft() { if [[ "$RUNNER_OS" == "Linux" ]]; then "$@" || echo "::warning::$* failed"; else "$@"; fi; }
           if [[ "$RUNNER_OS" == "Windows" ]]; then
-            if ! python ../tools/check_pe_arch.py "${{ matrix.pe_arch }}" "$client"; then
-              # A Nightly without an ARM64 build: the ARM64 launcher installs the x64 one (backend.rs, GAME_FALLBACK).
-              [[ "${{ matrix.pe_arch }}" == arm64 ]] && python ../tools/check_pe_arch.py x64 "$client" || exit 1
-              echo "::warning::the latest game has no ARM64 build: the launcher installed the x64 one"
-            fi
             python ../tools/check_imports.py "$client"
           elif [[ "$RUNNER_OS" == "Linux" ]]; then
             soft python3 ../tools/check_imports.py "$client"
@@ -268,18 +240,6 @@ jobs:
           # The client starts: --help prints before any window or GPU is needed.
           help() { "$client" --help > "$RUNNER_TEMP/help.txt" 2>&1 && head -3 "$RUNNER_TEMP/help.txt" && grep -q -- '--resources' "$RUNNER_TEMP/help.txt"; }
           soft help
-          # The per-user Windows setup: the same binary under the setup's name installs into a scratch
-          # folder, and the copy it installs uninstalls itself. HKCU of the runner only.
-          if [[ "$RUNNER_OS" == "Windows" ]]; then
-            setup="$RUNNER_TEMP/setup-smoke"
-            cp "$launcher" "$RUNNER_TEMP/horizon-launcher-setup.exe"
-            "$RUNNER_TEMP/horizon-launcher-setup.exe" setup --quiet --dir "$setup"
-            installed="$setup/Horizon Launcher/horizon-launcher.exe"
-            [[ -f "$installed" ]] || { echo "::error::the setup copied no launcher"; exit 1; }
-            "$installed" uninstall --quiet
-            [[ ! -f "$installed" ]] || { echo "::error::uninstall left the launcher"; exit 1; }
-            rm -rf "$setup"
-          fi
           rm -rf "$HORIZON_LAUNCHER_HOME"
       - name: The signing keychain, unlocked
         if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != ''
@@ -315,13 +275,7 @@ jobs:
             fi
           fi
           ls -l out
-      - name: Setup exe (Windows)
-        # The launcher's binary under another name: started with no arguments it shows the per-user
-        # installer instead of Home (launcher/src/installer.rs). Its name is what makes it the setup,
-        # so the ZIP's copy stays the launcher. Both go into the release's signed SHA256SUMS.
-        if: runner.os == 'Windows'
-        run: cp "$BIN/${{ matrix.binary }}" "out/${{ matrix.setup_asset }}"
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.asset }}
           path: launcher/out/*
@@ -339,12 +293,12 @@ jobs:
     # tools/ci/sign_release.sh, which calls only the runner's sha256sum and OpenSSL (docs/release-flow.md).
     environment: ${{ needs.decide.outputs.dry_run != 'true' && 'release' || '' }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           sparse-checkout: tools/ci/sign_release.sh
           sparse-checkout-cone-mode: false
           persist-credentials: false
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@v4
         with:
           path: dist
           pattern: horizon-launcher-*
@@ -356,13 +310,13 @@ jobs:
           EPHEMERAL: ${{ needs.decide.outputs.dry_run == 'true' && 'yes' || '' }}
           TAG: ${{ needs.decide.outputs.tag }}
         run: bash tools/ci/sign_release.sh "$TAG" dist/horizon-launcher-*
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         with:
           name: signature
           path: dist/SHA256SUMS*
           if-no-files-found: error
           retention-days: 3
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         if: needs.decide.outputs.dry_run == 'true'
         with:
           name: ephemeral.pub
@@ -376,7 +330,7 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Notes
@@ -386,7 +340,7 @@ jobs:
           python3 tools/release_train.py notes --kind launcher --tag "${{ needs.decide.outputs.tag }}" \
             --head "${{ needs.decide.outputs.head }}" --out notes > /dev/null
           { echo "## $(cat notes/title.txt)"; echo; cat notes/body.md; } >> "$GITHUB_STEP_SUMMARY"
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@v4
         with:
           path: dist
           merge-multiple: true
@@ -398,13 +352,6 @@ jobs:
           key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
           cargo run --locked --quiet -p horizon-release-sign -- verify --tag "$TAG" --publishing "${key[@]}" dist
       # Never marked latest: Horizon's own releases stay the repository's latest.
-      - name: The Windows ARM64 launcher, if it built
-        # Its build may fail without holding the release (continue-on-error): the release then has no ARM64
-        # files, and ARM64 launchers stay on their version until one has (backend::launcher_update_from).
-        run: |
-          for file in horizon-launcher-windows-arm64.zip horizon-launcher-setup-arm64.exe; do
-            [[ -f "dist/$file" ]] || echo "::warning::$file is missing: this release goes out without it"
-          done
       - name: Publish ${{ needs.decide.outputs.tag }}
         if: needs.decide.outputs.dry_run != 'true'
         env:
@@ -419,7 +366,7 @@ jobs:
         run: |
           echo "Would publish ${{ needs.decide.outputs.tag }} at ${{ needs.decide.outputs.head }}: $(cat notes/title.txt)"
           ls -l dist
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         with:
           name: launcher-release-notes
           path: notes/

.github/workflows/mod-registry.yml

@@ -15,23 +15,17 @@ on:
       - '.github/workflows/mod-registry.yml'
 permissions:
   contents: read
-concurrency:
-  group: mod-registry-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 jobs:
   check:
-    # Our checks runners (label horizon-checks, docs/ci-runners.md); SELF_HOSTED_CI=light or off: GitHub's.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 20
     defaults:
       run:
         working-directory: crates/horizon-mod-registry
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
       - run: rustup toolchain install stable --profile minimal --component rustfmt --component clippy
-      # Ours keep their build folder between jobs.
       - uses: Swatinem/rust-cache@v2
-        if: runner.environment == 'github-hosted'
         with:
           workspaces: crates/horizon-mod-registry
           save-if: ${{ github.ref == 'refs/heads/main' }}

.github/workflows/mojang-republish.yml

@@ -21,11 +21,10 @@ concurrency:
 
 jobs:
   check:
-    # One of our small runners (label horizon-light, docs/ci-runners.md): main's script, Mojang's public manifest.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
       - name: Check the manifest
         env:
           GH_TOKEN: ${{ github.token }}

.github/workflows/native-hook-stamp.yml

@@ -24,7 +24,7 @@ jobs:
       pull-requests: write
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: main
           fetch-depth: 0
@@ -52,8 +52,4 @@ jobs:
             git fetch origin "+refs/heads/$branch:refs/remotes/origin/$branch"
           fi
           git push --force-with-lease origin "$branch"
-          # The repo doesn't let GitHub Actions open pull requests (that setting would also let it approve them):
-          # the branch is pushed, and a maintainer opens the PR from it.
-          if ! gh pr create --base main --head "$branch" --title 'Stamp native hook API fragments' --body 'Assign API numbers to the pending native hook fragments. Close and reopen this PR to run CI.'; then
-            echo "::warning::Stamped fragments are on $branch; open a pull request from it (GitHub Actions may not open one here)."
-          fi
+          gh pr create --base main --head "$branch" --title 'Stamp native hook API fragments' --body 'Assign API numbers to the pending native hook fragments. Close and reopen this PR to run CI.'

.github/workflows/nightly-build.yml

@@ -92,7 +92,7 @@ jobs:
       source_tag: ${{ steps.pick.outputs.source_tag }}
       dry_run: ${{ steps.mode.outputs.dry_run }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
           persist-credentials: false
@@ -124,14 +124,14 @@ jobs:
         env:
           SHA: ${{ steps.pick.outputs.sha }}
         run: git archive --format=tar.gz --prefix="horizon-${SHA:0:7}/" -o horizon-source.tar.gz "$SHA"
-      - uses: actions/upload-artifact@v7
+      - 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@v7
+      - uses: actions/upload-artifact@v4
         with:
           name: nightly-notes
           path: nightly-notes.md
@@ -155,12 +155,12 @@ jobs:
     # The key's only job: main's sign_release.sh hashes the archives and signs with the runner's OpenSSL.
     environment: ${{ needs.pick.outputs.dry_run != 'true' && 'release' || '' }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           sparse-checkout: tools/ci/sign_release.sh
           sparse-checkout-cone-mode: false
           persist-credentials: false
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@v4
         with:
           path: dist
           pattern: horizon-*
@@ -171,22 +171,16 @@ jobs:
           RELEASE_SIGNING_KEY_NEXT: ${{ secrets.RELEASE_SIGNING_KEY_NEXT }}
           EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }}
         run: |
-          # Windows ARM64's build may fail without holding the Nightly (game-build.yml): then it is left out.
-          arm64=(); if [[ -f dist/horizon-windows-arm64.zip ]]; then arm64=(dist/horizon-windows-arm64.zip)
-          else echo "::warning::horizon-windows-arm64.zip is missing: SHA256SUMS goes out without it"; fi
-          musl=(); if [[ -f dist/horizon-linux-musl-x86_64.tar.gz ]]; then musl=(dist/horizon-linux-musl-x86_64.tar.gz)
-          else echo "::warning::horizon-linux-musl-x86_64.tar.gz is missing: SHA256SUMS goes out without it"; fi
           bash tools/ci/sign_release.sh nightly dist/horizon-linux-x86_64.tar.gz dist/horizon-windows-x64.zip \
-            "${arm64[@]}" "${musl[@]}" \
             dist/horizon-macos-arm64.zip dist/horizon-macos-x64.zip dist/horizon-server-linux-x86_64.tar.gz \
             dist/horizon-source.tar.gz
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         with:
           name: signature
           path: dist/SHA256SUMS*
           if-no-files-found: error
           retention-days: 3
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v4
         if: needs.pick.outputs.dry_run == 'true'
         with:
           name: ephemeral.pub
@@ -201,10 +195,10 @@ jobs:
       contents: write
       issues: read          # the open release-blocker issues (gate)
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@v4
         with:
           path: dist
           merge-multiple: true
@@ -236,27 +230,12 @@ jobs:
           set -euo pipefail
           python3 tools/ci/nightly.py rotate
           signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig)
-          # The ARM64 archive only when its build succeeded (the sign job left it out of SHA256SUMS otherwise).
-          arm64=()
-          if [[ -f dist/horizon-windows-arm64.zip ]]; then
-            arm64=("dist/horizon-windows-arm64.zip#Game files the launcher installs (Nightly): Windows ARM64 (horizon-windows-arm64.zip)")
-          else
-            echo "::warning::horizon-windows-arm64.zip is missing: the Nightly goes out without it (ARM64 launchers install the x64 build)"
-          fi
-          musl=()
-          if [[ -f dist/horizon-linux-musl-x86_64.tar.gz ]]; then
-            musl=("dist/horizon-linux-musl-x86_64.tar.gz#Game files for musl Linux (horizon-linux-musl-x86_64.tar.gz)")
-          else
-            echo "::warning::horizon-linux-musl-x86_64.tar.gz is missing: the Nightly goes out without it"
-          fi
           # A pre-release, never GitHub's latest: the latest stays the last vX.Y.Z, which launchers and servers from
           # before the Nightly-only switch keep (they don't read Nightlies).
           gh release create nightly --prerelease --latest=false --target "$SHA" \
             --title "Nightly $DATE · ${SHA:0:7}" --notes-file dist/nightly-notes.md \
             "dist/horizon-linux-x86_64.tar.gz#Game files the launcher installs (Nightly): Linux (horizon-linux-x86_64.tar.gz)" \
-            "${musl[@]}" \
             "dist/horizon-windows-x64.zip#Game files the launcher installs (Nightly): Windows (horizon-windows-x64.zip)" \
-            "${arm64[@]}" \
             "dist/horizon-macos-arm64.zip#Game files the launcher installs (Nightly): macOS on Apple Silicon (horizon-macos-arm64.zip)" \
             "dist/horizon-macos-x64.zip#Game files the launcher installs (Nightly): macOS on Intel (horizon-macos-x64.zip)" \
             "dist/horizon-server-linux-x86_64.tar.gz#Nightly dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \
@@ -274,8 +253,7 @@ jobs:
     # 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'
-    # One comment, no checkout and no secret: one of our small runners (label horizon-light, docs/ci-runners.md).
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 5
     permissions:
       issues: write

.github/workflows/nightly-command.yml

@@ -27,7 +27,7 @@ jobs:
       issues: write         # answers in the thread
       pull-requests: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: main
           persist-credentials: false

.github/workflows/nightly.yml

@@ -48,7 +48,7 @@ jobs:
           else
             echo "run=true" >> "$GITHUB_OUTPUT"
           fi
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         if: steps.when.outputs.run == 'true'
         with:
           fetch-depth: 0
@@ -82,7 +82,7 @@ jobs:
         run: python3 tools/ci/parity_issues.py --since "${{ steps.audit.outputs.since }}" ${{ inputs.dry_run && '--dry-run' || '' }} | tee -a "$GITHUB_STEP_SUMMARY"
       - name: Logs of the failed harnesses
         if: steps.when.outputs.run == 'true' && steps.audit.outputs.exit != '0'
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: nightly-parity-logs
           path: .local/parity-runner/logs/

.github/workflows/overlap-note.yml

@@ -19,15 +19,15 @@ jobs:
     concurrency:
       group: overlap-note-${{ github.event.pull_request.number }}
       cancel-in-progress: true
-    # One of our small runners (horizon-light), out of GitHub's pool: it runs main's script only (above), so a fork's
+    # One of playhorizon's small runners, out of GitHub's shared pool: it runs main's script only (above), so a fork's
     # pull request runs none of its code there (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 10
     permissions:
       contents: read
       pull-requests: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: main
           fetch-depth: 0

.github/workflows/pack-bench.yml

@@ -22,24 +22,17 @@ env:
 
 jobs:
   bench:
-    # Our checks runners (label horizon-checks, docs/ci-runners.md): the branch and the base on the same machine, as
-    # the comparison needs. SELF_HOSTED_CI=light or off: GitHub's.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 90
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install Rust and the ALSA and udev headers
-        env:
-          HOSTED: ${{ runner.environment == 'github-hosted' }}
         run: |
-          if [ "$HOSTED" = true ]; then
-            sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
-          fi
+          sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
           rustup toolchain install stable --profile minimal
       - uses: Swatinem/rust-cache@v2
-        if: runner.environment == 'github-hosted'
         with:
           shared-key: pack-bench
       - name: Bench the branch
@@ -53,15 +46,11 @@ jobs:
           SCALE: ${{ inputs.scale || '1' }}
         run: |
           git fetch https://github.com/horizon-rust/horizon.git "$BASE"
-          # Our runners keep the folder beside the checkout between jobs.
-          git worktree remove --force ../base 2> /dev/null || rm -rf ../base
-          git worktree prune
           git worktree add ../base FETCH_HEAD
           cp crates/horizon-client-render/examples/pack_load_bench.rs ../base/crates/horizon-client-render/examples/
           # A bench row that times a function the base lacks keeps it from building there: then
           # the branch's own rows compare the two ways.
-          target=${CARGO_TARGET_DIR:-$GITHUB_WORKSPACE/target}
-          (cd ../base && CARGO_TARGET_DIR="$target" cargo run --profile fast -p horizon-client-render \
+          (cd ../base && CARGO_TARGET_DIR="$GITHUB_WORKSPACE/target" cargo run --profile fast -p horizon-client-render \
             --example pack_load_bench -- --scale "$SCALE") > base.md \
             || echo "The bench does not build on the base." > base.md
       - name: Summary

.github/workflows/parity-main.yml

@@ -30,7 +30,7 @@ jobs:
     runs-on: [self-hosted, macOS, horizon-parity-main]
     timeout-minutes: 240  # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: ${{ github.sha }}
           fetch-depth: 0
@@ -69,7 +69,7 @@ jobs:
           python3 tools/parity_main.py bisect "$BASE_SHA" --comment
       - name: Logs of the failed harnesses
         if: steps.harnesses.outcome == 'failure'
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: parity-main-logs
           path: .local/parity-main-logs/

.github/workflows/parity.yml

@@ -33,7 +33,7 @@ jobs:
     # harnesses at a time) up to a few hours, and any pull request's job may land there.
     timeout-minutes: ${{ inputs.full && 360 || 180 }}
     steps:
-      - uses: actions/checkout@v7
+      - 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.
@@ -89,7 +89,7 @@ jobs:
         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()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: parity-logs
           path: .local/parity-runner/logs/

.github/workflows/pr-labels.yml

@@ -16,15 +16,15 @@ jobs:
   label:
     # Title-only edits change nothing: skip them before a runner starts.
     if: github.event.action != 'edited' || github.event.changes.body != null
-    # One of our small runners (horizon-light), out of GitHub's pool: it runs main's script only (above), so a fork's
+    # One of playhorizon's small runners, out of GitHub's shared pool: it runs main's script only (above), so a fork's
     # pull request runs none of its code there (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 5
     permissions:
       contents: read
       pull-requests: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: main
           persist-credentials: false

.github/workflows/release.yml

@@ -53,7 +53,7 @@ jobs:
       urgent: ${{ steps.decide.outputs.urgent }}
       dry_run: ${{ steps.mode.outputs.dry_run }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - id: mode

.github/workflows/telemetry-server.yml

@@ -15,23 +15,17 @@ on:
       - '.github/workflows/telemetry-server.yml'
 permissions:
   contents: read
-concurrency:
-  group: telemetry-server-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 jobs:
   check:
-    # Our checks runners (label horizon-checks, docs/ci-runners.md); SELF_HOSTED_CI=light or off: GitHub's.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 20
     defaults:
       run:
         working-directory: crates/horizon-telemetry-server
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
       - run: rustup toolchain install stable --profile minimal --component rustfmt --component clippy
-      # Ours keep their build folder between jobs.
       - uses: Swatinem/rust-cache@v2
-        if: runner.environment == 'github-hosted'
         with:
           workspaces: crates/horizon-telemetry-server
           save-if: ${{ github.ref == 'refs/heads/main' }}

.github/workflows/triage-command.yml

@@ -21,15 +21,14 @@ jobs:
       startsWith(github.event.comment.body, '/reopen') ||
       startsWith(github.event.comment.body, '/label') ||
       startsWith(github.event.comment.body, '/unlabel'))
-    # One of our small runners (label horizon-light, docs/ci-runners.md): main's script only, as above.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 5
     permissions:
       contents: read
       issues: write
       pull-requests: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
         with:
           ref: main
           persist-credentials: false

AGENTS.md

@@ -55,7 +55,6 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-server` | `horizon-server`: `server.toml`, CLI, supervisor of the headless game ([docs/hosting.md](docs/hosting.md)) |
 | `horizon-server-files` | `server.properties`, eula, ops/whitelist/bans, usercache |
 | `horizon-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-cosmetics` | Cosmetic items Horizon clients draw on players (off by default): the item format, bones and animations ([docs/cosmetics.md](docs/cosmetics.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)) |
@@ -104,10 +103,6 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
   + 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.
-- Developing a native mod? Run `horizon-launcher settings native-profile dev` once. `dev` builds the game crate
-  unoptimized: a mod edit rebuilds about 6× faster than with `performance`, while game logic runs up to about twice as
-  slow. Use it while developing, not for playing; `performance` stays the default for players and releases
-  ([docs/native-mods.md](docs/native-mods.md)).
 - Probes build into `.local/parity-target/`; harnesses find binaries via `lab.cargo_target()`, never `target/`.
 - Harness selection uses Cargo dep-info and reachable-code narrowing (`tools/parity_reach.py`).
   `horizon-client-lib` builds the control tool and client probes without gameplay; their dep-info
@@ -148,7 +143,7 @@ state stays separate from the library tests. This compiles gameplay twice for ex
 |---|---|
 | 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/`, `server_terrain.rs` (a server's kept chunks), `bluemap.rs` + `bluemap_detect.rs` (far terrain from its web map), `ticket_levels.rs`; G: `world_loading.rs`, `postprocess.rs`; game.rs `fn update_world` |
+| 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` |
@@ -179,24 +174,28 @@ state stays separate from the library tests. This compiles gameplay twice for ex
 - 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; a server ticks its levels (`fn tick_world`).
-- A server's players run through the shared gameplay code: `as_guest` swaps the guest's
+  `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.
 
-## Single player runs on a server thread
+## The two single-player paths
 
-`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 (#1514). A window's `Game` never ticks a world itself: the old in-frame path is gone
-(`--in-frame` and `--no-server-thread` only print a notice; `HORIZON_SERVER_THREAD` is ignored).
-Open `[server-thread]` issues list the gaps left.
+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.
 
-Single player, LAN guests and dedicated servers all run the server code, so a fix there serves all three.
-Test the server thread when you touch player-facing gameplay:
+LAN guests and dedicated servers always use the server code, so a fix there serves both. Test 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

CONTRIBUTING.md

@@ -5,8 +5,7 @@ everything is that **it plays exactly like vanilla**. This page is the short ver
 welcome on [Discord](https://discord.gg/playhorizon).
 
 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.
+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
@@ -15,25 +14,23 @@ queue (the hub, or `/suggest` on Discord) rather than to issues, which are for b
 
 ## Build it
 
-- **Prerequisites:** Rust (stable), Python 3.10+, JDK 25, and on Linux the ALSA and udev headers
-  (`libasound2-dev libudev-dev`).
-- **Resources:** Horizon never downloads the game; it prepares its resources from your own copy of Minecraft 26.3, as
-  described in [Build from source](README.md#build-from-source).
-- **Commands:**
+You need Rust (stable), Python 3.10+, JDK 25, and on Linux the ALSA and udev headers (`libasound2-dev libudev-dev`).
+Horizon never downloads the game: it prepares its resources from your own copy of Minecraft 26.3, as described in
+[Build from source](README.md#build-from-source).
 
-  ```sh
-  cargo run --release -p horizon-prepare -- --prepare --server-jar ~/Downloads/server.jar
-  cargo run --release -p horizon-client
-  ```
+```sh
+cargo run --release -p horizon-prepare -- --prepare --server-jar ~/Downloads/server.jar
+cargo run --release -p horizon-client
+```
 
-- **Launcher:** its own Cargo workspace in `launcher/` (`cd launcher && cargo run`; on NixOS, `nix-shell` first).
+The launcher is its own Cargo workspace in `launcher/` (`cd launcher && cargo run`; on NixOS, `nix-shell` first).
 
 ## Vanilla first
 
-Wherever vanilla has a feature, vanilla is the specification, down to the order of random calls. "Parity" here means
-Horizon gives the same results as the pinned 26.3 client and server for the same inputs, checked by a **harness**: a
-`tools/test_*_parity.py` script that runs a small Java oracle against the real game and a Rust probe against Horizon,
-and compares their outputs. There are about 290 of them.
+Wherever vanilla has a feature, vanilla is the specification, down to the order of random calls. "Parity" here
+means Horizon gives the same results as the pinned 26.3 client and server for the same inputs, checked by a
+**harness**: a `tools/test_*_parity.py` script that runs a small Java oracle against the real game and a Rust
+probe against Horizon, and compares their outputs. There are about 290 of them.
 
 - **Read the vanilla code before writing Horizon's.** `tools/rea_vanilla.py` queries the pinned game bytecode:
   `python3 tools/rea_vanilla.py method net.minecraft.world.level.block.DispenserBlock dispenseFrom`.
@@ -44,10 +41,11 @@ and compares their outputs. There are about 290 of them.
   off by default wherever they would change the vanilla look.
 - **Everything players run is Rust.** Python and Java are fine for dev tools and harness drivers in `tools/`, never
   for player-facing code.
-- **No game files in the repo.** 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.
+
+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, or code whose license allows it
 
@@ -56,23 +54,24 @@ another project's source may also be read and used, **only when that project's l
 
 - **Allowed:** MIT, MIT-0, BSD-2-Clause, BSD-3-Clause, 0BSD, ISC, zlib, Apache-2.0, Unlicense, and the CC0-1.0
   public-domain dedication. That code may be read, copied or adapted.
-- **Off limits, even to read:** GPL, LGPL (Iris), AGPL, MPL, EPL, Polyform (Sodium), the Creative Commons licenses
-  (CC BY, CC BY-SA, CC BY-NC and the others; CC0 is a public-domain dedication, not one of them), custom or
-  "source available" licenses, all rights reserved (OptiFine), and any project with no license or an unclear one.
-  Don't read, copy, translate or paraphrase their source, and don't send code an AI tool wrote from it. Being able
-  to download a mod or a pack does not give you the right to read its files.
+- **Everything else is off limits, even to read:** GPL, LGPL (Iris), AGPL, MPL, EPL, Polyform (Sodium), the Creative
+  Commons licenses (CC BY, CC BY-SA, CC BY-NC and the others; CC0 is a public-domain dedication, not one of them),
+  custom or "source available" licenses, all rights reserved (OptiFine), and any project with no license or an
+  unclear one. Don't read, copy, translate or paraphrase their source, and don't send code an AI tool
+  wrote from it. Being able to download a mod or a pack does not give you the right to read its files.
 - **Check the license yourself.** Read the LICENSE file at the commit you use and the header of each file you take:
-  some repositories mix licenses, and a file under another license is off limits. A license that changed: the one at
-  your commit counts. In doubt, don't: ask in #contributors first.
+  some repositories mix licenses, and a file under another license is off limits. A license that changed: the one
+  at your commit counts. In doubt, don't: ask in #contributors first.
 - **Say it in the pull request:** the project, a link to the commit, its license, and what you read or copied. A
   pull request that used another project's source without saying so is closed.
 - **Copied or adapted code** keeps its copyright line and license notice at the top of the file, and gets an entry
   in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md). Apache-2.0 code also keeps its NOTICE text and says what
   was changed.
 
-User documentation and file formats are fine to read, and packs and mods are fine to run and observe, whatever their
-license. Shader packs are a clean-room rewrite of the pack format, produced from a written description of it (see
-#1561); they carry no foreign source, and the rules above still apply to anything you read while working on them.
+User documentation and file formats are fine to read, and packs and mods are fine to run and observe, whatever
+their license. 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
 
@@ -88,8 +87,8 @@ your change can affect. Without the vanilla data on your machine it lists those
 `--quick` skips the harnesses. It exits non-zero when something fails.
 
 For the game workspace, Clippy checks all targets of the touched crates and their transitive workspace dependents,
-including examples. The dependency scope includes optional, platform, build and development dependencies. Tests run
-library, binary, integration and doc tests without building unrelated example executables. Shared Cargo
+including examples. The dependency scope includes optional, platform, build and development dependencies.
+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
@@ -97,8 +96,7 @@ configuration and toolchain changes select the whole workspace; CI also keeps it
 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. Issues labelled `tracker`, `proposal` or `not claimable` aren't
-claimed whole: claim one of the issues a tracker lists, or open one for the part you take.
+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 8 open issues at a time, not counting the ones your
@@ -124,8 +122,8 @@ it (edited on every push, never repeated): talk to its author in the thread befo
   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. `release-now` is for crash
-  fixes that shouldn't wait. pr_ready suggests one.
+  `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)).

Cargo.lock

@@ -329,12 +329,6 @@ dependencies = [
  "syn 3.0.6",
 ]
 
-[[package]]
-name = "byteorder-lite"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
-
 [[package]]
 name = "bytes"
 version = "1.12.1"
@@ -373,7 +367,6 @@ version = "0.1.0"
 dependencies = [
  "horizon-mods",
  "serde_json",
- "zip",
 ]
 
 [[package]]
@@ -1217,12 +1210,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
 [[package]]
 name = "hermit-abi"
 version = "0.5.3"
@@ -1279,7 +1266,6 @@ name = "horizon-assets"
 version = "0.1.0"
 dependencies = [
  "horizon-core",
- "log",
  "png",
  "serde",
  "serde_json",
@@ -1332,12 +1318,10 @@ dependencies = [
  "horizon-client-render",
  "horizon-command",
  "horizon-core",
- "horizon-cosmetics",
  "horizon-dualsense",
  "horizon-friends",
  "horizon-hdr",
  "horizon-items",
- "horizon-mod-api-gen",
  "horizon-mods",
  "horizon-narrator",
  "horizon-optifine",
@@ -1415,7 +1399,6 @@ dependencies = [
  "horizon-friends",
  "horizon-hdr",
  "horizon-items",
- "horizon-mcp",
  "horizon-mods",
  "horizon-narrator",
  "horizon-optifine",
@@ -1429,7 +1412,6 @@ dependencies = [
  "horizon-world",
  "log",
  "miniz_oxide 0.8.9",
- "mio",
  "naga",
  "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
@@ -1446,7 +1428,6 @@ dependencies = [
  "ureq",
  "wgpu",
  "winit",
- "xxhash-rust",
  "zip",
 ]
 
@@ -1468,10 +1449,8 @@ dependencies = [
  "horizon-client-input",
  "horizon-command",
  "horizon-core",
- "horizon-cosmetics",
  "horizon-hdr",
  "horizon-items",
- "horizon-mod-api-gen",
  "horizon-narrator",
  "horizon-optifine",
  "horizon-protocol",
@@ -1481,9 +1460,7 @@ dependencies = [
  "horizon-theme",
  "horizon-threads",
  "horizon-world",
- "image-webp",
  "log",
- "lz4_flex",
  "miniz_oxide 0.8.9",
  "naga",
  "png",
@@ -1500,7 +1477,6 @@ dependencies = [
  "wgpu",
  "winit",
  "zip",
- "zune-jpeg",
 ]
 
 [[package]]
@@ -1508,7 +1484,6 @@ name = "horizon-command"
 version = "0.1.0"
 dependencies = [
  "horizon-client-core",
- "horizon-core",
  "horizon-protocol",
  "horizon-world",
 ]
@@ -1520,18 +1495,6 @@ dependencies = [
  "libm",
 ]
 
-[[package]]
-name = "horizon-cosmetics"
-version = "0.1.0"
-dependencies = [
- "base64",
- "glam",
- "png",
- "serde",
- "serde_json",
- "ureq",
-]
-
 [[package]]
 name = "horizon-dualsense"
 version = "0.1.0"
@@ -1579,32 +1542,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "horizon-mcp"
-version = "0.1.0"
-dependencies = [
- "serde_json",
-]
-
-[[package]]
-name = "horizon-mod-api-gen"
-version = "0.1.0"
-dependencies = [
- "heck",
- "quote",
- "serde",
- "serde_json",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "horizon-mod-api-gen-tests"
-version = "0.1.0"
-dependencies = [
- "horizon-mod-api-gen",
- "serde_json",
-]
-
 [[package]]
 name = "horizon-mods"
 version = "0.1.0"
@@ -1637,7 +1574,6 @@ name = "horizon-optifine"
 version = "0.1.0"
 dependencies = [
  "horizon-bench",
- "horizon-core",
  "log",
  "regex",
 ]
@@ -1677,7 +1613,6 @@ dependencies = [
  "horizon-core",
  "horizon-world",
  "ipconfig",
- "log",
  "serde_json",
  "sha1",
  "sha2",
@@ -1707,12 +1642,10 @@ dependencies = [
  "ab_glyph",
  "base64",
  "chrono",
- "getrandom 0.3.4",
  "horizon-anticheat",
  "horizon-bench",
  "horizon-chat-filter",
  "horizon-core",
- "horizon-mcp",
  "horizon-release-sign",
  "horizon-server-files",
  "libc",
@@ -1800,7 +1733,6 @@ dependencies = [
  "flate2",
  "horizon-core",
  "libm",
- "log",
  "lz4_flex",
  "postcard",
  "serde",
@@ -1947,16 +1879,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "image-webp"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"
-dependencies = [
- "byteorder-lite",
- "quick-error",
-]
-
 [[package]]
 name = "indexmap"
 version = "2.14.2"
@@ -2180,6 +2102,8 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 [[package]]
 name = "libmimalloc-sys"
 version = "0.1.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9"
 dependencies = [
  "cc",
  "cty",
@@ -2317,18 +2241,6 @@ dependencies = [
  "simd-adler32",
 ]
 
-[[package]]
-name = "mio"
-version = "1.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1788edb87fdc09c7e26304471e2f5be8cdefb1b6930d6e3985fc02ff53bf86ee"
-dependencies = [
- "libc",
- "log",
- "wasi",
- "windows-sys 0.61.2",
-]
-
 [[package]]
 name = "multiversion_no_op"
 version = "1.0.0"
@@ -3190,12 +3102,6 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
 
-[[package]]
-name = "quick-error"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
-
 [[package]]
 name = "quick-xml"
 version = "0.41.0"
@@ -5213,8 +5119,10 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
 name = "xtask"
 version = "0.1.0"
 dependencies = [
- "horizon-mod-api-gen",
  "horizon-theme",
+ "quote",
+ "serde_json",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -5376,18 +5284,3 @@ dependencies = [
  "log",
  "simd-adler32",
 ]
-
-[[package]]
-name = "zune-core"
-version = "0.4.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
-
-[[package]]
-name = "zune-jpeg"
-version = "0.4.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713"
-dependencies = [
- "zune-core",
-]

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal", "third_party/naga", "third_party/libmimalloc-sys"]
+exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal", "third_party/naga"]
 members = [
     "crates/horizon-core",
     "crates/horizon-dualsense",
@@ -12,14 +12,11 @@ members = [
     "crates/horizon-client-core",
     "crates/horizon-client-input",
     "crates/horizon-client-render",
-    "crates/horizon-cosmetics",
     "crates/horizon-command",
     "crates/horizon-items",
     "crates/horizon-server-files",
     "crates/horizon-anticheat",
     "crates/horizon-chat-filter",
-    # The Model Context Protocol, shared by horizon-ctl, horizon-server and the launcher.
-    "crates/horizon-mcp",
     "crates/horizon-server",
     "crates/horizon-bots",
     "crates/horizon-assets",
@@ -31,8 +28,6 @@ members = [
     "crates/horizon-friends",
     "crates/horizon-relay",
     "crates/horizon-mods",
-    "crates/horizon-mod-api-gen",
-    "crates/horizon-mod-api-gen/dispatch-tests",
     "crates/cargo-horizon-mod",
     "crates/horizon-port-pack",
     "crates/horizon-shaders",
@@ -70,10 +65,6 @@ large_enum_variant = "allow"
 wgpu-hal = { path = "third_party/wgpu-hal" }
 # naga 30.0.1, with the fixes to its GLSL frontend that shader packs need (THIRD_PARTY_NOTICES.md).
 naga = { path = "third_party/naga" }
-# libmimalloc-sys 0.1.49 whose mimalloc v3 counts bits without POPCNT when MSVC builds it: the
-# game died before main on CPUs without it (Core 2, #7264; THIRD_PARTY_NOTICES.md). Drop this and
-# the folder once a libmimalloc-sys release has microsoft/mimalloc#1291's fix.
-libmimalloc-sys = { path = "third_party/libmimalloc-sys" }
 
 # Line tables keep file:line in backtraces; full debug info made every
 # example and test binary hundreds of megabytes and slow to link.

README.md

@@ -7,7 +7,7 @@
   <img src="https://img.shields.io/badge/Minecraft-Java%2026.3-5D9C3F" alt="Minecraft Java 26.3">
   <img src="https://img.shields.io/badge/Rust-stable-B7410E?logo=rust&logoColor=white" alt="Rust">
   <img src="https://img.shields.io/badge/vanilla%20parity-100%25-F0795A" alt="Vanilla parity 100%">
-  <a href="#project-status"><img src="https://img.shields.io/badge/player--visible%20gaps-0%20open-F0795A" alt="Player-visible gaps open"></a>
+  <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>
@@ -30,7 +30,7 @@ Minecraft: Java Edition 26.3, rewritten in Rust. Same worlds, same rules, same t
 
 ## Download
 
-Get **the Horizon launcher** from [playhorizon.dev](https://playhorizon.dev) or [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher&expanded=true) (Linux x86-64, macOS on Apple Silicon, macOS on Intel from the next Nightly, Windows x64). It installs and updates the game, prepares its files from your copy of Minecraft, and updates itself.
+Get **the Horizon launcher** from [playhorizon.dev](https://playhorizon.dev) or [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher-v&expanded=true) (Linux x86-64, macOS on Apple Silicon, macOS on Intel from the next Nightly, Windows x64). It installs and updates the game, prepares its files from your copy of Minecraft, and updates itself.
 
 **You need** a Microsoft account that owns Java Edition ([why](docs/microsoft-account.md)) and a GPU with Vulkan or OpenGL 3.3 (Linux), Vulkan or DirectX 12 (Windows), or a Mac (Apple Silicon, or Intel from the next Nightly). An existing Minecraft install (official launcher, Prism, MultiMC...) is reused; without one, Play downloads 26.3 from Mojang for your account. Step by step: [Install and first launch](https://playhorizon.dev/docs/install).
 
@@ -122,13 +122,13 @@ It runs rustfmt, clippy, the touched crates' tests, the Python tests, the public
 
 ## Project status
 
-**Player-visible gaps: 0 open** of the 833 the [port ledger](tools/port_ledger.py) found, reading every vanilla 26.3 method against Horizon's code: vanilla behaviour a player would notice that Horizon doesn't have yet. By area: Animals [0](https://github.com/horizon-rust/horizon/issues/3512); Monsters and bosses [0](https://github.com/horizon-rust/horizon/issues/3513); Entities, projectiles, vehicles and decorations [0](https://github.com/horizon-rust/horizon/issues/3514); Items, enchantments and inventories [0](https://github.com/horizon-rust/horizon/issues/3515); Blocks, redstone and fluids [0](https://github.com/horizon-rust/horizon/issues/3516); World, world generation and saves [0](https://github.com/horizon-rust/horizon/issues/3517); Screens, HUD and client packets [0](https://github.com/horizon-rust/horizon/issues/3518); Entity and block rendering, models [0](https://github.com/horizon-rust/horizon/issues/3519); Server and players on the server [0](https://github.com/horizon-rust/horizon/issues/3520); Mob AI, villagers and raids [0](https://github.com/horizon-rust/horizon/issues/3521). This number goes down as gaps close (`tools/parity_gaps.py`); the harness results below say that what is tested matches.
+**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 is the project's own audit: every subsystem matches vanilla in every harness that compares it. 100% means 100% of what the harnesses compare, not that nothing else differs.
 
 ### Java parity: 100%
 
-Scores: 0 (absent), 0.25 (started), 0.5 (playable, major features missing), 0.75 (mostly complete) or 1 (complete and verified by differential tests); the percentage is their average. Last audited 2026-10-13: the harnesses pass on Linux and macOS. The [port ledger](tools/port_ledger.py) adds a method-by-method view of what is ported.
+Scores: 0 (absent), 0.25 (started), 0.5 (playable, major features missing), 0.75 (mostly complete) or 1 (complete and verified by differential tests); the percentage is their average. Last audited 2026-10-13: all 281 harnesses pass on Linux and macOS. The [port ledger](tools/port_ledger.py) adds a method-by-method view of what is ported.
 
 | Subsystem | Score | Main gaps |
 | --- | ---: | --- |

ROADMAP.md

@@ -92,7 +92,7 @@ Owner: [ludovic111](https://github.com/ludovic111) · Tracking: [#3914](https://
 
 <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. 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).
+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>
 
@@ -234,11 +234,11 @@ Client-of-a-server fixes in `game/remote*.rs` and `horizon-protocol`: mobs' aggr
 
 #### One single-player path: remove the in-frame world
 
-Single player has one way to run, the server thread, so every fix works everywhere and there are fewer bugs. The older in-frame mode is removed.
+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`) ticked the world inside the window's `Game`. [#6473](https://github.com/horizon-rust/horizon/issues/6473) removes it with the code only it reached (the window's world loader and player tick, its portal travel and loading screen, the in-frame LAN host); the harnesses run on the server thread. See also 'Single player as a server' and [docs/server-levels.md](docs/server-levels.md).
+`--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>
 
@@ -634,6 +634,16 @@ A spike with ray-traced sun shadows, off by default, is a draft ([#1180](https:/
 
 </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.
@@ -868,7 +878,7 @@ Banners in End cities show as plain magenta instead of with their pattern.
 
 <details><summary>Technical</summary>
 
-Compare the banner block entities the End city templates place with vanilla's (`EndCityPieces`, the templates' block entity NBT, `BannerBlockEntity`'s patterns), in `crates/horizon-world/src/worldgen/structure/`. Issue [#1438](https://github.com/horizon-rust/horizon/issues/1438); possibly related: [#526](https://github.com/horizon-rust/horizon/issues/526). The templates' block entities now keep their patterns ([#1928](https://github.com/horizon-rust/horizon/issues/1928)).
+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>
 
@@ -878,7 +888,7 @@ Armour and tools in End city chests should come enchanted, as in vanilla.
 
 <details><summary>Technical</summary>
 
-`loot.rs` implements `enchant_with_levels`: find why the End city chest table's rolls come out bare, and compare them with vanilla's for a few seeds. Issues [#1437](https://github.com/horizon-rust/horizon/issues/1437), [#1660](https://github.com/horizon-rust/horizon/issues/1660). The loot's enchantment functions now reach every table that rolls ([#1911](https://github.com/horizon-rust/horizon/issues/1911), [#2037](https://github.com/horizon-rust/horizon/issues/2037)).
+`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>
 
@@ -894,7 +904,6 @@ Armour and tools in End city chests should come enchanted, as in vanilla.
 - **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)
-- **HDR monitors** (v0.2.74): Output for HDR monitors: brighter highlights and richer colour where your screen supports it. [#1441](https://github.com/horizon-rust/horizon/issues/1441) · [#2021](https://github.com/horizon-rust/horizon/issues/2021) · [#2292](https://github.com/horizon-rust/horizon/issues/2292)
 - **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)

THIRD_PARTY_NOTICES.md

@@ -14,20 +14,6 @@ Apache-2.0; both licenses are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
 fixes to its GLSL frontend that shader packs need, each applied in the commit that needed it. It is licensed under MIT or Apache-2.0; both licenses
 are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
 
-The GLSL frontend also resets the common type for each comma-separated declarator so one
-variable's array specifier does not change later variables.
-It also reads a struct member outside a constant expression through a pointer to the member,
-not out of a loaded copy of the whole struct, so a member an atomic function uses can be read.
-
-## libmimalloc-sys and mimalloc
-
-`third_party/libmimalloc-sys` is [libmimalloc-sys](https://github.com/purpleprotocol/mimalloc_rust)
-0.1.49 by Octavian Oncescu, with the [mimalloc](https://github.com/microsoft/mimalloc) v3 sources it
-bundles (Copyright (c) 2018-2025 Microsoft Corporation, Daan Leijen), both under the MIT license
-(`LICENSE.txt` and `c_src/mimalloc/v3/LICENSE` in that folder). It holds only the v3 sources. One
-change: `mi_popcount` in `include/mimalloc/bits.h` uses mimalloc's portable bit count on MSVC
-x86/x64 instead of the POPCNT instruction, which CPUs before Nehalem lack (#7264).
-
 ## Pixelify Sans
 
 `crates/horizon-theme/fonts/PixelifySans-*.ttf` is [Pixelify Sans](https://github.com/eifetx/Pixelify-Sans)
@@ -41,17 +27,6 @@ by The Pixelify Sans Project Authors, licensed under the SIL Open Font License 1
 license (`crates/horizon-theme/icons/pixel/LICENSE-pixelarticons.txt`). `star.svg` is Horizon's own, drawn on
 the same grid.
 
-## Hugeicons
-
-`crates/horizon-theme/icons/glass/*.svg` are icons from the free set of
-[Hugeicons](https://github.com/hugeicons/hugeicons) (`@hugeicons/core-free-icons` 4.4.0), under
-the MIT license (`crates/horizon-theme/icons/glass/LICENSE-hugeicons.txt`), exported with a 1.6
-stroke in `currentColor`.
-
-`crates/horizon-theme/icons/glass/discord.svg` is Discord's logo as drawn by
-[Simple Icons](https://github.com/simple-icons/simple-icons) 13.21.0 (CC0 1.0). The logo is Discord's
-trademark, used only on the button that opens Horizon's Discord server.
-
 ## AMD FidelityFX SDK (FSR 3.1 frame generation)
 
 `crates/horizon-client-render/src/gfx/frame_gen/optical_flow.wgsl` and `interpolation.wgsl` are
@@ -66,17 +41,19 @@ trademarks; Horizon is not affiliated with AMD.
 
 ## Mod loader logos
 
-The launcher shows the logo of the mod loader an instance plays with, and offers the logos as
-instance icons.
+The launcher shows the logo of the mod loader an instance plays with.
 
-- `launcher/assets/logos/{fabric,quilt,neoforge,forge}.png` are the loaders' logos as the launcher
-  mockup on [playhorizon.dev/launcher](https://playhorizon.dev/launcher) shows them (horizon-site
-  `public/media/launcher/*.webp`, converted to PNG), each its project's own mark:
-  [Fabric](https://fabricmc.net/), [Quilt](https://quiltmc.org/) (its art is
-  [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/)),
-  [NeoForged](https://neoforged.net/) (its art, by Ridanisaurus, is
-  [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)) and
-  [Minecraft Forge](https://minecraftforge.net/). They name the loader an instance runs.
+- `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.
@@ -138,35 +115,3 @@ licensed under the MIT license:
 > 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.
-
-## BlueMap
-
-`crates/horizon-client-render/src/bluemap.rs` reads the lowres tiles of a server's
-[BlueMap](https://github.com/BlueMap-Minecraft/BlueMap) web map. It follows three of BlueMap's files:
-`core/src/main/java/de/bluecolored/bluemap/core/map/lowres/LowresLayer.java` (`saveTile`) for the
-tiles' pixel layout, `common/webapp/src/js/util/Utils.js` (`pathFromCoords`) for their paths, and
-`core/src/main/java/de/bluecolored/bluemap/core/map/MapSettingsSerializer.java` for a map's
-`settings.json`, at commit
-[96ae320d1d39](https://github.com/BlueMap-Minecraft/BlueMap/tree/96ae320d1d39581c10058d8222f2290f2fcb5333).
-BlueMap is licensed under the MIT license:
-
-> Copyright (c) Blue (Lukas Rieger) <https://bluecolored.de>
-> Copyright (c) contributors
->
-> 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.

bench/bench.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """Server load bench: the same horizon-bots load on Horizon, vanilla 26.3 or Pumpkin.
 
-    python3 tools/bench.py --server horizon --exe target/release/horizon-server --bots 50
-    python3 tools/bench.py --server vanilla --jar ~/mc/server.jar --bots 50 --pre-generated ~/worlds/seed12345
-    python3 tools/bench.py --server pumpkin --exe ./pumpkin --bots 50
+    python3 bench/bench.py --server horizon --exe target/release/horizon-server --bots 50
+    python3 bench/bench.py --server vanilla --jar ~/mc/server.jar --bots 50 --pre-generated ~/worlds/seed12345
+    python3 bench/bench.py --server pumpkin --exe ./pumpkin --bots 50
 
 Every run uses a fresh scratch folder (bound to 127.0.0.1, offline, creative so the bots can fly), starts the
 server, lets `horizon-bots` join one every --join-every seconds, warms up, then measures for --seconds:
@@ -39,11 +39,6 @@ import tempfile
 import threading
 import time
 
-try:
-    from . import lab
-except ImportError:
-    import lab
-
 ROOT = Path(__file__).resolve().parent.parent
 EXE = '.exe' if os.name == 'nt' else ''
 SERVERS = ('horizon', 'vanilla', 'pumpkin')
@@ -212,7 +207,8 @@ class Server:
         self.lines = []
         self.lock = threading.Lock()
         self.log = log_path.open('w', encoding='utf-8')
-        env = lab.game_env(HORIZON_HOME=directory / 'horizon-home')
+        env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_HOME=str(directory / 'horizon-home'),
+                   HORIZON_LAUNCHER_NO_SELF_UPDATE='1')
         self.process = subprocess.Popen([str(c) for c in command], cwd=directory, stdin=subprocess.PIPE,
                                         stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
                                         encoding='utf-8', errors='replace', env=env)

benchmarks/particle-culling/2026-11-02/README.md

@@ -1,27 +0,0 @@
-# Particle culling review measurements — 2026-11-02
-
-Ordinary-scene captures and measurements for PR #7054. The scene contains 24 mobs, about 9,400–10,100 rain particles, and about 50–100 campfire smoke particles. Two opposite-order passes were run with 2 s warmup and 8 s measurement per condition. Host: Intel Core i7-3770S, Intel HD Graphics 4000, Vulkan/Mesa, 675×727, render distance 4, VSync off, 260 FPS cap.
-
-These are means of the two samples. CPU is the harness's average CPU time per frame; p99 is frame time. The normal scene is not expected to show large gains because most particles are visible.
-
-| Condition | FPS | CPU ms/frame | Frame p99 ms |
-| --- | ---: | ---: | ---: |
-| Main, culling Off | 88.39 | 1.930 | 23.85 |
-| Particle branch, culling Off | 88.55 | 1.828 | 24.88 |
-| Main, Entity Culling Synchronous | 89.12 | 1.887 | 23.07 |
-| Particle branch, Entity Culling Synchronous, Particle Culling Off | 89.06 | 1.897 | 25.18 |
-| Particle Culling Synchronous | 88.87 | 1.774 | 24.94 |
-| Particle Culling Asynchronous* | 89.00 | 1.754 | 24.90 |
-
-*The asynchronous samples predate the final switch to a dedicated particle worker. They are retained only as historical context and are not a measurement of the final worker implementation. No FPS improvement is claimed from these ordinary-scene runs. The Off path delegates directly to `render`; `disabled_culled_render_matches_the_regular_particle_path` checks that it produces the same vertices.
-
-The FPS and CPU differences are within run-to-run variability for this GPU-limited scene. The first four conditions are the reviewer's requested Main-versus-branch default and existing synchronous-mode comparisons. Particle Sync/Async rows are branch-internal mode comparisons.
-
-## Captures
-
-The screenshots show the same ordinary test world and FPS overlay:
-
-- `main-off.png`
-- `particle-off.png`
-- `particle-sync.png`
-- `particle-async.png`

benchmarks/perf/horizon-desktop-rd12.json

@@ -1,870 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-11-04T13:00:15Z",
- "app": {
-  "name": "horizon-client",
-  "version": "nightly-2026-11-04-67dad0d",
-  "commit": "67dad0d"
- },
- "hardware": {
-  "os": "linux",
-  "arch": "x86_64",
-  "cpu_threads": 24,
-  "os_version": "NixOS 26.05 (Yarara) (kernel 6.18.57)",
-  "cpu": "13th Gen Intel(R) Core(TM) i7-13700KF",
-  "ram_mb": 31904,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 4080",
-   "vendor": "nvidia",
-   "driver": "NVIDIA 595.71.05",
-   "backend": "vulkan",
-   "kind": "discrete"
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 12,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "load_avg_1m": 28.408,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 66658.183,
-   "stdev": 61839.502,
-   "min": 1827.42,
-   "max": 124993.694,
-   "ci95": 153630.237
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 74754.411,
-   "stdev": 59189.587,
-   "min": 13600.651,
-   "max": 131761.773,
-   "ci95": 147046.952
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 5571.499,
-   "stdev": 1900.32,
-   "min": 3378.38,
-   "max": 6730.394,
-   "ci95": 4721.037
-  },
-  "chunks.village.meshed_count": {
-   "n": 3,
-   "mean": 15287.0,
-   "stdev": 527.501,
-   "min": 14788.0,
-   "max": 15839.0,
-   "ci95": 1310.49
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 2958.557,
-   "stdev": 376.543,
-   "min": 2526.453,
-   "max": 3216.434,
-   "ci95": 935.46
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 368.457,
-   "stdev": 90.668,
-   "min": 300.631,
-   "max": 471.438,
-   "ci95": 225.25
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 91.04,
-   "stdev": 40.506,
-   "min": 46.124,
-   "max": 124.796,
-   "ci95": 100.63
-  },
-  "memory.village.gpu_mb": {
-   "n": 3,
-   "mean": 581.0,
-   "stdev": 48.0,
-   "min": 533.0,
-   "max": 629.0,
-   "ci95": 119.248
-  },
-  "memory.village.rss_mb": {
-   "n": 3,
-   "mean": 1277.531,
-   "stdev": 25.546,
-   "min": 1253.879,
-   "max": 1304.623,
-   "ci95": 63.466
-  },
-  "tick.village.client_ms": {
-   "n": 3,
-   "mean": 0.529,
-   "stdev": 0.127,
-   "min": 0.396,
-   "max": 0.649,
-   "ci95": 0.315
-  },
-  "cpu.village.p50_ms": {
-   "n": 3,
-   "mean": 0.185,
-   "stdev": 0.034,
-   "min": 0.162,
-   "max": 0.224,
-   "ci95": 0.085
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 3318.3,
-   "stdev": 911.608,
-   "min": 2266.627,
-   "max": 3883.075,
-   "ci95": 2264.743
-  },
-  "chunks.forest.meshed_count": {
-   "n": 3,
-   "mean": 16565.333,
-   "stdev": 172.755,
-   "min": 16367.0,
-   "max": 16683.0,
-   "ci95": 429.182
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 2333.626,
-   "stdev": 569.124,
-   "min": 1745.365,
-   "max": 2881.457,
-   "ci95": 1413.897
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 336.615,
-   "stdev": 185.666,
-   "min": 208.133,
-   "max": 549.487,
-   "ci95": 461.257
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 160.734,
-   "stdev": 127.586,
-   "min": 39.777,
-   "max": 294.05,
-   "ci95": 316.967
-  },
-  "memory.forest.gpu_mb": {
-   "n": 3,
-   "mean": 666.333,
-   "stdev": 24.44,
-   "min": 645.0,
-   "max": 693.0,
-   "ci95": 60.718
-  },
-  "memory.forest.rss_mb": {
-   "n": 3,
-   "mean": 1346.816,
-   "stdev": 42.279,
-   "min": 1305.547,
-   "max": 1390.037,
-   "ci95": 105.035
-  },
-  "tick.forest.client_ms": {
-   "n": 3,
-   "mean": 0.669,
-   "stdev": 0.084,
-   "min": 0.598,
-   "max": 0.761,
-   "ci95": 0.208
-  },
-  "cpu.forest.p50_ms": {
-   "n": 3,
-   "mean": 0.222,
-   "stdev": 0.032,
-   "min": 0.197,
-   "max": 0.258,
-   "ci95": 0.079
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 2463.434,
-   "stdev": 1056.0,
-   "min": 1527.516,
-   "max": 3608.283,
-   "ci95": 2623.462
-  },
-  "chunks.ocean.meshed_count": {
-   "n": 3,
-   "mean": 14226.667,
-   "stdev": 307.077,
-   "min": 14038.0,
-   "max": 14581.0,
-   "ci95": 762.883
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 2192.874,
-   "stdev": 1320.904,
-   "min": 673.829,
-   "max": 3071.415,
-   "ci95": 3281.573
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 345.406,
-   "stdev": 294.904,
-   "min": 8.977,
-   "max": 559.232,
-   "ci95": 732.642
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 172.573,
-   "stdev": 149.386,
-   "min": 1.038,
-   "max": 274.089,
-   "ci95": 371.125
-  },
-  "memory.ocean.gpu_mb": {
-   "n": 3,
-   "mean": 629.0,
-   "stdev": 32.0,
-   "min": 597.0,
-   "max": 661.0,
-   "ci95": 79.499
-  },
-  "memory.ocean.rss_mb": {
-   "n": 3,
-   "mean": 1352.223,
-   "stdev": 51.951,
-   "min": 1301.492,
-   "max": 1405.314,
-   "ci95": 129.065
-  },
-  "tick.ocean.client_ms": {
-   "n": 3,
-   "mean": 0.512,
-   "stdev": 0.099,
-   "min": 0.406,
-   "max": 0.603,
-   "ci95": 0.246
-  },
-  "cpu.ocean.p50_ms": {
-   "n": 3,
-   "mean": 0.178,
-   "stdev": 0.038,
-   "min": 0.135,
-   "max": 0.206,
-   "ci95": 0.094
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 6260.675,
-   "stdev": 3077.348,
-   "min": 2976.342,
-   "max": 9077.55,
-   "ci95": 7645.173
-  },
-  "chunks.mountain.meshed_count": {
-   "n": 3,
-   "mean": 16015.333,
-   "stdev": 209.872,
-   "min": 15826.0,
-   "max": 16241.0,
-   "ci95": 521.393
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 1412.095,
-   "stdev": 962.145,
-   "min": 714.773,
-   "max": 2509.775,
-   "ci95": 2390.293
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 182.479,
-   "stdev": 177.563,
-   "min": 13.364,
-   "max": 367.429,
-   "ci95": 441.126
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 88.451,
-   "stdev": 87.578,
-   "min": 1.526,
-   "max": 176.667,
-   "ci95": 217.572
-  },
-  "memory.mountain.gpu_mb": {
-   "n": 3,
-   "mean": 799.667,
-   "stdev": 18.475,
-   "min": 789.0,
-   "max": 821.0,
-   "ci95": 45.899
-  },
-  "memory.mountain.rss_mb": {
-   "n": 3,
-   "mean": 1491.572,
-   "stdev": 36.719,
-   "min": 1459.775,
-   "max": 1531.76,
-   "ci95": 91.221
-  },
-  "tick.mountain.client_ms": {
-   "n": 3,
-   "mean": 0.697,
-   "stdev": 0.155,
-   "min": 0.602,
-   "max": 0.876,
-   "ci95": 0.386
-  },
-  "cpu.mountain.p50_ms": {
-   "n": 3,
-   "mean": 0.325,
-   "stdev": 0.115,
-   "min": 0.239,
-   "max": 0.456,
-   "ci95": 0.286
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 1545.896,
-   "stdev": 30.591,
-   "min": 1524.965,
-   "max": 1581.004,
-   "ci95": 75.999
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1348.389,
-   "stdev": 52.5,
-   "min": 1296.172,
-   "max": 1401.168,
-   "ci95": 130.428
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 37594,
-   "seconds": 12.0,
-   "avg_fps": 3132.783,
-   "low_1pct_fps": 471.438,
-   "low_01pct_fps": 124.796,
-   "p50_ms": 0.271,
-   "p95_ms": 0.494,
-   "p99_ms": 1.127,
-   "p999_ms": 2.15,
-   "max_ms": 155.204,
-   "cpu_p50_ms": 0.168,
-   "gpu_p50_ms": 0.104,
-   "histogram": [
-    37151,
-    394,
-    30,
-    8,
-    5,
-    2,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 38598,
-   "seconds": 12.0,
-   "avg_fps": 3216.434,
-   "low_1pct_fps": 300.631,
-   "low_01pct_fps": 46.124,
-   "p50_ms": 0.267,
-   "p95_ms": 0.446,
-   "p99_ms": 1.034,
-   "p999_ms": 1.941,
-   "max_ms": 493.993,
-   "cpu_p50_ms": 0.162,
-   "gpu_p50_ms": 0.104,
-   "histogram": [
-    38177,
-    387,
-    16,
-    8,
-    4,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    1,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 30318,
-   "seconds": 12.0,
-   "avg_fps": 2526.453,
-   "low_1pct_fps": 333.302,
-   "low_01pct_fps": 102.199,
-   "p50_ms": 0.305,
-   "p95_ms": 0.757,
-   "p99_ms": 1.69,
-   "p999_ms": 3.539,
-   "max_ms": 170.856,
-   "cpu_p50_ms": 0.224,
-   "gpu_p50_ms": 0.106,
-   "histogram": [
-    29368,
-    759,
-    139,
-    35,
-    11,
-    3,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 34578,
-   "seconds": 12.0,
-   "avg_fps": 2881.457,
-   "low_1pct_fps": 549.487,
-   "low_01pct_fps": 294.05,
-   "p50_ms": 0.32,
-   "p95_ms": 0.483,
-   "p99_ms": 1.213,
-   "p999_ms": 2.5,
-   "max_ms": 5.358,
-   "cpu_p50_ms": 0.197,
-   "gpu_p50_ms": 0.154,
-   "histogram": [
-    34119,
-    379,
-    64,
-    9,
-    5,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 28489,
-   "seconds": 12.0,
-   "avg_fps": 2374.055,
-   "low_1pct_fps": 208.133,
-   "low_01pct_fps": 39.777,
-   "p50_ms": 0.313,
-   "p95_ms": 0.937,
-   "p99_ms": 1.863,
-   "p999_ms": 4.318,
-   "max_ms": 571.48,
-   "cpu_p50_ms": 0.211,
-   "gpu_p50_ms": 0.151,
-   "histogram": [
-    27193,
-    1071,
-    140,
-    51,
-    19,
-    9,
-    1,
-    2,
-    1,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 20945,
-   "seconds": 12.0,
-   "avg_fps": 1745.365,
-   "low_1pct_fps": 252.226,
-   "low_01pct_fps": 148.375,
-   "p50_ms": 0.343,
-   "p95_ms": 1.505,
-   "p99_ms": 2.758,
-   "p999_ms": 5.341,
-   "max_ms": 11.642,
-   "cpu_p50_ms": 0.258,
-   "gpu_p50_ms": 0.162,
-   "histogram": [
-    18145,
-    2293,
-    337,
-    106,
-    38,
-    13,
-    6,
-    5,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 36856,
-   "seconds": 12.0,
-   "avg_fps": 3071.415,
-   "low_1pct_fps": 559.232,
-   "low_01pct_fps": 274.089,
-   "p50_ms": 0.286,
-   "p95_ms": 0.492,
-   "p99_ms": 1.179,
-   "p999_ms": 2.711,
-   "max_ms": 6.718,
-   "cpu_p50_ms": 0.135,
-   "gpu_p50_ms": 0.127,
-   "histogram": [
-    36366,
-    405,
-    60,
-    13,
-    10,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 34001,
-   "seconds": 12.0,
-   "avg_fps": 2833.377,
-   "low_1pct_fps": 468.008,
-   "low_01pct_fps": 242.591,
-   "p50_ms": 0.295,
-   "p95_ms": 0.589,
-   "p99_ms": 1.41,
-   "p999_ms": 3.048,
-   "max_ms": 7.7,
-   "cpu_p50_ms": 0.206,
-   "gpu_p50_ms": 0.126,
-   "histogram": [
-    33314,
-    544,
-    106,
-    23,
-    10,
-    2,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 8086,
-   "seconds": 12.0,
-   "avg_fps": 673.829,
-   "low_1pct_fps": 8.977,
-   "low_01pct_fps": 1.038,
-   "p50_ms": 0.302,
-   "p95_ms": 0.665,
-   "p99_ms": 2.495,
-   "p999_ms": 15.716,
-   "max_ms": 4849.364,
-   "cpu_p50_ms": 0.194,
-   "gpu_p50_ms": 0.128,
-   "histogram": [
-    7808,
-    166,
-    50,
-    26,
-    8,
-    2,
-    3,
-    5,
-    2,
-    5,
-    1,
-    2,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    1,
-    1,
-    1,
-    2
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 12141,
-   "seconds": 12.0,
-   "avg_fps": 1011.738,
-   "low_1pct_fps": 166.643,
-   "low_01pct_fps": 87.16,
-   "p50_ms": 0.641,
-   "p95_ms": 2.642,
-   "p99_ms": 4.468,
-   "p999_ms": 7.821,
-   "max_ms": 22.536,
-   "cpu_p50_ms": 0.456,
-   "gpu_p50_ms": 0.138,
-   "histogram": [
-    7840,
-    2996,
-    866,
-    278,
-    87,
-    38,
-    16,
-    11,
-    2,
-    5,
-    0,
-    0,
-    0,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 30118,
-   "seconds": 12.0,
-   "avg_fps": 2509.775,
-   "low_1pct_fps": 367.429,
-   "low_01pct_fps": 176.667,
-   "p50_ms": 0.316,
-   "p95_ms": 0.771,
-   "p99_ms": 1.931,
-   "p999_ms": 4.2,
-   "max_ms": 14.633,
-   "cpu_p50_ms": 0.239,
-   "gpu_p50_ms": 0.127,
-   "histogram": [
-    29101,
-    775,
-    173,
-    38,
-    16,
-    8,
-    4,
-    1,
-    0,
-    1,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 8577,
-   "seconds": 12.0,
-   "avg_fps": 714.773,
-   "low_1pct_fps": 13.364,
-   "low_01pct_fps": 1.526,
-   "p50_ms": 0.416,
-   "p95_ms": 2.257,
-   "p99_ms": 4.36,
-   "p999_ms": 212.217,
-   "max_ms": 1051.428,
-   "cpu_p50_ms": 0.28,
-   "gpu_p50_ms": 0.132,
-   "histogram": [
-    7017,
-    978,
-    377,
-    111,
-    39,
-    24,
-    10,
-    6,
-    1,
-    0,
-    2,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    1,
-    2,
-    4,
-    2
-   ]
-  }
- ],
- "label": "horizon-desktop"
-}

benchmarks/perf/horizon-desktop-rd32.json

@@ -1,870 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-11-04T14:47:19Z",
- "app": {
-  "name": "horizon-client",
-  "version": "nightly-2026-11-04-67dad0d",
-  "commit": "67dad0d"
- },
- "hardware": {
-  "os": "linux",
-  "arch": "x86_64",
-  "cpu_threads": 24,
-  "os_version": "NixOS 26.05 (Yarara) (kernel 6.18.57)",
-  "cpu": "13th Gen Intel(R) Core(TM) i7-13700KF",
-  "ram_mb": 31904,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 4080",
-   "vendor": "nvidia",
-   "driver": "NVIDIA 595.71.05",
-   "backend": "vulkan",
-   "kind": "discrete"
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 32,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "load_avg_1m": 29.665,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 45386.16,
-   "stdev": 38970.921,
-   "min": 1077.276,
-   "max": 74343.156,
-   "ci95": 96816.948
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 86585.608,
-   "stdev": 71331.593,
-   "min": 11201.581,
-   "max": 153020.143,
-   "ci95": 177211.803
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 11082.587,
-   "stdev": 5351.291,
-   "min": 7620.454,
-   "max": 17246.096,
-   "ci95": 13294.417
-  },
-  "chunks.village.meshed_count": {
-   "n": 3,
-   "mean": 48440.333,
-   "stdev": 656.16,
-   "min": 48060.0,
-   "max": 49198.0,
-   "ci95": 1630.124
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 853.775,
-   "stdev": 345.646,
-   "min": 524.913,
-   "max": 1214.059,
-   "ci95": 858.701
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 130.235,
-   "stdev": 117.39,
-   "min": 9.024,
-   "max": 243.388,
-   "ci95": 291.635
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 70.65,
-   "stdev": 68.628,
-   "min": 1.125,
-   "max": 138.345,
-   "ci95": 170.496
-  },
-  "memory.village.gpu_mb": {
-   "n": 3,
-   "mean": 2202.333,
-   "stdev": 33.307,
-   "min": 2165.0,
-   "max": 2229.0,
-   "ci95": 82.745
-  },
-  "memory.village.rss_mb": {
-   "n": 3,
-   "mean": 1652.647,
-   "stdev": 73.452,
-   "min": 1568.063,
-   "max": 1700.344,
-   "ci95": 182.478
-  },
-  "tick.village.client_ms": {
-   "n": 3,
-   "mean": 0.493,
-   "stdev": 0.169,
-   "min": 0.319,
-   "max": 0.657,
-   "ci95": 0.42
-  },
-  "cpu.village.p50_ms": {
-   "n": 3,
-   "mean": 0.692,
-   "stdev": 0.207,
-   "min": 0.531,
-   "max": 0.925,
-   "ci95": 0.513
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 15019.921,
-   "stdev": 12855.4,
-   "min": 5613.942,
-   "max": 29668.11,
-   "ci95": 31937.162
-  },
-  "chunks.forest.meshed_count": {
-   "n": 3,
-   "mean": 80224.667,
-   "stdev": 678.709,
-   "min": 79626.0,
-   "max": 80962.0,
-   "ci95": 1686.142
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 898.208,
-   "stdev": 446.3,
-   "min": 382.944,
-   "max": 1163.61,
-   "ci95": 1108.759
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 178.513,
-   "stdev": 107.096,
-   "min": 54.933,
-   "max": 244.255,
-   "ci95": 266.064
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 103.369,
-   "stdev": 78.403,
-   "min": 12.974,
-   "max": 152.87,
-   "ci95": 194.779
-  },
-  "memory.forest.gpu_mb": {
-   "n": 3,
-   "mean": 2201.667,
-   "stdev": 34.429,
-   "min": 2163.0,
-   "max": 2229.0,
-   "ci95": 85.532
-  },
-  "memory.forest.rss_mb": {
-   "n": 3,
-   "mean": 1809.063,
-   "stdev": 93.103,
-   "min": 1707.98,
-   "max": 1891.305,
-   "ci95": 231.3
-  },
-  "tick.forest.client_ms": {
-   "n": 3,
-   "mean": 0.585,
-   "stdev": 0.147,
-   "min": 0.493,
-   "max": 0.754,
-   "ci95": 0.365
-  },
-  "cpu.forest.p50_ms": {
-   "n": 3,
-   "mean": 0.989,
-   "stdev": 0.725,
-   "min": 0.57,
-   "max": 1.826,
-   "ci95": 1.802
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 12399.047,
-   "stdev": 15052.073,
-   "min": 3174.115,
-   "max": 29768.486,
-   "ci95": 37394.441
-  },
-  "chunks.ocean.meshed_count": {
-   "n": 3,
-   "mean": 64737.0,
-   "stdev": 16149.666,
-   "min": 46089.0,
-   "max": 74089.0,
-   "ci95": 40121.232
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 735.22,
-   "stdev": 601.75,
-   "min": 108.108,
-   "max": 1307.912,
-   "ci95": 1494.952
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 134.654,
-   "stdev": 147.391,
-   "min": 1.252,
-   "max": 292.881,
-   "ci95": 366.169
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 62.062,
-   "stdev": 66.294,
-   "min": 0.202,
-   "max": 132.042,
-   "ci95": 164.697
-  },
-  "memory.ocean.gpu_mb": {
-   "n": 3,
-   "mean": 1942.333,
-   "stdev": 251.725,
-   "min": 1657.0,
-   "max": 2133.0,
-   "ci95": 625.369
-  },
-  "memory.ocean.rss_mb": {
-   "n": 3,
-   "mean": 1812.661,
-   "stdev": 102.065,
-   "min": 1697.912,
-   "max": 1893.313,
-   "ci95": 253.564
-  },
-  "tick.ocean.client_ms": {
-   "n": 3,
-   "mean": 0.421,
-   "stdev": 0.227,
-   "min": 0.193,
-   "max": 0.646,
-   "ci95": 0.563
-  },
-  "cpu.ocean.p50_ms": {
-   "n": 3,
-   "mean": 0.513,
-   "stdev": 0.194,
-   "min": 0.303,
-   "max": 0.686,
-   "ci95": 0.483
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 31815.539,
-   "stdev": 36758.245,
-   "min": 9582.166,
-   "max": 74243.988,
-   "ci95": 91319.913
-  },
-  "chunks.mountain.meshed_count": {
-   "n": 3,
-   "mean": 90876.333,
-   "stdev": 1525.588,
-   "min": 89793.0,
-   "max": 92621.0,
-   "ci95": 3790.075
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 712.657,
-   "stdev": 252.815,
-   "min": 450.565,
-   "max": 955.041,
-   "ci95": 628.077
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 117.93,
-   "stdev": 85.922,
-   "min": 24.389,
-   "max": 193.34,
-   "ci95": 213.46
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 72.407,
-   "stdev": 65.468,
-   "min": 3.577,
-   "max": 133.895,
-   "ci95": 162.646
-  },
-  "memory.mountain.gpu_mb": {
-   "n": 3,
-   "mean": 2783.667,
-   "stdev": 48.881,
-   "min": 2741.0,
-   "max": 2837.0,
-   "ci95": 121.436
-  },
-  "memory.mountain.rss_mb": {
-   "n": 3,
-   "mean": 1931.359,
-   "stdev": 106.681,
-   "min": 1808.184,
-   "max": 1994.242,
-   "ci95": 265.031
-  },
-  "tick.mountain.client_ms": {
-   "n": 3,
-   "mean": 1.03,
-   "stdev": 0.685,
-   "min": 0.564,
-   "max": 1.817,
-   "ci95": 1.702
-  },
-  "cpu.mountain.p50_ms": {
-   "n": 3,
-   "mean": 1.025,
-   "stdev": 0.315,
-   "min": 0.765,
-   "max": 1.376,
-   "ci95": 0.783
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2051.333,
-   "stdev": 147.151,
-   "min": 1884.176,
-   "max": 2161.316,
-   "ci95": 365.573
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1810.92,
-   "stdev": 94.623,
-   "min": 1707.342,
-   "max": 1892.828,
-   "ci95": 235.075
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 6301,
-   "seconds": 12.004,
-   "avg_fps": 524.913,
-   "low_1pct_fps": 9.024,
-   "low_01pct_fps": 1.125,
-   "p50_ms": 0.555,
-   "p95_ms": 2.072,
-   "p99_ms": 4.067,
-   "p999_ms": 282.455,
-   "max_ms": 3525.74,
-   "cpu_p50_ms": 0.531,
-   "gpu_p50_ms": 0.218,
-   "histogram": [
-    4878,
-    1060,
-    217,
-    86,
-    19,
-    15,
-    6,
-    2,
-    5,
-    0,
-    1,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    2,
-    0,
-    4,
-    3,
-    1
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 9869,
-   "seconds": 12.001,
-   "avg_fps": 822.353,
-   "low_1pct_fps": 138.293,
-   "low_01pct_fps": 72.479,
-   "p50_ms": 0.976,
-   "p95_ms": 2.871,
-   "p99_ms": 5.065,
-   "p999_ms": 9.942,
-   "max_ms": 23.337,
-   "cpu_p50_ms": 0.925,
-   "gpu_p50_ms": 0.245,
-   "histogram": [
-    5262,
-    3404,
-    771,
-    248,
-    81,
-    49,
-    23,
-    11,
-    12,
-    3,
-    0,
-    3,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 14570,
-   "seconds": 12.001,
-   "avg_fps": 1214.059,
-   "low_1pct_fps": 243.388,
-   "low_01pct_fps": 138.345,
-   "p50_ms": 0.655,
-   "p95_ms": 1.486,
-   "p99_ms": 2.883,
-   "p999_ms": 5.366,
-   "max_ms": 26.145,
-   "cpu_p50_ms": 0.62,
-   "gpu_p50_ms": 0.239,
-   "histogram": [
-    11502,
-    2683,
-    257,
-    77,
-    25,
-    23,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 4595,
-   "seconds": 11.999,
-   "avg_fps": 382.944,
-   "low_1pct_fps": 54.933,
-   "low_01pct_fps": 12.974,
-   "p50_ms": 2.269,
-   "p95_ms": 5.193,
-   "p99_ms": 8.719,
-   "p999_ms": 21.933,
-   "max_ms": 243.247,
-   "cpu_p50_ms": 1.826,
-   "gpu_p50_ms": 0.502,
-   "histogram": [
-    273,
-    1654,
-    1395,
-    836,
-    172,
-    122,
-    52,
-    38,
-    26,
-    10,
-    7,
-    5,
-    0,
-    2,
-    1,
-    0,
-    0,
-    0,
-    1,
-    0,
-    1,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 13964,
-   "seconds": 12.001,
-   "avg_fps": 1163.61,
-   "low_1pct_fps": 244.255,
-   "low_01pct_fps": 152.87,
-   "p50_ms": 0.682,
-   "p95_ms": 1.524,
-   "p99_ms": 2.877,
-   "p999_ms": 5.801,
-   "max_ms": 7.977,
-   "cpu_p50_ms": 0.57,
-   "gpu_p50_ms": 0.467,
-   "histogram": [
-    11067,
-    2532,
-    235,
-    82,
-    23,
-    16,
-    6,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 13777,
-   "seconds": 12.0,
-   "avg_fps": 1148.071,
-   "low_1pct_fps": 236.351,
-   "low_01pct_fps": 144.264,
-   "p50_ms": 0.691,
-   "p95_ms": 1.637,
-   "p99_ms": 3.131,
-   "p999_ms": 5.794,
-   "max_ms": 9.301,
-   "cpu_p50_ms": 0.57,
-   "gpu_p50_ms": 0.465,
-   "histogram": [
-    10826,
-    2511,
-    284,
-    106,
-    23,
-    16,
-    5,
-    5,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 1224,
-   "seconds": 11.322,
-   "avg_fps": 108.108,
-   "low_1pct_fps": 1.252,
-   "low_01pct_fps": 0.202,
-   "p50_ms": 0.439,
-   "p95_ms": 3.015,
-   "p99_ms": 7.359,
-   "p999_ms": 2880.23,
-   "max_ms": 7005.436,
-   "cpu_p50_ms": 0.303,
-   "gpu_p50_ms": 0.258,
-   "histogram": [
-    1081,
-    31,
-    49,
-    10,
-    3,
-    7,
-    23,
-    12,
-    4,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    2
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 15695,
-   "seconds": 12.0,
-   "avg_fps": 1307.912,
-   "low_1pct_fps": 292.881,
-   "low_01pct_fps": 132.042,
-   "p50_ms": 0.624,
-   "p95_ms": 1.219,
-   "p99_ms": 2.173,
-   "p999_ms": 4.841,
-   "max_ms": 16.764,
-   "cpu_p50_ms": 0.551,
-   "gpu_p50_ms": 0.401,
-   "histogram": [
-    13558,
-    1932,
-    140,
-    37,
-    14,
-    6,
-    3,
-    1,
-    1,
-    1,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 9476,
-   "seconds": 12.0,
-   "avg_fps": 789.641,
-   "low_1pct_fps": 109.83,
-   "low_01pct_fps": 53.941,
-   "p50_ms": 0.802,
-   "p95_ms": 3.406,
-   "p99_ms": 5.844,
-   "p999_ms": 14.977,
-   "max_ms": 22.481,
-   "cpu_p50_ms": 0.686,
-   "gpu_p50_ms": 0.403,
-   "histogram": [
-    5819,
-    2151,
-    787,
-    455,
-    112,
-    65,
-    36,
-    18,
-    7,
-    7,
-    7,
-    5,
-    4,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 5352,
-   "seconds": 11.878,
-   "avg_fps": 450.565,
-   "low_1pct_fps": 24.389,
-   "low_01pct_fps": 3.577,
-   "p50_ms": 1.431,
-   "p95_ms": 4.548,
-   "p99_ms": 7.601,
-   "p999_ms": 96.086,
-   "max_ms": 714.027,
-   "cpu_p50_ms": 1.376,
-   "gpu_p50_ms": 0.398,
-   "histogram": [
-    1412,
-    2323,
-    811,
-    460,
-    138,
-    84,
-    49,
-    34,
-    13,
-    9,
-    8,
-    2,
-    1,
-    1,
-    0,
-    1,
-    0,
-    0,
-    1,
-    2,
-    1,
-    1,
-    1,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 8789,
-   "seconds": 12.001,
-   "avg_fps": 732.365,
-   "low_1pct_fps": 136.06,
-   "low_01pct_fps": 79.749,
-   "p50_ms": 0.972,
-   "p95_ms": 3.329,
-   "p99_ms": 5.68,
-   "p999_ms": 9.7,
-   "max_ms": 18.289,
-   "cpu_p50_ms": 0.935,
-   "gpu_p50_ms": 0.383,
-   "histogram": [
-    4529,
-    3007,
-    715,
-    287,
-    120,
-    61,
-    37,
-    16,
-    12,
-    1,
-    1,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 11461,
-   "seconds": 12.001,
-   "avg_fps": 955.041,
-   "low_1pct_fps": 193.34,
-   "low_01pct_fps": 133.895,
-   "p50_ms": 0.787,
-   "p95_ms": 2.026,
-   "p99_ms": 3.953,
-   "p999_ms": 6.511,
-   "max_ms": 9.761,
-   "cpu_p50_ms": 0.765,
-   "gpu_p50_ms": 0.379,
-   "histogram": [
-    7754,
-    3114,
-    328,
-    165,
-    46,
-    33,
-    14,
-    5,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "horizon-desktop"
-}

benchmarks/perf/horizon-macmini-rd12.json

@@ -1,854 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-11-04T12:44:40Z",
- "app": {
-  "name": "horizon-client",
-  "version": "nightly-2026-11-04-67dad0d",
-  "commit": "67dad0d"
- },
- "hardware": {
-  "os": "macos",
-  "arch": "aarch64",
-  "cpu_threads": 14,
-  "os_version": "27.0.1",
-  "cpu": "Apple M4 Pro",
-  "ram_mb": 65536,
-  "gpu": {
-   "name": "Apple M4 Pro",
-   "vendor": "",
-   "driver": "",
-   "backend": "metal",
-   "kind": "integrated"
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 12,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": true,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "load_avg_1m": 17.39,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 1516.155,
-   "stdev": 34.227,
-   "min": 1476.782,
-   "max": 1538.813,
-   "ci95": 85.032
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 4080.9,
-   "stdev": 748.712,
-   "min": 3273.516,
-   "max": 4752.301,
-   "ci95": 1860.054
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 3363.749,
-   "stdev": 224.552,
-   "min": 3105.622,
-   "max": 3514.059,
-   "ci95": 557.864
-  },
-  "chunks.village.meshed_count": {
-   "n": 3,
-   "mean": 15473.667,
-   "stdev": 339.602,
-   "min": 15123.0,
-   "max": 15801.0,
-   "ci95": 843.686
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 999.753,
-   "stdev": 41.901,
-   "min": 970.527,
-   "max": 1047.758,
-   "ci95": 104.095
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 336.821,
-   "stdev": 17.834,
-   "min": 318.068,
-   "max": 353.566,
-   "ci95": 44.306
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 263.782,
-   "stdev": 31.556,
-   "min": 227.767,
-   "max": 286.582,
-   "ci95": 78.395
-  },
-  "memory.village.rss_mb": {
-   "n": 3,
-   "mean": 1147.654,
-   "stdev": 31.82,
-   "min": 1116.875,
-   "max": 1180.422,
-   "ci95": 79.052
-  },
-  "tick.village.client_ms": {
-   "n": 3,
-   "mean": 0.414,
-   "stdev": 0.036,
-   "min": 0.373,
-   "max": 0.44,
-   "ci95": 0.089
-  },
-  "cpu.village.p50_ms": {
-   "n": 3,
-   "mean": 0.52,
-   "stdev": 0.071,
-   "min": 0.44,
-   "max": 0.577,
-   "ci95": 0.177
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 3685.368,
-   "stdev": 844.43,
-   "min": 2932.117,
-   "max": 4598.204,
-   "ci95": 2097.85
-  },
-  "chunks.forest.meshed_count": {
-   "n": 3,
-   "mean": 16795.333,
-   "stdev": 437.802,
-   "min": 16325.0,
-   "max": 17191.0,
-   "ci95": 1087.648
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 592.615,
-   "stdev": 20.339,
-   "min": 580.401,
-   "max": 616.094,
-   "ci95": 50.529
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 250.069,
-   "stdev": 31.227,
-   "min": 217.065,
-   "max": 279.149,
-   "ci95": 77.58
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 151.684,
-   "stdev": 77.064,
-   "min": 64.033,
-   "max": 208.811,
-   "ci95": 191.454
-  },
-  "memory.forest.rss_mb": {
-   "n": 3,
-   "mean": 1064.344,
-   "stdev": 148.185,
-   "min": 901.203,
-   "max": 1190.609,
-   "ci95": 368.142
-  },
-  "tick.forest.client_ms": {
-   "n": 3,
-   "mean": 0.424,
-   "stdev": 0.003,
-   "min": 0.422,
-   "max": 0.427,
-   "ci95": 0.007
-  },
-  "cpu.forest.p50_ms": {
-   "n": 3,
-   "mean": 0.617,
-   "stdev": 0.016,
-   "min": 0.599,
-   "max": 0.629,
-   "ci95": 0.039
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 3594.311,
-   "stdev": 1381.026,
-   "min": 2011.153,
-   "max": 4551.541,
-   "ci95": 3430.936
-  },
-  "chunks.ocean.meshed_count": {
-   "n": 3,
-   "mean": 14527.0,
-   "stdev": 319.629,
-   "min": 14166.0,
-   "max": 14774.0,
-   "ci95": 794.068
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 789.003,
-   "stdev": 25.076,
-   "min": 766.83,
-   "max": 816.216,
-   "ci95": 62.297
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 276.887,
-   "stdev": 51.785,
-   "min": 217.373,
-   "max": 311.665,
-   "ci95": 128.651
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 169.278,
-   "stdev": 29.119,
-   "min": 137.156,
-   "max": 193.944,
-   "ci95": 72.341
-  },
-  "memory.ocean.rss_mb": {
-   "n": 3,
-   "mean": 982.995,
-   "stdev": 287.819,
-   "min": 651.109,
-   "max": 1164.063,
-   "ci95": 715.039
-  },
-  "tick.ocean.client_ms": {
-   "n": 3,
-   "mean": 0.397,
-   "stdev": 0.028,
-   "min": 0.38,
-   "max": 0.429,
-   "ci95": 0.069
-  },
-  "cpu.ocean.p50_ms": {
-   "n": 3,
-   "mean": 0.569,
-   "stdev": 0.045,
-   "min": 0.533,
-   "max": 0.62,
-   "ci95": 0.112
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 5682.993,
-   "stdev": 1272.063,
-   "min": 4476.873,
-   "max": 7012.069,
-   "ci95": 3160.234
-  },
-  "chunks.mountain.meshed_count": {
-   "n": 3,
-   "mean": 15640.0,
-   "stdev": 204.105,
-   "min": 15507.0,
-   "max": 15875.0,
-   "ci95": 507.067
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 716.475,
-   "stdev": 8.139,
-   "min": 707.613,
-   "max": 723.617,
-   "ci95": 20.221
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 313.736,
-   "stdev": 3.759,
-   "min": 311.007,
-   "max": 318.023,
-   "ci95": 9.338
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 270.042,
-   "stdev": 19.572,
-   "min": 247.802,
-   "max": 284.642,
-   "ci95": 48.624
-  },
-  "memory.mountain.rss_mb": {
-   "n": 3,
-   "mean": 997.474,
-   "stdev": 231.733,
-   "min": 790.266,
-   "max": 1247.703,
-   "ci95": 575.704
-  },
-  "tick.mountain.client_ms": {
-   "n": 3,
-   "mean": 0.385,
-   "stdev": 0.023,
-   "min": 0.359,
-   "max": 0.401,
-   "ci95": 0.057
-  },
-  "cpu.mountain.p50_ms": {
-   "n": 3,
-   "mean": 0.609,
-   "stdev": 0.044,
-   "min": 0.56,
-   "max": 0.645,
-   "ci95": 0.109
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 1213.255,
-   "stdev": 81.897,
-   "min": 1136.078,
-   "max": 1299.172,
-   "ci95": 203.461
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1034.279,
-   "stdev": 188.802,
-   "min": 816.453,
-   "max": 1150.961,
-   "ci95": 469.049
-  },
-  "memory.footprint_peak_mb": {
-   "n": 3,
-   "mean": 2167.747,
-   "stdev": 14.039,
-   "min": 2153.721,
-   "max": 2181.799,
-   "ci95": 34.878
-  },
-  "memory.footprint_steady_mb": {
-   "n": 3,
-   "mean": 1889.468,
-   "stdev": 24.444,
-   "min": 1862.799,
-   "max": 1910.807,
-   "ci95": 60.727
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 12573,
-   "seconds": 12.0,
-   "avg_fps": 1047.758,
-   "low_1pct_fps": 353.566,
-   "low_01pct_fps": 286.582,
-   "p50_ms": 0.921,
-   "p95_ms": 1.077,
-   "p99_ms": 2.675,
-   "p999_ms": 2.946,
-   "max_ms": 5.36,
-   "cpu_p50_ms": 0.44,
-   "gpu_p50_ms": 0.914,
-   "histogram": [
-    11056,
-    1291,
-    218,
-    6,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 11646,
-   "seconds": 12.0,
-   "avg_fps": 970.527,
-   "low_1pct_fps": 318.068,
-   "low_01pct_fps": 227.767,
-   "p50_ms": 0.973,
-   "p95_ms": 1.264,
-   "p99_ms": 2.805,
-   "p999_ms": 3.808,
-   "max_ms": 5.305,
-   "cpu_p50_ms": 0.577,
-   "gpu_p50_ms": 0.969,
-   "histogram": [
-    7035,
-    4334,
-    230,
-    39,
-    6,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 11771,
-   "seconds": 11.999,
-   "avg_fps": 980.973,
-   "low_1pct_fps": 338.828,
-   "low_01pct_fps": 276.996,
-   "p50_ms": 0.985,
-   "p95_ms": 1.157,
-   "p99_ms": 2.779,
-   "p999_ms": 3.068,
-   "max_ms": 4.308,
-   "cpu_p50_ms": 0.542,
-   "gpu_p50_ms": 0.98,
-   "histogram": [
-    6880,
-    4663,
-    208,
-    18,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 7394,
-   "seconds": 12.001,
-   "avg_fps": 616.094,
-   "low_1pct_fps": 253.993,
-   "low_01pct_fps": 182.207,
-   "p50_ms": 1.565,
-   "p95_ms": 1.915,
-   "p99_ms": 3.329,
-   "p999_ms": 4.661,
-   "max_ms": 7.32,
-   "cpu_p50_ms": 0.599,
-   "gpu_p50_ms": 1.551,
-   "histogram": [
-    82,
-    6988,
-    144,
-    162,
-    14,
-    2,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 6965,
-   "seconds": 12.0,
-   "avg_fps": 580.401,
-   "low_1pct_fps": 217.065,
-   "low_01pct_fps": 64.033,
-   "p50_ms": 1.654,
-   "p95_ms": 1.983,
-   "p99_ms": 3.233,
-   "p999_ms": 3.893,
-   "max_ms": 81.863,
-   "cpu_p50_ms": 0.629,
-   "gpu_p50_ms": 1.645,
-   "histogram": [
-    11,
-    6622,
-    153,
-    174,
-    4,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 6977,
-   "seconds": 12.001,
-   "avg_fps": 581.35,
-   "low_1pct_fps": 279.149,
-   "low_01pct_fps": 208.811,
-   "p50_ms": 1.659,
-   "p95_ms": 2.006,
-   "p99_ms": 3.273,
-   "p999_ms": 3.982,
-   "max_ms": 5.889,
-   "cpu_p50_ms": 0.623,
-   "gpu_p50_ms": 1.653,
-   "histogram": [
-    17,
-    6606,
-    164,
-    186,
-    1,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 9793,
-   "seconds": 11.998,
-   "avg_fps": 816.216,
-   "low_1pct_fps": 301.624,
-   "low_01pct_fps": 176.734,
-   "p50_ms": 1.171,
-   "p95_ms": 1.499,
-   "p99_ms": 2.928,
-   "p999_ms": 3.333,
-   "max_ms": 23.472,
-   "cpu_p50_ms": 0.533,
-   "gpu_p50_ms": 1.163,
-   "histogram": [
-    259,
-    9293,
-    182,
-    56,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 9202,
-   "seconds": 12.0,
-   "avg_fps": 766.83,
-   "low_1pct_fps": 217.373,
-   "low_01pct_fps": 137.156,
-   "p50_ms": 1.226,
-   "p95_ms": 1.912,
-   "p99_ms": 3.396,
-   "p999_ms": 6.003,
-   "max_ms": 13.562,
-   "cpu_p50_ms": 0.62,
-   "gpu_p50_ms": 1.219,
-   "histogram": [
-    635,
-    8130,
-    261,
-    124,
-    27,
-    15,
-    7,
-    2,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 9408,
-   "seconds": 12.001,
-   "avg_fps": 783.964,
-   "low_1pct_fps": 311.665,
-   "low_01pct_fps": 193.944,
-   "p50_ms": 1.22,
-   "p95_ms": 1.541,
-   "p99_ms": 2.865,
-   "p999_ms": 3.298,
-   "max_ms": 13.861,
-   "cpu_p50_ms": 0.555,
-   "gpu_p50_ms": 1.214,
-   "histogram": [
-    100,
-    9066,
-    204,
-    34,
-    2,
-    0,
-    1,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 8618,
-   "seconds": 12.0,
-   "avg_fps": 718.194,
-   "low_1pct_fps": 312.177,
-   "low_01pct_fps": 277.681,
-   "p50_ms": 1.338,
-   "p95_ms": 1.664,
-   "p99_ms": 3.068,
-   "p999_ms": 3.364,
-   "max_ms": 4.008,
-   "cpu_p50_ms": 0.622,
-   "gpu_p50_ms": 1.329,
-   "histogram": [
-    62,
-    8301,
-    130,
-    125,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 8492,
-   "seconds": 12.001,
-   "avg_fps": 707.613,
-   "low_1pct_fps": 311.007,
-   "low_01pct_fps": 284.642,
-   "p50_ms": 1.35,
-   "p95_ms": 1.707,
-   "p99_ms": 3.08,
-   "p999_ms": 3.329,
-   "max_ms": 3.796,
-   "cpu_p50_ms": 0.645,
-   "gpu_p50_ms": 1.342,
-   "histogram": [
-    32,
-    8216,
-    111,
-    133,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 8684,
-   "seconds": 12.001,
-   "avg_fps": 723.617,
-   "low_1pct_fps": 318.023,
-   "low_01pct_fps": 247.802,
-   "p50_ms": 1.318,
-   "p95_ms": 1.699,
-   "p99_ms": 2.875,
-   "p999_ms": 3.573,
-   "max_ms": 5.186,
-   "cpu_p50_ms": 0.56,
-   "gpu_p50_ms": 1.306,
-   "histogram": [
-    46,
-    8389,
-    199,
-    49,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "horizon-macmini"
-}

benchmarks/perf/horizon-macmini-rd32.json

@@ -1,854 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-11-04T13:17:26Z",
- "app": {
-  "name": "horizon-client",
-  "version": "nightly-2026-11-04-67dad0d",
-  "commit": "67dad0d"
- },
- "hardware": {
-  "os": "macos",
-  "arch": "aarch64",
-  "cpu_threads": 14,
-  "os_version": "27.0.1",
-  "cpu": "Apple M4 Pro",
-  "ram_mb": 65536,
-  "gpu": {
-   "name": "Apple M4 Pro",
-   "vendor": "",
-   "driver": "",
-   "backend": "metal",
-   "kind": "integrated"
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 32,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": true,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "load_avg_1m": 17.712,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 1528.444,
-   "stdev": 181.21,
-   "min": 1319.58,
-   "max": 1643.783,
-   "ci95": 450.188
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 12368.716,
-   "stdev": 6475.37,
-   "min": 7168.429,
-   "max": 19621.62,
-   "ci95": 16087.01
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 6926.208,
-   "stdev": 3712.691,
-   "min": 4208.555,
-   "max": 11156.419,
-   "ci95": 9223.581
-  },
-  "chunks.village.meshed_count": {
-   "n": 3,
-   "mean": 46790.333,
-   "stdev": 1381.89,
-   "min": 45236.0,
-   "max": 47880.0,
-   "ci95": 3433.082
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 453.505,
-   "stdev": 14.384,
-   "min": 441.517,
-   "max": 469.455,
-   "ci95": 35.735
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 222.897,
-   "stdev": 10.449,
-   "min": 212.173,
-   "max": 233.048,
-   "ci95": 25.96
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 173.55,
-   "stdev": 31.798,
-   "min": 142.967,
-   "max": 206.437,
-   "ci95": 78.996
-  },
-  "memory.village.rss_mb": {
-   "n": 3,
-   "mean": 1544.565,
-   "stdev": 26.422,
-   "min": 1516.75,
-   "max": 1569.328,
-   "ci95": 65.64
-  },
-  "tick.village.client_ms": {
-   "n": 3,
-   "mean": 0.528,
-   "stdev": 0.018,
-   "min": 0.511,
-   "max": 0.548,
-   "ci95": 0.045
-  },
-  "cpu.village.p50_ms": {
-   "n": 3,
-   "mean": 1.496,
-   "stdev": 0.049,
-   "min": 1.453,
-   "max": 1.549,
-   "ci95": 0.121
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 8297.116,
-   "stdev": 689.909,
-   "min": 7716.447,
-   "max": 9059.776,
-   "ci95": 1713.966
-  },
-  "chunks.forest.meshed_count": {
-   "n": 3,
-   "mean": 78617.667,
-   "stdev": 494.532,
-   "min": 78228.0,
-   "max": 79174.0,
-   "ci95": 1228.586
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 216.265,
-   "stdev": 6.372,
-   "min": 209.501,
-   "max": 222.156,
-   "ci95": 15.831
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 137.027,
-   "stdev": 3.787,
-   "min": 133.07,
-   "max": 140.617,
-   "ci95": 9.408
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 114.683,
-   "stdev": 7.985,
-   "min": 106.585,
-   "max": 122.551,
-   "ci95": 19.839
-  },
-  "memory.forest.rss_mb": {
-   "n": 3,
-   "mean": 1420.638,
-   "stdev": 247.812,
-   "min": 1266.047,
-   "max": 1706.469,
-   "ci95": 615.649
-  },
-  "tick.forest.client_ms": {
-   "n": 3,
-   "mean": 0.423,
-   "stdev": 0.059,
-   "min": 0.355,
-   "max": 0.458,
-   "ci95": 0.148
-  },
-  "cpu.forest.p50_ms": {
-   "n": 3,
-   "mean": 1.605,
-   "stdev": 0.269,
-   "min": 1.295,
-   "max": 1.779,
-   "ci95": 0.668
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 8354.659,
-   "stdev": 2877.749,
-   "min": 5454.947,
-   "max": 11209.93,
-   "ci95": 7149.301
-  },
-  "chunks.ocean.meshed_count": {
-   "n": 3,
-   "mean": 74315.667,
-   "stdev": 63.106,
-   "min": 74246.0,
-   "max": 74369.0,
-   "ci95": 156.776
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 274.828,
-   "stdev": 4.993,
-   "min": 270.041,
-   "max": 280.004,
-   "ci95": 12.404
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 165.765,
-   "stdev": 7.21,
-   "min": 157.538,
-   "max": 170.985,
-   "ci95": 17.912
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 140.185,
-   "stdev": 9.74,
-   "min": 129.976,
-   "max": 149.377,
-   "ci95": 24.198
-  },
-  "memory.ocean.rss_mb": {
-   "n": 3,
-   "mean": 1306.578,
-   "stdev": 97.011,
-   "min": 1199.094,
-   "max": 1387.641,
-   "ci95": 241.007
-  },
-  "tick.ocean.client_ms": {
-   "n": 3,
-   "mean": 0.416,
-   "stdev": 0.029,
-   "min": 0.392,
-   "max": 0.448,
-   "ci95": 0.071
-  },
-  "cpu.ocean.p50_ms": {
-   "n": 3,
-   "mean": 1.636,
-   "stdev": 0.121,
-   "min": 1.496,
-   "max": 1.708,
-   "ci95": 0.301
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 17124.873,
-   "stdev": 3461.08,
-   "min": 13599.217,
-   "max": 20517.544,
-   "ci95": 8598.494
-  },
-  "chunks.mountain.meshed_count": {
-   "n": 3,
-   "mean": 91909.0,
-   "stdev": 815.603,
-   "min": 91157.0,
-   "max": 92776.0,
-   "ci95": 2026.235
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 242.657,
-   "stdev": 3.405,
-   "min": 240.66,
-   "max": 246.588,
-   "ci95": 8.459
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 110.95,
-   "stdev": 14.622,
-   "min": 99.907,
-   "max": 127.532,
-   "ci95": 36.325
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 51.329,
-   "stdev": 28.253,
-   "min": 30.391,
-   "max": 83.465,
-   "ci95": 70.191
-  },
-  "memory.mountain.rss_mb": {
-   "n": 3,
-   "mean": 1451.688,
-   "stdev": 127.471,
-   "min": 1310.969,
-   "max": 1559.43,
-   "ci95": 316.681
-  },
-  "tick.mountain.client_ms": {
-   "n": 3,
-   "mean": 0.614,
-   "stdev": 0.017,
-   "min": 0.594,
-   "max": 0.627,
-   "ci95": 0.043
-  },
-  "cpu.mountain.p50_ms": {
-   "n": 3,
-   "mean": 2.233,
-   "stdev": 0.05,
-   "min": 2.194,
-   "max": 2.289,
-   "ci95": 0.124
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 1697.984,
-   "stdev": 29.735,
-   "min": 1667.406,
-   "max": 1726.797,
-   "ci95": 73.871
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1428.19,
-   "stdev": 120.658,
-   "min": 1333.0,
-   "max": 1563.891,
-   "ci95": 299.756
-  },
-  "memory.footprint_peak_mb": {
-   "n": 3,
-   "mean": 4921.753,
-   "stdev": 30.436,
-   "min": 4890.971,
-   "max": 4951.831,
-   "ci95": 75.613
-  },
-  "memory.footprint_steady_mb": {
-   "n": 3,
-   "mean": 4079.43,
-   "stdev": 10.978,
-   "min": 4068.049,
-   "max": 4089.956,
-   "ci95": 27.273
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 5634,
-   "seconds": 12.001,
-   "avg_fps": 469.455,
-   "low_1pct_fps": 223.469,
-   "low_01pct_fps": 171.246,
-   "p50_ms": 2.054,
-   "p95_ms": 2.492,
-   "p99_ms": 3.993,
-   "p999_ms": 5.425,
-   "max_ms": 6.645,
-   "cpu_p50_ms": 1.453,
-   "gpu_p50_ms": 1.965,
-   "histogram": [
-    0,
-    2082,
-    3324,
-    193,
-    24,
-    9,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 5395,
-   "seconds": 12.001,
-   "avg_fps": 449.543,
-   "low_1pct_fps": 233.048,
-   "low_01pct_fps": 206.437,
-   "p50_ms": 2.155,
-   "p95_ms": 2.611,
-   "p99_ms": 4.068,
-   "p999_ms": 4.456,
-   "max_ms": 5.305,
-   "cpu_p50_ms": 1.549,
-   "gpu_p50_ms": 2.043,
-   "histogram": [
-    0,
-    902,
-    4255,
-    206,
-    29,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 5298,
-   "seconds": 12.0,
-   "avg_fps": 441.517,
-   "low_1pct_fps": 212.173,
-   "low_01pct_fps": 142.967,
-   "p50_ms": 2.171,
-   "p95_ms": 3.249,
-   "p99_ms": 4.138,
-   "p999_ms": 5.591,
-   "max_ms": 9.676,
-   "cpu_p50_ms": 1.485,
-   "gpu_p50_ms": 2.092,
-   "histogram": [
-    0,
-    709,
-    4314,
-    229,
-    36,
-    6,
-    2,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 2606,
-   "seconds": 12.002,
-   "avg_fps": 217.137,
-   "low_1pct_fps": 140.617,
-   "low_01pct_fps": 106.585,
-   "p50_ms": 4.471,
-   "p95_ms": 5.926,
-   "p99_ms": 6.575,
-   "p999_ms": 7.735,
-   "max_ms": 12.187,
-   "cpu_p50_ms": 1.74,
-   "gpu_p50_ms": 4.238,
-   "histogram": [
-    0,
-    0,
-    0,
-    221,
-    2094,
-    172,
-    110,
-    8,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 2514,
-   "seconds": 12.0,
-   "avg_fps": 209.501,
-   "low_1pct_fps": 137.393,
-   "low_01pct_fps": 122.551,
-   "p50_ms": 4.627,
-   "p95_ms": 6.304,
-   "p99_ms": 6.93,
-   "p999_ms": 7.971,
-   "max_ms": 8.506,
-   "cpu_p50_ms": 1.779,
-   "gpu_p50_ms": 4.409,
-   "histogram": [
-    0,
-    0,
-    2,
-    35,
-    2097,
-    200,
-    162,
-    17,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 2667,
-   "seconds": 12.005,
-   "avg_fps": 222.156,
-   "low_1pct_fps": 133.07,
-   "low_01pct_fps": 114.913,
-   "p50_ms": 4.37,
-   "p95_ms": 5.756,
-   "p99_ms": 6.742,
-   "p999_ms": 8.444,
-   "max_ms": 8.984,
-   "cpu_p50_ms": 1.295,
-   "gpu_p50_ms": 4.152,
-   "histogram": [
-    0,
-    0,
-    0,
-    440,
-    1978,
-    144,
-    85,
-    16,
-    4,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 3294,
-   "seconds": 12.003,
-   "avg_fps": 274.44,
-   "low_1pct_fps": 157.538,
-   "low_01pct_fps": 129.976,
-   "p50_ms": 3.521,
-   "p95_ms": 4.814,
-   "p99_ms": 5.592,
-   "p999_ms": 7.491,
-   "max_ms": 7.868,
-   "cpu_p50_ms": 1.703,
-   "gpu_p50_ms": 3.277,
-   "histogram": [
-    0,
-    4,
-    55,
-    2967,
-    130,
-    122,
-    10,
-    6,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 3241,
-   "seconds": 12.002,
-   "avg_fps": 270.041,
-   "low_1pct_fps": 168.771,
-   "low_01pct_fps": 141.201,
-   "p50_ms": 3.578,
-   "p95_ms": 4.942,
-   "p99_ms": 5.631,
-   "p999_ms": 6.498,
-   "max_ms": 7.601,
-   "cpu_p50_ms": 1.708,
-   "gpu_p50_ms": 3.323,
-   "histogram": [
-    0,
-    2,
-    8,
-    2970,
-    110,
-    144,
-    5,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 3360,
-   "seconds": 12.0,
-   "avg_fps": 280.004,
-   "low_1pct_fps": 170.985,
-   "low_01pct_fps": 149.377,
-   "p50_ms": 3.477,
-   "p95_ms": 4.678,
-   "p99_ms": 5.462,
-   "p999_ms": 6.626,
-   "max_ms": 6.788,
-   "cpu_p50_ms": 1.496,
-   "gpu_p50_ms": 3.23,
-   "histogram": [
-    0,
-    1,
-    5,
-    3125,
-    129,
-    90,
-    10,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 2888,
-   "seconds": 12.0,
-   "avg_fps": 240.66,
-   "low_1pct_fps": 127.532,
-   "low_01pct_fps": 83.465,
-   "p50_ms": 3.984,
-   "p95_ms": 5.171,
-   "p99_ms": 6.823,
-   "p999_ms": 9.168,
-   "max_ms": 15.341,
-   "cpu_p50_ms": 2.194,
-   "gpu_p50_ms": 3.786,
-   "histogram": [
-    0,
-    0,
-    4,
-    2048,
-    638,
-    144,
-    33,
-    16,
-    3,
-    1,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 2889,
-   "seconds": 12.001,
-   "avg_fps": 240.722,
-   "low_1pct_fps": 99.907,
-   "low_01pct_fps": 40.132,
-   "p50_ms": 3.961,
-   "p95_ms": 5.706,
-   "p99_ms": 7.364,
-   "p999_ms": 12.597,
-   "max_ms": 49.156,
-   "cpu_p50_ms": 2.289,
-   "gpu_p50_ms": 3.802,
-   "histogram": [
-    0,
-    5,
-    126,
-    1859,
-    599,
-    194,
-    72,
-    22,
-    8,
-    1,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 2959,
-   "seconds": 12.0,
-   "avg_fps": 246.588,
-   "low_1pct_fps": 105.411,
-   "low_01pct_fps": 30.391,
-   "p50_ms": 3.851,
-   "p95_ms": 5.353,
-   "p99_ms": 6.248,
-   "p999_ms": 9.05,
-   "max_ms": 54.378,
-   "cpu_p50_ms": 2.216,
-   "gpu_p50_ms": 3.667,
-   "histogram": [
-    0,
-    2,
-    58,
-    2196,
-    462,
-    196,
-    32,
-    10,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "horizon-macmini"
-}

benchmarks/perf/site-2026-11-04.md

@@ -1,42 +0,0 @@
-# Horizon Nightly 2026-11-04 vs vanilla 26.3 on the Mac mini and the desktop (2026-11-04)
-
-> **The Mac mini reports (`*-macmini-rd*.json`) are offscreen, not comparable.** Horizon rendered offscreen (no presenting)
-> while vanilla drew into a window, so the Mac rows below are not a Horizon-vs-vanilla comparison, and the website does not
-> publish them: it keeps the Mac mini's 2026-10-22 runs. They are kept here only as a record of that day's offscreen run.
-
-The desktop runs are the ones behind playhorizon.dev/benchmarks as of 2026-11-04 (horizon-rust/horizon-site#58): `tools/perf_bench.py`
-reports, render distance 12 and 32, three games each, every game from a fresh world (seed 1234), 1280x720, VSync off. Files:
-`{horizon,vanilla}-macmini-rd{12,32}.json` and `{horizon,vanilla}-desktop-rd{12,32}.json` next to this page.
-
-## Builds
-
-- **Horizon:** the Nightly 2026-11-04 release bundle (67dad0d), as the launcher installs it: macOS arm64 on the Mac,
-  Linux x86_64 on the desktop. Its resources come from the bundle's own `horizon-prepare`. perf_bench ran from main
-  a55b9a2e52 and wrote that checkout's crate version and commit; `app.version` and `app.commit` were set to the bundle's by hand.
-- **Vanilla:** the 26.3 client jar with Fabric Loader and the driver mod, Java 25, the official launcher's JVM flags.
-
-## Machines and conditions
-
-- **Mac mini, Apple M4 Pro (14 cores, 20-core GPU), macOS: offscreen, not comparable.** The session was locked, so Horizon ran `--offscreen`: a locked
-  session gives a window no frames, and windowed Horizon measured 0 FPS. Vanilla drew into its window. Offscreen skips
-  presenting, which favours Horizon, so its averages aren't held at the 144 Hz display as they were on 2026-10-22. Each game
-  started at a 1-minute load of 17-18 (the run waited for < 20); during the runs the load rose to 30-50.
-- **Desktop, RTX 4080 + i7-13700KF, NixOS, NVIDIA 595.** Both games drew into a headless sway rendering on the RTX 4080 (never
-  on its screen), both through Wayland on Vulkan. Vanilla went through SDL's Wayland driver: through Xwayland each of its
-  frames took about 2 s on this day. The machine also runs CI and agents' builds: each game started at a load of 28-30 on
-  24 threads (the run waited for < 30) and the load rose to 40-70 during the runs. Vanilla at RD 32 crashed twice under that
-  load (`GPU timeout attempting to acquire next frame`) before a third series finished. Start-up times are inflated by the
-  load and by a cold disk on each series' first start (start → world up to 130-235 s).
-- **Order:** RD 12 ran Horizon then vanilla; RD 32 ran vanilla then Horizon.
-
-## Results (average over the flights of the three games; FPS average / 1% low)
-
-| Machine | RD | Horizon | Vanilla | Horizon ÷ vanilla (avg, 1% low) |
-|---|---|---|---|---|
-| Mac mini (**offscreen, not comparable**) | 12 | 774 / 294 | 132 / 27 | — |
-| Mac mini (**offscreen, not comparable**) | 32 | 297 / 159 | 68 / 16 | — |
-| Desktop | 12 | 2,224 / 308 | 1,824 / 201 | 1.2x, 1.5x |
-| Desktop | 32 | 800 / 140 | 696 / 64 | 1.15x, 2.2x |
-
-Neither machine was idle, so these say how both games behave on busy machines. They are not clean ratios; for those, see
-`windows-9800x3d-5080-2026-10-29.md`. The scripts and logs are in horizon-parity `shots/site-bench-2026-11-04/`.

benchmarks/perf/vanilla-desktop-rd12.json

@@ -1,787 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-11-04T13:28:55Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   }
-  ]
- },
- "hardware": {
-  "os": "linux",
-  "arch": "x86_64",
-  "cpu_threads": 24,
-  "os_version": "NixOS 26.05 (Yarara) (kernel 6.18.57)",
-  "cpu": "13th Gen Intel(R) Core(TM) i7-13700KF",
-  "ram_mb": 31904,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 4080",
-   "vendor": "NVIDIA",
-   "driver": "1.4.329 NVIDIA 595.71.05",
-   "backend": "vulkan",
-   "kind": ""
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 12,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "load_avg_1m": 28.788,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 121075.467,
-   "stdev": 30646.429,
-   "min": 93272.034,
-   "max": 153935.834,
-   "ci95": 76136.094
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 191063.8,
-   "stdev": 34368.16,
-   "min": 153895.533,
-   "max": 221692.034,
-   "ci95": 85382.134
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 18724.322,
-   "stdev": 9639.048,
-   "min": 13107.549,
-   "max": 29854.376,
-   "ci95": 23946.655
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 2161.532,
-   "stdev": 287.109,
-   "min": 1830.069,
-   "max": 2332.81,
-   "ci95": 713.276
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 162.575,
-   "stdev": 29.799,
-   "min": 136.023,
-   "max": 194.804,
-   "ci95": 74.03
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 27.752,
-   "stdev": 3.186,
-   "min": 24.403,
-   "max": 30.746,
-   "ci95": 7.916
-  },
-  "memory.village.gpu_mb": {
-   "n": 3,
-   "mean": 13.0,
-   "stdev": 0.0,
-   "min": 13.0,
-   "max": 13.0,
-   "ci95": 0.0
-  },
-  "memory.village.rss_mb": {
-   "n": 3,
-   "mean": 2902.054,
-   "stdev": 158.708,
-   "min": 2747.244,
-   "max": 3064.393,
-   "ci95": 394.285
-  },
-  "tick.village.client_ms": {
-   "n": 3,
-   "mean": 0.691,
-   "stdev": 0.097,
-   "min": 0.601,
-   "max": 0.794,
-   "ci95": 0.241
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 8852.332,
-   "stdev": 530.809,
-   "min": 8350.811,
-   "max": 9408.241,
-   "ci95": 1318.709
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 1841.581,
-   "stdev": 1186.781,
-   "min": 471.209,
-   "max": 2529.847,
-   "ci95": 2948.365
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 255.087,
-   "stdev": 217.128,
-   "min": 5.798,
-   "max": 402.877,
-   "ci95": 539.419
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 92.882,
-   "stdev": 81.722,
-   "min": 0.61,
-   "max": 156.13,
-   "ci95": 203.024
-  },
-  "memory.forest.gpu_mb": {
-   "n": 3,
-   "mean": 13.0,
-   "stdev": 0.0,
-   "min": 13.0,
-   "max": 13.0,
-   "ci95": 0.0
-  },
-  "memory.forest.rss_mb": {
-   "n": 3,
-   "mean": 3008.178,
-   "stdev": 149.07,
-   "min": 2875.082,
-   "max": 3169.256,
-   "ci95": 370.34
-  },
-  "tick.forest.client_ms": {
-   "n": 3,
-   "mean": 0.687,
-   "stdev": 0.132,
-   "min": 0.562,
-   "max": 0.825,
-   "ci95": 0.327
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 21215.745,
-   "stdev": 22821.547,
-   "min": 8034.077,
-   "max": 47567.797,
-   "ci95": 56696.441
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 1525.483,
-   "stdev": 1472.651,
-   "min": 633.984,
-   "max": 3225.275,
-   "ci95": 3658.563
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 191.398,
-   "stdev": 272.942,
-   "min": 10.346,
-   "max": 505.335,
-   "ci95": 678.08
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 49.506,
-   "stdev": 66.145,
-   "min": 1.104,
-   "max": 124.874,
-   "ci95": 164.326
-  },
-  "memory.ocean.gpu_mb": {
-   "n": 3,
-   "mean": 13.0,
-   "stdev": 0.0,
-   "min": 13.0,
-   "max": 13.0,
-   "ci95": 0.0
-  },
-  "memory.ocean.rss_mb": {
-   "n": 3,
-   "mean": 3062.136,
-   "stdev": 128.594,
-   "min": 2962.541,
-   "max": 3207.313,
-   "ci95": 319.472
-  },
-  "tick.ocean.client_ms": {
-   "n": 3,
-   "mean": 1.029,
-   "stdev": 0.573,
-   "min": 0.595,
-   "max": 1.678,
-   "ci95": 1.423
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 33255.15,
-   "stdev": 20451.99,
-   "min": 16655.144,
-   "max": 56102.104,
-   "ci95": 50809.661
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 1769.12,
-   "stdev": 996.863,
-   "min": 818.512,
-   "max": 2806.557,
-   "ci95": 2476.544
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 195.916,
-   "stdev": 195.285,
-   "min": 11.586,
-   "max": 400.567,
-   "ci95": 485.154
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 52.202,
-   "stdev": 51.208,
-   "min": 1.461,
-   "max": 103.864,
-   "ci95": 127.217
-  },
-  "memory.mountain.gpu_mb": {
-   "n": 3,
-   "mean": 13.0,
-   "stdev": 0.0,
-   "min": 13.0,
-   "max": 13.0,
-   "ci95": 0.0
-  },
-  "memory.mountain.rss_mb": {
-   "n": 3,
-   "mean": 2957.948,
-   "stdev": 340.935,
-   "min": 2586.504,
-   "max": 3256.625,
-   "ci95": 846.998
-  },
-  "tick.mountain.client_ms": {
-   "n": 3,
-   "mean": 1.436,
-   "stdev": 1.406,
-   "min": 0.462,
-   "max": 3.048,
-   "ci95": 3.494
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 3107.953,
-   "stdev": 141.888,
-   "min": 3020.105,
-   "max": 3271.645,
-   "ci95": 352.498
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 2985.317,
-   "stdev": 210.327,
-   "min": 2761.164,
-   "max": 3178.35,
-   "ci95": 522.523
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 21963,
-   "seconds": 12.001,
-   "avg_fps": 1830.069,
-   "low_1pct_fps": 136.023,
-   "low_01pct_fps": 30.746,
-   "p50_ms": 0.331,
-   "p95_ms": 1.153,
-   "p99_ms": 3.001,
-   "p999_ms": 9.997,
-   "max_ms": 326.36,
-   "histogram": [
-    20336,
-    1238,
-    167,
-    108,
-    40,
-    23,
-    12,
-    10,
-    8,
-    7,
-    5,
-    1,
-    2,
-    1,
-    2,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 27994,
-   "seconds": 12.0,
-   "avg_fps": 2332.81,
-   "low_1pct_fps": 194.804,
-   "low_01pct_fps": 28.107,
-   "p50_ms": 0.321,
-   "p95_ms": 0.771,
-   "p99_ms": 1.356,
-   "p999_ms": 3.836,
-   "max_ms": 331.931,
-   "histogram": [
-    27270,
-    652,
-    34,
-    13,
-    5,
-    2,
-    3,
-    4,
-    3,
-    2,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    1,
-    1,
-    0,
-    2,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 27861,
-   "seconds": 12.0,
-   "avg_fps": 2321.717,
-   "low_1pct_fps": 156.898,
-   "low_01pct_fps": 24.403,
-   "p50_ms": 0.281,
-   "p95_ms": 0.852,
-   "p99_ms": 1.73,
-   "p999_ms": 6.331,
-   "max_ms": 301.991,
-   "histogram": [
-    26932,
-    726,
-    124,
-    42,
-    4,
-    4,
-    3,
-    2,
-    9,
-    2,
-    3,
-    1,
-    1,
-    1,
-    0,
-    1,
-    1,
-    0,
-    2,
-    0,
-    2,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 30359,
-   "seconds": 12.0,
-   "avg_fps": 2529.847,
-   "low_1pct_fps": 356.586,
-   "low_01pct_fps": 121.906,
-   "p50_ms": 0.353,
-   "p95_ms": 0.563,
-   "p99_ms": 1.405,
-   "p999_ms": 4.444,
-   "max_ms": 20.302,
-   "histogram": [
-    29756,
-    460,
-    57,
-    52,
-    11,
-    5,
-    3,
-    5,
-    2,
-    4,
-    1,
-    0,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 5781,
-   "seconds": 12.268,
-   "avg_fps": 471.209,
-   "low_1pct_fps": 5.798,
-   "low_01pct_fps": 0.61,
-   "p50_ms": 0.359,
-   "p95_ms": 0.77,
-   "p99_ms": 1.78,
-   "p999_ms": 20.826,
-   "max_ms": 5834.37,
-   "histogram": [
-    5586,
-    158,
-    12,
-    11,
-    0,
-    1,
-    3,
-    2,
-    0,
-    0,
-    2,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    2,
-    3
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 30285,
-   "seconds": 12.0,
-   "avg_fps": 2523.687,
-   "low_1pct_fps": 402.877,
-   "low_01pct_fps": 156.13,
-   "p50_ms": 0.351,
-   "p95_ms": 0.539,
-   "p99_ms": 1.574,
-   "p999_ms": 3.683,
-   "max_ms": 16.022,
-   "histogram": [
-    29666,
-    490,
-    74,
-    35,
-    7,
-    2,
-    2,
-    1,
-    1,
-    5,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 11685,
-   "seconds": 16.293,
-   "avg_fps": 717.19,
-   "low_1pct_fps": 10.346,
-   "low_01pct_fps": 1.104,
-   "p50_ms": 0.299,
-   "p95_ms": 1.119,
-   "p99_ms": 2.568,
-   "p999_ms": 12.054,
-   "max_ms": 5250.537,
-   "histogram": [
-    10993,
-    502,
-    102,
-    39,
-    14,
-    8,
-    6,
-    4,
-    4,
-    1,
-    1,
-    2,
-    0,
-    2,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    2,
-    0,
-    4
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 38704,
-   "seconds": 12.0,
-   "avg_fps": 3225.275,
-   "low_1pct_fps": 505.335,
-   "low_01pct_fps": 124.874,
-   "p50_ms": 0.283,
-   "p95_ms": 0.36,
-   "p99_ms": 0.909,
-   "p999_ms": 2.015,
-   "max_ms": 132.801,
-   "histogram": [
-    38385,
-    279,
-    25,
-    3,
-    2,
-    0,
-    1,
-    0,
-    2,
-    4,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 7609,
-   "seconds": 12.002,
-   "avg_fps": 633.984,
-   "low_1pct_fps": 58.513,
-   "low_01pct_fps": 22.539,
-   "p50_ms": 1.141,
-   "p95_ms": 4.438,
-   "p99_ms": 9.113,
-   "p999_ms": 27.496,
-   "max_ms": 64.424,
-   "histogram": [
-    3452,
-    2398,
-    956,
-    368,
-    143,
-    96,
-    61,
-    46,
-    20,
-    29,
-    6,
-    10,
-    6,
-    7,
-    7,
-    0,
-    1,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 10168,
-   "seconds": 12.423,
-   "avg_fps": 818.512,
-   "low_1pct_fps": 11.586,
-   "low_01pct_fps": 1.461,
-   "p50_ms": 0.267,
-   "p95_ms": 0.892,
-   "p99_ms": 3.176,
-   "p999_ms": 198.757,
-   "max_ms": 1882.64,
-   "histogram": [
-    9733,
-    205,
-    121,
-    49,
-    12,
-    9,
-    8,
-    2,
-    2,
-    0,
-    1,
-    2,
-    1,
-    3,
-    0,
-    3,
-    2,
-    0,
-    0,
-    2,
-    4,
-    5,
-    1,
-    3
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 33679,
-   "seconds": 12.0,
-   "avg_fps": 2806.557,
-   "low_1pct_fps": 400.567,
-   "low_01pct_fps": 103.864,
-   "p50_ms": 0.324,
-   "p95_ms": 0.411,
-   "p99_ms": 1.167,
-   "p999_ms": 3.508,
-   "max_ms": 83.572,
-   "histogram": [
-    33272,
-    315,
-    46,
-    22,
-    2,
-    1,
-    4,
-    2,
-    9,
-    1,
-    2,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 20188,
-   "seconds": 12.0,
-   "avg_fps": 1682.292,
-   "low_1pct_fps": 175.594,
-   "low_01pct_fps": 51.28,
-   "p50_ms": 0.374,
-   "p95_ms": 1.37,
-   "p99_ms": 2.821,
-   "p999_ms": 8.947,
-   "max_ms": 53.494,
-   "histogram": [
-    18109,
-    1592,
-    314,
-    83,
-    36,
-    19,
-    7,
-    6,
-    6,
-    1,
-    3,
-    1,
-    4,
-    2,
-    3,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-desktop"
-}

benchmarks/perf/vanilla-desktop-rd32.json

@@ -1,787 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-11-04T15:46:25Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   }
-  ]
- },
- "hardware": {
-  "os": "linux",
-  "arch": "x86_64",
-  "cpu_threads": 24,
-  "os_version": "NixOS 26.05 (Yarara) (kernel 6.18.57)",
-  "cpu": "13th Gen Intel(R) Core(TM) i7-13700KF",
-  "ram_mb": 31904,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 4080",
-   "vendor": "NVIDIA",
-   "driver": "1.4.329 NVIDIA 595.71.05",
-   "backend": "vulkan",
-   "kind": ""
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 32,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "load_avg_1m": 28.799,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 112742.179,
-   "stdev": 27885.804,
-   "min": 81110.692,
-   "max": 133773.748,
-   "ci95": 69277.769
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 235049.179,
-   "stdev": 31461.958,
-   "min": 203486.748,
-   "max": 266409.692,
-   "ci95": 78162.144
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 79828.05,
-   "stdev": 109107.365,
-   "min": 16685.972,
-   "max": 205814.266,
-   "ci95": 271059.597
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 525.667,
-   "stdev": 390.505,
-   "min": 101.073,
-   "max": 869.433,
-   "ci95": 970.146
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 44.209,
-   "stdev": 39.491,
-   "min": 1.644,
-   "max": 79.658,
-   "ci95": 98.109
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 10.635,
-   "stdev": 9.759,
-   "min": 0.686,
-   "max": 20.192,
-   "ci95": 24.244
-  },
-  "memory.village.gpu_mb": {
-   "n": 3,
-   "mean": 34.333,
-   "stdev": 36.95,
-   "min": 13.0,
-   "max": 77.0,
-   "ci95": 91.797
-  },
-  "memory.village.rss_mb": {
-   "n": 3,
-   "mean": 3296.229,
-   "stdev": 296.464,
-   "min": 2956.234,
-   "max": 3500.773,
-   "ci95": 736.517
-  },
-  "tick.village.client_ms": {
-   "n": 3,
-   "mean": 1.23,
-   "stdev": 0.449,
-   "min": 0.897,
-   "max": 1.74,
-   "ci95": 1.114
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 61172.527,
-   "stdev": 17434.762,
-   "min": 46779.931,
-   "max": 80559.429,
-   "ci95": 43313.846
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 599.408,
-   "stdev": 492.96,
-   "min": 64.173,
-   "max": 1034.813,
-   "ci95": 1224.68
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 61.923,
-   "stdev": 56.534,
-   "min": 0.737,
-   "max": 112.221,
-   "ci95": 140.449
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 15.771,
-   "stdev": 14.11,
-   "min": 0.098,
-   "max": 27.463,
-   "ci95": 35.054
-  },
-  "memory.forest.gpu_mb": {
-   "n": 3,
-   "mean": 34.333,
-   "stdev": 36.95,
-   "min": 13.0,
-   "max": 77.0,
-   "ci95": 91.797
-  },
-  "memory.forest.rss_mb": {
-   "n": 3,
-   "mean": 3278.964,
-   "stdev": 301.465,
-   "min": 2947.268,
-   "max": 3536.27,
-   "ci95": 748.941
-  },
-  "tick.forest.client_ms": {
-   "n": 3,
-   "mean": 5.908,
-   "stdev": 8.813,
-   "min": 0.693,
-   "max": 16.084,
-   "ci95": 21.895
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 61762.098,
-   "stdev": 3569.17,
-   "min": 57919.097,
-   "max": 64972.973,
-   "ci95": 8867.026
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 1175.044,
-   "stdev": 131.94,
-   "min": 1093.801,
-   "max": 1327.281,
-   "ci95": 327.785
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 119.758,
-   "stdev": 68.419,
-   "min": 77.252,
-   "max": 198.683,
-   "ci95": 169.976
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 24.224,
-   "stdev": 18.982,
-   "min": 12.308,
-   "max": 46.114,
-   "ci95": 47.159
-  },
-  "memory.ocean.gpu_mb": {
-   "n": 3,
-   "mean": 34.333,
-   "stdev": 36.95,
-   "min": 13.0,
-   "max": 77.0,
-   "ci95": 91.797
-  },
-  "memory.ocean.rss_mb": {
-   "n": 3,
-   "mean": 3275.349,
-   "stdev": 317.864,
-   "min": 2924.113,
-   "max": 3543.23,
-   "ci95": 789.681
-  },
-  "tick.ocean.client_ms": {
-   "n": 3,
-   "mean": 0.654,
-   "stdev": 0.066,
-   "min": 0.579,
-   "max": 0.699,
-   "ci95": 0.163
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 113439.529,
-   "stdev": 64746.162,
-   "min": 55046.887,
-   "max": 183068.386,
-   "ci95": 160851.363
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 485.832,
-   "stdev": 317.254,
-   "min": 121.312,
-   "max": 699.617,
-   "ci95": 788.165
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 28.612,
-   "stdev": 23.334,
-   "min": 2.229,
-   "max": 46.542,
-   "ci95": 57.97
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 4.56,
-   "stdev": 3.408,
-   "min": 0.75,
-   "max": 7.318,
-   "ci95": 8.467
-  },
-  "memory.mountain.gpu_mb": {
-   "n": 3,
-   "mean": 34.333,
-   "stdev": 36.95,
-   "min": 13.0,
-   "max": 77.0,
-   "ci95": 91.797
-  },
-  "memory.mountain.rss_mb": {
-   "n": 3,
-   "mean": 3248.708,
-   "stdev": 480.962,
-   "min": 2700.645,
-   "max": 3600.484,
-   "ci95": 1194.873
-  },
-  "tick.mountain.client_ms": {
-   "n": 3,
-   "mean": 1.832,
-   "stdev": 2.076,
-   "min": 0.618,
-   "max": 4.229,
-   "ci95": 5.157
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 3371.958,
-   "stdev": 280.347,
-   "min": 3059.926,
-   "max": 3602.613,
-   "ci95": 696.476
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 3291.249,
-   "stdev": 316.441,
-   "min": 2935.975,
-   "max": 3542.848,
-   "ci95": 786.147
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 1248,
-   "seconds": 12.348,
-   "avg_fps": 101.073,
-   "low_1pct_fps": 1.644,
-   "low_01pct_fps": 0.686,
-   "p50_ms": 1.225,
-   "p95_ms": 11.161,
-   "p99_ms": 226.597,
-   "p999_ms": 1457.605,
-   "max_ms": 1457.874,
-   "histogram": [
-    548,
-    232,
-    97,
-    118,
-    51,
-    49,
-    24,
-    39,
-    16,
-    17,
-    13,
-    6,
-    3,
-    2,
-    5,
-    3,
-    2,
-    2,
-    4,
-    2,
-    3,
-    8,
-    1,
-    3
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 10435,
-   "seconds": 12.002,
-   "avg_fps": 869.433,
-   "low_1pct_fps": 79.658,
-   "low_01pct_fps": 20.192,
-   "p50_ms": 0.813,
-   "p95_ms": 2.537,
-   "p99_ms": 5.685,
-   "p999_ms": 13.292,
-   "max_ms": 351.251,
-   "histogram": [
-    7598,
-    2071,
-    393,
-    171,
-    55,
-    53,
-    22,
-    24,
-    20,
-    10,
-    9,
-    2,
-    2,
-    1,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 7278,
-   "seconds": 12.0,
-   "avg_fps": 606.495,
-   "low_1pct_fps": 51.326,
-   "low_01pct_fps": 11.026,
-   "p50_ms": 1.105,
-   "p95_ms": 3.854,
-   "p99_ms": 7.067,
-   "p999_ms": 24.484,
-   "max_ms": 443.95,
-   "histogram": [
-    3206,
-    2621,
-    800,
-    360,
-    112,
-    71,
-    34,
-    26,
-    12,
-    13,
-    3,
-    5,
-    2,
-    7,
-    2,
-    1,
-    1,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 975,
-   "seconds": 15.193,
-   "avg_fps": 64.173,
-   "low_1pct_fps": 0.737,
-   "low_01pct_fps": 0.098,
-   "p50_ms": 0.864,
-   "p95_ms": 5.083,
-   "p99_ms": 77.689,
-   "p999_ms": 10225.237,
-   "max_ms": 10225.237,
-   "histogram": [
-    680,
-    99,
-    104,
-    12,
-    30,
-    13,
-    8,
-    4,
-    2,
-    3,
-    2,
-    1,
-    1,
-    3,
-    0,
-    1,
-    0,
-    1,
-    2,
-    3,
-    1,
-    2,
-    1,
-    2
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 8391,
-   "seconds": 12.0,
-   "avg_fps": 699.237,
-   "low_1pct_fps": 72.811,
-   "low_01pct_fps": 19.752,
-   "p50_ms": 1.087,
-   "p95_ms": 2.927,
-   "p99_ms": 5.909,
-   "p999_ms": 15.268,
-   "max_ms": 252.557,
-   "histogram": [
-    3342,
-    3998,
-    656,
-    231,
-    56,
-    26,
-    15,
-    19,
-    12,
-    12,
-    11,
-    6,
-    1,
-    3,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 12418,
-   "seconds": 12.0,
-   "avg_fps": 1034.813,
-   "low_1pct_fps": 112.221,
-   "low_01pct_fps": 27.463,
-   "p50_ms": 0.837,
-   "p95_ms": 1.394,
-   "p99_ms": 3.491,
-   "p999_ms": 13.217,
-   "max_ms": 245.59,
-   "histogram": [
-    11155,
-    1004,
-    100,
-    64,
-    29,
-    16,
-    16,
-    10,
-    2,
-    6,
-    5,
-    3,
-    4,
-    2,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 13126,
-   "seconds": 12.0,
-   "avg_fps": 1093.801,
-   "low_1pct_fps": 77.252,
-   "low_01pct_fps": 12.308,
-   "p50_ms": 0.714,
-   "p95_ms": 1.402,
-   "p99_ms": 2.875,
-   "p999_ms": 12.067,
-   "max_ms": 238.158,
-   "histogram": [
-    11605,
-    1207,
-    191,
-    54,
-    17,
-    11,
-    7,
-    12,
-    4,
-    4,
-    2,
-    3,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    1,
-    2,
-    3,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 15928,
-   "seconds": 12.0,
-   "avg_fps": 1327.281,
-   "low_1pct_fps": 198.683,
-   "low_01pct_fps": 46.114,
-   "p50_ms": 0.67,
-   "p95_ms": 1.172,
-   "p99_ms": 2.111,
-   "p999_ms": 7.067,
-   "max_ms": 193.743,
-   "histogram": [
-    14891,
-    856,
-    102,
-    42,
-    7,
-    6,
-    8,
-    6,
-    0,
-    5,
-    3,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 13249,
-   "seconds": 12.0,
-   "avg_fps": 1104.051,
-   "low_1pct_fps": 83.338,
-   "low_01pct_fps": 14.249,
-   "p50_ms": 0.711,
-   "p95_ms": 1.403,
-   "p99_ms": 3.046,
-   "p999_ms": 10.625,
-   "max_ms": 451.869,
-   "histogram": [
-    11824,
-    1165,
-    124,
-    58,
-    13,
-    16,
-    11,
-    14,
-    7,
-    7,
-    3,
-    2,
-    1,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    1,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 1469,
-   "seconds": 12.109,
-   "avg_fps": 121.312,
-   "low_1pct_fps": 2.229,
-   "low_01pct_fps": 0.75,
-   "p50_ms": 2.12,
-   "p95_ms": 13.173,
-   "p99_ms": 125.189,
-   "p999_ms": 727.045,
-   "max_ms": 1939.723,
-   "histogram": [
-    196,
-    440,
-    438,
-    136,
-    50,
-    36,
-    24,
-    25,
-    22,
-    17,
-    17,
-    13,
-    6,
-    11,
-    8,
-    4,
-    1,
-    4,
-    4,
-    4,
-    3,
-    7,
-    2,
-    1
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 8396,
-   "seconds": 12.001,
-   "avg_fps": 699.617,
-   "low_1pct_fps": 46.542,
-   "low_01pct_fps": 7.318,
-   "p50_ms": 1.022,
-   "p95_ms": 2.433,
-   "p99_ms": 5.528,
-   "p999_ms": 13.993,
-   "max_ms": 305.464,
-   "histogram": [
-    3248,
-    4509,
-    361,
-    113,
-    52,
-    37,
-    21,
-    26,
-    14,
-    4,
-    3,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    1,
-    2,
-    2,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 7639,
-   "seconds": 12.0,
-   "avg_fps": 636.566,
-   "low_1pct_fps": 37.064,
-   "low_01pct_fps": 5.612,
-   "p50_ms": 1.023,
-   "p95_ms": 3.0,
-   "p99_ms": 7.11,
-   "p999_ms": 17.521,
-   "max_ms": 268.877,
-   "histogram": [
-    3051,
-    3794,
-    413,
-    158,
-    66,
-    43,
-    35,
-    21,
-    31,
-    12,
-    3,
-    4,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    4,
-    2,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-desktop"
-}

benchmarks/perf/vanilla-macmini-rd12.json

@@ -1,771 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-11-04T12:54:29Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   }
-  ]
- },
- "hardware": {
-  "os": "macos",
-  "arch": "aarch64",
-  "cpu_threads": 14,
-  "os_version": "27.0.1",
-  "cpu": "Apple M4 Pro",
-  "ram_mb": 65536,
-  "gpu": {
-   "name": "Apple M4 Pro",
-   "vendor": "Apple",
-   "driver": "4.1 Metal - 91.7",
-   "backend": "opengl",
-   "kind": ""
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 12,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "load_avg_1m": 17.628,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 12652.182,
-   "stdev": 3231.342,
-   "min": 9526.004,
-   "max": 15979.309,
-   "ci95": 8027.746
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 31329.516,
-   "stdev": 10016.129,
-   "min": 20777.004,
-   "max": 40705.309,
-   "ci95": 24883.451
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 12623.084,
-   "stdev": 4958.724,
-   "min": 7251.986,
-   "max": 17026.894,
-   "ci95": 12319.147
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 92.729,
-   "stdev": 58.527,
-   "min": 28.713,
-   "max": 143.496,
-   "ci95": 145.402
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 16.52,
-   "stdev": 10.949,
-   "min": 4.001,
-   "max": 24.308,
-   "ci95": 27.2
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 11.515,
-   "stdev": 7.155,
-   "min": 3.549,
-   "max": 17.394,
-   "ci95": 17.774
-  },
-  "memory.village.rss_mb": {
-   "n": 3,
-   "mean": 1834.469,
-   "stdev": 329.198,
-   "min": 1455.688,
-   "max": 2051.516,
-   "ci95": 817.839
-  },
-  "tick.village.client_ms": {
-   "n": 3,
-   "mean": 1.903,
-   "stdev": 1.114,
-   "min": 1.131,
-   "max": 3.18,
-   "ci95": 2.767
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 14590.694,
-   "stdev": 3260.615,
-   "min": 10942.613,
-   "max": 17221.108,
-   "ci95": 8100.47
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 106.817,
-   "stdev": 104.558,
-   "min": 43.857,
-   "max": 227.513,
-   "ci95": 259.759
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 23.0,
-   "stdev": 26.394,
-   "min": 7.338,
-   "max": 53.473,
-   "ci95": 65.57
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 14.841,
-   "stdev": 15.773,
-   "min": 5.157,
-   "max": 33.042,
-   "ci95": 39.186
-  },
-  "memory.forest.rss_mb": {
-   "n": 3,
-   "mean": 1814.245,
-   "stdev": 154.974,
-   "min": 1635.453,
-   "max": 1910.125,
-   "ci95": 385.007
-  },
-  "tick.forest.client_ms": {
-   "n": 3,
-   "mean": 1.452,
-   "stdev": 0.542,
-   "min": 0.826,
-   "max": 1.777,
-   "ci95": 1.346
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 13309.049,
-   "stdev": 8088.157,
-   "min": 6394.403,
-   "max": 22203.194,
-   "ci95": 20093.716
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 164.405,
-   "stdev": 141.4,
-   "min": 62.162,
-   "max": 325.77,
-   "ci95": 351.285
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 36.242,
-   "stdev": 37.051,
-   "min": 14.736,
-   "max": 79.024,
-   "ci95": 92.047
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 20.898,
-   "stdev": 17.899,
-   "min": 8.855,
-   "max": 41.466,
-   "ci95": 44.468
-  },
-  "memory.ocean.rss_mb": {
-   "n": 3,
-   "mean": 1724.453,
-   "stdev": 347.692,
-   "min": 1323.5,
-   "max": 1942.734,
-   "ci95": 863.784
-  },
-  "tick.ocean.client_ms": {
-   "n": 3,
-   "mean": 0.866,
-   "stdev": 0.248,
-   "min": 0.58,
-   "max": 1.03,
-   "ci95": 0.617
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 17989.43,
-   "stdev": 3969.295,
-   "min": 13444.423,
-   "max": 20774.261,
-   "ci95": 9861.07
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 162.084,
-   "stdev": 160.057,
-   "min": 68.44,
-   "max": 346.896,
-   "ci95": 397.635
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 33.74,
-   "stdev": 36.146,
-   "min": 11.158,
-   "max": 75.429,
-   "ci95": 89.798
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 17.194,
-   "stdev": 14.232,
-   "min": 7.903,
-   "max": 33.579,
-   "ci95": 35.357
-  },
-  "memory.mountain.rss_mb": {
-   "n": 3,
-   "mean": 1977.602,
-   "stdev": 108.627,
-   "min": 1872.516,
-   "max": 2089.453,
-   "ci95": 269.866
-  },
-  "tick.mountain.client_ms": {
-   "n": 3,
-   "mean": 0.772,
-   "stdev": 0.332,
-   "min": 0.463,
-   "max": 1.123,
-   "ci95": 0.825
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2135.313,
-   "stdev": 54.617,
-   "min": 2072.344,
-   "max": 2169.828,
-   "ci95": 135.686
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1836.44,
-   "stdev": 223.694,
-   "min": 1578.141,
-   "max": 1965.781,
-   "ci95": 555.732
-  },
-  "memory.footprint_peak_mb": {
-   "n": 3,
-   "mean": 3253.456,
-   "stdev": 68.323,
-   "min": 3178.409,
-   "max": 3312.05,
-   "ci95": 169.737
-  },
-  "memory.footprint_steady_mb": {
-   "n": 3,
-   "mean": 3144.363,
-   "stdev": 69.868,
-   "min": 3069.394,
-   "max": 3207.66,
-   "ci95": 173.576
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 1272,
-   "seconds": 12.002,
-   "avg_fps": 105.979,
-   "low_1pct_fps": 21.25,
-   "low_01pct_fps": 17.394,
-   "p50_ms": 7.527,
-   "p95_ms": 22.34,
-   "p99_ms": 40.461,
-   "p999_ms": 54.28,
-   "max_ms": 60.7,
-   "histogram": [
-    0,
-    0,
-    0,
-    56,
-    161,
-    170,
-    180,
-    167,
-    184,
-    118,
-    71,
-    61,
-    26,
-    25,
-    28,
-    12,
-    10,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 1723,
-   "seconds": 12.007,
-   "avg_fps": 143.496,
-   "low_1pct_fps": 24.308,
-   "low_01pct_fps": 13.602,
-   "p50_ms": 5.317,
-   "p95_ms": 16.181,
-   "p99_ms": 29.771,
-   "p999_ms": 56.832,
-   "max_ms": 90.209,
-   "histogram": [
-    0,
-    0,
-    63,
-    413,
-    271,
-    273,
-    185,
-    148,
-    112,
-    89,
-    47,
-    43,
-    28,
-    22,
-    18,
-    4,
-    5,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 346,
-   "seconds": 12.05,
-   "avg_fps": 28.713,
-   "low_1pct_fps": 4.001,
-   "low_01pct_fps": 3.549,
-   "p50_ms": 23.684,
-   "p95_ms": 110.057,
-   "p99_ms": 225.236,
-   "p999_ms": 281.776,
-   "max_ms": 281.776,
-   "histogram": [
-    0,
-    0,
-    0,
-    4,
-    8,
-    6,
-    6,
-    12,
-    21,
-    20,
-    23,
-    25,
-    24,
-    32,
-    50,
-    28,
-    24,
-    27,
-    17,
-    11,
-    6,
-    2,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 589,
-   "seconds": 12.001,
-   "avg_fps": 49.081,
-   "low_1pct_fps": 8.19,
-   "low_01pct_fps": 6.325,
-   "p50_ms": 15.443,
-   "p95_ms": 53.004,
-   "p99_ms": 94.69,
-   "p999_ms": 158.114,
-   "max_ms": 158.114,
-   "histogram": [
-    0,
-    0,
-    0,
-    2,
-    7,
-    20,
-    30,
-    46,
-    53,
-    48,
-    56,
-    62,
-    61,
-    66,
-    63,
-    18,
-    22,
-    20,
-    10,
-    4,
-    1,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 2731,
-   "seconds": 12.004,
-   "avg_fps": 227.513,
-   "low_1pct_fps": 53.473,
-   "low_01pct_fps": 33.042,
-   "p50_ms": 3.801,
-   "p95_ms": 7.955,
-   "p99_ms": 14.177,
-   "p999_ms": 24.479,
-   "max_ms": 38.218,
-   "histogram": [
-    0,
-    0,
-    526,
-    1157,
-    432,
-    257,
-    151,
-    88,
-    46,
-    32,
-    13,
-    15,
-    6,
-    6,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 527,
-   "seconds": 12.016,
-   "avg_fps": 43.857,
-   "low_1pct_fps": 7.338,
-   "low_01pct_fps": 5.157,
-   "p50_ms": 16.784,
-   "p95_ms": 57.353,
-   "p99_ms": 111.984,
-   "p999_ms": 193.905,
-   "max_ms": 193.905,
-   "histogram": [
-    0,
-    0,
-    0,
-    1,
-    2,
-    9,
-    16,
-    29,
-    40,
-    61,
-    50,
-    54,
-    52,
-    62,
-    57,
-    35,
-    28,
-    11,
-    13,
-    5,
-    2,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 746,
-   "seconds": 12.001,
-   "avg_fps": 62.162,
-   "low_1pct_fps": 14.965,
-   "low_01pct_fps": 12.372,
-   "p50_ms": 13.76,
-   "p95_ms": 35.144,
-   "p99_ms": 57.63,
-   "p999_ms": 80.827,
-   "max_ms": 80.827,
-   "histogram": [
-    0,
-    0,
-    2,
-    13,
-    12,
-    41,
-    37,
-    53,
-    67,
-    82,
-    80,
-    99,
-    82,
-    76,
-    58,
-    17,
-    11,
-    12,
-    4,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 3910,
-   "seconds": 12.002,
-   "avg_fps": 325.77,
-   "low_1pct_fps": 79.024,
-   "low_01pct_fps": 41.466,
-   "p50_ms": 2.685,
-   "p95_ms": 5.125,
-   "p99_ms": 8.342,
-   "p999_ms": 20.782,
-   "max_ms": 30.571,
-   "histogram": [
-    0,
-    78,
-    2526,
-    892,
-    203,
-    95,
-    49,
-    27,
-    13,
-    11,
-    7,
-    3,
-    2,
-    3,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 1268,
-   "seconds": 12.044,
-   "avg_fps": 105.282,
-   "low_1pct_fps": 14.736,
-   "low_01pct_fps": 8.855,
-   "p50_ms": 6.542,
-   "p95_ms": 25.245,
-   "p99_ms": 50.465,
-   "p999_ms": 79.065,
-   "max_ms": 146.809,
-   "histogram": [
-    0,
-    0,
-    4,
-    171,
-    190,
-    169,
-    167,
-    133,
-    105,
-    93,
-    53,
-    43,
-    35,
-    41,
-    26,
-    13,
-    11,
-    10,
-    3,
-    1,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 822,
-   "seconds": 12.011,
-   "avg_fps": 68.44,
-   "low_1pct_fps": 14.632,
-   "low_01pct_fps": 10.101,
-   "p50_ms": 11.396,
-   "p95_ms": 35.387,
-   "p99_ms": 55.24,
-   "p999_ms": 99.005,
-   "max_ms": 99.005,
-   "histogram": [
-    0,
-    0,
-    0,
-    10,
-    42,
-    62,
-    55,
-    86,
-    89,
-    97,
-    64,
-    73,
-    74,
-    72,
-    48,
-    21,
-    17,
-    8,
-    4,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 4165,
-   "seconds": 12.006,
-   "avg_fps": 346.896,
-   "low_1pct_fps": 75.429,
-   "low_01pct_fps": 33.579,
-   "p50_ms": 2.541,
-   "p95_ms": 4.838,
-   "p99_ms": 7.998,
-   "p999_ms": 20.209,
-   "max_ms": 53.577,
-   "histogram": [
-    0,
-    640,
-    2307,
-    855,
-    178,
-    93,
-    34,
-    22,
-    15,
-    3,
-    3,
-    8,
-    2,
-    2,
-    2,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 851,
-   "seconds": 12.0,
-   "avg_fps": 70.916,
-   "low_1pct_fps": 11.158,
-   "low_01pct_fps": 7.903,
-   "p50_ms": 10.128,
-   "p95_ms": 36.498,
-   "p99_ms": 68.434,
-   "p999_ms": 126.541,
-   "max_ms": 126.541,
-   "histogram": [
-    0,
-    0,
-    0,
-    38,
-    61,
-    87,
-    76,
-    69,
-    84,
-    100,
-    63,
-    53,
-    68,
-    53,
-    48,
-    15,
-    9,
-    16,
-    9,
-    2,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-macmini"
-}

benchmarks/perf/vanilla-macmini-rd32.json

@@ -1,771 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-11-04T13:08:37Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   }
-  ]
- },
- "hardware": {
-  "os": "macos",
-  "arch": "aarch64",
-  "cpu_threads": 14,
-  "os_version": "27.0.1",
-  "cpu": "Apple M4 Pro",
-  "ram_mb": 65536,
-  "gpu": {
-   "name": "Apple M4 Pro",
-   "vendor": "Apple",
-   "driver": "4.1 Metal - 91.7",
-   "backend": "opengl",
-   "kind": ""
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 32,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "load_avg_1m": 18.159,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 8607.88,
-   "stdev": 949.596,
-   "min": 8010.323,
-   "max": 9702.854,
-   "ci95": 2359.119
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 44182.88,
-   "stdev": 4031.933,
-   "min": 40172.323,
-   "max": 48235.854,
-   "ci95": 10016.685
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 17227.171,
-   "stdev": 5351.234,
-   "min": 13892.279,
-   "max": 23399.566,
-   "ci95": 13294.274
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 76.237,
-   "stdev": 45.661,
-   "min": 28.922,
-   "max": 120.041,
-   "ci95": 113.437
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 17.319,
-   "stdev": 12.99,
-   "min": 5.593,
-   "max": 31.283,
-   "ci95": 32.272
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 12.642,
-   "stdev": 9.463,
-   "min": 4.308,
-   "max": 22.93,
-   "ci95": 23.51
-  },
-  "memory.village.rss_mb": {
-   "n": 3,
-   "mean": 2674.987,
-   "stdev": 30.71,
-   "min": 2641.352,
-   "max": 2701.531,
-   "ci95": 76.294
-  },
-  "tick.village.client_ms": {
-   "n": 3,
-   "mean": 1.341,
-   "stdev": 0.407,
-   "min": 0.924,
-   "max": 1.737,
-   "ci95": 1.012
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 34112.389,
-   "stdev": 19305.487,
-   "min": 22633.094,
-   "max": 56401.09,
-   "ci95": 47961.36
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 72.848,
-   "stdev": 51.859,
-   "min": 18.307,
-   "max": 121.528,
-   "ci95": 128.837
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 22.096,
-   "stdev": 20.299,
-   "min": 3.973,
-   "max": 44.03,
-   "ci95": 50.429
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 16.093,
-   "stdev": 14.608,
-   "min": 3.688,
-   "max": 32.194,
-   "ci95": 36.291
-  },
-  "memory.forest.rss_mb": {
-   "n": 3,
-   "mean": 2519.729,
-   "stdev": 82.097,
-   "min": 2426.297,
-   "max": 2580.328,
-   "ci95": 203.957
-  },
-  "tick.forest.client_ms": {
-   "n": 3,
-   "mean": 1.115,
-   "stdev": 0.411,
-   "min": 0.726,
-   "max": 1.545,
-   "ci95": 1.02
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 19066.516,
-   "stdev": 9372.33,
-   "min": 13163.781,
-   "max": 29873.383,
-   "ci95": 23284.039
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 69.735,
-   "stdev": 46.656,
-   "min": 16.524,
-   "max": 103.635,
-   "ci95": 115.909
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 17.636,
-   "stdev": 13.616,
-   "min": 3.179,
-   "max": 30.217,
-   "ci95": 33.827
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 12.115,
-   "stdev": 10.798,
-   "min": 2.584,
-   "max": 23.842,
-   "ci95": 26.825
-  },
-  "memory.ocean.rss_mb": {
-   "n": 3,
-   "mean": 2557.143,
-   "stdev": 84.375,
-   "min": 2463.781,
-   "max": 2627.945,
-   "ci95": 209.616
-  },
-  "tick.ocean.client_ms": {
-   "n": 3,
-   "mean": 1.056,
-   "stdev": 0.233,
-   "min": 0.815,
-   "max": 1.281,
-   "ci95": 0.58
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 62214.712,
-   "stdev": 4884.13,
-   "min": 58937.045,
-   "max": 67828.14,
-   "ci95": 12133.83
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 51.809,
-   "stdev": 7.118,
-   "min": 45.235,
-   "max": 59.369,
-   "ci95": 17.685
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 6.336,
-   "stdev": 1.097,
-   "min": 5.545,
-   "max": 7.588,
-   "ci95": 2.725
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 3.458,
-   "stdev": 0.756,
-   "min": 2.827,
-   "max": 4.296,
-   "ci95": 1.878
-  },
-  "memory.mountain.rss_mb": {
-   "n": 3,
-   "mean": 2604.227,
-   "stdev": 15.043,
-   "min": 2588.234,
-   "max": 2618.094,
-   "ci95": 37.371
-  },
-  "tick.mountain.client_ms": {
-   "n": 3,
-   "mean": 0.957,
-   "stdev": 0.03,
-   "min": 0.926,
-   "max": 0.985,
-   "ci95": 0.074
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2731.016,
-   "stdev": 56.767,
-   "min": 2688.516,
-   "max": 2795.484,
-   "ci95": 141.03
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 2577.339,
-   "stdev": 77.295,
-   "min": 2488.203,
-   "max": 2625.875,
-   "ci95": 192.028
-  },
-  "memory.footprint_peak_mb": {
-   "n": 3,
-   "mean": 4612.571,
-   "stdev": 20.245,
-   "min": 4595.363,
-   "max": 4634.879,
-   "ci95": 50.296
-  },
-  "memory.footprint_steady_mb": {
-   "n": 3,
-   "mean": 4271.925,
-   "stdev": 26.308,
-   "min": 4246.207,
-   "max": 4298.785,
-   "ci95": 65.357
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 349,
-   "seconds": 12.067,
-   "avg_fps": 28.922,
-   "low_1pct_fps": 5.593,
-   "low_01pct_fps": 4.308,
-   "p50_ms": 24.684,
-   "p95_ms": 92.764,
-   "p99_ms": 150.338,
-   "p999_ms": 232.136,
-   "max_ms": 232.136,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    2,
-    3,
-    13,
-    17,
-    26,
-    31,
-    40,
-    46,
-    50,
-    32,
-    25,
-    20,
-    30,
-    10,
-    4,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 1441,
-   "seconds": 12.004,
-   "avg_fps": 120.041,
-   "low_1pct_fps": 31.283,
-   "low_01pct_fps": 22.93,
-   "p50_ms": 7.267,
-   "p95_ms": 13.622,
-   "p99_ms": 23.449,
-   "p999_ms": 42.564,
-   "max_ms": 44.657,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    64,
-    543,
-    397,
-    218,
-    100,
-    54,
-    24,
-    20,
-    7,
-    7,
-    5,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 958,
-   "seconds": 12.013,
-   "avg_fps": 79.749,
-   "low_1pct_fps": 15.082,
-   "low_01pct_fps": 10.689,
-   "p50_ms": 9.138,
-   "p95_ms": 28.848,
-   "p99_ms": 52.247,
-   "p999_ms": 93.55,
-   "max_ms": 93.55,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    19,
-    144,
-    232,
-    148,
-    111,
-    64,
-    56,
-    59,
-    57,
-    32,
-    17,
-    9,
-    6,
-    4,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 220,
-   "seconds": 12.017,
-   "avg_fps": 18.307,
-   "low_1pct_fps": 3.973,
-   "low_01pct_fps": 3.688,
-   "p50_ms": 40.635,
-   "p95_ms": 157.363,
-   "p99_ms": 235.253,
-   "p999_ms": 271.153,
-   "max_ms": 271.153,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    3,
-    6,
-    14,
-    17,
-    25,
-    25,
-    17,
-    27,
-    33,
-    24,
-    16,
-    11,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 1459,
-   "seconds": 12.005,
-   "avg_fps": 121.528,
-   "low_1pct_fps": 44.03,
-   "low_01pct_fps": 32.194,
-   "p50_ms": 7.381,
-   "p95_ms": 12.386,
-   "p99_ms": 18.354,
-   "p999_ms": 29.428,
-   "max_ms": 32.695,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    357,
-    642,
-    300,
-    80,
-    28,
-    28,
-    14,
-    7,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 945,
-   "seconds": 12.006,
-   "avg_fps": 78.709,
-   "low_1pct_fps": 18.284,
-   "low_01pct_fps": 12.397,
-   "p50_ms": 9.554,
-   "p95_ms": 27.657,
-   "p99_ms": 43.253,
-   "p999_ms": 80.663,
-   "max_ms": 80.663,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    18,
-    304,
-    191,
-    119,
-    67,
-    59,
-    53,
-    70,
-    34,
-    15,
-    10,
-    3,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 201,
-   "seconds": 12.164,
-   "avg_fps": 16.524,
-   "low_1pct_fps": 3.179,
-   "low_01pct_fps": 2.584,
-   "p50_ms": 44.933,
-   "p95_ms": 155.019,
-   "p99_ms": 263.919,
-   "p999_ms": 387.044,
-   "max_ms": 387.044,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    2,
-    4,
-    7,
-    20,
-    8,
-    29,
-    18,
-    25,
-    29,
-    29,
-    17,
-    8,
-    4,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 1244,
-   "seconds": 12.004,
-   "avg_fps": 103.635,
-   "low_1pct_fps": 30.217,
-   "low_01pct_fps": 23.842,
-   "p50_ms": 8.349,
-   "p95_ms": 17.445,
-   "p99_ms": 28.276,
-   "p999_ms": 38.037,
-   "max_ms": 45.85,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    162,
-    453,
-    312,
-    129,
-    71,
-    47,
-    32,
-    18,
-    16,
-    3,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 1069,
-   "seconds": 12.005,
-   "avg_fps": 89.047,
-   "low_1pct_fps": 19.512,
-   "low_01pct_fps": 9.92,
-   "p50_ms": 9.541,
-   "p95_ms": 20.819,
-   "p99_ms": 31.409,
-   "p999_ms": 99.668,
-   "max_ms": 101.942,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    64,
-    266,
-    283,
-    160,
-    112,
-    74,
-    51,
-    33,
-    17,
-    4,
-    1,
-    2,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 551,
-   "seconds": 12.181,
-   "avg_fps": 45.235,
-   "low_1pct_fps": 5.545,
-   "low_01pct_fps": 3.252,
-   "p50_ms": 14.921,
-   "p95_ms": 50.78,
-   "p99_ms": 105.154,
-   "p999_ms": 307.476,
-   "max_ms": 307.476,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    42,
-    137,
-    72,
-    58,
-    50,
-    47,
-    57,
-    39,
-    20,
-    15,
-    8,
-    3,
-    2,
-    1,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 718,
-   "seconds": 12.094,
-   "avg_fps": 59.369,
-   "low_1pct_fps": 7.588,
-   "low_01pct_fps": 4.296,
-   "p50_ms": 12.178,
-   "p95_ms": 38.273,
-   "p99_ms": 65.694,
-   "p999_ms": 232.789,
-   "max_ms": 232.789,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    140,
-    202,
-    115,
-    72,
-    48,
-    47,
-    43,
-    19,
-    19,
-    6,
-    4,
-    0,
-    3,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 610,
-   "seconds": 12.003,
-   "avg_fps": 50.822,
-   "low_1pct_fps": 5.875,
-   "low_01pct_fps": 2.827,
-   "p50_ms": 13.894,
-   "p95_ms": 44.208,
-   "p99_ms": 75.023,
-   "p999_ms": 353.686,
-   "max_ms": 353.686,
-   "histogram": [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    67,
-    115,
-    125,
-    88,
-    55,
-    54,
-    43,
-    25,
-    13,
-    15,
-    7,
-    0,
-    1,
-    2,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-macmini"
-}

crates/cargo-horizon-mod/Cargo.toml

@@ -6,20 +6,9 @@ license.workspace = true
 rust-version = "1.86"
 description = "cargo horizon-mod new/build/run/check: make Horizon content mods (docs/mods.md)"
 
-# `cargo binstall --git https://github.com/horizon-rust/horizon cargo-horizon-mod` (#2120) reads this: the archive
-# `cargo-horizon-mod`'s workflow attaches to the `cargo-horizon-mod-v<version>` release for the runner's target,
-# holding the binary at its root. tools/horizon_mod_binstall.py expands it for the workflow's targets.
-[package.metadata.binstall]
-pkg-url = "https://github.com/horizon-rust/horizon/releases/download/cargo-horizon-mod-v{ version }/{ name }-{ target }.tar.gz"
-bin-dir = "{ bin }{ binary-ext }"
-pkg-fmt = "tgz"
-
 [dependencies]
 horizon-mods = { path = "../horizon-mods", default-features = false, features = ["index"] }
 serde_json = "1.0.151"
 
-[dev-dependencies]
-zip = { version = "9.1.3", default-features = false, features = ["deflate"] }
-
 [lints]
 workspace = true

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

@@ -1,8 +1,7 @@
 //! `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).
 //!
-//! - `new <path> [--name "Name"]`: a content mod from the template; with
-//!   `--template native [--horizon <commit>]`, a native trait mod's bundle.
+//! - `new <path> [--name "Name"]`: a content mod from the template.
 //! - `build`: the `.hmod` in `target/horizon-mod/`, with the mod's `assets/`
 //!   and `data/`.
 //! - `run [--game <horizon-client>] [-- <game args>]`: build, then play with
@@ -33,7 +32,7 @@ fn main() -> ExitCode {
         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\"] [--template content|native [--horizon <commit>]] | 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> [--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()),
     };
     match result {
         Ok(()) => ExitCode::SUCCESS,
@@ -75,11 +74,6 @@ 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);
-    match flag(args, "--template") {
-        None | Some("content") => {}
-        Some("native") => return new_native(dir, &id, flag(args, "--horizon"), fill),
-        Some(_) => return Err("--template is content or native".into()),
-    }
     // A block copying a vanilla one, with its model, name, loot, recipe and tag.
     let files = [
         (
@@ -120,6 +114,11 @@ fn new(args: &[String]) -> Result<(), String> {
         ),
         (".gitignore", include_str!("../template/gitignore")),
     ];
+    if flag(args, "--template").is_some_and(|t| t != "content") {
+        return Err(
+            "only content mods are made here: code mods are native (docs/native-mods.md)".into(),
+        );
+    }
     for (file, text) in files {
         let file = fill(file);
         let file = file.as_str();
@@ -138,67 +137,6 @@ fn new(args: &[String]) -> Result<(), String> {
     Ok(())
 }
 
-/// A native trait mod's bundle in `dir` (docs/native-mods.md, "Trait mods"): its
-/// `horizon-mixin.toml` and an `[api]` crate with one hook. It is what the launcher
-/// builds (`native-build <dir>`) and packs as `mixins/<id>/` of a `.hnmod`
-/// (docs/api/mod-files.md). `horizon` pins the Horizon commit it is made for.
-fn new_native(
-    dir: &Path,
-    id: &str,
-    horizon: Option<&str>,
-    fill: impl Fn(&str) -> String,
-) -> Result<(), String> {
-    // `[mod] id`, as `horizon-native.json` needs it: the template keeps to its characters.
-    if id.len() > 64 {
-        return Err(format!("mod id {id}: 64 characters at most"));
-    }
-    let (compatibility, rev) = match horizon {
-        Some(commit) if horizon_mods::index::native::revision(commit) => (
-            format!("[compatibility]\nhorizon_revision = \"{commit}\"\n"),
-            format!(", rev = \"{commit}\""),
-        ),
-        Some(commit) => {
-            return Err(format!(
-                "--horizon {commit}: a Horizon commit is 40 lowercase hex digits"
-            ));
-        }
-        // Unpinned, it builds on the instance's own Horizon.
-        None => (
-            "# The Horizon commit it is made for; unpinned, it builds on the instance's own.\n\
-             # [compatibility]\n# horizon_revision = \"<40 hex digits>\"\n"
-                .to_owned(),
-            String::new(),
-        ),
-    };
-    let files = [
-        (
-            "horizon-mixin.toml",
-            include_str!("../template/native/horizon-mixin.toml"),
-        ),
-        (
-            "api/Cargo.toml",
-            include_str!("../template/native/api.toml"),
-        ),
-        ("api/src/lib.rs", include_str!("../template/native/lib.rs")),
-        (".gitignore", include_str!("../template/gitignore")),
-    ];
-    for (file, text) in files {
-        let to = dir.join(file);
-        std::fs::create_dir_all(to.parent().expect("a file in the mod"))
-            .map_err(|e| e.to_string())?;
-        let text = fill(text)
-            .replace("{compatibility}", &compatibility)
-            .replace("{rev}", &rev);
-        std::fs::write(&to, text).map_err(|e| format!("{}: {e}", to.display()))?;
-    }
-    println!(
-        "Created {} (native mod id {id}). Next: horizon-launcher native-build {} --instance <instance> --trust-native-code",
-        dir.display(),
-        dir.display()
-    );
-    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> {
@@ -334,68 +272,4 @@ mod tests {
         );
         std::fs::remove_dir_all(&dir).unwrap();
     }
-
-    #[test]
-    fn the_native_template_packs_into_an_hnmod_the_registry_accepts() {
-        use std::io::Write;
-        let dir = std::env::temp_dir().join(format!("horizon-mod-native-{}", std::process::id()));
-        let path = dir.join("machine-mod");
-        let commit = "0123456789abcdef0123456789abcdef01234567";
-        let args = [
-            path.display().to_string(),
-            "--template".into(),
-            "native".into(),
-            "--horizon".into(),
-            commit.into(),
-        ];
-        new(&args).unwrap();
-        let api = std::fs::read_to_string(path.join("api/Cargo.toml")).unwrap();
-        assert!(api.contains(&format!("rev = \"{commit}\"")), "{api}");
-        // Packed as the launcher packs a mod folder: the manifest, then the bundle under
-        // `mixins/<id>/` (docs/api/mod-files.md).
-        let manifest = serde_json::json!({
-            "schema": 1, "id": "machine_mod", "version": "0.1.0", "game": "26.3",
-            "horizon": commit, "mixins": "b".repeat(40),
-        });
-        let hnmod = dir.join("machine_mod.hnmod");
-        let mut zip = zip::ZipWriter::new(std::fs::File::create(&hnmod).unwrap());
-        let options = zip::write::SimpleFileOptions::default();
-        zip.start_file("horizon-native.json", options).unwrap();
-        zip.write_all(manifest.to_string().as_bytes()).unwrap();
-        for file in [
-            "horizon-mixin.toml",
-            "api/Cargo.toml",
-            "api/src/lib.rs",
-            ".gitignore",
-        ] {
-            assert!(horizon_mods::index::native::allowed(file), "{file}");
-            zip.start_file(format!("mixins/machine_mod/{file}"), options)
-                .unwrap();
-            zip.write_all(&std::fs::read(path.join(file)).unwrap())
-                .unwrap();
-        }
-        zip.finish().unwrap();
-        let report = check::check(&hnmod, check::kind_of(&hnmod).unwrap(), None, None).unwrap();
-        assert!(report.text().contains("machine_mod"), "{}", report.text());
-        // A pin that is not a commit is refused; with none, the folder builds on the
-        // instance's Horizon.
-        let bad = [
-            dir.join("bad").display().to_string(),
-            "--template".into(),
-            "native".into(),
-            "--horizon".into(),
-            "main".into(),
-        ];
-        assert!(new(&bad).unwrap_err().contains("40 lowercase hex"));
-        let free = dir.join("free");
-        new(&[
-            free.display().to_string(),
-            "--template".into(),
-            "native".into(),
-        ])
-        .unwrap();
-        let mixin = std::fs::read_to_string(free.join("horizon-mixin.toml")).unwrap();
-        assert!(!mixin.contains("\nhorizon_revision"), "{mixin}");
-        std::fs::remove_dir_all(&dir).unwrap();
-    }
 }

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

@@ -1,9 +0,0 @@
-[package]
-name = "mod-{id}"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-# The launcher points this at the Horizon source it builds the game from. Any other
-# dependency must be a crate and version in Horizon's Cargo.lock.
-horizon-client = { git = "https://github.com/horizon-rust/horizon"{rev} }

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

@@ -1,9 +0,0 @@
-# {name}: a native trait mod (docs/native-mods.md, "Trait mods"). Build it with
-# `horizon-launcher native-build <this folder> --instance <instance> --trust-native-code`.
-[mod]
-id = "{id}"
-version = "0.1.0"
-
-{compatibility}
-[api]
-path = "api"

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

@@ -1,18 +0,0 @@
-//! The trait mod: the launcher links this crate into the game and calls `hooks()`. Each
-//! method of `Hooks` is one of Horizon's hook points; implement the ones the mod needs
-//! (docs/native-mods.md, "Trait mods").
-use horizon_client::mod_api::{Hooks, Host, PlayerLoggedInEvent, Text};
-
-pub fn hooks() -> Box<dyn Hooks> {
-    Box::new(Mod)
-}
-
-struct Mod;
-
-impl Hooks for Mod {
-    /// A player joined the server (NeoForge's `PlayerLoggedInEvent`): greet them.
-    fn player_logged_in(&self, host: &mut dyn Host, event: &mut PlayerLoggedInEvent<'_>) {
-        let line = format!("{id} says hello, {}!", event.name);
-        host.tell(event.player, Text::literal(line));
-    }
-}

crates/horizon-assets/Cargo.toml

@@ -8,7 +8,6 @@ description = "Horizon version-specific model and resource decoding"
 
 [dependencies]
 horizon-core = { path = "../horizon-core" }
-log = "0.4"
 serde = "1.0.229"
 serde_json = { version = "1.0.151", features = ["raw_value"] }
 

crates/horizon-assets/src/bake.rs

@@ -1,10 +1,5 @@
 //! Cuboid geometry in block units, including blockstate rotation and UV locking.
-use crate::{
-    json::*,
-    model::*,
-    obj::{MtlTexture, ObjFace, ObjModel},
-    resolve::{ResolvedCuboidModel, ResolvedLoader},
-};
+use crate::{json::*, model::*, resolve::ResolvedCuboidModel};
 mod transform;
 pub use transform::BlockModelTransform;
 
@@ -18,40 +13,7 @@ pub struct ModelQuad {
     pub material: Material,
     pub tint_index: i32,
     pub shade_direction_override: Option<Direction>,
-    /// The face's or element's `light_emission`.
     pub light_emission: u8,
-    /// Least (block, sky) light the quad is drawn with: its emission, raised by `neoforge_data`.
-    pub light: [u8; 2],
-    /// `neoforge_data` colour (ARGB) multiplied into the quad's tint.
-    pub color: Option<i32>,
-    /// `neoforge_data` override of the model's ambient occlusion for this quad.
-    pub ambient_occlusion: Option<bool>,
-    pub render_type: Option<RenderType>,
-    /// False for a loader quad that takes no directional shading.
-    pub shade: bool,
-}
-
-/// NeoForge's `render_type` names.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum RenderType {
-    Solid,
-    Cutout,
-    CutoutMipped,
-    Translucent,
-    Tripwire,
-}
-impl RenderType {
-    /// Accepts a bare or `minecraft:` name; others (mods' own types) are `None`.
-    pub fn by_name(name: &str) -> Option<Self> {
-        match name.strip_prefix("minecraft:").unwrap_or(name) {
-            "solid" => Some(Self::Solid),
-            "cutout" => Some(Self::Cutout),
-            "cutout_mipped" => Some(Self::CutoutMipped),
-            "translucent" => Some(Self::Translucent),
-            "tripwire" => Some(Self::Tripwire),
-            _ => None,
-        }
-    }
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -224,17 +186,6 @@ fn bake_elements(
     skip_flat: bool,
 ) -> Result<Vec<ModelQuad>> {
     let mut output = Vec::new();
-    bake_into(model, transform, skip_flat, &mut output)?;
-    Ok(output)
-}
-/// The elements, then what the model's loader adds.
-fn bake_into(
-    model: &ResolvedCuboidModel,
-    transform: BlockModelTransform,
-    skip_flat: bool,
-    output: &mut Vec<ModelQuad>,
-) -> Result<()> {
-    let render_type = model.render_type.as_deref().and_then(RenderType::by_name);
     for element in model.elements() {
         let element = element
             .as_ref()
@@ -256,108 +207,11 @@ fn bake_into(
                 force_translucent: false,
             });
             output.push(bake_face(
-                element,
-                face,
-                *direction,
-                matrix,
-                material,
-                transform,
-                render_type,
+                element, face, *direction, matrix, material, transform,
             )?);
         }
     }
-    match model.loader() {
-        Some(ResolvedLoader::Composite(children)) => {
-            for child in children {
-                bake_into(child, transform, skip_flat, output)?;
-            }
-        }
-        Some(ResolvedLoader::Obj {
-            model: Some(obj),
-            flip_v,
-            shade,
-            hidden,
-        }) => bake_obj(model, obj, *flip_v, *shade, hidden, transform, output)?,
-        Some(ResolvedLoader::Obj { model: None, .. }) | None => {}
-    }
-    Ok(())
-}
-/// Obj faces are unculled quads in block units; the blockstate transform moves them whole.
-fn bake_obj(
-    model: &ResolvedCuboidModel,
-    obj: &ObjModel,
-    flip_v: bool,
-    shade: bool,
-    hidden: &std::collections::BTreeSet<String>,
-    transform: BlockModelTransform,
-    output: &mut Vec<ModelQuad>,
-) -> Result<()> {
-    let render_type = model.render_type.as_deref().and_then(RenderType::by_name);
-    for face in obj.faces.iter().filter(|f| !hidden.contains(&f.object)) {
-        let slot = match obj.materials.get(&face.material) {
-            Some(MtlTexture::Sprite(sprite)) => {
-                output.push(obj_quad(
-                    face,
-                    Material {
-                        sprite: identifier(sprite)?,
-                        force_translucent: false,
-                    },
-                    flip_v,
-                    shade,
-                    render_type,
-                    transform,
-                ));
-                continue;
-            }
-            Some(MtlTexture::Slot(slot)) => slot,
-            None => &face.material,
-        };
-        let material = if slot.is_empty() {
-            None
-        } else {
-            model.material(slot)?
-        };
-        let material = material.cloned().unwrap_or(Material {
-            sprite: "minecraft:missingno".to_owned(),
-            force_translucent: false,
-        });
-        output.push(obj_quad(
-            face,
-            material,
-            flip_v,
-            shade,
-            render_type,
-            transform,
-        ));
-    }
-    Ok(())
-}
-fn obj_quad(
-    face: &ObjFace,
-    material: Material,
-    flip_v: bool,
-    shade: bool,
-    render_type: Option<RenderType>,
-    transform: BlockModelTransform,
-) -> ModelQuad {
-    let positions = face.vertices.map(|v| transform.position(v.position));
-    ModelQuad {
-        positions,
-        uv: face
-            .vertices
-            .map(|v| [v.uv[0], if flip_v { 1.0 - v.uv[1] } else { v.uv[1] }]),
-        facing: facing(&positions).unwrap_or(Direction::Up),
-        cull: None,
-        material,
-        tint_index: -1,
-        shade_direction_override: None,
-        light_emission: 0,
-        light: [0; 2],
-        color: None,
-        ambient_occlusion: None,
-        render_type,
-        shade,
-    }
+    Ok(output)
 }
 /// `FaceBakery.bakeQuad` for a quad with explicit corners and unit-atlas UVs
 /// (`uv` in 0..16 texels), as `ItemModelGenerator` builds its layers.
@@ -376,7 +230,6 @@ pub fn bake_flat_face(
         rotation: None,
         shade_direction_override: None,
         light_emission: 0,
-        neoforge_data: None,
     };
     let face = Face {
         cull: None,
@@ -384,8 +237,6 @@ pub fn bake_flat_face(
         texture: String::new(),
         uv: Some(uv),
         rotation: 0,
-        light_emission: None,
-        neoforge_data: None,
     };
     bake_face(
         &element,
@@ -394,7 +245,6 @@ pub fn bake_flat_face(
         None,
         material,
         BlockModelTransform::new([0; 3], false),
-        None,
     )
 }
 fn bake_face(
@@ -404,7 +254,6 @@ fn bake_face(
     matrix: Option<ElementMatrix>,
     material: Material,
     transform: BlockModelTransform,
-    render_type: Option<RenderType>,
 ) -> Result<ModelQuad> {
     let mut positions = corners(element.from, element.to, direction).map(|v| v.map(|c| c / 16.0));
     if let (Some(rotation), Some(matrix)) = (&element.rotation, matrix) {
@@ -454,11 +303,6 @@ fn bake_face(
             uv.swap(index, found);
         }
     }
-    let data = face
-        .neoforge_data
-        .unwrap_or_default()
-        .over(element.neoforge_data.unwrap_or_default());
-    let light_emission = face.light_emission.unwrap_or(element.light_emission);
     Ok(ModelQuad {
         positions,
         uv,
@@ -467,196 +311,6 @@ fn bake_face(
         material,
         tint_index: face.tint_index,
         shade_direction_override: element.shade_direction_override,
-        light_emission,
-        light: [data.block_light, data.sky_light].map(|l| l.unwrap_or(0).max(light_emission)),
-        color: data.color,
-        ambient_occlusion: data.ambient_occlusion,
-        render_type,
-        shade: true,
+        light_emission: element.light_emission,
     })
 }
-
-#[cfg(test)]
-mod loader_tests {
-    use super::*;
-    use crate::resolve::{AssetReader, ModelLibrary};
-    use std::{collections::BTreeMap, sync::Arc};
-
-    struct Files(BTreeMap<&'static str, &'static str>);
-    impl AssetReader for Files {
-        fn read_text(&self, location: &str) -> Option<String> {
-            self.0.get(location).map(|text| (*text).to_owned())
-        }
-    }
-
-    fn library(models: &[(&str, &str)], files: &[(&'static str, &'static str)]) -> ModelLibrary {
-        let models = models
-            .iter()
-            .map(|(name, json)| ((*name).to_owned(), CuboidModel::from_json(json).unwrap()))
-            .collect();
-        ModelLibrary::new(models)
-            .unwrap()
-            .with_assets(Arc::new(Files(files.iter().copied().collect())))
-    }
-    fn bake(library: &ModelLibrary, name: &str) -> Vec<ModelQuad> {
-        bake_block_model(
-            &library.resolve(name).unwrap(),
-            BlockModelTransform::new([0; 3], false),
-        )
-        .unwrap()
-    }
-    fn sprites(quads: &[ModelQuad]) -> Vec<&str> {
-        quads.iter().map(|q| q.material.sprite.as_str()).collect()
-    }
-    const CUBE: &str =
-        r##"{"elements":[{"from":[0,0,0],"to":[16,16,16],"faces":{"up":{"texture":"#all"}}}]}"##;
-    const COMPOSITE: &str = r#"{"loader":"neoforge:composite","textures":{"all":"block/shared"},
-        "children":{"zeta":{"parent":"t:cube","textures":{"all":"block/own"}},"alpha":{"parent":"t:cube"}}}"#;
-
-    #[test]
-    fn composite_bakes_children_in_document_order_with_slot_fallback() {
-        let library = library(&[("t:cube", CUBE), ("t:comp", COMPOSITE)], &[]);
-        let quads = bake(&library, "t:comp");
-        assert_eq!(
-            sprites(&quads),
-            ["minecraft:block/own", "minecraft:block/shared"]
-        );
-    }
-    #[test]
-    fn composite_visibility_hides_a_child() {
-        let hidden =
-            COMPOSITE.replace(r#""children""#, r#""visibility":{"zeta":false},"children""#);
-        let library = library(&[("t:cube", CUBE), ("t:comp", &hidden)], &[]);
-        assert_eq!(
-            sprites(&bake(&library, "t:comp")),
-            ["minecraft:block/shared"]
-        );
-    }
-    #[test]
-    fn an_inheriting_model_overrides_which_children_are_visible() {
-        let hidden =
-            COMPOSITE.replace(r#""children""#, r#""visibility":{"zeta":false},"children""#);
-        let shown = r#"{"parent":"t:hidden","visibility":{"zeta":true,"alpha":false}}"#;
-        let library = library(
-            &[("t:cube", CUBE), ("t:hidden", &hidden), ("t:shown", shown)],
-            &[],
-        );
-        assert_eq!(sprites(&bake(&library, "t:shown")), ["minecraft:block/own"]);
-    }
-    #[test]
-    fn loader_is_inherited_by_parent_after_own_elements() {
-        let derived = r##"{"parent":"t:comp","textures":{"all":"block/derived"},
-            "elements":[{"from":[0,0,0],"to":[16,16,16],"faces":{"down":{"texture":"#all"}}}]}"##;
-        let library = library(
-            &[
-                ("t:cube", CUBE),
-                ("t:comp", COMPOSITE),
-                ("t:derived", derived),
-            ],
-            &[],
-        );
-        let quads = bake(&library, "t:derived");
-        assert_eq!(quads[0].facing, Direction::Down);
-        assert_eq!(
-            sprites(&quads),
-            [
-                "minecraft:block/derived",
-                "minecraft:block/own",
-                "minecraft:block/derived"
-            ]
-        );
-    }
-    #[test]
-    fn own_loader_wins_and_unknown_loader_adds_nothing() {
-        let other = r#"{"parent":"t:comp","loader":"somemod:thing"}"#;
-        let library = library(
-            &[("t:cube", CUBE), ("t:comp", COMPOSITE), ("t:other", other)],
-            &[],
-        );
-        assert!(bake(&library, "t:other").is_empty());
-    }
-    #[test]
-    fn composites_that_nest_through_themselves_are_an_error() {
-        let looping = r#"{"loader":"neoforge:composite","children":{"a":{"parent":"t:loop"}}}"#;
-        let library = library(&[("t:loop", looping)], &[]);
-        assert!(library.resolve("t:loop").is_err());
-    }
-
-    const OBJ: &str = "mtllib m.mtl\nv 0 0 0\nv 1 0 0\nv 1 0 1\nv 0 0 1\nv 0 1 0\n\
-        vt 0 0\nvt 1 0\nvt 1 1\nvt 0 1\n\
-        usemtl top\nf 1/1 4/4 3/3 2/2\nusemtl side\nf 1/1 2/2 5/4\nusemtl bare\nf 1/1 2/2 5/4\n";
-    const MTL: &str = "newmtl top\nmap_Kd #lid\nnewmtl side\nmap_Kd #wall\nnewmtl bare\nKd 1 1 1\n";
-    const OBJ_FILES: [(&str, &str); 2] = [("t:models/x.obj", OBJ), ("t:models/m.mtl", MTL)];
-    const OBJ_MODEL: &str = r#"{"loader":"neoforge:obj","model":"t:models/x.obj","flip_v":true,
-        "textures":{"lid":"block/lid","wall":"block/wall"}}"#;
-
-    #[test]
-    fn obj_faces_become_quads_with_materials_and_flipped_v() {
-        let flat = OBJ_MODEL.replace(r#""flip_v":true,"#, "");
-        let library = library(&[("t:o", OBJ_MODEL), ("t:flat", &flat)], &OBJ_FILES);
-        let quads = bake(&library, "t:o");
-        assert_eq!(
-            sprites(&quads),
-            [
-                "minecraft:block/lid",
-                "minecraft:block/wall",
-                "minecraft:missingno"
-            ]
-        );
-        assert_eq!(quads[0].facing, Direction::Up);
-        assert_eq!(quads[1].facing, Direction::South);
-        assert_eq!(quads[0].positions[1], [0.0, 0.0, 1.0]);
-        assert_eq!(quads[0].uv[0], [0.0, 1.0]);
-        assert_eq!(quads[0].uv[2], [1.0, 0.0]);
-        // A triangle repeats its last vertex.
-        assert_eq!(quads[1].positions[3], quads[1].positions[2]);
-        assert_eq!(quads[1].uv[3], quads[1].uv[2]);
-        assert!(quads.iter().all(|q| q.cull.is_none() && q.shade));
-        assert_eq!(bake(&library, "t:flat")[0].uv[0], [0.0, 0.0]);
-    }
-    #[test]
-    fn obj_shade_quads_false_and_mtl_override() {
-        let unshaded = r#"{"loader":"neoforge:obj","model":"t:models/x.obj","shade_quads":false,
-            "mtl_override":"t:models/o.mtl","textures":{"s":"block/s"}}"#;
-        let files = [
-            ("t:models/x.obj", OBJ),
-            ("t:models/o.mtl", "newmtl top\nmap_Kd #s\n"),
-        ];
-        let library = library(&[("t:u", unshaded)], &files);
-        let quads = bake(&library, "t:u");
-        assert!(quads.iter().all(|q| !q.shade));
-        assert_eq!(quads[0].material.sprite, "minecraft:block/s");
-    }
-    #[test]
-    fn missing_or_broken_obj_bakes_nothing() {
-        let missing = library(&[("t:o", OBJ_MODEL)], &[]);
-        assert!(bake(&missing, "t:o").is_empty());
-        let broken = library(
-            &[("t:o", OBJ_MODEL)],
-            &[("t:models/x.obj", "v 0 0 0\nf 1 2 3\n")],
-        );
-        assert!(bake(&broken, "t:o").is_empty());
-    }
-    #[test]
-    fn obj_visibility_skips_the_objects_a_model_hides() {
-        let two = "v 0 0 0\nv 1 0 0\nv 1 0 1\nv 0 0 1\no a\nusemtl m\nf 1 2 3 4\no b\nf 4 3 2 1\n";
-        let files = [("t:models/two.obj", two)];
-        let base =
-            r#"{"loader":"neoforge:obj","model":"t:models/two.obj","textures":{"m":"block/m"}}"#;
-        let hiding = r#"{"parent":"t:base","visibility":{"b":false}}"#;
-        let restoring = r#"{"parent":"t:hiding","visibility":{"b":true}}"#;
-        let library = library(
-            &[
-                ("t:base", base),
-                ("t:hiding", hiding),
-                ("t:restoring", restoring),
-            ],
-            &files,
-        );
-        assert_eq!(bake(&library, "t:base").len(), 2);
-        let quads = bake(&library, "t:hiding");
-        assert_eq!(quads.len(), 1);
-        assert_eq!(quads[0].facing, Direction::Down);
-        assert_eq!(bake(&library, "t:restoring").len(), 2);
-    }
-}

crates/horizon-assets/src/item_model.rs

@@ -17,7 +17,6 @@ use std::{
 };
 
 mod component_predicate;
-mod foreign;
 mod special;
 pub use special::{SpecialKind, SpecialModel};
 
@@ -432,17 +431,6 @@ impl ItemModelNode {
     pub fn decode(v: &Value) -> Result<Self> {
         let m = object(v)?;
         let kind = ident(required(m, "type")?)?;
-        if kind == "minecraft:condition" {
-            let property = ident(required(m, "property")?)?;
-            if !property.starts_with("minecraft:") {
-                return Ok(Self::Condition {
-                    transformation: optional_transformation(m)?,
-                    property: ConditionProperty::Custom(property),
-                    on_true: Box::new(Self::decode(required(m, "on_true")?)?),
-                    on_false: Box::new(Self::decode(required(m, "on_false")?)?),
-                });
-            }
-        }
         Ok(match kind.as_str() {
             "minecraft:empty" => Self::Empty,
             "minecraft:model" => Self::Model(ModelLeaf {
@@ -463,21 +451,12 @@ impl ItemModelNode {
                     .collect::<Result<_>>()?,
                 transformation: optional_transformation(m)?,
             },
-            "minecraft:condition" if foreign::property_is_foreign(m)? => foreign::wrap(
-                Self::decode(required(m, "on_false")?)?,
-                optional_transformation(m)?,
-            ),
             "minecraft:condition" => Self::Condition {
                 transformation: optional_transformation(m)?,
                 property: ConditionProperty::decode(m)?,
                 on_true: Box::new(Self::decode(required(m, "on_true")?)?),
                 on_false: Box::new(Self::decode(required(m, "on_false")?)?),
             },
-            "minecraft:select" if foreign::property_is_foreign(m)? => {
-                // No case can match a property Horizon cannot read.
-                let fallback = get(m, "fallback").map(Self::decode).transpose()?;
-                foreign::wrap(fallback.unwrap_or(Self::Empty), optional_transformation(m)?)
-            }
             "minecraft:select" => {
                 let transformation = optional_transformation(m)?;
                 let property = SelectProperty::decode(m)?;
@@ -505,7 +484,6 @@ impl ItemModelNode {
                 }
             }
             "minecraft:range_dispatch" => {
-                let foreign_property = foreign::property_is_foreign(m)?;
                 let mut entries = list(required(m, "entries")?)?
                     .iter()
                     .map(|e| {
@@ -518,17 +496,6 @@ impl ItemModelNode {
                     .collect::<Result<Vec<_>>>()?;
                 // `Comparator.comparingDouble`: Double.compare, a total order.
                 entries.sort_by(|a, b| f64::from(a.0).total_cmp(&f64::from(b.0)));
-                if foreign_property {
-                    // A property Horizon cannot read is 0.
-                    let fallback = get(m, "fallback").map(Self::decode).transpose()?;
-                    let chosen = last_index_less_or_equal(&entries, 0.0)
-                        .map(|i| entries.swap_remove(i).1)
-                        .or(fallback);
-                    return Ok(foreign::wrap(
-                        chosen.unwrap_or(Self::Empty),
-                        optional_transformation(m)?,
-                    ));
-                }
                 Self::RangeDispatch {
                     transformation: optional_transformation(m)?,
                     property: NumericProperty::decode(m)?,
@@ -539,21 +506,12 @@ impl ItemModelNode {
                         .transpose()?,
                 }
             }
-            "minecraft:special" if SpecialModel::is_foreign(required(m, "model")?) => {
-                // The mod's own renderer is not run: the base model stands in.
-                Self::Model(ModelLeaf {
-                    model: ident(required(m, "base")?)?,
-                    transformation: optional_transformation(m)?,
-                    tints: Vec::new(),
-                })
-            }
             "minecraft:special" => Self::Special {
                 base: ident(required(m, "base")?)?,
                 transformation: optional_transformation(m)?,
                 model: SpecialModel::decode(required(m, "model")?)?,
             },
             "minecraft:bundle/selected_item" => Self::BundleSelectedItem,
-            other if foreign::is_foreign(other) => foreign::decode_node(other, m),
             _ => return Err(err("unknown item model type")),
         })
     }
@@ -645,8 +603,6 @@ impl TintSource {
             "minecraft:firework" => Self::Firework(default()?),
             "minecraft:potion" => Self::Potion(default()?),
             "minecraft:team" => Self::Team(default()?),
-            // A mod's own tint source, which its Java code computes: untinted here.
-            other if foreign::is_foreign(other) => Self::Constant(-1),
             _ => return Err(err("unknown item tint source")),
         })
     }
@@ -658,7 +614,6 @@ impl TintSource {
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum ConditionProperty {
-    Custom(String),
     CustomModelData(i32),
     UsingItem,
     Broken,
@@ -991,10 +946,6 @@ pub struct Context<'a> {
 
 /// Host services the resolver cannot derive from data alone.
 pub trait ItemEnv {
-    /// A mod's namespaced conditional property, false when no mod supplies it.
-    fn item_model_property(&self, _property: &str, _stack: &StackView) -> bool {
-        false
-    }
     /// `PotionContents.getColorOr` for the potion/effects part: the mixed
     /// effect colour, or `None` when the contents have no visible effects.
     fn potion_effect_color(&self, _potion_contents: &Value) -> Option<i32> {
@@ -1348,9 +1299,6 @@ impl Resolve<'_> {
     fn condition(&self, property: &ConditionProperty) -> bool {
         let owner = self.ctx.owner;
         match property {
-            ConditionProperty::Custom(property) => {
-                self.env.item_model_property(property, self.stack)
-            }
             ConditionProperty::CustomModelData(i) => {
                 self.component("minecraft:custom_model_data")
                     .and_then(|d| custom_data_at(d, "flags", *i))
@@ -1769,7 +1717,5 @@ fn binary_search(a: &[f32], key: f32) -> std::result::Result<usize, usize> {
     Err(low as usize)
 }
 
-#[cfg(test)]
-mod foreign_tests;
 #[cfg(test)]
 mod tests;

crates/horizon-assets/src/item_model/foreign.rs

@@ -1,114 +0,0 @@
-//! Nodes and properties of other namespaces (a mod's, NeoForge's) decode to the closest vanilla behaviour.
-use super::{
-    ItemModelNode, ModelLeaf, Result, TintSource, get, ident, identifier, list, object,
-    optional_transformation,
-};
-use crate::{json::error as err, math::Mat4};
-use serde_json::{Map, Value};
-
-/// Keys a mod's node usually keeps its real model under, in order of preference.
-const MODEL_KEYS: [&str; 4] = ["model", "base_model", "base", "fallback"];
-
-pub fn is_foreign(id: &str) -> bool {
-    !id.starts_with("minecraft:")
-}
-
-/// A composite carries the transformation a collapsed node had.
-pub fn wrap(node: ItemModelNode, transformation: Option<Mat4>) -> ItemModelNode {
-    match transformation {
-        None => node,
-        Some(_) => ItemModelNode::Composite {
-            models: vec![node],
-            transformation,
-        },
-    }
-}
-
-pub fn property_is_foreign(m: &Map<String, Value>) -> Result<bool> {
-    let property = m
-        .get("property")
-        .ok_or_else(|| err("missing property"))
-        .and_then(ident)?;
-    Ok(is_foreign(&property))
-}
-
-fn leaf(model: String, m: &Map<String, Value>) -> ItemModelNode {
-    let tints = get(m, "tints")
-        .and_then(|t| list(t).ok())
-        .map(|t| {
-            t.iter()
-                .filter_map(|t| TintSource::decode(t).ok())
-                .collect()
-        })
-        .unwrap_or_default();
-    ItemModelNode::Model(ModelLeaf {
-        model,
-        transformation: optional_transformation(m).ok().flatten(),
-        tints,
-    })
-}
-
-/// A node of an unknown non-vanilla type: its nested node, else its model id, else nothing.
-pub fn decode_node(kind: &str, m: &Map<String, Value>) -> ItemModelNode {
-    if kind == "neoforge:fluid_container" {
-        return fluid_container(m);
-    }
-    for key in MODEL_KEYS {
-        match m.get(key) {
-            Some(nested @ Value::Object(_)) => {
-                if let Ok(node) = ItemModelNode::decode(nested) {
-                    return wrap(node, optional_transformation(m).ok().flatten());
-                }
-            }
-            Some(Value::String(id)) => {
-                if let Ok(id) = identifier(id) {
-                    return leaf(id, m);
-                }
-            }
-            _ => {}
-        }
-    }
-    let by_suffix = m
-        .iter()
-        .filter(|(k, _)| k.ends_with("_model"))
-        .find_map(|(_, v)| v.as_str().and_then(|id| identifier(id).ok()));
-    match by_suffix {
-        Some(id) => leaf(id, m),
-        None => ItemModelNode::Empty,
-    }
-}
-
-// The fluid is not drawn: only the base (and an unmasked cover) texture, taken as a model id (a bucket's).
-fn fluid_container(m: &Map<String, Value>) -> ItemModelNode {
-    let textures = m.get("textures").and_then(|t| object(t).ok());
-    let texture = |key: &str| {
-        textures
-            .and_then(|t| t.get(key))
-            .and_then(Value::as_str)
-            .and_then(|id| identifier(id).ok())
-    };
-    let mut layers = vec![texture("base")];
-    if m.get("cover_is_mask") == Some(&Value::Bool(false)) {
-        layers.push(texture("cover"));
-    }
-    let mut models: Vec<ItemModelNode> = layers
-        .into_iter()
-        .flatten()
-        .map(|model| {
-            ItemModelNode::Model(ModelLeaf {
-                model,
-                transformation: None,
-                tints: Vec::new(),
-            })
-        })
-        .collect();
-    let transformation = optional_transformation(m).ok().flatten();
-    match models.len() {
-        0 => ItemModelNode::Empty,
-        1 => wrap(models.remove(0), transformation),
-        _ => ItemModelNode::Composite {
-            models,
-            transformation,
-        },
-    }
-}

crates/horizon-assets/src/item_model/foreign_tests.rs

@@ -1,185 +0,0 @@
-use super::*;
-
-fn node(json: &str) -> Result<ItemModelNode> {
-    ItemModelNode::decode(&serde_json::from_str(json).unwrap())
-}
-fn model_id(n: &ItemModelNode) -> &str {
-    match n {
-        ItemModelNode::Model(leaf) => &leaf.model,
-        other => panic!("not a model: {other:?}"),
-    }
-}
-
-#[test]
-fn node_with_a_model_id_draws_that_model() {
-    let n = node(r#"{"type":"mod:thing","model":"mod:item/thing","tints":[{"type":"mod:tint"}]}"#)
-        .unwrap();
-    assert_eq!(model_id(&n), "mod:item/thing");
-    let ItemModelNode::Model(leaf) = n else {
-        unreachable!()
-    };
-    assert_eq!(leaf.tints, vec![TintSource::Constant(-1)]);
-    let n = node(r#"{"type":"mod:thing","base_model":"mod:item/base"}"#).unwrap();
-    assert_eq!(model_id(&n), "mod:item/base");
-    let n = node(r#"{"type":"mod:thing","on_model":"mod:item/a"}"#).unwrap();
-    assert_eq!(model_id(&n), "mod:item/a");
-}
-
-#[test]
-fn node_with_a_nested_node_decodes_it() {
-    let n = node(
-        r#"{"type":"neoforge:trimmed_armor","base_model":{"type":"minecraft:model","model":"mod:item/boots"}}"#,
-    )
-    .unwrap();
-    assert_eq!(model_id(&n), "mod:item/boots");
-    let n = node(
-        r#"{"type":"mod:x","model":{"type":"mod:y","model":"mod:item/inner"},"transformation":[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]}"#,
-    )
-    .unwrap();
-    let ItemModelNode::Composite {
-        models,
-        transformation,
-    } = n
-    else {
-        panic!("a transformation wraps the nested node")
-    };
-    assert!(transformation.is_some());
-    assert_eq!(model_id(&models[0]), "mod:item/inner");
-}
-
-#[test]
-fn node_with_nothing_usable_is_empty() {
-    assert!(matches!(
-        node(r#"{"type":"mod:facade"}"#).unwrap(),
-        ItemModelNode::Empty
-    ));
-    assert!(matches!(
-        node(r#"{"type":"mod:x","model":7}"#).unwrap(),
-        ItemModelNode::Empty
-    ));
-    assert!(ClientItem::from_json(r#"{"model":{"type":"ae2:facade"}}"#).is_ok());
-}
-
-#[test]
-fn unknown_vanilla_names_still_fail() {
-    assert!(node(r#"{"type":"minecraft:nope"}"#).is_err());
-    assert!(node(r#"{"type":"nope","model":"a:b"}"#).is_err());
-    let leaf = r#"{"type":"minecraft:model","model":"a:b"}"#;
-    for json in [
-        format!(
-            r#"{{"type":"minecraft:condition","property":"minecraft:nope","on_true":{leaf},"on_false":{leaf}}}"#
-        ),
-        format!(
-            r#"{{"type":"minecraft:select","property":"minecraft:nope","cases":[],"fallback":{leaf}}}"#
-        ),
-        format!(
-            r#"{{"type":"minecraft:range_dispatch","property":"minecraft:nope","entries":[],"fallback":{leaf}}}"#
-        ),
-    ] {
-        assert!(node(&json).is_err(), "{json}");
-    }
-    assert!(
-        node(r#"{"type":"minecraft:special","base":"a:b","model":{"type":"minecraft:nope"}}"#)
-            .is_err()
-    );
-    assert!(ClientItem::from_json(r#"{"model":{"type":"minecraft:nope"}}"#).is_err());
-}
-
-#[test]
-fn condition_property_is_false() {
-    let n = node(
-        r#"{"type":"minecraft:condition","property":"mod:flag",
-            "on_true":{"type":"minecraft:model","model":"a:yes"},
-            "on_false":{"type":"minecraft:model","model":"a:no"}}"#,
-    )
-    .unwrap();
-    // A mod's property stays a condition its mod answers per stack
-    // (`item_model_property`); with no mod answering it, `on_false` is drawn.
-    let ItemModelNode::Condition {
-        property: ConditionProperty::Custom(property),
-        on_false,
-        ..
-    } = &n
-    else {
-        panic!("not a custom condition: {n:?}")
-    };
-    assert_eq!(property, "mod:flag");
-    assert_eq!(model_id(on_false), "a:no");
-}
-
-#[test]
-fn select_property_takes_the_fallback_or_nothing() {
-    let n = node(
-        r#"{"type":"minecraft:select","property":"mod:level",
-            "cases":[{"when":"low","model":{"type":"minecraft:model","model":"a:low"}}],
-            "fallback":{"type":"minecraft:model","model":"a:other"}}"#,
-    )
-    .unwrap();
-    assert_eq!(model_id(&n), "a:other");
-    let n = node(r#"{"type":"minecraft:select","property":"mod:level","cases":[]}"#).unwrap();
-    assert!(matches!(n, ItemModelNode::Empty));
-}
-
-#[test]
-fn range_property_reads_zero() {
-    let entry = |t: f32, m: &str| {
-        format!(r#"{{"threshold":{t},"model":{{"type":"minecraft:model","model":"{m}"}}}}"#)
-    };
-    let fallback = r#","fallback":{"type":"minecraft:model","model":"a:fb"}"#;
-    let make = |entries: &[String], fallback: &str| {
-        node(&format!(
-            r#"{{"type":"minecraft:range_dispatch","property":"mod:fill","entries":[{}]{fallback}}}"#,
-            entries.join(",")
-        ))
-        .unwrap()
-    };
-    let n = make(&[entry(0.2, "a:one"), entry(0.4, "a:two")], fallback);
-    assert_eq!(model_id(&n), "a:fb");
-    let n = make(
-        &[
-            entry(0.0, "a:zero"),
-            entry(-1.0, "a:neg"),
-            entry(0.5, "a:half"),
-        ],
-        fallback,
-    );
-    assert_eq!(model_id(&n), "a:zero");
-    let n = make(&[entry(0.2, "a:one")], "");
-    assert!(matches!(n, ItemModelNode::Empty));
-}
-
-#[test]
-fn special_type_keeps_its_base_model() {
-    let n = node(
-        r#"{"type":"minecraft:special","base":"mod:item/cube","model":{"type":"mod:energy_cube"}}"#,
-    )
-    .unwrap();
-    assert_eq!(model_id(&n), "mod:item/cube");
-    let n =
-        node(r#"{"type":"minecraft:special","base":"a:b","model":{"type":"minecraft:shield"}}"#)
-            .unwrap();
-    assert!(matches!(n, ItemModelNode::Special { .. }));
-}
-
-#[test]
-fn fluid_container_draws_its_base_without_the_fluid() {
-    let n = node(
-        r#"{"type":"neoforge:fluid_container","fluid":"mod:gas","cover_is_mask":false,"flip_gas":true,
-            "textures":{"base":"minecraft:item/bucket","fluid":"neoforge:item/mask/bucket_fluid"}}"#,
-    )
-    .unwrap();
-    assert_eq!(model_id(&n), "minecraft:item/bucket");
-    let n = node(
-        r#"{"type":"neoforge:fluid_container","cover_is_mask":false,
-            "textures":{"base":"a:item/flask","cover":"a:item/flask_cover"}}"#,
-    )
-    .unwrap();
-    let ItemModelNode::Composite { models, .. } = n else {
-        panic!("base and cover")
-    };
-    assert_eq!(models.len(), 2);
-    assert!(matches!(
-        node(r#"{"type":"neoforge:fluid_container"}"#).unwrap(),
-        ItemModelNode::Empty
-    ));
-}

crates/horizon-assets/src/item_model/special.rs

@@ -77,13 +77,6 @@ fn one_of(v: &Value, names: &[&str]) -> Result<String> {
 }
 
 impl SpecialModel {
-    /// A special model type of another namespace, which Horizon has no renderer for.
-    pub fn is_foreign(v: &Value) -> bool {
-        v.get("type")
-            .and_then(Value::as_str)
-            .and_then(|t| super::identifier(t).ok())
-            .is_some_and(|t| super::foreign::is_foreign(&t))
-    }
     pub fn decode(v: &Value) -> Result<Self> {
         let m = object(v)?;
         let float_or = |key: &str, default: f32| get(m, key).map_or(Ok(default), float);

crates/horizon-assets/src/item_model/tests.rs

@@ -18,96 +18,3 @@ fn display_context_names_round_trip() {
         assert_eq!(DisplayContext::by_name(name).unwrap().name(), name);
     }
 }
-
-#[test]
-fn a_mods_tint_source_is_untinted_and_an_unknown_vanilla_one_fails() {
-    let tint = |json: &str| TintSource::decode(&serde_json::from_str(json).unwrap());
-    assert_eq!(
-        tint(r#"{"type":"ae2:storage_cell_state"}"#).unwrap(),
-        TintSource::Constant(-1)
-    );
-    assert!(tint(r#"{"type":"minecraft:nonsense"}"#).is_err());
-}
-
-#[test]
-fn custom_condition_is_evaluated_per_stack_at_branch_selection() {
-    struct Env;
-    impl ItemEnv for Env {
-        fn item_model_property(&self, property: &str, stack: &StackView) -> bool {
-            assert_eq!(property, "example:charged");
-            stack.count > 1 && stack.patch.get("example:charged") == Some(&Some(Value::Bool(true)))
-        }
-    }
-    let definition = ClientItem::from_json(
-        r#"{"model":{
-        "type":"minecraft:condition", "property":"example:charged",
-        "on_true":{"type":"minecraft:model","model":"example:item/charged"},
-        "on_false":{"type":"minecraft:model","model":"example:item/idle"}
-    }}"#,
-    )
-    .unwrap();
-    let mut models = ItemModels::default();
-    models.definitions.insert("example:tool".into(), definition);
-    models.prototypes.insert(
-        "example:tool".into(),
-        BTreeMap::from([(
-            "minecraft:item_model".into(),
-            Value::String("example:tool".into()),
-        )]),
-    );
-    let context = Context {
-        display: DisplayContext::Gui,
-        owner: None,
-        level: None,
-        seed: 0,
-    };
-    let mut stack = StackView::new("example:tool", 1);
-    let chosen = |stack: &StackView, env: &dyn ItemEnv| {
-        let resolved = models.resolve(stack, &context, env);
-        assert_eq!(resolved.layers.len(), 1);
-        let LayerContent::Model { model } = &resolved.layers[0].content else {
-            panic!("expected model leaf")
-        };
-        model.clone()
-    };
-    assert_eq!(chosen(&stack, &NoEnv), "example:item/idle");
-    assert_eq!(chosen(&stack, &Env), "example:item/idle");
-    stack
-        .patch
-        .insert("example:charged".into(), Some(Value::Bool(true)));
-    assert_eq!(chosen(&stack, &Env), "example:item/idle");
-    stack.count = 2;
-    assert_eq!(chosen(&stack, &Env), "example:item/charged");
-    assert_eq!(chosen(&stack, &NoEnv), "example:item/idle");
-    stack.patch.insert("example:charged".into(), None);
-    assert_eq!(chosen(&stack, &Env), "example:item/idle");
-}
-
-#[test]
-fn custom_condition_validates_its_name_and_both_branches() {
-    let node = |property: &str, on_true: Value| {
-        ItemModelNode::decode(&serde_json::json!({
-            "type": "minecraft:condition", "property": property,
-            "on_true": on_true, "on_false": {"type": "minecraft:empty"}
-        }))
-    };
-    let empty = serde_json::json!({"type": "minecraft:empty"});
-    for name in [
-        "minecraft:unknown",
-        "unknown",
-        "example:Bad",
-        "bad name:charged",
-    ] {
-        assert!(node(name, empty.clone()).is_err(), "{name}");
-    }
-    assert!(node("example:charged", Value::Null).is_err());
-    assert!(matches!(
-        node("minecraft:damaged", empty.clone()).unwrap(),
-        ItemModelNode::Condition {
-            property: ConditionProperty::Damaged,
-            ..
-        }
-    ));
-    assert!(matches!(node("example:charged", empty).unwrap(),
-        ItemModelNode::Condition { property: ConditionProperty::Custom(name), .. } if name == "example:charged"));
-}

crates/horizon-assets/src/json.rs

@@ -87,39 +87,6 @@ pub(crate) fn object(raw: &RawValue) -> Result<Object<'_>> {
     }
     Ok(serde_json::from_str(raw.get())?)
 }
-/// The members of an object in document order, which `object` loses.
-pub(crate) fn ordered_object(raw: &RawValue) -> Result<Vec<(String, &RawValue)>> {
-    struct Members<'a>(Vec<(String, &'a RawValue)>);
-    impl<'de> serde::Deserialize<'de> for Members<'de> {
-        fn deserialize<D: serde::Deserializer<'de>>(
-            deserializer: D,
-        ) -> std::result::Result<Self, D::Error> {
-            struct Visitor;
-            impl<'de> serde::de::Visitor<'de> for Visitor {
-                type Value = Members<'de>;
-                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                    f.write_str("an object")
-                }
-                fn visit_map<A: serde::de::MapAccess<'de>>(
-                    self,
-                    mut map: A,
-                ) -> std::result::Result<Self::Value, A::Error> {
-                    let mut members: Vec<(String, &'de RawValue)> = Vec::new();
-                    while let Some(entry) = map.next_entry::<String, &'de RawValue>()? {
-                        members.retain(|(name, _)| *name != entry.0);
-                        members.push(entry);
-                    }
-                    Ok(Members(members))
-                }
-            }
-            deserializer.deserialize_map(Visitor)
-        }
-    }
-    if !raw.get().starts_with('{') {
-        return Err(error("expected object"));
-    }
-    Ok(serde_json::from_str::<Members>(raw.get())?.0)
-}
 pub(crate) fn array(raw: &RawValue) -> Result<Vec<&RawValue>> {
     Ok(serde_json::from_str(raw.get())?)
 }

crates/horizon-assets/src/lib.rs

@@ -9,7 +9,6 @@ pub mod item_model;
 mod json;
 pub mod math;
 pub mod model;
-pub mod obj;
 pub mod palette;
 pub mod resolve;
 

crates/horizon-assets/src/model.rs

@@ -5,7 +5,7 @@
 //! does; render preparation must diagnose these before baking.
 use crate::json::*;
 use serde_json::value::RawValue;
-use std::{collections::BTreeMap, sync::Arc};
+use std::collections::BTreeMap;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Direction {
@@ -59,92 +59,11 @@ pub enum TextureSlot {
 #[derive(Clone, Debug, PartialEq)]
 pub struct CuboidModel {
     pub parent: Option<String>,
-    pub loader: Option<Loader>,
     pub ambient_occlusion: Option<bool>,
     pub gui_light: Option<GuiLight>,
     pub textures: BTreeMap<String, TextureSlot>,
     pub elements: Option<Vec<Option<Element>>>,
     pub display: Option<ItemTransforms>,
-    /// NeoForge's `render_type`, without a `minecraft:` prefix.
-    pub render_type: Option<String>,
-    /// A model's `visibility`: an obj object or composite child name to shown; absent is shown.
-    pub visibility: BTreeMap<String, bool>,
-}
-/// A custom model loader's payload; a model inherits its parent's loader unless it names its own.
-#[derive(Clone, Debug, PartialEq)]
-pub enum Loader {
-    /// `neoforge:composite`: children in document order.
-    Composite {
-        children: Vec<(String, Arc<CuboidModel>)>,
-        /// Child name to shown; a child absent from the map is shown.
-        visibility: BTreeMap<String, bool>,
-    },
-    /// `neoforge:obj`: `model` and `mtl_override` are asset locations.
-    Obj {
-        model: String,
-        flip_v: bool,
-        shade_quads: Option<bool>,
-        mtl_override: Option<String>,
-    },
-    /// A loader this decoder does not know: it adds no geometry.
-    Unknown(String),
-}
-/// NeoForge's `neoforge_data` of an element or a face; a face's keys win.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct NeoforgeData {
-    pub block_light: Option<u8>,
-    pub sky_light: Option<u8>,
-    /// ARGB.
-    pub color: Option<i32>,
-    pub ambient_occlusion: Option<bool>,
-}
-impl NeoforgeData {
-    /// `self` over `base`, key by key.
-    pub fn over(self, base: Self) -> Self {
-        Self {
-            block_light: self.block_light.or(base.block_light),
-            sky_light: self.sky_light.or(base.sky_light),
-            color: self.color.or(base.color),
-            ambient_occlusion: self.ambient_occlusion.or(base.ambient_occlusion),
-        }
-    }
-    fn decode(raw: &RawValue) -> Result<Self> {
-        let obj = object(raw)?;
-        let light = |key: &str| -> Result<Option<u8>> {
-            Ok(obj
-                .get(key)
-                .map(|r| integer(r))
-                .transpose()?
-                .map(|v| v.clamp(0, 15) as u8))
-        };
-        // Some mods spell both lights as one `light_emission`.
-        let emission = light("light_emission")?;
-        let color = match obj.get("color") {
-            Some(raw) if raw.get().starts_with('"') => {
-                let text = string(raw)?;
-                let text = text.trim();
-                let hex = text
-                    .strip_prefix('#')
-                    .or_else(|| text.strip_prefix("0x"))
-                    .or_else(|| text.strip_prefix("0X"));
-                match hex {
-                    Some(hex) => u32::from_str_radix(hex, 16).ok().map(|v| v as i32),
-                    None => text.parse::<u32>().ok().map(|v| v as i32),
-                }
-            }
-            Some(raw) => Some(integer(raw)?),
-            None => None,
-        };
-        Ok(Self {
-            block_light: light("block_light")?.or(emission),
-            sky_light: light("sky_light")?.or(emission),
-            color,
-            ambient_occlusion: obj
-                .get("ambient_occlusion")
-                .map(|r| boolean(r))
-                .transpose()?,
-        })
-    }
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct Element {
@@ -154,7 +73,6 @@ pub struct Element {
     pub rotation: Option<ElementRotation>,
     pub shade_direction_override: Option<Direction>,
     pub light_emission: u8,
-    pub neoforge_data: Option<NeoforgeData>,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct Face {
@@ -164,9 +82,6 @@ pub struct Face {
     pub uv: Option<[f32; 4]>,
     /// Normalized counterclockwise quadrants, in the range 0..4.
     pub rotation: u8,
-    /// A face-level `light_emission`, which wins over its element's.
-    pub light_emission: Option<u8>,
-    pub neoforge_data: Option<NeoforgeData>,
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Axis {
@@ -239,11 +154,6 @@ impl CuboidModel {
         } else {
             Some(identifier(&parent)?)
         };
-        let loader = obj
-            .get("loader")
-            .filter(|raw| raw.get() != "null")
-            .map(|raw| Loader::decode(raw, &obj))
-            .transpose()?;
         let ambient_occlusion = obj
             .get("ambientocclusion")
             .map(|r| boolean(r))
@@ -275,83 +185,15 @@ impl CuboidModel {
             .get("display")
             .map(|r| ItemTransforms::decode(r))
             .transpose()?;
-        let render_type = obj
-            .get("render_type")
-            .filter(|raw| raw.get().starts_with('"'))
-            .map(|raw| string(raw))
-            .transpose()?
-            .map(|name| name.strip_prefix("minecraft:").unwrap_or(&name).to_owned());
         Ok(Self {
             parent,
-            loader,
             ambient_occlusion,
             gui_light,
             textures,
             elements,
             display,
-            render_type,
-            visibility: visibility(&obj)?,
         })
     }
-    /// The models this one needs besides itself: its parent and its composite children's parents.
-    pub fn referenced_models(&self) -> Vec<String> {
-        let mut names: Vec<String> = self.parent.iter().cloned().collect();
-        if let Some(Loader::Composite { children, .. }) = &self.loader {
-            for (_, child) in children {
-                names.extend(child.referenced_models());
-            }
-        }
-        names
-    }
-}
-fn visibility(obj: &Object<'_>) -> Result<BTreeMap<String, bool>> {
-    let mut visibility = BTreeMap::new();
-    if let Some(raw) = obj.get("visibility") {
-        for (key, raw) in object(raw)? {
-            visibility.insert(key, boolean(raw)?);
-        }
-    }
-    Ok(visibility)
-}
-impl Loader {
-    fn decode(raw: &RawValue, obj: &Object<'_>) -> Result<Self> {
-        let name = primitive_string(raw)?;
-        match name.as_str() {
-            "neoforge:composite" => {
-                let mut children = Vec::new();
-                if let Some(raw) = obj.get("children") {
-                    for (name, raw) in ordered_object(raw)? {
-                        children.push((name, Arc::new(CuboidModel::decode(raw)?)));
-                    }
-                }
-                Ok(Self::Composite {
-                    children,
-                    visibility: visibility(obj)?,
-                })
-            }
-            "neoforge:obj" => {
-                let optional = |key: &str| {
-                    obj.get(key)
-                        .filter(|raw| raw.get() != "null")
-                        .map(|raw| primitive_string(raw))
-                        .transpose()
-                };
-                Ok(Self::Obj {
-                    model: identifier(&optional("model")?.ok_or_else(|| error("missing model"))?)?,
-                    flip_v: obj
-                        .get("flip_v")
-                        .map(|r| boolean(r))
-                        .transpose()?
-                        .unwrap_or(false),
-                    shade_quads: obj.get("shade_quads").map(|r| boolean(r)).transpose()?,
-                    mtl_override: optional("mtl_override")?
-                        .map(|name| identifier(&name))
-                        .transpose()?,
-                })
-            }
-            _ => Ok(Self::Unknown(name)),
-        }
-    }
 }
 fn nullable<T>(raw: &RawValue, decode: impl FnOnce(&RawValue) -> Result<T>) -> Result<Option<T>> {
     if raw.get() == "null" {
@@ -431,10 +273,6 @@ impl Element {
             rotation,
             shade_direction_override,
             light_emission: light_emission as u8,
-            neoforge_data: obj
-                .get("neoforge_data")
-                .map(|r| NeoforgeData::decode(r))
-                .transpose()?,
         })
     }
 }
@@ -468,15 +306,6 @@ impl Face {
             texture,
             uv,
             rotation: (rotation / 90) as u8,
-            light_emission: obj
-                .get("light_emission")
-                .map(|r| integer(r))
-                .transpose()?
-                .map(|v| v.clamp(0, 15) as u8),
-            neoforge_data: obj
-                .get("neoforge_data")
-                .map(|r| NeoforgeData::decode(r))
-                .transpose()?,
         })
     }
 }

crates/horizon-assets/src/obj.rs

@@ -1,183 +0,0 @@
-//! Wavefront OBJ and MTL text, as obj-loader models use them.
-use std::collections::BTreeMap;
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct ObjVertex {
-    /// Block units.
-    pub position: [f32; 3],
-    /// Texture coordinates as written, 0..1 across the sprite.
-    pub uv: [f32; 2],
-}
-/// One quad; a triangle repeats its last vertex.
-#[derive(Clone, Debug, PartialEq)]
-pub struct ObjFace {
-    /// Empty before any `usemtl`.
-    pub material: String,
-    /// The `o` (else `g`) it belongs to, which a model's `visibility` names.
-    pub object: String,
-    pub vertices: [ObjVertex; 4],
-}
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct ParsedObj {
-    pub mtllib: Option<String>,
-    pub faces: Vec<ObjFace>,
-}
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum MtlTexture {
-    /// `map_Kd #name`: a texture slot of the model.
-    Slot(String),
-    /// `map_Kd namespace:path`: a sprite.
-    Sprite(String),
-}
-/// A parsed OBJ with its materials.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct ObjModel {
-    pub faces: Vec<ObjFace>,
-    pub materials: BTreeMap<String, MtlTexture>,
-}
-
-pub fn parse_obj(text: &str) -> Result<ParsedObj, String> {
-    let mut positions: Vec<[f32; 3]> = Vec::new();
-    let mut uvs: Vec<[f32; 2]> = Vec::new();
-    let mut parsed = ParsedObj::default();
-    let mut material = String::new();
-    let mut object = String::new();
-    for (number, line) in text.lines().enumerate() {
-        let mut words = line.split_whitespace();
-        let Some(keyword) = words.next() else {
-            continue;
-        };
-        let at = |message: &str| format!("line {}: {message}", number + 1);
-        match keyword {
-            _ if keyword.starts_with('#') => {}
-            "v" => positions.push(floats::<3>(words).ok_or_else(|| at("bad vertex"))?),
-            "vt" => {
-                let mut words = words;
-                let u = words.next().and_then(|w| w.parse().ok());
-                let v = words.next().map_or(Some(0.0), |w| w.parse().ok());
-                let (Some(u), Some(v)) = (u, v) else {
-                    return Err(at("bad texture coordinate"));
-                };
-                uvs.push([u, v]);
-            }
-            "mtllib" => parsed.mtllib = words.next().map(str::to_owned),
-            "usemtl" => material = words.next().unwrap_or("").to_owned(),
-            "o" | "g" => object = words.next().unwrap_or("").to_owned(),
-            "f" => {
-                let mut corners = Vec::new();
-                for word in words {
-                    let mut parts = word.split('/');
-                    let position = index(parts.next(), positions.len())
-                        .ok_or_else(|| at("bad vertex index"))?;
-                    let uv = match parts.next() {
-                        None | Some("") => [0.0; 2],
-                        some => {
-                            uvs[index(some, uvs.len()).ok_or_else(|| at("bad texture index"))?]
-                        }
-                    };
-                    corners.push(ObjVertex {
-                        position: positions[position],
-                        uv,
-                    });
-                }
-                if corners.len() < 3 {
-                    return Err(at("face needs three vertices"));
-                }
-                let mut push = |vertices: [ObjVertex; 4]| {
-                    parsed.faces.push(ObjFace {
-                        material: material.clone(),
-                        object: object.clone(),
-                        vertices,
-                    });
-                };
-                if corners.len() <= 4 {
-                    let last = corners[corners.len() - 1];
-                    push(std::array::from_fn(|i| {
-                        corners.get(i).copied().unwrap_or(last)
-                    }));
-                } else {
-                    for i in 1..corners.len() - 1 {
-                        push([corners[0], corners[i], corners[i + 1], corners[i + 1]]);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-    Ok(parsed)
-}
-fn floats<'a, const N: usize>(mut words: impl Iterator<Item = &'a str>) -> Option<[f32; N]> {
-    let mut result = [0.0; N];
-    for value in &mut result {
-        *value = words.next()?.parse().ok()?;
-    }
-    Some(result)
-}
-/// A 1-based index, or a negative one counted from the end.
-fn index(word: Option<&str>, len: usize) -> Option<usize> {
-    let value: i64 = word?.parse().ok()?;
-    let index = if value < 0 {
-        len as i64 + value
-    } else {
-        value - 1
-    };
-    (0..len as i64).contains(&index).then_some(index as usize)
-}
-
-/// Material name to its `map_Kd`; other statements are ignored.
-pub fn parse_mtl(text: &str) -> BTreeMap<String, MtlTexture> {
-    let mut materials = BTreeMap::new();
-    let mut current = None;
-    for line in text.lines() {
-        let mut words = line.split_whitespace();
-        match words.next() {
-            Some("newmtl") => current = words.next().map(str::to_owned),
-            Some("map_Kd") => {
-                let (Some(name), Some(value)) = (&current, words.last()) else {
-                    continue;
-                };
-                let texture = match value.strip_prefix('#') {
-                    Some(slot) => MtlTexture::Slot(slot.to_owned()),
-                    None => MtlTexture::Sprite(value.to_owned()),
-                };
-                materials.insert(name.clone(), texture);
-            }
-            _ => {}
-        }
-    }
-    materials
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn quads_triangles_and_negative_indices() {
-        let text = "mtllib a.mtl\nv 0 0 0\nv 1 0 0\nv 1 1 0\nv 0 1 0\nvt 0 0\nvt 1 0\nvt 1 1\nvt 0 1\n\
-                    usemtl first\nf 1/1/1 2/2/1 3/3/1 4/4/1\nusemtl second\nf -4//1 -3//1 -2//1\n";
-        let parsed = parse_obj(text).unwrap();
-        assert_eq!(parsed.mtllib.as_deref(), Some("a.mtl"));
-        assert_eq!(parsed.faces.len(), 2);
-        assert_eq!(parsed.faces[0].material, "first");
-        assert_eq!(parsed.faces[0].vertices[2].uv, [1.0, 1.0]);
-        let triangle = &parsed.faces[1];
-        assert_eq!(triangle.material, "second");
-        assert_eq!(triangle.vertices[0].position, [0.0, 0.0, 0.0]);
-        assert_eq!(triangle.vertices[3], triangle.vertices[2]);
-        assert_eq!(triangle.vertices[2].position, [1.0, 1.0, 0.0]);
-    }
-    #[test]
-    fn bad_indices_are_errors() {
-        assert!(parse_obj("v 0 0 0\nf 1 2 3\n").is_err());
-        assert!(parse_obj("v 0 0 0\nv 1 0 0\nf 1 2\n").is_err());
-    }
-    #[test]
-    fn mtl_maps_slots_and_sprites() {
-        let materials =
-            parse_mtl("newmtl a\nKd 1 1 1\nmap_Kd #top\nnewmtl b\nmap_Kd mod:block/x\nnewmtl c\n");
-        assert_eq!(materials["a"], MtlTexture::Slot("top".into()));
-        assert_eq!(materials["b"], MtlTexture::Sprite("mod:block/x".into()));
-        assert!(!materials.contains_key("c"));
-    }
-}

crates/horizon-assets/src/resolve.rs

@@ -1,45 +1,18 @@
 //! Cuboid parent inheritance and texture-slot resolution.
-use crate::{
-    json::*,
-    model::*,
-    obj::{ObjModel, parse_mtl, parse_obj},
-};
+use crate::{json::*, model::*};
 use std::{
     collections::{BTreeMap, BTreeSet},
-    sync::{Arc, Mutex},
+    sync::Arc,
 };
 
 pub const MISSING_MODEL: &str = "minecraft:builtin/missing";
 /// `ItemModelGenerator.GENERATED_ITEM_MODEL_ID`.
 pub const GENERATED_MODEL: &str = "minecraft:builtin/generated";
-/// Composite children nest through parents that may name the composite again.
-const MAX_LOADER_DEPTH: u8 = 8;
 
-/// Reads asset files that models point at (`namespace:path` is `assets/namespace/path`).
-pub trait AssetReader: Send + Sync {
-    fn read_text(&self, location: &str) -> Option<String>;
-}
 /// Decoded models are immutable and their inherited geometry is shared.
 pub struct ModelLibrary {
     models: BTreeMap<String, Arc<CuboidModel>>,
     missing: Arc<CuboidModel>,
-    assets: Option<Arc<dyn AssetReader>>,
-    /// Keyed by obj and mtl override; `None` is a file that failed, already warned about.
-    objs: Mutex<BTreeMap<(String, Option<String>), Option<Arc<ObjModel>>>>,
-}
-/// What a model's loader adds to its own elements.
-#[derive(Clone, Debug)]
-pub enum ResolvedLoader {
-    /// The shown children, resolved on their own, in order.
-    Composite(Vec<ResolvedCuboidModel>),
-    Obj {
-        /// `None` when the file failed to load.
-        model: Option<Arc<ObjModel>>,
-        flip_v: bool,
-        shade: bool,
-        /// Objects the model chain's `visibility` hides.
-        hidden: BTreeSet<String>,
-    },
 }
 #[derive(Clone, Debug)]
 pub struct ResolvedCuboidModel {
@@ -49,17 +22,10 @@ pub struct ResolvedCuboidModel {
     pub textures: BTreeMap<String, Material>,
     /// Cyclic and dangling aliases are absent from `textures`.
     pub unresolved_textures: BTreeSet<String>,
-    /// NeoForge's `render_type`; the leaf-most model that sets one wins.
-    pub render_type: Option<String>,
     geometry: Option<Arc<CuboidModel>>,
     generated: bool,
-    loader: Option<ResolvedLoader>,
 }
 impl ResolvedCuboidModel {
-    /// Geometry from a custom loader, baked after the elements.
-    pub fn loader(&self) -> Option<&ResolvedLoader> {
-        self.loader.as_ref()
-    }
     /// Whether the top geometry is `builtin/generated`'s layer extrusion
     /// (no model closer to the leaf has elements of its own).
     pub fn uses_item_generator(&self) -> bool {
@@ -100,7 +66,6 @@ impl ModelLibrary {
     fn item_generator_model() -> CuboidModel {
         CuboidModel {
             parent: None,
-            loader: None,
             ambient_occlusion: None,
             gui_light: Some(GuiLight::Front),
             textures: BTreeMap::from([(
@@ -109,8 +74,6 @@ impl ModelLibrary {
             )]),
             elements: None,
             display: None,
-            render_type: None,
-            visibility: BTreeMap::new(),
         }
     }
     pub fn new(models: BTreeMap<String, CuboidModel>) -> Result<Self> {
@@ -137,15 +100,8 @@ impl ModelLibrary {
         Ok(Self {
             models: decoded,
             missing,
-            assets: None,
-            objs: Mutex::default(),
         })
     }
-    /// Where `neoforge:obj` models find their files.
-    pub fn with_assets(mut self, assets: Arc<dyn AssetReader>) -> Self {
-        self.assets = Some(assets);
-        self
-    }
     /// This library plus `extra` models; an `extra` model replaces a
     /// same-named one, but not the built-in missing and generated models.
     /// Every existing model is shared, not copied.
@@ -166,15 +122,13 @@ impl ModelLibrary {
         Ok(Self {
             models,
             missing: Arc::clone(&self.missing),
-            assets: self.assets.clone(),
-            objs: Mutex::default(),
         })
     }
     /// Follow the complete parent chain. A missing resource uses the built-in
     /// model; a cyclic chain is rejected, as native discovery excludes it.
     /// The returned model can outlive this library without copying its elements.
     pub fn resolve(&self, name: &str) -> Result<ResolvedCuboidModel> {
-        self.resolve_name(name, None)
+        self.resolve_chain(name, None)
     }
     /// Whether `name` and every parent it reaches are models of this library,
     /// with no cycle: `resolve` puts the missing model in for any other.
@@ -209,40 +163,28 @@ impl ModelLibrary {
         name: &str,
         child: &BTreeMap<String, TextureSlot>,
     ) -> Result<ResolvedCuboidModel> {
-        self.resolve_name(name, Some(child))
+        self.resolve_chain(name, Some(child))
     }
-    fn resolve_name(
+    fn resolve_chain(
         &self,
         name: &str,
         child: Option<&BTreeMap<String, TextureSlot>>,
     ) -> Result<ResolvedCuboidModel> {
-        let next = Some(identifier(name)?);
-        self.resolve_chain(Vec::new(), Vec::new(), next, &BTreeMap::new(), child, 0)
-    }
-    /// `chain` and `names` start with models that are not in the library (a
-    /// composite child); `next` is the parent to follow. `fallback` slots lose
-    /// to any slot the chain defines.
-    fn resolve_chain(
-        &self,
-        mut chain: Vec<Arc<CuboidModel>>,
-        mut names: Vec<String>,
-        mut next: Option<String>,
-        fallback: &BTreeMap<String, TextureSlot>,
-        child: Option<&BTreeMap<String, TextureSlot>>,
-        depth: u8,
-    ) -> Result<ResolvedCuboidModel> {
-        if depth > MAX_LOADER_DEPTH {
-            return Err(error("composite models nest too deeply"));
-        }
+        let mut name = identifier(name)?;
         let mut visited = BTreeSet::new();
-        while let Some(name) = next.take() {
+        let mut chain = Vec::new();
+        let mut names = Vec::new();
+        loop {
             if !visited.insert(name.clone()) {
                 return Err(error("cyclic model parent"));
             }
             let model = self.models.get(&name).unwrap_or(&self.missing);
-            chain.push(Arc::clone(model));
-            names.push(name);
-            next = model.parent.clone();
+            chain.push(model);
+            names.push(name.clone());
+            match &model.parent {
+                Some(parent) => name = parent.clone(),
+                None => break,
+            }
         }
         let ambient_occlusion = chain
             .iter()
@@ -252,8 +194,10 @@ impl ModelLibrary {
             .iter()
             .find_map(|m| m.gui_light)
             .unwrap_or(GuiLight::Side);
-        let render_type = chain.iter().find_map(|m| m.render_type.clone());
-        let geometry = chain.iter().find(|m| m.elements.is_some()).map(Arc::clone);
+        let geometry = chain
+            .iter()
+            .find(|m| m.elements.is_some())
+            .map(|m| Arc::clone(m));
         let generated = chain
             .iter()
             .zip(&names)
@@ -272,68 +216,13 @@ impl ModelLibrary {
         };
         // Resolve aliases only after applying every child override. A reference
         // inherited from a parent binds to the child's final slot definition.
-        let mut slots: BTreeMap<String, &TextureSlot> =
-            fallback.iter().map(|(k, v)| (k.clone(), v)).collect();
-        for model in chain.iter().rev() {
+        let mut slots = BTreeMap::new();
+        for model in chain.into_iter().rev() {
             slots.extend(model.textures.iter().map(|(k, v)| (k.clone(), v)));
         }
         if let Some(child) = child {
             slots.extend(child.iter().map(|(k, v)| (k.clone(), v)));
         }
-        let loader = match chain.iter().find_map(|m| m.loader.as_ref()) {
-            Some(Loader::Composite {
-                children,
-                visibility,
-            }) => {
-                let inherited: BTreeMap<String, TextureSlot> = slots
-                    .iter()
-                    .map(|(k, v)| (k.clone(), (*v).clone()))
-                    .collect();
-                // A model closer to the leaf overrides the loader's own map.
-                let mut visibility = visibility.clone();
-                for model in chain.iter().rev() {
-                    visibility.extend(model.visibility.iter().map(|(k, v)| (k.clone(), *v)));
-                }
-                let mut resolved = Vec::new();
-                for (child_name, child_model) in children {
-                    if visibility.get(child_name) == Some(&false) {
-                        continue;
-                    }
-                    resolved.push(self.resolve_chain(
-                        vec![Arc::clone(child_model)],
-                        vec![format!("{}#{child_name}", names[0])],
-                        child_model.parent.clone(),
-                        &inherited,
-                        None,
-                        depth + 1,
-                    )?);
-                }
-                Some(ResolvedLoader::Composite(resolved))
-            }
-            Some(Loader::Obj {
-                model,
-                flip_v,
-                shade_quads,
-                mtl_override,
-            }) => {
-                // Leaf wins: a model closer to the leaf overrides its parents' entries.
-                let mut visibility = BTreeMap::new();
-                for model in chain.iter().rev() {
-                    visibility.extend(model.visibility.iter().map(|(k, v)| (k.clone(), *v)));
-                }
-                Some(ResolvedLoader::Obj {
-                    model: self.load_obj(&names[0], model, mtl_override.as_deref()),
-                    flip_v: *flip_v,
-                    shade: shade_quads.unwrap_or(true),
-                    hidden: visibility
-                        .into_iter()
-                        .filter(|(_, shown)| !shown)
-                        .map(|(name, _)| name)
-                        .collect(),
-                })
-            }
-            Some(Loader::Unknown(_)) | None => None,
-        };
         let mut textures = BTreeMap::<String, Material>::new();
         let mut unresolved_textures = BTreeSet::<String>::new();
         for start in slots.keys() {
@@ -375,61 +264,12 @@ impl ModelLibrary {
             display,
             textures,
             unresolved_textures,
-            render_type,
             geometry,
             generated,
-            loader,
-        })
-    }
-    /// Parse an obj and its materials once; a failure warns once and yields no geometry.
-    fn load_obj(&self, label: &str, model: &str, mtl: Option<&str>) -> Option<Arc<ObjModel>> {
-        let key = (model.to_owned(), mtl.map(str::to_owned));
-        let mut cache = self.objs.lock().unwrap_or_else(|e| e.into_inner());
-        if let Some(found) = cache.get(&key) {
-            return found.clone();
-        }
-        let loaded = self.read_obj(model, mtl);
-        if let Err(message) = &loaded {
-            log::warn!("Horizon: obj model {label} ({model}): {message}");
-        }
-        let loaded = loaded.ok().map(Arc::new);
-        cache.insert(key, loaded.clone());
-        loaded
-    }
-    fn read_obj(&self, model: &str, mtl: Option<&str>) -> std::result::Result<ObjModel, String> {
-        let assets = self.assets.as_ref().ok_or("no asset source")?;
-        let text = assets.read_text(model).ok_or("file not found")?;
-        let parsed = parse_obj(&text)?;
-        let mtl = match (mtl, &parsed.mtllib) {
-            (Some(location), _) => Some(location.to_owned()),
-            (None, Some(file)) if file.contains(':') => Some(file.clone()),
-            (None, Some(file)) => {
-                let (namespace, path) = model.split_once(':').unwrap_or(("minecraft", model));
-                let directory = path.rsplit_once('/').map_or("", |(dir, _)| dir);
-                Some(if directory.is_empty() {
-                    format!("{namespace}:{file}")
-                } else {
-                    format!("{namespace}:{directory}/{file}")
-                })
-            }
-            (None, None) => None,
-        };
-        let materials = match mtl {
-            Some(location) => match assets.read_text(&location) {
-                Some(text) => parse_mtl(&text),
-                None => {
-                    log::warn!("Horizon: obj material file {location} not found");
-                    BTreeMap::new()
-                }
-            },
-            None => BTreeMap::new(),
-        };
-        Ok(ObjModel {
-            faces: parsed.faces,
-            materials,
         })
     }
 }
+
 /// The native missing-model cube uses slot names without a leading '#'.
 pub fn missing_model() -> CuboidModel {
     let faces = Direction::ALL
@@ -443,15 +283,12 @@ pub fn missing_model() -> CuboidModel {
                     texture: "missingno".to_owned(),
                     uv: Some([0.0, 0.0, 16.0, 16.0]),
                     rotation: 0,
-                    light_emission: None,
-                    neoforge_data: None,
                 }),
             )
         })
         .collect();
     CuboidModel {
         parent: None,
-        loader: None,
         ambient_occlusion: None,
         gui_light: None,
         elements: Some(vec![Some(Element {
@@ -461,12 +298,10 @@ pub fn missing_model() -> CuboidModel {
             rotation: None,
             shade_direction_override: None,
             light_emission: 0,
-            neoforge_data: None,
         })]),
         display: Some(ItemTransforms {
             contexts: std::array::from_fn(|_| DisplayTransform::Inherit),
         }),
-        render_type: None,
         textures: BTreeMap::from([
             (
                 "particle".to_owned(),
@@ -480,7 +315,6 @@ pub fn missing_model() -> CuboidModel {
                 }),
             ),
         ]),
-        visibility: BTreeMap::new(),
     }
 }
 
@@ -734,96 +568,4 @@ mod tests {
         assert!(!library.resolves("item/a"));
         assert!(!library.resolves("Item/Stick"));
     }
-    const LIGHTS: &str = r##"{"textures":{"a":"block/a"},"render_type":"minecraft:cutout","elements":[
-        {"from":[0,0,0],"to":[16,16,16],"light_emission":4,"neoforge_data":{"block_light":9,"color":-65536,"ambient_occlusion":false},
-         "faces":{"north":{"texture":"#a","neoforge_data":{"block_light":2,"sky_light":15,"unknown":1}},
-                  "south":{"texture":"#a","light_emission":11},
-                  "up":{"texture":"#a"}}}]}"##;
-    #[test]
-    fn neoforge_data_of_a_face_overrides_its_element_key_by_key() {
-        use crate::bake::bake_block_model;
-        let library = library(&[("block/lights", LIGHTS)]);
-        let model = library.resolve("block/lights").unwrap();
-        let quads =
-            bake_block_model(&model, crate::bake::BlockModelTransform::new([0; 3], false)).unwrap();
-        let by = |d| quads.iter().find(|q| q.facing == d).unwrap();
-        let north = by(Direction::North);
-        assert_eq!(north.light, [4, 15]);
-        assert_eq!(north.color, Some(-65536));
-        assert_eq!(north.ambient_occlusion, Some(false));
-        assert_eq!(by(Direction::South).light, [11, 11]);
-        assert_eq!(by(Direction::South).light_emission, 11);
-        assert_eq!(by(Direction::Up).light, [9, 4]);
-        assert!(
-            quads
-                .iter()
-                .all(|q| q.render_type == Some(crate::bake::RenderType::Cutout))
-        );
-    }
-    #[test]
-    fn vanilla_models_bake_without_extra_face_data() {
-        use crate::bake::bake_block_model;
-        let library = library(&[(
-            "block/plain",
-            r##"{"textures":{"a":"block/a"},"elements":[{"from":[0,0,0],"to":[16,16,16],"light_emission":6,"faces":{"up":{"texture":"#a"}}}]}"##,
-        )]);
-        let model = library.resolve("block/plain").unwrap();
-        let quad = &bake_block_model(&model, crate::bake::BlockModelTransform::new([0; 3], false))
-            .unwrap()[0];
-        assert_eq!((quad.light, quad.light_emission), ([6, 6], 6));
-        assert_eq!(
-            (quad.color, quad.ambient_occlusion, quad.render_type),
-            (None, None, None)
-        );
-    }
-    #[test]
-    fn render_type_comes_from_the_leaf_most_model_and_loses_its_prefix() {
-        let library = library(&[
-            ("block/base", r#"{"render_type":"translucent"}"#),
-            ("block/mid", r#"{"parent":"block/base"}"#),
-            (
-                "block/leaf",
-                r#"{"parent":"block/mid","render_type":"minecraft:cutout_mipped"}"#,
-            ),
-            ("block/bare", r#"{"parent":"block/mid"}"#),
-        ]);
-        let render = |name| library.resolve(name).unwrap().render_type;
-        assert_eq!(render("block/leaf").as_deref(), Some("cutout_mipped"));
-        assert_eq!(render("block/bare").as_deref(), Some("translucent"));
-        assert_eq!(render("block/absent"), None);
-        assert_eq!(
-            crate::bake::RenderType::by_name("minecraft:tripwire"),
-            Some(crate::bake::RenderType::Tripwire)
-        );
-        assert_eq!(crate::bake::RenderType::by_name("mod:glow"), None);
-    }
-    #[test]
-    fn neoforge_data_colour_and_legacy_emission_spellings() {
-        let model = CuboidModel::from_json(
-            r##"{"elements":[{"from":[0,0,0],"to":[1,1,1],"faces":{
-                "up":{"texture":"#a","neoforge_data":{"color":"#80FF0000","light_emission":7}},
-                "down":{"texture":"#a","neoforge_data":{"color":4294967295,"block_light":99}}}}]}"##,
-        )
-        .unwrap();
-        let elements = model.elements.unwrap();
-        let faces = &elements[0].as_ref().unwrap().faces;
-        let up = faces[&Direction::Up]
-            .as_ref()
-            .unwrap()
-            .neoforge_data
-            .unwrap();
-        assert_eq!(
-            (up.color, up.block_light, up.sky_light),
-            (Some(0x80FF0000u32 as i32), Some(7), Some(7))
-        );
-        let down = faces[&Direction::Down]
-            .as_ref()
-            .unwrap()
-            .neoforge_data
-            .unwrap();
-        assert_eq!(
-            (down.color, down.block_light, down.sky_light),
-            (Some(-1), Some(15), None)
-        );
-    }
 }

crates/horizon-bots/src/main.rs

@@ -14,8 +14,7 @@
 //!
 //!   horizon-bots --server 127.0.0.1:25565 --bots 25 --behaviour mixed --seconds 360 --report bots.json
 //!
-//! It prints one JSON line a second (bots online, chunks received), one with the first bot's spawn position, and
-//! writes a summary with `--report`.
+//! It prints one JSON line a second (bots online, chunks received) and writes a summary with `--report`.
 //! A bot moves only while it holds the chunk it stands in: vanilla's client stops ticking its player in a chunk
 //! it hasn't received, so a player can't outrun the server's chunk sending, on any server.
 //! Each bot also keeps the chunks it holds, as a client's chunk cache does, so the report tells chunks that
@@ -103,8 +102,6 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
                          to test what a server takes
   --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)
-  --capture FILE         record the first bot's play packets (milliseconds since it joined, id, body)
-                         for crates/horizon-protocol/examples/net_replay.rs
 ";
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -180,8 +177,6 @@ struct Options {
     /// The `minecraft:brand` to send, if any.
     brand: Option<String>,
     report: Option<String>,
-    /// --capture: where the first bot's play packets go.
-    capture: Option<String>,
     /// How many times as fast as vanilla's 20 Hz the bots tick (a timer cheat above 1).
     timer: f64,
 }
@@ -212,7 +207,6 @@ fn options() -> Result<Options, String> {
         click: None,
         name: "Bot".into(),
         report: None,
-        capture: None,
         brand: None,
         timer: 1.0,
     };
@@ -262,7 +256,6 @@ fn options() -> Result<Options, String> {
             "--attack-rounds" => o.attack_rounds = value.parse().map_err(|_| number("a number"))?,
             "--name" => o.name = value,
             "--report" => o.report = Some(value),
-            "--capture" => o.capture = Some(value),
             "--brand" => o.brand = Some(value),
             "--give" => {
                 for part in value.split(',') {
@@ -826,53 +819,12 @@ impl BatchSize {
     }
 }
 
-/// `--capture`: one record per play packet, little-endian: u32 milliseconds since the
-/// bot joined, i32 packet id, u32 body length, then the body (without the id).
-struct Capture {
-    out: std::io::BufWriter<std::fs::File>,
-    start: Instant,
-    /// The second last flushed: the process may end before the reader thread does.
-    flushed: u32,
-}
-impl Capture {
-    fn create(path: &str) -> Option<Self> {
-        match std::fs::File::create(path) {
-            Ok(file) => Some(Self {
-                out: std::io::BufWriter::new(file),
-                start: Instant::now(),
-                flushed: 0,
-            }),
-            Err(e) => {
-                eprintln!("--capture {path}: {e}");
-                None
-            }
-        }
-    }
-    fn record(&mut self, id: i32, body: &[u8]) {
-        use std::io::Write;
-        let ms = self.start.elapsed().as_millis() as u32;
-        let mut head = [0u8; 12];
-        head[..4].copy_from_slice(&ms.to_le_bytes());
-        head[4..8].copy_from_slice(&id.to_le_bytes());
-        head[8..].copy_from_slice(&(body.len() as u32).to_le_bytes());
-        let _ = self
-            .out
-            .write_all(&head)
-            .and_then(|()| self.out.write_all(body));
-        if ms / 1000 != self.flushed {
-            self.flushed = ms / 1000;
-            let _ = self.out.flush();
-        }
-    }
-}
-
 /// Reads the play state: answers what a client must answer, counts chunks, records teleports.
 fn read(
     mut reader: horizon_protocol::connection::ConnReader,
     writer: Arc<Mutex<ConnWriter>>,
     bot: Arc<Bot>,
     track: bool,
-    mut capture: Option<Capture>,
 ) {
     use ids::play::clientbound as cb;
     use ids::play::serverbound as sb;
@@ -896,9 +848,6 @@ fn read(
                 return;
             }
         };
-        if let Some(c) = &mut capture {
-            c.record(id, &body);
-        }
         let mut r = Reader::new(&body);
         let sent = match id {
             cb::KEEP_ALIVE => match r.i64() {
@@ -1058,10 +1007,7 @@ fn run_bot(
     {
         let (writer, bot) = (writer.clone(), bot.clone());
         let track = behaviour == Behaviour::Fight;
-        let capture = (index == 0)
-            .then(|| o.capture.as_deref().and_then(Capture::create))
-            .flatten();
-        thread::spawn(move || read(reader, writer, bot, track, capture));
+        thread::spawn(move || read(reader, writer, bot, track));
     }
     use ids::play::serverbound as sb;
     // Wait for the spawn position.
@@ -1079,10 +1025,6 @@ fn run_bot(
     };
     bot.joined_after_ms
         .store(asked.elapsed().as_millis() as u64, Ordering::SeqCst);
-    if index == 0 {
-        // Where the bots gather, for a client that comes to watch them (tools/perf_bench.py --server-bots).
-        println!("{}", json!({ "spawn": spawn }));
-    }
     let send = |body: Vec<u8>| lock(&writer).send(&body).is_ok();
     if !o.no_loaded {
         send(raw(sb::PLAYER_LOADED, |_| {}));

crates/horizon-chat-filter/src/lib.rs

@@ -125,11 +125,7 @@ impl Filter {
                     Some(w) => (w, true),
                     None => (word, false),
                 };
-                // An allow entry with no letters would allow every word (an empty prefix).
-                let runs = normalise::word(word);
-                if !runs.is_empty() {
-                    f.allowed.push((runs, prefix));
-                }
+                f.allowed.push((normalise::word(word), prefix));
                 continue;
             }
             let (kind, word) = match line.as_bytes()[0] {
@@ -243,19 +239,8 @@ impl Action {
 pub struct Mute {
     pub uuid: String,
     pub name: String,
-    /// Epoch milliseconds; `None`: until `/unmute`.
-    pub until: Option<i64>,
-    /// The operator who muted them (`/mute`, `/tempmute`); `None`: the filter.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub by: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub reason: Option<String>,
-}
-
-impl Mute {
-    pub fn active(&self, now: i64) -> bool {
-        self.until.is_none_or(|until| until > now)
-    }
+    /// Epoch milliseconds.
+    pub until: i64,
 }
 
 #[derive(Default, Serialize, Deserialize)]
@@ -327,38 +312,12 @@ impl Guard {
         )
     }
 
-    /// The player's mute, if they are muted at `now`.
-    pub fn muted(&self, uuid: u128, now: i64) -> Option<&Mute> {
-        self.mutes.get(&uuid).filter(|m| m.active(now))
-    }
-
-    /// The mutes in force at `now`, by name.
-    pub fn mutes(&self, now: i64) -> Vec<&Mute> {
-        let mut mutes: Vec<&Mute> = self.mutes.values().filter(|m| m.active(now)).collect();
-        mutes.sort_by(|a, b| a.name.cmp(&b.name));
-        mutes
-    }
-
-    /// An operator's `/mute` (`until` `None`) or `/tempmute`: replaces the player's mute.
-    pub fn mute(
-        &mut self,
-        uuid: u128,
-        name: &str,
-        until: Option<i64>,
-        by: &str,
-        reason: Option<String>,
-    ) {
-        self.mutes.insert(
-            uuid,
-            Mute {
-                uuid: uuid_string(uuid),
-                name: name.to_owned(),
-                until,
-                by: Some(by.to_owned()),
-                reason,
-            },
-        );
-        self.save();
+    /// When the player's mute ends, if they are muted at `now`.
+    pub fn muted_until(&self, uuid: u128, now: i64) -> Option<i64> {
+        self.mutes
+            .get(&uuid)
+            .map(|m| m.until)
+            .filter(|&until| until > now)
     }
 
     /// A hit by the player at `now`: the hit's number in the window, and what it leads to.
@@ -384,24 +343,15 @@ impl Guard {
             let until = now + i64::from(c.mute_minutes) * MINUTE;
             // The window starts again when the mute ends.
             s.counts_until = until + window;
-            // An operator's longer mute stays.
-            if !self
-                .mutes
-                .get(&uuid)
-                .is_some_and(|m| m.until.is_none_or(|u| u >= until))
-            {
-                self.mutes.insert(
-                    uuid,
-                    Mute {
-                        uuid: uuid_string(uuid),
-                        name: name.to_owned(),
-                        until: Some(until),
-                        by: None,
-                        reason: None,
-                    },
-                );
-                self.save();
-            }
+            self.mutes.insert(
+                uuid,
+                Mute {
+                    uuid: uuid_string(uuid),
+                    name: name.to_owned(),
+                    until,
+                },
+            );
+            self.save();
             Action::Muted { until }
         } else {
             Action::Refused
@@ -427,7 +377,7 @@ impl Guard {
             return;
         };
         let now = now_millis();
-        self.mutes.retain(|_, m| m.active(now));
+        self.mutes.retain(|_, m| m.until > now);
         let mut mutes: Vec<Mute> = self.mutes.values().cloned().collect();
         mutes.sort_by(|a, b| a.name.cmp(&b.name));
         if let Ok(text) = serde_json::to_string_pretty(&MutesFile { mutes }) {
@@ -474,55 +424,6 @@ pub fn append_log(path: &Path, line: &str) -> std::io::Result<()> {
     writeln!(f, "{line}")
 }
 
-/// `/tempmute`'s duration in milliseconds: a positive whole number and a unit, `s`, `m`, `h`, `d` or
-/// `w` (`10m`, `2h`, `1d`).
-pub fn parse_duration(text: &str) -> Option<i64> {
-    let unit = match text.chars().last()? {
-        's' => 1_000,
-        'm' => MINUTE,
-        'h' => 60 * MINUTE,
-        'd' => 24 * 60 * MINUTE,
-        'w' => 7 * 24 * 60 * MINUTE,
-        _ => return None,
-    };
-    let count: i64 = text[..text.len() - 1].parse().ok()?;
-    (count > 0).then(|| count.checked_mul(unit)).flatten()
-}
-
-/// The unit used when presenting a moderation duration to a player.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum DurationUnit {
-    Minute,
-    Hour,
-    Day,
-}
-
-/// A duration's rounded count and unit, shared by logs and translated replies.
-pub fn duration_parts(millis: i64) -> (i64, DurationUnit) {
-    let (unit, kind) = if millis <= 60 * MINUTE {
-        (MINUTE, DurationUnit::Minute)
-    } else if millis <= 48 * 60 * MINUTE {
-        (60 * MINUTE, DurationUnit::Hour)
-    } else {
-        (24 * 60 * MINUTE, DurationUnit::Day)
-    };
-    (
-        millis.div_euclid(unit) + i64::from(millis.rem_euclid(unit) > 0),
-        kind,
-    )
-}
-
-/// `millis` for logs, rounded up: minutes up to an hour, hours up to two days, then days.
-pub fn duration_text(millis: i64) -> String {
-    let (count, unit) = duration_parts(millis);
-    let unit = match unit {
-        DurationUnit::Minute => "minute",
-        DurationUnit::Hour => "hour",
-        DurationUnit::Day => "day",
-    };
-    format!("{count} {unit}{}", if count == 1 { "" } else { "s" })
-}
-
 pub fn now_millis() -> i64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)

crates/horizon-chat-filter/src/tests.rs

@@ -120,14 +120,14 @@ fn the_second_hit_mutes_and_the_third_bans() {
     let mut g = guard(Config::default());
     let id = 7;
     assert_eq!(g.strike(id, "Ann", NOW), (1, Action::Refused));
-    assert_eq!(g.muted(id, NOW), None);
+    assert_eq!(g.muted_until(id, NOW), None);
     let until = NOW + 3 * MIN + 10 * MIN;
     assert_eq!(
         g.strike(id, "Ann", NOW + 3 * MIN),
         (2, Action::Muted { until })
     );
-    assert_eq!(g.muted(id, NOW + 4 * MIN).unwrap().until, Some(until));
-    assert_eq!(g.muted(id, until), None);
+    assert_eq!(g.muted_until(id, NOW + 4 * MIN), Some(until));
+    assert_eq!(g.muted_until(id, until), None);
     // The time spent muted doesn't count: 8 minutes after the mute ended is still within the window.
     assert_eq!(
         g.strike(id, "Ann", until + 8 * MIN),
@@ -190,83 +190,15 @@ fn mutes_survive_a_restart_and_unmute_lifts_them() {
     let (_, action) = g.strike(5, "Dee", now);
     assert!(matches!(action, Action::Muted { .. }));
     let (mut again, _) = Guard::load(Config::default(), &dir);
-    assert!(again.muted(5, now).is_some());
+    assert!(again.muted_until(5, now).is_some());
     assert_eq!(again.unmute("dee").as_deref(), Some("Dee"));
     assert_eq!(again.unmute("dee"), None);
-    assert_eq!(again.muted(5, now), None);
-    // An operator's mutes are kept too, with who and why.
-    again.mute(6, "Eve", None, "Op", Some("spam".into()));
-    again.mute(7, "Fay", Some(now + MIN), "Op", None);
+    assert_eq!(again.muted_until(5, now), None);
     let (reloaded, _) = Guard::load(Config::default(), &dir);
-    assert_eq!(reloaded.muted(5, now), None);
-    let names: Vec<_> = reloaded
-        .mutes(now)
-        .iter()
-        .map(|m| m.name.as_str())
-        .collect();
-    assert_eq!(names, ["Eve", "Fay"]);
-    let eve = reloaded.muted(6, now).unwrap();
-    assert_eq!(
-        (eve.until, eve.by.as_deref(), eve.reason.as_deref()),
-        (None, Some("Op"), Some("spam"))
-    );
-    assert_eq!(reloaded.mutes(now + MIN).len(), 1);
+    assert_eq!(reloaded.muted_until(5, now), None);
     std::fs::remove_dir_all(&dir).unwrap();
 }
 
-#[test]
-fn a_mute_file_from_before_manual_mutes_still_loads() {
-    let saved: MutesFile = serde_json::from_str(
-        r#"{"mutes":[{"uuid":"00000000-0000-0000-0000-000000000005","name":"Dee","until":5}]}"#,
-    )
-    .unwrap();
-    assert_eq!(saved.mutes[0].until, Some(5));
-    assert_eq!(saved.mutes[0].by, None);
-}
-
-#[test]
-fn the_filter_never_shortens_an_operators_mute() {
-    let mut g = guard(Config::default());
-    g.mute(1, "Bo", None, "Op", None);
-    g.strike(1, "Bo", NOW);
-    g.strike(1, "Bo", NOW + MIN);
-    assert_eq!(
-        g.muted(1, NOW + 60 * MIN).unwrap().by.as_deref(),
-        Some("Op")
-    );
-    // A shorter one is replaced by the filter's.
-    g.mute(2, "Cy", Some(NOW + MIN), "Op", None);
-    g.strike(2, "Cy", NOW);
-    g.strike(2, "Cy", NOW);
-    assert_eq!(g.muted(2, NOW).unwrap().until, Some(NOW + 10 * MIN));
-}
-
-#[test]
-fn durations_read_and_print() {
-    assert_eq!(parse_duration("10m"), Some(10 * MIN));
-    assert_eq!(parse_duration("2h"), Some(120 * MIN));
-    assert_eq!(parse_duration("1d"), Some(24 * 60 * MIN));
-    assert_eq!(parse_duration("1w"), Some(7 * 24 * 60 * MIN));
-    assert_eq!(parse_duration("30s"), Some(30_000));
-    for bad in [
-        "",
-        "m",
-        "0m",
-        "-1m",
-        "1.5h",
-        "10",
-        "10x",
-        "99999999999999999w",
-    ] {
-        assert_eq!(parse_duration(bad), None, "{bad}");
-    }
-    assert_eq!(duration_text(61_000), "2 minutes");
-    assert_eq!(duration_text(MIN), "1 minute");
-    assert_eq!(duration_text(2 * 60 * MIN), "2 hours");
-    assert_eq!(duration_text(24 * 60 * MIN), "24 hours");
-    assert_eq!(duration_text(3 * 24 * 60 * MIN), "3 days");
-}
-
 #[test]
 fn a_missing_words_file_falls_back_to_the_built_in_list() {
     let config = Config {
@@ -319,27 +251,3 @@ fn a_message_costs_little() {
     }
     assert!(start.elapsed().as_millis() < 2000, "{:?}", start.elapsed());
 }
-
-#[test]
-fn an_allow_line_without_letters_allows_nothing() {
-    for line in ["!*", "!-*", "!", "!-"] {
-        let f = Filter::new(&format!("nigger\n{line}\n"));
-        assert!(f.matches("nigger"), "{line}");
-    }
-}
-
-#[test]
-fn duration_parts_preserve_rounding_without_overflow() {
-    for (millis, expected) in [
-        (1, (1, DurationUnit::Minute)),
-        (60_000, (1, DurationUnit::Minute)),
-        (61_000, (2, DurationUnit::Minute)),
-        (3_600_000, (60, DurationUnit::Minute)),
-        (3_600_001, (2, DurationUnit::Hour)),
-        (172_800_000, (48, DurationUnit::Hour)),
-        (172_800_001, (3, DurationUnit::Day)),
-        (i64::MAX, (106_751_991_168, DurationUnit::Day)),
-    ] {
-        assert_eq!(duration_parts(millis), expected);
-    }
-}

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

@@ -143,9 +143,7 @@ impl<'a> Fields<'a> {
     /// `RandomizableContainer.tryLoadLootTable` / `trySaveLootTable`; true when the
     /// block entity has a loot table (and so saves no items).
     fn loot_table(&mut self) -> bool {
-        let Some(table) =
-            text(self.input.get("LootTable")).and_then(|id| crate::identifier::normalize_id(&id))
-        else {
+        let Some(table) = text(self.input.get("LootTable")) else {
             return false;
         };
         self.put("LootTable", string(&table));
@@ -907,16 +905,6 @@ mod tests {
         assert_eq!(out.get("LootTable"), Some(&string("minecraft:chests/x")));
     }
 
-    #[test]
-    fn invalid_loot_table_leaves_items_intact() {
-        let out = canon(
-            "{id:\"minecraft:barrel\",x:1,y:2,z:3,LootTable:\"INVALID TABLE\",\
-             Items:[{Slot:0b,id:\"minecraft:stone\",count:1}]}",
-        );
-        assert!(out.get("Items").is_some());
-        assert!(out.get("LootTable").is_none());
-    }
-
     #[test]
     fn items_are_validated_and_sorted_by_slot() {
         let out = canon(

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

@@ -207,17 +207,15 @@ fn style_flag(v: Option<&Value>) -> Option<bool> {
     }
 }
 
-/// ExtraCodecs.UNTRUSTED_URI / Util.parseAndValidateUntrustedUri: http and
-/// https only, scheme case-insensitive. Every `open_url` a server sends must
-/// pass it: anything else (`file:`, a UNC path, a custom protocol handler)
-/// could start a program through the system's URL handler.
-pub fn untrusted_http_url(url: &str) -> bool {
+fn untrusted_http_url(url: &str) -> bool {
+    // ExtraCodecs.UNTRUSTED_URI / Util.parseAndValidateUntrustedUri: http and
+    // https only, scheme case-insensitive.
     url.split_once(':').is_some_and(|(scheme, _)| {
         scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
     })
 }
 
-/// `ClickEvent.CODEC` plus the legacy `value` field TextComponentHoverAndClickEventFix
+/// ClickEvent.CODEC plus the legacy `value` field TextComponentHoverAndClickEventFix
 /// renames (`url` / `command` / `page`).
 fn parse_click_event(e: &serde_json::Map<String, Value>) -> Option<crate::text::ClickEvent> {
     let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
@@ -251,13 +249,6 @@ fn parse_click_event(e: &serde_json::Map<String, Value>) -> Option<crate::text::
         Some("show_dialog") => e.get("dialog").map(|dialog| {
             crate::text::ClickEvent::ShowDialog(crate::scoreboard::json_to_tag(dialog))
         }),
-        Some("custom") => Some(crate::text::ClickEvent::Custom {
-            id: crate::identifier::parse_identifier(&text("id")?)?,
-            payload: e
-                .get("payload")
-                .filter(|value| !value.is_null())
-                .map(crate::scoreboard::json_to_tag),
-        }),
         _ => None,
     }
 }
@@ -266,7 +257,10 @@ fn parse_click_event(e: &serde_json::Map<String, Value>) -> Option<crate::text::
 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(|| hex_color(c));
+        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);
     style.bold = style_flag(o.get("bold"));
@@ -309,13 +303,6 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
     style
 }
 
-/// `TextColor.parseColor` for `#...`: `Integer.parseInt(rest, 16)` (so a sign
-/// and any digit count are accepted), kept only within `0..=0xFFFFFF`.
-pub(crate) fn hex_color(c: &str) -> Option<u32> {
-    let value = i64::from_str_radix(c.strip_prefix('#')?, 16).ok()?;
-    (0..=0xFF_FFFF).contains(&value).then_some(value as u32)
-}
-
 /// `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() {
@@ -498,33 +485,6 @@ pub fn name_text(tag: &Tag) -> Text {
 mod tests {
     use super::*;
 
-    #[test]
-    fn hex_color_follows_text_color_parse_color() {
-        for bad in [
-            "#1000000",
-            "#FFFFFFFF",
-            "#-FF",
-            "#",
-            "#zz",
-            "FFFFFF",
-            "#99999999999",
-        ] {
-            assert_eq!(hex_color(bad), None, "{bad}");
-        }
-        for (good, want) in [
-            ("#FFFFFF", 0xFFFFFF),
-            ("#000000", 0),
-            ("#F", 15),
-            ("#+FF", 255),
-            ("#-0", 0),
-        ] {
-            assert_eq!(hex_color(good), Some(want), "{good}");
-        }
-        let out = serde_json::json!({"text": "A", "color": "#1000000"});
-        let text = to_text(&out, &mut |_| Text::empty());
-        assert_eq!(text.spans[0].style.color, None);
-    }
-
     #[test]
     fn shadow_color_accepts_packed_and_rgba_styles() {
         let packed = serde_json::json!({"text": "A", "shadow_color": -16711936});
@@ -625,63 +585,6 @@ mod tests {
         assert_eq!(text.spans[0].style.underlined, Some(true));
     }
 
-    #[test]
-    fn custom_click_events_keep_payloads_and_inherit_to_inline_objects() {
-        use crate::text::ClickEvent;
-        use horizon_world::nbt::Tag;
-
-        for (payload, expected) in [
-            (None, None),
-            (Some(serde_json::Value::Null), None),
-            (Some(serde_json::json!(42)), Some(Tag::Int(42))),
-            (
-                Some(serde_json::json!({"shop": "potions", "amount": 3})),
-                Some(Tag::Compound(
-                    [
-                        ("amount".into(), Tag::Int(3)),
-                        ("shop".into(), Tag::String("potions".into())),
-                    ]
-                    .into_iter()
-                    .collect(),
-                )),
-            ),
-        ] {
-            let mut event = serde_json::json!({"action": "custom", "id": "test:shop"});
-            if let Some(payload) = payload {
-                event["payload"] = payload;
-            }
-            let component = serde_json::json!({
-                "text": "", "click_event": event,
-                "extra": [{"object": "atlas", "sprite": "minecraft:item/potion"}, "Shop"]
-            });
-            let text = to_text(&component, &mut |_| Text::empty());
-            for (_, style) in text.chars() {
-                assert_eq!(
-                    style.click,
-                    Some(ClickEvent::Custom {
-                        id: "test:shop".into(),
-                        payload: expected.clone(),
-                    })
-                );
-            }
-            let encoded = text.component();
-            let decoded = to_text(&encoded, &mut |_| Text::empty());
-            assert_eq!(decoded, text);
-            if expected.is_none() {
-                assert!(!encoded.to_string().contains("\"payload\""));
-            }
-        }
-        for id in ["Bad ID", "Uppercase:shop"] {
-            let text = to_text(
-                &serde_json::json!({
-                    "text": "Shop", "click_event": {"action": "custom", "id": id}
-                }),
-                &mut |_| Text::empty(),
-            );
-            assert_eq!(text.spans[0].style.click, None);
-        }
-    }
-
     #[test]
     fn the_font_is_inherited_and_kept() {
         let (v, _) =
@@ -721,15 +624,4 @@ mod tests {
         let (v, _) = parse_snbt("{n:1.5}").unwrap();
         assert_eq!(v["n"], Value::from(1.5));
     }
-
-    #[test]
-    fn name_text_preserves_legacy_and_decodes_components() {
-        let legacy = Tag::String("§6Golden Name".into());
-        let text = name_text(&legacy);
-        assert_eq!(text.plain(), "Golden Name");
-
-        let comp = Tag::compound([("text", Tag::String("Custom Name".into()))]);
-        let text = name_text(&comp);
-        assert_eq!(text.plain(), "Custom Name");
-    }
 }

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

@@ -125,51 +125,19 @@ pub const RULES: &[Rule] = &[
     b("universal_anger", "mobs", false),
     b("water_source_conversion", "updates", true),
 ];
-/// GameRules.MAX_MINECART_SPEED (26.3), available with minecart improvements.
-pub const MAX_MINECART_SPEED: Rule = i("max_minecart_speed", "misc", 8, 1, 1000);
-pub const MINECART_IMPROVEMENTS: &str = "minecraft:minecart_improvements";
-
-pub fn available_rules(minecart_improvements: bool) -> impl Iterator<Item = &'static Rule> {
-    RULES
-        .iter()
-        .chain(minecart_improvements.then_some(&MAX_MINECART_SPEED))
-}
-
 pub fn rule(name: &str) -> Option<&'static Rule> {
     let name = name.strip_prefix("minecraft:").unwrap_or(name);
-    available_rules(true).find(|r| r.name == name)
+    RULES.iter().find(|r| r.name == name)
 }
 
 /// Current values (defaults unless set).
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct GameRules {
     values: BTreeMap<&'static str, Value>,
-    minecart_improvements: bool,
 }
 impl GameRules {
-    pub fn with_features(features: &[String]) -> Self {
-        Self {
-            minecart_improvements: features.iter().any(|f| f == MINECART_IMPROVEMENTS),
-            ..Self::default()
-        }
-    }
-    /// GameRules.copy(enabledFeatures): keep available values, add defaults for
-    /// newly enabled rules and discard rules absent from the target feature set.
-    pub fn copy_with_features(&self, features: &[String]) -> Self {
-        let mut rules = Self::with_features(features);
-        for (&name, &value) in &self.values {
-            rules.set(name, value);
-        }
-        rules
-    }
-    pub fn available_rules(&self) -> impl Iterator<Item = &'static Rule> + use<> {
-        available_rules(self.minecart_improvements)
-    }
     pub fn get(&self, name: &str) -> Option<Value> {
         let r = rule(name)?;
-        if r.name == MAX_MINECART_SPEED.name && !self.minecart_improvements {
-            return None;
-        }
         Some(self.values.get(r.name).copied().unwrap_or(r.default))
     }
     pub fn bool(&self, name: &str) -> bool {
@@ -192,9 +160,7 @@ impl GameRules {
     }
     /// Set a rule; false if the name or value type is wrong.
     pub fn set(&mut self, name: &str, value: Value) -> bool {
-        let Some(r) = rule(name).filter(|r| self.get(r.name).is_some()) else {
-            return false;
-        };
+        let Some(r) = rule(name) else { return false };
         let ok = match (r.default, value) {
             (Value::Bool(_), Value::Bool(_)) => true,
             (Value::Int(_), Value::Int(v)) => (r.min..=r.max).contains(&v),
@@ -210,7 +176,8 @@ impl GameRules {
     /// Every rule's value by name without namespace, as `save::Level` holds
     /// them (booleans as 0 or 1).
     pub fn by_name(&self) -> BTreeMap<String, i32> {
-        self.available_rules()
+        RULES
+            .iter()
             .map(|r| {
                 let v = match self.values.get(r.name).copied().unwrap_or(r.default) {
                     Value::Bool(b) => i32::from(b),
@@ -222,8 +189,8 @@ impl GameRules {
     }
     /// GameRuleMap codec: `{data: {"minecraft:<rule>": value...}, DataVersion}`.
     pub fn to_nbt(&self) -> NamedTag {
-        let data: Vec<(horizon_world::nbt::JavaString, Tag)> = self
-            .available_rules()
+        let data: Vec<(horizon_world::nbt::JavaString, Tag)> = RULES
+            .iter()
             .map(|r| {
                 let v = self.values.get(r.name).copied().unwrap_or(r.default);
                 let tag = match v {
@@ -245,14 +212,11 @@ impl GameRules {
         }
     }
     pub fn from_nbt(root: &Tag) -> Self {
-        Self::from_nbt_with_features(root, &[])
-    }
-    pub fn from_nbt_with_features(root: &Tag, features: &[String]) -> Self {
-        let mut rules = Self::with_features(features);
+        let mut rules = Self::default();
         let Some(data) = root.get("data") else {
             return rules;
         };
-        for r in rules.available_rules() {
+        for r in RULES {
             let key = format!("minecraft:{}", r.name);
             let value = data.get(&key).or_else(|| data.get(r.name));
             match (r.default, value) {
@@ -268,18 +232,15 @@ impl GameRules {
         rules
     }
     pub fn load(world: &Path) -> Self {
-        Self::load_with_features(world, &[])
-    }
-    pub fn load_with_features(world: &Path, features: &[String]) -> Self {
         let Ok(bytes) = fs::read(world.join("data/minecraft/game_rules.dat")) else {
-            return Self::with_features(features);
+            return Self::default();
         };
         let Ok(raw) = Compression::Gzip.decode(&bytes, 16 << 20) else {
-            return Self::with_features(features);
+            return Self::default();
         };
         match nbt::read_named(&raw, Limits::default()) {
-            Ok((root, _)) => Self::from_nbt_with_features(&root.tag, features),
-            Err(_) => Self::with_features(features),
+            Ok((root, _)) => Self::from_nbt(&root.tag),
+            Err(_) => Self::default(),
         }
     }
     pub fn save(&self, world: &Path) -> crate::Result<()> {

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

@@ -79,243 +79,9 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/uk_ua.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/uk_ua.json")
             }
-            "assets/horizon/lang/hi_in.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/hi_in.json")
-            }
-            "assets/horizon/lang/id_id.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/id_id.json")
-            }
             "assets/horizon/lang/tr_tr.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/tr_tr.json")
             }
-            "assets/horizon/lang/ko_kr.json" | "assets/horizon/lang/ko.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ko_kr.json")
-            }
-            "assets/horizon/lang/hr_hr.json" | "assets/horizon/lang/hr.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/hr_hr.json")
-            }
-            "assets/horizon/lang/pt_pt.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/pt_pt.json")
-            }
-            "assets/horizon/lang/ur_pk.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ur_pk.json")
-            }
-            "assets/horizon/lang/fa_ir.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/fa_ir.json")
-            }
-            "assets/horizon/lang/he_il.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/he_il.json")
-            }
-            "assets/horizon/lang/hu_hu.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/hu_hu.json")
-            }
-            "assets/horizon/lang/ro_ro.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ro_ro.json")
-            }
-            "assets/horizon/lang/da_dk.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/da_dk.json")
-            }
-            "assets/horizon/lang/fi_fi.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/fi_fi.json")
-            }
-            "assets/horizon/lang/no_no.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/no_no.json")
-            }
-            "assets/horizon/lang/bg_bg.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/bg_bg.json")
-            }
-            "assets/horizon/lang/sk_sk.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/sk_sk.json")
-            }
-            "assets/horizon/lang/lt_lt.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/lt_lt.json")
-            }
-            "assets/horizon/lang/it_it.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/it_it.json")
-            }
-            "assets/horizon/lang/nl_nl.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/nl_nl.json")
-            }
-            "assets/horizon/lang/vi_vn.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/vi_vn.json")
-            }
-            "assets/horizon/lang/th_th.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/th_th.json")
-            }
-            "assets/horizon/lang/ja_jp.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ja_jp.json")
-            }
-            "assets/horizon/lang/ar_sa.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ar_sa.json")
-            }
-            "assets/horizon/lang/pt_br.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/pt_br.json")
-            }
-            "assets/horizon/lang/cs_cz.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/cs_cz.json")
-            }
-            "assets/horizon/lang/sv_se.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/sv_se.json")
-            }
-            "assets/horizon/lang/el_gr.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/el_gr.json")
-            }
-            "assets/horizon/lang/ca_es.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ca_es.json")
-            }
-            "assets/horizon/lang/et_ee.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/et_ee.json")
-            }
-            "assets/horizon/lang/lv_lv.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/lv_lv.json")
-            }
-            "assets/horizon/lang/sl_si.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/sl_si.json")
-            }
-            "assets/horizon/lang/sr_cs.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/sr_cs.json")
-            }
-            "assets/horizon/lang/is_is.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/is_is.json")
-            }
-            "assets/horizon/lang/af_za.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/af_za.json")
-            }
-            "assets/horizon/lang/ms_my.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ms_my.json")
-            }
-            "assets/horizon/lang/be_by.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/be_by.json")
-            }
-            "assets/horizon/lang/sr_sp.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/sr_sp.json")
-            }
-            "assets/horizon/lang/az_az.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/az_az.json")
-            }
-            "assets/horizon/lang/uz_uz.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/uz_uz.json")
-            }
-            "assets/horizon/lang/kk_kz.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/kk_kz.json")
-            }
-            "assets/horizon/lang/ka_ge.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ka_ge.json")
-            }
-            "assets/horizon/lang/hy_am.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/hy_am.json")
-            }
-            "assets/horizon/lang/bs_ba.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/bs_ba.json")
-            }
-            "assets/horizon/lang/mk_mk.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/mk_mk.json")
-            }
-            "assets/horizon/lang/sq_al.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/sq_al.json")
-            }
-            "assets/horizon/lang/cy_gb.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/cy_gb.json")
-            }
-            "assets/horizon/lang/ga_ie.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ga_ie.json")
-            }
-            "assets/horizon/lang/eu_es.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/eu_es.json")
-            }
-            "assets/horizon/lang/gl_es.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/gl_es.json")
-            }
-            "assets/horizon/lang/fil_ph.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/fil_ph.json")
-            }
-            "assets/horizon/lang/ta_in.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ta_in.json")
-            }
-            "assets/horizon/lang/mn_mn.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/mn_mn.json")
-            }
-            "assets/horizon/lang/lo_la.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/lo_la.json")
-            }
-            "assets/horizon/lang/so_so.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/so_so.json")
-            }
-            "assets/horizon/lang/fy_nl.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/fy_nl.json")
-            }
-            "assets/horizon/lang/gd_gb.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/gd_gb.json")
-            }
-            "assets/horizon/lang/lb_lu.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/lb_lu.json")
-            }
-            "assets/horizon/lang/ky_kg.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ky_kg.json")
-            }
-            "assets/horizon/lang/kn_in.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/kn_in.json")
-            }
-            "assets/horizon/lang/mt_mt.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/mt_mt.json")
-            }
-            "assets/horizon/lang/eo_uy.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/eo_uy.json")
-            }
-            "assets/horizon/lang/haw_us.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/haw_us.json")
-            }
-            "assets/horizon/lang/ig_ng.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ig_ng.json")
-            }
-            "assets/horizon/lang/la_la.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/la_la.json")
-            }
-            "assets/horizon/lang/tt_ru.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/tt_ru.json")
-            }
-            "assets/horizon/lang/yi_de.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/yi_de.json")
-            }
-            "assets/horizon/lang/yo_ng.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/yo_ng.json")
-            }
-            "assets/horizon/lang/ba_ru.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/ba_ru.json")
-            }
-            "assets/horizon/lang/br_fr.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/br_fr.json")
-            }
-            "assets/horizon/lang/cv_cu.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/cv_cu.json")
-            }
-            "assets/horizon/lang/fo_fo.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/fo_fo.json")
-            }
-            "assets/horizon/lang/fur_it.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/fur_it.json")
-            }
-            "assets/horizon/lang/li_li.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/li_li.json")
-            }
-            "assets/horizon/lang/lmo.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/lmo.json")
-            }
-            "assets/horizon/lang/oc_fr.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/oc_fr.json")
-            }
-            "assets/horizon/lang/sah_sah.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/sah_sah.json")
-            }
-            "assets/horizon/lang/se_no.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/se_no.json")
-            }
-            "assets/horizon/lang/szl.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/szl.json")
-            }
-            "assets/horizon/lang/vec_it.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/vec_it.json")
-            }
             "assets/horizon/lang/de_de.json" | "assets/horizon/lang/de_at.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/de_de.json")
             }
@@ -388,36 +154,6 @@ pub fn apply_deprecated(map: &mut HashMap<String, String>, json: &[u8]) {
     }
 }
 
-/// `Language.loadFromJson` for one `lang/<code>.json`: its entries go into `map` in file order.
-/// A file that is plain JSON reads as before; any other goes through Gson's lenient reader
-/// (`#`, `//` and `/* */` comments, unquoted or single-quoted names and values, raw control
-/// characters in strings, `=` or `=>` and `;`), which vanilla reads lang files with (expected
-/// from `Language.loadFromJson`, Gson). A file that is not JSON even so adds nothing; a value
-/// that is not a string, number or boolean (`GsonHelper.convertToString`) ends the file there.
-fn read_lang_file(bytes: &[u8], map: &mut HashMap<String, String>) {
-    use horizon_world::datafix::json::{Json, parse_lenient};
-    if let Ok(entries) = serde_json::from_slice::<HashMap<String, String>>(bytes) {
-        map.extend(entries);
-        return;
-    }
-    let text = String::from_utf8_lossy(bytes);
-    // Gson's JsonReader skips a leading byte order mark.
-    let text = text.strip_prefix('\u{feff}').unwrap_or(&text);
-    let utf16: Vec<u16> = text.encode_utf16().collect();
-    let Some(Json::Obj(entries)) = parse_lenient(&utf16) else {
-        return;
-    };
-    for (key, value) in entries {
-        let value = match value {
-            Json::Str(s) => String::from_utf16_lossy(&s),
-            Json::Num(n) => n,
-            Json::Bool(b) => b.to_string(),
-            Json::Null | Json::Arr(_) | Json::Obj(_) => break,
-        };
-        map.insert(String::from_utf16_lossy(&key), value);
-    }
-}
-
 impl Language {
     /// ClientLanguage.loadFrom: en_us first, then the selected language, each
     /// from every namespace and every source in priority order (later sources
@@ -443,7 +179,9 @@ impl Language {
                     else {
                         continue;
                     };
-                    read_lang_file(&bytes, &mut map);
+                    if let Ok(entries) = serde_json::from_slice::<HashMap<String, String>>(&bytes) {
+                        map.extend(entries);
+                    }
                 }
             }
         }
@@ -903,165 +641,4 @@ mod tests {
             ["en_us", "fr_fr"]
         );
     }
-
-    fn read(body: &str) -> HashMap<String, String> {
-        let mut map = HashMap::new();
-        read_lang_file(body.as_bytes(), &mut map);
-        map
-    }
-    fn entries(pairs: &[(&str, &str)]) -> HashMap<String, String> {
-        pairs
-            .iter()
-            .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
-            .collect()
-    }
-
-    #[test]
-    fn a_plain_json_lang_file_reads_as_before() {
-        let body = "{\"a\": \"Apple \\\"quoted\\\" \\u00e9\", \"b\": \"\", \"a\": \"Again\"}";
-        let strict: HashMap<String, String> = serde_json::from_str(body).unwrap();
-        assert_eq!(read(body), strict);
-        assert_eq!(read(body), entries(&[("a", "Again"), ("b", "")]));
-    }
-
-    #[test]
-    fn lang_files_read_with_comments() {
-        let want = entries(&[("a", "Apple"), ("b", "Banana # not a comment // either")]);
-        for body in [
-            "# header\n{\n# a comment\n\"a\": \"Apple\",\n\"b\": \"Banana # not a comment // either\"\n}\n",
-            "// header\n{\"a\": \"Apple\", // after\n\"b\": \"Banana # not a comment // either\"}",
-            "/* header\n over lines */{\"a\": /* inline */ \"Apple\", \"b\": \"Banana # not a comment // either\"}",
-        ] {
-            assert_eq!(read(body), want, "{body}");
-        }
-    }
-
-    #[test]
-    fn lang_files_read_unquoted_and_single_quoted_names_and_values() {
-        assert_eq!(
-            read("{a: 'Apple', 'b': \"Banana\", c: Cherry}"),
-            entries(&[("a", "Apple"), ("b", "Banana"), ("c", "Cherry")])
-        );
-        // A single-quoted string may hold a double quote, and the reverse.
-        assert_eq!(
-            read("{'a': 'say \"hi\"', \"b\": \"it's\"}"),
-            entries(&[("a", "say \"hi\""), ("b", "it's")])
-        );
-    }
-
-    #[test]
-    fn lang_files_read_raw_control_characters_in_strings() {
-        assert_eq!(
-            read("{\"a\": \"tab\there\", \"b\": \"two\nlines\"}"),
-            entries(&[("a", "tab\there"), ("b", "two\nlines")])
-        );
-    }
-
-    #[test]
-    fn lang_files_read_gson_separators_and_a_byte_order_mark() {
-        assert_eq!(
-            read("\u{feff}{\"a\" = \"Apple\"; \"b\" => \"Banana\"}"),
-            entries(&[("a", "Apple"), ("b", "Banana")])
-        );
-        // A trailing comma before `}` is not JSON even to Gson's lenient reader.
-        assert_eq!(read("{# c\n\"a\": \"Apple\",}"), HashMap::new());
-    }
-
-    #[test]
-    fn numbers_and_booleans_read_as_their_text() {
-        // GsonHelper.convertToString: a primitive reads as its text.
-        assert_eq!(
-            read("{\"a\": 1.50, \"b\": true, \"c\": -2e3}"),
-            entries(&[("a", "1.50"), ("b", "true"), ("c", "-2e3")])
-        );
-    }
-
-    #[test]
-    fn a_value_that_is_no_text_ends_the_file_there() {
-        assert_eq!(
-            read("# c\n{\"a\": \"Apple\", \"b\": [\"x\"], \"c\": \"Cherry\"}"),
-            entries(&[("a", "Apple")])
-        );
-        assert_eq!(read("{\"a\": null, \"b\": \"Banana\"}"), HashMap::new());
-    }
-
-    #[test]
-    fn a_lang_file_that_is_not_json_adds_nothing() {
-        for body in [
-            "# c\n{\"a\": \"Apple\"",
-            "[\"a\"]",
-            "\"a\"",
-            "",
-            "{\"a\": \"Apple\"} {",
-        ] {
-            assert_eq!(read(body), HashMap::new(), "{body:?}");
-        }
-    }
-
-    #[test]
-    fn a_pack_lang_file_with_comments_layers_over_english() {
-        let base = Mem(HashMap::from([(
-            "assets/minecraft/lang/en_us.json".into(),
-            br#"{"a":"Apple","b":"Banana"}"#.to_vec(),
-        )]));
-        let pack = Mem(HashMap::from([(
-            "assets/minecraft/lang/fr_fr.json".into(),
-            b"{\n# Fruits\n\"a\": \"Pomme\"\n}\n".to_vec(),
-        )]));
-        let sources: [&dyn ResourceSource; 2] = [&base, &pack];
-        let fr = Language::load(&sources, "fr_fr");
-        assert_eq!(fr.get("a"), Some("Pomme"));
-        assert_eq!(fr.get("b"), Some("Banana"));
-    }
-
-    /// Every lang file of a downloaded pack, e.g. BACAP Language Pack:
-    /// `HORIZON_LANG_PACK_DIR=<pack>/assets/minecraft/lang cargo test -p horizon-client-core
-    /// lang::tests::every_lang_file_of_a_pack_reads -- --ignored --nocapture`.
-    #[test]
-    #[ignore = "needs a downloaded pack in HORIZON_LANG_PACK_DIR"]
-    fn every_lang_file_of_a_pack_reads() {
-        let Ok(dir) = std::env::var("HORIZON_LANG_PACK_DIR") else {
-            return;
-        };
-        let mut failed = Vec::new();
-        let mut paths: Vec<_> = std::fs::read_dir(dir)
-            .unwrap()
-            .map(|e| e.unwrap().path())
-            .collect();
-        paths.sort();
-        for path in paths {
-            let bytes = std::fs::read(&path).unwrap();
-            let strict = serde_json::from_slice::<HashMap<String, String>>(&bytes).is_ok();
-            let mut map = HashMap::new();
-            read_lang_file(&bytes, &mut map);
-            // An independent count: the distinct `"name":` that start a line.
-            let text = String::from_utf8_lossy(&bytes);
-            let names: std::collections::HashSet<&str> = text
-                .lines()
-                .filter_map(|line| {
-                    let rest = line.trim_start().strip_prefix('"')?;
-                    let mut escaped = false;
-                    let end = rest.char_indices().find_map(|(i, c)| {
-                        let close = c == '"' && !escaped;
-                        escaped = c == '\\' && !escaped;
-                        close.then_some(i)
-                    })?;
-                    rest[end + 1..]
-                        .trim_start()
-                        .starts_with(':')
-                        .then(|| &rest[..end])
-                })
-                .collect();
-            println!(
-                "{}: strict {strict}, {} keys, {} names",
-                path.display(),
-                map.len(),
-                names.len()
-            );
-            if map.is_empty() || map.len() != names.len() {
-                failed.push(path);
-            }
-        }
-        assert!(failed.is_empty(), "{failed:?}");
-    }
 }

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

@@ -79,65 +79,28 @@ fn elements(tag: &Tag) -> Option<Vec<Tag>> {
         _ => return None,
     })
 }
-/// `DoubleTag.intValue` / `FloatTag.intValue` floor before the i32 conversion;
-/// integral tags use their intValue narrowing. Byte arrays then keep the low byte.
-fn int_value(t: &Tag) -> Option<i32> {
-    Some(match t {
-        Tag::Byte(v) => i32::from(*v),
-        Tag::Short(v) => i32::from(*v),
-        Tag::Int(v) => *v,
-        Tag::Long(v) => *v as i32,
-        Tag::Float(v) => f32::from_bits(*v).floor() as i32,
-        Tag::Double(v) => f64::from_bits(*v).floor() as i32,
-        _ => return None,
-    })
-}
-/// `FloatTag.longValue` truncates; `DoubleTag.longValue` floors before narrowing.
-fn long_value(t: &Tag) -> Option<i64> {
-    Some(match t {
-        Tag::Byte(v) => i64::from(*v),
-        Tag::Short(v) => i64::from(*v),
-        Tag::Int(v) => i64::from(*v),
-        Tag::Long(v) => *v,
-        // FloatTag.longValue truncates; DoubleTag.longValue floors first.
-        Tag::Float(v) => f32::from_bits(*v) as i64,
-        Tag::Double(v) => f64::from_bits(*v).floor() as i64,
-        _ => return None,
-    })
-}
-#[derive(Clone, Copy)]
-enum ElementKind {
-    List,
-    NumericArray,
-}
-impl ElementKind {
-    // Admission only: arrays require NumericTag; lists accept every tag type.
-    fn accepts(self, value: &Tag) -> bool {
-        matches!(self, Self::List)
-            || matches!(
-                value,
-                Tag::Byte(_)
-                    | Tag::Short(_)
-                    | Tag::Int(_)
-                    | Tag::Long(_)
-                    | Tag::Float(_)
-                    | Tag::Double(_)
-            )
+fn number(t: &Tag) -> Option<i64> {
+    match t {
+        Tag::Byte(v) => Some(i64::from(*v)),
+        Tag::Short(v) => Some(i64::from(*v)),
+        Tag::Int(v) => Some(i64::from(*v)),
+        Tag::Long(v) => Some(*v),
+        _ => None,
     }
 }
-/// Rust view adapter: run `f` over the elements, then write arrays using their numeric accessor.
+/// Run `f` over the elements of a list/array, writing array results back.
 /// None when `tag` is not list-like.
-fn with_elements<R>(tag: &mut Tag, f: impl FnOnce(&mut Vec<Tag>, ElementKind) -> R) -> Option<R> {
+fn with_elements<R>(tag: &mut Tag, f: impl FnOnce(&mut Vec<Tag>) -> R) -> Option<R> {
     match tag {
-        Tag::List(l) => Some(f(l, ElementKind::List)),
+        Tag::List(l) => Some(f(l)),
         Tag::ByteArray(_) | Tag::IntArray(_) | Tag::LongArray(_) => {
             let mut v = elements(tag)?;
-            let r = f(&mut v, ElementKind::NumericArray);
+            let r = f(&mut v);
+            let nums: Vec<i64> = v.iter().filter_map(number).collect();
             match tag {
-                // Float/double byteValue uses intValue's floor, then narrows.
-                Tag::ByteArray(a) => *a = v.iter().filter_map(int_value).map(|n| n as u8).collect(),
-                Tag::IntArray(a) => *a = v.iter().filter_map(int_value).collect(),
-                Tag::LongArray(a) => *a = v.iter().filter_map(long_value).collect(),
+                Tag::ByteArray(a) => *a = nums.iter().map(|n| *n as u8).collect(),
+                Tag::IntArray(a) => *a = nums.iter().map(|n| *n as i32).collect(),
+                Tag::LongArray(a) => *a = nums,
                 _ => {}
             }
             Some(r)
@@ -194,20 +157,6 @@ impl NbtPath {
     pub fn is_empty(&self) -> bool {
         self.nodes.is_empty()
     }
-    /// Whether this selects a compound-field chain, including filtered or quoted fields.
-    /// Matching a root or child does not change that subtree's writer provenance.
-    pub fn is_field_path(&self, fields: &[&str]) -> bool {
-        let mut fields = fields.iter();
-        for node in &self.nodes {
-            match node {
-                Node::MatchRoot(_) => {}
-                Node::Child(name) | Node::MatchChild(name, _)
-                    if fields.next().copied() == Some(name.as_str()) => {}
-                _ => return false,
-            }
-        }
-        fields.next().is_none()
-    }
     fn not_found(&self, node: usize) -> PathError {
         let end = self.ends[node];
         PathError::new(
@@ -400,7 +349,7 @@ impl NbtPath {
         });
         removed
     }
-    /// `NbtPathArgument.NbtPath.insert`: insert accepted tags into every reached collection.
+    /// `insert` (also append and prepend): into every list the path reaches.
     pub fn insert(
         &self,
         index: i32,
@@ -423,23 +372,19 @@ impl NbtPath {
                 return;
             }
             let shown = crate::snbt::to_snbt(target);
-            let result = with_elements(target, |list, kind| {
+            let result = with_elements(target, |list| {
                 let start = if index < 0 {
                     list.len() as i64 + i64::from(index) + 1
                 } else {
                     i64::from(index)
                 };
                 let mut any = false;
-                let mut at = start;
-                for v in values {
-                    if !kind.accepts(v) {
-                        continue;
-                    }
+                for (n, v) in values.iter().enumerate() {
+                    let at = start + n as i64;
                     if at < 0 || at as usize > list.len() {
                         return Err(CollectionError::InvalidIndex(at as i32));
                     }
                     list.insert(at as usize, v.clone());
-                    at += 1;
                     any = true;
                 }
                 Ok(any)
@@ -483,8 +428,7 @@ fn preferred_parent(node: &Node) -> Tag {
         _ => Tag::Compound(Compound::new()),
     }
 }
-/// Children of `parent`; the array creation arm follows
-/// `NbtPathArgument.AllElementsNode.getOrCreateTag` admission.
+/// `getOrCreateTag` (or `getTag` without `create`): the children of `parent`.
 fn step_mut(
     node: &Node,
     parent: &mut Tag,
@@ -524,14 +468,11 @@ fn step_mut(
         }
         Node::AllElements => {
             let make = create;
-            let _ = with_elements(parent, |list, kind| {
+            let _ = with_elements(parent, |list| {
                 if list.is_empty() {
                     if let Some(make) = make {
-                        let value = make();
-                        if kind.accepts(&value) {
-                            list.push(value);
-                            out(&mut list[0]);
-                        }
+                        list.push(make());
+                        out(&mut list[0]);
                     }
                 } else {
                     for t in list.iter_mut() {
@@ -541,7 +482,7 @@ fn step_mut(
             });
         }
         Node::Index(i) => {
-            let _ = with_elements(parent, |list, _kind| {
+            let _ = with_elements(parent, |list| {
                 let n = list.len() as i64;
                 let idx = if *i < 0 {
                     n + i64::from(*i)
@@ -577,8 +518,7 @@ fn step_mut(
         }
     }
 }
-/// Element setters follow `NbtPathArgument.AllElementsNode.setTag` and
-/// `NbtPathArgument.IndexedElementNode.setTag`; object nodes replace their children.
+/// `Node.setTag`: replace the child(ren) of `parent` with `value`.
 fn set_tag(node: &Node, parent: &mut Tag, value: &Tag) -> usize {
     match node {
         Node::Child(name) => {
@@ -598,36 +538,29 @@ fn set_tag(node: &Node, parent: &mut Tag, value: &Tag) -> usize {
             }
             0
         }
-        Node::AllElements => with_elements(parent, |list, kind| {
-            let len = list.len();
-            if len == 0 {
-                if kind.accepts(value) {
-                    list.push(value.clone());
-                }
-                // AllElementsNode returns 1 here even when addTag rejects.
+        Node::AllElements => with_elements(parent, |list| {
+            if list.is_empty() {
+                list.push(value.clone());
                 return 1;
             }
-            // Compare the original tags, before numeric conversion.
             let changed = list.iter().filter(|t| *t != value).count();
             if changed == 0 {
                 return 0;
             }
-            list.clear();
-            if !kind.accepts(value) {
-                return 0;
+            for t in list.iter_mut() {
+                *t = value.clone();
             }
-            list.resize(len, value.clone());
             changed
         })
         .unwrap_or(0),
-        Node::Index(i) => with_elements(parent, |list, kind| {
+        Node::Index(i) => with_elements(parent, |list| {
             let n = list.len() as i64;
             let idx = if *i < 0 {
                 n + i64::from(*i)
             } else {
                 i64::from(*i)
             };
-            if (0..n).contains(&idx) && list[idx as usize] != *value && kind.accepts(value) {
+            if (0..n).contains(&idx) && list[idx as usize] != *value {
                 list[idx as usize] = value.clone();
                 1
             } else {
@@ -653,7 +586,6 @@ fn set_tag(node: &Node, parent: &mut Tag, value: &Tag) -> usize {
         Node::MatchRoot(_) => 0,
     }
 }
-/// Removal arms, including `NbtPathArgument.AllElementsNode.removeTag`.
 fn remove_tag(node: &Node, parent: &mut Tag) -> usize {
     match node {
         Node::Child(name) => match parent {
@@ -671,13 +603,13 @@ fn remove_tag(node: &Node, parent: &mut Tag) -> usize {
             }
             _ => 0,
         },
-        Node::AllElements => with_elements(parent, |l, _kind| {
+        Node::AllElements => with_elements(parent, |l| {
             let n = l.len();
             l.clear();
             n
         })
         .unwrap_or(0),
-        Node::Index(i) => with_elements(parent, |l, _kind| {
+        Node::Index(i) => with_elements(parent, |l| {
             let n = l.len() as i64;
             let idx = if *i < 0 {
                 n + i64::from(*i)
@@ -840,25 +772,6 @@ fn parse_compound(text: &str, i: usize) -> Result<(Tag, usize), PathError> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    #[test]
-    fn field_provenance_handles_quotes_and_filters_without_matching_lists() {
-        for text in [
-            "blockState.properties",
-            "\"blockState\".\"properties\"",
-            "{source:1b}.blockState.properties",
-            "blockState{id:\"minecraft:piston_head\"}.properties",
-        ] {
-            let path = NbtPath::parse(text).unwrap();
-            assert!(path.is_field_path(&["blockState", "properties"]));
-            assert!(!path.is_field_path(&["blockState"]));
-        }
-        assert!(NbtPath::parse("{source:1b}").unwrap().is_field_path(&[]));
-        assert!(
-            !NbtPath::parse("blockState[].properties")
-                .unwrap()
-                .is_field_path(&["blockState", "properties"])
-        );
-    }
 
     fn tag(s: &str) -> Tag {
         parse_snbt(s).unwrap().0
@@ -974,100 +887,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn numeric_array_edits_use_the_destination_numeric_accessor() {
-        for (initial, value, inserted, indexed, all) in [
-            (
-                "{v:[B;1b,2b]}",
-                "-3.5f",
-                "{v:[B;1b,-4b,2b]}",
-                "{v:[B;-4b,2b]}",
-                "{v:[B;-4b,-4b]}",
-            ),
-            (
-                "{v:[B;1b,2b]}",
-                "-3.5d",
-                "{v:[B;1b,-4b,2b]}",
-                "{v:[B;-4b,2b]}",
-                "{v:[B;-4b,-4b]}",
-            ),
-            (
-                "{v:[I;1,2]}",
-                "-3.5f",
-                "{v:[I;1,-4,2]}",
-                "{v:[I;-4,2]}",
-                "{v:[I;-4,-4]}",
-            ),
-            (
-                "{v:[I;1,2]}",
-                "-3.5d",
-                "{v:[I;1,-4,2]}",
-                "{v:[I;-4,2]}",
-                "{v:[I;-4,-4]}",
-            ),
-            (
-                "{v:[L;1L,2L]}",
-                "-3.5f",
-                "{v:[L;1L,-3L,2L]}",
-                "{v:[L;-3L,2L]}",
-                "{v:[L;-3L,-3L]}",
-            ),
-            (
-                "{v:[L;1L,2L]}",
-                "-3.5d",
-                "{v:[L;1L,-4L,2L]}",
-                "{v:[L;-4L,2L]}",
-                "{v:[L;-4L,-4L]}",
-            ),
-        ] {
-            let value = tag(value);
-            let mut root = tag(initial);
-            assert_eq!(
-                path("v")
-                    .insert(1, &mut root, std::slice::from_ref(&value))
-                    .unwrap(),
-                1
-            );
-            assert_eq!(root, tag(inserted));
-            let mut root = tag(initial);
-            assert_eq!(path("v[0]").set(&mut root, &value).unwrap(), 1);
-            assert_eq!(root, tag(indexed));
-            let mut root = tag(initial);
-            assert_eq!(path("v[]").set(&mut root, &value).unwrap(), 2);
-            assert_eq!(root, tag(all));
-        }
-    }
-
-    #[test]
-    fn numeric_arrays_reject_nonnumeric_insert_and_indexed_set() {
-        for initial in ["{v:[B;1b,2b]}", "{v:[I;1,2]}", "{v:[L;1L,2L]}"] {
-            let original = tag(initial);
-            let value = tag("\"bad\"");
-            for index in [0, 99, -99] {
-                let mut root = original.clone();
-                assert_eq!(
-                    path("v")
-                        .insert(index, &mut root, std::slice::from_ref(&value))
-                        .unwrap(),
-                    0
-                );
-                assert_eq!(root, original);
-            }
-            let mut root = original.clone();
-            assert_eq!(path("v[0]").set(&mut root, &value).unwrap(), 0);
-            assert_eq!(root, original);
-        }
-    }
-
-    #[test]
-    fn empty_array_wildcard_set_preserves_vanillas_count_on_rejection() {
-        for initial in ["{v:[B;]}", "{v:[I;]}", "{v:[L;]}"] {
-            let mut root = tag(initial);
-            assert_eq!(path("v[]").set(&mut root, &tag("\"bad\"")).unwrap(), 1);
-            assert_eq!(root, tag(initial));
-        }
-    }
-
     #[test]
     fn partial_comparison() {
         let actual = tag("{a:1,b:{c:[1,2,3],d:\"x\"},e:2}");

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

@@ -173,16 +173,6 @@ impl Registries {
         fill(&mut self.templates, "templates");
         fill(&mut self.persistent_components, "persistent_components");
         fill(&mut self.learnable_recipes, "learnable_recipes");
-        if self.summonable.is_empty() {
-            self.summonable = strings(&r["summonable"]);
-            self.summonable.sort();
-            self.summonable.dedup();
-        }
-        if self.entity_types.is_empty() {
-            self.entity_types = strings(&r["entity_types"]);
-            self.entity_types.sort();
-            self.entity_types.dedup();
-        }
         const RELOADED: [&str; 5] = [
             "minecraft:advancement",
             "minecraft:recipe",
@@ -246,16 +236,6 @@ impl Registries {
         fill(&mut self.templates, &e.templates);
         fill(&mut self.persistent_components, &e.persistent_components);
         fill(&mut self.learnable_recipes, &e.learnable_recipes);
-        if self.summonable.is_empty() {
-            self.summonable.clone_from(&e.summonable);
-            self.summonable.sort();
-            self.summonable.dedup();
-        }
-        if self.entity_types.is_empty() {
-            self.entity_types.clone_from(&e.entity_types);
-            self.entity_types.sort();
-            self.entity_types.dedup();
-        }
         for (name, ids) in &e.by_registry {
             if !self.by_registry.contains_key(name) {
                 self.by_registry.insert(name.clone(), ids.clone());

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

@@ -107,7 +107,10 @@ pub fn style_from_json(v: &Value) -> Style {
     let mut s = Style::default();
     let Some(o) = v.as_object() else { return s };
     if let Some(c) = o.get("color").and_then(Value::as_str) {
-        s.color = text::named_color(c).or_else(|| component::hex_color(c));
+        s.color = text::named_color(c).or_else(|| {
+            c.strip_prefix('#')
+                .and_then(|h| u32::from_str_radix(h, 16).ok())
+        });
     }
     s.shadow_color = o.get("shadow_color").and_then(component::shadow_color);
     let flag = |k: &str| o.get(k).and_then(Value::as_bool);
@@ -1338,9 +1341,9 @@ fn decompose(c: &Comp) -> (serde_json::Map<String, Value>, Vec<Comp>) {
                     }
                     "color" => {
                         let color = v.as_str().map(|s| match s.strip_prefix('#') {
-                            Some(_) => match component::hex_color(s) {
-                                Some(rgb) => format!("#{rgb:06X}"),
-                                None => s.to_owned(),
+                            Some(hex) => match u32::from_str_radix(hex, 16) {
+                                Ok(rgb) => format!("#{rgb:06X}"),
+                                Err(_) => s.to_owned(),
                             },
                             None => s.to_owned(),
                         });

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

@@ -8,20 +8,11 @@ pub use horizon_world::snbt_text::{java_double, java_float, quote_and_escape, to
 
 // ---- the coloured form -----------------------------------------------------
 
-/// Writer provenance for a live moving-piston command read, or its selected subtree.
-#[derive(Clone, Copy)]
-pub enum PistonPart {
-    Entity,
-    State,
-    Properties,
-}
-
 struct Pretty {
     indentation: String,
     result: Text,
     indent_depth: usize,
     depth: usize,
-    piston: Option<PistonPart>,
 }
 fn is_numeric(t: &Tag) -> bool {
     matches!(
@@ -67,10 +58,6 @@ impl Pretty {
         self.lit("]", None);
     }
     fn sub(&mut self, tag: &Tag, indent: bool) {
-        self.sub_with(tag, indent, None);
-    }
-    fn sub_with(&mut self, tag: &Tag, indent: bool, piston: Option<PistonPart>) {
-        let previous = std::mem::replace(&mut self.piston, piston);
         if indent {
             self.indent_depth += 1;
         }
@@ -80,7 +67,6 @@ impl Pretty {
             self.indent_depth -= 1;
         }
         self.depth -= 1;
-        self.piston = previous;
     }
     fn visit(&mut self, tag: &Tag) {
         match tag {
@@ -171,11 +157,7 @@ impl Pretty {
                 "\n"
             };
             let n = c.len();
-            let entries = match self.piston {
-                Some(part) => piston_hash_order(c, part),
-                None => java_hash_order(c),
-            };
-            for (i, (k, v)) in entries.into_iter().enumerate() {
+            for (i, (k, v)) in java_hash_order(c).into_iter().enumerate() {
                 self.lit(&entry, None);
                 let key = string_of(k);
                 if !key.is_empty()
@@ -189,12 +171,7 @@ impl Pretty {
                 }
                 self.lit(":", None);
                 self.lit(" ", None);
-                let child = match (self.piston, key.as_str()) {
-                    (Some(PistonPart::Entity), "blockState") => Some(PistonPart::State),
-                    (Some(PistonPart::State), "properties") => Some(PistonPart::Properties),
-                    _ => None,
-                };
-                self.sub_with(v, true, child);
+                self.sub(v, true);
                 if i + 1 < n {
                     self.lit(",", None);
                     self.lit(spacing, None);
@@ -209,61 +186,22 @@ impl Pretty {
         }
     }
 }
-fn hash_bucket(len: usize, key: &horizon_world::nbt::JavaString) -> usize {
-    let mut capacity = 16usize;
-    while len > capacity * 3 / 4 {
-        capacity *= 2;
-    }
-    let h = string_of(key)
-        .encode_utf16()
-        .fold(0u32, |h, ch| h.wrapping_mul(31).wrapping_add(u32::from(ch)));
-    ((h ^ (h >> 16)) as usize) & (capacity - 1)
-}
-fn piston_hash_order(
-    c: &horizon_world::nbt::Compound,
-    part: PistonPart,
-) -> Vec<(&horizon_world::nbt::JavaString, &Tag)> {
-    let mut entries: Vec<_> = c.iter().collect();
-    match part {
-        PistonPart::Entity => {
-            // saveAdditional, then the base's components and saveMetadata.
-            let fields = [
-                "blockState",
-                "facing",
-                "progress",
-                "extending",
-                "source",
-                "components",
-                "id",
-                "x",
-                "y",
-                "z",
-            ];
-            entries.sort_by_key(|(k, _)| {
-                (
-                    hash_bucket(c.len(), k),
-                    fields
-                        .iter()
-                        .position(|s| *s == string_of(k))
-                        .unwrap_or(fields.len()),
-                )
-            });
-        }
-        PistonPart::Properties => {
-            // StateDefinition builds property codecs in sorted-name order.
-            // DFU's nested map-pair encoder writes the second codec first.
-            entries.sort_by_key(|(k, _)| (hash_bucket(c.len(), k), std::cmp::Reverse(*k)));
-        }
-        PistonPart::State => return java_hash_order(c),
-    }
-    entries
-}
 /// The iteration order of the `HashMap<String, Tag>` a `CompoundTag` holds,
 /// for a map that grew to its size by insertion: buckets by
 /// `HashMap.hash(String.hashCode())`, keys sharing a bucket in key order.
 pub fn java_hash_order(
     c: &horizon_world::nbt::Compound,
 ) -> Vec<(&horizon_world::nbt::JavaString, &Tag)> {
+    let mut capacity = 16usize;
+    while c.len() > capacity * 3 / 4 {
+        capacity *= 2;
+    }
+    let bucket = |k: &horizon_world::nbt::JavaString| {
+        let h = string_of(k)
+            .encode_utf16()
+            .fold(0u32, |h, ch| h.wrapping_mul(31).wrapping_add(u32::from(ch)));
+        ((h ^ (h >> 16)) as usize) & (capacity - 1)
+    };
     // Keys sharing a bucket iterate in insertion order: the order vanilla's
     // savers write them, as far as it is known here.
     const WRITE_ORDER: &[&str] = &[
@@ -330,7 +268,7 @@ pub fn java_hash_order(
             .unwrap_or(WRITE_ORDER.len())
     };
     let mut entries: Vec<_> = c.iter().collect();
-    entries.sort_by_key(|(k, _)| (hash_bucket(c.len(), k), rank(k)));
+    entries.sort_by_key(|(k, _)| (bucket(k), rank(k)));
     entries
 }
 /// `NbtUtils.toPrettyComponent`: the coloured, unindented form.
@@ -343,19 +281,6 @@ pub fn pretty_indented(tag: &Tag, indentation: &str) -> Text {
         result: Text::empty(),
         indent_depth: 0,
         depth: 0,
-        piston: None,
-    };
-    p.visit(tag);
-    p.result
-}
-/// Command-only writer order; ordinary pretty printing keeps its existing policy.
-pub fn pretty_piston(tag: &Tag, part: PistonPart) -> Text {
-    let mut p = Pretty {
-        indentation: String::new(),
-        result: Text::empty(),
-        indent_depth: 0,
-        depth: 0,
-        piston: Some(part),
     };
     p.visit(tag);
     p.result
@@ -370,33 +295,6 @@ mod tests {
         to_snbt(&parse_snbt(s).unwrap().0)
     }
     #[test]
-    fn live_piston_writer_order_does_not_change_default_pretty() {
-        let tag = parse_snbt(
-            r#"{id:"minecraft:piston",blockState:{id:"minecraft:piston_head",properties:{facing:"east",short:"false",type:"normal"}},components:{},x:1,y:100,z:0,facing:5b,progress:0.0f,source:1b,extending:1b}"#,
-        ).unwrap().0;
-        let ordinary = r#"{blockState: {id: "minecraft:piston_head", properties: {facing: "east", short: "false", type: "normal"}}, components: {}, x: 1, facing: 5b, progress: 0.0f, y: 100, z: 0, id: "minecraft:piston", source: 1b, extending: 1b}"#;
-        assert_eq!(pretty(&tag).plain(), ordinary);
-        assert_eq!(
-            pretty_piston(&tag, PistonPart::Entity).plain(),
-            r#"{blockState: {id: "minecraft:piston_head", properties: {short: "false", facing: "east", type: "normal"}}, components: {}, x: 1, facing: 5b, progress: 0.0f, y: 100, z: 0, source: 1b, id: "minecraft:piston", extending: 1b}"#,
-        );
-        let state = tag.get("blockState").unwrap();
-        assert_eq!(
-            pretty_piston(state, PistonPart::State).plain(),
-            r#"{id: "minecraft:piston_head", properties: {short: "false", facing: "east", type: "normal"}}"#,
-        );
-        let props = state.get("properties").unwrap();
-        assert_eq!(
-            pretty_piston(props, PistonPart::Properties).plain(),
-            r#"{short: "false", facing: "east", type: "normal"}"#,
-        );
-        assert_eq!(
-            pretty(props).plain(),
-            r#"{facing: "east", short: "false", type: "normal"}"#
-        );
-        assert_eq!(pretty(&tag).plain(), ordinary);
-    }
-    #[test]
     fn compact_form_matches_vanilla() {
         assert_eq!(
             rt("{b:1b,a:\"x\",c:[1,2],d:1.5f,e:2d,f:3L,g:4s}"),

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

@@ -39,7 +39,7 @@ pub fn named_color(name: &str) -> Option<u32> {
     COLORS.iter().find(|c| c.1 == name).map(|c| c.2)
 }
 
-/// Click actions carried by text components.
+/// Click actions carried by locally constructed text components.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ClickEvent {
     /// `ClickEvent.OpenUrl`: an http or https link.
@@ -53,11 +53,6 @@ pub enum ClickEvent {
     /// `ClickEvent.ShowDialog`: a `minecraft:dialog` registry id, or the
     /// dialog itself as the component carried it.
     ShowDialog(horizon_world::nbt::Tag),
-    /// `ClickEvent.Custom`: a server-defined action with an optional NBT payload.
-    Custom {
-        id: String,
-        payload: Option<horizon_world::nbt::Tag>,
-    },
     /// A local file to open with the system handler.
     /// Only allow this in locally constructed messages, never server/LAN text.
     OpenFile(String),
@@ -246,28 +241,6 @@ impl Text {
         t.source = Some(Value::Object(c).into());
         t
     }
-    /// Component.translatableWithFallback(key, fallback, args): `translate`, with `fallback` as
-    /// the template when the language has no `key`.
-    pub fn translate_with_fallback(key: &str, fallback: &str, args: &[Text]) -> Self {
-        let template = lang::current()
-            .and_then(|l| l.get(key).map(str::to_owned))
-            .unwrap_or_else(|| fallback.to_owned());
-        let mut t = format_translation(&template, args);
-        let mut c = Map::new();
-        c.insert("translate".into(), key.into());
-        c.insert("fallback".into(), fallback.into());
-        if !args.is_empty() {
-            c.insert("with".into(), args.iter().map(Text::argument).collect());
-        }
-        t.source = Some(Value::Object(c).into());
-        t
-    }
-    /// CommonComponents.optionNameValue: "Caption: value" joined as the language joins them
-    /// (`options.generic_value`: "%s : %s" in French, "%s：%s" in Chinese). English's "%s: %s"
-    /// when the language has no such key, as without prepared resources.
-    pub fn option_name_value(caption: Text, value: Text) -> Self {
-        Self::translate_with_fallback("options.generic_value", "%s: %s", &[caption, value])
-    }
     /// A translatable message whose arguments are plain strings.
     pub fn tr(key: &str, args: &[&dyn std::fmt::Display]) -> Self {
         let args: Vec<Text> = args.iter().map(|a| Text::literal(a.to_string())).collect();
@@ -566,7 +539,7 @@ const STYLE_KEYS: [&str; 11] = [
     "insertion",
     "font",
 ];
-/// `Style.Serializer`: the fields a style sets.
+/// Style.Serializer: the fields a style sets.
 fn style_json(style: &Style) -> Vec<(String, Value)> {
     let mut out = Vec::new();
     if let Some(c) = style.color {
@@ -608,13 +581,6 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
                 "action": "show_dialog",
                 "dialog": crate::scoreboard::tag_to_json(dialog),
             }),
-            ClickEvent::Custom { id, payload } => {
-                let mut event = json!({ "action": "custom", "id": id });
-                if let Some(payload) = payload {
-                    event["payload"] = crate::scoreboard::tag_to_json(payload);
-                }
-                event
-            }
             ClickEvent::OpenFile(path) => json!({ "action": "open_file", "path": path }),
         };
         out.push(("click_event".to_owned(), event));

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

@@ -12,48 +12,13 @@ pub fn uuid_text(u: [i32; 4]) -> String {
     )
 }
 pub fn uuid_from_text(s: &str) -> Option<[i32; 4]> {
-    let mut hex = [0u8; 32];
-    let mut len = 0;
-    for b in s.bytes() {
-        if b == b'-' {
-            continue;
-        }
-        if !b.is_ascii_hexdigit() || len >= 32 {
-            return None;
-        }
-        hex[len] = b;
-        len += 1;
-    }
-    if len != 32 {
+    let hex: String = s.chars().filter(|c| *c != '-').collect();
+    if hex.len() != 32 {
         return None;
     }
-    let hex = std::str::from_utf8(&hex).ok()?;
     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)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn uuid_from_text_rejects_multibyte_and_non_hex() {
-        assert_eq!(uuid_from_text("€€€€€€€€€€aa"), None);
-        assert_eq!(uuid_from_text("€€€€€€€€€€aa----"), None);
-        assert_eq!(uuid_from_text("+0000001-0000-0000-0000-000000000000"), None);
-        assert_eq!(uuid_from_text("00000000-0000-0000-0000-00000000000g"), None);
-        assert_eq!(uuid_from_text(""), None);
-    }
-
-    #[test]
-    fn uuid_from_text_parses_hex_and_dashes() {
-        let u = [0x01234567, -0x76543211, 0x01234567, -0x76543211];
-        let text = uuid_text(u);
-        assert_eq!(uuid_from_text(&text), Some(u));
-        let undashed: String = text.chars().filter(|c| *c != '-').collect();
-        assert_eq!(uuid_from_text(&undashed), Some(u));
-    }
-}

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

@@ -119,19 +119,6 @@ impl Button {
             ][face],
         }
     }
-    /// The face button that plays this one's part on a Nintendo pad going by its letters
-    /// (`PadSettings::nintendo_letters`): the A it prints on the right is South, which confirms
-    /// and jumps as A does on a Switch; B (bottom) is East, X (top) West, Y (left) North. It is
-    /// its own inverse, so it turns a part into the button playing it and back.
-    pub fn by_letter(self) -> Button {
-        match self {
-            Button::South => Button::East,
-            Button::East => Button::South,
-            Button::West => Button::North,
-            Button::North => Button::West,
-            other => other,
-        }
-    }
 }
 
 /// A pad's inputs at one moment. Sticks are `[x, y]` with right and up
@@ -155,14 +142,6 @@ impl PadState {
     pub fn held(&self, button: Button) -> bool {
         self.buttons & button.bit() != 0
     }
-    /// A Nintendo pad's buttons read by their letters (`Button::by_letter`).
-    pub fn by_letter(&self) -> PadState {
-        let mut state = *self;
-        for part in [Button::South, Button::East, Button::West, Button::North] {
-            state.set(part, self.held(part.by_letter()));
-        }
-        state
-    }
     /// Two sources at once (a real pad and `horizon-ctl pad`): buttons held on
     /// either, sticks and triggers added.
     pub fn merge(&self, other: &PadState) -> PadState {
@@ -200,13 +179,12 @@ impl PadState {
 #[derive(Clone, Debug, Default)]
 pub struct Edges {
     held: u32,
-    suppressed: u32,
 }
 impl Edges {
     pub fn update(&mut self, state: &PadState, threshold: f32) -> Vec<(Button, bool)> {
         let mut now = state.buttons;
         for (trigger, button) in [(0, Button::LeftTrigger), (1, Button::RightTrigger)] {
-            let was = (self.held | self.suppressed) & button.bit() != 0;
+            let was = self.held & button.bit() != 0;
             let value = state.triggers[trigger];
             let on = if was {
                 value >= (threshold - 0.1).max(0.05)
@@ -219,8 +197,6 @@ impl Edges {
                 now &= !button.bit();
             }
         }
-        self.suppressed &= now;
-        now &= !self.suppressed;
         let changed = now ^ self.held;
         self.held = now;
         Button::ALL
@@ -241,50 +217,6 @@ impl Edges {
     pub fn is_held(&self, button: Button) -> bool {
         self.held & button.bit() != 0
     }
-    /// Cancel a context without turning its still-held buttons into new presses.
-    pub fn cancel(&mut self) -> Vec<(Button, bool)> {
-        self.suppressed |= self.held;
-        self.release_all()
-    }
-}
-
-/// Intentional activity may take input ownership; an unchanged hold may not.
-#[derive(Default)]
-pub struct Activity {
-    buttons: u32,
-    sticks: [[f32; 2]; 2],
-}
-impl Activity {
-    pub fn observe(&mut self, state: &PadState, settings: &PadSettings) -> bool {
-        let mut buttons = state.buttons;
-        for (i, button) in [(0, Button::LeftTrigger), (1, Button::RightTrigger)] {
-            let threshold = if self.buttons & button.bit() != 0 {
-                (settings.trigger_threshold - 0.1).max(0.05)
-            } else {
-                settings.trigger_threshold
-            };
-            if state.triggers[i] >= threshold {
-                buttons |= button.bit();
-            }
-        }
-        let mut activity = buttons & !self.buttons != 0;
-        self.buttons = buttons;
-        for (i, (stick, deadzone)) in [
-            (state.left, settings.move_deadzone),
-            (state.right, settings.look_deadzone),
-        ]
-        .into_iter()
-        .enumerate()
-        {
-            if length(stick) <= deadzone {
-                self.sticks[i] = [0.0; 2];
-            } else if length([stick[0] - self.sticks[i][0], stick[1] - self.sticks[i][1]]) > 0.08 {
-                activity = true;
-                self.sticks[i] = stick;
-            }
-        }
-        activity
-    }
 }
 
 /// Horizon's pad-only actions (no vanilla key mapping).
@@ -316,39 +248,6 @@ pub const ACTIONS: &[(&str, Option<Button>)] = &[
     ("key.smoothCamera", None),
 ];
 
-/// How a bindable action reaches the game: one of its own handlers, shared
-/// with the keyboard where the keyboard has one, or else the vanilla default
-/// key or button of its mapping, as a rebound keyboard key would.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Route {
-    HotbarStep {
-        next: bool,
-    },
-    /// Held, or flipped when the pad's toggle sneak is on.
-    Sneak,
-    Screenshot,
-    SmoothCamera,
-    Key(winit::keyboard::KeyCode),
-    Mouse(winit::event::MouseButton),
-}
-
-/// The route of a bindable action; `None` for one the pad can't reach.
-pub fn route(action: &str) -> Option<Route> {
-    match action {
-        HOTBAR_PREVIOUS => Some(Route::HotbarStep { next: false }),
-        HOTBAR_NEXT => Some(Route::HotbarStep { next: true }),
-        "key.sneak" => Some(Route::Sneak),
-        "key.screenshot" => Some(Route::Screenshot),
-        "key.smoothCamera" => Some(Route::SmoothCamera),
-        _ => {
-            let default = crate::keybinds::KeyBinds::default_of(action);
-            crate::keybinds::mouse_button(default)
-                .map(Route::Mouse)
-                .or_else(|| crate::keybinds::key_code(default).map(Route::Key))
-        }
-    }
-}
-
 /// An action's name in the binds list: vanilla's translation key, or
 /// Horizon's own English for the pad-only actions.
 pub fn action_caption(action: &str) -> &str {
@@ -414,6 +313,31 @@ impl GlyphStyle {
     }
 }
 
+/// How a controller drives menus (docs/controllers.md, "Menus and
+/// inventories").
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum MenuNav {
+    /// A console-style highlight moved between widgets and slots.
+    #[default]
+    Focus,
+    /// A virtual mouse pointer.
+    Pointer,
+}
+impl MenuNav {
+    pub fn name(self) -> &'static str {
+        match self {
+            MenuNav::Focus => "focus",
+            MenuNav::Pointer => "pointer",
+        }
+    }
+    pub fn parse(name: &str) -> Self {
+        match name {
+            "pointer" => MenuNav::Pointer,
+            _ => MenuNav::Focus,
+        }
+    }
+}
+
 /// The on-screen keyboard A opens on a text field in focus mode.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum TextKeyboard {
@@ -475,16 +399,9 @@ pub struct PadSettings {
     /// holding it, unless vanilla's toggle crouch is on already.
     pub toggle_sneak: bool,
     pub glyphs: GlyphStyle,
-    /// A Nintendo pad's face buttons go by their letters (A confirms and jumps, as on the
-    /// Switch's own menus and keyboard) instead of their places (B, at the bottom, does): on
-    /// by default on the Switch only.
-    pub nintendo_letters: bool,
+    /// How the pad drives menus: a focus highlight or a virtual pointer.
+    pub menu_nav: MenuNav,
     pub keyboard: TextKeyboard,
-    /// Menu pointer multiplier, scroll lines/second, and repeat times in seconds.
-    pub pointer_speed: f32,
-    pub scroll_speed: f32,
-    pub repeat_delay: f32,
-    pub repeat_interval: f32,
     /// Action name -> button, `None` for unbound; missing means the default.
     bindings: BTreeMap<&'static str, Option<Button>>,
 }
@@ -503,12 +420,8 @@ impl Default for PadSettings {
             trigger_threshold: 0.4,
             toggle_sneak: true,
             glyphs: GlyphStyle::Auto,
-            nintendo_letters: cfg!(target_os = "horizon"),
+            menu_nav: MenuNav::Focus,
             keyboard: TextKeyboard::Auto,
-            pointer_speed: 1.0,
-            scroll_speed: 12.0,
-            repeat_delay: 0.35,
-            repeat_interval: 0.09,
             bindings: BTreeMap::new(),
         }
     }
@@ -549,13 +462,6 @@ impl PadSettings {
                     .filter(|v| v.is_finite())
                     .map_or(d, |v| v.clamp(0.0, 1.0))
             };
-            let bounded = |default: f32, min: f32, max: f32| {
-                value
-                    .parse::<f32>()
-                    .ok()
-                    .filter(|v| v.is_finite())
-                    .map_or(default, |v| v.clamp(min, max))
-            };
             match key.trim() {
                 "enabled" => s.enabled = flag(s.enabled),
                 "vibration" => s.vibration = flag(s.vibration),
@@ -571,12 +477,8 @@ impl PadSettings {
                 }
                 "toggleSneak" => s.toggle_sneak = flag(s.toggle_sneak),
                 "glyphs" => s.glyphs = GlyphStyle::parse(value),
-                "nintendoLetters" => s.nintendo_letters = flag(s.nintendo_letters),
+                "menuNavigation" => s.menu_nav = MenuNav::parse(value),
                 "keyboard" => s.keyboard = TextKeyboard::parse(value),
-                "pointerSpeed" => s.pointer_speed = bounded(s.pointer_speed, 0.25, 3.0),
-                "scrollSpeed" => s.scroll_speed = bounded(s.scroll_speed, 1.0, 36.0),
-                "repeatDelay" => s.repeat_delay = bounded(s.repeat_delay, 0.1, 1.0),
-                "repeatInterval" => s.repeat_interval = bounded(s.repeat_interval, 0.03, 0.3),
                 other => {
                     if let Some(action) = other.strip_prefix("bind_") {
                         let button = if value == "none" {
@@ -595,7 +497,7 @@ impl PadSettings {
     }
     pub fn serialize(&self) -> String {
         let mut text = format!(
-            "enabled:{}\nvibration:{}\nadaptiveTriggers:{}\nlightbar:{}\nlookSensitivity:{}\ninvertX:{}\ninvertY:{}\nmoveDeadzone:{}\nlookDeadzone:{}\ntriggerThreshold:{}\ntoggleSneak:{}\nglyphs:{}\nnintendoLetters:{}\nkeyboard:{}\n",
+            "enabled:{}\nvibration:{}\nadaptiveTriggers:{}\nlightbar:{}\nlookSensitivity:{}\ninvertX:{}\ninvertY:{}\nmoveDeadzone:{}\nlookDeadzone:{}\ntriggerThreshold:{}\ntoggleSneak:{}\nglyphs:{}\nmenuNavigation:{}\nkeyboard:{}\n",
             bool_text(self.enabled),
             bool_text(self.vibration),
             bool_text(self.adaptive_triggers),
@@ -608,13 +510,9 @@ impl PadSettings {
             self.trigger_threshold,
             bool_text(self.toggle_sneak),
             self.glyphs.name(),
-            bool_text(self.nintendo_letters),
+            self.menu_nav.name(),
             self.keyboard.name(),
         );
-        text.push_str(&format!(
-            "pointerSpeed:{}\nscrollSpeed:{}\nrepeatDelay:{}\nrepeatInterval:{}\n",
-            self.pointer_speed, self.scroll_speed, self.repeat_delay, self.repeat_interval,
-        ));
         for (action, button) in &self.bindings {
             text.push_str(&format!(
                 "bind_{action}:{}\n",
@@ -1265,131 +1163,6 @@ pub fn bow_power(ticks: u32) -> f32 {
 mod tests {
     use super::*;
 
-    #[test]
-    fn every_bindable_action_reaches_the_game() {
-        for (action, _) in ACTIONS {
-            assert!(route(action).is_some(), "{action} has nowhere to go");
-        }
-    }
-
-    #[test]
-    fn navigation_preferences_migrate_and_stay_with_each_player() {
-        let dir = std::env::temp_dir().join(format!(
-            "horizon-pad-{}-{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
-        ));
-        let p2 = dir.join("P2");
-        fs::create_dir_all(&p2).unwrap();
-        let fresh = PadSettings::load(&dir);
-        assert_eq!(fresh, PadSettings::default());
-        // An older file, with the removed menuNavigation key: bindings kept.
-        let legacy =
-            PadSettings::parse("menuNavigation:pointer\nbind_key.jump:east\nlookSensitivity:0.7\n");
-        assert_eq!(legacy.binding("key.jump"), Some(Button::East));
-        assert_eq!(legacy.look_sensitivity, 0.7);
-        fresh.save(&dir);
-        assert!(!dir.join(FILE).exists(), "defaults write no file");
-        let mut other = legacy;
-        other.pointer_speed = 2.5;
-        other.scroll_speed = 24.0;
-        other.repeat_delay = 0.6;
-        other.repeat_interval = 0.12;
-        other.save(&p2);
-        assert_eq!(PadSettings::load(&p2), other);
-        assert_eq!(PadSettings::load(&dir), fresh, "P2 did not write P1");
-        let invalid = PadSettings::parse(
-            "pointerSpeed:NaN\nscrollSpeed:inf\nrepeatDelay:-10\nrepeatInterval:20\n",
-        );
-        assert_eq!((invalid.pointer_speed, invalid.scroll_speed), (1.0, 12.0));
-        assert_eq!((invalid.repeat_delay, invalid.repeat_interval), (0.1, 0.3));
-        let bounded = PadSettings::parse(
-            "pointerSpeed:10\nscrollSpeed:-1\nrepeatDelay:NaN\nrepeatInterval:inf\n",
-        );
-        assert_eq!((bounded.pointer_speed, bounded.scroll_speed), (3.0, 1.0));
-        assert_eq!(
-            (bounded.repeat_delay, bounded.repeat_interval),
-            (0.35, 0.09)
-        );
-        fs::remove_dir_all(dir).unwrap();
-    }
-
-    #[test]
-    fn ownership_requires_new_activity_and_ignores_drift() {
-        let settings = PadSettings::default();
-        let mut p1 = Activity::default();
-        let mut p2 = Activity::default();
-        let mut state = PadState {
-            left: [0.04, 0.03],
-            ..PadState::default()
-        };
-        assert!(!p1.observe(&state, &settings));
-        state.set(Button::South, true);
-        assert!(p1.observe(&state, &settings));
-        assert!(
-            !p1.observe(&state, &settings),
-            "held pad cannot reclaim mouse ownership"
-        );
-        assert!(
-            p2.observe(&state, &settings),
-            "another player's tracker is independent"
-        );
-        state.set(Button::South, false);
-        assert!(!p1.observe(&state, &settings));
-        state.left = [0.5, 0.0];
-        assert!(p1.observe(&state, &settings));
-        state.left = [0.52, 0.0];
-        assert!(!p1.observe(&state, &settings));
-        for x in [0.54, 0.56] {
-            state.left = [x, 0.0];
-            assert!(!p1.observe(&state, &settings));
-        }
-        state.left = [0.6, 0.0];
-        assert!(
-            p1.observe(&state, &settings),
-            "slow intentional movement accumulates"
-        );
-        state.left = [0.0; 2];
-        state.triggers[0] = 0.5;
-        assert!(p1.observe(&state, &settings));
-        state.triggers[0] = 0.35;
-        assert!(!p1.observe(&state, &settings));
-        state.triggers[0] = 0.45;
-        assert!(
-            !p1.observe(&state, &settings),
-            "trigger threshold noise is not new activity"
-        );
-    }
-
-    #[test]
-    fn cancelled_holds_stay_released_until_neutral_then_press_again() {
-        let mut edges = Edges::default();
-        let mut state = PadState::default();
-        state.set(Button::South, true);
-        state.triggers[1] = 0.8;
-        assert_eq!(
-            edges.update(&state, 0.4),
-            vec![(Button::South, true), (Button::RightTrigger, true)]
-        );
-        assert_eq!(
-            edges.cancel(),
-            vec![(Button::South, false), (Button::RightTrigger, false)]
-        );
-        assert!(edges.update(&state, 0.4).is_empty());
-        state.triggers[1] = 0.35;
-        assert!(edges.update(&state, 0.4).is_empty());
-        assert!(edges.update(&PadState::default(), 0.4).is_empty());
-        assert_eq!(edges.update(&state, 0.4), vec![(Button::South, true)]);
-        state.triggers[1] = 0.7;
-        assert_eq!(
-            edges.update(&state, 0.4),
-            vec![(Button::RightTrigger, true)]
-        );
-    }
-
     #[test]
     fn defaults_follow_bedrock() {
         let s = PadSettings::default();
@@ -1419,9 +1192,7 @@ mod tests {
         s.invert_y = true;
         s.look_sensitivity = 0.75;
         s.glyphs = GlyphStyle::PlayStation;
-        s.nintendo_letters = !s.nintendo_letters;
         let text = s.serialize();
-        assert!(text.contains(&format!("nintendoLetters:{}\n", s.nintendo_letters)));
         assert!(text.contains("bind_key.jump:east\n"));
         assert!(text.contains("bind_key.drop:none\n"));
         assert!(!text.contains("key.sneak"));
@@ -1467,27 +1238,6 @@ mod tests {
         assert_eq!(other, ([0.0, 0.0], [1.0, 0.0]));
     }
 
-    #[test]
-    fn a_nintendo_pad_by_its_letters_confirms_with_a() {
-        // The pad's A sits on the right (East): going by letters it plays South, confirm and jump.
-        let mut pad = PadState::default();
-        pad.set(Button::East, true);
-        pad.set(Button::LeftBumper, true);
-        pad.left = [0.5, -0.25];
-        let parts = pad.by_letter();
-        assert!(parts.held(Button::South));
-        assert!(!parts.held(Button::East));
-        // Other buttons and the sticks stay; reading by letters again gives the pad back.
-        assert!(parts.held(Button::LeftBumper));
-        assert_eq!(parts.left, [0.5, -0.25]);
-        assert_eq!(parts.by_letter(), pad);
-        // A part's glyph is the letter of the button playing it.
-        assert_eq!(Button::South.by_letter().label(GlyphStyle::Nintendo), "A");
-        assert_eq!(Button::East.by_letter().label(GlyphStyle::Nintendo), "B");
-        assert_eq!(Button::West.by_letter().label(GlyphStyle::Nintendo), "X");
-        assert_eq!(Button::North.by_letter().label(GlyphStyle::Nintendo), "Y");
-    }
-
     #[test]
     fn radial_deadzone_rescales() {
         assert_eq!(radial([0.1, 0.05], 0.15), [0.0, 0.0]);
@@ -1664,13 +1414,14 @@ mod tests {
         assert_eq!(stick_direction([0.9, 0.2], 0.5), Some(Button::DPadRight));
         assert_eq!(stick_direction([-0.2, -0.8], 0.5), Some(Button::DPadDown));
         assert_eq!(stick_direction([0.3, 0.3], 0.5), None);
-        let s = PadSettings {
-            keyboard: TextKeyboard::Horizon,
-            ..PadSettings::default()
-        };
+        let mut s = PadSettings::default();
+        assert_eq!(s.menu_nav, MenuNav::Focus);
+        s.menu_nav = MenuNav::Pointer;
+        s.keyboard = TextKeyboard::Horizon;
+        let back = PadSettings::parse(&s.serialize());
         assert_eq!(
-            PadSettings::parse(&s.serialize()).keyboard,
-            TextKeyboard::Horizon
+            (back.menu_nav, back.keyboard),
+            (MenuNav::Pointer, TextKeyboard::Horizon)
         );
         assert!(steam_keyboard(TextKeyboard::Steam) && !steam_keyboard(TextKeyboard::Horizon));
     }

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

@@ -1,155 +0,0 @@
-//! The keys a player's mappings hold, as their vanilla default keys, and which
-//! devices hold each one. A key stays held while any device holds it, so one
-//! device letting go (splitscreen moving the keyboard to another player, say)
-//! can't release what another still presses.
-
-use std::collections::HashMap;
-use winit::keyboard::KeyCode;
-
-/// Where a press came from.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Source {
-    /// The keyboard and mouse, and the scripting socket acting as them.
-    Keyboard,
-    Pad,
-}
-
-impl Source {
-    fn bit(self) -> u8 {
-        match self {
-            Source::Keyboard => 1,
-            Source::Pad => 2,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct HeldKeys {
-    held: HashMap<KeyCode, u8>,
-}
-
-impl HeldKeys {
-    pub fn contains(&self, key: &KeyCode) -> bool {
-        self.held.contains_key(key)
-    }
-    /// `source` holds `key`. True when nothing held it before.
-    pub fn press(&mut self, key: KeyCode, source: Source) -> bool {
-        let sources = self.held.entry(key).or_insert(0);
-        let new = *sources == 0;
-        *sources |= source.bit();
-        new
-    }
-    /// `source` lets go of `key`. True when nothing holds it any more.
-    pub fn release(&mut self, key: &KeyCode, source: Source) -> bool {
-        let Some(sources) = self.held.get_mut(key) else {
-            return true;
-        };
-        *sources &= !source.bit();
-        if *sources == 0 {
-            self.held.remove(key);
-            true
-        } else {
-            false
-        }
-    }
-    pub fn held_by(&self, key: &KeyCode, source: Source) -> bool {
-        self.held
-            .get(key)
-            .is_some_and(|sources| sources & source.bit() != 0)
-    }
-    /// `source` lets go of everything: the keys nothing holds any more.
-    pub fn release_source(&mut self, source: Source) -> Vec<KeyCode> {
-        let keys: Vec<KeyCode> = self
-            .held
-            .iter()
-            .filter(|(_, sources)| *sources & source.bit() != 0)
-            .map(|(key, _)| *key)
-            .collect();
-        keys.into_iter()
-            .filter(|key| self.release(key, source))
-            .collect()
-    }
-    /// Held, by the keyboard unless a device already holds it: for callers
-    /// that don't say where the press came from.
-    pub fn insert(&mut self, key: KeyCode) -> bool {
-        if self.contains(&key) {
-            return false;
-        }
-        self.press(key, Source::Keyboard)
-    }
-    /// Let go of `key` whoever holds it.
-    pub fn remove(&mut self, key: &KeyCode) -> bool {
-        self.held.remove(key).is_some()
-    }
-    pub fn clear(&mut self) {
-        self.held.clear();
-    }
-    pub fn is_empty(&self) -> bool {
-        self.held.is_empty()
-    }
-    pub fn len(&self) -> usize {
-        self.held.len()
-    }
-    pub fn iter(&self) -> impl Iterator<Item = &KeyCode> {
-        self.held.keys()
-    }
-}
-
-impl IntoIterator for HeldKeys {
-    type Item = KeyCode;
-    type IntoIter = std::collections::hash_map::IntoKeys<KeyCode, u8>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.held.into_keys()
-    }
-}
-
-impl<'a> IntoIterator for &'a HeldKeys {
-    type Item = &'a KeyCode;
-    type IntoIter = std::collections::hash_map::Keys<'a, KeyCode, u8>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.held.keys()
-    }
-}
-
-impl FromIterator<KeyCode> for HeldKeys {
-    fn from_iter<I: IntoIterator<Item = KeyCode>>(keys: I) -> Self {
-        let mut held = HeldKeys::default();
-        for key in keys {
-            held.insert(key);
-        }
-        held
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn a_key_stays_held_while_any_device_holds_it() {
-        let mut keys = HeldKeys::default();
-        assert!(keys.press(KeyCode::Space, Source::Pad));
-        assert!(!keys.press(KeyCode::Space, Source::Keyboard));
-        assert!(keys.press(KeyCode::KeyW, Source::Keyboard));
-        assert_eq!(keys.release_source(Source::Keyboard), vec![KeyCode::KeyW]);
-        assert!(keys.contains(&KeyCode::Space) && !keys.contains(&KeyCode::KeyW));
-        assert!(keys.held_by(&KeyCode::Space, Source::Pad));
-        assert!(!keys.held_by(&KeyCode::Space, Source::Keyboard));
-        assert!(keys.release(&KeyCode::Space, Source::Pad));
-        assert!(keys.is_empty());
-    }
-
-    #[test]
-    fn untagged_inserts_and_removes_act_as_before() {
-        let mut keys = HeldKeys::default();
-        keys.press(KeyCode::ShiftLeft, Source::Pad);
-        assert!(!keys.insert(KeyCode::ShiftLeft), "already held");
-        assert!(!keys.held_by(&KeyCode::ShiftLeft, Source::Keyboard));
-        assert!(
-            keys.remove(&KeyCode::ShiftLeft),
-            "remove lets go for everyone"
-        );
-        assert!(!keys.contains(&KeyCode::ShiftLeft));
-        assert!(keys.release(&KeyCode::KeyA, Source::Keyboard), "never held");
-    }
-}

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

@@ -5,7 +5,6 @@
 #![forbid(unsafe_code)]
 pub mod clipboard;
 pub mod gamepad;
-pub mod held;
 pub mod input;
 pub mod interaction_input;
 pub mod key_names;
@@ -13,5 +12,4 @@ pub mod keybinds;
 pub mod keymapping;
 pub mod modifiers;
 pub mod mouse;
-pub mod snap;
 pub mod window;

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

@@ -1,152 +0,0 @@
-//! Where the controller's menu cursor settles once the stick is let go, and
-//! how it gets there. Every rule's number lives in [`Tuning`], so the feel can
-//! be adjusted in one place.
-
-/// The snapping engine's knobs, in GUI pixels and seconds.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Tuning {
-    /// A let-go cursor settles on a target this close to it.
-    pub radius: f32,
-    /// How long the glide onto a target takes.
-    pub glide_seconds: f32,
-    /// Movement shorter than this is a wobble: the cursor stays where it was.
-    pub min_travel: f32,
-    /// A flick that ends still nearest its starting target commits to the
-    /// neighbour it was heading for once it covered this fraction of the way.
-    pub commit: f32,
-    /// How far off the flick's direction a neighbour may lie (cosine of the
-    /// angle: 0.7 is about 45 degrees).
-    pub cone: f32,
-    /// The pointer's speed over a slot or control, as a fraction of its
-    /// speed elsewhere (1 leaves it unchanged).
-    pub over_target_speed: f32,
-}
-
-pub const TUNING: Tuning = Tuning {
-    radius: 16.0,
-    glide_seconds: 0.025,
-    min_travel: 1.5,
-    commit: 0.15,
-    cone: 0.7,
-    over_target_speed: 1.0,
-};
-
-type Point = (f32, f32);
-
-fn distance(a: Point, b: Point) -> f32 {
-    ((a.0 - b.0).powi(2) + (a.1 - b.1).powi(2)).sqrt()
-}
-
-/// The target nearest `at`, if one lies within `radius`.
-pub fn nearest(at: Point, targets: &[Point], radius: f32) -> Option<usize> {
-    targets
-        .iter()
-        .enumerate()
-        .map(|(i, t)| (i, distance(at, *t)))
-        .filter(|(_, d)| *d <= radius)
-        .min_by(|a, b| a.1.total_cmp(&b.1))
-        .map(|(i, _)| i)
-}
-
-/// Where a stick movement from `start` to `end` settles among `targets`
-/// (their centres), or `None` to leave the cursor where it is.
-pub fn settle(start: Point, end: Point, targets: &[Point], tuning: &Tuning) -> Option<usize> {
-    let near = nearest(end, targets, tuning.radius);
-    let travel = (end.0 - start.0, end.1 - start.1);
-    let length = distance(start, end);
-    if length < tuning.min_travel {
-        return near;
-    }
-    let origin = nearest(start, targets, tuning.radius);
-    if near != origin {
-        return near;
-    }
-    // Still nearest where it started: a quick flick toward a neighbour.
-    let Some(o) = origin else {
-        return near;
-    };
-    let from = targets[o];
-    let heading = (travel.0 / length, travel.1 / length);
-    let next = targets
-        .iter()
-        .enumerate()
-        .filter(|(i, _)| *i != o)
-        .filter_map(|(i, t)| {
-            let to = (t.0 - from.0, t.1 - from.1);
-            let gap = distance(from, *t);
-            let aligned = (to.0 * heading.0 + to.1 * heading.1) / gap;
-            (gap > 0.0 && aligned >= tuning.cone).then_some((i, gap, to))
-        })
-        .min_by(|a, b| a.1.total_cmp(&b.1));
-    match next {
-        Some((i, gap, to)) => {
-            let progress = ((end.0 - from.0) * to.0 + (end.1 - from.1) * to.1) / (gap * gap);
-            if progress >= tuning.commit {
-                Some(i)
-            } else {
-                near
-            }
-        }
-        None => near,
-    }
-}
-
-/// The cursor `seconds` into a glide from `from` to `to`: eased out, so it
-/// slows as it lands, and exactly `to` once the glide is over.
-pub fn glide(from: Point, to: Point, seconds: f32, tuning: &Tuning) -> Point {
-    let t = (seconds / tuning.glide_seconds).clamp(0.0, 1.0);
-    let eased = 1.0 - (1.0 - t).powi(3);
-    (
-        from.0 + (to.0 - from.0) * eased,
-        from.1 + (to.1 - from.1) * eased,
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// A row of inventory slots, 18 pixels apart, and the slot below the first.
-    const SLOTS: [Point; 4] = [(8.0, 8.0), (26.0, 8.0), (44.0, 8.0), (8.0, 26.0)];
-
-    #[test]
-    fn a_short_flick_moves_to_the_neighbour_it_heads_for() {
-        // 4 pixels right of slot 0: still nearest slot 0, but heading for slot 1.
-        assert_eq!(settle((8.0, 8.0), (12.0, 8.0), &SLOTS, &TUNING), Some(1));
-        assert_eq!(settle((8.0, 8.0), (8.0, 12.0), &SLOTS, &TUNING), Some(3));
-        assert_eq!(settle((26.0, 8.0), (22.0, 8.0), &SLOTS, &TUNING), Some(0));
-    }
-
-    #[test]
-    fn a_wobble_stays_put() {
-        assert_eq!(settle((8.0, 8.0), (8.5, 8.4), &SLOTS, &TUNING), Some(0));
-        // Barely started toward the neighbour: not committed.
-        assert_eq!(settle((8.0, 8.0), (9.6, 8.0), &SLOTS, &TUNING), Some(0));
-    }
-
-    #[test]
-    fn a_long_move_settles_on_the_nearest_target() {
-        assert_eq!(settle((8.0, 8.0), (42.0, 9.0), &SLOTS, &TUNING), Some(2));
-        // Far from everything: left where it is.
-        assert_eq!(settle((8.0, 8.0), (200.0, 200.0), &SLOTS, &TUNING), None);
-    }
-
-    #[test]
-    fn a_flick_off_any_row_does_not_jump_sideways() {
-        // Up from slot 0: nothing lies that way, so it stays on slot 0.
-        assert_eq!(settle((8.0, 8.0), (8.0, 4.0), &SLOTS, &TUNING), Some(0));
-    }
-
-    #[test]
-    fn the_glide_eases_onto_its_target_and_stops_there() {
-        let (from, to) = ((0.0, 0.0), (20.0, -10.0));
-        assert_eq!(glide(from, to, 0.0, &TUNING), from);
-        let half = glide(from, to, TUNING.glide_seconds / 2.0, &TUNING);
-        assert!(
-            half.0 > 10.0 && half.0 < 20.0,
-            "eased out: past halfway at half time"
-        );
-        assert_eq!(glide(from, to, TUNING.glide_seconds, &TUNING), to);
-        assert_eq!(glide(from, to, 1.0, &TUNING), to);
-    }
-}

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

@@ -182,38 +182,13 @@ impl LimiterClock for SystemClock {
         i64::try_from(self.origin.elapsed().as_nanos()).unwrap_or(i64::MAX)
     }
     fn park(&mut self, nanos: i64) {
-        let end = self.nanos().saturating_add(nanos);
-        park_in_steps(
-            end,
-            || self.nanos(),
-            |step| {
-                std::thread::sleep(std::time::Duration::from_nanos(step as u64));
-            },
-        );
+        std::thread::sleep(std::time::Duration::from_nanos(nanos.max(0) as u64));
     }
     fn spin(&mut self) {
         std::hint::spin_loop();
     }
 }
 
-/// The longest single sleep of [`SystemClock::park`].
-const PARK_STEP_NS: i64 = 1_000_000;
-
-/// Sleeps until `now()` reaches `end`, at most [`PARK_STEP_NS`] at a time. macOS lets
-/// a sleep run late by a share of its length (timer coalescing: 1.8-3.5 ms on a 14 ms
-/// sleep, 0.25 ms on 1 ms), more than the limiter's overshoot margin can learn (capped
-/// at 2 ms): a 60 FPS cap gave frames of 17-20 ms. Short steps keep the lateness to
-/// the last step's.
-fn park_in_steps(end: i64, mut now: impl FnMut() -> i64, mut sleep: impl FnMut(i64)) {
-    loop {
-        let left = end - now();
-        if left <= 0 {
-            return;
-        }
-        sleep(left.min(PARK_STEP_NS));
-    }
-}
-
 /// The real clock without busy waiting: where vanilla spins on
 /// `Thread.onSpinWait` for the last half millisecond, this sleeps in short
 /// steps, so a capped frame rate leaves the core idle.
@@ -243,18 +218,6 @@ pub fn end_frame(
     }
 }
 
-/// [`end_frame`] on a fixed grid of frame slots ([`FramerateLimiter::limit_on_grid`]):
-/// Horizon's Efficient pacing.
-pub fn end_frame_on_grid(
-    limiter: &mut FramerateLimiter,
-    framerate_limit: i32,
-    clock: &mut impl LimiterClock,
-) {
-    if framerate_limit < 260 {
-        limiter.limit_on_grid(framerate_limit, clock);
-    }
-}
-
 impl FramerateLimiter {
     pub fn new(now_ns: i64) -> Self {
         Self::with_state(now_ns, 0, 0)
@@ -285,37 +248,6 @@ impl FramerateLimiter {
             self.average_overshoot_ns = 0;
             self.last_framerate_limit = framerate_limit;
         }
-        self.wait_until(target_time_ns, clock);
-        self.last_frame_time = clock.nanos();
-    }
-    /// Horizon's Efficient pacing: [`Self::limit_display_fps`]'s wait, but each frame's
-    /// slot starts where the last one's ended (its deadline), not when the thread woke
-    /// up. Vanilla's way adds every late wake-up to the frame (on the Mac, 50 us sleeps
-    /// running 0.2 ms late made a 144 FPS cap 139); on a fixed grid the cap holds on
-    /// average. A frame that ends past its slot, or wakes up more than half a frame
-    /// late, starts the grid again from now: no frame is rushed out to catch up.
-    pub fn limit_on_grid(&mut self, framerate_limit: i32, clock: &mut impl LimiterClock) {
-        let period = 1_000_000_000 / i64::from(framerate_limit);
-        if framerate_limit != self.last_framerate_limit {
-            self.average_overshoot_ns = 0;
-            self.last_framerate_limit = framerate_limit;
-        }
-        let deadline = self.last_frame_time + period;
-        if clock.nanos() >= deadline {
-            self.last_frame_time = clock.nanos();
-            return;
-        }
-        self.wait_until(deadline, clock);
-        let woke = clock.nanos();
-        self.last_frame_time = if woke - deadline > period / 2 {
-            woke
-        } else {
-            deadline
-        };
-    }
-    /// `limitDisplayFPS`'s wait: sleep to within the learned overshoot and half a
-    /// millisecond of `target_time_ns`, then spin.
-    fn wait_until(&mut self, target_time_ns: i64, clock: &mut impl LimiterClock) {
         loop {
             let remaining = target_time_ns - clock.nanos();
             if remaining <= 0 {
@@ -339,6 +271,7 @@ impl FramerateLimiter {
                 clock.spin();
             }
         }
+        self.last_frame_time = clock.nanos();
     }
     pub fn last_frame_time(&self) -> i64 {
         self.last_frame_time
@@ -745,140 +678,6 @@ mod tests {
         assert_eq!(calculate_scale([1920, 1080], 3, true), 4);
         assert_eq!(gui_scaled_size([1921, 1081], 4), [481, 271]);
     }
-    /// A clock whose sleeps run late by a quarter of their length, as macOS's do,
-    /// sleeping as [`SystemClock::park`] does.
-    struct Coalescing {
-        now: std::cell::Cell<i64>,
-    }
-    impl LimiterClock for Coalescing {
-        fn nanos(&mut self) -> i64 {
-            self.now.get()
-        }
-        fn park(&mut self, nanos: i64) {
-            let now = &self.now;
-            park_in_steps(
-                now.get() + nanos,
-                || now.get(),
-                |step| {
-                    now.set(now.get() + step + step / 4);
-                },
-            );
-        }
-        fn spin(&mut self) {
-            self.now.set(self.now.get() + 1000);
-        }
-    }
-    #[test]
-    fn a_frame_cap_holds_when_sleeps_run_late() {
-        let mut clock = Coalescing {
-            now: std::cell::Cell::new(0),
-        };
-        let mut limiter = FramerateLimiter::new(0);
-        let mut last = 0;
-        for frame in 0..120 {
-            // The frame's own work.
-            clock.now.set(clock.now.get() + 2_000_000);
-            limiter.limit_display_fps(60, &mut clock);
-            let period = clock.now.get() - last;
-            last = clock.now.get();
-            assert!(
-                (16_666_666..16_666_666 + 100_000).contains(&period),
-                "frame {frame}: {period} ns"
-            );
-        }
-    }
-    /// A clock whose sleeps and spins each run up to `late` ns late (a different
-    /// share each time), as a loaded machine's do.
-    struct Late {
-        now: i64,
-        late: i64,
-        seed: u64,
-    }
-    impl Late {
-        fn new(late: i64) -> Self {
-            Self {
-                now: 0,
-                late,
-                seed: 0x9e37_79b9_7f4a_7c15,
-            }
-        }
-        fn lateness(&mut self) -> i64 {
-            self.seed ^= self.seed << 13;
-            self.seed ^= self.seed >> 7;
-            self.seed ^= self.seed << 17;
-            (self.seed % 1000) as i64 * self.late / 1000
-        }
-    }
-    impl LimiterClock for Late {
-        fn nanos(&mut self) -> i64 {
-            self.now
-        }
-        fn park(&mut self, nanos: i64) {
-            self.now += nanos + self.lateness();
-        }
-        fn spin(&mut self) {
-            self.now += 50_000 + self.lateness();
-        }
-    }
-    /// Frame periods of 144 FPS frames whose work takes `work(frame)` ns.
-    fn grid_periods(late: i64, work: impl Fn(usize) -> i64) -> Vec<i64> {
-        let mut clock = Late::new(late);
-        let mut limiter = FramerateLimiter::new(0);
-        let mut ends = Vec::new();
-        for frame in 0..300 {
-            clock.now += work(frame);
-            limiter.limit_on_grid(144, &mut clock);
-            ends.push(clock.now);
-        }
-        ends.windows(2).map(|w| w[1] - w[0]).collect()
-    }
-    #[test]
-    fn the_grid_holds_the_cap_when_wake_ups_run_late() {
-        let period = 1_000_000_000 / 144;
-        for late in [0, 50_000, 200_000, 1_000_000] {
-            let periods = grid_periods(late, |_| 2_000_000);
-            let mean = periods[10..].iter().sum::<i64>() / (periods.len() - 10) as i64;
-            assert!(
-                (mean - period).abs() < 10_000,
-                "{late} ns late: mean period {mean} ns"
-            );
-            // Each slot waits at least half a frame: the grid never rushes one out.
-            assert!(
-                periods.iter().all(|&p| p > period / 2),
-                "{late} ns late: {periods:?}"
-            );
-        }
-        // Vanilla's way adds the lateness to the frames: the cap isn't held.
-        let mut clock = Late::new(400_000);
-        let mut limiter = FramerateLimiter::new(0);
-        for _ in 0..300 {
-            clock.now += 2_000_000;
-            limiter.limit_display_fps(144, &mut clock);
-        }
-        assert!(
-            clock.now / 300 > period + 50_000,
-            "vanilla: {} ns",
-            clock.now / 300
-        );
-    }
-    #[test]
-    fn a_long_frame_starts_the_grid_again_without_a_burst() {
-        let period = 1_000_000_000 / 144;
-        // Frame 100 works 30 ms: four slots go by.
-        let periods = grid_periods(
-            50_000,
-            |frame| if frame == 100 { 30_000_000 } else { 2_000_000 },
-        );
-        assert!(periods[99] >= 30_000_000);
-        for (i, &p) in periods.iter().enumerate().skip(100) {
-            // On the grid a slot is a late wake-up (50 us at most) short or long.
-            assert!(
-                (period - 100_000..period + 100_000).contains(&p),
-                "frame {}: {p} ns",
-                i + 1
-            );
-        }
-    }
     #[test]
     fn limiter_paces_frames_at_the_target() {
         let mut limiter = FramerateLimiter::new(0);

crates/horizon-client-lib/Cargo.toml

@@ -20,8 +20,6 @@ horizon-client-render = { path = "../horizon-client-render" }
 horizon-command = { path = "../horizon-command" }
 horizon-items = { path = "../horizon-items" }
 horizon-core = { path = "../horizon-core" }
-# `horizon-ctl mcp`: the Model Context Protocol, shared with the launcher and the server.
-horizon-mcp = { path = "../horizon-mcp" }
 # The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
 horizon-optifine = { path = "../horizon-optifine" }
 horizon-threads = { path = "../horizon-threads" }
@@ -63,10 +61,6 @@ ab_glyph = "0.2.32"
 log = "0.4"
 chrono = { version = "0.4.42", default-features = false, features = ["clock", "std"] }
 flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs", "runtime_detection"] }
-# The network threads of a server's players: epoll, kqueue or Windows' AFD (lan/io_pool.rs).
-mio = { version = "1.2.4", features = ["os-poll", "net"] }
-# Shared chunk frames are found by one keyed 128-bit hash of their body (lan/conn.rs SharedFrames).
-xxhash-rust = { version = "0.8.19", features = ["xxh3"] }
 horizon-theme = { path = "../horizon-theme" }
 # Opt-in data collection: the game keeps, the launcher sends (docs/telemetry.md); `live` is
 # the anonymous "I'm playing" ping the game sends itself (`heartbeat.rs`).
@@ -138,10 +132,6 @@ path = "../horizon-client/src/bin/horizon-ctl/main.rs"
 name = "chunk_load_bench"
 path = "../horizon-client/examples/chunk_load_bench.rs"
 
-[[example]]
-name = "gen_light_bench"
-path = "../horizon-client/examples/gen_light_bench.rs"
-
 [[example]]
 name = "gameplay_decode_profile"
 path = "../horizon-client/examples/gameplay_decode_profile.rs"
@@ -229,7 +219,3 @@ path = "../horizon-client/tests/tall_column.rs"
 [[test]]
 name = "wide_states"
 path = "../horizon-client/tests/wide_states.rs"
-
-[[example]]
-name = "chunk_encoding_bench"
-path = "../horizon-client/examples/chunk_encoding_bench.rs"

crates/horizon-client-render/Cargo.toml

@@ -7,9 +7,6 @@ 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-cosmetics = { path = "../horizon-cosmetics" }
-# The GUI atlas's pixels, kept compressed once uploaded (hud.rs `pack_pixels`).
-lz4_flex = { version = "0.14", default-features = false, features = ["std", "safe-encode", "safe-decode", "checked-decode"] }
 horizon-assets = { path = "../horizon-assets" }
 horizon-bench = { path = "../horizon-bench" }
 horizon-client-core = { path = "../horizon-client-core" }
@@ -43,10 +40,6 @@ miniz_oxide = "0.8"
 naga = { version = "30.0.1", features = ["wgsl-in", "glsl-in", "hlsl-out"] }
 half = "2"
 png = "0.18"
-# Project icons served by Modrinth are often WebP or JPEG rather than PNG, and
-# the pack browser showed nothing for those. Both are small pure-Rust decoders.
-image-webp = { version = "0.2", default-features = false }
-zune-jpeg = { version = "0.4", default-features = false, features = ["std"] }
 pollster = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1.0.151", features = ["raw_value"] }
@@ -75,9 +68,6 @@ audio = ["dep:cpal"]
 # Helpers horizon-client's tests build their fixtures with.
 test-support = []
 
-[build-dependencies]
-horizon-mod-api-gen = { path = "../horizon-mod-api-gen" }
-
 [lints]
 workspace = true
 

crates/horizon-client-render/build.rs

@@ -1,7 +0,0 @@
-fn main() {
-    let root =
-        std::path::PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap()).join("../..");
-    let out_dir = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
-    horizon_mod_api_gen::generate(&root, &out_dir, horizon_mod_api_gen::Target::Render)
-        .expect("generating native render mod API");
-}

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

@@ -1,222 +0,0 @@
-//! Original synthetic capability regression; no game resources or player world.
-//! Run with fresh HORIZON_HOME, HORIZON_LAUNCHER_HOME, XDG_DATA_HOME and XDG_CONFIG_HOME,
-//! HORIZON_NO_AUDIO=1 and HORIZON_LAUNCHER_NO_SELF_UPDATE=1.
-use horizon_client_render::{gfx::Renderer, graphics::GraphicsApi};
-use std::{io::Write, sync::Arc};
-use winit::{
-    application::ApplicationHandler,
-    event::WindowEvent,
-    event_loop::{ActiveEventLoop, EventLoop},
-    window::{Window, WindowId},
-};
-
-const VERTEX: &str = "#version 120\nvoid main() { gl_Position = ftransform(); }\n";
-const COLOUR: &str = "#version 120\nvoid main() { gl_FragColor = vec4(1.0); }\n";
-// Reading the actual shadow sampler activates the shadow pass, rather than just
-// placing a shadow program in the archive and assuming the pass runs.
-const SHADOW_READ: &str = "#version 120\nuniform sampler2D shadowtex0;\n\
-    void main() { gl_FragColor = vec4(vec3(texture2D(shadowtex0, vec2(0.5)).r), 1.0); }\n";
-
-fn pack(properties: &str, shadow: Option<&str>, reads_shadow: bool) -> horizon_shaders::Pack {
-    let mut zip = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
-    let mut write = |name: &str, text: &str| {
-        zip.start_file(
-            format!("shaders/{name}"),
-            zip::write::SimpleFileOptions::default(),
-        )
-        .unwrap();
-        zip.write_all(text.as_bytes()).unwrap();
-    };
-    write("shaders.properties", properties);
-    write("final.vsh", VERTEX);
-    write("final.fsh", if reads_shadow { SHADOW_READ } else { COLOUR });
-    write("gbuffers_entities.vsh", VERTEX);
-    write("gbuffers_entities.fsh", COLOUR);
-    if let Some(shadow) = shadow {
-        write("shadow.vsh", VERTEX);
-        write("shadow.fsh", shadow);
-    }
-    horizon_shaders::Pack::from_zip_bytes(
-        "original-shadow-ownership",
-        zip.finish().unwrap().into_inner(),
-    )
-    .unwrap()
-}
-
-fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
-    let white = [255; 4];
-    let panorama = Arc::new(horizon_client_render::gfx::panorama::Faces::colour([0; 4]));
-    let mut renderer = pollster::block_on(Renderer::new(
-        window,
-        true,
-        &white,
-        1,
-        1,
-        1,
-        &[],
-        &[],
-        (&white, 1, 1),
-        (&white, 1, 1),
-        (&white, 1, 1),
-        (&white, 1),
-        panorama,
-        None,
-        None,
-        GraphicsApi::Vulkan,
-        false,
-        false,
-        true,
-    ))?;
-    assert!(!renderer.pack_entity_shadows(), "no selected pack");
-    renderer.set_shader_pack(0, None, &[]).unwrap();
-    assert!(
-        !renderer.pack_entity_shadows(),
-        "selected pack without a compiled post"
-    );
-
-    let cases = [
-        ("full", "", Some(COLOUR), true, false, true),
-        (
-            "player-only",
-            "shadowEntities=false\nshadowPlayer=true",
-            Some(COLOUR),
-            true,
-            false,
-            false,
-        ),
-        // Block-entity shadows alone must not suppress a mob's blob.
-        (
-            "blocks-only",
-            "shadowEntities=false",
-            Some(COLOUR),
-            true,
-            false,
-            false,
-        ),
-        (
-            "disabled",
-            "shadow.enabled=false",
-            Some(COLOUR),
-            true,
-            false,
-            false,
-        ),
-        ("missing-program", "", None, true, false, false),
-        (
-            "failed-translation",
-            "",
-            Some("#version 120\nvoid main() { gl_FragColor = deliberately_undefined; }"),
-            true,
-            false,
-            false,
-        ),
-        ("failed-pipeline", "", Some(COLOUR), true, true, false),
-        (
-            "unused-shadow-program",
-            "",
-            Some(COLOUR),
-            false,
-            false,
-            false,
-        ),
-        (
-            "forced-shadow-program",
-            "shadow.enabled=true",
-            Some(COLOUR),
-            false,
-            false,
-            true,
-        ),
-    ];
-    for dimension in [0, -1, 1] {
-        for (name, properties, shadow, reads_shadow, break_pipeline, expected) in cases {
-            let pack = pack(properties, shadow, reads_shadow);
-            let mut macros = horizon_shaders::Macros::standard();
-            renderer.define_pack_macros(&mut macros);
-            let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
-            let mut post = horizon_shaders::load_post(
-                &pack,
-                "",
-                &properties,
-                &macros,
-                &renderer.pack_inputs(),
-            );
-            if name == "failed-translation" {
-                assert!(post.shadow_entities.is_none());
-                assert!(post.notes.iter().any(|note| note.contains("skipped")));
-            } else if name == "missing-program" {
-                assert!(post.shadow_entities.is_none());
-                assert!(post.notes.iter().any(|note| note.contains("no program")));
-            } else if break_pipeline {
-                // A translated stage can still fail device pipeline creation. Inject a
-                // missing entry point into only the entity caster; terrain/block stages
-                // and the settings stay valid. PackPost must report the compiled result.
-                post.shadow_entities
-                    .as_mut()
-                    .unwrap()
-                    .program
-                    .as_mut()
-                    .unwrap()
-                    .vertex
-                    .entry_points[0]
-                    .name = "deliberately_missing_main".into();
-            } else {
-                assert!(post.notes.is_empty(), "{name}: {:?}", post.notes);
-            }
-            let (_, notes) = renderer
-                .set_shader_pack(dimension, Some(post), &[])
-                .unwrap()
-                .unwrap();
-            if break_pipeline {
-                assert!(
-                    notes.iter().any(|note| note.contains("skipped")),
-                    "{notes:?}"
-                );
-            } else if name != "missing-program" && name != "failed-translation" {
-                assert!(
-                    !notes.iter().any(|note| note.contains("skipped")),
-                    "{name}: {notes:?}"
-                );
-            }
-            assert_eq!(
-                renderer.pack_entity_shadows(),
-                expected,
-                "{name}, dimension {dimension}: {notes:?}"
-            );
-            assert!(!renderer.native_shadow());
-            println!("{name}, dimension {dimension}: replaces_mob_blob={expected}");
-        }
-    }
-    renderer.drop_shader_packs();
-    assert!(
-        !renderer.pack_entity_shadows(),
-        "dropped pack restores fallback"
-    );
-    println!("ENTITY_SHADOW_OWNERSHIP_PASSED: 27 compiled controls and no/pending/dropped pack");
-    Ok(())
-}
-
-struct App;
-impl ApplicationHandler for App {
-    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        let window = Arc::new(
-            event_loop
-                .create_window(
-                    Window::default_attributes()
-                        .with_visible(false)
-                        .with_inner_size(winit::dpi::LogicalSize::new(32., 32.)),
-                )
-                .unwrap(),
-        );
-        if let Err(error) = fixture(window) {
-            eprintln!("Shadow ownership fixture failed: {error}");
-            std::process::exit(1);
-        }
-        event_loop.exit();
-    }
-    fn window_event(&mut self, _: &ActiveEventLoop, _: WindowId, _: WindowEvent) {}
-}
-
-fn main() {
-    EventLoop::new().unwrap().run_app(&mut App).unwrap();
-}

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

@@ -1,830 +0,0 @@
-//! Draws a scene `horizon-ctl render-capture DIR` wrote, offscreen, from its camera, with the
-//! real `Renderer`, and prints GPU and CPU milliseconds per frame and Horizon's own passes'
-//! GPU times as JSON (docs/graphics.md, "Render capture and replay").
-//! `cargo run --release -p horizon-client-render --example scene_replay -- DIR [--frames 300]
-//! [--warmup 60] [--yaw-offsets 0,90,180,270] [--texture-filtering 0|1|2] [--anisotropy-bit N]
-//! [--mipmaps N] [--lod-distance CHUNKS] [--render-distance CHUNKS] [--size WxH]
-//! [--section-draws flat|indirect] [--section-cull on|off] [--section-sides on|off]
-//! [--gpu-culling on|off] [--root RESOURCES] [--screenshot PNG]
-//! [--world SAVE --leaf-culling MODE] [--memory on]`
-//! `--screenshot` saves the first view's last frame, after the timed frames.
-//! `--world` meshes the captured sections again from that save's region files
-//! (blocks, biomes and saved light; `ao`, `biomeBlendRadius` and `cutoutLeaves`
-//! from `./options.txt`) with `--leaf-culling` (default `off`), so a mesher
-//! change can be measured on the captured view. A section whose 3x3 columns are
-//! not all saved keeps its captured mesh.
-//! `--memory on` adds the renderer's largest GPU resources and, on macOS, the process's
-//! physical footprint by category (`footprint`), taken after the timed frames.
-use horizon_client_render::{
-    assets::{Assets, RenderAssets},
-    biome::Biomes,
-    blocks::BlockFacts,
-    chunk::{BIOME_STRATEGY, Chunk, ColumnLayout, Light, block_strategy},
-    fast_hash::{FxHashMap, FxHashSet},
-    gfx::{
-        PreparedTextures, Renderer, ScreenshotRequest,
-        capture::{self, AtlasCheck, Scene},
-        panorama::Faces,
-    },
-    graphics::LeafCullingMode,
-    hud::HudBatch,
-    lod::TileKey,
-    mesher::{MeshScratch, MeshTables, Mesher, SectionMesh, packed},
-    models,
-};
-use horizon_core::{
-    biome::{BiomeZoom, obfuscate_seed},
-    paletted::PalettedContainer,
-};
-use horizon_world::{
-    chunk::BlockState,
-    nbt::{Limits, NamedTag, Tag},
-    region::RegionFile,
-    registry::BlockRegistry,
-};
-use serde_json::{Value, json};
-use std::{
-    path::{Path, PathBuf},
-    sync::{
-        Arc,
-        atomic::{AtomicUsize, Ordering},
-    },
-    time::{Duration, Instant},
-};
-use winit::{
-    application::ApplicationHandler,
-    event::WindowEvent,
-    event_loop::{ActiveEventLoop, EventLoop},
-    window::{Window, WindowId},
-};
-
-// The game's allocator, so that `--memory`'s footprint is the game's: the system heap kept
-// gigabytes of the meshes `--world` frees dirty.
-#[global_allocator]
-static ALLOCATOR: horizon_threads::Allocator = horizon_threads::ALLOCATOR;
-
-#[derive(Default)]
-struct Options {
-    dir: PathBuf,
-    frames: usize,
-    warmup: usize,
-    yaw_offsets: Vec<f32>,
-    root: Option<PathBuf>,
-    texture_filtering: Option<i32>,
-    anisotropy_bit: Option<i32>,
-    mipmaps: Option<u32>,
-    lod_distance: Option<u32>,
-    render_distance: Option<i32>,
-    size: Option<[u32; 2]>,
-    flat: Option<bool>,
-    cull: Option<bool>,
-    sides: Option<bool>,
-    gpu_culling: Option<bool>,
-    screenshot: Option<PathBuf>,
-    world: Option<PathBuf>,
-    leaf_culling: LeafCullingMode,
-    memory: bool,
-}
-
-fn on_off(value: &str) -> Result<bool, String> {
-    match value {
-        "on" | "flat" => Ok(true),
-        "off" | "indirect" => Ok(false),
-        other => Err(format!("expected on or off, got {other}")),
-    }
-}
-
-fn options() -> Result<Options, String> {
-    let mut o = Options {
-        frames: 300,
-        warmup: 60,
-        yaw_offsets: vec![0.0],
-        ..Default::default()
-    };
-    let mut args = std::env::args().skip(1);
-    let mut dir = None;
-    while let Some(arg) = args.next() {
-        if !arg.starts_with("--") {
-            dir = Some(PathBuf::from(arg));
-            continue;
-        }
-        let value = args.next().ok_or(format!("{arg} needs a value"))?;
-        let number = |v: &str| v.parse::<i64>().map_err(|e| format!("{arg}: {e}"));
-        match arg.as_str() {
-            "--frames" => o.frames = number(&value)?.max(1) as usize,
-            "--warmup" => o.warmup = number(&value)?.max(0) as usize,
-            "--yaw-offsets" => {
-                o.yaw_offsets = value
-                    .split(',')
-                    .map(|v| v.trim().parse::<f32>().map_err(|e| format!("{arg}: {e}")))
-                    .collect::<Result<_, _>>()?
-            }
-            "--root" => o.root = Some(value.into()),
-            "--texture-filtering" => o.texture_filtering = Some(number(&value)? as i32),
-            "--anisotropy-bit" => o.anisotropy_bit = Some(number(&value)? as i32),
-            "--mipmaps" => o.mipmaps = Some(number(&value)?.max(0) as u32),
-            "--lod-distance" => o.lod_distance = Some(number(&value)?.max(0) as u32),
-            "--render-distance" => o.render_distance = Some(number(&value)?.max(0) as i32),
-            "--size" => {
-                let (w, h) = value.split_once('x').ok_or("--size takes WxH")?;
-                o.size = Some([number(w)? as u32, number(h)? as u32]);
-            }
-            "--section-draws" => o.flat = Some(on_off(&value)?),
-            "--section-cull" => o.cull = Some(on_off(&value)?),
-            "--section-sides" => o.sides = Some(on_off(&value)?),
-            "--gpu-culling" => o.gpu_culling = Some(on_off(&value)?),
-            "--screenshot" => o.screenshot = Some(value.into()),
-            "--world" => o.world = Some(value.into()),
-            "--memory" => o.memory = on_off(&value)?,
-            "--leaf-culling" => {
-                o.leaf_culling = LeafCullingMode::ALL
-                    .into_iter()
-                    .find(|mode| mode.name() == value)
-                    .ok_or(format!("no leaf culling mode {value}"))?;
-            }
-            other => return Err(format!("unknown option {other}")),
-        }
-    }
-    o.dir = dir.ok_or("the capture directory is required")?;
-    Ok(o)
-}
-
-/// Milliseconds: average, median, 95th percentile and slowest, over `samples`.
-fn summary(samples: &[f32]) -> Value {
-    if samples.is_empty() {
-        return Value::Null;
-    }
-    let mut sorted = samples.to_vec();
-    sorted.sort_by(f32::total_cmp);
-    let at = |q: f32| sorted[((sorted.len() - 1) as f32 * q).round() as usize];
-    json!({
-        "avg": samples.iter().sum::<f32>() / samples.len() as f32,
-        "min": sorted[0],
-        "p10": at(0.1),
-        "p50": at(0.5),
-        "p95": at(0.95),
-        "max": sorted[sorted.len() - 1],
-        "samples": samples.len(),
-    })
-}
-
-fn ms(d: Duration) -> f32 {
-    d.as_secs_f32() * 1000.0
-}
-
-fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
-    let o = options()?;
-    let scene = Scene::read(&o.dir)?;
-    let settings = &scene.settings;
-    let root = o.root.clone().unwrap_or_else(|| settings.resources.clone());
-    let loading = Instant::now();
-    let assets = Assets::load(&root)?;
-    let render = assets.reload(&root)?;
-    if AtlasCheck::of(&render) != settings.atlas {
-        return Err(format!(
-            "the block sprites at {} are not the ones the capture was made with (resource packs \
-             or mods?): pass --root with the game's resource root",
-            root.display()
-        )
-        .into());
-    }
-    let one = [255u8; 4];
-    let zero = [0u8; 4];
-    let pixels = render.pixels.get();
-    let prepared = PreparedTextures::new(
-        &pixels,
-        render.sprite_size,
-        render.texture_layers,
-        &render.sprite_mips,
-        (&zero[..], 1),
-    )
-    .with_pbr(
-        &render.pbr_normals,
-        &render.pbr_specular,
-        render.pbr_size,
-        render.texture_layers,
-    );
-    let mut renderer = pollster::block_on(Renderer::new(
-        window,
-        true,
-        &pixels,
-        render.sprite_size,
-        render.sprite_minimum_size,
-        render.texture_layers,
-        &render.sprite_mips,
-        &render.animations,
-        (&one[..], 1, 1),
-        (&zero[..], 1, 1),
-        (&zero[..], 1, 1),
-        (&zero[..], 1),
-        Arc::new(Faces::colour([0, 0, 0, 255])),
-        Some(prepared),
-        None,
-        settings.graphics_api(),
-        settings.translucent_batching,
-        false,
-        false,
-    ))?;
-    drop(pixels);
-    render.pixels.pack();
-    let state = &scene.renderer;
-    let [width, height] = o.size.unwrap_or(state.size);
-    renderer.resize(width, height);
-    renderer.gamma = state.gamma;
-    renderer.fullbright = state.fullbright;
-    renderer.improved_transparency = state.improved_transparency;
-    renderer.animated_textures = state.animated_textures;
-    let filtering = o.texture_filtering.unwrap_or(settings.texture_filtering);
-    let anisotropy = o.anisotropy_bit.unwrap_or(settings.anisotropy_bit);
-    renderer.set_texture_filtering(filtering, anisotropy);
-    renderer.set_mipmap_levels(o.mipmaps.unwrap_or(settings.mipmap_levels));
-    renderer.set_world_post(
-        settings.resolution_scale,
-        settings.fxaa,
-        settings.taa,
-        settings.upscale,
-    );
-    let mut notes = Vec::new();
-    let mut note = |what: &str, result: horizon_client_render::Result<()>| {
-        if let Err(e) = result {
-            notes.push(format!("{what}: {e}"));
-        }
-    };
-    note(
-        "section-draws",
-        renderer.set_flat_draws(o.flat.unwrap_or(state.flat_draws)),
-    );
-    note(
-        "section-cull",
-        renderer.set_section_cull(o.cull.unwrap_or(state.section_cull)),
-    );
-    note(
-        "gpu-culling",
-        renderer.set_gpu_culling(o.gpu_culling.unwrap_or(state.gpu_culling)),
-    );
-    renderer.set_section_sides(o.sides.unwrap_or(state.section_sides));
-    renderer.set_pass_timing(true);
-    let layout = ColumnLayout::of_level(state.min_y, state.sections as i32 * 16);
-    if layout != ColumnLayout::VANILLA {
-        renderer.clear_sections(layout);
-    }
-
-    // Near sections first: with no far tile resident yet, none fades in.
-    let camera = scene.frame.camera;
-    let column = |x: f64| (x.floor() as i32) >> 4;
-    let (cx, cz) = (column(camera[0]), column(camera[2]));
-    let near = |x: i32, z: i32| {
-        o.render_distance
-            .is_none_or(|r| (x - cx).pow(2) + (z - cz).pow(2) <= r * r)
-    };
-    let (mut remeshed, mut world_report) = (FxHashMap::default(), Value::Null);
-    if let Some(world) = &o.world {
-        let keys: Vec<[i32; 3]> = section_keys(&o.dir)?
-            .into_iter()
-            .filter(|&[x, _, z]| near(x, z))
-            .collect();
-        let started = Instant::now();
-        remeshed = remesh(world, &root, &assets, &render, o.leaf_culling, &keys)?;
-        world_report = json!({
-            "save": world.display().to_string(),
-            "leaf_culling": o.leaf_culling.name(),
-            "remeshed": remeshed.len(),
-            "kept": keys.len() - remeshed.len(),
-            "remesh_ms": ms(started.elapsed()),
-        });
-    }
-    let leaf_layers = leaf_layers(&render);
-    let (mut sections, mut quads, mut leaf_quads) = (0, 0usize, 0usize);
-    let mut packed_quads = 0usize;
-    capture::read_meshes(&o.dir, "sections", |[x, y, z], captured| {
-        if near(x, z) {
-            let mesh = remeshed.remove(&[x, y, z]).unwrap_or(captured);
-            quads += mesh.solid.len() / 4;
-            packed_quads += packed::packed_quads(&mesh.packed, mesh.solid.len() / 4);
-            leaf_quads += mesh
-                .solid
-                .iter()
-                .filter(|v| leaf_layers.contains(&v.layer))
-                .count()
-                / 4;
-            renderer.upload((x, y, z), &mesh);
-            sections += 1;
-        }
-    })?;
-    let mut tiles: Vec<(TileKey, SectionMesh)> = Vec::new();
-    capture::read_meshes(&o.dir, "tiles", |[x, z, level], mesh| {
-        let key = TileKey {
-            x,
-            z,
-            level: level as u8,
-        };
-        let [ox, _, oz] = key.origin();
-        let half = f64::from(key.size()) / 2.0;
-        let (dx, dz) = (
-            f64::from(ox) + half - camera[0],
-            f64::from(oz) + half - camera[2],
-        );
-        let near = o
-            .lod_distance
-            .is_none_or(|d| (dx * dx + dz * dz).sqrt() <= f64::from(d) * 16.0);
-        if near {
-            tiles.push((key, mesh));
-        }
-    })?;
-    let tile_count = tiles.len();
-    if !tiles.is_empty() {
-        let cutout: FxHashSet<(i32, i32)> = scene.lod_cutout.iter().copied().collect();
-        renderer.queue_lods(tiles, Vec::new(), Some(cutout));
-        renderer.upload_lods(Duration::from_secs(3600));
-    }
-    let loaded_ms = ms(loading.elapsed());
-
-    let hud = HudBatch::new([width, height]);
-    let mut views = Vec::new();
-    for &offset in &o.yaw_offsets {
-        let mut frame = scene.frame(&hud);
-        frame.yaw += offset;
-        frame.eye_rotation[0] += offset;
-        if let Some(r) = o.render_distance {
-            frame.distance = (r * 16) as f32;
-            frame.detail_distance = frame.distance;
-        }
-        let draw = |renderer: &mut Renderer| -> horizon_client_render::Result<Duration> {
-            if frame.cave_culling {
-                renderer.start_occlusion(frame.camera, frame.distance);
-            }
-            let started = Instant::now();
-            renderer.render(&frame)?;
-            Ok(started.elapsed())
-        };
-        for _ in 0..o.warmup {
-            draw(&mut renderer)?;
-        }
-        renderer.gpu_times.clear();
-        let (mut call, mut encode, mut gpu) = (Vec::new(), Vec::new(), Vec::new());
-        for _ in 0..o.frames {
-            call.push(ms(draw(&mut renderer)?));
-            encode.push(ms(renderer.last_encode));
-            gpu.append(&mut renderer.gpu_times);
-        }
-        // Timestamps arrive a few frames late: a few more of the same frame bring them in.
-        for _ in 0..16 {
-            if gpu.len() >= o.frames {
-                break;
-            }
-            draw(&mut renderer)?;
-            gpu.append(&mut renderer.gpu_times);
-        }
-        gpu.truncate(o.frames);
-        if let Some(path) = o.screenshot.as_ref().filter(|_| views.is_empty()) {
-            renderer.screenshot_result = None;
-            renderer.screenshot = Some(ScreenshotRequest {
-                path: path.clone(),
-                size: None,
-                scaled: false,
-            });
-            for _ in 0..32 {
-                draw(&mut renderer)?;
-                if renderer.screenshot_result.is_some() {
-                    break;
-                }
-            }
-            match renderer.screenshot_result.take() {
-                Some(Ok(_)) => {}
-                Some(Err(e)) => notes.push(format!("screenshot: {e}")),
-                None => notes.push("screenshot: not saved".into()),
-            }
-        }
-        views.push(json!({
-            "yaw_offset": offset,
-            "gpu_ms": summary(&gpu),
-            "render_call_ms": summary(&call),
-            "cpu_encode_ms": summary(&encode),
-            "gpu_passes_median_ms": renderer
-                .own_pass_times()
-                .into_iter()
-                .map(|(name, ms)| (name, json!(ms)))
-                .collect::<serde_json::Map<_, _>>(),
-            "drawn_sections": renderer.drawn_sections,
-            "section_draws": renderer.section_draws,
-            "section_draw_calls": renderer.section_draw_calls,
-            // Occlusion culling's last result: boxes hidden, boxes tested, share of solid
-            // indices hidden.
-            "culled": renderer.culled_sections(),
-        }));
-    }
-    let section_draws = if renderer.flat_draws() {
-        "flat"
-    } else {
-        "indirect"
-    };
-    let memory = o.memory.then(|| memory_report(&renderer));
-    let report = json!({
-        "capture": o.dir.display().to_string(),
-        "adapter": renderer.info.name,
-        "captured_on": state.adapter,
-        "size": [width, height],
-        "sections": sections,
-        "solid_quads": quads,
-        "leaf_quads": leaf_quads,
-        // Solid quads uploaded as one record each (`mesher::packed`).
-        "packed_quads": packed_quads,
-        "world": world_report,
-        "tiles": tile_count,
-        "load_ms": loaded_ms,
-        "frames": o.frames,
-        "warmup": o.warmup,
-        "settings": {
-            "texture_filtering": filtering,
-            "anisotropy_bit": anisotropy,
-            "mipmaps": o.mipmaps.unwrap_or(settings.mipmap_levels),
-            "lod_distance": o.lod_distance,
-            "render_distance": o.render_distance,
-            "section_draws": section_draws,
-            "section_cull": renderer.section_cull(),
-            "section_sides": renderer.section_sides(),
-            "gpu_culling": renderer.gpu_culling(),
-            "shader_pack_left_out": state.shader_pack,
-        },
-        "notes": notes,
-        "views": views,
-        "memory": memory,
-    });
-    println!("{}", serde_json::to_string_pretty(&report)?);
-    Ok(())
-}
-
-fn mb(bytes: u64) -> f64 {
-    (bytes as f64 / 1048576.0 * 10.0).round() / 10.0
-}
-
-/// `--memory`: the renderer's census in MiB and, on macOS, `footprint`'s summary of this
-/// process (GPU buffers and textures count as IOAccelerator memory there).
-fn memory_report(renderer: &Renderer) -> Value {
-    let gpu: serde_json::Map<String, Value> = renderer
-        .gpu_census()
-        .into_iter()
-        .map(|(name, bytes)| (format!("{name}_mb"), json!(mb(bytes))))
-        .collect();
-    let footprint = std::process::Command::new("/usr/bin/footprint")
-        .args(["-f", "bytes", "-p", &std::process::id().to_string()])
-        .output()
-        .ok()
-        .map(|out| String::from_utf8_lossy(&out.stdout).into_owned());
-    let footprint = footprint.map(|text| {
-        let mut total = None;
-        let mut categories = Vec::new();
-        for line in text.lines() {
-            if let Some(at) = line.find("Footprint: ") {
-                total = line[at + 11..]
-                    .split_whitespace()
-                    .next()
-                    .and_then(|v| v.parse::<u64>().ok());
-            }
-            // "  <dirty> B  <clean> B  <reclaimable> B  <regions>  <category>"
-            let words: Vec<&str> = line.split_whitespace().collect();
-            if words.len() >= 8
-                && words[1] == "B"
-                && let Ok(dirty) = words[0].parse::<u64>()
-                && dirty >= 1 << 20
-            {
-                categories.push(json!([words[7..].join(" "), mb(dirty)]));
-            }
-        }
-        json!({ "total_mb": total.map(mb), "dirty_by_category_mb": categories })
-    });
-    json!({ "gpu": gpu, "footprint": footprint })
-}
-
-struct App;
-impl ApplicationHandler for App {
-    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        let window = Arc::new(
-            event_loop
-                .create_window(Window::default_attributes().with_visible(false))
-                .unwrap(),
-        );
-        if let Err(error) = replay(window) {
-            eprintln!("scene_replay: {error}");
-            std::process::exit(1);
-        }
-        event_loop.exit();
-    }
-    fn window_event(&mut self, _: &ActiveEventLoop, _: WindowId, _: WindowEvent) {}
-}
-
-fn main() {
-    EventLoop::new().unwrap().run_app(&mut App).unwrap();
-}
-
-/// The captured sections' keys, from the index alone.
-fn section_keys(dir: &Path) -> Result<Vec<[i32; 3]>, Box<dyn std::error::Error>> {
-    #[derive(serde::Deserialize)]
-    struct Key {
-        key: [i32; 3],
-    }
-    let records: Vec<Key> = serde_json::from_reader(std::io::BufReader::new(std::fs::File::open(
-        dir.join("sections.json"),
-    )?))?;
-    Ok(records.into_iter().map(|r| r.key).collect())
-}
-
-/// Sprite layers of every leaves block, as terrain vertices carry them (with or
-/// without `OPAQUE_LAYER`).
-fn leaf_layers(render: &RenderAssets) -> FxHashSet<u16> {
-    render
-        .sprite_layers
-        .iter()
-        .filter(|(name, _)| name.ends_with("_leaves"))
-        .flat_map(|(_, &layer)| {
-            [
-                layer as u16,
-                layer as u16 | horizon_client_render::mesher::OPAQUE_LAYER,
-            ]
-        })
-        .collect()
-}
-
-/// `--world`: the sections `keys` meshed again from `save`'s overworld region
-/// files, on every core, as the game's workers mesh them.
-fn remesh(
-    save: &Path,
-    root: &Path,
-    assets: &Assets,
-    render: &RenderAssets,
-    leaf_culling: LeafCullingMode,
-    keys: &[[i32; 3]],
-) -> Result<FxHashMap<[i32; 3], SectionMesh>, Box<dyn std::error::Error>> {
-    let facts = BlockFacts::load(root, assets.registry)?;
-    let visibility = models::load_visibility(root, assets.registry)?;
-    let tables = MeshTables::new(assets, render, &facts, visibility)?;
-    let biomes = Biomes::load(root)?;
-    let seed = world_seed(save).unwrap_or_else(|| {
-        eprintln!(
-            "scene_replay: no seed in {}, biome blending uses 0",
-            save.display()
-        );
-        0
-    });
-    let options = std::fs::read_to_string("options.txt").unwrap_or_default();
-    let option = |key: &str| {
-        options
-            .lines()
-            .find_map(|l| l.strip_prefix(key)?.strip_prefix(':').map(str::to_owned))
-    };
-    let smooth_lighting = option("ao").is_none_or(|v| v == "true");
-    let cutout_leaves = option("cutoutLeaves").is_none_or(|v| v == "true");
-    let blend_radius = option("biomeBlendRadius")
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(2);
-
-    let mut columns: Vec<(i32, i32)> = keys
-        .iter()
-        .flat_map(|&[x, _, z]| {
-            (-1..=1).flat_map(move |dz| (-1..=1).map(move |dx| (x + dx, z + dz)))
-        })
-        .collect();
-    columns.sort_unstable();
-    columns.dedup();
-    let threads = std::thread::available_parallelism().map_or(4, |n| n.get());
-    let region_dir = save.join("dimensions/minecraft/overworld/region");
-    let next = AtomicUsize::new(0);
-    let chunks: FxHashMap<(i32, i32), Chunk> = std::thread::scope(|scope| {
-        let workers: Vec<_> = (0..threads)
-            .map(|_| {
-                scope.spawn(|| {
-                    let mut files: FxHashMap<(i32, i32), Option<RegionFile>> = FxHashMap::default();
-                    let mut out = Vec::new();
-                    loop {
-                        let i = next.fetch_add(1, Ordering::Relaxed);
-                        let Some(&(x, z)) = columns.get(i) else {
-                            break;
-                        };
-                        let file = files.entry((x >> 5, z >> 5)).or_insert_with(|| {
-                            RegionFile::open(region_dir.join(format!(
-                                "r.{}.{}.mca",
-                                x >> 5,
-                                z >> 5
-                            )))
-                            .ok()
-                        });
-                        let root = file
-                            .as_mut()
-                            .and_then(|f| {
-                                f.read(horizon_core::position::ChunkPos::new(x, z))
-                                    .ok()
-                                    .flatten()
-                            })
-                            .and_then(|record| record.nbt(Limits::default()).ok());
-                        if let Some(chunk) =
-                            root.and_then(|root| decode(&root, assets.registry, &biomes))
-                        {
-                            out.push(((x, z), chunk));
-                        }
-                    }
-                    out
-                })
-            })
-            .collect();
-        workers
-            .into_iter()
-            .flat_map(|w| w.join().unwrap())
-            .collect()
-    });
-
-    let meshable: Vec<[i32; 3]> = keys
-        .iter()
-        .copied()
-        .filter(|&[x, _, z]| {
-            (-1..=1).all(|dz| (-1..=1).all(|dx| chunks.contains_key(&(x + dx, z + dz))))
-        })
-        .collect();
-    let next = AtomicUsize::new(0);
-    let meshes = std::thread::scope(|scope| {
-        let workers: Vec<_> = (0..threads)
-            .map(|_| {
-                scope.spawn(|| {
-                    let mut mesher = Mesher {
-                        nether_shading: false,
-                        shader_pack_lighting: false,
-                        separate_ao: false,
-                        assets,
-                        render,
-                        tables: &tables,
-                        biomes: &biomes,
-                        visibility: tables.visibility.clone(),
-                        zoom: BiomeZoom::new(obfuscate_seed(seed)),
-                        blend_radius,
-                        smooth_lighting,
-                        cutout_leaves,
-                        translucent_layers: &[],
-                        leaf_culling,
-                    };
-                    let mut scratch = MeshScratch::default();
-                    let mut out = Vec::new();
-                    loop {
-                        let i = next.fetch_add(1, Ordering::Relaxed);
-                        let Some(&[x, y, z]) = meshable.get(i) else {
-                            break;
-                        };
-                        let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
-                            std::array::from_fn(|dx| {
-                                chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1))
-                            })
-                        });
-                        let mut mesh =
-                            mesher.mesh_reusing(&region, y, SectionMesh::default(), &mut scratch);
-                        mesh.sort_solid();
-                        out.push(([x, y, z], mesh));
-                    }
-                    out
-                })
-            })
-            .collect();
-        workers
-            .into_iter()
-            .flat_map(|w| w.join().unwrap())
-            .collect::<FxHashMap<_, _>>()
-    });
-    Ok(meshes)
-}
-
-/// The world seed: `data/minecraft/world_gen_settings.dat`, or level.dat's
-/// `Data.WorldGenSettings` in older saves.
-fn world_seed(save: &Path) -> Option<i64> {
-    let read = |path: PathBuf| {
-        horizon_world::datafix::files::read_dat(&path)
-            .ok()
-            .flatten()
-    };
-    let seed = |tag: Option<&Tag>| match tag?.get("seed")? {
-        Tag::Long(seed) => Some(*seed),
-        _ => None,
-    };
-    seed(
-        read(save.join("data/minecraft/world_gen_settings.dat"))
-            .as_ref()
-            .and_then(|t| t.get("data")),
-    )
-    .or_else(|| {
-        seed(
-            read(save.join("level.dat"))?
-                .get("Data")?
-                .get("WorldGenSettings"),
-        )
-    })
-}
-
-/// A saved full chunk's blocks, biomes and light, as the client's own save
-/// loader reads them (`save::decode_lit`, in horizon-client).
-fn decode(root: &NamedTag, registry: &BlockRegistry, biomes: &Biomes) -> Option<Chunk> {
-    let tag = &root.tag;
-    let text = |t: Option<&Tag>| match t {
-        Some(Tag::String(s)) => Some(s.to_string_lossy().to_string()),
-        _ => None,
-    };
-    if text(tag.get("Status")).is_some_and(|s| s != "minecraft:full" && s != "full") {
-        return None;
-    }
-    if tag.get("isLightOn") != Some(&Tag::Byte(1)) {
-        return None;
-    }
-    let (Some(Tag::Int(x)), Some(Tag::Int(z))) = (tag.get("xPos"), tag.get("zPos")) else {
-        return None;
-    };
-    let mut chunk = Chunk::with_layout(*x, *z, ColumnLayout::VANILLA);
-    let air = registry.default_state("minecraft:air")?.0;
-    let Some(Tag::List(sections)) = tag.get("sections") else {
-        return Some(chunk);
-    };
-    let longs = |t: Option<&Tag>| match t {
-        Some(Tag::LongArray(data)) => Some(data.iter().map(|&w| w as u64).collect::<Vec<_>>()),
-        _ => None,
-    };
-    let mut layers = vec![(None, None); chunk.sections.len()];
-    for section in sections {
-        let Some(Tag::Byte(y)) = section.get("Y") else {
-            continue;
-        };
-        let Some(si) = chunk.section_index(i32::from(*y) * 16) else {
-            continue;
-        };
-        let target = Arc::make_mut(&mut chunk.sections[si]);
-        if let Some(states) = section.get("block_states")
-            && let Some(Tag::List(palette)) = states.get("palette")
-        {
-            let palette: Vec<u32> = palette
-                .iter()
-                .map(|p| {
-                    BlockState::from_nbt(p)
-                        .ok()
-                        .and_then(|s| {
-                            registry.id(&s).or_else(|| {
-                                let default = registry.default_state(&s.name)?;
-                                let mut full = registry.state(default)?.clone();
-                                for (k, v) in &s.properties {
-                                    if full.properties.contains_key(k) {
-                                        full.properties.insert(k.clone(), v.clone());
-                                    }
-                                }
-                                registry.id(&full).or(Some(default))
-                            })
-                        })
-                        .map_or(air, |id| id.0)
-                })
-                .collect();
-            let data = longs(states.get("data"));
-            if let Ok(blocks) =
-                PalettedContainer::from_packed(block_strategy(), palette, data.as_deref())
-            {
-                target.blocks = blocks;
-            }
-        }
-        if let Some(b) = section.get("biomes")
-            && let Some(Tag::List(palette)) = b.get("palette")
-        {
-            let palette: Vec<u32> = palette
-                .iter()
-                .map(|p| match p {
-                    Tag::String(s) => u32::from(biomes.id(&s.to_string_lossy())),
-                    _ => 0,
-                })
-                .collect();
-            let data = longs(b.get("data"));
-            if let Ok(container) =
-                PalettedContainer::from_packed(BIOME_STRATEGY, palette, data.as_deref())
-            {
-                target.biomes = container;
-            }
-        }
-        let layer = |name: &str| match section.get(name) {
-            Some(Tag::ByteArray(a)) if a.len() == 2048 => Some(a.clone()),
-            _ => None,
-        };
-        layers[si] = (layer("SkyLight"), layer("BlockLight"));
-    }
-    // `save::load_light`: a section without saved sky light takes the light
-    // of the blocks above it, from the top of the column down.
-    let mut above = [15u8; 256];
-    for (si, (sky, block)) in layers.into_iter().enumerate().rev() {
-        let mut data = Box::new([0u8; 4096]);
-        for (i, v) in data.iter_mut().enumerate() {
-            let nibble =
-                |layer: &Option<Vec<u8>>| layer.as_ref().map(|l| l[i >> 1] >> ((i & 1) << 2) & 15);
-            let s = nibble(&sky).unwrap_or(above[i & 255]);
-            let b = nibble(&block).unwrap_or(0);
-            *v = s << 4 | b;
-        }
-        if sky.is_some() {
-            for (i, a) in above.iter_mut().enumerate() {
-                *a = data[i] >> 4;
-            }
-        }
-        let section = Arc::make_mut(&mut chunk.sections[si]);
-        section.light = Light::Full(data);
-        section.compact();
-    }
-    chunk.lit = true;
-    chunk.light_loaded = true;
-    Some(chunk)
-}

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

@@ -1,404 +0,0 @@
-//! Original asset-free standard-pack entity fixture. Run with throwaway HORIZON_HOME,
-//! HORIZON_LAUNCHER_HOME, XDG_DATA_HOME and XDG_CONFIG_HOME (AGENTS.md).
-//! `cargo run -p horizon-client-render --example standard_pack_gpu_entities -- <output-dir>`
-use client::{
-    gfx::{
-        Frame, Renderer, ScreenshotRequest,
-        entity_skin::{SkinFrame, SkinJob, SkinPart, SkinVertex},
-        native_render,
-        pack_draw::EntitySpan,
-    },
-    graphics::GraphicsApi,
-    hud::HudBatch,
-};
-use horizon_client_render as client;
-use std::{
-    path::Path,
-    sync::{
-        Arc,
-        atomic::{AtomicBool, AtomicUsize, Ordering},
-    },
-};
-use winit::{
-    application::ApplicationHandler,
-    event::WindowEvent,
-    event_loop::{ActiveEventLoop, EventLoop},
-    window::{Window, WindowId},
-};
-
-static NEEDS_SPANS: AtomicBool = AtomicBool::new(false);
-static OBSERVED: AtomicUsize = AtomicUsize::new(0);
-struct Observer;
-impl native_render::RenderHooks for Observer {
-    fn render_needs(&self, event: &mut native_render::RenderNeedsEvent<'_>) {
-        event.needs.entity_spans |= NEEDS_SPANS.load(Ordering::Relaxed);
-    }
-    fn world_drawn(&self, event: &mut native_render::WorldDrawnEvent<'_, '_>) {
-        if NEEDS_SPANS.load(Ordering::Relaxed) {
-            assert_eq!(event.world.entities.len(), 12);
-            assert_eq!(
-                event.world.spans.iter().map(|s| s.id).collect::<Vec<_>>(),
-                [77, 88, 99]
-            );
-            OBSERVED.fetch_add(1, Ordering::Relaxed);
-        }
-    }
-}
-
-fn pack(renderer: &mut Renderer, folder: &Path, valid: bool) {
-    let shaders = folder.join("shaders");
-    std::fs::create_dir_all(&shaders).unwrap();
-    let vertex = "#version 120\nvarying vec2 uv; void main(){gl_Position=ftransform();uv=gl_MultiTexCoord0.xy;}\n";
-    let fragment = "#version 120\nuniform int entityId; uniform int blockEntityId; uniform vec4 entityColor; void main(){gl_FragData[0]=vec4(float(entityId)/255.0,entityColor.a,float(blockEntityId)/255.0,1.0);}\n";
-    for program in [
-        "gbuffers_entities",
-        "gbuffers_block",
-        "gbuffers_entities_translucent",
-    ] {
-        std::fs::write(shaders.join(format!("{program}.vsh")), vertex).unwrap();
-        std::fs::write(
-            shaders.join(format!("{program}.fsh")),
-            if valid {
-                fragment
-            } else {
-                "#version 120\nvoid main(){ invalid shader; }"
-            },
-        )
-        .unwrap();
-    }
-    std::fs::write(shaders.join("final.vsh"), vertex).unwrap();
-    std::fs::write(shaders.join("final.fsh"), "#version 120\nvarying vec2 uv; uniform sampler2D colortex0; void main(){gl_FragColor=texture2D(colortex0,uv);}\n").unwrap();
-    std::fs::write(
-        shaders.join("shaders.properties"),
-        "oldLighting=false\nshadow.enabled=false\n",
-    )
-    .unwrap();
-    let pack = horizon_shaders::Pack::open(folder).unwrap();
-    let mut macros = horizon_shaders::Macros::standard();
-    renderer.define_pack_macros(&mut macros);
-    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
-    let post = horizon_shaders::load_post(&pack, "", &properties, &macros, &renderer.pack_inputs());
-    assert_eq!(post.notes.is_empty(), valid, "{:?}", post.notes);
-    let (_, notes) = renderer
-        .set_shader_pack(0, Some(post), &[])
-        .unwrap()
-        .unwrap();
-    assert!(
-        !valid || notes.iter().all(|n| !n.contains("skipped")),
-        "{notes:?}"
-    );
-}
-
-fn read(path: &Path) -> Vec<u8> {
-    let decoder = png::Decoder::new(std::io::BufReader::new(std::fs::File::open(path).unwrap()));
-    let mut reader = decoder.read_info().unwrap();
-    let mut bytes = vec![0; reader.output_buffer_size().unwrap()];
-    let info = reader.next_frame(&mut bytes).unwrap();
-    assert_eq!(info.color_type, png::ColorType::Rgba);
-    bytes.truncate(info.buffer_size());
-    bytes
-}
-
-fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
-    let out = std::env::args().nth(1).ok_or("output directory required")?;
-    let out = Path::new(&out);
-    std::fs::create_dir_all(out)?;
-    native_render::install(Box::new([&Observer])).map_err(|_| "observer already installed")?;
-    let white = [255; 16 * 16 * 4];
-    let zero = [0; 4];
-    let mut renderer = pollster::block_on(Renderer::new(
-        window,
-        true,
-        &white,
-        16,
-        16,
-        1,
-        &[],
-        &[],
-        (&white, 16, 16),
-        (&zero, 1, 1),
-        (&zero, 1, 1),
-        (&zero, 1),
-        Arc::new(client::gfx::panorama::Faces::colour([0, 0, 0, 255])),
-        None,
-        None,
-        GraphicsApi::Vulkan,
-        false,
-        false,
-        true,
-    ))?;
-    renderer.resize(320, 180);
-    assert!(
-        renderer.skins_entities(),
-        "fixture requires compute skinning"
-    );
-    let unmodified_tagged = renderer.skins_tagged();
-    pack(&mut renderer, &out.join("valid-pack"), true);
-    assert!(
-        !renderer.skins_tagged(),
-        "eye/tagged layers keep the CPU path with a pack"
-    );
-
-    let spans = [77, 88, 99]
-        .into_iter()
-        .enumerate()
-        .map(|(i, id)| EntitySpan {
-            start: i as u32 * 4,
-            stage: horizon_shaders::render_stage("ENTITIES"),
-            id,
-            hidden: i == 2,
-            ..Default::default()
-        })
-        .collect::<Vec<_>>();
-    let mut skin = SkinFrame {
-        reset: true,
-        vertices: 12,
-        spans: spans.clone(),
-        parts: vec![SkinPart {
-            matrix: glam::Mat4::IDENTITY.to_cols_array(),
-            normal: glam::Mat3::IDENTITY.to_cols_array(),
-        }],
-        ..Default::default()
-    };
-    for (i, x) in [-1.8, 0.3, -0.7].into_iter().enumerate() {
-        for (pos, uv) in [
-            [x, -0.8, 5.],
-            [x, 0.8, 5.],
-            [x + 1.4, 0.8, 5.],
-            [x + 1.4, -0.8, 5.],
-        ]
-        .into_iter()
-        .zip([[0., 0.], [0., 1.], [1., 1.], [1., 0.]])
-        {
-            skin.new_model.push(SkinVertex {
-                pos,
-                uv,
-                axis: 5,
-                part: 0,
-            });
-        }
-        skin.jobs.push(SkinJob {
-            first: i as u32 * 4,
-            dst: i as u32 * 4,
-            count: 4,
-            rect: [0., 0., 1., 1.],
-            color: u32::MAX,
-            light: 0xf0f0,
-            overlay: if i == 0 { 1 } else { 5 },
-            ..Default::default()
-        });
-    }
-    let cpu = client::gfx::entity_skin::expand(&skin.new_model, &skin);
-    let hud = HudBatch::new([320, 180]);
-    let mut frame = fixture_frame(&hud);
-    frame.title = false;
-    frame.camera = glam::DVec3::ZERO;
-    frame.eye = glam::DVec3::ZERO;
-    frame.pitch = 0.;
-    frame.entities = &cpu;
-    frame.entity_spans = &spans;
-    renderer.screenshot = Some(ScreenshotRequest {
-        path: out.join("cpu.png"),
-        size: None,
-        scaled: false,
-    });
-    renderer.render(&frame)?;
-    let expected = read(&out.join("cpu.png"));
-    let matches = expected
-        .as_chunks::<4>()
-        .0
-        .iter()
-        .filter(|p| p[..3] == [77, 77, 0])
-        .count();
-    assert!(
-        matches > 100,
-        "original entity-ID/hurt output, got {matches} pixels"
-    );
-    let white = expected
-        .as_chunks::<4>()
-        .0
-        .iter()
-        .filter(|p| p[..3] == [88, 192, 0])
-        .count();
-    assert!(
-        white > 100,
-        "original entity-ID/white-flash output, got {white} pixels"
-    );
-    assert_eq!(
-        expected
-            .as_chunks::<4>()
-            .0
-            .iter()
-            .filter(|p| p[0] == 99)
-            .count(),
-        0,
-        "hidden caster is not camera-visible"
-    );
-    assert!(
-        renderer.skins_entities(),
-        "compiled standard-pack stages must accept GPU posing"
-    );
-    frame.entities = &[];
-    frame.entity_spans = &[];
-    frame.skin = Some(&skin);
-    renderer.screenshot = Some(ScreenshotRequest {
-        path: out.join("gpu.png"),
-        size: None,
-        scaled: false,
-    });
-    renderer.render(&frame)?;
-    assert_eq!(
-        read(&out.join("gpu.png")),
-        expected,
-        "CPU and GPU standard-pack pixels"
-    );
-
-    NEEDS_SPANS.store(true, Ordering::Relaxed);
-    assert!(
-        !renderer.skins_entities(),
-        "native CPU-stream observer keeps its fallback"
-    );
-    frame.skin = None;
-    frame.entities = &cpu;
-    frame.entity_spans = &spans;
-    renderer.render(&frame)?;
-    assert_eq!(OBSERVED.load(Ordering::Relaxed), 1);
-    NEEDS_SPANS.store(false, Ordering::Relaxed);
-    assert!(renderer.skins_entities());
-    pack(&mut renderer, &out.join("failed-pack"), false);
-    assert!(
-        !renderer.skins_entities(),
-        "failed entity programs retain CPU posing"
-    );
-    renderer.drop_shader_packs();
-    assert!(
-        renderer.skins_entities(),
-        "ordinary path returns when the pack is dropped"
-    );
-    assert_eq!(renderer.skins_tagged(), unmodified_tagged);
-    std::fs::write(
-        out.join("result.json"),
-        serde_json::to_vec_pretty(&serde_json::json!({
-            "cpu_gpu_pixels_equal": true, "entity_id_hurt_pixels": matches, "hidden_subject_pixels": 0,
-                "entity_id_white_flash_pixels": white,
-                "graphics_adapter": client::crash::system_details("fixture").into_iter()
-                    .find(|(name, _)| name == "Graphics Adapter").map(|(_, detail)| detail),
-            "native_observer_frames": OBSERVED.load(Ordering::Relaxed), "player_game_started": false,
-            "fixture_only_not_gameplay_or_fps_proof": true
-        }))?,
-    )?;
-    Ok(())
-}
-
-struct App;
-impl ApplicationHandler for App {
-    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        let window = Arc::new(
-            event_loop
-                .create_window(Window::default_attributes().with_visible(false))
-                .unwrap(),
-        );
-        if let Err(error) = fixture(window) {
-            eprintln!("fixture failed: {error}");
-            std::process::exit(1);
-        }
-        event_loop.exit();
-    }
-    fn window_event(&mut self, _: &ActiveEventLoop, _: WindowId, _: WindowEvent) {}
-}
-fn main() {
-    for key in [
-        "HORIZON_HOME",
-        "HORIZON_LAUNCHER_HOME",
-        "XDG_DATA_HOME",
-        "XDG_CONFIG_HOME",
-    ] {
-        assert!(
-            std::env::var_os(key).is_some(),
-            "set throwaway {key} (AGENTS.md)"
-        );
-    }
-    EventLoop::new().unwrap().run_app(&mut App).unwrap();
-}
-
-fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
-    Frame {
-        weather: &[],
-        weather_time: client::weather::Time::new(0, 0.0),
-        camera: glam::DVec3::new(0.5, 100.0, 0.5),
-        yaw: 0.0,
-        pitch: 10.0,
-        fov_degrees: 85.0,
-        eye: glam::DVec3::new(0.5, 100.0, 0.5),
-        eye_rotation: [0.0, 10.0],
-        first_person: true,
-        bob: glam::Mat4::IDENTITY,
-        spin: glam::Mat4::IDENTITY,
-        sky: client::environment::Sky::default(),
-        shadow_scene_revision: (0, 0),
-        shadow_cache: false,
-        distance: 12.0,
-        detail_distance: 12.0,
-        depth_far: 1000.0,
-        underwater: false,
-        water_plane: None,
-        cave_culling: false,
-        title: true,
-        sky_blocked: false,
-        skybox: false,
-        end_sky: false,
-        end_sky_sprite: None,
-        environment_fog: None,
-        water_fog: [0.0; 3],
-        fog: None,
-        dark_disc: false,
-        outline: Vec::new(),
-        outline_after_terrain: false,
-        outline_high_contrast: false,
-        pvp: Default::default(),
-        debug_lines: &[],
-        debug_lines_on_top: &[],
-        debug_crosshair: &[],
-        hud,
-        glint_alpha: 0.75,
-        glint_ticks: 0.0,
-        nether_lighting: false,
-        entities: &[],
-        static_block_entities: &[],
-        visible_static_block_entity_sections: &[],
-        static_block_entity_stats: Default::default(),
-        entity_motion: &[],
-        entity_spans: &[],
-        skin: None,
-        glowing: &[],
-        dynamic_lights: &[],
-        colored_lights: &[],
-        emissive_layers: &[],
-        clouds: None,
-        lightning: Default::default(),
-        additive: &[],
-        see_through: &[],
-        world_primitives: Default::default(),
-        shadow_only: &[],
-        celestial: &[],
-        stars: None,
-        hand: &[],
-        hand_items: &[],
-        hand_fov_degrees: 70.0,
-        screen: &[],
-        pack: Default::default(),
-        border: None,
-        game_time: 0.0,
-        shader_game_time: 0.0,
-        end_portal_sprites: [[0.0; 4]; 2],
-        crumbling_sprite: [0.0; 4],
-        ticks: 0,
-        darkness: (0.0, 0.0),
-        night_vision: 0.0,
-        block_flicker: 0.0,
-        boss_darken: 0.0,
-        chunk_fade: 0.0,
-        post_effects: client::post_chain::Request::none(),
-        menu_blur: None,
-    }
-}

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

@@ -84,9 +84,7 @@ pub struct Assets {
 pub struct RenderAssets {
     pub sprite_size: u32,
     pub sprite_minimum_size: u32,
-    /// The block sprites' RGBA, layer by layer: as built until a renderer has
-    /// them, then kept compressed ([`SpritePixels`]).
-    pub pixels: SpritePixels,
+    pub pixels: Vec<u8>,
     pub texture_layers: u32,
     pub model_catalog: crate::models::StateModels,
     /// Shared parsed resources; item-only validation errors surface at item preparation.
@@ -107,84 +105,7 @@ pub struct RenderAssets {
     pub pbr_size: u32,
     /// OptiFine connected textures (empty without `optifine/ctm` files).
     pub connected: crate::connected::ConnectedTextures,
-    /// Fusion connected textures (empty without Fusion's connecting textures and models).
-    pub fusion: crate::fusion::FusionTextures,
-    /// Counts up each time resources load, from 1: a native mod asks again where blocks'
-    /// sprites are when it changes (`native_block_sprites_version`).
-    pub generation: u64,
 }
-/// The block sprites' pixels for a renderer to upload. Once a renderer has
-/// them ([`Self::pack`]) they are kept lz4-compressed: the GPU holds the
-/// texture array, and the copy only serves a renderer made again (another
-/// window, a lost device, another graphics API), which waits for
-/// [`Self::get`] to uncompress them. Shared by the window and the workers'
-/// `RenderAssets`, so the compressed form replaces the raw one in place.
-pub struct SpritePixels(Arc<PixelStore>);
-struct PixelStore {
-    len: usize,
-    /// Set by the first `pack`: later calls cost one atomic read.
-    packing: std::sync::atomic::AtomicBool,
-    /// As built; dropped once `packed` holds them.
-    raw: std::sync::Mutex<Option<Arc<Vec<u8>>>>,
-    packed: std::sync::OnceLock<Vec<u8>>,
-}
-impl SpritePixels {
-    pub fn new(pixels: Vec<u8>) -> Self {
-        Self(Arc::new(PixelStore {
-            len: pixels.len(),
-            packing: std::sync::atomic::AtomicBool::new(false),
-            raw: std::sync::Mutex::new(Some(Arc::new(pixels))),
-            packed: std::sync::OnceLock::new(),
-        }))
-    }
-    /// Their size in bytes, uncompressed.
-    pub fn len(&self) -> usize {
-        self.0.len
-    }
-    pub fn is_empty(&self) -> bool {
-        self.0.len == 0
-    }
-    /// The pixels as built, uncompressed again once packed.
-    pub fn get(&self) -> Arc<Vec<u8>> {
-        let raw = self.0.raw.lock().unwrap_or_else(|e| e.into_inner()).clone();
-        raw.unwrap_or_else(|| {
-            let packed = self.0.packed.get().map(Vec::as_slice).unwrap_or_default();
-            Arc::new(
-                lz4_flex::decompress_size_prepended(packed)
-                    .ok()
-                    .filter(|p| p.len() == self.0.len)
-                    .unwrap_or_else(|| vec![0; self.0.len]),
-            )
-        })
-    }
-    /// Keep them compressed from now on, once a renderer has uploaded them:
-    /// compressed on a thread of their own, the raw copy dropped after.
-    pub fn pack(&self) {
-        use std::sync::atomic::Ordering;
-        if self.0.len == 0 || self.0.packing.swap(true, Ordering::Relaxed) {
-            return;
-        }
-        let store = self.0.clone();
-        let job = move || {
-            let raw = store.raw.lock().unwrap_or_else(|e| e.into_inner()).clone();
-            if let Some(raw) = raw {
-                let _ = store.packed.set(lz4_flex::compress_prepend_size(&raw));
-                // `get` reads the compressed copy from here on.
-                *store.raw.lock().unwrap_or_else(|e| e.into_inner()) = None;
-            }
-        };
-        let fallback = job.clone();
-        if std::thread::Builder::new()
-            .name("Sprite packing".into())
-            .spawn(job)
-            .is_err()
-        {
-            fallback();
-        }
-    }
-}
-/// The last `RenderAssets::generation` handed out.
-static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
 fn invalid(message: &str) -> io::Error {
     io::Error::new(io::ErrorKind::InvalidData, message)
 }
@@ -196,7 +117,8 @@ impl Assets {
         if manifest["data_version"].as_i64() != Some(i64::from(DATA_VERSION)) {
             return Err(invalid("resources do not match Horizon's pinned data version").into());
         }
-        let (registry, flags) = horizon_world::level::data::load_registry_with_flags(root)?;
+        let (registry, flags) =
+            BlockRegistry::from_facts_json_with_flags(File::open(root.join("facts.json"))?)?;
         let bundle: Value =
             serde_json::from_reader(BufReader::new(File::open(root.join("block-tags.json"))?))?;
         let mut definitions = TagDefinitions::default();
@@ -279,20 +201,6 @@ impl Assets {
     pub fn reload(&self, root: &Path) -> Result<RenderAssets> {
         RenderAssets::load(root, self)
     }
-    /// [`Assets::reload`] with the model library already parsed.
-    ///
-    /// Parsing it reads every model file under `assets/`, which needs no
-    /// block registry, so a caller that has the files to spare can start
-    /// it before `Assets::load` finishes and hand the result in here. On
-    /// a cold cache that is most of a second of reading moved off the
-    /// critical path.
-    pub fn reload_with_models(
-        &self,
-        root: &Path,
-        parsed: crate::model_library::ParsedModels,
-    ) -> Result<RenderAssets> {
-        RenderAssets::load_with_parsed(root, self, true, Some(parsed))
-    }
     /// [`Assets::reload`] for a server, which draws nothing: the sprites'
     /// layers, without the block or item models or the textures' pixels.
     pub fn reload_for_server(&self, root: &Path) -> Result<RenderAssets> {
@@ -304,16 +212,6 @@ impl RenderAssets {
         Self::load_with(root, assets, true)
     }
     fn load_with(root: &Path, assets: &Assets, draws: bool) -> Result<Self> {
-        Self::load_with_parsed(root, assets, draws, None)
-    }
-    /// `parsed`: the model library when a caller parsed it ahead of this
-    /// (see [`Assets::reload_with_models`]); otherwise it is parsed here.
-    fn load_with_parsed(
-        root: &Path,
-        assets: &Assets,
-        draws: bool,
-        parsed: Option<crate::model_library::ParsedModels>,
-    ) -> Result<Self> {
         let registry = assets.registry;
         let mut sprites = crate::sprites::Sprites::with_disk_cache(root);
         for name in MATERIALS {
@@ -321,24 +219,17 @@ impl RenderAssets {
         }
         // A server draws no block and no item: its block models (about 24 MB
         // baked) and item model library (7 MB) stay empty.
-        let parsed = match parsed {
-            Some(parsed) => parsed,
-            None if draws => {
-                let _step = crate::spans::startup::step("core.models_parse");
-                crate::model_library::ParsedModels::load(root)
-            }
-            None => crate::model_library::ParsedModels::default(),
+        let parsed = if draws {
+            crate::model_library::ParsedModels::load(root)
+        } else {
+            crate::model_library::ParsedModels::default()
         };
-        let mut models = if draws {
-            let _step = crate::spans::startup::step("core.models_bake");
+        let models = if draws {
             crate::models::prepare_with_models(root, registry, &mut sprites, &parsed)?
         } else {
             crate::models::PreparedModels::default()
         };
-        let model_library = {
-            let _step = crate::spans::startup::step("core.item_library");
-            parsed.into_item_library()
-        };
+        let model_library = parsed.into_item_library();
         // Fluids are drawn by the fluid renderer, not block models; breaking
         // progress uses the destroy-stage overlays.
         for name in [
@@ -352,14 +243,7 @@ impl RenderAssets {
         }
         for stage in 0..10 {
             sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
-            sprites.insert(root, &format!("minecraft:block/destroy_oit_stage_{stage}"))?;
         }
-        let fusion = if draws {
-            let _step = crate::spans::startup::step("core.fusion");
-            crate::fusion::FusionTextures::load(root, registry, &mut sprites, &mut models.catalog)
-        } else {
-            Default::default()
-        };
         let mut emissive = Vec::new();
         let connected = if draws {
             crate::native_emissive::load(root, &mut sprites);
@@ -406,7 +290,7 @@ impl RenderAssets {
             sprite_size: sprites.size,
             sprite_minimum_size: sprites.minimum_size,
             texture_layers: u32::try_from(sprites.count())?,
-            pixels: SpritePixels::new(sprites.pixels),
+            pixels: sprites.pixels,
             model_catalog: models.catalog,
             model_library,
             model_placements: models.placements,
@@ -420,8 +304,6 @@ impl RenderAssets {
             pbr_specular: sprites.specular,
             pbr_size: sprites.pbr_size,
             connected,
-            fusion,
-            generation: GENERATION.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1,
         })
     }
 }
@@ -504,29 +386,4 @@ mod tests {
             [ConsumeEffect::ApplyEffects { probability, .. }] if probability == 0.3
         ));
     }
-
-    #[test]
-    fn sprite_pixels_come_back_the_same_once_packed() {
-        // Two layers of 16x16 RGBA with some structure, as sprites have.
-        let pixels: Vec<u8> = (0..2 * 16 * 16 * 4).map(|i| (i * 7 % 251) as u8).collect();
-        let stored = super::SpritePixels::new(pixels.clone());
-        assert_eq!(*stored.get(), pixels);
-        stored.pack();
-        stored.pack();
-        // The packing thread drops the raw copy once the compressed one is set.
-        let started = std::time::Instant::now();
-        while stored.0.raw.lock().unwrap().is_some() {
-            assert!(started.elapsed().as_secs() < 10, "packing never finished");
-            std::thread::yield_now();
-        }
-        assert!(
-            stored
-                .0
-                .packed
-                .get()
-                .is_some_and(|p| p.len() < pixels.len())
-        );
-        assert_eq!(*stored.get(), pixels);
-        assert_eq!(stored.len(), pixels.len());
-    }
 }

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

@@ -180,16 +180,6 @@ pub fn list_textures(root: &Path) -> Vec<String> {
     for ns in namespaces.flatten() {
         let namespace = ns.file_name().to_string_lossy().into_owned();
         let base = ns.path().join("textures");
-        // A prepared root's: from its data file, without listing the disk.
-        if let Some(files) = horizon_core::prepared_files::files_under(&base) {
-            out.extend(
-                files
-                    .iter()
-                    .filter_map(|file| file.strip_suffix(".png"))
-                    .map(|rel| format!("{namespace}:{rel}")),
-            );
-            continue;
-        }
         let mut stack = vec![base.clone()];
         while let Some(dir) = stack.pop() {
             let Ok(entries) = fs::read_dir(&dir) else {
@@ -379,17 +369,14 @@ pub fn generate(
             let (_, _, key) = load(palette_key, "textures/palettes")?;
             let (_, _, target) = load(palette, "textures/palettes")?;
             let mut mapped = argb(&pixels);
-            let key = argb(&key);
-            let target = argb(&target);
-            apply_palette(&mut mapped, &key, &target)?;
-            let out: Vec<u8> = mapped
+            apply_palette(&mut mapped, &argb(&key), &argb(&target))?;
+            let out = mapped
                 .iter()
                 .flat_map(|p| {
                     let [a, r, g, b] = p.to_be_bytes();
                     [r, g, b, a]
                 })
                 .collect();
-            drop(mapped);
             Some((w, h, out))
         }
     }

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

@@ -61,8 +61,6 @@ struct Mixer {
     world_names: Vec<String>,
     /// The callback's cameras (position, basis, world), kept to be refilled without allocating.
     cameras: Vec<([f64; 3], Basis, u32)>,
-    /// Per-source gain/pan/step cache for one buffer, reused across callbacks.
-    voices: Vec<(ChannelId, [f32; 3], f64)>,
     limiter_peak: f32,
     /// The output device the stream was opened on (`Library.currentDeviceName`).
     #[cfg(feature = "audio")]
@@ -185,7 +183,6 @@ struct Decode {
     key: String,
     file: PathBuf,
     channel: ChannelId,
-    looping: bool,
 }
 /// Give a channel waiting on its sound the decoded samples and start it, as
 /// the buffer future attaching and playing the source. A source stopped or
@@ -208,18 +205,6 @@ fn attach(mixer: &Mutex<Mixer>, channel: ChannelId, samples: Samples, looping: b
 type Stream = cpal::Stream;
 #[cfg(not(feature = "audio"))]
 type Stream = std::convert::Infallible;
-/// A level sound retained for the network broadcaster, in playback order.
-#[derive(Clone, Debug)]
-pub struct CapturedSound {
-    pub event: String,
-    pub position: [f64; 3],
-    pub volume: f32,
-    pub pitch: f32,
-    pub source: usize,
-    pub entity: Option<u32>,
-    pub except_entity: Option<u32>,
-}
-
 pub struct Audio {
     _stream: Option<Stream>,
     device_name: String,
@@ -236,7 +221,7 @@ pub struct Audio {
     source_override: Option<usize>,
     /// Positional sounds played since the last drain, kept while the world
     /// is open to the network so guests hear them too.
-    pub capture: Option<Vec<CapturedSound>>,
+    pub capture: Option<Vec<(String, [f64; 3], f32, f32)>>,
     /// How many times each positional sound played (the control socket's `status`),
     /// with or without an audio device.
     pub heard: std::collections::BTreeMap<String, u32>,
@@ -435,7 +420,7 @@ impl Backend for MixerBackend {
         let key = format!("{namespace}:{path}");
         let cached = self.cache.lock().ok().and_then(|mut c| c.get(&key));
         if let Some(samples) = cached {
-            attach(&self.mixer, channel, samples, looping);
+            attach(&self.mixer, channel, samples, false);
             return;
         }
         let decoder = self.decoder.get_or_insert_with(|| {
@@ -454,18 +439,13 @@ impl Backend for MixerBackend {
                             }
                             samples
                         });
-                        attach(&mixer, job.channel, samples, job.looping);
+                        attach(&mixer, job.channel, samples, false);
                     }
                 })
                 .expect("sound decoder thread");
             send
         });
-        let _ = decoder.send(Decode {
-            key,
-            file,
-            channel,
-            looping,
-        });
+        let _ = decoder.send(Decode { key, file, channel });
     }
     /// `alSourceStop`: any state becomes stopped, an initial source too (a
     /// sound still decoding then never starts).
@@ -558,8 +538,9 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         (forward, up, right)
     };
     // Every camera hearing (splitscreen: the other players' too), in the mixer's own buffer.
-    mixer.cameras.clear();
-    mixer.cameras.extend(
+    let mut cameras = std::mem::take(&mut mixer.cameras);
+    cameras.clear();
+    cameras.extend(
         std::iter::once((
             0,
             (mixer.listener, mixer.listener_yaw, mixer.listener_pitch),
@@ -578,11 +559,10 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
             )
         }),
     );
-    let shared = mixer.cameras.len() > 1;
+    let shared = cameras.len() > 1;
     let dot = |a: [f64; 3], b: [f64; 3]| (a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) as f32;
     // Gains and pans per source for this buffer.
-    let mut voices = std::mem::take(&mut mixer.voices);
-    voices.clear();
+    let mut voices: Vec<(ChannelId, [f32; 3], f64)> = Vec::new();
     for (id, c) in &mixer.channels {
         let Some((_, source_rate)) = &c.samples else {
             continue;
@@ -600,8 +580,7 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         };
         let length = |d: [f64; 3]| d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
         // The nearest camera hears it (one camera but in splitscreen).
-        let camera = mixer
-            .cameras
+        let camera = cameras
             .iter()
             .filter(|camera| c.relative || camera.2 == c.world)
             .min_by(|a, b| length(away(a.0)).total_cmp(&length(away(b.0))))
@@ -632,7 +611,8 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         let step = f64::from(*source_rate) / f64::from(rate) * f64::from(c.pitch.max(0.0));
         voices.push((*id, [left, right, gain], step));
     }
-    for (id, [left, right, gain], step) in voices.iter().copied() {
+    mixer.cameras = cameras;
+    for (id, [left, right, gain], step) in voices {
         let Some(c) = mixer.channels.get_mut(&id) else {
             continue;
         };
@@ -662,7 +642,6 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
             c.position += step;
         }
     }
-    mixer.voices = voices;
     // Limit the whole buffer together, preserving waveform and stereo balance
     // instead of flattening each overloaded sample; release over 200 ms
     // (OpenAL Soft's output limiter, `ALC_OUTPUT_LIMITER_SOFT`, releases
@@ -705,27 +684,17 @@ fn open_device(
 ) -> Result<(cpal::Stream, cpal::SupportedStreamConfig)> {
     use cpal::SampleFormat as F;
     let config = device.default_output_config()?;
-    let build = |stream_config: &cpal::StreamConfig| match config.sample_format() {
-        F::F32 => build_stream::<f32>(device, &config, stream_config, mixer.clone()),
-        F::F64 => build_stream::<f64>(device, &config, stream_config, mixer.clone()),
-        F::I16 => build_stream::<i16>(device, &config, stream_config, mixer.clone()),
-        F::I32 => build_stream::<i32>(device, &config, stream_config, mixer.clone()),
-        F::I8 => build_stream::<i8>(device, &config, stream_config, mixer.clone()),
-        F::U16 => build_stream::<u16>(device, &config, stream_config, mixer.clone()),
-        F::U32 => build_stream::<u32>(device, &config, stream_config, mixer.clone()),
-        F::U8 => build_stream::<u8>(device, &config, stream_config, mixer.clone()),
+    let stream = match config.sample_format() {
+        F::F32 => build_stream::<f32>(device, &config, mixer.clone()),
+        F::F64 => build_stream::<f64>(device, &config, mixer.clone()),
+        F::I16 => build_stream::<i16>(device, &config, mixer.clone()),
+        F::I32 => build_stream::<i32>(device, &config, mixer.clone()),
+        F::I8 => build_stream::<i8>(device, &config, mixer.clone()),
+        F::U16 => build_stream::<u16>(device, &config, mixer.clone()),
+        F::U32 => build_stream::<u32>(device, &config, mixer.clone()),
+        F::U8 => build_stream::<u8>(device, &config, mixer.clone()),
         other => Err(format!("unsupported sample format {other}").into()),
-    };
-    let short = audio_stream_config(&config);
-    let stream = match build(&short) {
-        Ok(stream) => stream,
-        // A device that refuses the short fixed buffer still plays with cpal's default one.
-        Err(e) if short != config.config() => {
-            log::info!("Horizon: audio output refused a short buffer ({e}); using the default");
-            build(&config.config())?
-        }
-        Err(e) => return Err(e),
-    };
+    }?;
     stream.play()?;
     if let Ok(mut m) = mixer.lock() {
         m.device_name = device.name().unwrap_or_default();
@@ -806,35 +775,10 @@ fn cards_changed(seen: Option<&str>, cards: Option<&str>) -> bool {
         _ => true,
     }
 }
-
-/// The cpal `StreamConfig` to open an output stream with. On Linux the ALSA
-/// backend's `BufferSize::Default` means a ~100 ms buffer, so sound effects
-/// come out about 100 ms late: request a short fixed buffer there. Other
-/// platforms keep cpal's default behaviour.
-#[cfg(feature = "audio")]
-fn audio_stream_config(config: &cpal::SupportedStreamConfig) -> cpal::StreamConfig {
-    #[cfg(target_os = "linux")]
-    {
-        let range = match config.buffer_size() {
-            cpal::SupportedBufferSize::Range { min, max } => (*min, *max),
-            cpal::SupportedBufferSize::Unknown => (256, 4096),
-        };
-        let target = 1024u32.clamp(range.0, range.1);
-        let mut sc = config.config();
-        sc.buffer_size = cpal::BufferSize::Fixed(target);
-        sc
-    }
-    #[cfg(not(target_os = "linux"))]
-    {
-        config.config()
-    }
-}
-
 #[cfg(feature = "audio")]
 fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
     device: &cpal::Device,
     config: &cpal::SupportedStreamConfig,
-    stream_config: &cpal::StreamConfig,
     mixer: Arc<Mutex<Mixer>>,
 ) -> Result<cpal::Stream> {
     let rate = config.sample_rate().0;
@@ -842,7 +786,7 @@ fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
     let mut scratch = Vec::new();
     let on_error = mixer.clone();
     let stream = device.build_output_stream(
-        stream_config,
+        &config.config(),
         move |data: &mut [T], _| {
             scratch.resize(data.len(), 0.0f32);
             if let Ok(mut m) = mixer.lock() {
@@ -1262,13 +1206,8 @@ impl Audio {
     /// `SoundManager.reload` (resource packs changed): stop every sound, then
     /// read sound events and sound files from the new resource root.
     pub fn reload(&mut self, root: &Path) {
-        self.reload_with(root, SoundRegistry::load(root));
-    }
-    /// [`Self::reload`] with the root's sound events already read
-    /// (`SoundRegistry::load`, which a pack reload runs off the render thread).
-    pub fn reload_with(&mut self, root: &Path, registry: SoundRegistry) {
         self.stop_all();
-        self.engine.registry = registry;
+        self.engine.registry = SoundRegistry::load(root);
         self.backend.root = root.to_owned();
         let mut cache = self.backend.cache.lock().unwrap();
         cache.entries.clear();
@@ -1309,17 +1248,7 @@ impl Audio {
     pub fn play_after(&mut self, event: &str, at: [f64; 3], volume: f32, pitch: f32, ticks: i32) {
         let seed = self.random.next_long();
         if let Some(capture) = self.capture.as_mut() {
-            capture.push(CapturedSound {
-                event: event.to_owned(),
-                position: at,
-                volume,
-                pitch,
-                source: self.source_override.unwrap_or_else(|| {
-                    crate::settings::sound_source(&crate::sound_events::normalize(event))
-                }),
-                entity: None,
-                except_entity: None,
-            });
+            capture.push((event.to_owned(), at, volume, pitch));
         }
         *self.heard.entry(event.to_owned()).or_default() += 1;
         self.sync_volumes();
@@ -1358,66 +1287,6 @@ impl Audio {
         preview.preview(self, source, volume);
         self.preview = preview;
     }
-    /// An incoming entity-sound packet: retain its seed and category without rebroadcasting it.
-    pub fn play_entity_seeded(
-        &mut self,
-        event: &str,
-        source: usize,
-        volume: f32,
-        pitch: f32,
-        seed: i64,
-        entity: crate::sound_engine::SoundEntity,
-    ) {
-        *self.heard.entry(event.to_owned()).or_default() += 1;
-        let event = crate::sound_events::normalize(event);
-        let instance = SoundInstance::entity_bound(
-            &event,
-            source,
-            volume,
-            pitch,
-            LegacyRandom::new(seed),
-            entity,
-        );
-        self.play_instance(instance, false);
-    }
-    /// A level's entity overload: preserve the emitter and excluded player for
-    /// the server broadcaster while the local sound follows the same object.
-    pub fn play_bound(
-        &mut self,
-        event: &str,
-        source: usize,
-        volume: f32,
-        pitch: f32,
-        entity: crate::sound_engine::SoundEntity,
-        except_entity: Option<u32>,
-    ) {
-        if let Some(capture) = self.capture.as_mut() {
-            capture.push(CapturedSound {
-                event: event.to_owned(),
-                position: entity.state().position,
-                volume,
-                pitch,
-                source,
-                entity: Some(entity.id),
-                except_entity,
-            });
-        }
-        let seed = self.random.next_long();
-        self.play_entity_seeded(event, source, volume, pitch, seed, entity);
-    }
-    /// Removal belongs to the old object even if its numeric id is immediately reused.
-    pub fn remove_sound_entity(&mut self, id: u32) {
-        for entity in self
-            .engine
-            .bound_entities()
-            .into_iter()
-            .filter(|e| e.id == id)
-        {
-            let mut state = entity.state();
-            state.removed = true;
-            entity.update(state);
-        }
-    }
     /// `play` with the seed a sound packet carries.
     pub fn play_seeded(
         &mut self,
@@ -1428,17 +1297,7 @@ impl Audio {
         seed: i64,
     ) {
         if let (Some(capture), Some(at)) = (self.capture.as_mut(), at) {
-            capture.push(CapturedSound {
-                event: event.to_owned(),
-                position: at,
-                volume,
-                pitch,
-                source: self.source_override.unwrap_or_else(|| {
-                    crate::settings::sound_source(&crate::sound_events::normalize(event))
-                }),
-                entity: None,
-                except_entity: None,
-            });
+            capture.push((event.to_owned(), at, volume, pitch));
         }
         if at.is_some() {
             *self.heard.entry(event.to_owned()).or_default() += 1;
@@ -1578,81 +1437,6 @@ impl Sounds for Audio {
 mod tests {
     use super::*;
 
-    #[test]
-    fn level_capture_keeps_order_category_entity_and_actor_exclusion() {
-        let mut audio = Audio::silent(Path::new("/nonexistent/horizon-entity-sound-test"));
-        audio.capture = Some(Vec::new());
-        let mut expected = audio.random.clone();
-        audio.play_on(
-            7,
-            "minecraft:block.amethyst_block.chime",
-            Some([1.0; 3]),
-            0.5,
-            1.0,
-        );
-        let entity = crate::sound_engine::SoundEntity::new(37, [2.123456789, 64.0, -3.0], false);
-        audio.play_bound(
-            "minecraft:block.amethyst_block.chime",
-            6,
-            2.0,
-            1.2,
-            entity,
-            Some(17),
-        );
-        let sounds = audio.capture.as_ref().unwrap();
-        assert_eq!(sounds.len(), 2);
-        assert_eq!(
-            (sounds[0].source, sounds[0].entity, sounds[0].except_entity),
-            (7, None, None)
-        );
-        let bound = &sounds[1];
-        assert_eq!(
-            (bound.source, bound.entity, bound.except_entity),
-            (6, Some(37), Some(17))
-        );
-        assert_eq!(bound.position, [2.123456789, 64.0, -3.0]);
-        assert_eq!((bound.volume, bound.pitch), (2.0, 1.2));
-        expected.next_long();
-        expected.next_long();
-        assert_eq!(audio.random.next_long(), expected.next_long());
-    }
-
-    #[test]
-    fn entity_sound_packets_neither_rebroadcast_nor_advance_the_local_seed_generator() {
-        let mut audio = Audio::silent(Path::new("/nonexistent/horizon-entity-sound-test"));
-        audio.capture = Some(Vec::new());
-        let mut expected = audio.random.clone();
-        let entity = crate::sound_engine::SoundEntity::new(7, [1.0, 2.0, 3.0], false);
-        audio.play_entity_seeded("minecraft:fixture.bound", 6, 0.7, 1.2, 42, entity);
-        assert!(audio.capture.as_ref().unwrap().is_empty());
-        assert_eq!(audio.random.next_long(), expected.next_long());
-    }
-    #[test]
-    fn removal_marks_only_existing_references_to_that_entity() {
-        use crate::sound_engine::SoundEntity;
-        let mut audio = Audio::silent(Path::new("/nonexistent/horizon-entity-sound-test"));
-        let old = SoundEntity::new(7, [0.0; 3], false);
-        let other = SoundEntity::new(8, [0.0; 3], false);
-        for entity in [old.clone(), other.clone()] {
-            audio.engine.add(
-                SoundInstance::entity_bound(
-                    "minecraft:fixture.bound",
-                    6,
-                    1.0,
-                    1.0,
-                    LegacyRandom::new(42),
-                    entity,
-                ),
-                true,
-            );
-        }
-        audio.remove_sound_entity(7);
-        let replacement = SoundEntity::new(7, [10.0; 3], false);
-        assert!(old.state().removed);
-        assert!(!other.state().removed);
-        assert!(!replacement.state().removed);
-    }
-
     #[test]
     fn button_click_uses_vanilla_ui_parameters_without_advancing_world_random() {
         let mut audio = Audio::silent(Path::new("/nonexistent/horizon-test-assets"));

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

@@ -49,10 +49,6 @@ impl AuthSession {
             access_token: access_token.to_owned(),
         }
     }
-
-    pub fn access_token(&self) -> &str {
-        &self.access_token
-    }
     /// The session file's JSON: {"name", "uuid", "access_token", "user_type": "msa", "xuid"}.
     pub fn parse(text: &str) -> Result<Self, String> {
         let v: serde_json::Value =
@@ -105,22 +101,6 @@ impl AuthSession {
         let _ = std::fs::remove_file(path);
         Self::parse(&text.map_err(|e| format!("{}: {e}", path.display()))?)
     }
-    /// The access token's expiry (its JWT `exp`) has passed, or is a minute away: the session
-    /// service would refuse it. A token that doesn't read as a JWT counts as good: the server
-    /// says.
-    pub fn expired(&self) -> bool {
-        let exp = self
-            .access_token
-            .split('.')
-            .nth(1)
-            .and_then(|p| crate::skins::base64_decode(&p.replace('-', "+").replace('_', "/")))
-            .and_then(|json| serde_json::from_slice::<serde_json::Value>(&json).ok())
-            .and_then(|v| v.get("exp")?.as_u64());
-        let now = SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .map_or(0, |d| d.as_secs());
-        exp.is_some_and(|exp| exp <= now + 60)
-    }
 }
 
 static CURRENT: OnceLock<Arc<AuthSession>> = OnceLock::new();
@@ -207,7 +187,6 @@ pub(crate) fn discovery() -> Result<Arc<serde_json::Value>, JoinError> {
     let doc: serde_json::Value = agent()
         .get(&discovery_url())
         .call()
-        .inspect_err(|e| log::warn!("The services discovery document: {e}"))
         .ok()
         .and_then(|r| r.into_string().ok())
         .and_then(|t| serde_json::from_str(&t).ok())
@@ -274,33 +253,9 @@ pub fn join_request(session: &AuthSession, server_hash: &str) -> String {
     .to_string()
 }
 
-/// A join that got no answer is worth one more try, as leaving and joining
-/// again would be: `join` is safe to repeat, it only records the server's
-/// hash. Any other answer is the service's own and stands.
-fn with_one_retry(
-    mut join: impl FnMut() -> Result<(), JoinError>,
-    pause: Duration,
-) -> Result<(), JoinError> {
-    match join() {
-        Err(JoinError::Unavailable) => {
-            std::thread::sleep(pause);
-            join()
-        }
-        result => result,
-    }
-}
-
 /// MinecraftServicesSessionService.joinServer: tell the session service this
-/// account is joining the server whose hash is `server_hash`. Horizon tries
-/// twice when the service doesn't answer; vanilla asks the player to.
+/// account is joining the server whose hash is `server_hash`.
 pub fn join_server(session: &AuthSession, server_hash: &str) -> Result<(), JoinError> {
-    with_one_retry(
-        || join_server_once(session, server_hash),
-        Duration::from_millis(500),
-    )
-}
-
-fn join_server_once(session: &AuthSession, server_hash: &str) -> Result<(), JoinError> {
     let doc = discovery()?;
     let url = endpoint(&doc, "session", "join").ok_or(JoinError::Unavailable)?;
     match agent()
@@ -309,19 +264,11 @@ fn join_server_once(session: &AuthSession, server_hash: &str) -> Result<(), Join
         .send_string(&join_request(session, server_hash))
     {
         Ok(_) => Ok(()),
-        Err(ureq::Error::Status(status, response)) => {
-            if status >= 500 {
-                log::warn!("The session service's join answered {status}");
-            }
-            Err(JoinError::from_response(
-                status,
-                &response.into_string().unwrap_or_default(),
-            ))
-        }
-        Err(ureq::Error::Transport(e)) => {
-            log::warn!("The session service's join: {e}");
-            Err(JoinError::Unavailable)
-        }
+        Err(ureq::Error::Status(status, response)) => Err(JoinError::from_response(
+            status,
+            &response.into_string().unwrap_or_default(),
+        )),
+        Err(ureq::Error::Transport(_)) => Err(JoinError::Unavailable),
     }
 }
 
@@ -456,8 +403,11 @@ struct ChatKeys {
     fetching: bool,
     next_try: Option<std::time::Instant>,
 }
-static CHAT_KEYS: std::sync::LazyLock<Mutex<std::collections::HashMap<u128, ChatKeys>>> =
-    std::sync::LazyLock::new(|| Mutex::new(std::collections::HashMap::new()));
+static CHAT_KEYS: Mutex<ChatKeys> = Mutex::new(ChatKeys {
+    current: None,
+    fetching: false,
+    next_try: None,
+});
 
 /// prepareKeyPair (`now`: on a join) or, from a tick, shouldRefreshKeyPair
 /// then prepareKeyPair: start fetching when there is no key pair or it is
@@ -466,14 +416,7 @@ pub fn prepare_chat_keys(now: bool) {
     let Some(session) = current() else {
         return;
     };
-    prepare_chat_keys_for(session, now);
-}
-
-/// Prepare keys for this player, independently of the other local accounts.
-pub fn prepare_chat_keys_for(session: Arc<AuthSession>, now: bool) {
-    let uuid = session.uuid;
-    let mut accounts = CHAT_KEYS.lock().unwrap();
-    let keys = accounts.entry(uuid).or_default();
+    let mut keys = CHAT_KEYS.lock().unwrap();
     let instant = std::time::Instant::now();
     if keys.fetching || !now && keys.next_try.is_some_and(|t| instant < t) {
         return;
@@ -487,13 +430,12 @@ pub fn prepare_chat_keys_for(session: Arc<AuthSession>, now: bool) {
         return;
     }
     keys.fetching = true;
-    drop(accounts);
+    drop(keys);
     let spawned = std::thread::Builder::new()
         .name("Profile key fetch".into())
         .spawn(move || {
             let result = fetch_chat_keys(&session);
-            let mut accounts = CHAT_KEYS.lock().unwrap();
-            let keys = accounts.entry(uuid).or_default();
+            let mut keys = CHAT_KEYS.lock().unwrap();
             keys.fetching = false;
             match result {
                 Ok(pair) => keys.current = Some(Arc::new(pair)),
@@ -501,24 +443,19 @@ pub fn prepare_chat_keys_for(session: Arc<AuthSession>, now: bool) {
             }
         });
     if spawned.is_err() {
-        CHAT_KEYS.lock().unwrap().entry(uuid).or_default().fetching = false;
+        CHAT_KEYS.lock().unwrap().fetching = false;
     }
 }
 
 /// The chat key pair fetched so far, unless it has expired.
 pub fn chat_keys() -> Option<Arc<ChatKeyPair>> {
-    chat_keys_for(current()?.uuid)
-}
-
-/// This account's key pair; another local player's keys can never be returned.
-pub fn chat_keys_for(uuid: u128) -> Option<Arc<ChatKeyPair>> {
+    let now = now_millis();
     CHAT_KEYS
         .lock()
         .unwrap()
-        .get(&uuid)?
         .current
         .clone()
-        .filter(|k| !k.public.has_expired(now_millis()))
+        .filter(|k| !k.public.has_expired(now))
 }
 
 const MINECRAFT_PROFILE: &str = "https://api.minecraftservices.com/minecraft/profile";
@@ -627,77 +564,6 @@ mod tests {
 
     const UUID: u128 = 0x069a79f444e94726a5befca90e38aaf5;
 
-    /// Runs `with_one_retry` over these answers, in order: the result and how
-    /// many it asked for.
-    fn joined(answers: &[Result<(), JoinError>]) -> (Result<(), JoinError>, usize) {
-        let mut asked = 0;
-        let result = with_one_retry(
-            || {
-                asked += 1;
-                answers[asked - 1].clone()
-            },
-            Duration::ZERO,
-        );
-        (result, asked)
-    }
-
-    #[test]
-    fn a_join_with_no_answer_is_tried_once_more() {
-        let none = Err(JoinError::Unavailable);
-        assert_eq!(joined(&[none.clone(), Ok(())]), (Ok(()), 2));
-        // Twice without an answer: the message the player knows.
-        assert_eq!(joined(&[none.clone(), none.clone()]), (none, 2));
-    }
-
-    #[test]
-    fn a_join_the_service_answered_is_not_tried_again() {
-        assert_eq!(joined(&[Ok(())]), (Ok(()), 1));
-        for refused in [
-            JoinError::InvalidSession,
-            JoinError::Banned,
-            JoinError::InsufficientPrivileges,
-            JoinError::Other("Status: 429".into()),
-        ] {
-            assert_eq!(joined(&[Err(refused.clone())]), (Err(refused), 1));
-        }
-    }
-
-    /// base64url without padding, as a JWT's parts are.
-    fn base64url(bytes: &[u8]) -> String {
-        const ALPHABET: &[u8; 64] =
-            b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-        let mut out = String::new();
-        for chunk in bytes.chunks(3) {
-            let n =
-                chunk.iter().fold(0u32, |n, &b| n << 8 | u32::from(b)) << (8 * (3 - chunk.len()));
-            for k in 0..=chunk.len() {
-                out.push(char::from(ALPHABET[(n >> (18 - 6 * k) & 63) as usize]));
-            }
-        }
-        out
-    }
-
-    #[test]
-    fn a_token_past_its_exp_is_expired() {
-        // header.payload.signature, the payload base64url without padding.
-        let token = |exp: u64| {
-            let json = format!(r#"{{"exp":{exp}}}"#);
-            let payload = base64url(json.as_bytes());
-            AuthSession::new("Ann", UUID, &format!("e30.{payload}.sig"))
-        };
-        let now = SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .unwrap()
-            .as_secs();
-        assert!(token(now - 10).expired());
-        assert!(
-            token(now + 30).expired(),
-            "a minute from its end: as good as gone"
-        );
-        assert!(!token(now + 3600).expired());
-        assert!(!AuthSession::new("Ann", UUID, "not-a-jwt").expired());
-    }
-
     fn write(dir: &Path, text: &str, mode: u32) -> std::path::PathBuf {
         let path = dir.join("session.json");
         std::fs::write(&path, text).unwrap();
@@ -861,37 +727,6 @@ mod tests {
         .to_string()
     }
 
-    #[test]
-    fn local_accounts_use_their_own_chat_keys() {
-        let pair = |signature: &[u8]| {
-            let mut keys = parse_certificates(&certificates(PRIVATE_B64, PUBLIC_B64)).unwrap();
-            keys.public.expires_at = i64::MAX;
-            keys.refreshed_after = i64::MAX;
-            keys.public.signature = signature.to_vec();
-            Arc::new(keys)
-        };
-        let ann = pair(b"ann");
-        let bea = pair(b"bea");
-        {
-            let mut accounts = CHAT_KEYS.lock().unwrap();
-            for (uuid, keys) in [(101, ann.clone()), (102, bea.clone())] {
-                accounts.insert(
-                    uuid,
-                    ChatKeys {
-                        current: Some(keys),
-                        ..Default::default()
-                    },
-                );
-            }
-        }
-        prepare_chat_keys_for(Arc::new(AuthSession::new("Ann", 101, "unused")), true);
-        assert!(Arc::ptr_eq(&chat_keys_for(101).unwrap(), &ann));
-        assert!(Arc::ptr_eq(&chat_keys_for(102).unwrap(), &bea));
-        assert!(chat_keys_for(103).is_none());
-        CHAT_KEYS.lock().unwrap().remove(&101);
-        CHAT_KEYS.lock().unwrap().remove(&102);
-    }
-
     #[test]
     fn certificates_response() {
         let pair = parse_certificates(&certificates(PRIVATE_B64, PUBLIC_B64)).unwrap();

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

@@ -5,6 +5,7 @@ use horizon_core::{noise::SimplexNoise, position::BlockPos, random::LegacyRandom
 use serde_json::Value;
 use std::{
     collections::{BTreeMap, HashMap},
+    fs,
     path::Path,
     sync::Arc,
 };
@@ -170,9 +171,7 @@ fn color(v: &Value) -> Option<u32> {
 }
 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::Cursor::new(horizon_core::prepared_files::read(
-        &path,
-    )?));
+    let mut decoder = png::Decoder::new(std::io::BufReader::new(fs::File::open(path)?));
     decoder.ignore_checksums(true);
     decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
     let mut reader = decoder.read_info()?;
@@ -278,22 +277,21 @@ impl Biomes {
             dry: colormap(root, "dry_foliage")?,
         };
         let mut list = Vec::new();
-        // The folder's own files (not its subfolders'), by file name: through `json_folder`,
-        // from the prepared data file when there is one.
-        let folder = horizon_world::json_folder::read(&root.join("data/minecraft/worldgen/biome"))?;
-        let mut files: Vec<_> = folder
-            .files
-            .iter()
-            .filter(|f| !f.name.contains('/'))
+        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();
-        files.sort_by_cached_key(|f| format!("{}.json", f.name));
-        for file in files {
-            let v: Value = serde_json::from_slice(file.bytes()?)?;
-            list.push(BiomeInfo::from_json(
-                format!("minecraft:{}", file.name),
-                &v,
-                &maps,
-            ));
+        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()
@@ -434,25 +432,6 @@ impl Biomes {
         }
         changed.then_some(out)
     }
-
-    /// This table (the biome files') with its colours passed through `f`, when
-    /// they differ from `current`'s: what a refresh of a table already
-    /// coloured by `f` once must not compound.
-    pub fn recolored_from(
-        &self,
-        current: &Self,
-        f: impl FnMut(&str, &mut BiomeColors),
-    ) -> Option<Self> {
-        let out = self.with_colors(f).unwrap_or_else(|| self.clone());
-        let tints = |b: &BiomeInfo| (b.grass, b.foliage, b.dry_foliage, b.water);
-        let same = out.list.len() == current.list.len()
-            && out
-                .list
-                .iter()
-                .zip(&current.list)
-                .all(|(a, b)| tints(a) == tints(b));
-        (!same).then_some(out)
-    }
 }
 
 /// A 24-bit colour as sRGB components in 0..1.

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

@@ -89,7 +89,6 @@ pub struct BlockEntities {
     /// instance blocks, `shows_box`), so a frame looks at them without scanning the map.
     /// Like `mods`, one taken out stays listed until `put` or `remove`.
     boxes: FxHashSet<Pos>,
-    asleep: FxHashSet<Pos>,
 }
 
 /// A structure or test instance block: the block entities whose box the frame may draw.
@@ -230,7 +229,6 @@ impl BlockEntities {
     }
     /// `removeBlockEntityTicker`: no slot, made or pending.
     fn cancel(&mut self, pos: &Pos) {
-        self.asleep.remove(pos);
         self.freed |= self.live.remove(pos).is_some();
         self.pending.remove(pos);
     }
@@ -294,30 +292,15 @@ impl BlockEntities {
             .filter(move |((cx, cz), _)| !far(*cx, x) && !far(*cz, z))
             .flat_map(|(_, set)| set)
     }
-    /// `LevelChunk.getBlockEntity`: the block entity at `pos`, if any.
-    pub fn get(&self, pos: &Pos) -> Option<&BlockEntity> {
-        self.map.get(pos)
-    }
     pub fn get_mut(&mut self, pos: &Pos) -> Option<&mut BlockEntity> {
-        self.asleep.remove(pos);
         self.map.get_mut(pos)
     }
     pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Pos, &mut BlockEntity)> {
-        self.asleep.clear();
         self.map.iter_mut()
     }
     pub fn values_mut(&mut self) -> impl Iterator<Item = &mut BlockEntity> {
-        self.asleep.clear();
         self.map.values_mut()
     }
-    pub fn sleep(&mut self, pos: Pos) {
-        if self.map.contains_key(&pos) {
-            self.asleep.insert(pos);
-        }
-    }
-    pub fn is_asleep(&self, pos: &Pos) -> bool {
-        self.asleep.contains(pos)
-    }
     /// `LevelChunk.setBlockEntity` (+ `addAndRegisterBlockEntity`): a new
     /// block entity may get a slot; one replacing another keeps its slot.
     /// One of the same type rewrites it in place (a jukebox taking a disc,
@@ -333,7 +316,6 @@ impl BlockEntities {
             self.attachments.remove(&pos);
         }
         let new_box = shows_box(&entity);
-        self.asleep.remove(&pos);
         let old = self.map.insert(pos, entity);
         if old.is_none() {
             self.add(pos);
@@ -360,7 +342,6 @@ impl BlockEntities {
         if absent {
             self.add(pos);
         }
-        self.asleep.remove(&pos);
         let entity = self.map.entry(pos).or_insert_with(make);
         if absent && matches!(entity, BlockEntity::Mod(_)) {
             self.mods.entry(chunk_of(pos)).or_default().insert(pos);
@@ -373,7 +354,6 @@ impl BlockEntities {
     /// `LevelChunk.removeBlockEntity`: the block entity and its slot.
     pub fn remove(&mut self, pos: &Pos) -> Option<BlockEntity> {
         self.attachments.remove(pos);
-        self.asleep.remove(pos);
         self.cancel(pos);
         let removed = self.map.remove(pos);
         if matches!(removed, Some(BlockEntity::Mod(_))) {
@@ -385,7 +365,6 @@ impl BlockEntities {
     /// The block entity at `pos`, out of the map for a while: its slot stays
     /// for `put` to bring it back (a tick working on it).
     pub fn take(&mut self, pos: &Pos) -> Option<BlockEntity> {
-        self.asleep.remove(pos);
         let taken = self.map.remove(pos);
         if taken.is_some() {
             self.out.insert(*pos);
@@ -395,7 +374,6 @@ impl BlockEntities {
     /// Brings back what `take` took, in its slot.
     pub fn put(&mut self, pos: Pos, entity: BlockEntity) {
         self.out.remove(&pos);
-        self.asleep.remove(&pos);
         if matches!(entity, BlockEntity::Mod(_)) {
             self.mods.entry(chunk_of(pos)).or_default().insert(pos);
         }
@@ -417,7 +395,6 @@ impl BlockEntities {
             &mut self.attachments,
         );
         let (mods, boxes) = (&mut self.mods, &mut self.boxes);
-        self.asleep.clear();
         self.map.retain(|p, e| {
             let kept = keep(p, e);
             if !kept {
@@ -435,7 +412,6 @@ impl BlockEntities {
         self.map.clear();
         self.mods.clear();
         self.boxes.clear();
-        self.asleep.clear();
         self.tickers = Arc::default();
         self.live.clear();
         self.added.clear();
@@ -453,7 +429,6 @@ impl BlockEntities {
         let order = chunk_map_order(entities.iter().map(|(p, _)| *p));
         for (p, e) in entities {
             self.attachments.remove(&p);
-            self.asleep.remove(&p);
             let new_is_mod = matches!(e, BlockEntity::Mod(_));
             self.note_box(p, Some(&e));
             let old = self.map.insert(p, e);
@@ -473,7 +448,6 @@ impl BlockEntities {
     /// `LevelChunk.setBlockState` on a block entity's position, from state
     /// `old` to `new`: a ticker made, kept or dropped.
     pub fn state_changed(&mut self, pos: Pos, old: u32, new: u32) {
-        self.asleep.remove(&pos);
         if self.states.is_empty() || !self.map.contains_key(&pos) {
             return;
         }
@@ -564,51 +538,6 @@ mod tests {
         found
     }
     #[test]
-    fn a_sleeping_block_entity_wakes_on_any_change() {
-        let p = (1, 64, 1);
-        let mut b = level();
-        b.sleep(p);
-        assert!(!b.is_asleep(&p));
-        b.insert(p, hopper());
-        let asleep = |b: &mut BlockEntities, wake: &dyn Fn(&mut BlockEntities)| {
-            b.sleep(p);
-            assert!(b.is_asleep(&p));
-            wake(b);
-            b.is_asleep(&p)
-        };
-        assert!(asleep(&mut b, &|_| {}));
-        assert!(!asleep(&mut b, &|b| {
-            b.get_mut(&p);
-        }));
-        assert!(!asleep(&mut b, &|b| {
-            b.insert(p, hopper());
-        }));
-        assert!(!asleep(&mut b, &|b| {
-            b.get_or_insert_with(p, hopper);
-        }));
-        assert!(!asleep(&mut b, &|b| {
-            let held = b.take(&p).unwrap();
-            b.put(p, held);
-        }));
-        assert!(!asleep(&mut b, &|b| b.state_changed(p, 1, 1)));
-        assert!(!asleep(&mut b, &|b| b.forget(&p)));
-        assert!(!asleep(&mut b, &|b| {
-            b.iter_mut().count();
-        }));
-        assert!(!asleep(&mut b, &|b| {
-            b.values_mut().count();
-        }));
-        assert!(!asleep(&mut b, &|b| b.retain(|_, _| true)));
-        assert!(!asleep(&mut b, &|b| b.load_chunk(vec![(p, hopper())])));
-        assert!(!asleep(&mut b, &|b| {
-            b.remove(&p);
-            b.insert(p, hopper());
-        }));
-        b.sleep(p);
-        b.clear();
-        assert!(!b.is_asleep(&p));
-    }
-    #[test]
     fn mod_block_entities_are_listed_by_chunk_until_they_go() {
         let mut b = level();
         let modded = || BlockEntity::Mod(Box::default());
@@ -644,7 +573,6 @@ mod tests {
             default: || 0,
             codec: None,
             copy_on_death: false,
-            sync: false,
         };
         let p = (1, 64, 2);
         let mut entities = level();

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

@@ -383,7 +383,7 @@ impl Shulker {
         out
     }
     /// `ShulkerBoxBlock.canOpen`: a closed box only opens when its lid has room
-    /// (`level.noCollision` of the lid box at half progress, deflated by 1e-6).
+    /// (`level.noCollision` of the half-block lid box, deflated by 1e-6).
     pub fn lid_box(pos: [i32; 3], facing: u8) -> [f64; 6] {
         let bottom = [
             f64::from(pos[0]) + 0.5,
@@ -939,14 +939,6 @@ impl BlockEntityAnims {
     /// Drops the state of block entities that are gone or changed kind:
     /// `present` holds the loaded block entities' tickers, sorted by position.
     pub fn retain_present(&mut self, present: &[([i32; 3], Ticker)]) {
-        self.retain_animations(present, false);
-    }
-    /// An integrated server owns bell state independently of renderer visibility.
-    /// Its world ticker removes bells when their actual block changes.
-    pub fn retain_present_preserving_bells(&mut self, present: &[([i32; 3], Ticker)]) {
-        self.retain_animations(present, true);
-    }
-    fn retain_animations(&mut self, present: &[([i32; 3], Ticker)], keep_bells: bool) {
         let is = |p: &[i32; 3], f: fn(&Ticker) -> bool| {
             present
                 .binary_search_by_key(p, |(q, _)| *q)
@@ -956,9 +948,7 @@ impl BlockEntityAnims {
         self.books.retain(|p, _| is(p, |t| *t == Ticker::Book));
         self.shulkers
             .retain(|p, _| is(p, |t| matches!(t, Ticker::Shulker { .. })));
-        if !keep_bells {
-            self.bells.retain(|p, _| is(p, |t| *t == Ticker::Bell));
-        }
+        self.bells.retain(|p, _| is(p, |t| *t == Ticker::Bell));
         self.conduits
             .retain(|p, _| is(p, |t| *t == Ticker::Conduit));
         self.skulls

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

@@ -1,432 +0,0 @@
-//! Where a block's textures are in the block sprite arrays, side by side, for drawing the block
-//! somewhere the mesher does not: a native mod's own pass drawing blocks as voxels
-//! (`native_block_sprites`, `WorldDrawn::block_sprites`; docs/native-mods.md). The answer is the
-//! model's own faces, as the mesher bakes them: each face's sprite (its array and layer), where on
-//! the block's side it lies and how its texture runs across it, and its tint source.
-//!
-//! Each sprite is a whole layer of a square texture array (`sprites::Sprites`), so a face's UVs run
-//! 0 to 1 within its layer; the renderer's split (`Renderer::sprite_split`) layers to an array.
-use crate::{mesher::TintSource, models::catalog::BakedFace, streaming::WorkerContext};
-use horizon_assets::model::Direction;
-use horizon_core::position::BlockPos;
-use horizon_world::registry::{BlockRegistry, BlockStateId};
-
-/// A sprite: its array (0 for every vanilla texture on most GPUs; past the first array's layers in
-/// 1 to 7) and its layer in that array.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SpriteRef {
-    pub array: u32,
-    pub layer: u32,
-    /// It animates (water, lava, fire, sea lanterns...): the arrays always hold the frame being shown.
-    pub animated: bool,
-    /// Some of its pixels are clear (alpha 0): leaves, glass, flowers. Draw those as holes.
-    pub cutout: bool,
-}
-
-/// One face of a block's model on one of its sides.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct FaceSprite {
-    pub sprite: SpriteRef,
-    /// Where the face lies on the side, in the side's two axes ([`side_axes`]), from 0 to 1 across the block:
-    /// `[a0, b0, a1, b1]`. `[0, 0, 1, 1]` for a whole face.
-    pub rect: [f32; 4],
-    /// How deep into the block the face lies from the side's own plane (0 for a cube's face, 0.5 for a slab's top).
-    pub inset: f32,
-    /// The texture across the side: the point (a, b) on it shows `uv = [u0, v0] + a * [du_u, du_v] + b * [dv_u,
-    /// dv_v]` of the sprite, `[u0, v0, du_u, du_v, dv_u, dv_v]`. Rotations and mirrors (a log on its side, a
-    /// model's `rotation` and `uvlock`) are in it.
-    pub uv: [f32; 6],
-    /// Its colour source, none for an untinted face: multiply the texture by the source's colour.
-    pub tint: Option<TintSource>,
-    /// It has partly clear pixels: drawn sorted and blended.
-    pub translucent: bool,
-}
-
-/// What a block draws on each side, in [`Direction::ALL`]'s order (down, up, north, south, west, east).
-#[derive(Clone, Debug, PartialEq)]
-pub struct BlockSprites {
-    /// The faces on each side, in the model's order: the one drawn first first (a grass block's side: its dirt
-    /// and grass, then the grass overlay tinted over it). A side with none is empty. Faces that do not lie flat
-    /// on a side (a flower's crossed planes, a rotated element) are left out.
-    pub sides: [Vec<FaceSprite>; 6],
-    /// The model's particle sprite (what breaking it scatters, a flower's whole picture), if it has one.
-    pub particle: Option<SpriteRef>,
-    /// The model is a plain cube: one whole face on each side, at its plane.
-    pub cube: bool,
-}
-
-/// The two axes a side's `rect` and `uv` count along, as indices into (x, y, z): down and up across x then z; north
-/// and south across x then y; west and east across z then y. (The block's corner at 0, 0, 0 is 0 on each.)
-pub fn side_axes(side: Direction) -> (usize, usize) {
-    match side {
-        Direction::Down | Direction::Up => (0, 2),
-        Direction::North | Direction::South => (0, 1),
-        Direction::West | Direction::East => (2, 1),
-    }
-}
-
-/// The axis a side faces along, and where its plane is (0 or 1).
-fn side_plane(side: Direction) -> (usize, f32) {
-    match side {
-        Direction::Down => (1, 0.0),
-        Direction::Up => (1, 1.0),
-        Direction::North => (2, 0.0),
-        Direction::South => (2, 1.0),
-        Direction::West => (0, 0.0),
-        Direction::East => (0, 1.0),
-    }
-}
-
-/// A block state from `name[property=value,...]`, the namespace `minecraft:` when it has none; properties left
-/// out take the block's default. None for a block or a property the game does not know.
-pub fn parse_state(registry: &BlockRegistry, text: &str) -> Option<BlockStateId> {
-    let (name, props) = match text.trim().split_once('[') {
-        Some((n, rest)) => (n, rest.strip_suffix(']')?),
-        None => (text.trim(), ""),
-    };
-    let name = if name.contains(':') {
-        name.to_owned()
-    } else {
-        format!("minecraft:{name}")
-    };
-    let default = registry.default_state(&name)?;
-    let mut state = registry.state(default)?.clone();
-    for pair in props.split(',').map(str::trim).filter(|p| !p.is_empty()) {
-        let (k, v) = pair.split_once('=')?;
-        let slot = state.properties.get_mut(k.trim())?;
-        *slot = v.trim().to_owned();
-    }
-    registry.resolve(&state).ok()
-}
-
-/// The sprites `context`'s resources hold, `split` layers to an array (`Renderer::sprite_split`).
-pub struct Lookup<'a> {
-    context: &'a WorkerContext,
-    split: u32,
-}
-
-impl<'a> Lookup<'a> {
-    pub fn new(context: &'a WorkerContext, split: u32) -> Self {
-        Self {
-            context,
-            split: split.max(1),
-        }
-    }
-    /// The sprite at `layer` of all the layers.
-    pub fn sprite(&self, layer: u32) -> SpriteRef {
-        let render = &self.context.render;
-        SpriteRef {
-            array: layer / self.split,
-            layer: layer % self.split,
-            animated: render.animations.iter().any(|a| a.layer == layer),
-            cutout: render
-                .sprite_mips
-                .get(layer as usize)
-                .is_some_and(|m| m.has_transparent),
-        }
-    }
-
-    /// A texture by name (`minecraft:block/stone`, `block/stone`); none for one no model uses (the arrays hold only
-    /// the textures models and the game's own drawing name).
-    pub fn texture(&self, name: &str) -> Option<SpriteRef> {
-        let layers = &self.context.render.sprite_layers;
-        let layer = layers
-            .get(name)
-            .or_else(|| layers.get(&format!("minecraft:{name}")))?;
-        Some(self.sprite(*layer))
-    }
-
-    /// What block `name` (`minecraft:oak_log[axis=x]`; properties left out take the default) draws on each side;
-    /// none for a block the game does not know.
-    pub fn block(&self, name: &str) -> Option<BlockSprites> {
-        let state = parse_state(self.context.assets.registry, name)?;
-        Some(self.state(state))
-    }
-
-    /// What `state` draws on each side. A fluid has its still texture on all six; a block drawn only as a block
-    /// entity (a chest, a sign) or not at all (air) has empty sides, and its particle sprite if any.
-    pub fn state(&self, state: BlockStateId) -> BlockSprites {
-        let render = &self.context.render;
-        let catalog = &render.model_catalog;
-        let mut sides: [Vec<FaceSprite>; 6] = Default::default();
-        let block = self
-            .context
-            .assets
-            .registry
-            .state(state)
-            .map_or("", |s| s.name.as_str());
-        let fluid = match block {
-            "minecraft:water" | "minecraft:bubble_column" => {
-                Some(("block/water_still", Some(TintSource::Water), true))
-            }
-            "minecraft:lava" => Some(("block/lava_still", None, false)),
-            _ => None,
-        };
-        if let Some((texture, tint, translucent)) = fluid {
-            let sprite = self.texture(texture);
-            if let Some(sprite) = sprite {
-                for side in &mut sides {
-                    side.push(FaceSprite {
-                        sprite,
-                        rect: [0.0, 0.0, 1.0, 1.0],
-                        inset: 0.0,
-                        uv: [0.0, 0.0, 1.0, 0.0, 0.0, 1.0],
-                        tint,
-                        translucent,
-                    });
-                }
-            }
-            return BlockSprites {
-                sides,
-                particle: sprite,
-                cube: sprite.is_some(),
-            };
-        }
-        let models = catalog
-            .collect(state, BlockPos::new(0, 0, 0))
-            .unwrap_or_default();
-        let mut all = 0;
-        for face in models.iter().flat_map(|(_, m)| &m.faces) {
-            all += 1;
-            let Some((side, sprite)) = self.face(state, face) else {
-                continue;
-            };
-            sides[side as usize].push(sprite);
-        }
-        let particle = catalog
-            .particle(state)
-            .or_else(|| {
-                models
-                    .iter()
-                    .flat_map(|(_, m)| &m.faces)
-                    .map(|f| f.layer)
-                    .next()
-            })
-            .map(|layer| self.sprite(layer));
-        // a cube: every side has a whole face at its plane (and perhaps overlays laid on it), and the model has no
-        // other faces
-        let whole = |f: &FaceSprite| f.rect == [0.0, 0.0, 1.0, 1.0] && f.inset == 0.0;
-        let cube = all == sides.iter().map(Vec::len).sum::<usize>()
-            && sides.iter().all(|s| !s.is_empty() && s.iter().all(whole));
-        BlockSprites {
-            sides,
-            particle,
-            cube,
-        }
-    }
-
-    /// A model face as it lies on its side; none when it does not lie flat on one.
-    fn face(&self, state: BlockStateId, face: &BakedFace) -> Option<(Direction, FaceSprite)> {
-        let q = &face.quad;
-        let side = q.facing;
-        let (normal, plane) = side_plane(side);
-        let depth = q.positions[0][normal];
-        if q.positions.iter().any(|p| (p[normal] - depth).abs() > 1e-4) {
-            return None;
-        }
-        let (a, b) = side_axes(side);
-        let ab: [[f32; 2]; 4] = q.positions.map(|p| [p[a], p[b]]);
-        let uv = affine(&ab, &q.uv)?;
-        let (mut a0, mut b0, mut a1, mut b1) = (f32::MAX, f32::MAX, f32::MIN, f32::MIN);
-        for [x, y] in ab {
-            a0 = a0.min(x);
-            b0 = b0.min(y);
-            a1 = a1.max(x);
-            b1 = b1.max(y);
-        }
-        let snap = |v: f32| {
-            let r = (v * 4096.0).round() / 4096.0;
-            if r == 0.0 { 0.0 } else { r }
-        };
-        Some((
-            side,
-            FaceSprite {
-                sprite: self.sprite(face.layer),
-                rect: [a0, b0, a1, b1].map(snap),
-                inset: snap((depth - plane).abs()),
-                uv: uv.map(snap),
-                tint: self.context.tables.tint_source(state, q.tint_index),
-                translucent: face.translucent,
-            },
-        ))
-    }
-}
-
-/// The affine map from a face's points on its side to its UVs, `[u0, v0, du_u, du_v, dv_u, dv_v]`, from three of
-/// its corners that are not in a line (a model's faces are parallelograms on their side).
-fn affine(ab: &[[f32; 2]; 4], uv: &[[f32; 2]; 4]) -> Option<[f32; 6]> {
-    for [i, j, k] in [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]] {
-        let d1 = [ab[j][0] - ab[i][0], ab[j][1] - ab[i][1]];
-        let d2 = [ab[k][0] - ab[i][0], ab[k][1] - ab[i][1]];
-        let det = d1[0] * d2[1] - d1[1] * d2[0];
-        if det.abs() < 1e-6 {
-            continue;
-        }
-        let e1 = [uv[j][0] - uv[i][0], uv[j][1] - uv[i][1]];
-        let e2 = [uv[k][0] - uv[i][0], uv[k][1] - uv[i][1]];
-        // e1 = d1.a * du + d1.b * dv, e2 = d2.a * du + d2.b * dv
-        let du = [
-            (e1[0] * d2[1] - e2[0] * d1[1]) / det,
-            (e1[1] * d2[1] - e2[1] * d1[1]) / det,
-        ];
-        let dv = [
-            (e2[0] * d1[0] - e1[0] * d2[0]) / det,
-            (e2[1] * d1[0] - e1[1] * d2[0]) / det,
-        ];
-        let o = [
-            uv[i][0] - ab[i][0] * du[0] - ab[i][1] * dv[0],
-            uv[i][1] - ab[i][0] * du[1] - ab[i][1] * dv[1],
-        ];
-        return Some([o[0], o[1], du[0], du[1], dv[0], dv[1]]);
-    }
-    None
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn a_faces_texture_runs_across_its_side() {
-        // a whole face, the texture upright: u along a, v along b
-        let ab = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]];
-        assert_eq!(
-            affine(&ab, &[[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]]),
-            Some([0.0, 0.0, 1.0, 0.0, 0.0, 1.0])
-        );
-        // turned a quarter (a log on its side): u runs down b, v back along a
-        let turned = affine(&ab, &[[0.0, 1.0], [0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]).unwrap();
-        assert_eq!(turned, [0.0, 1.0, 0.0, -1.0, 1.0, 0.0]);
-        // a slab's side: the lower half of the block, the lower half of the texture (v counts down)
-        let half = [[0.0, 0.0], [1.0, 0.0], [1.0, 0.5], [0.0, 0.5]];
-        let m = affine(&half, &[[0.0, 1.0], [1.0, 1.0], [1.0, 0.5], [0.0, 0.5]]).unwrap();
-        assert_eq!(m, [0.0, 1.0, 1.0, 0.0, 0.0, -1.0]);
-        // a face seen edge on has no map
-        assert_eq!(affine(&[[0.0, 0.0]; 4], &[[0.0, 0.0]; 4]), None);
-    }
-
-    /// The game's own blocks from real prepared resources: a cube, a grass block's tinted top and overlaid sides, a
-    /// log on its side (its texture turned), leaves (cut out, foliage), water, a slab and a flower.
-    #[test]
-    #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"]
-    fn real_blocks_name_their_sprites() -> crate::Result<()> {
-        use crate::{
-            assets::Assets, biome::Biomes, blocks::BlockFacts, light::LightTables,
-            mesher::MeshTables,
-        };
-        use std::sync::Arc;
-        let root = std::path::PathBuf::from(
-            std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"),
-        );
-        let assets = Arc::new(Assets::load(&root)?);
-        let render = Arc::new(assets.reload(&root)?);
-        let facts = BlockFacts::load(&root, assets.registry)?;
-        let tables = Arc::new(MeshTables::new(
-            &assets,
-            &render,
-            &facts,
-            crate::models::load_visibility(&root, assets.registry)?,
-        )?);
-        let context = WorkerContext {
-            light: Arc::new(LightTables::load(&root, assets.registry, &facts)?),
-            tables,
-            assets: assets.clone(),
-            render,
-            biomes: Arc::new(Biomes::load(&root)?),
-        };
-        let lookup = Lookup::new(&context, 2048);
-        let whole = [0.0, 0.0, 1.0, 1.0];
-        let upright = [0.0, 0.0, 1.0, 0.0, 0.0, 1.0];
-
-        let stone = lookup.block("minecraft:stone").unwrap();
-        assert!(stone.cube);
-        let top = stone.sides[Direction::Up as usize][0];
-        assert_eq!(
-            (top.rect, top.inset, top.tint, top.sprite.array),
-            (whole, 0.0, None, 0)
-        );
-        assert_eq!(lookup.texture("minecraft:block/stone"), Some(top.sprite));
-        assert_eq!(lookup.texture("block/stone"), Some(top.sprite));
-        assert!(!top.sprite.animated && !top.sprite.cutout);
-
-        let grass = lookup.block("grass_block").unwrap();
-        assert!(grass.cube);
-        assert_eq!(
-            grass.sides[Direction::Up as usize][0].tint,
-            Some(TintSource::Grass)
-        );
-        assert_eq!(grass.sides[Direction::Down as usize][0].tint, None);
-        let side = &grass.sides[Direction::North as usize];
-        assert_eq!(side.len(), 2, "the side and its overlay");
-        assert_eq!(
-            (side[0].tint, side[1].tint),
-            (None, Some(TintSource::Grass))
-        );
-        assert_eq!(
-            lookup.texture("block/grass_block_side_overlay"),
-            Some(side[1].sprite)
-        );
-
-        // seen from outside, a side's texture runs from its top left: on the north side (looking south, east on
-        // the left) u falls with x and v with y; on top, u and v run with x and z (stone's first variant is turned)
-        let planks = lookup.block("oak_planks").unwrap();
-        let uv = |b: &BlockSprites, d: Direction| b.sides[d as usize][0].uv;
-        let north = uv(&planks, Direction::North);
-        assert_eq!(north, [1.0, 1.0, -1.0, 0.0, 0.0, -1.0]);
-        assert_eq!(uv(&planks, Direction::Up), upright);
-        assert_eq!(
-            uv(&planks, Direction::South),
-            [0.0, 1.0, 1.0, 0.0, 0.0, -1.0]
-        );
-        assert_eq!(
-            uv(&planks, Direction::Down),
-            [0.0, 1.0, 1.0, 0.0, 0.0, -1.0]
-        );
-        // an upright log's side runs as stone's; on its side (axis x) the texture is turned a quarter
-        let log = lookup.block("oak_log").unwrap();
-        let log_x = lookup.block("minecraft:oak_log[axis=x]").unwrap();
-        assert_eq!(log.sides[Direction::North as usize][0].uv, north);
-        let turned = log_x.sides[Direction::North as usize][0].uv;
-        assert_eq!(
-            (turned[2], turned[5]),
-            (0.0, 0.0),
-            "u runs along y, v along x: {turned:?}"
-        );
-        assert_eq!(
-            log_x.sides[Direction::West as usize][0].sprite,
-            log.sides[Direction::Up as usize][0].sprite,
-            "its end faces west"
-        );
-
-        let leaves = lookup.block("oak_leaves").unwrap();
-        let leaf = leaves.sides[Direction::Up as usize][0];
-        assert!(leaf.sprite.cutout);
-        assert_eq!(leaf.tint, Some(TintSource::Foliage));
-        assert!(matches!(
-            lookup.block("spruce_leaves").unwrap().sides[0][0].tint,
-            Some(TintSource::Fixed(0x61_9961))
-        ));
-
-        let water = lookup.block("water").unwrap();
-        let w = water.sides[Direction::Up as usize][0];
-        assert!(w.sprite.animated && w.translucent);
-        assert_eq!(w.tint, Some(TintSource::Water));
-
-        let slab = lookup.block("stone_slab").unwrap();
-        assert!(!slab.cube);
-        assert_eq!(slab.sides[Direction::Up as usize][0].inset, 0.5);
-        assert_eq!(
-            slab.sides[Direction::North as usize][0].rect,
-            [0.0, 0.0, 1.0, 0.5]
-        );
-
-        let flower = lookup.block("dandelion").unwrap();
-        assert!(!flower.cube && flower.sides.iter().all(Vec::is_empty));
-        assert!(flower.particle.is_some_and(|p| p.cutout));
-
-        assert_eq!(lookup.block("minecraft:no_such_block"), None);
-        assert_eq!(lookup.block("stone[no_such=1]"), None);
-        assert!(lookup.block("air").unwrap().sides.iter().all(Vec::is_empty));
-        Ok(())
-    }
-}

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

@@ -1,452 +0,0 @@
-//! Finding a server's BlueMap without the player naming it
-//! (`blueMapAutoDetect`, off by default): the BlueMap worker tries a few
-//! likely web addresses (`candidates`), taking only one whose `settings.json`
-//! is BlueMap's web-app settings, and the answer is kept per server in
-//! `server-terrain/<server>/BlueMap/detected.txt` so a rejoin asks nothing.
-//! A `blueMap:` line the player wrote always wins.
-use crate::bluemap::Settings;
-use std::{
-    net::IpAddr,
-    path::{Path, PathBuf},
-    sync::Mutex,
-    time::{Duration, SystemTime},
-};
-
-/// The answer kept per server, beside its BlueMap tiles.
-pub const FILE: &str = "detected.txt";
-/// A server found without a map is asked again after this long.
-pub const RETRY_NONE: Duration = Duration::from_secs(24 * 3600);
-/// A map found is checked again (its address first) after this long.
-pub const RETRY_FOUND: Duration = Duration::from_secs(7 * 24 * 3600);
-/// Each probe gets this long, connecting included.
-pub const TIMEOUT: Duration = Duration::from_secs(4);
-/// Probes start this far apart at least.
-pub const GAP: Duration = Duration::from_millis(500);
-
-/// Where a level's BlueMap comes from.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Source {
-    /// The player's `blueMap:` line, or a map found before.
-    Url {
-        url: String,
-        maps: Vec<(String, String)>,
-    },
-    /// To be looked for at these addresses, in order.
-    Detect(Vec<String>),
-}
-
-/// What the server at `address` draws far terrain from, its BlueMap folder
-/// being `dir`: `None` when the player named no map and either auto-detect
-/// is off or the server was found without one recently.
-pub fn source(settings: &Settings, address: &str, dir: &Path, now: SystemTime) -> Option<Source> {
-    if let Some(server) = settings.server(address) {
-        return Some(Source::Url {
-            url: server.url.clone(),
-            maps: server.maps.clone(),
-        });
-    }
-    if !settings.auto_detect {
-        return None;
-    }
-    let mut probes = Vec::new();
-    // Only an address this server's would be looked for at: a remembered
-    // one from elsewhere (a copied folder) names someone else's.
-    let ours = candidates(address);
-    match remembered(dir, now) {
-        Remembered::Found(url) | Remembered::Stale(Some(url)) if !ours.contains(&url) => {}
-        Remembered::Found(url) => {
-            return Some(Source::Url {
-                url,
-                maps: Vec::new(),
-            });
-        }
-        Remembered::Nothing => return None,
-        Remembered::Stale(Some(url)) => probes.push(url),
-        Remembered::Stale(None) => {}
-    }
-    for candidate in ours {
-        if !probes.contains(&candidate) {
-            probes.push(candidate);
-        }
-    }
-    (!probes.is_empty()).then_some(Source::Detect(probes))
-}
-
-/// The first labels a game server's host name takes beside its site's.
-const GAME_LABELS: &[&str] = &["play", "mc", "minecraft", "mine", "join", "server"];
-
-/// Domains whose names belong to many customers (dynamic DNS, server
-/// hosts): `map.` of them is someone else's.
-const SHARED: &[&str] = &[
-    "aternos.me",
-    "ddns.net",
-    "duckdns.org",
-    "hopto.org",
-    "minehut.gg",
-    "no-ip.org",
-    "playit.gg",
-    "serveminecraft.net",
-    "zapto.org",
-];
-
-/// The web addresses a server's BlueMap likely answers at: BlueMap's own
-/// web server (port 8100), the server's host, and its `map.` subdomain, also
-/// under the parent domain of a `play.`/`mc.` style host (`GAME_LABELS`).
-pub fn candidates(address: &str) -> Vec<String> {
-    let address = address.trim().to_ascii_lowercase();
-    let host = if let Some(rest) = address.strip_prefix('[') {
-        rest.split(']').next().unwrap_or(rest)
-    } else if address.matches(':').count() > 1 {
-        &address[..]
-    } else {
-        address.split(':').next().unwrap_or(&address)
-    };
-    let host = host.trim_end_matches('.');
-    if host.is_empty() {
-        return Vec::new();
-    }
-    let mut out = Vec::new();
-    if let Ok(ip) = host.parse::<IpAddr>() {
-        // Certificates are for names: plain HTTP only.
-        let host = match ip {
-            IpAddr::V6(_) => format!("[{host}]"),
-            IpAddr::V4(_) => host.to_owned(),
-        };
-        out.push(format!("http://{host}:8100"));
-        out.push(format!("http://{host}"));
-        return out;
-    }
-    if !host
-        .chars()
-        .all(|c| c.is_ascii_alphanumeric() || c == '.' || c == '-')
-    {
-        return Vec::new();
-    }
-    out.push(format!("http://{host}:8100"));
-    let labels = host.split('.').count();
-    let map = |host: &str| (!host.starts_with("map.")).then(|| format!("map.{host}"));
-    if labels >= 2
-        && let Some(map) = map(host)
-    {
-        out.push(format!("https://{map}"));
-    }
-    out.push(format!("https://{host}"));
-    if labels >= 2
-        && let Some(map) = map(host)
-    {
-        out.push(format!("http://{map}"));
-    }
-    out.push(format!("http://{host}"));
-    // `play.example.net` → `map.example.net`, only for a game server's
-    // usual names: the parent of `name.hosting.example` is another party's.
-    if labels >= 3
-        && let Some((first, parent)) = host.split_once('.')
-        && GAME_LABELS.contains(&first)
-        && !SHARED.contains(&parent)
-        && let Some(map) = map(parent)
-    {
-        out.push(format!("https://{map}"));
-        out.push(format!("http://{map}"));
-    }
-    let mut seen = Vec::new();
-    out.retain(|url| {
-        let new = !seen.contains(url);
-        seen.push(url.clone());
-        new
-    });
-    out
-}
-
-/// Whether `json` is a BlueMap web app's `settings.json`: a list of map ids
-/// and where their data lies, not any page a web server returns.
-pub fn is_web_app_settings(json: &[u8]) -> bool {
-    let Ok(v) = serde_json::from_slice::<serde_json::Value>(json) else {
-        return false;
-    };
-    let maps = v.get("maps").and_then(|m| m.as_array());
-    maps.is_some_and(|maps| !maps.is_empty() && maps.iter().all(|m| m.is_string()))
-        && v.get("mapDataRoot").is_some_and(|r| r.is_string())
-}
-
-/// Whether a BlueMap web app answers at `base`.
-pub fn probe(agent: &ureq::Agent, base: &str) -> bool {
-    use std::io::Read;
-    let Ok(response) = agent
-        .get(&format!("{base}/settings.json"))
-        .timeout(TIMEOUT)
-        .call()
-    else {
-        return false;
-    };
-    let mut body = Vec::new();
-    response
-        .into_reader()
-        .take(256 << 10)
-        .read_to_end(&mut body)
-        .is_ok()
-        && is_web_app_settings(&body)
-}
-
-/// What an earlier look found.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Remembered {
-    Found(String),
-    /// Nothing, recently.
-    Nothing,
-    /// Never looked, or long enough ago to look again (first at the map
-    /// found then, if any).
-    Stale(Option<String>),
-}
-
-pub fn remembered(dir: &Path, now: SystemTime) -> Remembered {
-    let Ok(text) = std::fs::read_to_string(dir.join(FILE)) else {
-        return Remembered::Stale(None);
-    };
-    let mut words = text.split_whitespace();
-    let (kind, at) = (words.next(), words.next().and_then(|t| t.parse().ok()));
-    let Some(at) = at.map(|secs| SystemTime::UNIX_EPOCH + Duration::from_secs(secs)) else {
-        return Remembered::Stale(None);
-    };
-    // A time ahead of the clock (a clock set wrong, a copied file) is stale.
-    let Ok(age) = now.duration_since(at) else {
-        return Remembered::Stale(None);
-    };
-    match (kind, words.next()) {
-        (Some("found"), Some(url)) if age < RETRY_FOUND => Remembered::Found(url.to_owned()),
-        (Some("found"), Some(url)) => Remembered::Stale(Some(url.to_owned())),
-        (Some("none"), _) if age < RETRY_NONE => Remembered::Nothing,
-        _ => Remembered::Stale(None),
-    }
-}
-
-/// Keeps what a look found (`None`: no map).
-pub fn remember(dir: &Path, found: Option<&str>, now: SystemTime) {
-    let secs = now
-        .duration_since(SystemTime::UNIX_EPOCH)
-        .map_or(0, |d| d.as_secs());
-    let text = match found {
-        Some(url) => format!("found {secs} {url}\n"),
-        None => format!("none {secs}\n"),
-    };
-    let _ = std::fs::create_dir_all(dir);
-    let _ = std::fs::write(dir.join(FILE), text);
-}
-
-/// The servers being looked at now, by BlueMap folder: one look a server at
-/// a time, however many levels open meanwhile.
-static LOOKING: Mutex<Vec<PathBuf>> = Mutex::new(Vec::new());
-
-/// The right to look for `dir`'s server's map, until dropped.
-pub struct Claim(PathBuf);
-impl Claim {
-    /// `None` while another look at the same server runs.
-    pub fn take(dir: &Path) -> Option<Self> {
-        let mut looking = LOOKING.lock().unwrap();
-        if looking.iter().any(|d| d == dir) {
-            return None;
-        }
-        looking.push(dir.to_owned());
-        Some(Self(dir.to_owned()))
-    }
-}
-impl Drop for Claim {
-    fn drop(&mut self) {
-        LOOKING.lock().unwrap().retain(|d| *d != self.0);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn candidates_cover_the_web_server_host_and_map_subdomains() {
-        assert_eq!(
-            candidates("Play.Example.net:25566"),
-            [
-                "http://play.example.net:8100",
-                "https://map.play.example.net",
-                "https://play.example.net",
-                "http://map.play.example.net",
-                "http://play.example.net",
-                "https://map.example.net",
-                "http://map.example.net",
-            ]
-        );
-        assert_eq!(
-            candidates("example.net"),
-            [
-                "http://example.net:8100",
-                "https://map.example.net",
-                "https://example.net",
-                "http://map.example.net",
-                "http://example.net",
-            ]
-        );
-        // Already the map's host: no `map.map.`.
-        assert_eq!(
-            candidates("map.example.net"),
-            [
-                "http://map.example.net:8100",
-                "https://map.example.net",
-                "http://map.example.net",
-            ]
-        );
-        assert_eq!(
-            candidates("192.0.2.7:25565"),
-            ["http://192.0.2.7:8100", "http://192.0.2.7"]
-        );
-        assert_eq!(
-            candidates("[2001:db8::7]:25565"),
-            ["http://[2001:db8::7]:8100", "http://[2001:db8::7]"]
-        );
-        assert_eq!(
-            candidates("2001:db8::7"),
-            ["http://[2001:db8::7]:8100", "http://[2001:db8::7]"]
-        );
-        assert_eq!(
-            candidates("localhost"),
-            [
-                "http://localhost:8100",
-                "https://localhost",
-                "http://localhost"
-            ]
-        );
-        // A hosted name's parent is the host's, not the server's.
-        assert!(
-            !candidates("play.ddns.net")
-                .iter()
-                .any(|url| url.ends_with("//map.ddns.net"))
-        );
-        assert!(
-            !candidates("name.host.example")
-                .iter()
-                .any(|url| url.ends_with("//map.host.example"))
-        );
-        assert!(candidates("").is_empty());
-        assert!(candidates("evil.example.net/path?x").is_empty());
-    }
-
-    #[test]
-    fn only_blue_maps_settings_count() {
-        let web_app = br#"{"version":"5.4","useCookies":true,"maps":["world","world_nether"],
-            "mapDataRoot":"maps","liveDataRoot":"maps","scripts":[],"styles":[]}"#;
-        assert!(is_web_app_settings(web_app));
-        assert!(!is_web_app_settings(b"<!doctype html><html></html>"));
-        assert!(
-            !is_web_app_settings(br#"{"maps":["world"]}"#),
-            "no data root"
-        );
-        assert!(!is_web_app_settings(br#"{"maps":[],"mapDataRoot":"maps"}"#));
-        assert!(!is_web_app_settings(
-            br#"{"maps":[1],"mapDataRoot":"maps"}"#
-        ));
-        assert!(!is_web_app_settings(
-            br#"{"maps":"world","mapDataRoot":"maps"}"#
-        ));
-        assert!(!is_web_app_settings(
-            br#"[{"maps":["world"],"mapDataRoot":"maps"}]"#
-        ));
-    }
-
-    fn scratch(name: &str) -> PathBuf {
-        let dir = std::env::temp_dir().join(format!(
-            "horizon-bluemap-detect-{name}-{}",
-            std::process::id()
-        ));
-        let _ = std::fs::remove_dir_all(&dir);
-        dir
-    }
-
-    #[test]
-    fn answers_are_kept_and_looked_at_again_later() {
-        let dir = scratch("remember");
-        let t0 = SystemTime::UNIX_EPOCH + Duration::from_secs(1_800_000_000);
-        let hour = Duration::from_secs(3600);
-        assert_eq!(remembered(&dir, t0), Remembered::Stale(None));
-        remember(&dir, None, t0);
-        assert_eq!(remembered(&dir, t0 + hour), Remembered::Nothing);
-        // Written ahead of the clock: not trusted.
-        assert_eq!(remembered(&dir, t0 - hour), Remembered::Stale(None));
-        assert_eq!(remembered(&dir, t0 + RETRY_NONE), Remembered::Stale(None));
-        remember(&dir, Some("https://map.example.net"), t0);
-        assert_eq!(
-            remembered(&dir, t0 + 2 * RETRY_NONE),
-            Remembered::Found("https://map.example.net".into())
-        );
-        assert_eq!(
-            remembered(&dir, t0 + RETRY_FOUND),
-            Remembered::Stale(Some("https://map.example.net".into()))
-        );
-        std::fs::write(dir.join(FILE), "garbage").unwrap();
-        assert_eq!(remembered(&dir, t0), Remembered::Stale(None));
-        std::fs::remove_dir_all(&dir).unwrap();
-    }
-
-    #[test]
-    fn the_players_map_wins_and_detection_waits_for_the_setting() {
-        let dir = scratch("source");
-        let now = SystemTime::now();
-        let mut settings = Settings::default();
-        let address = "play.example.net";
-        assert_eq!(
-            source(&settings, address, &dir, now),
-            None,
-            "off by default"
-        );
-        settings.auto_detect = true;
-        let Some(Source::Detect(probes)) = source(&settings, address, &dir, now) else {
-            panic!("looked for");
-        };
-        assert_eq!(probes, candidates(address));
-        remember(&dir, None, now);
-        assert_eq!(
-            source(&settings, address, &dir, now),
-            None,
-            "none, recently"
-        );
-        remember(&dir, Some("https://map.example.net"), now);
-        assert_eq!(
-            source(&settings, address, &dir, now),
-            Some(Source::Url {
-                url: "https://map.example.net".into(),
-                maps: Vec::new()
-            })
-        );
-        // A remembered map this server's addresses don't include (a copied
-        // folder's) is no map.
-        remember(&dir, Some("https://tracker.example"), now);
-        let Some(Source::Detect(probes)) = source(&settings, address, &dir, now) else {
-            panic!("looked for, the remembered one ignored");
-        };
-        assert_eq!(probes, candidates(address));
-        remember(&dir, Some("https://map.example.net"), now);
-        // Past a week the found map is tried first, then the rest.
-        let later = now + RETRY_FOUND;
-        let Some(Source::Detect(probes)) = source(&settings, address, &dir, later) else {
-            panic!("looked for again");
-        };
-        assert_eq!(probes[0], "https://map.example.net");
-        assert_eq!(probes.len(), candidates(address).len());
-        settings.servers.push(
-            Settings::parse_server("play.example.net http://example.net:8123 nether=n").unwrap(),
-        );
-        assert_eq!(
-            source(&settings, address, &dir, now),
-            Some(Source::Url {
-                url: "http://example.net:8123".into(),
-                maps: vec![("minecraft:the_nether".into(), "n".into())]
-            })
-        );
-        std::fs::remove_dir_all(&dir).unwrap();
-    }
-
-    #[test]
-    fn one_look_a_server_at_a_time() {
-        let dir = scratch("claim");
-        let claim = Claim::take(&dir).unwrap();
-        assert!(Claim::take(&dir).is_none());
-        drop(claim);
-        assert!(Claim::take(&dir).is_some());
-    }
-}

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

@@ -118,7 +118,6 @@ mod tests {
                 layer: 0,
                 opaque: true,
                 translucent: false,
-                fusion: None,
                 quad: ModelQuad {
                     positions: [
                         [0.0, 0.5, 0.0],
@@ -136,11 +135,6 @@ mod tests {
                     tint_index: -1,
                     shade_direction_override: None,
                     light_emission: 0,
-                    light: [0; 2],
-                    color: None,
-                    ambient_occlusion: None,
-                    render_type: None,
-                    shade: true,
                 },
             }],
         }

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

@@ -340,17 +340,6 @@ impl BrewingStand {
         }
         out
     }
-    pub fn idle(&self) -> bool {
-        let bottles = [
-            self.items[0].is_some(),
-            self.items[1].is_some(),
-            self.items[2].is_some(),
-        ];
-        self.brew_time <= 0
-            && self.items[3].is_none()
-            && (self.fuel > 0 || self.items[4].is_none())
-            && self.last_bottles == Some(bottles)
-    }
     fn brew(&mut self, brewing: &Brewing, items: &Items, out: &mut BrewTick) {
         let Some(ingredient) = self.items[3].clone() else {
             return;
@@ -466,27 +455,6 @@ mod tests {
         assert_eq!(stand.brew_time, 0);
     }
 
-    #[test]
-    fn a_brewing_stand_is_idle_only_while_its_tick_changes_nothing() {
-        let mut stand = BrewingStand::new();
-        assert!(!stand.idle());
-        stand.last_bottles = Some([false; 3]);
-        assert!(stand.idle());
-        stand.items[0] = Some(ItemStack::new("minecraft:potion", 1));
-        assert!(!stand.idle());
-        stand.last_bottles = Some([true, false, false]);
-        assert!(stand.idle());
-        stand.items[4] = Some(ItemStack::new("minecraft:blaze_powder", 1));
-        assert!(!stand.idle());
-        stand.fuel = 3;
-        assert!(stand.idle());
-        stand.items[3] = Some(ItemStack::new("minecraft:nether_wart", 1));
-        assert!(!stand.idle());
-        stand.items[3] = None;
-        stand.brew_time = 5;
-        assert!(!stand.idle());
-    }
-
     /// #3312: `PotionContents.getPotionDescription` names the effects with
     /// translatable components, so a Russian game reads them from ru_ru.json
     /// (the prepared one; skipped without it), as the tooltip's other lines.