Merge pull request #1447 from ludovic111/chore/client-mods-feature

🤖 Agent: merged after verify and CI parity passed, built merged with current main. Code mods become horizon-client's `mods` feature: CI's two test commands run with `--features horizon-client/mods,horizon-mods/pack`; tests pass with and without it.
Merge pull request #1522 from ludovic111/fix/prepare-netty-natives
2026-11-07 17:21:49 -10:00 · 2026-10-24 03:01:51 +02:00 · 2026-10-24 02:53:32 +02:00 · 2026-10-24 02:52:06 +02:00 · 2026-10-24 02:40:52 +02:00 · 2026-10-24 02:36:33 +02:00
736 changed files with 8467 additions and 8296 deletions
@@ -0,0 +1,5 @@
+# Generated files that tests compare byte for byte with what they generate: LF on every OS, also
+# where Git for Windows' core.autocrlf would check them out with CRLF.
+docs/launcher-commands.md text eol=lf
+docs/horizon-ctl-commands.md text eol=lf
+website/src/tokens.css text eol=lf
@@ -6,7 +6,6 @@
 /.github/                                @ludovic111
 /tools/ci/                               @ludovic111
 /tools/release_train.py                  @ludovic111
-/tools/release_channels.py               @ludovic111
 /crates/horizon-release-sign/            @ludovic111
 /crates/horizon-server/src/update.rs     @ludovic111
 /crates/horizon-server/Cargo.toml        @ludovic111
@@ -61,12 +61,17 @@ jobs:
        if: steps.rust.outputs.required != 'false'
        run: |
          cargo +stable fmt --all -- --check
-          cargo +stable clippy --workspace --all-targets -- -D warnings
+          # With the game's code mods (on in every release build, off by default).
+          cargo +stable clippy --workspace --all-targets --features horizon-client/mods -- -D warnings
          # The server build (released as horizon-engine): the game without sound or controllers.
          cargo +stable clippy -p horizon-client --all-targets --no-default-features -- -D warnings
+      # Libraries, binaries and integration tests, then doc tests: not the ~275 examples, which clippy above already
+      # type-checks and the parity job builds and runs (they were most of this step's build and link time).
      - name: Test Rust core and voxel kernel correctness
        if: steps.rust.outputs.required != 'false'
-        run: cargo +stable test --workspace
+        run: |
+          cargo +stable test --workspace --lib --bins --tests --features horizon-client/mods,horizon-mods/pack
+          cargo +stable test --workspace --doc --features horizon-client/mods,horizon-mods/pack
  parity:
    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
    uses: ./.github/workflows/parity.yml
@@ -1,55 +0,0 @@
-name: promote
-# Beta game releases become stable once a day (docs/release-flow.md, "Channels"): at 20:00 UTC (21:00 in Paris in
-# winter time, 22:00 in summer) tools/release_channels.py promotes the newest beta that had been out 6 hours by then,
-# passed its release smoke test and isn't covered by an issue labelled release-blocker. Launchers on the Alpha
-# channel install every beta when it is published; Stable gets the day's promotion. The later runs of the evening are
-# retries for a run GitHub starts late or skips: they promote the same beta, so stable still moves once.
-# By hand, from GitHub's app too (Actions > promote > Run workflow):
-#   gh workflow run promote -f tag=v0.2.3                 # that beta now, without waiting for 20:00
-#   gh workflow run promote -f tag=v0.2.3 -f force=true   # even blocked or without its smoke test
-#   gh workflow run promote -f dry_run=true               # say what would be promoted
-# Holding betas back: label an issue release-blocker. While it is open it holds every beta; closed as completed it
-# still holds the betas published before it closed. The issue's text is never read (its author could edit it).
-# When the oldest waiting beta is 30 hours old (it missed a promotion it was due for), an issue "Promotion to stable
-# has stalled" says so; it closes itself after the next promotion.
-on:
-  schedule:
-    - cron: '7,37 20-21 * * *'
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: The beta to promote now (empty = the newest beta that is due)
-        type: string
-        default: ''
-      force:
-        description: Promote that tag even if a release-blocker covers it or its smoke test didn't run
-        type: boolean
-        default: false
-      dry_run:
-        description: Say what would be promoted, change nothing
-        type: boolean
-        default: false
-permissions:
-  contents: write
-  issues: write
-concurrency:
-  group: promote
-  cancel-in-progress: false
-jobs:
-  promote:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          # The notes of a promoted release cover every pull request since the last stable one.
-          fetch-depth: 0
-          # gh uses GH_TOKEN below; nothing needs git credentials on disk.
-          persist-credentials: false
-      - name: Promote
-        env:
-          GH_TOKEN: ${{ github.token }}
-          TAG: ${{ inputs.tag }}
-          FORCE: ${{ inputs.force && 'yes' || '' }}
-          DRY_RUN: ${{ (inputs.dry_run || github.ref != 'refs/heads/main') && 'yes' || '' }}
-        run: python3 tools/release_channels.py promote ${TAG:+--tag "$TAG"} ${FORCE:+--force} ${DRY_RUN:+--dry-run}
@@ -3,12 +3,15 @@ name: release
 # release waiting for merges to settle goes out without another merge) and by hand, tools/release_train.py decides:
 # a release when pull requests merged since the last one changed what players run and the newest merged 5 minutes
 # ago (the oldest 20 minutes ago, if merges never pause), or at once for a pull request labelled release-now.
-# RELEASES_PAUSED=1 (repository variable) stops them.
+# RELEASES_PAUSED=1 (repository variable) stops them; so does an open issue labelled release-blocker, forced runs too.
 # Builds Linux (an older Ubuntu, so the binary runs on any recent distribution and on NixOS through nix-ld) and
 # Windows on GitHub, macOS on the Mac mini's runner (MAC_RUNNER=macos-latest sends it to GitHub), then
 # publishes vX.Y.Z on the release line in .github/release-line.txt (docs/versioning.md; without it, the dated
-# vYYYY.MM.DD[.N] from before 0.2) with notes from the merged pull requests, as a beta (a pre-release) that promote.yml makes
-# stable in its daily promotion. macOS: with the repository variable MACOS_SIGN_IDENTITY set, the programs are signed with
+# vYYYY.MM.DD[.N] from before 0.2) with notes from the merged pull requests, as the release and GitHub's latest: one
+# channel, which launchers, `horizon-server update` and install.sh follow at once. So it is published only after the
+# checks that used to gate a promotion pass in this run: the Mac mini's smoke test drew a world, and no release-blocker
+# is open (tools/release_train.py gate); otherwise nothing is published. macOS: with the repository variable
+# MACOS_SIGN_IDENTITY set, the programs are signed with
 # Developer ID and the hardened runtime and the zip is notarized, from the runner's signing keychain
 # (packaging/macos/README.md); unset (forks), ad hoc.
 #   gh workflow run release --ref <branch>                       # dry run: builds and notes, publishes nothing
@@ -32,6 +35,8 @@ on:
        default: false
 permissions:
  contents: read
+  # The open release-blocker issues (decide).
+  issues: read
 concurrency:
  group: game-release
  cancel-in-progress: false
@@ -128,7 +133,8 @@ jobs:
        if: runner.os == 'Linux'
        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
      - name: Build the client, horizon-ctl, horizon-prepare and horizon-server
-        run: cargo build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
+        # `horizon-client/mods`: every released game runs code mods (the feature is off in dev builds).
+        run: cargo build --release --locked --features horizon-client/mods -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
      - name: Every program the release folder takes was built
        run: |
          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
@@ -203,7 +209,7 @@ jobs:
                  or not report.get("meshed_sections") or not report.get("player"):
              sys.exit("the smoke run did not draw a world")
          EOF
-          # Published with the release: a beta becomes stable only with it (tools/release_channels.py).
+          # Published with the release; the publish job checks it again before it publishes anything.
          cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json"
      - uses: actions/upload-artifact@v4
        if: runner.environment == 'self-hosted'
@@ -250,8 +256,9 @@ jobs:
        run: |
          set -euo pipefail
          # After the client is packaged: target/release/horizon-client is rebuilt without the audio and
-          # controllers features, so it needs neither libasound nor libudev (minimal server images lack them).
-          cargo build --release --locked -p horizon-client --no-default-features --bin horizon-client
+          # controllers features, so it needs neither libasound nor libudev (minimal server images lack them),
+          # and with code mods like the client.
+          cargo build --release --locked -p horizon-client --no-default-features --features mods --bin horizon-client
          cargo run --locked -p xtask -- package-server target/release/horizon-client "dist/${{ matrix.server_dir }}"
          folder="dist/${{ matrix.server_dir }}"
          python3 tools/check_imports.py --server "$folder/horizon-engine" "$folder/horizon-server" "$folder/horizon-prepare"
@@ -319,6 +326,7 @@ jobs:
    timeout-minutes: 15
    permissions:
      contents: write
+      issues: read
    steps:
      - uses: actions/checkout@v4
        with:
@@ -341,6 +349,17 @@ jobs:
        run: |
          key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
          cargo run --locked --quiet -p horizon-release-sign -- verify --tag "$TAG" --publishing "${key[@]}" dist
+      - name: Ready to publish (the smoke test passed, no release-blocker is open)
+        # Right before publishing: an issue labelled while the builds ran still holds this release. A dry run only
+        # reports what a real run would do.
+        env:
+          GH_TOKEN: ${{ github.token }}
+          DRY_RUN: ${{ needs.decide.outputs.dry_run }}
+        run: |
+          if ! python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json --blockers; then
+            [[ "$DRY_RUN" == true ]] || { echo "::error::Nothing published"; exit 1; }
+            echo "::warning::A real run would publish nothing"
+          fi
      - name: Publish ${{ needs.decide.outputs.tag }}
        if: needs.decide.outputs.dry_run != 'true'
        env:
@@ -348,17 +367,15 @@ jobs:
          TAG: ${{ needs.decide.outputs.tag }}
        run: |
          signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig)
-          smoke=(); [[ -f dist/smoke-test.json ]] && smoke=(dist/smoke-test.json)
-          # A beta (pre-release), the Alpha channel's: promote.yml makes it stable and latest in its daily promotion
-          # (docs/release-flow.md).
+          # The release and the latest at once: there is one channel (docs/release-flow.md).
          gh release create "$TAG" --target "${{ needs.decide.outputs.head }}" --title "$(cat notes/title.txt)" \
-            --notes-file notes/body.md --prerelease --latest=false dist/horizon-linux-x86_64.tar.gz \
+            --notes-file notes/body.md --latest dist/horizon-linux-x86_64.tar.gz \
            dist/horizon-windows-x64.zip dist/horizon-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz \
-            dist/SHA256SUMS "${signature[@]}" "${smoke[@]}"
+            dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json
      - name: Dry run, the release that would be published
        if: needs.decide.outputs.dry_run == 'true'
        run: |
-          echo "Would publish ${{ needs.decide.outputs.tag }} at ${{ needs.decide.outputs.head }}: $(cat notes/title.txt)"
+          echo "Would publish ${{ needs.decide.outputs.tag }} at ${{ needs.decide.outputs.head }} as the release and latest: $(cat notes/title.txt)"
          ls -l dist
      - uses: actions/upload-artifact@v4
        with:
@@ -0,0 +1,175 @@
+# Horizon: a map for agents
+
+Minecraft: Java Edition 26.3 rewritten in Rust (wgpu). Vanilla is the specification wherever it has the
+feature. Read [CONTRIBUTING.md](CONTRIBUTING.md) once; this page tells you where things are.
+Feature → files → harness for the most-changed areas: [docs/architecture.md](docs/architecture.md).
+
+## Rules that bite
+
+- **Never commit Mojang's files**: game jars, assets, decompiled source, prepared resources (`.local/`).
+  `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit.
+- **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
+  folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
+  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Never write to
+  `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
+- **Mark what an agent posts.** A PR body starts with
+  `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.` (issues: "Filed by", reviews:
+  "Review by"); every comment starts with `🤖 Agent:`. Never write as Ludovic.
+- **Attribution.** Commits end with `Co-Authored-By: Claude <model> <[email protected]>`; PR bodies end
+  with `🤖 Generated with [Claude Code](https://claude.com/claude-code)`.
+- Everything players run is Rust. Python/Java only for dev tools and harness drivers in `tools/`.
+- Horizon-only features follow [docs/design-system.md](docs/design-system.md) and are off by default where
+  they would change the vanilla look.
+- Small PRs (< ~500 lines). Labels: `feature` (players get something new), `skip-release` (they see no
+  change), none for a fix. Agents never add `release-now`: the maintainer decides it. Every merge to main ships
+  ([docs/release-flow.md](docs/release-flow.md)).
+- Contributors first: `gh pr list --state open --search <area>` before you start; never duplicate theirs.
+
+## Crates
+
+Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-server` are separate workspaces.
+
+| Crate | Owns |
+|---|---|
+| `horizon-client` | The game: a lib (`src/lib.rs`, ~190 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
+| `horizon-world` | Vanilla world data with no gameplay loop: NBT, regions, chunks, `datafix/`, `worldgen/`, `level/` (server-side block behaviour, ticks, redstone), entity physics, items, effects, food, damage |
+| `horizon-core` | Simulation primitives: Java `Random`s, `jmath` (HotSpot-exact `Math`), positions, noise, density, paletted storage, `version.rs` (the pinned version) |
+| `horizon-protocol` | Network protocol 777: codecs, framing, encryption, `packets/{handshake,status,login,configuration,play}.rs`, `entity_data.rs` |
+| `horizon-assets` | Resource decoding: block-state and item models, baking, atlases |
+| `horizon-prepare` | Builds `.local/horizon-client/26.3` from the player's own Minecraft install (runs the Java exporters) |
+| `horizon-server` | `horizon-server`: `server.toml`, CLI, supervisor of the headless game ([docs/hosting.md](docs/hosting.md)) |
+| `horizon-server-files` | `server.properties`, eula, ops/whitelist/bans, usercache |
+| `horizon-friends`, `horizon-relay` | Play with Friends: invite codes, encrypted tunnel, the relay ([docs/play-with-friends.md](docs/play-with-friends.md)) |
+| `horizon-shaderpack` | OptiFine/Iris packs: preprocessor, GLSL → WGSL ([docs/shader-packs.md](docs/shader-packs.md)) |
+| `horizon-mods`, `horizon-mod-sdk`, `cargo-horizon-mod` | Sandboxed WebAssembly mods: runtime, SDK + WIT, `cargo horizon-mod` ([docs/mods.md](docs/mods.md)) |
+| `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) |
+| `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website |
+| `horizon-telemetry`, `horizon-telemetry-server`, `horizon-bench` | Opt-in data collection, its ingest server, the benchmark report format |
+| `horizon-dualsense`, `horizon-threads`, `horizon-release-sign`, `horizon-bots`, `voxel-kernels`, `xtask` | DualSense output, thread priorities, signed release checksums, load-test bots, occupancy kernels, repo tasks |
+| `launcher/` | GPUI launcher: `main.rs` (UI), `backend.rs` (installs, updates), `cli.rs`, `mcp.rs`, `*_page.rs` |
+
+Other top-level folders: `tools/` (harnesses and dev scripts), `tests/` (Python unit tests: `python3 -m
+unittest discover -s tests`), `mods/horizon/src/test/java/dev/horizonlab/parity/` (Java oracles),
+`website/` (playhorizon.dev; its paths are relative to `website/`), `docs/`, `.github/workflows/`.
+
+## Build and test fast
+
+```sh
+python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
+python3 tools/pr_ready.py --quick          # same without harnesses
+cargo test -p horizon-client --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
+cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
+python3 tools/parity.py --changed origin/main       # the harnesses your branch can affect (CI's parity job)
+python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cover these files, without running them
+python3 tools/parity.py mob_ai sculk       # named harnesses
+python3 tools/lan_e2e.py --check chest     # two real games over LAN (host in-frame); --server-thread for the host on its server thread
+python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
+```
+
+- Harnesses and the game need the vanilla data in `.local/` (`minecraft/`, `horizon-client/26.3`, `datagen/`,
+  `tools/`): see [docs/parity-workflow.md](docs/parity-workflow.md). Without it, pr_ready lists the
+  harnesses for CI.
+- A harness = `tools/test_<name>_parity.py` (324 of them) + a Java oracle (`mods/horizon/src/test/java/dev/horizonlab/parity/Vanilla*Oracle.java`)
+  + a Rust probe: `crates/<crate>/examples/<name>_{probe,fixture}.rs` (horizon-world 175, horizon-client 104),
+  or the game binary with a fixture env var (`game/dispense_fixture.rs`, `game/sculk_fixture.rs`,
+  `game/command_harness.rs`, `game/net_harness.rs`). Copy a nearby harness for a new one.
+- Probes build into `.local/parity-target/`; harnesses find binaries via `lab.cargo_target()`, never `target/`.
+- What a change reruns (of 329 harnesses, measured 2026-10-23): a file of the game binary (`game.rs`, `game/`)
+  ~25, a file of the client lib ~103, of `horizon-world` ~103–109, of `horizon-core` ~119. Plan for it.
+- Rust integration tests: `crates/horizon-client/tests/` (`lan_bot.rs`, `generation_saves.rs`, `streaming_meshes.rs`).
+- **macOS:** `cargo build/test --workspace` may fail to link the two wasm guest cdylibs (undefined
+  `horizon:mods/events` symbols) until #1446 lands: add `--exclude coords-hud --exclude horizon-mods-test-guest`.
+  Their real check is `cargo test -p horizon-mods` (builds them for `wasm32-unknown-unknown`).
+- Linux needs `libasound2-dev libudev-dev`; `--no-default-features` drops audio and controllers (the server build).
+- Run and drive the game (starts the `horizon-client` beside `horizon-ctl`; other arguments go to the game):
+  `target/fast/horizon-ctl --socket $PWD/ctl.sock launch --world W --creative --offscreen --wait --resources $PWD/.local/horizon-client/26.3`,
+  then `horizon-ctl --socket … state|keys|turn|command|screenshot|quit`
+  ([docs/horizon-ctl-commands.md](docs/horizon-ctl-commands.md)).
+
+## Vanilla reference
+
+- Decompiled sources: `.local/minecraft/26.3/sources/{client,server}/` (`python3 tools/lab.py decompile`).
+- Bytecode queries (callers through lambdas, every overload):
+  `python3 tools/rea_vanilla.py method net.minecraft.world.level.block.DispenserBlock dispenseFrom`
+  ([docs/decompilation-status.md](docs/decompilation-status.md)).
+- A harness runs the oracle against the real 26.3 jars and the Rust probe on the same inputs, then compares
+  their JSON. Oracle runs are cached by `tools/parity_shim.py`; `--fresh` reruns them.
+- Mirror vanilla's `Math` calls with `horizon_core::jmath`, and vanilla's RNG with `horizon_core::random`:
+  random draws must happen in vanilla's order.
+
+## horizon-client: where things live
+
+`L:` = lib (`crates/horizon-client/src/`), `G:` = bin (`crates/horizon-client/src/game/`). The lib can't see
+`Game`; bin code reaches the lib as `horizon_client::<module>`.
+
+| Subsystem | Files |
+|---|---|
+| Game loop, tick, frame | `game.rs`: `fn run`, `impl ApplicationHandler for Game` (`window_event`, `about_to_wait`), `fn tick`, `fn tick_world`, `fn render`; L: `clock.rs`, `window.rs`, `spans.rs` |
+| Rendering | L: `gfx.rs` (`Renderer::new`, `Renderer::render`), `gfx/` (cull, occlusion, translucency, upload, timing, lod, weather, stars, end_sky), `*.wgsl`, `particles.rs`, `block_entity_render.rs`, `item_render.rs`, `fog.rs`, `clouds.rs`, `camera.rs`, `first_person.rs`; G: `render_tick.rs`, `item_draw.rs` |
+| Chunks, streaming, light | L: `streaming.rs` (worker pool: generate, light, mesh), `world.rs`, `chunk.rs`, `chunk_map.rs`, `light.rs`, `mesher.rs` + `mesher/`, `vanillagen.rs` (binds horizon-world's generator), `lod.rs` + `lod/`, `ticket_levels.rs`; G: `world_loading.rs`, `postprocess.rs`; game.rs `fn update_world` |
+| World generation | `crates/horizon-world/src/worldgen/` (`generator*.rs`, `feature_graph.rs`, `structure/`, `carver/`) |
+| Block behaviour | `crates/horizon-world/src/level/` (`mod.rs`, `tick.rs`, `hooks.rs`, `redstone.rs`, `place.rs`, `interact.rs`); game.rs `fn tick_blocks`, `fn process_level_events` |
+| Mobs | L: `mobs.rs` (types), `mobs/` (`ai.rs`, `goals.rs`, `brain.rs`, `*_brain.rs`, `nav.rs`, `path.rs`, `species.rs`, `spawning.rs`, `render.rs`, `anim.rs`); G: `creatures.rs` (ticking, spawning, mob events), one file per mob family (`dragon.rs`, `wither.rs`, `villagers.rs`, `piglins.rs`, `golems.rs`...), `natural_spawning.rs` |
+| Other entities | L: `entities.rs`, `projectiles.rs`, `arrows.rs`; G: `boats.rs`, `minecarts.rs`, `mounts.rs`, `armor_stands.rs`, `paintings.rs`, `frames.rs`, `fireworks.rs`, `tnt.rs`, `explosion.rs` |
+| Player actions | game.rs (`fn use_hand`, `fn use_item`, `fn attack`, `fn tick_mining`, `fn break_block`); G: `hand.rs`, `combat.rs`, `consume.rs`, `potions.rs`, `shield.rs`, `crossbow.rs`, `trident.rs`, `fishing.rs`; L: `motion.rs` + `motion/` (movement), `collisions.rs`, `items.rs`, `item_data.rs` |
+| Inventory and containers | L: `menu.rs` (`AbstractContainerMenu.clicked`), `container_screen.rs`, `containers.rs`, `creative.rs`, `crafting.rs`, `recipe_book*.rs`, `stations.rs`, `merchant.rs`; game.rs `fn menu_ops`, `fn click_inventory`; G: `stations.rs`, `trading.rs`, `recipe_book.rs`, `machines.rs` |
+| Commands | parse: L: `command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`, `nbt_path.rs`; G: `functions.rs`, `command_blocks.rs` |
+| UI screens | `Screen` enum in game.rs; L: `title.rs` + `title/`, `options_ui.rs`, `multiplayer.rs`, `pack_screen.rs`, `graphics_ui.rs`, `screen_draw.rs`, `ui.rs` (widgets), `hud.rs`, `hud_layout.rs`, `hud_overlays.rs`, `chat.rs`, `tab_list.rs`; G: `startup_menu.rs`, `screens.rs` (pause, death), `options.rs`, `lan_screen.rs`, `chat.rs`, `sign_edit.rs`, `books.rs` |
+| Multiplayer client | L: `net.rs` (network thread); G: `remote.rs` (`fn handle_packet`, `fn tick_remote`), `remote_*.rs` (mob data, objects, projectiles, vehicles, stations) |
+| LAN host / server side | L: `lan/` (`conn.rs` handshake + login threads, `hub.rs` + `hub/` play state, `chunks.rs`, `entity.rs`, `tracking.rs`, `guest.rs`, `playerdata.rs`); G: `lan.rs` (`LanHost`), `lan_actions.rs` (`fn as_guest`, `fn tick_guests`), `lan_*.rs` per feature, `lan_entities.rs` (tracked entities) |
+| Integrated server | G: `integrated.rs` (the server thread), `levels.rs` (one level per dimension, `fn tick_server`), `server_travel.rs` |
+| Dedicated server | G: `dedicated.rs`, `dedicated/status.rs`; crates `horizon-server-files`, `horizon-server` |
+| Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `block_entity_nbt.rs`, `options_file.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
+| Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; L: `keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `osk.rs`, `clipboard.rs`; G: `pad.rs`, `pad_menu.rs` |
+| Audio | L: `audio.rs` (mixer), `sound_engine.rs`, `sound_events.rs`, `music.rs`, `ambience.rs`; G: `music.rs`, `subtitle_hud.rs` |
+| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `lang.rs`; crate `horizon-assets`; G: `packs.rs` |
+| Shader packs | L: `shader_pack.rs` (Horizon WGSL packs), `java_pack.rs` + crate `horizon-shaderpack` (Iris/OptiFine), `gfx/pack_stages.rs`, `gfx/java_stages.rs`; G: `shader_packs.rs` |
+| Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
+| Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
+| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |
+
+## How `Game` is organised
+
+- `struct Game` (game.rs, ~290 fields) holds everything. Its methods are spread over ~180 files: game.rs keeps
+  the core (tick, render, input, inventory, world open/close) and each `game/<feature>.rs` adds an
+  `impl Game<'_>` block for one feature, with its own state types. Fields are private to the bin.
+- Find a feature's code: `grep -rn "fn tick_<thing>\|fn <verb>_<thing>" crates/horizon-client/src/game*`;
+  the file is usually `game/<thing>s.rs`. Who calls it: grep the name in game.rs's `fn tick` / `fn tick_world`.
+- Fields that say which mode runs: `remote` (this window is a client of a server: multiplayer, LAN guest, or
+  single player on its server thread), `lan` (`LanHost`: this world is open to the network), `integrated`
+  (the window's own server thread), `serving` (this `Game` *is* that server thread), `options.dedicated`.
+  `fn tick` returns `tick_remote()` when `remote` is set; nothing else of the local simulation runs.
+- A server's players run through the same gameplay code as the local player: `as_guest` swaps the guest's
+  state (position, inventory, mode, mining, item use) into `Game` for one call (`game/lan_actions.rs`), and
+  `levels.rs` swaps whole dimensions in the same way. Changes reach clients through the block log, level
+  events and the entity tracker (`lan/tracking.rs`, `game/lan_entities.rs`).
+- Shared read-only data: `Resources` (`res`: blocks, items, recipes, mob types, biomes) and `PackResources`
+  (`pack`), both in game.rs.
+
+## The two single-player paths
+
+1. **In-frame (default since #1428):** the window's `Game` ticks the world itself, one level that follows
+   the player (`fn enter_dimension`). This is what Stable players run and what harnesses test.
+2. **Server thread (`--server-thread` or `HORIZON_SERVER_THREAD=1`):** `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. Not at parity yet:
+   open `[server-thread]` issues list the gaps.
+
+LAN guests and dedicated servers always use the server code, so a fix there serves both. Test both paths
+when you touch player-facing gameplay:
+
+```sh
+cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T                   # in-frame
+cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --server-thread   # server thread
+python3 tools/lan_e2e.py --check <name>                  # host in-frame, guest is a server client
+python3 tools/lan_e2e.py --server-thread --check <name>  # host on its server thread (portals, levels, distance, lava need it)
+python3 tools/parity.py dedicated_server server_entities server_player_damage
+```
+
+## Docs worth knowing
+
+[docs/parity-workflow.md](docs/parity-workflow.md) (runner, gate, shards, scopes) ·
+[docs/native-client.md](docs/native-client.md) (options, controls, horizon-ctl) ·
+[docs/server-levels.md](docs/server-levels.md) (levels per dimension) ·
+[docs/rust-parity.md](docs/rust-parity.md) (what is ported) · [docs/known-issues.md](docs/known-issues.md) ·
+[docs/release-flow.md](docs/release-flow.md) · [docs/README.md](docs/README.md) (index).
@@ -0,0 +1 @@
+AGENTS.md
@@ -1493,7 +1493,6 @@ dependencies = [
 name = "horizon-mods"
 version = "0.1.0"
 dependencies = [
- "horizon-mods",
 "log",
 "serde",
 "serde_json",
@@ -18,7 +18,8 @@ horizon-protocol = { path = "../horizon-protocol" }
 horizon-server-files = { path = "../horizon-server-files" }
 horizon-friends = { path = "../horizon-friends" }
 # Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md).
-horizon-mods = { path = "../horizon-mods" }
+# Their runtime is the `mods` feature.
+horizon-mods = { path = "../horizon-mods", default-features = false }
 wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl"] }
 winit = "0.30.13"
 pollster = "0.4"
@@ -78,6 +79,9 @@ default = ["audio", "controllers"]
 audio = ["dep:cpal"]
 # Controllers: gilrs, and the DualSense's own output. Without it only `horizon-ctl pad`'s virtual pad.
 controllers = ["dep:gilrs", "dep:horizon-dualsense"]
+# Runs code mods (wasmtime and cranelift: a quarter of a clean build). On in every release build
+# (release.yml); the tests and probes don't need it. Content mods load without it.
+mods = ["horizon-mods/runtime"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace"]

@@ -1,104 +0,0 @@
-//! Full production fact loading, including file reads, interning and temporary destruction.
-//! cargo run --profile fast -p horizon-client --example block_facts_bench -- ROOT [SAMPLES]
-//! Use SAMPLES=1 with an OS peak-RSS wrapper; `digest` checks all facts
-//! and the shape sharing partition (including sharing between outlines and edges).
-use horizon_client::blocks::BlockFacts;
-use horizon_world::{DATA_VERSION, nbt::Tag, registry::BlockRegistry};
-use serde_json::Value;
-use std::{
-    collections::{HashMap, hash_map::DefaultHasher},
-    fs,
-    hash::{Hash, Hasher},
-    hint::black_box,
-    path::Path,
-    time::Instant,
-};
-type Result<T> = horizon_client::Result<T>;
-
-fn tag(value: &Value) -> Result<Tag> {
-    Ok(match value {
-        Value::String(s) => Tag::String(s.as_str().into()),
-        Value::Number(n) => Tag::Int(i32::try_from(n.as_i64().ok_or("registry number")?)?),
-        Value::Array(a) => Tag::List(a.iter().map(tag).collect::<Result<_>>()?),
-        Value::Object(o) => Tag::Compound(
-            o.iter()
-                .map(|(k, v)| Ok((k.as_str().into(), tag(v)?)))
-                .collect::<Result<_>>()?,
-        ),
-        _ => return Err("registry value".into()),
-    })
-}
-fn registry(root: &Path) -> Result<BlockRegistry> {
-    let facts: Value = serde_json::from_slice(&fs::read(root.join("facts.json"))?)?;
-    Ok(BlockRegistry::from_nbt(&Tag::compound([
-        ("DataVersion", Tag::Int(DATA_VERSION)),
-        (
-            "states",
-            Tag::List(
-                facts["states"]
-                    .as_array()
-                    .ok_or("registry states")?
-                    .iter()
-                    .map(|s| tag(&s[4]))
-                    .collect::<Result<_>>()?,
-            ),
-        ),
-        ("defaults", tag(&facts["defaults"])?),
-    ]))?)
-}
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
-    let root = Path::new(
-        args.first()
-            .ok_or("usage: block_facts_bench ROOT [SAMPLES|digest]")?,
-    );
-    let setup = Instant::now();
-    let registry = registry(root)?;
-    println!(
-        "registry_setup_ms={:.3}",
-        setup.elapsed().as_secs_f64() * 1000.0
-    );
-    if args.get(1).is_some_and(|s| s == "digest") {
-        let facts = BlockFacts::load(root, &registry)?;
-        let mut hash = DefaultHasher::new();
-        let mut shapes = HashMap::new();
-        facts.air.hash(&mut hash);
-        for state in &facts.states {
-            format!("{state:?}").hash(&mut hash);
-            for shape in [&state.outline, &state.outline_edges] {
-                let next = shapes.len();
-                shapes
-                    .entry((shape.as_ptr(), shape.len()))
-                    .or_insert(next)
-                    .hash(&mut hash);
-            }
-        }
-        println!(
-            "states={} shared_shapes={} digest={:016x}",
-            facts.states.len(),
-            shapes.len(),
-            hash.finish()
-        );
-        return Ok(());
-    }
-    let samples: usize = args.get(1).map(|s| s.parse()).transpose()?.unwrap_or(9);
-    assert!(samples > 0);
-    // First load is reported separately; OS file caches are not forcibly evicted.
-    let load = || -> Result<f64> {
-        let start = Instant::now();
-        let facts = black_box(BlockFacts::load(black_box(root), black_box(&registry))?);
-        let ms = start.elapsed().as_secs_f64() * 1000.0;
-        drop(facts);
-        Ok(ms)
-    };
-    println!("first_load_ms={:.3}", load()?);
-    if samples > 1 {
-        load()?;
-        load()?;
-        let mut times = (0..samples).map(|_| load()).collect::<Result<Vec<_>>>()?;
-        println!("samples_ms={times:.3?}");
-        times.sort_by(f64::total_cmp);
-        println!("median_ms={:.3}", times[times.len() / 2]);
-    }
-    Ok(())
-}
@@ -1,216 +0,0 @@
-//! Resident chunk storage benchmark: generates a block of vanilla terrain, then
-//! reports the resident block/biome memory, the cost of lookups, meshing and
-//! lighting on it.
-//!
-//! chunk_bench <client resource dir> [--seed S] [--size N]
-#![forbid(unsafe_code)]
-use horizon_client::{
-    assets::Assets,
-    biome::Biomes,
-    blocks::BlockFacts,
-    chunk::{Chunk, MIN_Y, SECTIONS},
-    light::{LightTables, apply_lighting, light_chunk},
-    mesher::{MeshTables, Mesher},
-    models,
-    streaming::{ChunkGenerator, Proto},
-    vanillagen::VanillaTerrain,
-};
-use horizon_core::biome::BiomeZoom;
-use std::{path::PathBuf, sync::Arc, time::Instant};
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    let root = PathBuf::from(args.first().ok_or("usage: chunk_bench RESOURCES")?);
-    let flag = |name: &str, default: i64| -> i64 {
-        args.iter()
-            .position(|a| a == name)
-            .and_then(|i| args.get(i + 1))
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(default)
-    };
-    let (seed, size) = (flag("--seed", 12345), flag("--size", 8) as i32);
-    let assets = Assets::load(&root)?;
-    let render = assets.reload(&root)?;
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let biomes = Biomes::load(&root)?;
-    let tables = MeshTables::new(
-        &assets,
-        &render,
-        &facts,
-        models::load_visibility(&root, assets.registry)?,
-    )?;
-    let light = LightTables::load(&root, assets.registry, &facts)?;
-    let terrain = VanillaTerrain::new(&root.join("worldgen"), assets.registry, &biomes, seed)?;
-    let mut worker = terrain.worker();
-
-    // Protos for size+4 columns, decorated for the inner size+2, finished as size+2.
-    let started = Instant::now();
-    let outer = size + 4;
-    let mut protos: Vec<Option<Proto>> = (0..outer * outer)
-        .map(|i| Some(terrain.proto(&mut worker, i % outer, i / outer)))
-        .collect();
-    eprintln!("proto: {:.2}s", started.elapsed().as_secs_f64());
-    let started = Instant::now();
-    let inner = size + 2;
-    for z in 1..=inner {
-        for x in 1..=inner {
-            let mut region: [Proto; 9] = std::array::from_fn(|k| {
-                let (dx, dz) = (k as i32 % 3 - 1, k as i32 / 3 - 1);
-                protos[((z + dz) * outer + x + dx) as usize]
-                    .take()
-                    .expect("proto")
-            });
-            terrain.decorate(&mut worker, &mut region);
-            for (k, p) in region.into_iter().enumerate() {
-                let (dx, dz) = (k as i32 % 3 - 1, k as i32 / 3 - 1);
-                protos[((z + dz) * outer + x + dx) as usize] = Some(p);
-            }
-        }
-    }
-    eprintln!("decorate: {:.2}s", started.elapsed().as_secs_f64());
-    let started = Instant::now();
-    let mut chunks: Vec<Chunk> = Vec::new();
-    for z in 1..=inner {
-        for x in 1..=inner {
-            let proto = protos[(z * outer + x) as usize].take().expect("proto");
-            let mut chunk = terrain.finish(proto);
-            chunk.x = x;
-            chunk.z = z;
-            chunks.push(chunk);
-        }
-    }
-    let finish = started.elapsed().as_secs_f64();
-    println!(
-        "finish (proto -> resident chunk): {:.1} ms per chunk",
-        finish * 1e3 / chunks.len() as f64
-    );
-
-    let chunks: Vec<Arc<Chunk>> = chunks.into_iter().map(Arc::new).collect();
-    let at = |x: i32, z: i32| chunks[((z - 1) * inner + x - 1) as usize].clone();
-
-    // Light all inner-inner columns.
-    let started = Instant::now();
-    let mut lit = Vec::new();
-    for z in 2..inner {
-        for x in 2..inner {
-            let region: [[Option<Arc<Chunk>>; 3]; 3] = std::array::from_fn(|dz| {
-                std::array::from_fn(|dx| Some(at(x + dx as i32 - 1, z + dz as i32 - 1)))
-            });
-            let borrowed = horizon_client::mesher::borrow(&region);
-            lit.push(((x, z), light_chunk(&borrowed, &light, true)));
-        }
-    }
-    println!(
-        "light: {:.2} ms per column",
-        started.elapsed().as_secs_f64() * 1e3 / lit.len() as f64
-    );
-    let mut chunks: Vec<Chunk> = chunks.iter().map(|c| (**c).clone()).collect();
-    for ((x, z), sections) in lit {
-        apply_lighting(&mut chunks[((z - 1) * inner + x - 1) as usize], sections);
-    }
-    let chunks: Vec<Arc<Chunk>> = chunks.into_iter().map(Arc::new).collect();
-    let at = |x: i32, z: i32| chunks[((z - 1) * inner + x - 1) as usize].clone();
-
-    // Memory.
-    let (mut bytes, mut sections, mut uniform) = (0usize, 0usize, 0usize);
-    for chunk in &chunks {
-        bytes += chunk.heap_bytes();
-        for s in &chunk.sections {
-            sections += 1;
-            uniform += usize::from(s.is_uniform(s.get(0)));
-        }
-    }
-    println!(
-        "resident: {} chunks, {} sections ({} uniform), {:.1} KiB per chunk ({:.2} MiB total)",
-        chunks.len(),
-        sections,
-        uniform,
-        bytes as f64 / 1024.0 / chunks.len() as f64,
-        bytes as f64 / 1048576.0
-    );
-
-    // Meshing.
-    let mut mesher = Mesher {
-        nether_shading: false,
-        assets: &assets,
-        render: &render,
-        tables: &tables,
-        biomes: &biomes,
-        visibility: tables.visibility.clone(),
-        zoom: BiomeZoom::new(7),
-        blend_radius: 2,
-        smooth_lighting: true,
-        cutout_leaves: true,
-        cull_leaves: false,
-    };
-    let mut best = f64::MAX;
-    let mut quads = 0usize;
-    for _ in 0..3 {
-        let started = Instant::now();
-        let mut jobs = 0;
-        quads = 0;
-        for z in 2..inner {
-            for x in 2..inner {
-                let region: [[Option<Arc<Chunk>>; 3]; 3] = std::array::from_fn(|dz| {
-                    std::array::from_fn(|dx| Some(at(x + dx as i32 - 1, z + dz as i32 - 1)))
-                });
-                let borrowed = horizon_client::mesher::borrow(&region);
-                for sy in 0..SECTIONS as i32 {
-                    let mesh = mesher.mesh(&borrowed, sy);
-                    quads += (mesh.solid.len() + mesh.translucent.len()) / 4;
-                    jobs += 1;
-                }
-            }
-        }
-        best = best.min(started.elapsed().as_secs_f64() / f64::from(jobs));
-    }
-    println!(
-        "mesh: {:.1} us per section ({} quads total)",
-        best * 1e6,
-        quads
-    );
-
-    // Random lookups, as collision and entity queries do.
-    let mut state = 0x9E37_79B9_7F4A_7C15u64;
-    let started = Instant::now();
-    let mut sum = 0u64;
-    let lookups = 20_000_000u64;
-    for _ in 0..lookups {
-        state ^= state << 13;
-        state ^= state >> 7;
-        state ^= state << 17;
-        let cx = 2 + (state % u64::from((inner - 2) as u32)) as i32;
-        let cz = 2 + ((state >> 8) % u64::from((inner - 2) as u32)) as i32;
-        let chunk = &chunks[((cz - 1) * inner + cx - 1) as usize];
-        let (x, y, z) = (
-            (state >> 16) as i32 & 15,
-            MIN_Y + ((state >> 24) % 384) as i32,
-            (state >> 40) as i32 & 15,
-        );
-        sum += u64::from(chunk.get(x, y, z));
-    }
-    println!(
-        "random get: {:.2} ns per lookup (checksum {sum})",
-        started.elapsed().as_secs_f64() * 1e9 / lookups as f64
-    );
-    // Coherent scan, as a column or area query does.
-    let started = Instant::now();
-    let mut sum = 0u64;
-    for _ in 0..4 {
-        for chunk in &chunks {
-            for y in MIN_Y..MIN_Y + 384 {
-                for z in 0..16 {
-                    for x in 0..16 {
-                        sum += u64::from(chunk.get(x, y, z));
-                    }
-                }
-            }
-        }
-    }
-    println!(
-        "scan get: {:.2} ns per lookup (checksum {sum})",
-        started.elapsed().as_secs_f64() * 1e9 / (4.0 * chunks.len() as f64 * 98304.0)
-    );
-    Ok(())
-}
@@ -1,140 +0,0 @@
-//! Isolated production mob-model builder benchmark; no assets, Game, GPU or full-frame work.
-//! CARGO_TARGET_DIR=/home/bob/Documents/horizon/target CARGO_INCREMENTAL=0 \
-//! cargo run --profile fast -p horizon-client --example entity_geometry_bench
-use horizon_client::{
-    mesher::Vertex,
-    mobs::{Part, Polygon, anim::Poses, render},
-};
-use std::{hint::black_box, time::Instant};
-
-fn cube(name: String, position: f32) -> Part {
-    let polygons = (0..6)
-        .map(|face| {
-            let axis = face / 2;
-            let side = (face % 2) as f32;
-            let mut normal = [0.0; 3];
-            normal[axis] = side * 2.0 - 1.0;
-            Polygon {
-                normal,
-                vertices: [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]].map(|uv| {
-                    let mut vertex = [0.0; 5];
-                    vertex[axis] = side * 8.0;
-                    vertex[(axis + 1) % 3] = uv[0] * 8.0;
-                    vertex[(axis + 2) % 3] = uv[1] * 8.0;
-                    vertex[3] = uv[0];
-                    vertex[4] = uv[1];
-                    vertex
-                }),
-            }
-        })
-        .collect();
-    Part {
-        name,
-        pose: [position, 0.0, 0.0, 0.1, 0.2, 0.0, 1.0, 1.0, 1.0],
-        polygons,
-        children: Vec::new(),
-    }
-}
-
-fn build(model: &Part, poses: &Poses, count: usize, out: &mut Vec<Vertex>) {
-    for i in 0..count {
-        render::draw(
-            black_box(model),
-            glam::Mat4::from_translation(glam::Vec3::new((i % 32) as f32, 0.0, (i / 32) as f32)),
-            black_box(poses),
-            [0.125, 0.25, 0.5, 0.75],
-            0xffc0_d0e0,
-            0xf0f0,
-            0,
-            out,
-        );
-    }
-    black_box(out.as_slice());
-}
-
-fn measure(model: &Part, poses: &Poses, count: usize, iterations: usize, reuse: bool) -> f64 {
-    let mut retained = Vec::new();
-    build(model, poses, count, &mut retained); // Untimed warmup.
-    let start = Instant::now();
-    for _ in 0..iterations {
-        let mut out = if reuse {
-            std::mem::take(&mut retained)
-        } else {
-            Vec::new()
-        };
-        out.clear();
-        build(model, poses, count, &mut out);
-        if reuse {
-            retained = out;
-        }
-    }
-    start.elapsed().as_secs_f64() * 1e6 / iterations as f64
-}
-
-fn main() {
-    let mut model = cube("body".into(), 0.0);
-    model.children = (1..6).map(|i| cube(format!("part{i}"), i as f32)).collect();
-    let poses = Poses::new(&model);
-    for count in [32, 256, 1024, 4096, 8192] {
-        let mut expected = Vec::new();
-        build(&model, &poses, count, &mut expected);
-        let mut retained = Vec::new();
-        build(&model, &poses, count, &mut retained);
-        let (pointer, capacity) = (retained.as_ptr(), retained.capacity());
-        // Populated -> empty/reset -> smaller -> populated must never leave stale vertices.
-        for n in [0, count / 2, count, count] {
-            retained.clear();
-            build(&model, &poses, n, &mut retained);
-            let mut fresh = Vec::new();
-            build(&model, &poses, n, &mut fresh);
-            assert_eq!(
-                bytemuck::cast_slice::<Vertex, u8>(&retained),
-                bytemuck::cast_slice::<Vertex, u8>(&fresh)
-            );
-            assert_eq!(
-                (retained.as_ptr(), retained.capacity()),
-                (pointer, capacity)
-            );
-        }
-        assert_eq!(
-            bytemuck::cast_slice::<Vertex, u8>(&retained),
-            bytemuck::cast_slice::<Vertex, u8>(&expected)
-        );
-        let iterations = (100_000 / count).clamp(40, 1000);
-        let mut fresh = Vec::new();
-        let mut reused = Vec::new();
-        let mut paired_speedups = Vec::new();
-        // Alternate order, reporting medians over eleven warmed batches.
-        for batch in 0..11 {
-            let mut pair = [0.0; 2];
-            for reuse in if batch % 2 == 0 {
-                [false, true]
-            } else {
-                [true, false]
-            } {
-                let time = measure(&model, &poses, count, iterations, reuse);
-                pair[usize::from(reuse)] = time;
-                if reuse {
-                    reused.push(time);
-                } else {
-                    fresh.push(time);
-                }
-            }
-            paired_speedups.push(pair[0] / pair[1]);
-        }
-        paired_speedups.sort_by(f64::total_cmp);
-        fresh.sort_by(f64::total_cmp);
-        reused.sort_by(f64::total_cmp);
-        println!(
-            "entities={count} vertices={} capacity={capacity} retained_bytes={} fresh_us={:.3} reused_us={:.3} speedup={:.3}x paired_speedup_median={:.3}x paired_speedup_range={:.3}..{:.3}x iterations={iterations} batches=11 byte_equivalence=pass pointer_capacity_reuse=pass",
-            retained.len(),
-            capacity * size_of::<Vertex>(),
-            fresh[5],
-            reused[5],
-            fresh[5] / reused[5],
-            paired_speedups[5],
-            paired_speedups[0],
-            paired_speedups[10]
-        );
-    }
-}
@@ -1,205 +0,0 @@
-//! Compare the exact read/deserialize sequences used by the model loaders.
-//! Run with `cargo run -p horizon-client --profile fast --example json_readers_bench`.
-//! Optional arguments: resource directory, repetitions (default 9).
-use serde_json::{Map, Value, json};
-use std::{
-    collections::BTreeMap,
-    fmt::Debug,
-    fs::{self, File},
-    hint::black_box,
-    io::BufReader,
-    path::{Path, PathBuf},
-    time::Instant,
-};
-
-type Result<T> = horizon_client::Result<T>;
-
-#[derive(Clone, Copy)]
-enum Reader {
-    File,
-    Buffered,
-    Slice,
-}
-const READERS: [Reader; 3] = [Reader::File, Reader::Buffered, Reader::Slice];
-
-// These match the map types and reader expressions at all three production sites.
-macro_rules! reader {
-    ($name:ident, $map:ty) => {
-        fn $name(path: &Path, reader: Reader) -> Result<$map> {
-            Ok(match reader {
-                Reader::File => serde_json::from_reader(File::open(path)?)?,
-                Reader::Buffered => serde_json::from_reader(BufReader::new(File::open(path)?))?,
-                Reader::Slice => serde_json::from_slice(&fs::read(path)?)?,
-            })
-        }
-    };
-}
-reader!(prepare_facts, Map<String, Value>);
-reader!(catalog_facts, BTreeMap<String, Value>);
-
-struct Fixture(PathBuf);
-impl Fixture {
-    fn new() -> Result<Self> {
-        let root =
-            std::env::temp_dir().join(format!("horizon-json-readers-{}", std::process::id()));
-        fs::create_dir(&root)?;
-        Ok(Self(root))
-    }
-}
-impl Drop for Fixture {
-    fn drop(&mut self) {
-        let _ = fs::remove_dir_all(&self.0);
-    }
-}
-
-fn fixtures(root: &Path) -> Result<()> {
-    let states: Vec<_> = (0..56)
-        .map(|i| {
-            json!({"facing": (["north", "east", "south", "west"][i % 4]),
-                "powered": if i / 4 % 2 == 0 { "false" } else { "true" },
-                "age": (i / 8).to_string()})
-        })
-        .collect();
-    let mut models = Map::new();
-    let mut render = Map::new();
-    for i in 0..1024 {
-        let name = format!("minecraft:fixture_block_{i:04}");
-        models.insert(
-            name.clone(),
-            json!({
-                "schema": {"facing": {"named": ["north", "east", "south", "west"]},
-                    "powered": {"named": ["false", "true"]}, "age": {"integer": [0, 6]}},
-                "states": states
-            }),
-        );
-        render.insert(
-            name,
-            json!({"rule": "never", "can_occlude": true, "bars_tag": false}),
-        );
-    }
-    fs::write(root.join("model-states.json"), serde_json::to_vec(&models)?)?;
-    fs::write(
-        root.join("render-definitions.json"),
-        serde_json::to_vec(&render)?,
-    )?;
-    Ok(())
-}
-
-fn benchmark<T: PartialEq + Debug>(
-    label: &str,
-    path: &Path,
-    repetitions: usize,
-    read: impl Fn(&Path, Reader) -> Result<T>,
-) -> Result<()> {
-    let expected = read(path, Reader::File)?;
-    for reader in READERS {
-        assert_eq!(expected, read(path, reader)?);
-        for _ in 0..2 {
-            black_box(read(black_box(path), reader)?);
-        }
-    }
-    drop(expected);
-    let mut samples: [Vec<f64>; 3] = std::array::from_fn(|_| Vec::new());
-    for repetition in 0..repetitions {
-        // Rotate reader order to distribute drift across implementations.
-        for offset in 0..3 {
-            let index = (repetition + offset) % 3;
-            let start = Instant::now();
-            let value = black_box(read(black_box(path), READERS[index])?);
-            samples[index].push(start.elapsed().as_secs_f64() * 1000.0);
-            drop(value); // Match the loaders: retain the parsed tree after loading.
-        }
-    }
-    let median: Vec<_> = samples
-        .iter_mut()
-        .map(|s| {
-            s.sort_by(f64::total_cmp);
-            s[s.len() / 2]
-        })
-        .collect();
-    println!(
-        "{label}: {} bytes, {repetitions} samples/reader, median ms: File={:.3}, BufReader={:.3}, read+slice={:.3}; slice speedup={:.2}x",
-        fs::metadata(path)?.len(),
-        median[0],
-        median[1],
-        median[2],
-        median[0] / median[2]
-    );
-    Ok(())
-}
-
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
-    let fixture = if args.is_empty() {
-        Some(Fixture::new()?)
-    } else {
-        None
-    };
-    let root = fixture
-        .as_ref()
-        .map(|f| f.0.clone())
-        .unwrap_or_else(|| PathBuf::from(&args[0]));
-    if fixture.is_some() {
-        fixtures(&root)?;
-        println!(
-            "Generated representative fixtures: 1024 blocks, 57344 model states; warm filesystem cache."
-        );
-    }
-    let repetitions = args.get(1).map(|s| s.parse()).transpose()?.unwrap_or(9);
-    assert!(repetitions > 0, "repetitions must be positive");
-    benchmark(
-        "prepare model states",
-        &root.join("model-states.json"),
-        repetitions,
-        prepare_facts,
-    )?;
-    benchmark(
-        "catalog model states",
-        &root.join("model-states.json"),
-        repetitions,
-        catalog_facts,
-    )?;
-    benchmark(
-        "render definitions",
-        &root.join("render-definitions.json"),
-        repetitions,
-        catalog_facts,
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn reader_equivalence_and_errors() -> Result<()> {
-        let fixture = Fixture::new()?;
-        let path = fixture.0.join("test.json");
-        fs::write(&path, br#"{"minecraft:stone":{"schema":{},"states":[{}]},"unicode":"\u2603","duplicate":1,"duplicate":2}"#)?;
-        let expected = prepare_facts(&path, Reader::File)?;
-        for reader in READERS {
-            assert_eq!(expected, prepare_facts(&path, reader)?);
-            assert_eq!(
-                expected.iter().collect::<BTreeMap<_, _>>(),
-                catalog_facts(&path, reader)?.iter().collect()
-            );
-        }
-        for invalid in [b"{\"a\": ".as_slice(), b"{} trailing", b"{\"a\":\"\xff\"}"] {
-            fs::write(&path, invalid)?;
-            for reader in READERS {
-                let error = prepare_facts(&path, reader).unwrap_err();
-                assert!(error.downcast_ref::<serde_json::Error>().is_some());
-                assert!(catalog_facts(&path, reader).is_err());
-            }
-        }
-        fs::remove_file(&path)?;
-        for reader in READERS {
-            let error = prepare_facts(&path, reader).unwrap_err();
-            assert_eq!(
-                error.downcast_ref::<std::io::Error>().unwrap().kind(),
-                std::io::ErrorKind::NotFound
-            );
-        }
-        Ok(())
-    }
-}
@@ -1,143 +0,0 @@
-//! Serve a small flat world on the LAN server without the game, for joining
-//! with a real client while developing the protocol:
-//! `cargo run --release --example lan_flat -- RESOURCES PORT`.
-use horizon_client::{
-    assets::Assets,
-    blocks::BlockFacts,
-    chunk::{Chunk, MIN_Y},
-    lan::{
-        Lan,
-        chunks::ChunkEncoder,
-        data::SyncData,
-        hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
-    },
-    world::World,
-};
-use horizon_protocol::packets::play::Serverbound as S;
-use std::{path::PathBuf, sync::Arc, time::Duration};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut args = std::env::args().skip(1);
-    let root = PathBuf::from(args.next().ok_or("RESOURCES PORT")?);
-    let port: u16 = args.next().ok_or("port")?.parse()?;
-    let assets = Assets::load(&root)?;
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let state = |name: &str| assets.registry.default_state(name).map_or(0, |s| s.0);
-    let sync = Arc::new(SyncData::load(&root)?);
-    let biomes: Vec<String> = sync
-        .dynamic
-        .registries
-        .get("minecraft:worldgen/biome")
-        .map(|v| v.iter().map(|(n, _)| n.clone()).collect())
-        .unwrap_or_default();
-    let encoder = ChunkEncoder::new(
-        facts
-            .states
-            .iter()
-            .map(|s| (s.name.clone(), s.fluid_level > 0 || s.waterlogged)),
-        &sync.builtin,
-        &biomes,
-        &biomes,
-    );
-    let (stone, dirt, grass) = (
-        state("minecraft:stone"),
-        state("minecraft:dirt"),
-        state("minecraft:grass_block"),
-    );
-    let mut world = World::new(facts.air, 0);
-    for cz in -8..=8 {
-        for cx in -8..=8 {
-            let mut chunk = Chunk::empty(cx, cz);
-            for z in 0..16 {
-                for x in 0..16 {
-                    for y in MIN_Y..60 {
-                        let v = if y == 59 {
-                            grass
-                        } else if y > 55 {
-                            dirt
-                        } else {
-                            stone
-                        };
-                        chunk.set(x, y, z, v);
-                    }
-                }
-            }
-            chunk.lit = true;
-            world.chunks.insert((cx, cz), Arc::new(chunk));
-        }
-    }
-    let lan = Lan::start(sync.clone(), port, "Flat - Example".into(), 8)?;
-    println!("listening on {}", lan.port);
-    let mut hub = Hub::new(
-        lan,
-        sync,
-        encoder,
-        HubConfig {
-            default_game_mode: 1,
-            guest_commands: true,
-            force_game_mode: false,
-            hardcore: false,
-            view_distance: 8,
-            simulation_distance: 8,
-            dimension: "minecraft:overworld".into(),
-            seed: 0,
-            max_players: 8,
-            dedicated: false,
-            integrated: false,
-        },
-    );
-    let mut next_entity = 100u32;
-    let host = HostState {
-        uuid: 42,
-        name: "Host".into(),
-        entity_id: 1,
-        position: [0.5, 60.0, 0.5],
-        yaw: 0.0,
-        pitch: 0.0,
-        head_yaw: 0.0,
-        on_ground: true,
-        game_mode: 1,
-        sneaking: false,
-        sprinting: false,
-        equipment: Default::default(),
-        health: 20.0,
-        attributes: Vec::new(),
-        bed: None,
-        living_flags: 0,
-    };
-    loop {
-        world.game_time += 1;
-        world.day_time += 1;
-        let mut ctx = TickCtx {
-            world: &mut world,
-            host: Some(&host),
-            entities: &[],
-            next_entity: &mut next_entity,
-            spawn: [8.5, 60.0, 8.5],
-            difficulty: 2,
-            difficulty_locked: false,
-            clock_rate: 1.0,
-            tick_rate: 20.0,
-            tick_frozen: false,
-            tick_steps: (0, 0),
-            collision: None,
-        };
-        for event in hub.tick(&mut ctx) {
-            match event {
-                HostEvent::Joined(conn) => hub.place_new_player(conn, &mut ctx),
-                HostEvent::Packet(_, packet) => {
-                    if std::env::var_os("HORIZON_NET_DEBUG").is_some()
-                        && !matches!(*packet, S::ClientTickEnd(_))
-                    {
-                        eprintln!("[lan] {packet:?}");
-                    }
-                }
-                HostEvent::Chat { line, .. } | HostEvent::Warn(line) | HostEvent::Error(line) => {
-                    println!("{line}")
-                }
-                HostEvent::Left(_) => {}
-            }
-        }
-        std::thread::sleep(Duration::from_millis(50));
-    }
-}
@@ -1,153 +0,0 @@
-//! Read-only saved chunk benchmark. All timings exclude resource/corpus setup.
-//!
-//! load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum]
-//! Add --profile-worker when a sampling collector cannot sample the main thread.
-//! Reports warm filesystem SaveDir::load (read, inflate, NBT, decode and light),
-//! plus isolated inflate/NBT and native decode. No files in the save are changed.
-use horizon_client::{
-    assets::Assets,
-    biome::Biomes,
-    blocks::BlockFacts,
-    save::{SaveDir, SaveTables, decode_with},
-};
-use horizon_world::{nbt::Limits, region::RegionFile};
-use sha2::{Digest, Sha256};
-use std::{hint::black_box, path::PathBuf, sync::Arc, time::Instant};
-
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn main() -> Result<()> {
-    if std::env::args().any(|a| a == "--profile-worker") {
-        std::thread::spawn(|| run().map_err(|e| e.to_string()))
-            .join()
-            .expect("benchmark worker")
-            .map_err(Into::into)
-    } else {
-        run()
-    }
-}
-
-fn run() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    let usage = "load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum]";
-    let root = PathBuf::from(args.first().ok_or(usage)?);
-    let dimension = PathBuf::from(args.get(1).ok_or(usage)?);
-    let flag = |name: &str, default: usize| -> Result<usize> {
-        Ok(match args.iter().position(|a| a == name) {
-            Some(i) => args.get(i + 1).ok_or(usage)?.parse()?,
-            None => default,
-        })
-    };
-    let rounds = flag("--rounds", 5)?;
-    let limit = flag("--limit", 256)?;
-    if rounds == 0 || limit == 0 {
-        return Err("rounds and limit must be positive".into());
-    }
-    let assets = Assets::load(&root)?;
-    let facts = BlockFacts::load(&root, assets.registry)?;
-    let biomes = Biomes::load(&root)?;
-    let tables = Arc::new(SaveTables::new(&assets).with_block_entities(&facts));
-    let source = SaveDir::new(dimension.clone());
-    let _ = source.tables.set(tables.clone());
-    let mut paths: Vec<_> = std::fs::read_dir(dimension.join("region"))?
-        .map(|e| e.map(|e| e.path()))
-        .collect::<std::io::Result<_>>()?;
-    paths.retain(|p| p.extension().is_some_and(|e| e == "mca"));
-    paths.sort();
-    let mut corpus = Vec::new();
-    'regions: for path in paths {
-        let mut region = RegionFile::open(path)?;
-        let mut positions: Vec<_> = region.chunks().map(|(pos, _)| pos).collect();
-        positions.sort_by_key(|p| (p.x, p.z));
-        for pos in positions {
-            let record = region.read(pos)?.ok_or("missing record")?;
-            let tag = record.nbt(Limits::default())?;
-            if decode_with(&tag, assets.registry, &biomes, Some(&tables)).is_none() {
-                continue;
-            }
-            corpus.push((pos, record, tag));
-            if corpus.len() == limit {
-                break 'regions;
-            }
-        }
-    }
-    if corpus.is_empty() {
-        return Err("no full chunks in corpus".into());
-    }
-    let mut records_hash = Sha256::new();
-    for (pos, record, _) in &corpus {
-        records_hash.update(pos.x.to_le_bytes());
-        records_hash.update(pos.z.to_le_bytes());
-        records_hash.update((record.compressed.len() as u64).to_le_bytes());
-        records_hash.update(&record.compressed);
-    }
-    println!(
-        "{}",
-        serde_json::json!({"corpus": dimension, "chunks": corpus.len(), "rounds": rounds,
-            "compressed_records_sha256": format!("{:x}", records_hash.finalize()),
-            "compressed_bytes": corpus.iter().map(|(_, r, _)| r.compressed.len()).sum::<usize>()})
-    );
-    // Prime SaveDir's region handles and the filesystem cache before measurement.
-    for (pos, _, _) in &corpus {
-        black_box(
-            source
-                .load(pos.x, pos.z, assets.registry, &biomes)
-                .ok_or("load failed")?,
-        );
-    }
-    for round in 0..rounds {
-        let started = Instant::now();
-        for (pos, _, _) in &corpus {
-            black_box(
-                source
-                    .load(pos.x, pos.z, assets.registry, &biomes)
-                    .ok_or("load failed")?,
-            );
-        }
-        let load_s = started.elapsed().as_secs_f64();
-        let started = Instant::now();
-        for (_, record, _) in &corpus {
-            black_box(record.nbt(Limits::default())?);
-        }
-        let nbt_s = started.elapsed().as_secs_f64();
-        let started = Instant::now();
-        for (_, _, tag) in &corpus {
-            black_box(
-                decode_with(tag, assets.registry, &biomes, Some(&tables)).ok_or("decode failed")?,
-            );
-        }
-        let decode_s = started.elapsed().as_secs_f64();
-        println!(
-            "{}",
-            serde_json::json!({"round": round, "load_s": load_s,
-            "inflate_nbt_s": nbt_s, "decode_s": decode_s})
-        );
-    }
-    if args.iter().any(|a| a == "--checksum") {
-        let mut hash = Sha256::new();
-        let mut light_loaded = 0;
-        for (pos, _, _) in &corpus {
-            let chunk = source
-                .load(pos.x, pos.z, assets.registry, &biomes)
-                .ok_or("load failed")?;
-            hash.update(pos.x.to_le_bytes());
-            hash.update(pos.z.to_le_bytes());
-            light_loaded += usize::from(chunk.light_loaded);
-            for section in &chunk.sections {
-                for i in 0..4096 {
-                    hash.update(section.get(i).to_le_bytes());
-                    hash.update([section.light(i)]);
-                }
-                for i in 0..64 {
-                    hash.update(section.biomes.get(i).to_le_bytes());
-                }
-            }
-        }
-        println!(
-            "{}",
-            serde_json::json!({"blocks_biomes_light_sha256": format!("{:x}", hash.finalize()),
-            "light_loaded": light_loaded})
-        );
-    }
-    Ok(())
-}
@@ -1,8 +1,7 @@
 //! Replays `tools/test_ambient_sound_parity.py` scripts through Horizon's
 //! ambient sound handlers over its `SoundEngine`:
 //! `ambient_fixture ROOT INPUT OUTPUT`.
-#[path = "audio_common/mod.rs"]
-mod common;
+use crate::audio_common as common;
 use common::{Fake, d, f, flush};
 use horizon_client::ambience::{Ambience, AmbientContext, AmbientSounds, Mood, bubble_column_in};
 use horizon_client::sound_engine::{Bound, SoundEngine, TickContext, Ticking};
@@ -47,8 +46,8 @@ fn sounds(a: &[&str]) -> AmbientSounds {
    }
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1])));
    engine.listening = true;
    let mut backend = Fake::default();
@@ -50,8 +50,8 @@ fn particle(k: ArrowParticle) -> &'static str {
        ArrowParticle::Splash => "splash",
    }
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err("usage: arrow_probe RESOURCES FIXTURE_DIRECTORY --describe|REFERENCE".into());
    }
@@ -18,8 +18,8 @@ fn music(m: Option<&Music>) -> String {
    })
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let root = std::path::Path::new(&args[1]);
    let tables = MusicTables::load(root);
    let ambient = AmbientTables::load(root);
@@ -24,8 +24,8 @@ fn db(v: &Value) -> f64 {
    f64::from_bits(u64::from_str_radix(v.as_str().unwrap(), 16).unwrap())
 }

-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let [root, input, output, scene_json] = &args[..] else {
        return Err("usage: auto_jump_probe RESOURCES INPUT OUTPUT SCENE_JSON".into());
    };
@@ -118,8 +118,8 @@ fn status(s: ShulkerStatus) -> &'static str {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: block_entity_anim_fixture RESOURCES INPUTS OUTPUT".into());
    };
@@ -110,8 +110,8 @@ fn intern(s: &str) -> &'static str {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, textures, output] = args.as_slice() else {
        return Err("usage: block_entity_render_fixture RESOURCES INPUTS TEXTURES OUTPUT".into());
    };
@@ -26,8 +26,8 @@ fn entity(name: &str) -> BlockEntity {
        .unwrap_or_else(|| panic!("no block entity for {name}"))
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let input = std::fs::read_to_string(&args[1]).expect("input");
    let mut out = String::new();
    let mut entities = BlockEntities::default();
@@ -8,8 +8,8 @@ use std::{
    io::{BufRead, BufReader, BufWriter, Write},
    path::Path,
 };
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let root = Path::new(&args[1]);
    let assets = Assets::load(root)?;
    let render = assets.reload(root)?;
@@ -51,8 +51,8 @@ impl Around for Column {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: block_transform_fixture RESOURCES INPUT OUTPUT")?,
@@ -16,8 +16,8 @@ use std::{
 };
 /// The stage sprite origin the cracks carry (the oracle compares the geometry and UVs only).
 const STAGE: [f32; 2] = [0.25, 0.5];
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let root = Path::new(&args[1]);
    let assets = Assets::load(root)?;
    let render = assets.reload(root)?;
@@ -323,8 +323,8 @@ fn avatar(c: &Value, out: &mut impl Write) -> Result<()> {
    Ok(())
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -70,8 +70,8 @@ fn describe(state: &BlockState) -> String {
    format!("{}|{}", state.name, props.join(","))
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: cauldron_fixture RESOURCES INPUT OUTPUT")?,
@@ -5,6 +5,7 @@
 //! the oracle's JSON form.
 //!
 //! usage: chat_screen_fixture RESOURCES REGISTRIES CASES OUTPUT
+use crate::pack_screen_fixture;
 use horizon_client::{
    chat::{ChatAction, ChatScreen, Commands},
    command::vanilla,
@@ -15,14 +16,11 @@ use horizon_client::{
 use serde_json::{Value, json};
 use std::{fmt::Write as _, fs, path::PathBuf};
 use winit::keyboard::KeyCode as K;
-#[path = "pack_screen_fixture.rs"]
-#[allow(dead_code)]
-mod pack_screen_fixture;
 #[path = "chat_screen_fixture/registries.rs"]
 mod registries;

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, registries, inputs, output] = args.as_slice() else {
        return Err("usage: chat_screen_fixture RESOURCES REGISTRIES CASES OUTPUT".into());
    };
@@ -1,8 +1,8 @@
 //! CloudRenderer face selection and mesh traversal, without a GPU.
 use horizon_client::clouds;
 use std::{fmt::Write, fs};
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let mut output = String::new();
    for (case, line) in fs::read_to_string(&args[1])?.lines().enumerate() {
        let values: Vec<i32> = line
@@ -132,8 +132,8 @@ fn tree(d: &Dispatcher, node: usize) -> Value {
    v
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    if args.get(1).map(String::as_str) == Some("tree") {
        let d = &vanilla::registered(false);
        let mut v = tree(d, 0);
@@ -24,8 +24,8 @@ fn input_name(input: Input) -> &'static str {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -11,8 +11,8 @@ use horizon_client::{
 use serde_json::{Value, json};
 use std::{fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: creative_search_fixture RESOURCES CREATIVE_JSON VANILLA_JSON OUTPUT";
    let names = Names::load(Path::new(args.get(1).ok_or(usage)?));
    let creative = Creative::from_json(&serde_json::from_slice(&fs::read(
@@ -0,0 +1,49 @@
+//! How the probe binary runs a probe. main.rs lists the probes and nothing else (tools/parity.py leaves it out of
+//! the harnesses' dependencies); code every probe relies on goes here.
+use std::process::ExitCode;
+
+/// `probes! { a, b, }` declares the binary's `main`, which runs the probe module named by its first argument.
+macro_rules! probes {
+    ($($name:ident,)*) => {
+        fn run(name: &str) -> Option<std::process::ExitCode> {
+            use std::process::Termination;
+            Some(match name {
+                $(stringify!($name) => $name::main().report(),)*
+                _ => return None,
+            })
+        }
+
+        fn main() -> std::process::ExitCode {
+            dispatch::main(&[$(stringify!($name)),*], run)
+        }
+    };
+}
+
+/// The probe's command line as its own example saw it: the program, then the arguments after the probe's name.
+pub fn args() -> std::vec::IntoIter<String> {
+    let mut args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        args.remove(1);
+    }
+    args.into_iter()
+}
+
+/// args(), as OsStrings.
+pub fn args_os() -> std::vec::IntoIter<std::ffi::OsString> {
+    let mut args: Vec<_> = std::env::args_os().collect();
+    if args.len() > 1 {
+        args.remove(1);
+    }
+    args.into_iter()
+}
+
+pub fn main(names: &[&str], run: fn(&str) -> Option<ExitCode>) -> ExitCode {
+    let name = std::env::args().nth(1).unwrap_or_default();
+    run(&name).unwrap_or_else(|| {
+        eprintln!(
+            "usage: probe <name> [arguments...]\nprobes: {}",
+            names.join(" ")
+        );
+        ExitCode::from(2)
+    })
+}
@@ -14,8 +14,8 @@ fn d(v: f64) -> String {
    format!("{:016x}", v.to_bits())
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in BufReader::new(File::open(&args[1])?).lines().enumerate() {
        let c: Value = serde_json::from_str(&line?)?;
@@ -10,8 +10,8 @@ use horizon_client::{
 };
 use std::{fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: enchanting_fixture RESOURCES INPUT OUTPUT")?,
@@ -3,7 +3,7 @@
 //! posed model with `mobs::render::draw` under the case's living-entity root
 //! transform and writes each drawn part's packed vertex normals.
 //!
-//! cargo run --profile fast -p horizon-client --example entity_anim_fixture -- \
+//! cargo run --profile fast -p horizon-client --example probe -- entity_anim_fixture \
 //!     RESOURCES VANILLA.jsonl OUT.jsonl
 use horizon_client::mesher::Vertex;
 use horizon_client::mobs::{
@@ -288,8 +288,8 @@ fn entity_state(mob: &mut Mob, species: Species, case: &Value) {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    let root = PathBuf::from(&args[0]);
    let types = MobTypes::load(&root)?;
    let animations = MobData::load_animations(&root);
@@ -61,8 +61,8 @@ fn species(id: &str) -> Species {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -53,8 +53,8 @@ fn line(s: &LootStack) -> String {
    out
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: entity_death_loot_fixture RESOURCES INPUT OUTPUT")?,
@@ -13,8 +13,8 @@ fn d(v: f64) -> String {
    format!("{:016x}", v.to_bits())
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in BufReader::new(File::open(&args[1])?).lines().enumerate() {
        let c: Value = serde_json::from_str(&line?)?;
@@ -9,8 +9,8 @@ use horizon_client::{
 };
 use std::{collections::HashMap, fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: environment_fixture RESOURCES INPUT OUTPUT")?,
@@ -388,8 +388,8 @@ fn describe(m: &Mob, all: &[Mob], regs: &SpawnRegistries) -> String {
    t.join(" ")
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: finalize_spawn_fixture RESOURCES INPUT OUTPUT HALLOWEEN")?,
@@ -11,8 +11,8 @@ use std::{
    io::{BufRead, BufReader, BufWriter, Write},
 };

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for line in input.lines() {
@@ -4,8 +4,8 @@
 use horizon_client::{enchant::Enchantments, item_data::parse_stack, item_tooltip::firework_lines};
 use std::{error::Error, fmt::Write, path::PathBuf};

-fn main() -> Result<(), Box<dyn Error>> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = crate::args().collect();
    let input = std::fs::read_to_string(&args[1])?;
    let root = input
        .lines()
@@ -458,8 +458,8 @@ impl HandWorld for ResetWorld<'_, '_> {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -50,8 +50,8 @@ impl LimiterClock for Script {
    }
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -291,8 +291,8 @@ fn key(c: &Value, out: &mut impl Write) -> Result<()> {
    Ok(())
 }

-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let mut out = BufWriter::new(File::create(&args[1])?);
    for line in BufReader::new(File::open(&args[0])?).lines() {
        let c: Value = serde_json::from_str(&line?)?;
@@ -13,8 +13,8 @@ use horizon_client::{
 use serde_json::Value;
 use std::{fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: ghost_recipe_fixture RESOURCES CASES OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -2,7 +2,7 @@
 use horizon_client::command::args::GameMode;
 use horizon_client::items::{ItemStack, take_held_drop};

-fn main() {
+pub fn main() {
    for mode in [
        GameMode::Survival,
        GameMode::Creative,
@@ -10,8 +10,8 @@ use serde_json::Value;
 use std::path::Path;
 use std::{fmt::Write as _, fs};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: hotbar_fixture RESOURCES CASES OUTPUT";
    let items = Items::catalog(Path::new(args.first().and(args.get(1)).ok_or(usage)?))?;
    let known = |id: &str| items.get(id).is_some();
@@ -20,8 +20,8 @@ type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 #[path = "hud_fixture/kinds.rs"]
 mod kinds;

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: hud_fixture RESOURCES INPUTS OUTPUT".into());
    };
@@ -306,6 +306,7 @@ fn chat(c: &Value, h: i32, atlas: &HudAtlas) -> Vec<GuiDraw> {
        height_focused: option("chatHeightFocused"),
        height_unfocused: option("chatHeightUnfocused"),
        line_spacing: option("chatLineSpacing"),
+        colors: c["chatColors"].as_bool().unwrap_or(true),
    };
    for m in c["messages"].as_array().into_iter().flatten() {
        // GuiMessageTag indicator colours: systemSinglePlayer and chatError.
@@ -11,8 +11,8 @@ fn number(v: &Value) -> f32 {
 fn bits(v: f32) -> u32 {
    if v.is_nan() { 0x7fc00000 } else { v.to_bits() }
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let mut out = BufWriter::new(File::create(&args[1])?);
    for line in BufReader::new(File::open(&args[0])?).lines() {
        let f: Value = serde_json::from_str(&line?)?;
@@ -82,8 +82,8 @@ impl TargetUseWorld for World {
    }
 }

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let input = std::io::BufReader::new(std::fs::File::open(&args[1])?);
    let mut out = std::io::BufWriter::new(std::fs::File::create(&args[2])?);
    for (i, line) in input.lines().enumerate() {
@@ -14,8 +14,8 @@ fn unhex(s: &str) -> Vec<u8> {
        .collect()
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let cases = std::fs::read_to_string(&args[1]).unwrap();
    let mut out = String::new();
    let mut games: Vec<LanGame> = Vec::new();
@@ -2,7 +2,7 @@
 //! server with Horizon's light engine and compare every SkyLight/BlockLight
 //! value with the arrays vanilla stored.
 //!
-//! cargo run --profile fast -p horizon-client --example light_parity -- \
+//! cargo run --profile fast -p horizon-client --example probe -- light_parity \
 //!     RESOURCES DIMENSION_DIR [--nether] [--chunks X0 Z0 X1 Z1]
 use horizon_client::{
    assets::Assets,
@@ -21,8 +21,8 @@ use std::{collections::HashMap, path::PathBuf};

 type Arrays = HashMap<i32, (Option<Vec<u8>>, Option<Vec<u8>>)>;

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    let root = PathBuf::from(
        args.first()
            .ok_or("usage: light_parity RESOURCES DIMENSION_DIR")?,
@@ -0,0 +1,178 @@
+//! Every horizon-client parity probe in one binary: `probe <name> [arguments]` runs `<name>.rs` as its own
+//! example did (tools/test_*_parity.py, tools/oracle_harness.py, tools/audio_harness.py). Linking ~80 examples,
+//! each with the whole client in it, was most of the parity job's probe build; one binary builds it once.
+//!
+//! This file only lists the probes, so that adding one reruns no harness: tools/parity.py leaves it out of
+//! their dependencies. How a probe runs is in dispatch.rs.
+#[macro_use]
+mod dispatch;
+
+use dispatch::{args, args_os};
+
+mod ambient_fixture;
+mod arrow_probe;
+mod audio_attributes_fixture;
+/// Sound-engine fakes the audio probes share.
+mod audio_common;
+mod auto_jump_probe;
+mod block_entity_anim_fixture;
+mod block_entity_render_fixture;
+mod block_entity_tickers_fixture;
+mod block_particles_fixture;
+mod block_transform_fixture;
+mod breaking_fixture;
+mod camera_probe;
+mod cauldron_fixture;
+mod chat_screen_fixture;
+mod cloud_fixture;
+mod command_parse_fixture;
+mod container_screen_probe;
+mod creative_search_fixture;
+mod emitter_particles_probe;
+mod enchanting_fixture;
+mod entity_anim_fixture;
+mod entity_components_probe;
+mod entity_death_loot_fixture;
+mod entity_particles_probe;
+mod environment_fixture;
+mod finalize_spawn_fixture;
+mod fire_starter_sound_probe;
+mod firework_tooltip_fixture;
+mod first_person_probe;
+mod frame_limiter_probe;
+mod game_loop_probe;
+mod ghost_recipe_fixture;
+mod held_drop_fixture;
+mod hotbar_fixture;
+mod hud_fixture;
+mod input_probe;
+mod interaction_input_fixture;
+mod lan_probe;
+mod light_parity;
+mod marker_particles_probe;
+mod menu_fixture;
+mod mipmap_probe;
+mod mob_ai_probe;
+mod mob_attributes_fixture;
+mod music_fixture;
+mod natural_spawn_fixture;
+mod options_probe;
+mod pack_resources_fixture;
+mod pack_screen_fixture;
+mod pack_selection_fixture;
+mod particle_providers_probe;
+mod pick_block_data_fixture;
+mod place_recipe_fixture;
+mod player_sync_fixture;
+mod raid_fixture;
+mod random_tick_sections_probe;
+mod recipe_book_fixture;
+mod recipe_book_render_fixture;
+mod recipe_book_view_fixture;
+mod recipe_fixture;
+mod scene_collision_probe;
+mod scene_motion_probe;
+mod scoreboard_fixture;
+mod screen_layout_fixture;
+mod section_mesh_fixture;
+mod server_files_probe;
+mod situational_music_fixture;
+mod skin_image_fixture;
+mod sound_engine_fixture;
+mod sound_event_fixture;
+mod spawn_rules_fixture;
+mod sprint_probe;
+mod subtitle_fixture;
+mod tab_list_fixture;
+mod team_rules_fixture;
+mod toggle_keys_probe;
+mod tooltip_display_fixture;
+mod trading_fixture;
+mod translucency_fixture;
+mod weather_fixture;
+mod world_border_render_fixture;
+mod world_options_fixture;
+
+probes! {
+    ambient_fixture,
+    arrow_probe,
+    audio_attributes_fixture,
+    auto_jump_probe,
+    block_entity_anim_fixture,
+    block_entity_render_fixture,
+    block_entity_tickers_fixture,
+    block_particles_fixture,
+    block_transform_fixture,
+    breaking_fixture,
+    camera_probe,
+    cauldron_fixture,
+    chat_screen_fixture,
+    cloud_fixture,
+    command_parse_fixture,
+    container_screen_probe,
+    creative_search_fixture,
+    emitter_particles_probe,
+    enchanting_fixture,
+    entity_anim_fixture,
+    entity_components_probe,
+    entity_death_loot_fixture,
+    entity_particles_probe,
+    environment_fixture,
+    finalize_spawn_fixture,
+    fire_starter_sound_probe,
+    firework_tooltip_fixture,
+    first_person_probe,
+    frame_limiter_probe,
+    game_loop_probe,
+    ghost_recipe_fixture,
+    held_drop_fixture,
+    hotbar_fixture,
+    hud_fixture,
+    input_probe,
+    interaction_input_fixture,
+    lan_probe,
+    light_parity,
+    marker_particles_probe,
+    menu_fixture,
+    mipmap_probe,
+    mob_ai_probe,
+    mob_attributes_fixture,
+    music_fixture,
+    natural_spawn_fixture,
+    options_probe,
+    pack_resources_fixture,
+    pack_screen_fixture,
+    pack_selection_fixture,
+    particle_providers_probe,
+    pick_block_data_fixture,
+    place_recipe_fixture,
+    player_sync_fixture,
+    raid_fixture,
+    random_tick_sections_probe,
+    recipe_book_fixture,
+    recipe_book_render_fixture,
+    recipe_book_view_fixture,
+    recipe_fixture,
+    scene_collision_probe,
+    scene_motion_probe,
+    scoreboard_fixture,
+    screen_layout_fixture,
+    section_mesh_fixture,
+    server_files_probe,
+    situational_music_fixture,
+    skin_image_fixture,
+    sound_engine_fixture,
+    sound_event_fixture,
+    spawn_rules_fixture,
+    sprint_probe,
+    subtitle_fixture,
+    tab_list_fixture,
+    team_rules_fixture,
+    toggle_keys_probe,
+    tooltip_display_fixture,
+    trading_fixture,
+    translucency_fixture,
+    weather_fixture,
+    world_border_render_fixture,
+    world_options_fixture,
+}
@@ -22,8 +22,8 @@ use std::{
    sync::Arc,
 };

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(".local/horizon-client/26.3");
    let assets = Assets::load(root)?;
    let facts = BlockFacts::load(root, assets.registry)?;
@@ -58,11 +58,12 @@ fn state(menu: &Menu) -> String {
        .map(|(slot, stack)| format!("{slot}:{}", canon_stack(stack.as_ref())))
        .collect();
    let line = format!(
-        "{} | {} |{data} | {} | {}",
+        "{} | {} |{data} | {} | {} | {}",
        slots.join(" "),
        canon_stack(menu.carried.as_ref()),
        menu.drops.join(";"),
-        equipped.join(";")
+        equipped.join(";"),
+        menu.player_sounds.join(";")
    );
    if menu.kind() != Kind::Lectern {
        return line;
@@ -74,8 +75,8 @@ fn state(menu: &Menu) -> String {
    format!("{line} | inv{items}")
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: menu_fixture RESOURCES INPUT OUTPUT")?,
@@ -171,6 +172,7 @@ fn main() -> horizon_client::Result<()> {
        });
        menu.drops.clear();
        menu.equipped.clear();
+        menu.player_sounds.clear();
        out += &format!("init {}\n", state(&menu));
        for op in case["ops"].as_array().ok_or("ops")? {
            let slot = op[0].as_i64().unwrap_or(0) as i32;
@@ -4,8 +4,8 @@
 //! rows like VanillaMipmapOracle.
 use std::{fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    let input = fs::read_to_string(&args[0])?;
    let mut lines = input.lines();
    let root = Path::new(lines.next().ok_or("no resources root")?);
@@ -759,8 +759,8 @@ fn villager(m: &Mob) -> String {
    s
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err("usage: mob_ai_probe RESOURCES SCENARIOS OUTPUT".into());
    }
@@ -6,8 +6,8 @@ use horizon_client::mobs::{Mob, MobTypes};
 use horizon_core::geometry::Vec3;
 use std::{fmt::Write as _, fs, path::Path, sync::Arc};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: mob_attributes_fixture RESOURCES OUTPUT")?,
@@ -1,7 +1,6 @@
 //! Replays `tools/test_music_parity.py` scripts through Horizon's
 //! `MusicManager` over its `SoundEngine`: `music_fixture ROOT INPUT OUTPUT`.
-#[path = "audio_common/mod.rs"]
-mod common;
+use crate::audio_common as common;
 use common::{Fake, describe, f, flush};
 use horizon_client::music::{Music, MusicFrequency, MusicManager};
 use horizon_client::sound_engine::{Bound, MUSIC, SoundEngine, TickContext};
@@ -21,8 +20,8 @@ fn music(spec: &str) -> Option<Music> {
    ))
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1])));
    engine.listening = true;
    let mut backend = Fake::default();
@@ -508,8 +508,8 @@ fn yaw_text(entity: &str, v: f32) -> String {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: natural_spawn_fixture RESOURCES INPUT OUTPUT")?,
@@ -7,8 +7,8 @@ use horizon_client::{
 };
 use std::{fs, io::Write};

-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let mut names: Vec<_> = fs::read_dir(&args[0])?
        .map(|e| e.map(|e| e.path()))
        .collect::<std::io::Result<_>>()?;
@@ -30,8 +30,8 @@ fn types(root: &std::path::Path, file: PathBuf, key: &str) -> String {
        })
        .collect()
 }
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let input = fs::read_to_string(&args[1])?;
    let mut lines = input.lines();
    let root: Vec<&str> = lines.next().ok_or("empty input")?.split(' ').collect();
@@ -66,8 +66,8 @@ pub fn encode(draws: &[Draw]) -> Value {
    )
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: pack_screen_fixture RESOURCES CASES OUTPUT".into());
    };
@@ -35,8 +35,8 @@ fn lists(m: &SelectionModel) -> Value {
    json!({"unselected": side(false), "selected": side(true)})
 }

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [inputs, output] = args.as_slice() else {
        return Err("usage: pack_selection_fixture INPUTS OUTPUT".into());
    };
@@ -140,8 +140,8 @@ fn world(assets: &Assets, facts: &BlockFacts, floor: bool, water: bool) -> Resul
    Ok(world)
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = &Path::new(".local/horizon-client").join(horizon_core::VANILLA_VERSION);
    let assets = Assets::load(root)?;
    let facts = BlockFacts::load(root, assets.registry)?;
@@ -78,8 +78,8 @@ fn case(line: &str) -> Option<String> {
    Some(out)
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = fs::read_to_string(
        args.get(1)
            .ok_or("usage: pick_block_data_fixture INPUT OUTPUT")?,
@@ -28,8 +28,8 @@ fn state(menu: &Menu) -> String {
    )
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: place_recipe_fixture RESOURCES CASES ORDERS OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -8,8 +8,8 @@ fn number(value: &Value) -> f64 {
    f64::from_bits(u64::from_str_radix(value.as_str().unwrap(), 16).unwrap())
 }

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let input = std::io::BufReader::new(std::fs::File::open(&args[1])?);
    let mut out = std::io::BufWriter::new(std::fs::File::create(&args[2])?);
    for line in input.lines() {
@@ -459,8 +459,8 @@ fn run_codec(c: &BTreeMap<&str, &str>) -> Result<String, String> {
    Ok(log.join(" ; "))
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: raid_fixture RESOURCES INPUT OUTPUT")?,
@@ -51,8 +51,8 @@ impl LevelAccess for Air {
    fn emit(&mut self, _: LevelEvent) {}
 }

-fn main() -> Result<(), Box<dyn Error>> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = crate::args().collect();
    let input = std::fs::read_to_string(&args[1])?;
    let root = input
        .lines()
@@ -57,8 +57,8 @@ fn compound(tag: &Tag) -> String {
    out
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: recipe_book_fixture RESOURCES CASES OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -30,8 +30,8 @@ fn round(v: f32) -> f32 {
    (v * 1e4).round() / 1e4
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: recipe_book_render_fixture RESOURCES CASES OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -15,8 +15,8 @@ use horizon_client::{
 use serde_json::Value;
 use std::{fmt::Write as _, fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: recipe_book_view_fixture RESOURCES CASES OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -12,8 +12,8 @@ use horizon_client::{
 };
 use std::{fs, path::Path};

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: recipe_fixture RESOURCES INPUT OUTPUT")?,
@@ -28,8 +28,8 @@ fn vector(value: &Value) -> Result<Vec3> {
    };
    Ok(Vec3::new(number(0)?, number(1)?, number(2)?))
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err("usage: scene_collision_probe RESOURCES FIXTURE_DIRECTORY RADIUS".into());
    }
@@ -78,6 +78,7 @@ fn main() -> Result<()> {
        let mut selected = collisions::EntityCollisions {
            blocks: scene,
            entities: &entities,
+            border: None,
        };
        let movement = world_movement::resolve_world_movement(
            &mut selected,
@@ -233,8 +233,8 @@ fn snapshot(out: &mut impl Write, player: &PlayerMotion) -> Result<()> {
    writeln!(out, "events {}", events.join(" | "))?;
    Ok(())
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err(
            "usage: scene_motion_probe RESOURCES FIXTURE_DIRECTORY --describe|REFERENCE".into(),
@@ -370,8 +370,8 @@ fn score_json(sc: &sb::Score) -> Value {
    })
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let registries: Value =
        serde_json::from_str(&fs::read_to_string(&args[1]).expect("registries")).expect("json");
    let list = |k: &str| -> Vec<String> {
@@ -60,8 +60,8 @@ fn draw_json(d: &ScreenDraw) -> Value {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: screen_layout_fixture RESOURCES INPUT OUTPUT";
    let banners = Banners::load(Path::new(args.get(1).ok_or(usage)?));
    let input = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -170,8 +170,8 @@ fn scene(
    }
    Ok(json!({"name": row["name"], "quads": quads}))
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    if args.len() != 3 {
        return Err(
            "usage: section_mesh_fixture RESOURCES (INPUT.jsonl | facts) OUTPUT.jsonl".into(),
@@ -11,8 +11,8 @@ use horizon_client::server::{
 use horizon_protocol::crypto::uuid_string;
 use std::{fmt::Write as _, path::Path};

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut args = std::env::args().skip(1);
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut args = crate::args().skip(1);
    let root = std::path::PathBuf::from(args.next().ok_or("CASES OUTPUT")?);
    let output = args.next().ok_or("OUTPUT")?;
    let mut cases: Vec<_> = std::fs::read_dir(&root)?
@@ -5,8 +5,8 @@ use horizon_client::music::{BackgroundMusic, Music, MusicTables, Situation};
 use horizon_client::sound_events::normalize;
 use std::io::Write;

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let tables = MusicTables::load(std::path::Path::new(&args[1]));
    let input = std::fs::read_to_string(&args[2]).expect("input");
    let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output"));
@@ -9,8 +9,8 @@ use std::{
 };
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [inputs, output] = args.as_slice() else {
        return Err("usage: skin_image_fixture INPUTS OUTPUT".into());
    };
@@ -1,8 +1,7 @@
 //! Replays `tools/test_sound_engine_parity.py` scripts through Horizon's
 //! `SoundEngine` with a backend recording what an OpenAL source would hold:
 //! `sound_engine_fixture ROOT INPUT OUTPUT`.
-#[path = "audio_common/mod.rs"]
-mod common;
+use crate::audio_common as common;
 use common::{Fake, d, describe, f, flush, result_name};
 use horizon_client::sound_engine::{
    Attenuation, Backend, CartSound, InstanceId, SoundEngine, SoundInstance, TickContext,
@@ -12,8 +11,8 @@ use horizon_core::random::LegacyRandom;
 use std::collections::BTreeMap;
 use std::io::Write;

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1])));
    engine.listening = true;
    let mut backend = Fake::default();
@@ -9,8 +9,8 @@ fn bits(v: f32) -> String {
    format!("{:08x}", v.to_bits())
 }

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let registry = SoundRegistry::load(std::path::Path::new(&args[1]));
    let mut engine = SoundEngine::new(registry);
    let input = std::fs::read_to_string(&args[2]).expect("input");
@@ -136,8 +136,8 @@ fn reason(name: &str) -> Reason {
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let root = Path::new(
        args.get(1)
            .ok_or("usage: spawn_rules_fixture RESOURCES INPUT OUTPUT")?,
@@ -20,8 +20,8 @@ fn keys(mask: u64) -> Keys {
        analog: None,
    }
 }
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let mut out = BufWriter::new(File::create(&args[1])?);
    for line in BufReader::new(File::open(&args[0])?).lines() {
        let f: Value = serde_json::from_str(&line?)?;
@@ -21,8 +21,8 @@ fn pose(m: [f32; 6]) -> Value {
    json!(m)
 }

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: subtitle_fixture RESOURCES INPUTS OUTPUT".into());
    };
@@ -53,8 +53,8 @@ fn runs(t: &Text) -> Value {
    out.into_iter().map(|(r, k)| json!([r, k])).collect()
 }

-fn main() -> Result<()> {
-    let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<PathBuf> = crate::args_os().skip(1).map(PathBuf::from).collect();
    let [root, inputs, output] = args.as_slice() else {
        return Err("usage: tab_list_fixture RESOURCES INPUTS OUTPUT".into());
    };
@@ -8,8 +8,8 @@ use horizon_client::scoreboard::{self as sb, CollisionRule, NameView, Scoreboard
 use serde_json::{Value, json};
 use std::{fs, io::Write};

-fn main() {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() {
+    let args: Vec<String> = crate::args().collect();
    let mut out = std::io::BufWriter::new(fs::File::create(&args[2]).expect("output"));
    for line in fs::read_to_string(&args[1]).expect("inputs").lines() {
        let c: Value = serde_json::from_str(line).expect("case");
@@ -11,8 +11,8 @@ use std::{
    io::{BufRead, BufReader, BufWriter, Write},
 };

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let input = BufReader::new(File::open(&args[1])?);
    let mut out = BufWriter::new(File::create(&args[2])?);
    for (n, line) in input.lines().enumerate() {
@@ -3,8 +3,8 @@ use horizon_client::{item_tooltip::TooltipDisplay, items::ItemStack};
 use horizon_world::nbt::Tag;
 use std::{error::Error, fmt::Write};

-fn main() -> Result<(), Box<dyn Error>> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = crate::args().collect();
    let mut output = String::new();
    for line in std::fs::read_to_string(&args[1])?.lines() {
        let fields: Vec<&str> = line.split('\t').collect();
@@ -231,8 +231,8 @@ fn prepare(m: &mut Merchant, gossips: &mut Gossips, kv: &HashMap<String, String>
    }
 }

-fn main() -> horizon_client::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
    let usage = "usage: trading_fixture RESOURCES INPUT VANILLA_OUTPUT OUTPUT";
    let root = Path::new(args.get(1).ok_or(usage)?);
    let input = fs::read_to_string(args.get(2).ok_or(usage)?)?;
@@ -14,8 +14,8 @@ struct Case {
    cameras: Vec<[f64; 3]>,
 }

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().skip(1).collect();
    let [input, output] = args.as_slice() else {
        return Err("usage: translucency_fixture INPUT OUTPUT".into());
    };
@@ -8,8 +8,8 @@ fn bits(value: f32) -> String {
        format!("{:x}", value.to_bits())
    }
 }
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args().collect();
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
    let mut output = String::new();
    let mut parameters = weather::ParameterCache::default();
    for (case, line) in fs::read_to_string(&args[1])?.lines().enumerate() {
@@ -24,8 +24,8 @@ fn doubles(v: &[f64]) -> Value {
    v.iter().map(|f| f.to_bits() as i64).collect()
 }

-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
+pub fn main() -> Result<()> {
+    let args: Vec<String> = crate::args().skip(1).collect();
    let [inputs, output] = args.as_slice() else {
        return Err("usage: world_border_render_fixture INPUTS OUTPUT".into());
    };