Server watchdog: put the server thread's stack in the crash report

ServerWatchdog's report only had the last 50 log lines, so a tick stuck for 60 s on the official server (#15349) never said where. The watchdog now interrupts the server thread with a signal (Linux, Android, Apple) whose handler captures that thread's backtrace, and the report carries it as its stack, as vanilla's report carries the server thread's stack. A thread that does not answer in 5 s, or a system without the signal, is named in the report's details instead. Refs #15349 Co-Authored-By: Claude Opus 5.5 <[email protected]>
Merge pull request #15239 from yahya-nusseibeh/fix/port-pack-panics
2026-11-11 10:31:38 -10:00 · 2026-11-11 19:35:19 +01:00 · 2026-11-11 19:20:37 +01:00 · 2026-11-11 19:20:18 +01:00 · 2026-11-11 19:19:58 +01:00 · 2026-11-11 19:19:38 +01:00
571 changed files with 35029 additions and 5210 deletions
@@ -1,16 +1,16 @@
-# Changes to these files wait for Ludovic's review once branch protection requires code owners' reviews
+# Changes to these files wait for a council member's review (council poll P35, 2026-11-10) once branch protection requires code owners' reviews
 # (tools/ci/protect_pipeline.sh, docs/security.md). They are what builds, signs and ships releases, the code that
 # checks downloads before installing them (backend.rs downloads, installs and updates the launcher itself; links.json
 # says where from; the Cargo.toml files pick the crates that do it), and this file. Everything else merges as soon as
 # `verify` passes.
-/.github/                                @ludovic111
-/tools/ci/                               @ludovic111
-/tools/release_train.py                  @ludovic111
-/crates/horizon-release-sign/            @ludovic111
-/crates/horizon-server/src/update.rs     @ludovic111
-/crates/horizon-server/Cargo.toml        @ludovic111
-/launcher/src/signed.rs                  @ludovic111
-/launcher/src/backend.rs                 @ludovic111
-/launcher/links.json                     @ludovic111
-/launcher/Cargo.toml                     @ludovic111
-/packaging/                              @ludovic111
+/.github/                                @horizon-rust/council
+/tools/ci/                               @horizon-rust/council
+/tools/release_train.py                  @horizon-rust/council
+/crates/horizon-release-sign/            @horizon-rust/council
+/crates/horizon-server/src/update.rs     @horizon-rust/council
+/crates/horizon-server/Cargo.toml        @horizon-rust/council
+/launcher/src/signed.rs                  @horizon-rust/council
+/launcher/src/backend.rs                 @horizon-rust/council
+/launcher/links.json                     @horizon-rust/council
+/launcher/Cargo.toml                     @horizon-rust/council
+/packaging/                              @horizon-rust/council
@@ -32,13 +32,6 @@
 <!-- The vanilla classes and methods this follows (tools/rea_vanilla.py), and the harness that checks it.
     "Horizon-only" for a feature vanilla doesn't have; "none" for tooling or docs. -->

-## Other projects' code
-
-<!-- "none", or for each project you read or copied from: its link at the commit, its license (only MIT,
-     BSD-2-Clause, BSD-3-Clause, Apache-2.0, ISC, zlib, 0BSD, MIT-0, Unlicense or CC0-1.0), and what you took.
-     CONTRIBUTING.md "Only original code". Shader packs: also the sections of docs/cleanroom/shader-packs-spec.md,
-     the documentation pages and the packs you used. -->
-
 ## Self-check

 <!-- Paste the block `python3 tools/pr_ready.py` prints (`--base upstream/main` from a fork). -->
@@ -40,7 +40,7 @@ jobs:
      ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && (vars.SELF_HOSTED_CI == 'all' ||
      github.event_name == 'pull_request' && (endsWith(format('{0}', github.event.pull_request.number), '0') ||
      endsWith(format('{0}', github.event.pull_request.number), '1'))) &&
-      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
+      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-24.04' }}
    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v7
@@ -119,22 +119,22 @@ jobs:
        if: steps.rust.outputs.required != 'false'
        run: |
          cargo +stable fmt --all -- --check
-          cargo +stable clippy --workspace --all-targets -- -D warnings
+          cargo +stable clippy --workspace --all-targets --locked -- -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
+          cargo +stable clippy -p horizon-client --all-targets --locked --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).
-      # cargo test, not nextest: nextest's process per test reloads each binary's shared tables for every test, and on
+      # cargo test --locked, not nextest: nextest's process per test reloads each binary's shared tables for every test, and on
      # these 4-core runners it was no faster (#4978).
      - name: Test Rust core and voxel kernel correctness
        if: steps.rust.outputs.required != 'false'
        run: |
-          cargo +stable test --workspace --lib --bins --tests
+          cargo +stable test --locked --workspace --lib --bins --tests
          # The full content-root tests (#[ignore]d: minutes each on a laptop). The same build as above; they need the
          # prepared vanilla data, so without it they pass at once. Keep the target selection identical to avoid
          # recompiling the workspace with a different dependency graph.
-          cargo +stable test --workspace --lib --bins --tests mod_content::tests:: -- --ignored
-          cargo +stable test --workspace --doc
+          cargo +stable test --locked --workspace --lib --bins --tests mod_content::tests:: -- --ignored
+          cargo +stable test --locked --workspace --doc
  # The launcher is its own workspace (launcher/Cargo.toml), so verify's cargo runs never build it. A pull request that
  # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
  # alone and break it together (#2059 and the registry ratings did, 2026-10-26).
@@ -143,7 +143,7 @@ jobs:
      ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && (vars.SELF_HOSTED_CI == 'all' ||
      github.event_name == 'pull_request' && (endsWith(format('{0}', github.event.pull_request.number), '0') ||
      endsWith(format('{0}', github.event.pull_request.number), '1'))) &&
-      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
+      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-24.04' }}
    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v7
@@ -313,358 +313,8 @@ jobs:
      head: ${{ github.event.pull_request.head.sha }}
      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
      frame_identity: ${{ contains(github.event.pull_request.labels.*.name, 'frame-identity') }}
-  # Horizon never downloads the game. These jobs need a self-hosted Linux runner
-  # (label horizon-game) holding the maintainer's own copy: the official launcher's
-  # game directory in HORIZON_MINECRAFT_DIR and the pinned server jar in
-  # HORIZON_SERVER_JAR. Start them by hand: gh workflow run checks --ref <branch>.
-  vanilla-parity:
-    if: github.event_name == 'workflow_dispatch'
-    runs-on: [self-hosted, linux, horizon-game]
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-python@v7
-        with:
-          python-version: '3.12'
-      - name: Install Rust toolchain
-        run: rustup toolchain install stable --profile minimal
-      - uses: actions/setup-java@v6
-        with:
-          distribution: temurin
-          java-version: '25'
-      - name: Compare Rust foundations with pinned vanilla client and server bytecode
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_rust_parity.py --prepare
-      - name: Check Rust world-data interoperability with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_world_parity.py
-      - name: Compare scheduled ticks and saved tick data with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_tick_parity.py
-      - name: Compare simulation geometry and cached block collision shapes
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: |
-          python tools/test_geometry_parity.py
-          python tools/test_collision_parity.py
-      - name: Compare noise samplers and density kernels with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_noise_parity.py
-      - name: Compare compiled density samplers with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_density_parity.py
-      - name: Compare world-generation JSON codecs with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_worldgen_parity.py
-      - name: Compare heightmap predicates and chunk mutations with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_heightmap_parity.py
-      - name: Compare pre-light chunk status transitions and block writes
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_chunk_stage_parity.py
-      - name: Compare feature placement into resident neighboring chunks
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_feature_region_parity.py
-      - name: Compare nested feature selectors and sequences
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_feature_graph_parity.py
-      - name: Compare named feature holders and placed-feature tags
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_feature_catalog_parity.py
-      - name: Compare configured fill-layer block placement
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_fill_layer_parity.py
-      - name: Compare replacement-rule codecs and evaluation
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_rule_test_parity.py
-      - name: Compare simple-block placement and feature composition
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_simple_block_parity.py
-      - name: Compare block-column sampling and obstruction
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_block_column_parity.py
-      - name: Compare vertical pillars and cap feature placement
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_pillar_parity.py
-      - name: Compare exactly-one-neighbor feature spreading
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_neighbor_spread_parity.py
-      - name: Compare block-pile support and placement
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_block_pile_parity.py
-      - name: Compare disk replacement and postprocessing
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_disk_parity.py
-      - name: Compare block-blob support search and geometry
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_block_blob_parity.py
-      - name: Compare spring placement and fluid tick scheduling
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_spring_parity.py
-      - name: Compare vine attachment priority and placement
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_vines_parity.py
-      - name: Compare underwater magma floor scans and occlusion
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_underwater_magma_parity.py
-      - name: Compare blue-ice seeding and growth attempts
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_blue_ice_parity.py
-      - name: Compare spike geometry and discontinuous roots
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_spike_parity.py
-      - name: Compare End podium construction and destruction requests
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_end_podium_parity.py
-      - name: Rust End gateway parity
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_end_gateway_parity.py
-      - name: Compare bonus chest placement and conditional loot seeding
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_bonus_chest_parity.py
-      - name: Compare recursive chorus generation and connection refreshes
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_chorus_plant_parity.py
-      - name: Compare small speleothem patches and waterlogged points
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_speleothem_parity.py
-      - name: Compare replacement blob search and Manhattan shells
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_replace_blobs_parity.py
-      - name: Compare bamboo stalks, podzol patches and leafy caps
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_bamboo_parity.py
-      - name: Compare Nether delta rims and shifted contents
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_delta_parity.py
-      - name: Compare biome freezing and snow eligibility
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_biome_weather_parity.py
-      - name: Compare frozen top layers and snowy ground updates
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_snow_freeze_parity.py
-      - name: Compare generation-stage tick storage and routing
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_generation_tick_parity.py
-      - name: Compare below-zero upgrade metadata codecs
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_retrogen_data_parity.py
-      - name: Compare below-zero upgrade lifecycle and block transformations
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_retrogen_chunk_parity.py
-      - name: Compare chunk-status metadata, ordering and codecs
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_chunk_status_parity.py
-      - name: Compare proto-chunk block-entity storage and coordinates
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_block_entity_storage_parity.py
-      - name: Compare ordered single-block replacement features
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_replace_block_parity.py
-      - name: Compare scattered ore placement and air-exposure checks
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_scattered_ore_parity.py
-      - name: Compare resident bulk-section access and raw writes
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_bulk_section_parity.py
-      - name: Compare biome feature ordering and cycle detection
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_feature_sort_parity.py
-      - name: Compare world-generation random wrappers and seeding
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_worldgen_random_parity.py
-      - name: Compare biome filtering and top-level feature context
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_biome_placement_parity.py
-      - name: Compare biome decoration feature scheduling and seeding
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_decoration_parity.py
-      - name: Compare decoration against resident biome and terrain sections
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_decoration_region_parity.py
-      - name: Compare block-state provider choices and rotation
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_state_provider_parity.py
-      - name: Compare contained fluids and height queries with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_fluid_parity.py
-      - name: Compare entity obstruction with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_entity_obstruction_parity.py
-      - name: Compare block solidity and replaceability with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_block_properties_parity.py
-      - name: Compare face slicing and block support with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_face_support_parity.py
-      - name: Compare cached block support with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_block_support_parity.py
-      - name: Compare dynamic block support with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_dynamic_support_parity.py
-      - name: Compare moving-piston collision and interpolation with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_piston_shape_parity.py
-      - name: Compare supported block survival rules with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_block_survival_parity.py
-      - name: Compare noise-stage chunk filling with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_terrain_parity.py
-      - name: Compare structure terrain-adaptation density with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_structure_density_parity.py
-      - name: Compare seeded material bands and surface queries with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_material_surface_parity.py
-      - name: Compare material condition codecs and rule evaluation with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_material_condition_parity.py
-      - name: Compare biome temperatures and cache behavior with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_biome_temperature_parity.py
-      - name: Compare badlands and frozen-ocean extensions with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_material_extension_parity.py
-      - name: Compare bundled material-rule libraries with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_material_rule_library_parity.py
-      - name: Compare fixed, checkerboard and End biome sources with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_biome_source_parity.py
-      - name: Compare seeded cave paths and failure state with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_cave_carver_parity.py
-      - name: Compare seeded canyon paths and width factors with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_canyon_carver_parity.py
-      - name: Compare initial block-writing feature algorithms with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_basic_feature_parity.py
-      - name: Compare feature placement chains with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_feature_placement_parity.py
-      - name: Compare feature placement primitives with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_placement_parity.py
-      - name: Compare anchored height providers with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_height_provider_parity.py
-      - name: Compare scalar value providers with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_value_provider_parity.py
-      - name: Compare cave and canyon geometric primitives with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_carving_geometry_parity.py
-      - name: Compare carving-mask traversal and callback mutations with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_carving_mask_parity.py
-      - name: Compare registry-bound biome-source codecs with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_biome_source_codec_parity.py
-      - name: Compare all four biome-source kinds in chunk generation with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_biome_generation_parity.py
-      - name: Compare chunk biome filling and failure state with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_biome_chunk_parity.py
-      - name: Compare biome zoom and seed obfuscation with pinned vanilla
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_biome_zoom_parity.py
-      - name: Compare surface-stage chunks with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_material_stage_parity.py
-      - name: Compare block-state JSON codecs with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_block_state_codec_parity.py
-      - name: Compare vertical anchors with pinned vanilla client and server
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_anchor_parity.py
-      - name: Compare float logarithms at domain and rounding boundaries
-        env:
-          RUSTUP_TOOLCHAIN: stable
-        run: python tools/test_float_log_parity.py
+  # JFR analysis uses JDK-generated fixture recordings on the self-hosted Linux runner.
+  # Start a manual checks dispatch with: gh workflow run checks --ref <branch>.
  jfr-analysis:
    if: github.event_name == 'workflow_dispatch'
    runs-on: [self-hosted, linux, horizon-game]
@@ -58,6 +58,18 @@ jobs:
          echo "Merges since ${BASE_SHA}:"
          git log --first-parent --format='  %h %s' "$BASE_SHA..HEAD"
          python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400
+      - name: Preserve the initial failure logs
+        if: steps.harnesses.outcome == 'failure'
+        run: |
+          rm -rf .local/parity-main-logs && cp -R .local/parity-runner/logs .local/parity-main-logs 2>/dev/null || true
+      - name: Upload the initial failure logs
+        if: steps.harnesses.outcome == 'failure'
+        uses: actions/upload-artifact@v7
+        with:
+          name: parity-main-logs
+          path: .local/parity-main-logs/
+          if-no-files-found: warn
+          retention-days: 7
      - name: A flake, or the merge that broke them
        if: steps.harnesses.outcome == 'failure'
        env:
@@ -65,13 +77,4 @@ jobs:
          PARITY_HOSTS: ''
          BASE_SHA: ${{ steps.base.outputs.sha }}
        run: |
-          rm -rf .local/parity-main-logs && cp -R .local/parity-runner/logs .local/parity-main-logs 2>/dev/null || true
          python3 tools/parity_main.py bisect "$BASE_SHA" --comment
-      - name: Logs of the failed harnesses
-        if: steps.harnesses.outcome == 'failure'
-        uses: actions/upload-artifact@v7
-        with:
-          name: parity-main-logs
-          path: .local/parity-main-logs/
-          if-no-files-found: ignore
-          retention-days: 7
@@ -0,0 +1,34 @@
+name: runner watch
+# Every 30 minutes: one issue when jobs wait over 2 hours for a self-hosted runner nobody runs (the maintainer's
+# machines are off), closed again once nothing waits (tools/ci/runner_watch.py, docs/operations.md). It runs on
+# GitHub's runners, never ours: it must work when every self-hosted runner is gone.
+#   gh workflow run "runner watch" -f dry_run=true
+on:
+  schedule:
+    - cron: '11,41 * * * *'
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: Only print what it would do with the issue
+        type: boolean
+        default: false
+permissions:
+  actions: read
+  contents: read
+  issues: write
+concurrency:
+  group: runner-watch
+  cancel-in-progress: false
+
+jobs:
+  watch:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - name: Jobs waiting for a self-hosted runner
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: python3 tools/ci/runner_watch.py ${{ inputs.dry_run && '--dry-run' || '' }}
@@ -1,7 +1,9 @@
 # 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; performance work may differ inside as long as it stays compatible with vanilla
+([CONTRIBUTING.md](CONTRIBUTING.md#when-it-doesnt-have-to-be-11)). 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
@@ -20,6 +22,13 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
  is the GitHub account the PR is opened from (`gh api user --jq .login`). Issues say "Filed by", reviews
  "Review by". Every comment starts with `🤖 Agent:`. Write only as the person you work for: the lines on
  this page that name Ludovic are for his own agents (account `ludovic111`), never for anyone else's.
+- **Review only when asked, and decide.** Review a pull request only when its author or a maintainer asks.
+  Asked by a maintainer to review open pull requests in general, take them one at a time, oldest first, skipping
+  drafts, your person's own and those they already reviewed. Check that the change does what it says (bugs, edge
+  cases), what it could break, whether tests cover it, and whether its scope and description hold up. Report only
+  what you can point to with a `file:line`, each point marked Blocker (fix before merge), Important, Nit,
+  Suggestion, Question or Praise. Submit a decision, never a plain comment: `gh pr review --approve` when nothing
+  blocks, `--request-changes` when something does.
 - **Attribution.** Commits end with a `Co-Authored-By:` line for the agent that wrote them, and PR bodies
  with that agent's own "Generated with" line. Example, Ludovic's agents (Claude Code on `ludovic111`):
  first line `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, commits
@@ -35,7 +44,6 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - Small PRs (< ~500 lines). Labels: `feature` (players get something new), `skip-release` (they see no
  change), none for a fix. Agents never add `release-now`: the maintainer decides it. Merges ship in batches of 5, or after
  6 hours ([docs/release-flow.md](docs/release-flow.md)).
- Contributors first: `gh pr list --state open --search <area>` before you start; never duplicate theirs.
 - **No hardcoded user-facing strings.** Keep UI translation-ready from the start. In the launcher (`launcher/`), wrap visible text with `tr("...")` or `trf("... {arg} ...", &[("arg", &val)])` from `crate::i18n` instead of raw string literals or `format!`. In the game, use translation keys (`Text::tr`, `lang::get`), never hardcoded English strings.
 - **Claim before you start**: comment `/claim` on the issue (no issue yet: open one, then claim it). An assigned
  issue is taken, and so is one labelled `in progress` (claimed on Discord): pick another. `/unclaim` when you stop;
@@ -47,6 +55,29 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - **Render passes keep HDR's light.** A pass that reads, filters or redraws the world's picture (upscaling,
  anti-aliasing, sharpening, frame generation, post effects, captures) follows [docs/hdr-passes.md](docs/hdr-passes.md).

+## Don't lose time
+
+Where agent time went, measured on sessions and CI in November 2026: reading code, compiling `horizon-client`,
+waiting in loops, and work someone else had already done. Tests were a small part.
+
+- **Check nobody else is on it.** One in three pull requests closed unmerged was a duplicate. Before you write
+  code, look at the issue's linked pull requests and run
+  `gh pr list --state open --search "<issue number, function or file name>"`; then `/claim`.
+- **Find code with the map, not by reading.** Start from the tables below and
+  `python3 tools/port_ledger.py where Class.method`. Read the function you change and its callers, not whole
+  files.
+- **Compile cheaply while you work.** `cargo check -p <crate>` after an edit. Clippy, fmt and tests run once, at
+  the end, through `pr_ready.py`. `cargo clippy -p horizon-client` and `cargo build -p horizon-client` are the
+  slowest commands here: never after every edit, and build the game only when you need to run it.
+- **Don't wait in loops.** Start a long command in the background and carry on, or wait for it once. No
+  `sleep` or `until grep` polling of builds, harnesses or CI.
+- **One test per changed behaviour.** None for a refactor or a file move, none that reads source text, and no
+  harness where vanilla has nothing to compare (Horizon's own features, performance work).
+- **A red check isn't always yours.** When `verify` fails in a test your change can't reach, say so in the pull
+  request and move on; don't hunt it.
+- **Unsure about a rule? Finish the work.** Take the reading that lets you finish, and say in the pull request
+  which one you took. Don't stop, and don't change direction halfway.
+
 ## Crates

 Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-server` are separate workspaces.
@@ -96,6 +127,7 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 - Use independent expected values or a vanilla oracle; do not derive the answer from the code under test.
 - Test outcomes, not only calls to stubs. Use mocks to isolate behavior, not as the behavior itself.
 - Skip tests of trivial constants, derives and getters, or behavior already covered by another test.
+- One test per changed behaviour is enough. A refactor or a move that changes no behaviour gets no new test.
 - Avoid pinning implementation details; a harmless refactor should not break a behavior test.
 - Make slow tests faster without removing cases or weakening their coverage.
 - Never delete parity harnesses or tests that pin vanilla behaviour: they are the spec.
@@ -152,7 +184,8 @@ python3 tools/lang_coverage.py --summary   # the keys each language still misses
 - 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.
+  random draws must happen in vanilla's order. Performance work may break that order where no player can rely
+  on it; the pull request says so ([CONTRIBUTING.md](CONTRIBUTING.md#when-it-doesnt-have-to-be-11)).

 ## horizon-client: where things live

@@ -215,7 +248,8 @@ player does (#1514). A window's `Game` never ticks a world itself: the old in-fr
 Open `[server-thread]` issues list the gaps left.

 Single player, LAN guests and dedicated servers all run the server code, so a fix there serves all three.
-Test the server thread when you touch player-facing gameplay:
+When you change how the server and its clients talk (packets, tracking, guests, the server thread itself), check
+it there. Other gameplay fixes are covered by their own harness and CI's parity job:

 ```sh
 cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T               # server thread
@@ -1,7 +1,8 @@
 # Contributing to Horizon

 Thanks for helping. Horizon is Minecraft: Java Edition 26.3 rewritten in Rust, and the one rule that shapes
-everything is that **it plays exactly like vanilla**. This page is the short version of how we work; questions are
+everything is that **it plays like vanilla**: first exactly like it, then better where players gain from it
+([vanilla first, then better](#vanilla-first-then-better)). This page is the short version of how we work; questions are
 welcome on [Discord](https://discord.gg/playhorizon).

 This repository holds the game and the launcher, plus the tools, tests and docs that build, check and release them.
@@ -23,7 +24,7 @@ here.

 ## Build it

- **Prerequisites:** Rust (stable), Python 3.10+, JDK 25, and on Linux the ALSA and udev headers
+- **Prerequisites:** Rust (stable), Python 3.11+, JDK 25, git 2.38 or newer, and on Linux the ALSA and udev headers
  (`libasound2-dev libudev-dev`).
 - **Resources:** Horizon never downloads the game; it prepares its resources from your own copy of Minecraft 26.3, as
  described in [Build from source](README.md#build-from-source).
@@ -36,7 +37,10 @@ here.

 - **Launcher:** its own Cargo workspace in `launcher/` (`cd launcher && cargo run`; on NixOS, `nix-shell` first).

-## Vanilla first
+## Vanilla first, then better
+
+Horizon gets there in two stages. First it plays exactly like vanilla; that is what parity work is for. Then it
+improves on vanilla where players gain from it, mostly speed: FPS, TPS, loading, memory.

 Wherever vanilla has a feature, vanilla is the specification, down to the order of random calls. "Parity" here means
 Horizon gives the same results as the pinned 26.3 client and server for the same inputs, checked by a **harness**: a
@@ -49,8 +53,10 @@ and compares their outputs.
 - **One version: 26.3.** Parity work targets 26.3 until its parity is good, redstone first. Don't open pull requests
  that move Horizon to a newer Minecraft version for now; to join servers on a newer version, put a Via proxy
  (ViaVersion, ViaProxy) in front of them.
- **Gameplay changes come with a harness**, new or extended, so the next change can't silently break them.
-  [The parity workflow](docs/parity-workflow.md) shows how harnesses run; copy a nearby one.
+- **Ports of vanilla behaviour come with a harness**, new or extended, so the next change can't silently break
+  them. [The parity workflow](docs/parity-workflow.md) shows how harnesses run; copy a nearby one. Where vanilla
+  has nothing to compare (Horizon's own features, performance work, refactors), no harness is needed: one Rust
+  test of the changed behaviour, or the numbers before and after.
 - **Horizon's own features** (the launcher, the new menus) follow [the design system](docs/design-system.md) and are
  off by default wherever they would change the vanilla look.
 - **Three layers: engine, platform, Horizon.**
@@ -67,40 +73,26 @@ and compares their outputs.
  The pre-push hook checks the full history reachable from the branches and tags being pushed. Run
  `python3 tools/check_public_tree.py --history` to audit the history of all local refs.

-## Only original code, or code whose license allows it
+### When it doesn't have to be 1:1

-Horizon is MIT. Its code is written from Minecraft 26.3 itself and from public documentation. Since 30 October 2026
-another project's source may also be read and used, **only when that project's license allows it**:
+Parity is about what players and the vanilla game see, not about copying vanilla's internals. Performance work (a
+multithreaded server tick, rendering, chunk loading, memory) doesn't have to keep vanilla's internal order or its
+exact random calls. It has to work together with normal Minecraft:

- **Allowed:** MIT, MIT-0, BSD-2-Clause, BSD-3-Clause, 0BSD, ISC, zlib, Apache-2.0, Unlicense, and the CC0-1.0
-  public-domain dedication. That code may be read, copied or adapted.
- **Off limits, even to read:** GPL, LGPL (Iris), AGPL, MPL, EPL, Polyform (Sodium), the Creative Commons licenses
-  (CC BY, CC BY-SA, CC BY-NC and the others; CC0 is a public-domain dedication, not one of them), custom or
-  "source available" licenses, all rights reserved (OptiFine), and any project with no license or an unclear one.
-  Don't read, copy, translate or paraphrase their source, and don't send code an AI tool wrote from it. Being able
-  to download a mod or a pack does not give you the right to read its files.
- **Java's own library is GPL too.** OpenJDK's source (`java.lang.Math`, `StrictMath`, `FdLibm`, `HashMap`, the
-  sorts, `Double.toString`, HotSpot's intrinsics...) is GPL-2.0, so it is off limits like the rest. Reproduce Java's
-  behaviour from its API documentation (the Javadoc) and from what a JVM returns, or from a permissive original such
-  as Sun's fdlibm C sources (see [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)); see #6741.
- **Check the license yourself.** Read the LICENSE file at the commit you use and the header of each file you take:
-  some repositories mix licenses, and a file under another license is off limits. A license that changed: the one at
-  your commit counts. In doubt, don't: ask in #contributors first.
- **Say it in the pull request:** the project, a link to the commit, its license, and what you read or copied. A
-  pull request that used another project's source without saying so is closed.
- **Copied or adapted code** keeps its copyright line and license notice at the top of the file, and gets an entry
-  in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md). Apache-2.0 code also keeps its NOTICE text and says what
-  was changed.
-
-User documentation and file formats are fine to read, and packs and mods are fine to run and observe, whatever their
-license. Shader packs are a clean-room rewrite of the pack format, produced from a written description of it (see
-#1561): the [specification and its provenance log](docs/cleanroom/README.md) are public. They carry no foreign
-source, and the rules above still apply to anything you read while working on them. A shader-pack pull request
-names its sources: the sections of that specification, the documentation pages and the packs it ran.
+- **Vanilla clients and servers still work with it.** A vanilla 26.3 client plays on a Horizon server, Horizon joins
+  vanilla servers, and saves and worlds open in both, as before.
+- **The game still plays the same.** Farms, redstone, mobs and drops work the way players know from vanilla. A
+  difference may only show where no player can rely on it, such as which of two mobs ticks first or exactly which
+  random number a mob gets.
+- **Vanilla's slow paths aren't copied.** When vanilla spends a lot of FPS or TPS on something that can reach the
+  same result faster, Horizon does it faster. Copying a performance problem isn't parity.
+- **Say what changes.** The pull request names the vanilla behaviour it no longer reproduces exactly, why players
+  won't notice it or why it's worth it, and how it was checked: numbers before and after, and the harnesses that
+  still pass. A change players could notice, such as a different tick order on a busy server, goes behind a setting.

 ## Vendor libraries and Java mods

- **Upscalers and latency tools.** AMD FSR (MIT) may go in the repository, like any code under an allowed license.
+- **Upscalers and latency tools.** AMD FSR (MIT) may go in the repository.
  NVIDIA's DLSS, Reflex and any other library under an NVIDIA license may not: they ship only as an optional native mod
  that downloads NVIDIA's files itself, on the player's machine. No NVIDIA binaries, headers or SDK files in the
  repository.
@@ -1947,6 +1947,7 @@ name = "horizon-server-files"
 version = "0.1.0"
 dependencies = [
 "base64 0.22.1",
+ "getrandom 0.3.4",
 "horizon-core",
 "horizon-protocol",
 "horizon-world",
@@ -2,6 +2,9 @@

 > Adopted 2026-11-09 by the founder as his last decision as head of the project. It takes effect when he
 > announces that he is stepping down. From then on only the council changes it, by a 2/3 poll (section 15).
+>
+> Amended 2026-11-10 by the founder (three kinds of action, elections by tier, who may do what, and council poll P41:
+> the mods decide moderation matters). The council can overturn this amendment by poll.

 Horizon has no boss. A **council of equals** decides by polls. **Theme groups** do the work in their areas, each
 with a **lead**. The **Horizon Team** reviews and merges code. **Moderators** keep the Discord server and the
@@ -50,13 +53,13 @@ the Horizon Team, for example.
 | Level | What it can do | How you get in | How you leave | 18+ |
 | --- | --- | --- | --- | --- |
 | **Member** | Play, chat, report bugs, suggest ideas, open issues and pull requests, pick group roles | Join the Discord server or the GitHub repo | Leave, or get banned | No |
-| **Contributor** (⛏️ Iron, 🥇 Gold, 💎 Diamond, 🟪 Netherite ranks) | Write in #contributors; `/claim` issues; nominate people for group lead (if active in that group) | One merged pull request in a public horizon-rust repo, linked with `/link-github` and `/verify-github`. Ranks come from merged pull requests: 10, 40, 100 and 200 | Contributor status and ranks stay | No |
-| **Group member** | Read and write in the group's channel; get the group's pings; take part in the group's advisory poll on its lead | Pick the group's role in Channels & Roles, or with `/groups` | Remove the role | No |
-| **🤝 Support** | Answer and close posts in #horizon-support | `/apply`; vote of the mods and the Team (as today) | Resign, 30 days inactive, or removed by the Chief of Mods or the council | No |
-| **🛡️ Moderator** | Time out, delete messages, manage threads, quarantine. No bans | `/apply`, then the selection filter; mods' vote; the council may object within 24 h | Resign, 30 days inactive, suspended by the Chief of Mods, removed by a council poll (simple majority) | **Yes** |
-| **🛡️ Chief of Mods** | A moderator's powers, plus bans; leads the mods; suspends a mod at once pending the council | Council poll (simple majority), from the mods with at least 30 days | Resign, 30 days inactive, council poll (simple majority) | **Yes** |
-| **🧭 Group lead** | Decides inside the group's topic (section 6); manages the group's channel; triage on the group's GitHub issues | Nomination, the filter, a 24 h public discussion with an advisory group poll, then a council poll (simple majority); 30 days probation | Resign, 30 days inactive (automatic), council poll (simple majority); confirmed again every 6 months | **Yes** |
-| **🌌 Horizon Team** | Review and merge pull requests (GitHub `horizon-team`, write access); `/nightly` and triage commands (trusted reviewers); #horizon-team | Nomination, the filter, a 24 h public discussion, then a council poll (2/3); 30 days probation | Resign, 60 days without a merge or review (automatic), council poll (2/3, without the person) | **Yes** |
+| **Contributor** (⛏️ Iron, 🥇 Gold, 💎 Diamond, 🟪 Netherite ranks) | Write in #contributors; `/claim` issues; vote in their group's elections (if active in that group) | One merged pull request in a public horizon-rust repo, linked with `/link-github` and `/verify-github`. Ranks come from merged pull requests: 10, 40, 100 and 200 | Contributor status and ranks stay | No |
+| **Group member** | Read and write in the group's channel; get the group's pings; vote in the group's elections and votes when active | Pick the group's role in Channels & Roles, or with `/groups` | Remove the role | No |
+| **🤝 Support** | Answer and close posts in #horizon-support | Given by any moderator (a free action, section 2.1) | Resign, 30 days inactive, or removed by a moderator, the Chief of Mods or the council | No |
+| **🛡️ Moderator** | Time out, delete messages, manage threads, quarantine. No bans | Elected by the mods (section 5.3); council veto within 24 h | Resign, 30 days inactive, suspended by the Chief of Mods, recalled by the mods, removed by a council poll (simple majority) | **Yes** |
+| **🛡️ Chief of Mods** | A moderator's powers, plus bans; leads the mods; suspends a mod at once pending the council | Elected by the mods, from the mods with at least 30 days (section 5.3); council veto within 24 h | Resign, 30 days inactive, recalled by the mods, council poll (simple majority) | **Yes** |
+| **🧭 Group lead** | Decides inside the group's topic (section 6); manages the group's channel; triage on the group's GitHub issues | Elected by the group's active members and the Team (section 5.3); council veto within 24 h; 30 days probation | Resign, 30 days inactive (automatic), recalled by the same electorate, council poll (simple majority); confirmed again every 6 months | **Yes** |
+| **🌌 Horizon Team** | Review and merge pull requests (GitHub `horizon-team`, write access); `/nightly` and triage commands (trusted reviewers); #horizon-team | Elected by the Team, 2/3 (section 5.3); council veto within 24 h; 30 days probation | Resign, 60 days without a merge or review (automatic), recalled by the Team (2/3), council poll (2/3, without the person) | **Yes** |
 | **🏛️ Council** | Decides everything else by poll (section 4); bans; emergency actions by any 2 members | Nominated by a council member, the filter, a 24 h public discussion, then a council poll (2/3); 30 days probation | Resign, inactivity (section 5.5), council poll (2/3, without the person) | **Yes** |

 **The account holder** isn't a level. The founder (Ludovic) still holds the project's accounts (GitHub organisation
@@ -64,6 +67,55 @@ owner, Discord server owner, the Microsoft app approved by Mojang, the domains,
 council's decisions on them and hands them over step by step (section 11). As a council member he has one vote,
 like everyone else.

+### 2.1 Three kinds of action
+
+Most things need no vote at all. A vote is for power over other people, and for decisions that bind a whole body.
+
+| Kind | What | How |
+| --- | --- | --- |
+| **Free** | Everyday actions inside your own role (the list below, and anything of the same weight) | Just do it. Kira logs the ones she sees in #staff-log. The tier above can reverse it; if people disagree, the tier above votes. A pattern of abuse is a recall |
+| **Body vote** | Giving or taking a role that carries power (an election), or a decision that belongs to one body: the mods, the Team, a group | `/elect` or `/vote body:` in Kira (section 5.3). Any council member can call a veto within 24 hours |
+| **Council poll** | Rules, money, accounts and ownership, the council's own members, vetoes, anything that spans several bodies | `/poll` (section 4) |
+
+Free actions, for example:
+
+- a lead gives or removes their group's helper role (🧩 Horizon Modding Team), through Kira;
+- a moderator gives or removes 🤝 Support, through Kira;
+- a moderator times out, deletes, quarantines, or changes a channel's slowmode or topic; the Chief of Mods bans and
+  unbans;
+- the Team merges and labels;
+- a server operator restarts the official server, or prunes backups and chunks by the written rule;
+- a lead pins, renames or creates threads in their group's channels;
+- Kira's automatic actions.
+
+**The 24-hour rule.** Every vote lasts 24 hours at most, and closes earlier once its result can't change. Only council
+polls on this document, the licence, money and the GitHub organisation's ownership last 48 hours. A veto is called
+within 24 hours of a result.
+
+### 2.2 Who may do what
+
+What each post decides, and what it holds on Discord, on the official server and on GitHub. Anything not listed is a
+council matter.
+
+| Post | Decides | Discord | Official server | GitHub |
+| --- | --- | --- | --- | --- |
+| **Member** | — | Chat, threads, picks group roles | Play | Issues, pull requests, `/claim` |
+| **Group helper** (🧩 Horizon Modding Team) | — | Writes in the group's team channel | — | — |
+| **🤝 Support** | Closes support posts | Manages threads in #horizon-support | — | — |
+| **🛡️ Moderator** | Moderation matters, by the mods' vote (section 7) | Time out, delete messages, manage threads and nicknames, audit log, voice mute and move; quarantine through Kira; the staff channels | In-game op if also elected operator | — |
+| **🛡️ Chief of Mods** | A moderator's, plus bans and unbans; suspends a mod at once; breaks ties in the mods' votes | Plus Ban | As a moderator | — |
+| **Server operator** | In-game moderation by the server rules | — | Op (the server's ops list); no panel, no `server.toml` | — |
+| **🧭 Server & SMP lead** | The server's settings, by the written rules (backup first, warning in game) | As every lead | A panel sub-user once a council accounts poll gives one | As every lead |
+| **🧭 Group lead** | The group's free actions; gives and removes its helper role | In the group's channels: delete messages, manage and pin threads, ping the group; the helper role through Kira | — | Triage on the group's labels through Kira (no repository role) |
+| **🌌 Horizon Team** | Merges; elects Team members | #horizon-team and the staff channels. The role still carries timeout and delete; whether it keeps them is a mod matter | — | `horizon-team`: write on horizon, horizon-mods, horizon-mixins, horizon-native-mod-template and horizon-server; also kira and horizon-site if P37 passes |
+| **🔧 Server Manager** | — | Manage Channels and Manage Roles (the server's layout); given by council poll | — | — |
+| **🏛️ Council** | Council polls, vetoes, emergencies (any 2) | A moderator's permissions plus Ban, mention @everyone and pin; #council | Panel sub-users for two members if P38 passes | The `council` team: code-owner reviews and the release tools' owner powers if P35 passes, security managers if P36 passes; a second organisation owner if P28 passes |
+| **Account holder** (the founder) | Carries out decisions on his accounts (section 11) | Server owner | The panel's owner account | Organisation owner |
+
+Kira applies a passed election everywhere she can: Discord roles herself, GitHub team membership when the council has
+given her a token for it. Whatever she can't do (a panel sub-user, the ops list, a GitHub team without a token) she
+posts as a list of clicks for a named person.
+
 ## 3. Each level in detail

 ### Member
@@ -84,13 +136,13 @@ an issue or a pull request on GitHub, or a request for a council poll (any counc

 Each theme group (section 6) has a role that anyone can pick and drop. It opens the group's channel and receives the
 group's pings. Picking a role grants no power. A group member counts as **active in the group** when Kira has seen at
-least one counted action in the group's area (section 5.1) in the last 60 days. Only active group members can
-nominate a lead or vote in the group's advisory poll.
+least one counted action in the group's area (section 5.1) in the last 60 days. Active group members vote in the
+group's elections and decisions (section 5.3).

 ### 🤝 Support

 Unchanged: Support members help players in #horizon-support. They answer every post there and mark posts solved.
-The role carries no permission, so it has no age rule. They join through `/apply`, and the mods and the Team vote.
+The role carries no permission, so it has no age rule. A moderator gives it, and takes it back, through Kira.

 ### 🛡️ Moderators and the Chief of Mods

@@ -151,7 +203,7 @@ don't go through the filter or a probation. They do make the 18+ declaration (se
 | --- | --- |
 | Who starts one | Any council member, with `/poll` (Kira). Anyone else asks a council member to start it |
 | Where | #polls-and-decisions, in public. Polls about a person (removal, appeals, the age rule) run in #council, and only their result is public |
-| How long | 24 hours. It closes early only if every council member has voted |
+| How long | 24 hours; 48 hours for this document, the licence, money and the GitHub organisation's ownership. It closes early only if every council member has voted |
 | Ballot | Yes, No or Abstain. You can change it until the poll closes |
 | Quorum | At least half of the council votes (Abstain counts). With 6 members, 3 votes |
 | Simple majority | More Yes than No |
@@ -165,20 +217,20 @@ don't go through the filter or a probation. They do make the 18+ declaration (se

 | Simple majority | Two-thirds |
 | --- | --- |
-| Day-to-day project decisions: direction, priorities, settling disputes between groups, a public statement | Adding council members and Horizon Team members |
-| Group leads and co-leads: appointing, removing, confirming every 6 months | Removing a council member or a Team member (without the person concerned) |
-| Moderators, the Chief of Mods, Support: confirming, removing | Rules: this document, the server rules, the contributing policy, the licence |
+| Day-to-day project decisions: direction, priorities, settling disputes between groups, a public statement | Adding council members |
+| Vetoing a body's vote or election (section 5.3) | Removing a council member or a Team member (without the person concerned) |
+| Removing a group lead, a moderator, the Chief of Mods or Support (their bodies can also recall them) | Rules: this document, the server rules, the contributing policy, the licence |
 | Ending a probation early | Money (section 12) |
 | Confirming an emergency action | Account handover steps (section 11) |
-| Second-level moderation appeals | Waiving part of the selection filter (section 5.4) |
+| Deciding for a body that has fewer than 3 voters | Waiving part of the selection filter (section 5.4) |
 | Bringing back someone who stepped down for inactivity, within 6 months | Changing the council's size |

 **When in doubt, two-thirds.** Any council member can say a poll needs 2/3, and Kira then counts it at 2/3.

 ### 4.4 Discussion

-Polls that add someone to the council, the Team or a lead post start with a **24-hour public discussion** (section
-5.3). Other polls are discussed in their own thread while they run. A member who wants more time votes No and says
+Polls that add someone to the council start with a **24-hour public discussion**. Other polls, and elections, are
+discussed in their own thread while they run. A member who wants more time votes No and says
 why. A failed poll can come back after 7 days.

 ### 4.5 Conflicts of interest
@@ -220,7 +272,7 @@ false age declaration (section 9).
 ## 5. The selection filter

 Nobody becomes a lead, a Team member or a council member just because they are well liked or talk a lot. Kira
-measures the work, and only people above a floor can be nominated. The council then decides among them.
+measures the work, and only people above a floor can be nominated. Their body then elects them (section 5.3).

 ### 5.1 What Kira measures

@@ -254,25 +306,63 @@ A nomination is refused below these floors.
 The numbers are checked again once a year (section 15). They should stay reachable for people who really work on
 Horizon and out of reach for people who don't.

-### 5.3 The path to a role
+### 5.3 Elections

-1. **Nomination.** Run `/nominate member: role: [group:]` in Kira.
-   - A **group lead** can be nominated by an active member of that group or by a council member. A self-nomination
-     needs a second from another active group member or a council member.
-   - A **Team member** can be nominated by a council or Team member. Someone can also nominate themselves with
-     `/apply`, if a council or Team member sponsors them.
-   - A **council member** can only be nominated by a council member.
-   - **Moderators** apply with `/apply`.
-2. **The filter.** Kira checks the floor and the 18+ declaration. Below the floor, Kira refuses and says which line
-   is short.
-3. **Public discussion, 24 hours.** Kira posts the nomination and the evidence card in a thread of
-   #polls-and-decisions. Contributors and the council can comment. For a lead, Kira also runs an **advisory poll** in
-   the group's channel for the same 24 hours. Only active group members vote in it, and the council sees the result.
-4. **Council poll, 24 hours.** Simple majority for a lead, 2/3 for the Team and the council. For moderators, the mods'
-   vote replaces this step, and any two council members can object within 24 hours; the council then decides by poll.
-5. **Probation, 30 days.** The role is held in full, except for the Team limits in section 3. At day 25, Kira asks the
-   council in #council whether anything is wrong. Probation ends by itself at day 30, unless a council poll (simple
-   majority) ended it earlier.
+The body that works with a person elects them. Kira runs it: `/elect post: member: [group:]`, and `action: remove`
+for a recall.
+
+| Post | Who votes | Passes with | Who can start it |
+| --- | --- | --- | --- |
+| **🛡️ Moderator** | The mods (🛡️ Mod and 🛡️ Chief of Mods) | Simple majority; the Chief of Mods breaks a tie | Any mod, a council member |
+| **🛡️ Chief of Mods** | The mods; candidates are mods for 30 days or more | Simple majority | Any mod, a council member |
+| **Server operator** | The mods and the 🧭 Server lead | Simple majority | The Server lead, the Chief of Mods, a council member |
+| **🧭 Group lead** (a co-lead once the group has 8 active members) | The group's active members, and the Team | Simple majority | The current lead, a Team member, a council member |
+| **🌌 Horizon Team** | The Team | Two thirds, and at least 3 Yes | A Team member, a council member |
+| **🏛️ Council** | The council, by poll after a 24-hour discussion (section 4) | Two thirds, and at least 3 Yes | A council member |
+| 🤝 Support, a group's helper role | Nobody: a free action (section 2.1) | — | A moderator; the group's lead |
+
+An **active group member** has held the group's role for 14 days or more (Kira counts from when she first saw it)
+and has at least one merged pull request or review with the group's label in the last 60 days.
+
+1. **Start.** Kira checks the floor (5.2) and the 18+ declaration. If the candidate falls short, the person starting
+   gets a private "not now", and the candidate a private message saying what is missing. Nothing is posted and no
+   reason is ever shown to anyone else. Kira checks what she can measure (verified GitHub, merged pull requests and
+   reviews, overall and by the group's label, rank, days in the server, Kira level, clean record, the declaration);
+   the voters judge the rest.
+2. **Vote, 24 hours,** in the body's channel, discussed in the vote's thread. Yes, No or Abstain, changeable while it
+   runs. Kira shows how many voted, never who. It closes early once the result can't change.
+3. **Result,** applied at once. Kira gives or takes the Discord role and, with a token, the GitHub team; she lists the
+   rest as clicks for a named person. Only the result is published, never the ballots.
+4. **Veto, 24 hours.** Any council member can call it with the button under the result. A council poll (simple
+   majority, without the people involved) decides; if it passes, Kira undoes the result.
+5. **Probation, 30 days,** for leads and Team members. It ends by itself unless someone who can vote starts a recall.
+
+The council can always remove someone by its own poll. **Body votes** work the same way for a body's own decisions:
+`/vote body:mods`, `body:team` or `body:group`, simple majority, 24 hours, the same veto.
+
+#### Hard cases
+
+| Case | What happens |
+| --- | --- |
+| Fewer than 3 can vote | The council decides by poll |
+| Quorum | A third of the electorate, and at least 3 ballots (Abstain counts). Without it, nothing changes |
+| Tie | Fails, and nothing changes. In the mods' votes, the Chief of Mods' ballot breaks it |
+| The candidate | Doesn't vote on themselves, and can decline (the election ends). The person who started it votes normally |
+| Conflicts | Whoever the vote is about, or who gave or received the moderation action in question, doesn't vote |
+| Several candidates for one seat | Nominations within the first 12 hours join one approval ballot. The seat goes to the most approvals if that is at least half of the voters; otherwise a 24-hour run-off between the top two |
+| A seat that is held | Changes only by a recall or by the 6-month confirmation |
+| The council is already voting on it | No election starts for the same person and post |
+| Cooldown | A failed or vetoed election can't be started again for the same person and post for 30 days. At most 3 elections run at once in a body |
+| Vacancy | When a lead or the Chief of Mods leaves, Kira opens the seat's election herself: 24 hours of nominations, then the vote with everyone nominated. Nobody nominated: the seat stays open, and the tier above acts meanwhile. Kira never picks a candidate |
+| Abuse of a free action | The tier above reverses it; a disagreement goes to its vote. A pattern is a recall |
+| Emergency | Section 4.6. The Chief of Mods can still suspend a mod at once |
+| Kira is down | The body may run the same vote as a Discord poll in its channel for 24 hours; Kira records the result when she is back |
+
+#### Reminders, not nominations
+
+Once a month in a group's channel, Kira says how to propose someone, only when the group has no lead or someone in it
+meets a post's floor. When a seat opens, she posts once in the electorate's channel. Once a month in #council, she
+lists privately the people who meet a floor. These are suggestions: only people start elections.

 ### 5.4 Exceptions

@@ -299,8 +389,8 @@ holder or an org owner removes GitHub access when the Team role ends.

 ### 5.6 Terms

- **Group leads** are confirmed every 6 months by a simple-majority poll. If someone else in the group passes the
-  floor and is nominated, both go on the same poll.
+- **Group leads** are confirmed every 6 months by an election in their group. If someone else in the group passes the
+  floor and is nominated within its first 12 hours, both go on the same ballot.
 - **Council and Team** have no fixed term. They stay as long as they are active and keep the council's trust. Removal
  is always possible (section 4.7).

@@ -339,8 +429,9 @@ the design system:
 - technical and design direction inside the area, when vanilla behaviour and the default look don't change;
 - accepting or declining an idea or a proposal in the area. Any two active group members or one council member can
  take that decision to the council;
+- giving and removing the group's helper role, through Kira (a free action);
 - how the group organises itself (threads, meetings, the channel's rules on top of the server's);
- asking the Team for reviews, adding `needs-proof`, and nominating people.
+- asking the Team for reviews, adding `needs-proof`, and starting elections in the group.

 ### 6.4 What goes to the council

@@ -356,21 +447,28 @@ the design system:

 The work goes on. The Team reviews and merges, and Kira still routes the group's issues and questions to its
 channel. Until a lead is chosen, any council member may take a lead's decision for that group and says so in the
-channel. Kira pins a "lead wanted" note with the floor. **No lead is better than a lead who doesn't do the work:**
+channel. Kira posts once that the seat is open and how to start its election (section 5.3). **No lead is better than a lead who doesn't do the work:**
 nobody is appointed just to fill the seat.

 ## 7. Moderation and appeals

+- **The mods decide moderation matters** (council poll P41, imposed by the founder on 2026-11-10): who joins or
+  leaves the mod team, the mods' permissions and the staff channels, bans and unbans, and channel settings for
+  moderation. Everyday actions are free (section 2.1). Anything bigger is a mods' vote (`/vote body:mods`, simple
+  majority, 24 hours), and the Chief of Mods breaks ties. **The council keeps a veto:** within 24 hours of a mods'
+  decision, any council member can call a council poll, and a simple majority overturns it.
 - **The server rules** are in #rules. Moderators enforce them, the Chief of Mods leads the mods, and the council can
  change the rules (2/3).
 - **Every action has a mod case**: who acted, what they did, and why. Kira keeps the cases.
 - **First appeal:** within 14 days, through #appeal (for a quarantine) or mod mail. A moderator who wasn't involved,
  or the Chief of Mods, answers within 72 hours.
- **Second appeal:** for bans, timeouts over 24 hours and quarantines, a council poll in #council (simple majority).
-  Members who were involved don't vote. The answer is final for 90 days.
+- **Second appeal:** for bans, timeouts over 24 hours and quarantines, a mods' vote in #mod-chat. Mods who were
+  involved don't vote, and the council's veto applies. The answer is final for 90 days.
 - **Not appealable here:** actions that Discord's rules or the law require. Those are reported where the law says.
- **Removing a moderator:** the Chief of Mods can suspend a moderator at once, and the council decides within 72 hours
-  (simple majority). The council removes the Chief of Mods the same way.
+- **Removing a moderator:** the Chief of Mods can suspend a moderator at once, and the mods decide within 72 hours by
+  a recall vote. The mods recall the Chief of Mods the same way. The council can also remove either by poll.
+- **Council members keep the ban permission** for emergencies and when no moderator is around. They log the ban like
+  any other, and the mods can reverse it by vote.
 - **Staff are moderated like everyone.** When a council member is involved, the council decides without them.

 ## 8. Conflicts and hard cases
@@ -432,7 +530,7 @@ unable to act, and never puts an account that is tied to a person into anyone el

 | Account | Today | Can it be shared? | Plan |
 | --- | --- | --- | --- |
-| **GitHub organisation** (horizon-rust) | One owner (the founder) | Yes: an organisation can have several owners | **Step 1:** a second owner from the council, chosen by a 2/3 poll in the council's first week, with two-factor authentication on. **Step 2:** a `council` team; CODEOWNERS reviews and the release tools' owner powers (`paused`, `/nightly remove`) move from the founder to that team |
+| **GitHub organisation** (horizon-rust) | Two owners since 2026-11-11: the founder and rdbtCVS (P28); a `council` team holds CODEOWNERS (P35) and is the security managers (P36) | Yes: an organisation can have several owners | **Step 1:** a second owner from the council, chosen by a 2/3 poll in the council's first week, with two-factor authentication on. **Step 2:** a `council` team; CODEOWNERS reviews and the release tools' owner powers (`paused`, `/nightly remove`) move from the founder to that team |
 | **Discord server** | Owned by the founder | Partly: a server has exactly one owner; powers can be given through roles | **Step 1:** the 🏛️ Council role gets moderation and ban permissions; Kira applies the outcomes of passed polls, so nobody needs Manage Roles; two-factor authentication becomes required for moderation. Ownership itself stays with the founder until a legal entity exists |
 | **Kira** (bot application, Railway service) | The founder's Discord developer account and Railway | The bot: yes (a Discord developer team). Railway: adding members may need a paid plan | **Step 1:** a Discord developer team with two council members. Railway members once the council decides on money |
 | **Official server** (hosting panel) | The founder's account | Yes: panel sub-users | **Step 1:** sub-users for the Server and SMP lead and for one council member |
@@ -458,7 +556,9 @@ and the founder carries it out.
 ## 13. Transparency

 - **#polls-and-decisions:** every poll and every result, posted by Kira, and the 24-hour discussions of nominations.
-  For polls that aren't about a person, each member's vote is shown once the poll closes.
+  For polls that aren't about a person, each member's vote is shown once the poll closes. The results of elections
+  and body votes are posted there too; for elections, only the result.
+- **#staff-log:** the free actions Kira sees (roles given or taken, bans, unbans), so the tier above can check them.
 - **The decisions log:** Kira keeps an append-only record of every poll, emergency action, appointment and
  step-down, with its date and result. It is public and machine-readable, so the agents can check a decision there.
 - **This document** lives in horizon-rust/horizon as `GOVERNANCE.md`. A short summary is pinned in #rules and in
@@ -109,7 +109,7 @@ horizon-ctl break -1 65 -3                              # mines it; replies with

 ## Build from source

-Needs Rust 1.90+, Python 3.10+, JDK 25, and on Linux `libasound2-dev libudev-dev`. `horizon-prepare` builds the game's resources from **your own copy** of Java Edition 26.3 (checked against `research-lock.json`) and never downloads it:
+Needs Rust 1.90+, Python 3.11+, JDK 25, and on Linux `libasound2-dev libudev-dev`. `horizon-prepare` builds the game's resources from **your own copy** of Java Edition 26.3 (checked against `research-lock.json`) and never downloads it:

 1. **Client:** play 26.3 once in the official launcher. Horizon reads `~/.minecraft` (or `--minecraft-dir` / `HORIZON_MINECRAFT_DIR`).
 2. **Server jar:** the 26.3 server jar (`downloads.server.url` in `versions/26.3/26.3.json`), passed once with `--server-jar` or `HORIZON_SERVER_JAR`.
@@ -358,3 +358,29 @@ state of Starling's `crates/horizon-client-render/src/touch.rs` at the same comm

 `crates/horizon-client-render/src/android_runtime.rs` and `android_runtime/tests/` are adapted from the
 input part of Starling's `crates/horizon-client-render/src/android_runtime.rs` at the same commit.
+
+## PCG3D hash
+
+`hash3` in `crates/horizon-client-render/src/hdr.wgsl`, the noise HDR10 output's dither is made from, is the
+`pcg3d` hash of Mark Jarzynski and Marc Olano ("Hash Functions for GPU Rendering", Journal of Computer Graphics
+Techniques 9(3), 2020), from <https://github.com/markjarzynski/PCG3D>. Copyright 2020 Mark Jarzynski & Marc Olano,
+licensed under MIT:
+
+```
+Copyright 2020 Mark Jarzynski & Marc Olano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
@@ -23,6 +23,10 @@ pub const WITHDRAWN_PARTNER_SERVER: &str = "afri-network.co.za";
 /// (the telemetry server's status checks).
 pub const OFFICIAL_SERVER_STATUS: &str = "play.playhorizon.dev:24454";

+/// Horizon's website, where the launcher is downloaded: the game started without its prepared
+/// files sends the player there.
+pub const WEBSITE: &str = "https://playhorizon.dev";
+
 /// The cosmetics service: cosmetics, emotes, "Show me as a Horizon player"
 /// (`HORIZON_COSMETICS_API` overrides it).
 pub const COSMETICS_API: &str = "https://cosmetics.playhorizon.dev";
@@ -21,7 +21,6 @@ use std::collections::BTreeMap;
 use serde::{Deserialize, Serialize};

 pub mod combat;
-pub mod prediction;
 pub mod timer;

 /// What one check's violation level leads to.
@@ -162,8 +161,8 @@ checks! {

    /// Prediction: each move played again from the client's own inputs with vanilla's movement code,
    /// and compared (speed, step, fly, jesus...). Each player's client ticks are recorded
-    /// (`prediction::Record`), with a ping a tick to place what the server changes, and played again
-    /// (horizon-client's `lan::prediction`). A move that lands farther than `tolerance` from the
+    /// (horizon-client's `lan::prediction::record`), with a ping a tick to place what the server changes,
+    /// and played again (`lan::prediction`). A move that lands farther than `tolerance` from the
    /// replay flags, by how far it lands (one `tolerance` off weighs 1, at most 5 a tick), and the
    /// setback puts the player back where its moves last agreed. A tick near what the replay can't
    /// play yet (another entity, a block change or abilities the client hadn't seen, a moving piston,
@@ -279,15 +278,6 @@ pub struct Player {
    pub timer: timer::Balance,
    /// The server tick and height where the ground last held the player.
    pub ground: Option<(u64, f64)>,
-    /// The client ticks the prediction plays again (only while it runs).
-    pub record: Option<Box<prediction::Record>>,
-    /// Sprinting as the client's own commands left it (ServerboundPlayerCommandPacket's
-    /// START_SPRINTING and STOP_SPRINTING: LocalPlayer.wasSprinting), which the record's ticks take.
-    /// Not the server's player: a hit with extra knockback stops its sprint
-    /// (Player.causeExtraKnockback), the client's own `Player.attack` doesn't (a mob's `hurtClient`
-    /// is false), and once the server's flag reaches it LocalPlayer.aiStep starts the sprint again
-    /// while the sprint key is held, with nothing to say: wasSprinting never changed.
-    pub sprinting: bool,
    /// The attacks of the client tick being heard.
    pub attacks: combat::Attacks,
 }
@@ -70,6 +70,8 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
                         other one 30 000 characters long), flood-book (100 pages of 1024 characters
                         into a writable book), flood-sign (four 384-character lines on the block
                         below), flood-recipe (recipe book placements)
+  --ack-mode MODE        chunk batch feedback: vanilla (default) or 64 (fixed chunks per tick);
+                         one ACK per completed batch; use explore for a controlled pacing test
  --flood N              packets a tick for the flood behaviours; default 100
  --attack NAME          attack the player NAME twice a second, from wherever the bot is (a reach test),
                         swinging after each attack as vanilla's client does. NAME,NAME...: each of them
@@ -171,6 +173,8 @@ struct Options {
    /// --crits: fight bots alternate jumped critical hits and sweeps at a sword's cooldown.
    crits: bool,
    flood: usize,
+    /// None uses vanilla estimation; --ack-mode 64 requests a fixed rate.
+    ack_rate: Option<f32>,
    no_read: bool,
    no_loaded: bool,
    height: f64,
@@ -209,6 +213,7 @@ fn options() -> Result<Options, String> {
        no_swing: false,
        crits: false,
        flood: 100,
+        ack_rate: None,
        no_read: false,
        no_loaded: false,
        height: 24.0,
@@ -266,6 +271,13 @@ fn options() -> Result<Options, String> {
                o.explore_speed = value.parse().map_err(|_| number("blocks a second"))?;
            }
            "--pvp" => o.pvp = value.parse().map_err(|_| number("true or false"))?,
+            "--ack-mode" => {
+                o.ack_rate = match value.as_str() {
+                    "vanilla" => None,
+                    "64" => Some(64.0),
+                    _ => return Err(format!("--ack-mode {value}: use vanilla or 64")),
+                };
+            }
            "--flood" => o.flood = value.parse().map_err(|_| number("packets a tick"))?,
            "--attack" => o.attack = Some(value),
            "--attack-after" => o.attack_after = value.parse().map_err(|_| number("seconds"))?,
@@ -950,6 +962,7 @@ fn read(
    writer: Arc<Mutex<ConnWriter>>,
    bot: Arc<Bot>,
    track: bool,
+    ack_rate: Option<f32>,
    mut capture: Option<Capture>,
 ) {
    use ids::play::clientbound as cb;
@@ -1035,7 +1048,8 @@ fn read(
                batch.finished(r.varint().unwrap_or(0));
                send(
                    play::Serverbound::ChunkBatchReceived(play::ChunkBatchReceived {
-                        chunks_per_tick: batch.desired_chunks_per_tick(),
+                        chunks_per_tick: ack_rate
+                            .unwrap_or_else(|| batch.desired_chunks_per_tick()),
                    })
                    .encode(),
                )
@@ -1139,7 +1153,8 @@ fn run_bot(
        let capture = (index == 0)
            .then(|| o.capture.as_deref().and_then(Capture::create))
            .flatten();
-        thread::spawn(move || read(reader, writer, bot, track, capture));
+        let ack_rate = o.ack_rate;
+        thread::spawn(move || read(reader, writer, bot, track, ack_rate, capture));
    }
    use ids::play::serverbound as sb;
    // Wait for the spawn position.
@@ -1519,6 +1534,7 @@ fn main() {
        "behaviour": o.behaviour,
        "seed": o.seed,
        "explore_speed": o.explore_speed,
+        "ack_mode": o.ack_rate.map_or("vanilla", |_| "64"),
        "pvp": o.pvp,
        "view_distance": o.view_distance,
        "seconds": o.seconds,
@@ -1584,6 +1600,83 @@ mod tests {
        AddEntity, Clientbound, MoveEntity, MoveEntityPos, RemoveEntities, SetEntityData, VecDelta,
    };

+    /// Exercise the production reader over framed connections. Pings are barriers
+    /// so extra ACKs are observable without sleeps or timing guesses.
+    fn check_chunk_acks(ack_rate: Option<f32>) {
+        use horizon_protocol::connection::Pipe;
+        let (client, server) = Pipe::pair();
+        let (reader, writer) = Connection::local(client).split();
+        let mut server = Connection::local(server);
+        server
+            .reader
+            .set_read_timeout(Some(Duration::from_secs(2)))
+            .unwrap();
+        let bot = Arc::new(Bot::default());
+        bot.online.store(true, Ordering::SeqCst);
+        let handle = thread::spawn(move || {
+            read(
+                reader,
+                Arc::new(Mutex::new(writer)),
+                bot,
+                false,
+                ack_rate,
+                None,
+            )
+        });
+        for (nonce, size) in [0, 1, 5].into_iter().enumerate() {
+            server
+                .send(&raw(ids::play::clientbound::CHUNK_BATCH_START, |_| {}))
+                .unwrap();
+            server
+                .send(&raw(ids::play::clientbound::PING, |w| w.i32(nonce as i32)))
+                .unwrap();
+            let (id, body) = server.recv().unwrap();
+            assert_eq!(
+                id,
+                ids::play::serverbound::PONG,
+                "batch start must not send an ACK"
+            );
+            assert_eq!(Reader::new(&body).i32().unwrap(), nonce as i32);
+            server
+                .send(&raw(ids::play::clientbound::CHUNK_BATCH_FINISHED, |w| {
+                    w.varint(size)
+                }))
+                .unwrap();
+            server
+                .send(&raw(ids::play::clientbound::PING, |w| w.i32(nonce as i32)))
+                .unwrap();
+            let (id, body) = server.recv().unwrap();
+            assert_eq!(id, ids::play::serverbound::CHUNK_BATCH_RECEIVED);
+            let rate = Reader::new(&body).f32().unwrap();
+            if let Some(fixed) = ack_rate {
+                assert_eq!(rate, fixed);
+            } else if size == 0 {
+                assert_eq!(rate, 3.5, "vanilla initial rate must remain the default");
+            } else {
+                assert!(rate.is_finite() && rate > 0.0);
+            }
+            let (id, body) = server.recv().unwrap();
+            assert_eq!(
+                id,
+                ids::play::serverbound::PONG,
+                "exactly one ACK per finished batch"
+            );
+            assert_eq!(Reader::new(&body).i32().unwrap(), nonce as i32);
+        }
+        server.writer.shutdown();
+        handle.join().unwrap();
+    }
+
+    #[test]
+    fn fixed_64_ack_is_sent_once_per_finished_batch() {
+        check_chunk_acks(Some(64.0));
+    }
+
+    #[test]
+    fn vanilla_acks_remain_once_per_finished_batch() {
+        check_chunk_acks(None);
+    }
+
    fn feed(entities: &mut Entities, packet: &Clientbound) {
        let bytes = packet.encode();
        let mut r = Reader::new(&bytes);
@@ -514,6 +514,34 @@ pub fn name_text(tag: &Tag) -> Text {
 #[cfg(test)]
 mod tests {
    use super::*;
+
+    #[test]
+    fn nested_fallback_references_stay_bounded() {
+        // 300 references to the argument, nested three deep: 27 million copies of "A" from a
+        // 4 KB component, which ran a client out of memory.
+        let bomb = |depth: usize, text: &str| {
+            let pattern = "%1$s".repeat(300);
+            let mut v = serde_json::json!({ "text": text });
+            for _ in 0..depth {
+                v = serde_json::json!({"translate": "x.unknown", "fallback": pattern, "with": [v]});
+            }
+            v
+        };
+        let started = std::time::Instant::now();
+        let text = to_text(&bomb(3, "A"), &mut |s| Text::literal(s));
+        assert!(text.spans.len() < 1 << 15, "{} spans", text.spans.len());
+        // One long argument referenced many times multiplies bytes, not spans.
+        let long = "B".repeat(64 << 10);
+        let text = to_text(&bomb(1, &long), &mut |s| Text::literal(s));
+        let bytes: usize = text.spans.iter().map(|s| s.text.len()).sum();
+        assert!(bytes <= 4 << 20, "{bytes} bytes");
+        assert!(started.elapsed() < std::time::Duration::from_secs(5));
+        // A real fallback still formats.
+        let ok = serde_json::json!({
+            "translate": "x.unknown", "fallback": "%1$s and %1$s", "with": [{"text": "A"}]
+        });
+        assert_eq!(to_text(&ok, &mut |s| Text::literal(s)).plain(), "A and A");
+    }
    use crate::lang::{self, Language, ResourceSource};

    struct Mem(std::collections::HashMap<String, Vec<u8>>);
@@ -74,11 +74,70 @@ pub trait ResourceSource {
        vec!["minecraft".into()]
    }
 }
+/// The bundled file a language reads, and whether it drops `ß`: a regional variant reads its
+/// language's file (Swiss German writes "ss" for "ß", as vanilla's de_ch does).
+fn bundled_code(code: &str) -> (&str, bool) {
+    match code {
+        "ko" => ("ko_kr", false),
+        "hr" => ("hr_hr", false),
+        "de_at" => ("de_de", false),
+        "de_ch" => ("de_de", true),
+        "fr_ca" | "fr_ch" => ("fr_fr", false),
+        "es_ar" | "es_cl" | "es_ec" | "es_mx" | "es_uy" | "es_ve" => ("es_es", false),
+        code => (code, false),
+    }
+}
+
+/// Lang files crates above the engine ship (`horizon_hooks::lang`), each a list of
+/// (code, JSON) pairs. The game's entry installs them once, before any language loads.
+static CRATE_FILES: std::sync::OnceLock<&'static [&'static [(&'static str, &'static str)]]> =
+    std::sync::OnceLock::new();
+
+/// Installs the crates' lang files (`horizon_hooks::lang::engine::all()`). Only the first call
+/// counts.
+pub fn install_crate_files(files: &'static [&'static [(&'static str, &'static str)]]) {
+    let _ = CRATE_FILES.set(files);
+}
+
+/// The crates' entries for language `code` (through [`bundled_code`]'s variants) that the
+/// engine's own `horizon` file for it doesn't have: on a key both have, the engine wins.
+fn read_crate_files(files: &[&[(&str, &str)]], code: &str, map: &mut HashMap<String, String>) {
+    if files.is_empty() {
+        return;
+    }
+    let (file, swiss) = bundled_code(code);
+    let mut own = HashMap::new();
+    if let Some(bytes) = Bundled.read(&format!("assets/horizon/lang/{code}.json")) {
+        read_lang_file(&bytes, &mut own);
+    }
+    for (c, json) in files.iter().flat_map(|f| f.iter()) {
+        if *c != file {
+            continue;
+        }
+        let mut theirs = HashMap::new();
+        if swiss {
+            read_lang_file(json.replace('ß', "ss").as_bytes(), &mut theirs);
+        } else {
+            read_lang_file(json.as_bytes(), &mut theirs);
+        }
+        for (key, value) in theirs {
+            if !own.contains_key(&key) {
+                map.insert(key, value);
+            }
+        }
+    }
+}
+
 /// Horizon's own strings, compiled in so they need no prepared resources.
 struct Bundled;
 impl ResourceSource for Bundled {
    fn read(&self, path: &str) -> Option<Vec<u8>> {
-        let body = match path {
+        let code = path
+            .strip_prefix("assets/horizon/lang/")?
+            .strip_suffix(".json")?;
+        let (file, swiss) = bundled_code(code);
+        let path = format!("assets/horizon/lang/{file}.json");
+        let body = match path.as_str() {
            "assets/horizon/lang/en_us.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/en_us.json")
            }
@@ -103,10 +162,10 @@ impl ResourceSource for Bundled {
            "assets/horizon/lang/tr_tr.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/tr_tr.json")
            }
-            "assets/horizon/lang/ko_kr.json" | "assets/horizon/lang/ko.json" => {
+            "assets/horizon/lang/ko_kr.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/ko_kr.json")
            }
-            "assets/horizon/lang/hr_hr.json" | "assets/horizon/lang/hr.json" => {
+            "assets/horizon/lang/hr_hr.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/hr_hr.json")
            }
            "assets/horizon/lang/pt_pt.json" => {
@@ -331,30 +390,20 @@ impl ResourceSource for Bundled {
            "assets/horizon/lang/vec_it.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/vec_it.json")
            }
-            "assets/horizon/lang/de_de.json" | "assets/horizon/lang/de_at.json" => {
+            "assets/horizon/lang/de_de.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/de_de.json")
            }
-            // Swiss German writes "ss" for "ß", as vanilla's de_ch does.
-            "assets/horizon/lang/de_ch.json" => {
-                let de = include_str!("../../horizon-client/assets/horizon/lang/de_de.json");
-                return Some(de.replace('ß', "ss").into_bytes());
-            }
-            "assets/horizon/lang/fr_fr.json"
-            | "assets/horizon/lang/fr_ca.json"
-            | "assets/horizon/lang/fr_ch.json" => {
+            "assets/horizon/lang/fr_fr.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/fr_fr.json")
            }
-            "assets/horizon/lang/es_es.json"
-            | "assets/horizon/lang/es_ar.json"
-            | "assets/horizon/lang/es_cl.json"
-            | "assets/horizon/lang/es_ec.json"
-            | "assets/horizon/lang/es_mx.json"
-            | "assets/horizon/lang/es_uy.json"
-            | "assets/horizon/lang/es_ve.json" => {
+            "assets/horizon/lang/es_es.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/es_es.json")
            }
            _ => return None,
        };
+        if swiss {
+            return Some(body.replace('ß', "ss").into_bytes());
+        }
        Some(body.as_bytes().to_vec())
    }
    fn namespaces(&self) -> Vec<String> {
@@ -438,6 +487,16 @@ impl Language {
    /// from every namespace and every source in priority order (later sources
    /// override).
    pub fn load(sources: &[&dyn ResourceSource], code: &str) -> Self {
+        let crate_files = CRATE_FILES.get().copied().unwrap_or_default();
+        Self::load_with(sources, code, crate_files)
+    }
+
+    /// [`Language::load`] with these crates' lang files.
+    fn load_with(
+        sources: &[&dyn ResourceSource],
+        code: &str,
+        crate_files: &[&[(&str, &str)]],
+    ) -> Self {
        let mut map = HashMap::new();
        let mut codes = vec![DEFAULT];
        if code != DEFAULT {
@@ -453,12 +512,14 @@ impl Language {
            sources.iter().flat_map(|s| s.namespaces()).collect();
        for c in codes {
            for namespace in &namespaces {
-                for source in sources {
-                    let Some(bytes) = source.read(&format!("assets/{namespace}/lang/{c}.json"))
-                    else {
-                        continue;
-                    };
-                    read_lang_file(&bytes, &mut map);
+                for (i, source) in sources.iter().enumerate() {
+                    if let Some(bytes) = source.read(&format!("assets/{namespace}/lang/{c}.json")) {
+                        read_lang_file(&bytes, &mut map);
+                    }
+                    // The crates' text right after the engine's own (`Bundled`, the first source).
+                    if i == 0 && namespace == "horizon" {
+                        read_crate_files(crate_files, c, &mut map);
+                    }
                }
            }
        }
@@ -688,6 +749,43 @@ mod tests {
        );
    }

+    #[test]
+    fn a_crates_text_loads_after_the_engines_and_before_packs() {
+        static CRATE: &[(&str, &str)] = &[
+            (
+                "en_us",
+                r#"{"test.crate.hello": "Hello", "horizon.osk.close": "Shut", "test.crate.packed": "Crate"}"#,
+            ),
+            (
+                "de_de",
+                r#"{"test.crate.hello": "Grüß dich", "horizon.osk.close": "Zu"}"#,
+            ),
+            ("fr_fr", r#"{"test.crate.hello": "Bonjour"}"#),
+        ];
+        let pack = Mem(HashMap::from([(
+            "assets/horizon/lang/en_us.json".to_owned(),
+            br#"{"test.crate.packed": "Pack"}"#.to_vec(),
+        )]));
+        let load = |code| Language::load_with(&[&pack], code, &[CRATE]);
+        let en = load("en_us");
+        assert_eq!(en.get("test.crate.hello"), Some("Hello"));
+        // The engine's own file wins on a key both have; a pack wins over both.
+        assert_eq!(en.get("horizon.osk.close"), Some("Close"));
+        assert_eq!(en.get("test.crate.packed"), Some("Pack"));
+        let de = load("de_de");
+        assert_eq!(de.get("test.crate.hello"), Some("Grüß dich"));
+        assert_eq!(de.get("horizon.osk.close"), Some("Schließen"));
+        // Regional variants read their language's file, as the engine's do.
+        assert_eq!(load("de_ch").get("test.crate.hello"), Some("Grüss dich"));
+        assert_eq!(load("fr_ca").get("test.crate.hello"), Some("Bonjour"));
+        // A language the crate lacks falls back to its English.
+        assert_eq!(load("pl_pl").get("test.crate.hello"), Some("Hello"));
+        // Without crate files, nothing changes.
+        let plain = Language::load_with(&[&pack], "de_de", &[]);
+        assert_eq!(plain.get("test.crate.hello"), None);
+        assert_eq!(plain.len() + 1, de.len());
+    }
+
    #[test]
    fn a_scoped_language_is_the_calling_threads_and_reports_what_it_lacks() {
        let empty = Mem(HashMap::new());
@@ -739,6 +837,20 @@ mod tests {
        std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("../horizon-client/assets/horizon/lang")
    }
+    /// The crates whose own lang files the game loads (`crates/<name>/assets/lang`,
+    /// registered through `horizon_hooks::lang`), with that folder.
+    fn crate_lang_dirs() -> Vec<(String, std::path::PathBuf)> {
+        let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
+        let mut dirs: Vec<_> = std::fs::read_dir(&crates)
+            .unwrap()
+            .flatten()
+            .map(|e| (e.file_name().into_string().unwrap(), e.path()))
+            .map(|(name, path)| (name, path.join("assets/lang")))
+            .filter(|(_, dir)| dir.join("en_us.json").is_file())
+            .collect();
+        dirs.sort();
+        dirs
+    }
    /// The keys of a flat bundled file in file order, duplicates included (a map
    /// would keep only the last of two equal keys). One `"key": "value"` per line.
    fn file_keys(body: &str) -> Vec<String> {
@@ -776,11 +888,33 @@ mod tests {

    #[test]
    fn bundled_files_are_served_and_have_no_stale_or_repeated_keys() {
-        let dir = bundled_dir();
+        let engine = check_lang_dir(&bundled_dir(), true);
+        assert!(
+            engine.1 >= 7,
+            "found {} bundled lang files in {}",
+            engine.1,
+            bundled_dir().display()
+        );
+        // A crate's files pass the same checks. Its keys are its own: on a key the engine's
+        // files also have, the engine's text would win and hide the crate's.
+        for (name, dir) in crate_lang_dirs() {
+            let (en, _) = check_lang_dir(&dir, false);
+            for key in en.keys() {
+                assert!(
+                    !engine.0.contains_key(key),
+                    "{name}: {key} is also the engine's"
+                );
+            }
+        }
+    }
+
+    /// The checks every lang folder passes: flat maps, no repeated key, no key en_us lacks, the
+    /// same placeholders as English, no empty text. Its en_us and how many files it has.
+    fn check_lang_dir(dir: &std::path::Path, bundled: bool) -> (HashMap<String, String>, usize) {
        let en_body = std::fs::read_to_string(dir.join("en_us.json")).unwrap();
        let en: HashMap<String, String> = serde_json::from_str(&en_body).unwrap();
        let mut seen = 0;
-        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
+        for entry in std::fs::read_dir(dir).unwrap().flatten() {
            let name = entry.file_name().into_string().unwrap();
            let Some(code) = name.strip_suffix(".json") else {
                continue;
@@ -789,7 +923,7 @@ mod tests {
            // A file that Bundled::read does not name is never loaded.
            let path = format!("assets/horizon/lang/{name}");
            assert!(
-                Bundled.read(&path).is_some(),
+                !bundled || Bundled.read(&path).is_some(),
                "{name} is not served by Bundled"
            );
            let body = std::fs::read_to_string(entry.path()).unwrap();
@@ -815,11 +949,7 @@ mod tests {
                assert!(!value.trim().is_empty(), "{code}: {key} is empty");
            }
        }
-        assert!(
-            seen >= 7,
-            "found {seen} bundled lang files in {}",
-            dir.display()
-        );
+        (en, seen)
    }

    #[test]
@@ -834,10 +964,10 @@ mod tests {
                }
            }
        }
-        let en: HashMap<String, String> = serde_json::from_str(
-            &std::fs::read_to_string(bundled_dir().join("en_us.json")).unwrap(),
-        )
-        .unwrap();
+        let english = |dir: &std::path::Path| -> HashMap<String, String> {
+            serde_json::from_str(&std::fs::read_to_string(dir.join("en_us.json")).unwrap()).unwrap()
+        };
+        let mut en = english(&bundled_dir());
        let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
        let mut files = Vec::new();
        for krate in [
@@ -847,6 +977,11 @@ mod tests {
        ] {
            rust_files(&crates.join(krate).join("src"), &mut files);
        }
+        // A crate that ships lang files names its keys in its own sources.
+        for (name, dir) in crate_lang_dirs() {
+            en.extend(english(&dir));
+            rust_files(&crates.join(name).join("src"), &mut files);
+        }
        assert!(files.len() > 100, "found only {} sources", files.len());
        let mut found = 0;
        for file in files {
@@ -529,10 +529,13 @@ impl Team {
            None => t,
        }
    }
-    /// `PlayerTeam.getFormattedDisplayName`.
+    /// `PlayerTeam.getFormattedDisplayName`: the display name in the team's
+    /// `displayNameStyle`, which its constructor makes the team's name on hover
+    /// (`ShowText`) and as insertion.
    pub fn formatted_display_name(&self) -> Text {
        let inner = hover_name(comp_text(&self.display_name), &self.name).with_style(&Style {
            click: None,
+            insertion: Some(self.name.clone()),
            ..Style::default()
        });
        self.apply_color(bracketed(inner))
@@ -1411,6 +1414,21 @@ fn finish(node: &mut serde_json::Map<String, Value>, extra: Vec<Comp>) -> Comp {
 #[cfg(test)]
 mod tests {
    use super::*;
+    /// #14279: `PlayerTeam`'s `displayNameStyle` puts the team's name on hover
+    /// and as insertion; `getFormattedDisplayName` brackets the name in it.
+    #[test]
+    fn a_teams_formatted_name_inserts_the_team_name() {
+        let team = Team::new("reds");
+        let c = team.formatted_display_name().component();
+        assert_eq!(c["translate"], "chat.square_brackets");
+        let inner = &c["with"][0];
+        assert_eq!(inner["text"], "reds");
+        assert_eq!(inner["insertion"], "reds");
+        assert_eq!(inner["hover_event"]["action"], "show_text");
+        // `{"text":"reds"}` or its short form `"reds"`: the same component.
+        let value = &inner["hover_event"]["value"];
+        assert!(value == "reds" || value["text"] == "reds", "{value}");
+    }

    fn board() -> Scoreboard {
        let mut sb = Scoreboard::default();
@@ -320,7 +320,12 @@ pub fn java_hash_order(
        "FallFlying",
        "sleeping_pos",
        "Brain",
+        "last_hurt_by_player",
+        "last_hurt_by_player_memory_time",
+        "last_hurt_by_mob",
+        "ticks_since_last_hurt_by_mob",
        "equipment",
+        "locator_bar_icon",
        // ArmorStand.
        "Invisible",
        "Small",
@@ -337,6 +342,12 @@ pub fn java_hash_order(
        "immovable",
        "description",
        "hide_description",
+        // Interaction.addAdditionalSaveData.
+        "width",
+        "height",
+        "attack",
+        "interaction",
+        "response",
    ];
    // BlockEntity.saveMetadata writes the position after the entity's data.
    const AFTER: &[&str] = &["x", "y", "z"];
@@ -436,6 +447,20 @@ mod tests {
        );
    }
    #[test]
+    fn interaction_compound_orders_width_before_interaction_in_shared_bucket() {
+        // `width` and `interaction` share a bucket at every table size;
+        // `Interaction.addAdditionalSaveData` writes `width` first.
+        let tag = parse_snbt(
+            r#"{Air:300s,Fire:0s,Invulnerable:0b,Motion:[0.0d,0.0d,0.0d],OnGround:0b,PortalCooldown:0,Pos:[4.5d,100.0d,4.5d],Rotation:[0.0f,0.0f],UUID:[I;66,0,0,1],fall_distance:0.0d,height:1.25f,interaction:{player:[I;1,2,3,4],timestamp:9L},response:0b,width:1.0f}"#,
+        )
+        .unwrap()
+        .0;
+        assert_eq!(
+            pretty(&tag).plain(),
+            "{Motion: [0.0d, 0.0d, 0.0d], Invulnerable: 0b, fall_distance: 0.0d, Air: 300s, OnGround: 0b, PortalCooldown: 0, Rotation: [0.0f, 0.0f], Pos: [4.5d, 100.0d, 4.5d], response: 0b, Fire: 0s, width: 1.0f, interaction: {player: [I; 1, 2, 3, 4], timestamp: 9L}, UUID: [I; 66, 0, 0, 1], height: 1.25f}",
+        );
+    }
+    #[test]
    fn compact_form_matches_vanilla() {
        assert_eq!(
            rt("{b:1b,a:\"x\",c:[1,2],d:1.5f,e:2d,f:3L,g:4s}"),
@@ -282,17 +282,20 @@ impl Text {
    pub fn push(&mut self, other: impl Into<Text>) {
        let other = other.into();
        let sibling = other.component();
-        let mut root = if self.spans.is_empty() && self.source.is_none() {
-            json!({ "text": "" })
-        } else {
-            let c = self.component();
-            if STYLE_KEYS.iter().any(|k| c.get(*k).is_some()) {
-                json!({ "text": "", "extra": [c] })
-            } else {
-                c
-            }
+        // The tree is appended to in place: cloning all of it on every append made a component
+        // with N siblings (a server's chat or MOTD "extra") cost N^2.
+        let root = match self.source.take() {
+            None if self.spans.is_empty() => std::sync::Arc::new(json!({ "text": "" })),
+            None => std::sync::Arc::new(self.component()),
+            Some(c) => c,
        };
-        if let Value::Object(o) = &mut root {
+        let mut root = if STYLE_KEYS.iter().any(|k| root.get(*k).is_some()) {
+            let c = std::sync::Arc::try_unwrap(root).unwrap_or_else(|c| (*c).clone());
+            std::sync::Arc::new(json!({ "text": "", "extra": [c] }))
+        } else {
+            root
+        };
+        if let Value::Object(o) = std::sync::Arc::make_mut(&mut root) {
            match o.get_mut("extra") {
                Some(Value::Array(a)) => a.push(sibling),
                _ => {
@@ -300,7 +303,7 @@ impl Text {
                }
            }
        }
-        self.source = Some(root.into());
+        self.source = Some(root);
        self.spans.extend(other.spans);
    }
    /// Apply `style` underneath every span (MutableComponent.withStyle on a parent).
@@ -671,11 +674,22 @@ pub fn legacy_format(style: &Style, code: char, reset: &Style) -> Style {
    s
 }

+/// The most spans one translation expands to. Vanilla's `TranslatableContents.decompose` keeps
+/// references to its arguments, so its cost stays linear in the input; copying them here makes
+/// nested `%1$s` templates multiply (`k` references nested `D` deep: `k^D` copies), and a server's
+/// `fallback` template is any text it likes.
+const MAX_TRANSLATION_SPANS: usize = 1 << 15;
+/// The most text one translation expands to: one long argument referenced many times multiplies
+/// bytes, not spans.
+const MAX_TRANSLATION_BYTES: usize = 1 << 22;
+
 /// TranslatableContents.decomposeTemplate: `%s` takes the next argument,
 /// `%n$s` a numbered one and `%%` is a percent sign. Malformed templates are
-/// shown verbatim.
+/// shown verbatim, and so is one that would expand past [`MAX_TRANSLATION_SPANS`] or
+/// [`MAX_TRANSLATION_BYTES`].
 pub fn format_translation(template: &str, args: &[Text]) -> Text {
    let mut out = Text::default();
+    let mut bytes = 0usize;
    let mut literal = String::new();
    let mut next = 0usize;
    let chars: Vec<char> = template.chars().collect();
@@ -725,6 +739,14 @@ pub fn format_translation(template: &str, args: &[Text]) -> Text {
                let Some(arg) = args.get(index) else {
                    return Text::literal(template);
                };
+                bytes = bytes
+                    .saturating_add(literal.len())
+                    .saturating_add(arg.spans.iter().map(|s| s.text.len()).sum());
+                if out.spans.len().saturating_add(arg.spans.len()) >= MAX_TRANSLATION_SPANS
+                    || bytes > MAX_TRANSLATION_BYTES
+                {
+                    return Text::literal(template);
+                }
                if !literal.is_empty() {
                    out.spans.push(Span {
                        text: std::mem::take(&mut literal),
@@ -750,6 +772,42 @@ pub fn format_translation(template: &str, args: &[Text]) -> Text {
 mod tests {
    use super::*;
    #[test]
+    fn appending_builds_the_same_tree_in_linear_time() {
+        // A styled text is wrapped once, so its style doesn't reach what follows; a plain one
+        // takes the siblings itself; a copy taken before an append keeps its own tree.
+        let mut styled = Text::literal("a").with_style(&Style {
+            bold: Some(true),
+            ..Style::default()
+        });
+        styled.push(Text::literal("b"));
+        let before = styled.clone();
+        styled.push(Text::literal("c"));
+        assert_eq!(
+            styled.component(),
+            json!({"text": "", "extra": [{"text": "a", "bold": true}, {"text": "b"}, {"text": "c"}]})
+        );
+        assert_eq!(
+            before.component(),
+            json!({"text": "", "extra": [{"text": "a", "bold": true}, {"text": "b"}]})
+        );
+        let mut plain = Text::default();
+        plain.push(Text::literal("x"));
+        plain.push(Text::literal("y"));
+        assert_eq!(
+            plain.component(),
+            json!({"text": "", "extra": [{"text": "x"}, {"text": "y"}]})
+        );
+        // 20 000 siblings, as a server's chat may carry: 76 s before, as each append cloned the
+        // whole tree.
+        let started = std::time::Instant::now();
+        let mut long = Text::default();
+        for _ in 0..20_000 {
+            long.push(Text::literal("a"));
+        }
+        assert_eq!(long.spans.len(), 20_000);
+        assert!(started.elapsed() < std::time::Duration::from_secs(5));
+    }
+    #[test]
    fn click_events_serialize_and_inherit_as_one_style_field() {
        for (event, json) in [
            (
@@ -98,6 +98,7 @@ actions! {
    Emote, "key.emote", Some(KeyCode::KeyB);
    HotbarPrevious, "pad.hotbarPrevious", None;
    HotbarNext, "pad.hotbarNext", None;
+    Radial, "pad.radial", None;
 }

 impl Action {
@@ -253,6 +253,17 @@ impl Activity {
 /// Horizon's pad-only actions (no vanilla key mapping).
 pub const HOTBAR_PREVIOUS: &str = "pad.hotbarPrevious";
 pub const HOTBAR_NEXT: &str = "pad.hotbarNext";
+/// Held, opens the radial menu (`radial.rs`).
+pub const RADIAL: &str = "pad.radial";
+
+mod radial_file;
+pub use radial_file::{RadialMode, RadialStick, opener_refused};
+
+/// The `bindLayout` the settings file is written in. 1: the defaults of the binds list as they
+/// are; 2: the radial menu's opener resolved against the player's own buttons.
+const BIND_LAYOUT: u32 = 2;
+/// The layout from which the file, not the default, says where the opener is.
+const OPENER_LAYOUT: u32 = 2;

 /// Bindable actions and their default buttons: vanilla key mappings (the
 /// game acts as their default key) and Horizon's pad-only actions. Start is
@@ -271,6 +282,7 @@ pub const ACTIONS: &[(&str, Option<Button>)] = &[
    ("key.togglePerspective", Some(Button::Select)),
    ("key.pickItem", Some(Button::DPadLeft)),
    ("key.chat", Some(Button::DPadUp)),
+    (RADIAL, Some(Button::DPadRight)),
    ("key.advancements", None),
    ("key.playerlist", None),
    ("key.command", None),
@@ -303,11 +315,14 @@ pub enum Route {
    HotbarStep {
        next: bool,
    },
+    Radial,
    /// Held, or flipped when the pad's toggle sneak is on.
    Sneak,
    Screenshot,
    SmoothCamera,
    Fullscreen,
+    /// F3's debug screen, shown or hidden as F3 alone does.
+    DebugOverlay,
    /// Does nothing by itself: what reads it asks whether the button is held
    /// (`Minecraft.handleKeybinds`' toolbar keys, held with a hotbar key).
    Held,
@@ -320,10 +335,12 @@ pub fn route(action: &str) -> Option<Route> {
    match action {
        HOTBAR_PREVIOUS => Some(Route::HotbarStep { next: false }),
        HOTBAR_NEXT => Some(Route::HotbarStep { next: true }),
+        RADIAL => Some(Route::Radial),
        "key.sneak" => Some(Route::Sneak),
        "key.screenshot" => Some(Route::Screenshot),
        "key.smoothCamera" => Some(Route::SmoothCamera),
        "key.fullscreen" => Some(Route::Fullscreen),
+        "key.debug.overlay" => Some(Route::DebugOverlay),
        "key.saveToolbarActivator" | "key.loadToolbarActivator" => Some(Route::Held),
        _ => {
            let default = crate::keybinds::KeyBinds::default_of(action);
@@ -334,12 +351,16 @@ pub fn route(action: &str) -> Option<Route> {
    }
 }

+/// The radial menu's opener, as the binds list and the gameplay guide name it.
+pub const RADIAL_CAPTION: &str = "horizon.pad.action.radial";
+
 /// An action's name in the binds list: vanilla's translation key, or
 /// Horizon's own English for the pad-only actions.
 pub fn action_caption(action: &str) -> &str {
    match action {
        HOTBAR_PREVIOUS => "Hotbar: Previous Slot",
        HOTBAR_NEXT => "Hotbar: Next Slot",
+        RADIAL => RADIAL_CAPTION,
        other => other,
    }
 }
@@ -654,6 +675,21 @@ pub struct PadSettings {
    pub repeat_interval: f32,
    /// Action name -> button, `None` for unbound; missing means the default.
    bindings: BTreeMap<&'static str, Option<Button>>,
+    /// The radial menu's pages.
+    pub radial: crate::radial::Pages,
+    /// Whether the radial menu's opener is held or pressed once.
+    pub radial_mode: RadialMode,
+    /// The stick that selects in it.
+    pub radial_stick: RadialStick,
+    /// Lines this game doesn't read (a newer Horizon's settings, an action it doesn't have, a
+    /// button it doesn't know), kept as they were so a save here loses nothing.
+    extra: Vec<(String, String)>,
+    /// The newest `bindLayout` the file has been written in: this game's, or a newer Horizon's,
+    /// kept so that one doesn't resolve its file again as older than it is.
+    bind_layout: u32,
+    /// The opener last used with each stick (`RadialStick::ALL` order), so stepping the Selects
+    /// With row and back gives each stick's own opener again.
+    openers: radial_file::StickOpeners,
 }
 impl Default for PadSettings {
    fn default() -> Self {
@@ -680,6 +716,12 @@ impl Default for PadSettings {
            repeat_delay: 0.35,
            repeat_interval: 0.09,
            bindings: BTreeMap::new(),
+            radial: Default::default(),
+            radial_mode: RadialMode::Hold,
+            radial_stick: RadialStick::Right,
+            extra: Vec::new(),
+            bind_layout: BIND_LAYOUT,
+            openers: radial_file::StickOpeners::default(),
        }
    }
 }
@@ -706,6 +748,7 @@ impl PadSettings {
    }
    pub fn parse(text: &str) -> Self {
        let mut s = Self::default();
+        let mut saved_opener = None;
        for line in text.lines() {
            let Some((key, value)) = line.split_once(':') else {
                continue;
@@ -754,22 +797,85 @@ impl PadSettings {
                "scrollSpeed" => s.scroll_speed = bounded(s.scroll_speed, 1.0, 36.0),
                "repeatDelay" => s.repeat_delay = bounded(s.repeat_delay, 0.1, 1.0),
                "repeatInterval" => s.repeat_interval = bounded(s.repeat_interval, 0.03, 0.3),
+                "radialMode" => s.radial_mode = RadialMode::parse(value),
+                "radialStick" => s.radial_stick = RadialStick::parse(value),
+                // Read after the loop, from the whole text.
+                "bindLayout" => {}
+                // The radial menu's pages (`radial::Pages::parse`).
+                other if other.starts_with("radial_") || other == crate::radial::LAYOUT_KEY => {}
                other => {
-                    if let Some(action) = other.strip_prefix("bind_") {
-                        let button = if value == "none" {
-                            Some(None)
-                        } else {
-                            Button::parse(value).map(Some)
-                        };
-                        if let Some(button) = button {
-                            s.bind(action, button);
-                        }
+                    let known = other
+                        .strip_prefix("bind_")
+                        .filter(|action| ACTIONS.iter().any(|a| a.0 == *action));
+                    let button = if value == "none" {
+                        Some(None)
+                    } else {
+                        Button::parse(value).map(Some)
+                    };
+                    match (known, button) {
+                        // The opener once the selecting stick is known.
+                        (Some(RADIAL), Some(button)) => saved_opener = Some(button),
+                        (Some(action), Some(button)) => s.bind(action, button),
+                        _ => s.extra.push((other.to_owned(), value.to_owned())),
                    }
                }
            }
        }
-        // A file from before these defaults: its player's buttons stay where they were.
-        if !text.is_empty() && !text.lines().any(|line| line.starts_with("bindLayout:")) {
+        // An opener on a button it can't be with this stick reads as never saved.
+        let refused_opener = match saved_opener {
+            Some(Some(b)) if opener_refused(s.radial_stick, b) => true,
+            Some(button) => {
+                s.bind(RADIAL, button);
+                false
+            }
+            None => false,
+        };
+        if let Some(pages) = crate::radial::Pages::parse(
+            text.lines()
+                .filter_map(|line| line.split_once(':'))
+                .map(|(key, value)| (key.trim(), value.trim())),
+        ) {
+            s.radial = pages;
+        }
+        let lines = || text.lines().map(str::trim);
+        let saved = |action: &str| {
+            let prefix = format!("bind_{action}:");
+            lines().any(|line| line.starts_with(&prefix))
+        };
+        // The layout the file was written in; none in a file from before these defaults.
+        let layout = lines()
+            .find_map(|line| line.strip_prefix("bindLayout:"))
+            .map(|value| value.trim().parse::<u32>().unwrap_or(0));
+        s.bind_layout = layout.map_or(BIND_LAYOUT, |layout| layout.max(BIND_LAYOUT));
+        // Once, for a file from before the radial menu's opener, or one with the opener on a
+        // button it can no longer be: a button the player bound by hand stays theirs, and the
+        // opener's default doesn't take it. From then on the file says where the opener is, and
+        // a conflict made since stays shown in the binds list.
+        let before_opener = layout.is_none_or(|layout| layout < OPENER_LAYOUT);
+        if !text.is_empty() && (refused_opener || (before_opener && !saved(RADIAL))) {
+            let default_opener = ACTIONS
+                .iter()
+                .find(|(action, _)| *action == RADIAL)
+                .and_then(|(_, button)| *button);
+            let taken = s.bindings.iter().any(|(action, button)| {
+                *action != RADIAL && button.is_some() && *button == default_opener
+            });
+            if taken {
+                s.bindings.insert(RADIAL, None);
+            }
+        }
+        // The default too can be under the selecting thumb (D-pad Right, the left stick
+        // selecting): no button opens the menu until the player picks one.
+        if s.binding(RADIAL)
+            .is_some_and(|b| opener_refused(s.radial_stick, b))
+        {
+            s.bindings.insert(RADIAL, None);
+        }
+        // A file from before these defaults: its player's buttons stay where they were, and
+        // nothing they saved shares a button with the radial menu's opener. They can bind one
+        // in the binds list.
+        if !text.is_empty() && layout.is_none() {
+            s.bindings.entry(RADIAL).or_insert(None);
            for (action, button) in [
                ("key.drop", Button::East),
                ("key.togglePerspective", Button::DPadUp),
@@ -778,10 +884,7 @@ impl PadSettings {
                ("key.advancements", Button::DPadDown),
            ] {
                // A button saved by hand stays, even one that's now this action's default.
-                if !text
-                    .lines()
-                    .any(|line| line.starts_with(&format!("bind_{action}:")))
-                {
+                if !saved(action) {
                    s.bindings.entry(action).or_insert(Some(button));
                }
            }
@@ -822,7 +925,25 @@ impl PadSettings {
            "playInBackground:{}\n",
            bool_text(self.play_in_background)
        ));
-        text.push_str("bindLayout:1\n");
+        text.push_str(&format!(
+            "radialMode:{}\nradialStick:{}\n",
+            self.radial_mode.name(),
+            self.radial_stick.name()
+        ));
+        text.push_str(&format!("bindLayout:{}\n", self.bind_layout));
+        for (key, value) in &self.extra {
+            // A button this game didn't know, for an action the player has bound here since.
+            let rebound = key
+                .strip_prefix("bind_")
+                .is_some_and(|action| self.bindings.contains_key(action));
+            if !rebound {
+                text.push_str(&format!("{key}:{value}\n"));
+            }
+        }
+        // The default pages aren't written: they can improve for a player who never changed them.
+        if self.radial != crate::radial::Pages::default() {
+            text.push_str(&self.radial.serialize());
+        }
        text
    }
    pub fn default_of(action: &str) -> Option<Button> {
@@ -835,11 +956,15 @@ impl PadSettings {
            None => Self::default_of(action),
        }
    }
-    /// Bind an action (`None` unbinds); unknown actions are ignored.
+    /// Put `action` on `button`, or unbind it. An unknown action, or a button it can't take
+    /// (`can_bind`), changes nothing.
    pub fn bind(&mut self, action: &str, button: Option<Button>) {
        let Some((name, default)) = ACTIONS.iter().find(|a| a.0 == action) else {
            return;
        };
+        if button.is_some_and(|b| !self.can_bind(action, b)) {
+            return;
+        }
        if button == *default {
            self.bindings.remove(name);
        } else {
@@ -1440,6 +1565,14 @@ pub enum Rumble {
        radius: f32,
    },
    Totem,
+    /// The radial menu's stick reached a slot that would run: a tick.
+    RadialSlot,
+    /// The radial menu's page turned: a shorter tick.
+    RadialPage,
+    /// The page turn went round an end: a second tick after the first.
+    RadialWrap,
+    /// A release ran nothing after something had been selected: a soft buzz.
+    RadialNothing,
 }
 impl From<crate::input_source::Feedback> for Rumble {
    fn from(event: crate::input_source::Feedback) -> Self {
@@ -1459,6 +1592,7 @@ pub struct Pulse {
    pub weak: f32,
    pub millis: u32,
 }
+use crate::radial::{RADIAL_NOTHING, RADIAL_PAGE_TICK, RADIAL_TICK};
 impl Rumble {
    pub fn name(self) -> &'static str {
        match self {
@@ -1466,6 +1600,10 @@ impl Rumble {
            Rumble::BlockBroken => "block",
            Rumble::Explosion { .. } => "explosion",
            Rumble::Totem => "totem",
+            Rumble::RadialSlot => "radial",
+            Rumble::RadialPage => "radial_page",
+            Rumble::RadialWrap => "radial_wrap",
+            Rumble::RadialNothing => "radial_nothing",
        }
    }
    /// The pulse, or `None` when it is too faint to feel.
@@ -1492,6 +1630,9 @@ impl Rumble {
                    millis: 350,
                })
            }
+            Rumble::RadialSlot => Some(RADIAL_TICK),
+            Rumble::RadialPage | Rumble::RadialWrap => Some(RADIAL_PAGE_TICK),
+            Rumble::RadialNothing => Some(RADIAL_NOTHING),
            Rumble::Totem => Some(Pulse {
                strong: 0.7,
                weak: 0.7,
@@ -1513,6 +1654,10 @@ impl Rumble {
        };
        match self {
            Rumble::BlockBroken => vec![Pulse { millis: 35, ..p }],
+            Rumble::RadialSlot
+            | Rumble::RadialPage
+            | Rumble::RadialWrap
+            | Rumble::RadialNothing => vec![p],
            Rumble::Hurt(_) => {
                let tail = p.millis.saturating_sub(50) / 2;
                vec![step(1.0, 50), step(0.55, tail), step(0.25, tail)]
@@ -1873,7 +2018,55 @@ bind_key.hotbar.2:north
        let odd = PadSettings::parse(
            "lookSensitivity:NaN\nbind_key.nope:south\nbind_key.jump:x9\nbindLayout:1\n",
        );
-        assert_eq!(odd, PadSettings::default());
+        assert_eq!(
+            odd.look_sensitivity,
+            PadSettings::default().look_sensitivity
+        );
+        assert_eq!(odd.binding("key.jump"), Some(Button::South));
+        assert_eq!(odd.actions_of(Button::South), ["key.jump"]);
+    }
+
+    #[test]
+    fn lines_this_game_doesnt_read_survive_a_save() {
+        // A newer Horizon's setting, an action this game doesn't have, a button it doesn't know.
+        let text =
+            "bindLayout:2\nhapticStrength:0.4\nbind_horizon:dash:south\nbind_key.jump:paddle1\n";
+        let s = PadSettings::parse(text);
+        assert_eq!(
+            s.binding("key.jump"),
+            Some(Button::South),
+            "the default meanwhile"
+        );
+        let saved = s.serialize();
+        for line in [
+            "hapticStrength:0.4\n",
+            "bind_horizon:dash:south\n",
+            "bind_key.jump:paddle1\n",
+        ] {
+            assert!(saved.contains(line), "{line} lost from\n{saved}");
+        }
+        assert_eq!(PadSettings::parse(&saved), s);
+        // Bound here since, the action's own line is the one written.
+        let mut s = s;
+        s.bind("key.jump", Some(Button::West));
+        let saved = s.serialize();
+        assert!(!saved.contains("paddle1"), "{saved}");
+        assert_eq!(
+            PadSettings::parse(&saved).binding("key.jump"),
+            Some(Button::West)
+        );
+    }
+
+    #[test]
+    fn a_newer_bind_layout_is_kept() {
+        let newer = BIND_LAYOUT + 1;
+        let s = PadSettings::parse(&format!("bindLayout:{newer}\nvibration:false\n"));
+        assert!(s.serialize().contains(&format!("bindLayout:{newer}\n")));
+        let s = PadSettings::parse("bindLayout:1\nvibration:false\n");
+        assert!(
+            s.serialize()
+                .contains(&format!("bindLayout:{BIND_LAYOUT}\n"))
+        );
    }

    #[test]
@@ -0,0 +1,354 @@
+//! The radial menu's settings in the controller file (`horizon-controller.txt`): how its opener
+//! holds it open, the stick that selects, which buttons the opener may be with that stick, and the
+//! opener each stick had this session. `PadSettings::parse` and `serialize` read and write their
+//! lines (`radialMode`, `radialStick`, `bind_pad.radial`).
+use super::{Button, PadSettings, RADIAL};
+
+/// The buttons under the right thumb, which steers the right stick.
+const RIGHT_THUMB: [Button; 4] = [
+    Button::South,
+    Button::West,
+    Button::North,
+    Button::RightStick,
+];
+/// The buttons under the left thumb, which steers the left stick.
+const LEFT_THUMB: [Button; 5] = [
+    Button::DPadUp,
+    Button::DPadDown,
+    Button::DPadLeft,
+    Button::DPadRight,
+    Button::LeftStick,
+];
+
+/// Whether the radial menu's opener can't be `button` while `stick` selects. One rule: the opener
+/// is never under a thumb that selects (holding it and steering are two jobs for one thumb), nor
+/// B, which cancels the open menu. So with the right stick the face buttons and R3 go, with the
+/// left the D-pad and L3, with either both; a bumper, a trigger and View are always free, and
+/// with a bumper for the opener the other bumper turns the pages.
+pub fn opener_refused(stick: RadialStick, button: Button) -> bool {
+    button == Button::East
+        || (stick != RadialStick::Left && RIGHT_THUMB.contains(&button))
+        || (stick != RadialStick::Right && LEFT_THUMB.contains(&button))
+}
+
+/// How the radial menu's opener holds it open.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum RadialMode {
+    /// Held: letting go runs what is selected.
+    #[default]
+    Hold,
+    /// A press opens it; A or the opener again runs what is selected, B closes it.
+    Toggle,
+}
+impl RadialMode {
+    pub const ALL: [Self; 2] = [Self::Hold, Self::Toggle];
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Hold => "hold",
+            Self::Toggle => "toggle",
+        }
+    }
+    pub fn parse(value: &str) -> Self {
+        Self::ALL
+            .into_iter()
+            .find(|mode| mode.name() == value)
+            .unwrap_or_default()
+    }
+}
+
+/// The stick that selects in the radial menu.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum RadialStick {
+    #[default]
+    Right,
+    Left,
+    /// The last stick to lean past the select tilt.
+    Either,
+}
+impl RadialStick {
+    pub const ALL: [Self; 3] = [Self::Right, Self::Left, Self::Either];
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Right => "right",
+            Self::Left => "left",
+            Self::Either => "either",
+        }
+    }
+    pub fn parse(value: &str) -> Self {
+        Self::ALL
+            .into_iter()
+            .find(|stick| stick.name() == value)
+            .unwrap_or_default()
+    }
+}
+
+/// The opener each stick had, for this session: what the player stepped through, not a setting,
+/// so it is neither saved nor compared.
+#[derive(Clone, Copy, Debug, Default)]
+pub(super) struct StickOpeners([Option<Button>; 3]);
+impl PartialEq for StickOpeners {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
+impl StickOpeners {
+    fn slot(&mut self, stick: RadialStick) -> &mut Option<Button> {
+        let at = RadialStick::ALL
+            .iter()
+            .position(|s| *s == stick)
+            .unwrap_or(0);
+        &mut self.0[at]
+    }
+}
+
+impl PadSettings {
+    /// Whether `button` can be bound to `action`: anything but the radial menu's opener under
+    /// a thumb that selects, or on B (`opener_refused`).
+    pub fn can_bind(&self, action: &str, button: Button) -> bool {
+        action != RADIAL || !opener_refused(self.radial_stick, button)
+    }
+    /// The stick the radial menu selects with. An opener under the thumb that now selects is
+    /// unbound, and its row in the radial page says so. An unbound opener then takes the one this
+    /// stick had before in this session, or else its default where nothing else has it (D-pad
+    /// Right, back on the right stick).
+    pub fn set_radial_stick(&mut self, stick: RadialStick) {
+        let was = self.radial_stick;
+        *self.openers.slot(was) = self.binding(RADIAL);
+        self.radial_stick = stick;
+        if self
+            .binding(RADIAL)
+            .is_some_and(|b| opener_refused(stick, b))
+        {
+            self.bindings.insert(RADIAL, None);
+        }
+        if self.binding(RADIAL).is_some() {
+            return;
+        }
+        // The player's own, shared or not: they put it there.
+        if let Some(own) = self
+            .openers
+            .slot(stick)
+            .filter(|b| !opener_refused(stick, *b))
+        {
+            self.bind(RADIAL, Some(own));
+            return;
+        }
+        let default = Self::default_of(RADIAL);
+        let free =
+            default.is_some_and(|d| !opener_refused(stick, d) && self.actions_of(d).is_empty());
+        if free {
+            self.bindings.remove(RADIAL);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::Rumble;
+    use super::*;
+
+    #[test]
+    fn a_new_player_holds_d_pad_right_for_the_radial_menu() {
+        for s in [PadSettings::default(), PadSettings::parse("")] {
+            assert_eq!(s.binding(RADIAL), Some(Button::DPadRight));
+            assert!(!s.conflicts(RADIAL));
+        }
+        let s = PadSettings::parse(&PadSettings::default().serialize());
+        assert_eq!(s, PadSettings::default());
+    }
+
+    #[test]
+    fn a_button_bound_by_hand_stays_with_it_over_the_openers_default() {
+        let s = PadSettings::parse("bindLayout:1\nbind_key.playerlist:right\n");
+        assert_eq!(s.binding("key.playerlist"), Some(Button::DPadRight));
+        assert_eq!(s.binding(RADIAL), None);
+        assert!(!s.conflicts("key.playerlist"));
+        assert_eq!(PadSettings::parse(&s.serialize()), s);
+    }
+
+    #[test]
+    fn a_saved_opener_stays_where_it_was_saved() {
+        let s =
+            PadSettings::parse("bindLayout:1\nbind_pad.radial:right\nbind_key.playerlist:right\n");
+        assert_eq!(s.binding(RADIAL), Some(Button::DPadRight));
+    }
+
+    #[test]
+    fn a_conflict_made_since_the_migration_stays_after_a_restart() {
+        // Bound in the binds list onto the opener's button: both stay, and the list marks it.
+        let mut s = PadSettings::default();
+        s.bind("key.playerlist", Some(Button::DPadRight));
+        let text = s.serialize();
+        assert!(text.contains("bindLayout:2"));
+        let read = PadSettings::parse(&text);
+        assert_eq!(read.binding(RADIAL), Some(Button::DPadRight));
+        assert!(read.conflicts(RADIAL));
+        assert_eq!(read, s);
+        // The same, hand-written with spaces around the lines.
+        let read = PadSettings::parse("  bindLayout:2\n  bind_key.playerlist:right\n");
+        assert_eq!(read.binding(RADIAL), Some(Button::DPadRight));
+    }
+
+    #[test]
+    fn a_layout_one_file_resolves_the_opener_once() {
+        let s = PadSettings::parse("bind_key.chat:up\n bindLayout:1\nbind_key.playerlist:right\n");
+        assert_eq!(s.binding(RADIAL), None, "the player's own button wins");
+        assert_eq!(s.binding("key.playerlist"), Some(Button::DPadRight));
+        assert_eq!(s.binding("key.chat"), Some(Button::DPadUp));
+        let text = s.serialize();
+        assert!(text.contains("bindLayout:2\n") && text.contains("bind_pad.radial:none\n"));
+        assert_eq!(PadSettings::parse(&text), s);
+        // Without a conflict the opener keeps its default.
+        let s = PadSettings::parse("bindLayout:1\nvibration:false\n");
+        assert_eq!(s.binding(RADIAL), Some(Button::DPadRight));
+        // A line with leading spaces is still a saved opener.
+        let s =
+            PadSettings::parse("bindLayout:1\n bind_pad.radial:right\nbind_key.playerlist:right\n");
+        assert_eq!(s.binding(RADIAL), Some(Button::DPadRight));
+    }
+
+    #[test]
+    fn the_opener_never_goes_under_the_selecting_thumb_nor_on_b() {
+        use Button as B;
+        let face = [B::South, B::West, B::North, B::RightStick];
+        let dpad = [
+            B::DPadUp,
+            B::DPadDown,
+            B::DPadLeft,
+            B::DPadRight,
+            B::LeftStick,
+        ];
+        for stick in RadialStick::ALL {
+            let mut s = PadSettings::default();
+            s.set_radial_stick(stick);
+            for button in Button::ALL {
+                let refused = button == B::East
+                    || (stick != RadialStick::Left && face.contains(&button))
+                    || (stick != RadialStick::Right && dpad.contains(&button));
+                assert_eq!(!s.can_bind(RADIAL, button), refused, "{stick:?} {button:?}");
+                // Other actions still take any of them.
+                assert!(s.can_bind("key.chat", button));
+            }
+            // A bumper is always free, and stays one through the file.
+            s.bind(RADIAL, Some(B::LeftBumper));
+            assert_eq!(s.binding(RADIAL), Some(B::LeftBumper), "{stick:?}");
+            assert_eq!(PadSettings::parse(&s.serialize()), s, "{stick:?}");
+        }
+        // A file with a refused opener reads as never saved: the default, unless taken.
+        for button in [B::South, B::East, B::West, B::North, B::RightStick] {
+            let text = format!("bindLayout:2\nbind_pad.radial:{}\n", button.name());
+            let read = PadSettings::parse(&text);
+            assert_eq!(read.binding(RADIAL), Some(B::DPadRight), "{button:?}");
+            let taken = format!("{text}bind_key.playerlist:right\n");
+            assert_eq!(
+                PadSettings::parse(&taken).binding(RADIAL),
+                None,
+                "{button:?}"
+            );
+        }
+        // Read with the stick it was saved for, wherever the stick's line is.
+        let left = PadSettings::parse("bind_pad.radial:north\nbindLayout:2\nradialStick:left\n");
+        assert_eq!(left.binding(RADIAL), Some(B::North));
+    }
+
+    #[test]
+    fn a_stick_that_takes_the_openers_thumb_unbinds_it_and_the_right_gives_it_back() {
+        let mut s = PadSettings::default();
+        s.set_radial_stick(RadialStick::Left);
+        assert_eq!(
+            s.binding(RADIAL),
+            None,
+            "D-pad Right is under the left thumb"
+        );
+        assert_eq!(PadSettings::parse(&s.serialize()).binding(RADIAL), None);
+        s.set_radial_stick(RadialStick::Right);
+        assert_eq!(s.binding(RADIAL), Some(Button::DPadRight));
+        // An opener the player picked that both sticks allow stays.
+        s.bind(RADIAL, Some(Button::RightBumper));
+        s.set_radial_stick(RadialStick::Either);
+        assert_eq!(s.binding(RADIAL), Some(Button::RightBumper));
+    }
+
+    #[test]
+    fn stepping_the_stick_and_back_gives_each_stick_its_own_opener() {
+        // Left with Y, back to the right stick: Y is under the right thumb, D-pad Right opens.
+        let mut s = PadSettings::default();
+        s.set_radial_stick(RadialStick::Left);
+        s.bind(RADIAL, Some(Button::North));
+        s.set_radial_stick(RadialStick::Right);
+        assert_eq!(s.binding(RADIAL), Some(Button::DPadRight));
+        // And Left again has its Y back, shared with Inventory as the player left it.
+        s.set_radial_stick(RadialStick::Left);
+        assert_eq!(s.binding(RADIAL), Some(Button::North));
+        // Right with D-pad Left: the left stick refuses it, and the right gets it back.
+        let mut s = PadSettings::default();
+        s.bind(RADIAL, Some(Button::DPadLeft));
+        s.set_radial_stick(RadialStick::Left);
+        assert_eq!(s.binding(RADIAL), None);
+        s.set_radial_stick(RadialStick::Either);
+        assert_eq!(s.binding(RADIAL), None);
+        s.set_radial_stick(RadialStick::Right);
+        assert_eq!(s.binding(RADIAL), Some(Button::DPadLeft));
+    }
+
+    #[test]
+    fn a_file_from_before_the_radial_menu_binds_no_opener() {
+        let s = PadSettings::parse("vibration:false\nbind_key.chat:up\n");
+        assert_eq!(s.binding(RADIAL), None);
+        assert_eq!(PadSettings::parse(&s.serialize()), s);
+    }
+
+    #[test]
+    fn the_radial_menus_ticks_are_felt_and_tell_apart() {
+        let tick = Rumble::RadialSlot.pulse().unwrap();
+        assert!((40..=50).contains(&tick.millis), "{tick:?}");
+        assert!((0.25..=0.35).contains(&tick.weak), "{tick:?}");
+        let page = Rumble::RadialPage.pulse().unwrap();
+        assert!(page.millis < tick.millis, "a page turn is the shorter tick");
+        assert_eq!(Rumble::RadialWrap.pulse(), Some(page));
+        let nothing = Rumble::RadialNothing.pulse().unwrap();
+        assert!(
+            nothing.strong > 0.0 && nothing.millis > tick.millis,
+            "{nothing:?}"
+        );
+        assert!(
+            nothing.strong.max(nothing.weak) < 0.3,
+            "a soft buzz: {nothing:?}"
+        );
+    }
+
+    #[test]
+    fn the_radial_menus_mode_and_stick_survive_the_settings_file() {
+        let s = PadSettings::default();
+        assert_eq!(
+            (s.radial_mode, s.radial_stick),
+            (RadialMode::Hold, RadialStick::Right)
+        );
+        for mode in RadialMode::ALL {
+            for stick in RadialStick::ALL {
+                let mut s = PadSettings {
+                    radial_mode: mode,
+                    ..PadSettings::default()
+                };
+                s.set_radial_stick(stick);
+                assert_eq!(PadSettings::parse(&s.serialize()), s);
+            }
+        }
+        let read = PadSettings::parse("radialMode:sideways\nradialStick:up\n");
+        assert_eq!(
+            (read.radial_mode, read.radial_stick),
+            (RadialMode::Hold, RadialStick::Right)
+        );
+    }
+
+    #[test]
+    fn radial_pages_survive_the_settings_file() {
+        let mut s = PadSettings::default();
+        let pages = "radial_0_label:Mine\nradial_0_slots:key.chat,,,,,,,\n";
+        s.radial =
+            crate::radial::Pages::parse(pages.lines().filter_map(|l| l.split_once(':'))).unwrap();
+        let read = PadSettings::parse(&s.serialize());
+        assert_eq!(read.radial, s.radial);
+        assert_ne!(read.radial, crate::radial::Pages::default());
+    }
+}
@@ -141,8 +141,13 @@ impl Guide {
    pub fn at_detail(self, detail: GuideDetail) -> Self {
        match detail {
            GuideDetail::Full => self,
+            // Nothing else in play names the radial menu.
            GuideDetail::Basic => Guide {
-                left: Vec::new(),
+                left: self
+                    .left
+                    .into_iter()
+                    .filter(|row| row.caption == crate::gamepad::RADIAL_CAPTION)
+                    .collect(),
                right: self.right,
            },
            GuideDetail::Off => Guide {
@@ -178,6 +183,8 @@ pub fn resolve(facts: &Facts, settings: &PadSettings) -> Guide {
                "key.swapOffhand",
                (player && any_item).then_some("horizon.controller.guide.swap"),
            ),
+            // Nothing else in play says the menu is there; it opens for a spectator too.
+            row(crate::gamepad::RADIAL, Some(crate::gamepad::RADIAL_CAPTION)),
        ]
        .into_iter()
        .flatten()
@@ -566,6 +573,7 @@ mod tests {
                (Button::North, "key.inventory"),
                (Button::DPadDown, "horizon.controller.guide.drop"),
                (Button::West, "horizon.controller.guide.swap"),
+                (Button::DPadRight, crate::gamepad::RADIAL_CAPTION),
            ]
        );
    }
@@ -736,12 +744,12 @@ mod tests {
                gliding: true,
                ..Facts::default()
            }),
-            ["key.inventory"]
+            ["key.inventory", crate::gamepad::RADIAL_CAPTION]
        );
    }

    #[test]
-    fn a_spectator_only_flies_opens_spectates_and_has_its_menu() {
+    fn a_spectator_only_flies_opens_spectates_and_has_its_menus() {
        let facts = Facts {
            spectator: true,
            flying: true,
@@ -765,7 +773,8 @@ mod tests {
            captions(&guide.left),
            [
                "horizon.controller.guide.fly_up",
-                "horizon.controller.guide.fly_down"
+                "horizon.controller.guide.fly_down",
+                crate::gamepad::RADIAL_CAPTION
            ]
        );
    }
@@ -16,5 +16,6 @@ pub mod keybinds;
 pub mod keymapping;
 pub mod modifiers;
 pub mod mouse;
+pub mod radial;
 pub mod snap;
 pub mod window;
@@ -6,7 +6,12 @@ use horizon_world::{
    worldgen::{tags::TagDefinitions, terrain::TerrainBlockStates},
 };
 use serde_json::Value;
-use std::{collections::BTreeSet, io, path::Path, sync::Arc};
+use std::{
+    collections::BTreeSet,
+    io,
+    path::Path,
+    sync::{Arc, Mutex},
+};

 pub const MATERIALS: [&str; 6] = ["bedrock", "dirt", "stone", "sand", "oak_planks", "bricks"];
 #[derive(Clone, Copy)]
@@ -182,6 +187,23 @@ static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::
 fn invalid(message: &str) -> io::Error {
    io::Error::new(io::ErrorKind::InvalidData, message)
 }
+/// Every block registry [`Assets::load`] has handed out, one per distinct
+/// content. Callers keep `&'static` references, so a registry is never freed;
+/// loading equal data again (tests load the same root once per fixture)
+/// returns the one already leaked instead of leaking another (about 11 MB for
+/// vanilla).
+static REGISTRIES: Mutex<Vec<&'static BlockRegistry>> = Mutex::new(Vec::new());
+
+/// `registry` leaked, or the equal one leaked before it.
+fn intern_registry(registry: BlockRegistry) -> &'static BlockRegistry {
+    let mut leaked = REGISTRIES.lock().unwrap_or_else(|e| e.into_inner());
+    if let Some(&same) = leaked.iter().find(|&&known| *known == registry) {
+        return same;
+    }
+    let registry: &'static BlockRegistry = Box::leak(Box::new(registry));
+    leaked.push(registry);
+    registry
+}
 impl Assets {
    pub fn load(root: &Path) -> Result<Self> {
        let manifest: Value = horizon_world::json_file::read(&root.join("horizon-resources.json"))?;
@@ -256,7 +278,7 @@ impl Assets {
        // Chunks hold every state of this registry: content mods can take it
        // past vanilla's 16-bit global palette.
        crate::chunk::set_block_states(registry.len());
-        let registry: &'static BlockRegistry = Box::leak(Box::new(registry));
+        let registry = intern_registry(registry);
        Ok(Self {
            registry,
            properties,
@@ -320,6 +342,16 @@ impl RenderAssets {
            }
            None => crate::model_library::ParsedModels::default(),
        };
+        // Connected-texture rules find their faces by sprite layer: what they match by name keeps a
+        // layer of its own, decided before the models insert their textures.
+        let ctm_rules = if draws {
+            horizon_optifine::ctm::load(root)
+        } else {
+            Vec::new()
+        };
+        sprites.keep_apart(crate::connected::ConnectedTextures::matched_sprites(
+            &ctm_rules,
+        ));
        let mut models = if draws {
            let _step = crate::spans::startup::step("core.models_bake");
            crate::models::prepare_with_models(root, registry, &mut sprites, &parsed)?
@@ -359,6 +391,7 @@ impl RenderAssets {
            let mut found = Vec::new();
            crate::connected::ConnectedTextures::load(
                root,
+                ctm_rules,
                registry,
                &mut sprites,
                |state, face| {
@@ -496,6 +529,29 @@ mod tests {
        ));
    }

+    #[test]
+    fn equal_registries_are_leaked_once() {
+        use horizon_world::registry::BlockRegistry;
+        let registry = |extra: &str| {
+            let facts = format!(
+                r#"{{"defaults":{{"minecraft:air":0,"fixture:{extra}":1}},"states":[
+                    ["air",true,false,"","minecraft:air"],
+                    ["{extra}",false,false,"","fixture:{extra}"]
+                ]}}"#
+            );
+            BlockRegistry::from_facts_json(facts.as_bytes()).unwrap()
+        };
+        let first = super::intern_registry(registry("interned_once"));
+        let again = super::intern_registry(registry("interned_once"));
+        let other = super::intern_registry(registry("interned_other"));
+        assert!(std::ptr::eq(first, again), "equal content leaked twice");
+        assert!(!std::ptr::eq(first, other), "different content shared");
+        assert_eq!(
+            other.default_state("fixture:interned_other"),
+            Some(horizon_world::registry::BlockStateId(1))
+        );
+    }
+
    #[test]
    fn sprite_pixels_come_back_the_same_once_packed() {
        // Two layers of 16x16 RGBA with some structure, as sprites have.
@@ -7,7 +7,7 @@ use serde_json::Value;
 use std::{
    collections::{BTreeMap, HashMap},
    path::Path,
-    sync::Arc,
+    sync::{Arc, OnceLock},
 };

 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -398,7 +398,37 @@ impl Biomes {
    pub fn contains(&self, name: &str) -> bool {
        self.index.contains_key(name)
    }
+    /// The biome at `id`, clamped to the last entry when `id` is past the
+    /// table (a stale column from an older registry keeps its id).
+    ///
+    /// When the table is empty (a resource pack with no biome files), returns
+    /// a shared default plains biome instead of panicking on `list.len() - 1`.
    pub fn get(&self, id: u16) -> &BiomeInfo {
+        if self.list.is_empty() {
+            static DEFAULT: OnceLock<BiomeInfo> = OnceLock::new();
+            return DEFAULT.get_or_init(|| BiomeInfo {
+                spawns: HashMap::new(),
+                spawn_costs: HashMap::new(),
+                creature_probability: 0.0,
+                increased_fire_burnout: false,
+                name: "minecraft:plains".to_owned(),
+                temperature: 0.8,
+                frozen: false,
+                downfall: 0.4,
+                precipitation: false,
+                grass: 0x7f_c0_55,
+                modifier: GrassModifier::None,
+                foliage: 0x6a_ab_37,
+                dry_foliage: 0x79_75_54,
+                water: 0x3f_76_e4,
+                sky: None,
+                fog: None,
+                water_fog: 0x3f_76_e4,
+                ambient_particles: Vec::new(),
+                features: Vec::new(),
+                attributes: Default::default(),
+            });
+        }
        &self.list[usize::from(id).min(self.list.len() - 1)]
    }
    /// The name of biome `id`, plains (as for an unknown name) when the id is
@@ -795,4 +825,34 @@ mod blend_tests {
        }
        assert!(at(-2.0) > 0.0 && at(-2.0) < 0.5);
    }
+
+    /// An empty biome table (a resource pack with no biome files) must not
+    /// panic on `get`: before the fix, `list.len() - 1` underflowed.
+    #[test]
+    fn get_on_empty_biome_table_returns_default_instead_of_panicking() {
+        use std::sync::Arc;
+
+        let empty = Biomes {
+            builtin: Arc::new(Vec::new()),
+            index: HashMap::new(),
+            list: Vec::new(),
+            info_noise: SimplexNoise::with_skipped_offsets(&mut LegacyRandom::new(2345), true),
+            colormaps: Arc::new(Colormaps {
+                grass: Vec::new(),
+                foliage: Vec::new(),
+                dry: Vec::new(),
+            }),
+            packs: BTreeMap::new(),
+        };
+        // Any id returns the shared default plains biome, no panic.
+        let b = empty.get(0);
+        assert_eq!(b.name, "minecraft:plains");
+        let b = empty.get(65535);
+        assert_eq!(b.name, "minecraft:plains");
+        // Colours and temperature come from the default.
+        assert_eq!(b.temperature, 0.8);
+        assert_eq!(b.grass, 0x7f_c0_55);
+        assert_eq!(b.foliage, 0x6a_ab_37);
+        assert_eq!(b.water, 0x3f_76_e4);
+    }
 }
@@ -84,6 +84,71 @@ pub fn contents_effects(stack: &ItemStack) -> Vec<(&'static str, i32, i32)> {
        )
        .collect()
 }
+/// `PotionContents.getAllEffects`, retaining each custom instance's flags.
+pub fn contents_instances(stack: &ItemStack) -> Vec<crate::effects::EffectInstance> {
+    use horizon_client_core::nbt_value::{number, text};
+    use horizon_world::nbt::Tag;
+    let mut effects: Vec<_> = stack
+        .potion()
+        .and_then(potion)
+        .map_or(&[][..], |p| p.effects)
+        .iter()
+        .map(|(id, duration, amp)| crate::effects::EffectInstance::new(id, *duration, *amp))
+        .collect();
+    if let Some((_, Tag::List(custom))) = stack
+        .data()
+        .and_then(|d| d.potion_extra.iter().find(|(k, _)| k == "custom_effects"))
+    {
+        for e in custom {
+            let Some(def) = text(e.get("id")).and_then(|id| effect(&id)) else {
+                continue;
+            };
+            let mut instance = crate::effects::EffectInstance::new(
+                def.id,
+                number(e.get("duration")).unwrap_or(0) as i32,
+                number(e.get("amplifier")).unwrap_or(0).clamp(0, 255) as i32,
+            );
+            instance.ambient = number(e.get("ambient")).unwrap_or(0) != 0;
+            instance.visible = number(e.get("show_particles")) != Some(0);
+            effects.push(instance);
+        }
+    }
+    effects
+}
+/// `PotionContents.getColor`: an explicit colour wins; otherwise mix only
+/// visible base and custom effects, with their amplifier weights.
+pub fn contents_color(stack: &ItemStack) -> u32 {
+    use horizon_client_core::nbt_value::number;
+    if let Some(color) = stack
+        .data()
+        .and_then(|d| d.potion_extra.iter().find(|(k, _)| k == "custom_color"))
+        .and_then(|(_, v)| number(Some(v)))
+    {
+        return color as u32;
+    }
+    0xFF00_0000
+        | horizon_client_core::potions::effects_color(
+            contents_instances(stack)
+                .iter()
+                .filter(|e| e.visible)
+                .map(|e| (e.id, e.amplifier)),
+        )
+}
+/// `PotionContents.equals(EMPTY)`: colour and custom name also make contents
+/// nonempty, even when there is no registered potion or custom effect.
+pub fn contents_empty(stack: &ItemStack) -> bool {
+    use horizon_world::nbt::Tag;
+    stack.potion().is_none()
+        && stack.data().is_none_or(|d| {
+            d.potion_extra
+                .iter()
+                .all(|(key, value)| match key.as_str() {
+                    "custom_effects" => matches!(value, Tag::List(list) if list.is_empty()),
+                    "custom_color" | "custom_name" => false,
+                    _ => true,
+                })
+        })
+}
 /// Roman amplifier suffix (`potion.potency.N`) and duration lines of a potion.
 pub fn tooltip(
    potion: Option<&str>,
@@ -706,4 +771,39 @@ mod tests {
        let lines = effect_lines([("minecraft:resistance", 15, 0)], 1.0, &translate);
        assert_eq!(lines[0].0, "resistance");
    }
+    #[test]
+    fn custom_contents_color_and_empty_semantics() {
+        use horizon_world::nbt::Tag;
+        let mut stack = ItemStack::new("minecraft:tipped_arrow", 1);
+        assert!(contents_empty(&stack));
+        stack
+            .data_mut()
+            .potion_extra
+            .push(("custom_effects".into(), Tag::List(Vec::new())));
+        assert!(contents_empty(&stack));
+        stack.data_mut().potion_extra = vec![(
+            "custom_effects".into(),
+            Tag::List(vec![
+                Tag::compound([
+                    ("id", Tag::String("minecraft:glowing".into())),
+                    ("amplifier", Tag::Int(1)),
+                ]),
+                Tag::compound([
+                    ("id", Tag::String("minecraft:poison".into())),
+                    ("show_particles", Tag::Byte(0)),
+                ]),
+            ]),
+        )];
+        assert!(!contents_empty(&stack));
+        // Glowing's colour; hidden poison contributes no weight.
+        assert_eq!(contents_color(&stack), 0xFF94_A061);
+        stack
+            .data_mut()
+            .potion_extra
+            .push(("custom_color".into(), Tag::Int(123456)));
+        assert_eq!(contents_color(&stack), 123456);
+        stack.data_mut().potion_extra = vec![("custom_name".into(), Tag::String("test".into()))];
+        assert!(!contents_empty(&stack));
+        assert_eq!(contents_color(&stack), 0xFF38_5DC6);
+    }
 }
@@ -1974,7 +1974,11 @@ impl ChatScreen {
            return false;
        }
        let max = l.list.len().saturating_sub(self.layout.line_limit) as i32;
-        l.offset = ((l.offset as f64 - amount.clamp(-1.0, 1.0)) as i32).clamp(0, max) as usize;
+        // Round instead of truncating: touchpad/PixelDelta produces fractional
+        // amounts and truncation drops movement in one direction (#14338).
+        l.offset = (l.offset as f64 - amount.clamp(-1.0, 1.0))
+            .round()
+            .clamp(0.0, max as f64) as usize;
        true
    }
    /// `CommandSuggestions.formatText`: argument colours over the input. The
@@ -2086,6 +2090,11 @@ impl ChatScreen {
    ) {
        let limit = l.list.len().min(self.layout.line_limit);
        let [rx, ry, rw, rh] = l.rect;
+        // SuggestionsList.extractRenderState: the whole list asks for the
+        // pointing hand while the pointer is inside its rectangle.
+        if mouse.0 >= rx && mouse.0 < rx + rw && mouse.1 >= ry && mouse.1 < ry + rh {
+            crate::widgets::request_cursor(crate::widgets::Cursor::PointingHand);
+        }
        let has_prev = l.offset > 0;
        let has_next = l.list.len() > l.offset + limit;
        let moved = l.last_mouse != mouse;
@@ -1066,3 +1066,32 @@ fn a_server_filter_mask_hides_or_masks_the_message() {
            .all(|s| s.style.color.is_none())
    );
 }
+
+/// `SuggestionsList.extractRenderState`: the list's rectangle asks for the
+/// pointing hand; outside it the cursor stays the arrow.
+#[test]
+fn the_suggestion_list_asks_for_the_pointing_hand() {
+    let font = font();
+    let m = Measure(&font);
+    let registries = Registries::default();
+    let c = Commands {
+        dispatcher: crate::command::vanilla::game_dispatcher(),
+        registries: &registries,
+    };
+    let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
+    screen.type_text(&m, &c, "/");
+    let rect = screen
+        .suggestions
+        .as_ref()
+        .expect("the root commands are a suggestion list")
+        .rect;
+    let _ = crate::widgets::take_cursor();
+    screen.draw(&m, (rect[0] + 2, rect[1] + 2), 0, 0);
+    assert_eq!(
+        crate::widgets::take_cursor(),
+        crate::widgets::Cursor::PointingHand
+    );
+    let _ = crate::widgets::take_cursor();
+    screen.draw(&m, (rect[0] - 1, rect[1] + 2), 0, 0);
+    assert_eq!(crate::widgets::take_cursor(), crate::widgets::Cursor::Arrow);
+}
@@ -539,6 +539,7 @@ pub struct Data {
    pub current: Option<Info>,
    pub travel: i32,
    pub selector: Selector,
+    pub reload_particle: bool,
 }
 /// Which sculk block entity this is.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -124,15 +124,25 @@ fn sprite_name(resource: &str) -> String {
 }

 impl ConnectedTextures {
-    /// The rules under `root`, with their tiles inserted into `sprites` (before it finishes).
-    /// `face_layer` answers a block state's sprite on a side, for rules that connect by tile.
+    /// The sprites `rules` match by name (`matchTiles`, `connectTiles`), for
+    /// [`Sprites::keep_apart`]: before the models insert theirs.
+    pub fn matched_sprites(rules: &[Rule]) -> Vec<String> {
+        (rules.iter())
+            .flat_map(|r| r.match_tiles.iter().chain(&r.connect_tiles))
+            .map(|t| sprite_name(t))
+            .collect()
+    }
+
+    /// `rules` (`ctm::load` under `root`), with their tiles inserted into `sprites` (before it
+    /// finishes). `face_layer` answers a block state's sprite on a side, for rules that connect
+    /// by tile.
    pub fn load(
        root: &Path,
+        mut rules: Vec<Rule>,
        registry: &BlockRegistry,
        sprites: &mut Sprites,
        mut face_layer: impl FnMut(BlockStateId, Face) -> Option<u32>,
    ) -> Self {
-        let mut rules = ctm::load(root);
        // Rules with a custom name load no tiles: section meshes see no block entity.
        rules.retain(|r| r.name.is_none());
        // Rule indices are `u16`.
@@ -1270,6 +1280,41 @@ mod tests {
        assert!(!ctm.stacked_pane_hides(3, 3, post));
    }

+    #[test]
+    fn rules_name_the_sprites_they_match() {
+        // `matchTiles` among the textures and beside the file (a chain onto another rule's
+        // tile), and `connectTiles`: each as the sprite name the textures and tiles are inserted
+        // under.
+        let dir = "assets/minecraft/optifine/ctm/pack/crops";
+        let rule = |file: &str, text: &str| {
+            Rule::parse(
+                &format!("{dir}/{file}"),
+                &horizon_optifine::properties::Properties::parse(text),
+            )
+            .unwrap()
+            .unwrap()
+        };
+        let rules = [
+            rule(
+                "1.properties",
+                "matchTiles=./19.png\nmethod=random\ntiles=5-6",
+            ),
+            rule(
+                "2.properties",
+                "matchTiles=textures/block/extra/placeholder.png\nmethod=overlay\n\
+                 connectTiles=textures/block/stone.png\ntiles=0-16",
+            ),
+        ];
+        assert_eq!(
+            ConnectedTextures::matched_sprites(&rules),
+            [
+                format!("{dir}/19.png"),
+                "minecraft:block/extra/placeholder".to_owned(),
+                "minecraft:block/stone".to_owned(),
+            ]
+        );
+    }
+
    #[test]
    fn sprite_names() {
        assert_eq!(
@@ -57,6 +57,8 @@ pub enum Item {
    /// Wait for a button to bind to this action.
    Bind(&'static str),
    ResetBinds,
+    /// Opens the radial menu's pages (`radial_editor`).
+    Radial,
    Info(Info),
 }

@@ -106,6 +108,15 @@ fn choice_description(opt: Opt, pad: &PadSettings) -> Option<&'static str> {
            }
            gamepad::Lightbar::Off => "A DualSense keeps its own light.",
        },
+        Opt::PadRadialMode => match pad.radial_mode {
+            gamepad::RadialMode::Hold => "horizon.options.radial_mode.hold.about",
+            gamepad::RadialMode::Toggle => "horizon.options.radial_mode.toggle.about",
+        },
+        Opt::PadRadialStick => match pad.radial_stick {
+            gamepad::RadialStick::Right => "horizon.options.radial_stick.right.about",
+            gamepad::RadialStick::Left => "horizon.options.radial_stick.left.about",
+            gamepad::RadialStick::Either => "horizon.options.radial_stick.either.about",
+        },
        _ => return None,
    })
 }
@@ -123,6 +134,11 @@ fn info(info: Info, text: &'static str) -> Setting {
    }
 }

+/// The radial menu's group, on General (how it opens and selects) and Bindings (its pages).
+const RADIAL_GROUP: &str = "Radial Menu";
+/// The row that opens the radial menu's pages.
+const RADIAL_PAGES: &str = "horizon.pages.open.controller_radial";
+
 /// Shown on a binding's row until it is focused, and in the search.
 const BIND_TEXT: &str = "Press this row, then the button that should do it.";

@@ -201,6 +217,13 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                        ),
                    ],
                ),
+                (
+                    RADIAL_GROUP,
+                    vec![
+                        option(Opt::PadRadialMode, "horizon.options.radial_mode.about"),
+                        option(Opt::PadRadialStick, "horizon.options.radial_stick.about"),
+                    ],
+                ),
                (
                    "Menus",
                    vec![
@@ -231,6 +254,13 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
        (
            Page::Bindings,
            vec![
+                (
+                    RADIAL_GROUP,
+                    vec![Setting {
+                        item: Item::Radial,
+                        text: "Named pages of eight actions, held open with a button.",
+                    }],
+                ),
                ("Actions", binds),
                (
                    "Reset",
@@ -437,6 +467,7 @@ fn row(setting: Setting, s: &Settings, context: &Context) -> Row<Item> {
            Row::new(item, name, value).about(about)
        }
        Item::ResetBinds => Row::new(item, lang::get(RESET_ALL), Value::Press).about(about),
+        Item::Radial => Row::new(item, lang::get(RADIAL_PAGES), Value::Press).about(about),
        Item::Info(which) => {
            let (name, value) = context.read(which);
            Row::new(item, lang::get(name), Value::Read(value)).about(about)
@@ -496,6 +527,7 @@ impl Screen for ControllerScreen {
                s.controller.reset_bindings();
                vec![Output::Event(Event::Changed)]
            }
+            Item::Radial => vec![Output::Push(crate::options_ui::Page::ControllerRadial)],
            Item::Bind(_) | Item::Info(_) => Vec::new(),
        }
    }
@@ -533,15 +565,21 @@ impl Screen for ControllerScreen {
    fn undoes(&self) -> bool {
        true
    }
-    /// This player's controller settings, bindings included, as the screen found them.
+    /// This player's controller settings, bindings included, as the screen found them. The
+    /// radial menu's pages stay as they are: their own screen has its own Undo.
    fn undo(&mut self, s: &mut Settings, before: &Settings) -> Vec<Output> {
+        let radial = std::mem::take(&mut s.controller.radial);
        s.controller = before.controller.clone();
+        s.controller.radial = radial;
        Vec::new()
    }
    /// Undo is there exactly while the controller settings differ from what the screen opened
-    /// with: a binding the game made while the row waited counts, a value stepped back doesn't.
+    /// with: a binding the game made while the row waited counts, a value stepped back doesn't,
+    /// and nor do the radial menu's pages, which this Undo keeps.
    fn differs(&self, s: &Settings, before: &Settings) -> Option<bool> {
-        Some(s.controller != before.controller)
+        let mut now = s.controller.clone();
+        now.radial = before.controller.radial.clone();
+        Some(now != before.controller)
    }
 }

@@ -793,6 +831,48 @@ mod tests {
        assert_eq!(arts(&batch, row), 0);
    }

+    /// The radial menu's pages have their own screen and Undo: editing them shows no Undo here,
+    /// and another change's Undo keeps them as edited.
+    #[test]
+    fn radial_pages_edited_on_their_own_screen_leave_undo_alone() {
+        let mut s = Settings::default();
+        let mut ui = ui(Page::General);
+        draw(&mut ui, &s, None);
+        s.controller.radial.remove(1);
+        draw(&mut ui, &s, None);
+        assert!(
+            !ui.changed(),
+            "Undo here keeps the pages: it has nothing to do"
+        );
+        s.controller.invert_y = !s.controller.invert_y;
+        draw(&mut ui, &s, None);
+        assert!(ui.changed());
+        let reached = (0..100).any(|_| {
+            key(&mut ui, &mut s, K::Tab);
+            ui.focused() == Some(Target::Undo)
+        });
+        assert!(reached);
+        key(&mut ui, &mut s, K::Enter);
+        assert_eq!(s.controller.radial.len(), 1);
+        assert_eq!(s.controller.invert_y, PadSettings::default().invert_y);
+    }
+
+    /// The Bindings page's radial row opens the radial menu's pages.
+    #[test]
+    fn the_radial_row_opens_the_radial_pages() {
+        let mut s = Settings::default();
+        let mut ui = ui(Page::Bindings);
+        let at = ui.point_at(&s, SIZE, Item::Radial);
+        let outputs = ui.click(&mut s, at, SIZE, false, false, false);
+        assert_eq!(
+            outputs,
+            [
+                CLICK,
+                Output::Push(crate::options_ui::Page::ControllerRadial)
+            ]
+        );
+    }
+
    #[test]
    fn the_search_finds_rows_across_pages_and_drops_empty_pages() {
        let s = Settings::default();
@@ -816,8 +896,8 @@ mod tests {
        let mut s = Settings::default();
        s.controller.bind(JUMP, Some(Button::North));
        let mut ui = ui(Page::Bindings);
-        // Search, the three pages, then the first action.
-        for _ in 0..Page::ALL.len() + 2 {
+        // Search, the three pages, the radial menu's row, then the first action.
+        for _ in 0..Page::ALL.len() + 3 {
            key(&mut ui, &mut s, K::Tab);
        }
        assert_eq!(ui.focused(), Some(Target::Row(Item::Bind(JUMP))));
@@ -939,6 +1019,8 @@ mod tests {
            (Opt::PadNintendoButtons, 2),
            (Opt::PadKeyboard, 3),
            (Opt::PadLightbar, 3),
+            (Opt::PadRadialMode, 2),
+            (Opt::PadRadialStick, 3),
        ] {
            let setting = option(opt, "the fixed sentence");
            let mut seen = Vec::new();
@@ -972,6 +1054,8 @@ mod tests {
                Opt::PadNintendoButtons,
                Opt::PadKeyboard,
                Opt::PadLightbar,
+                Opt::PadRadialMode,
+                Opt::PadRadialStick,
            ] {
                for _ in 0..4 {
                    lang::get(choice_description(opt, &settings.controller).unwrap());
@@ -990,6 +1074,7 @@ mod tests {
            }
            ControllerScreen::default().side();
            lang::get(TITLE);
+            lang::get(RADIAL_PAGES);
            for text in [
                "Press the button for this. %s cancels.",
                "This button also does: %s",
@@ -439,20 +439,33 @@ fn deliver(home: &Path, report: Report) -> Option<PathBuf> {
    }
 }

-/// The report for a hung server tick, written by the watchdog thread
-/// (`ServerWatchdog`): the stuck thread's stack is not available to Rust, so
-/// the report carries none.
-pub fn report_watchdog(home: &Path, side: &'static str, message: String) -> Option<PathBuf> {
+/// The report for a hung server tick, written by the watchdog thread (`ServerWatchdog`): the
+/// stack is the server thread's, read from the watchdog (`horizon_threads::stack_dump`), as
+/// vanilla's report carries the server thread's stack; without it, the details say why.
+pub fn report_watchdog(
+    home: &Path,
+    side: &'static str,
+    message: String,
+    server_stack: Result<String, horizon_threads::stack_dump::NoStack>,
+) -> Option<PathBuf> {
+    let mut details = system_details(side);
+    let stack = match server_stack {
+        Ok(stack) => stack_lines(&stack, false),
+        Err(why) => {
+            details.push(("Server thread stack".into(), why.to_string()));
+            String::new()
+        }
+    };
    deliver(
        home,
        Report {
            time: Local::now(),
            description: "Watching Server".into(),
            error: format!("{message} (Watching Server)"),
-            stack: String::new(),
+            stack,
            thread: thread_name(side),
            side,
-            details: system_details(side),
+            details,
            log: crate::logging::recent_lines(),
        },
    )
@@ -1,6 +1,7 @@
 //! Data packs (`<world>/datapacks`: folders and zips with `pack.mcmeta`) and
 //! the parts of them commands use: `.mcfunction` functions (with macros and
 //! line continuation), function tags and predicates.
+mod slot_sources;
 use crate::zip::Zip;
 use horizon_world::{
    nbt::Tag,
@@ -663,6 +664,8 @@ pub struct DataStore {
    pub item_modifiers: BTreeMap<String, serde_json::Value>,
    /// `slot_source` definitions, evaluated against a command's live accessor.
    pub slot_sources: BTreeMap<String, serde_json::Value>,
+    /// Slot-source tags belong to the same loaded snapshot as their definitions.
+    pub slot_source_tags: BTreeMap<String, Vec<(String, bool)>>,
    /// The content tables' raw files from the packs after the built-in one:
    /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `dialog/`, `damage_type/`, `data_maps/`, `enchantment/` and `tags/…/` files, by
    /// `<kind-dir>/<ns>:<path>`, each id's files in pack order. The tables
@@ -759,6 +762,16 @@ impl DataStore {
                    && let Ok(v) = serde_json::from_slice(&bytes)
                {
                    s.item_modifiers.insert(id, v);
+                } else if let Some(id) = resource_id(&f, "tags/slot_source", ".json")
+                    && let Some(bytes) = pack.read(&f)
+                    && let Ok(v) = serde_json::from_slice::<serde_json::Value>(&bytes)
+                {
+                    let entries = tag_entries(&v);
+                    let slot = s.slot_source_tags.entry(id).or_default();
+                    if v["replace"].as_bool() == Some(true) {
+                        slot.clear();
+                    }
+                    slot.extend(entries);
                } else if let Some(id) = resource_id(&f, "slot_source", ".json")
                    && let Some(bytes) = pack.read(&f)
                    && let Ok(v) = serde_json::from_slice(&bytes)
@@ -0,0 +1,86 @@
+//! Slot-source holder-set tags share DataStore's pack ordering and snapshot.
+use super::DataStore;
+use std::collections::BTreeSet;
+impl DataStore {
+    /// TagLoader's required-member validation and first-seen membership order.
+    pub fn slot_source_tag(&self, id: &str) -> Result<Vec<String>, String> {
+        fn visit(
+            store: &DataStore,
+            id: &str,
+            active: &mut BTreeSet<String>,
+        ) -> Result<Vec<String>, String> {
+            if !active.insert(id.to_owned()) {
+                return Err(format!("Recursive slot-source tag #{id}"));
+            }
+            let result = (|| {
+                let entries = store
+                    .slot_source_tags
+                    .get(id)
+                    .ok_or_else(|| format!("Unknown slot-source tag #{id}"))?;
+                let mut out = Vec::new();
+                for (entry, required) in entries {
+                    let values = if let Some(tag) = entry.strip_prefix('#') {
+                        visit(store, tag, active)
+                    } else if store.slot_sources.contains_key(entry) {
+                        Ok(vec![entry.clone()])
+                    } else {
+                        Err(format!("Unknown slot source {entry}"))
+                    };
+                    match values {
+                        Ok(values) => {
+                            for value in values {
+                                if !out.contains(&value) {
+                                    out.push(value);
+                                }
+                            }
+                        }
+                        Err(error) if *required => return Err(error),
+                        Err(_) => {}
+                    }
+                }
+                Ok(out)
+            })();
+            active.remove(id);
+            result
+        }
+        visit(self, id, &mut BTreeSet::new())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn holder_set_tags_keep_order_required_members_and_snapshot_authority() {
+        let mut store = DataStore::default();
+        for name in ["t:a", "t:b"] {
+            store.slot_sources.insert(
+                name.into(),
+                serde_json::json!({"type":"slot_range","slots":"container.0"}),
+            );
+        }
+        store.slot_source_tags.insert(
+            "t:child".into(),
+            vec![("t:b".into(), true), ("t:a".into(), true)],
+        );
+        store.slot_source_tags.insert(
+            "t:all".into(),
+            vec![
+                ("t:a".into(), true),
+                ("#t:child".into(), true),
+                ("t:absent".into(), false),
+            ],
+        );
+        assert_eq!(store.slot_source_tag("t:all").unwrap(), ["t:a", "t:b"]);
+        store
+            .slot_source_tags
+            .get_mut("t:all")
+            .unwrap()
+            .push(("t:absent".into(), true));
+        assert!(store.slot_source_tag("t:all").is_err());
+        store
+            .slot_source_tags
+            .insert("t:cycle".into(), vec![("#t:cycle".into(), true)]);
+        assert!(store.slot_source_tag("t:cycle").is_err());
+    }
+}
@@ -12,6 +12,8 @@ use std::collections::HashMap;
 use std::path::Path;
 use std::sync::{Arc, RwLock};

+mod noise;
+
 pub struct Environment {
    system: System,
    /// What the packs' expressions read; the frame sets it before sampling.
@@ -559,13 +561,9 @@ impl<'a> BlockHost<'a> {
    }
 }

-/// The simplex noise `r.noise(x, y)` reads, the same for blocks and particles.
-pub(crate) fn polytone_noise() -> &'static horizon_core::noise::SimplexNoise {
-    static NOISE: std::sync::OnceLock<horizon_core::noise::SimplexNoise> =
-        std::sync::OnceLock::new();
-    NOISE.get_or_init(|| {
-        horizon_core::noise::SimplexNoise::new(&mut horizon_core::random::LegacyRandom::new(0))
-    })
+/// The noise `r.noise(x, y)` reads, the same for blocks and particles.
+pub(crate) fn polytone_noise() -> &'static noise::PerlinSimplex {
+    noise::builtin()
 }

 impl horizon_polytone::expr::Host for BlockHost<'_> {
@@ -615,7 +613,7 @@ impl horizon_polytone::expr::Host for BlockHost<'_> {
            (V::Object(2), "noise") => {
                let mut coords = args.iter().filter(|v| !matches!(v, V::Str(_))).map(V::num);
                let (x, y) = (coords.next().unwrap_or(0.0), coords.next().unwrap_or(0.0));
-                num(f64::from(polytone_noise().get2(x, y)))
+                num(polytone_noise().get(x, y))
            }
            _ => Err(format!("{name} is not available to block colormaps")),
        }
@@ -0,0 +1,116 @@
+//! Polytone's `r.noise(x, y)`: 1.18-1.21's `PerlinSimplexNoise` over simplex noises, which 26.3 no
+//! longer has. Measured on the real mod (Polytone 26.3-6.8.6) with a pack whose grass colormap encodes
+//! the noise: the built-in noise is seed 0 with octaves `{1}`, read with the noise offsets
+//! (`getValue(x, y, true)`), and a `polytone/noises` definition with seed 0 or 1 and octaves `{0}`,
+//! `{1}` or `{0, 1}` matches this construction too.
+
+use horizon_core::noise::SimplexNoise;
+use horizon_core::random::{LegacyRandom, RandomSource};
+
+/// `PerlinSimplexNoise(random, octaves)`: one simplex noise per octave, the highest octave first.
+pub(crate) struct PerlinSimplex {
+    levels: Vec<Option<SimplexNoise>>,
+    input_factor: f64,
+    value_factor: f64,
+}
+
+impl PerlinSimplex {
+    /// The construction of `PerlinSimplexNoise(new LegacyRandomSource(seed), octaves)`: octave 0 takes
+    /// the first noise of `seed`'s random; the positive octaves come from a random seeded by that
+    /// noise's value at its own offsets, the negative ones from `seed`'s random after it.
+    pub(crate) fn new(seed: i64, octaves: &[i32]) -> Self {
+        let mut random = LegacyRandom::new(seed);
+        let lowest = octaves.iter().copied().min().unwrap_or(0);
+        let highest = octaves.iter().copied().max().unwrap_or(0);
+        let count = (highest - lowest + 1) as usize;
+        let first = SimplexNoise::new(&mut random);
+        let top = highest;
+        let wanted = |index: i32| octaves.contains(&(top - index));
+        let mut levels: Vec<Option<SimplexNoise>> = (0..count).map(|_| None).collect();
+        for index in top + 1..count as i32 {
+            if index >= 0 && wanted(index) {
+                levels[index as usize] = Some(SimplexNoise::new(&mut random));
+            } else {
+                random.consume_count(262);
+            }
+        }
+        if highest > 0 {
+            // `(long)(getValue(xo, yo, zo) * 9.223372E18F)`: the noise at its own offsets, which
+            // 26.3's get3 reads at (0, 0, 0). The float constant is 2^63.
+            let value = first.get3_f64(0.0, 0.0, 0.0) * 9.223_372e18_f32 as f64;
+            let mut upper = LegacyRandom::new(value as i64);
+            for index in (0..top).rev() {
+                if (index as usize) < count && wanted(index) {
+                    levels[index as usize] = Some(SimplexNoise::new(&mut upper));
+                } else {
+                    upper.consume_count(262);
+                }
+            }
+        }
+        if (0..count as i32).contains(&top) && octaves.contains(&0) {
+            levels[top as usize] = Some(first);
+        }
+        Self {
+            levels,
+            input_factor: 2f64.powi(highest),
+            value_factor: 1.0 / (2f64.powi(count as i32) - 1.0),
+        }
+    }
+
+    /// `getValue(x, y, true)`: each octave read with its offsets, which 26.3's simplex adds itself.
+    pub(crate) fn get(&self, x: f64, y: f64) -> f64 {
+        let (mut input, mut value, mut sum) = (self.input_factor, self.value_factor, 0.0);
+        for level in &self.levels {
+            if let Some(noise) = level {
+                sum += noise.get2_f64(x * input, y * input) * value;
+            }
+            input /= 2.0;
+            value *= 2.0;
+        }
+        sum
+    }
+}
+
+/// The built-in `r.noise(x, y)`: seed 0, octaves `{1}`.
+pub(crate) fn builtin() -> &'static PerlinSimplex {
+    static NOISE: std::sync::OnceLock<PerlinSimplex> = std::sync::OnceLock::new();
+    NOISE.get_or_init(|| PerlinSimplex::new(0, &[1]))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `r.noise(x/8, z/8)` read on the real mod (Polytone 26.3-6.8.6): a grass colormap whose pixel
+    /// encodes the value, decoded to about 0.01 (polytone-work/rnoise in the measurement notes).
+    #[test]
+    fn the_builtin_noise_reads_what_the_mod_draws() {
+        for (x, z, mod_value) in [
+            (0, 10, -0.28373),
+            (3, 10, -0.14683),
+            (10, 0, 0.31833),
+            (24, 14, -0.55941),
+            (40, 25, -0.48358),
+            (7, 3, -0.68202),
+        ] {
+            let value = builtin().get(f64::from(x) / 8.0, f64::from(z) / 8.0);
+            assert!(
+                (value - mod_value).abs() < 0.02,
+                "({x}, {z}): {value} against {mod_value}"
+            );
+        }
+    }
+
+    /// The octaves add as `PerlinSimplexNoise`'s do: `{0, 1}` is a third of `{1}` and two thirds of
+    /// `{0}` (measured: 0.067 = 0.33 x -0.284 + 0.67 x 0.247 at (0, 10) / 8).
+    #[test]
+    fn two_octaves_weigh_a_third_and_two_thirds() {
+        let both = PerlinSimplex::new(0, &[0, 1]);
+        let (low, high) = (PerlinSimplex::new(0, &[0]), PerlinSimplex::new(0, &[1]));
+        for (x, y) in [(0.0, 1.25), (2.5, -3.0), (17.1, 4.4)] {
+            let mixed = high.get(x, y) / 3.0 + low.get(x, y) * 2.0 / 3.0;
+            assert!((both.get(x, y) - mixed).abs() < 1e-12);
+        }
+        assert!((both.get(0.0, 1.25) - 0.067).abs() < 0.02);
+    }
+}
@@ -60,6 +60,7 @@ mod entity_outline;
 mod fluid;
 #[cfg(test)]
 mod inter_stage_tests;
+mod section_fade;
 mod terrain_model;
 #[cfg(test)]
 pub(crate) mod test_gpu;
@@ -74,6 +75,10 @@ pub use entity_batch::{
    WATER_MASK_OVERLAY, WORLD_TEXT_OVERLAY, WORLD_TEXT_POLYGON_OFFSET_OVERLAY, is_native_terrain,
    mark_oit,
 };
+use section_fade::{
+    CHUNK_VISIBILITY_THRESHOLD, FadeInputs, chunk_visibility, fade_millis, section_instance,
+    section_visibility,
+};
 pub use view::{View, ViewSet};

 /// Window.getAppropriateLineWidth, in framebuffer pixels.
@@ -365,62 +370,6 @@ fn pack_terrain_camera(camera: DVec3) -> DVec3 {
    let whole = camera.floor();
    whole + ((camera - whole) * 65536.0).round() / 65536.0
 }
-/// A section's instance: its camera-relative origin and its UV step, negated
-/// past its fade code while it fades in over far terrain (`lod::instance`).
-fn section_instance(origin: [f32; 3], fade: u32, visibility: f32) -> [f32; 4] {
-    let step = 1.0 / crate::mesher::UV_STEPS;
-    [
-        origin[0],
-        origin[1],
-        origin[2],
-        if fade == 0 {
-            // The step is a power of two, so its mantissa is free: it holds the vanilla
-            // chunk fade-in's `1 - visibility` in 23 bits (terrain.wgsl's `instance_step` and
-            // `instance_visibility` read it back). A whole section is the bare step.
-            let faded = ((1.0 - visibility) * 8_388_608.0)
-                .round()
-                .clamp(0.0, 8_388_607.0) as u32;
-            f32::from_bits(step.to_bits() | faded)
-        } else {
-            -(fade as f32 + step)
-        },
-    ]
-}
-/// `SectionRenderDispatcher.RenderSection.getVisibility`: how far through its fade-in a section
-/// uploaded `elapsed_ms` ago is.
-fn chunk_visibility(elapsed_ms: u64, fade_ms: u64) -> f32 {
-    if elapsed_ms >= fade_ms {
-        1.0
-    } else {
-        elapsed_ms as f32 / fade_ms as f32
-    }
-}
-/// `Util.toMillis`: `Mth.floor(seconds * 1000.0)`.
-fn fade_millis(seconds: f32) -> u64 {
-    (f64::from(seconds) * 1000.0).floor().max(0.0) as u64
-}
-/// `chunk_visibility` at `now` of a section first uploaded at `uploaded`
-/// (`Renderer::section_uploaded`; none: one that fades in over far terrain, or
-/// whose column left), with the chunk fade-in `fade_ms`.
-fn section_visibility(uploaded: Option<&Instant>, fade_ms: u64, now: Instant) -> f32 {
-    uploaded.map_or(1.0, |&t| {
-        let elapsed = now.saturating_duration_since(t).as_millis() as u64;
-        chunk_visibility(elapsed, fade_ms)
-    })
-}
-/// What a section's fade depends on besides the section itself
-/// (`SectionGpu::drawn_faded`): the time, the chunk fade-in time, the sections'
-/// first uploads (`Renderer::section_uploaded`) and those held while far
-/// terrain comes in (`Renderer::lod_retiring`).
-#[derive(Clone, Copy)]
-struct FadeInputs<'a> {
-    now: Instant,
-    fade_ms: u64,
-    uploaded: &'a FxHashMap<SectionKey, Instant>,
-    retiring: &'a crate::fast_hash::FxHashSet<SectionKey>,
-}
-/// `LevelRenderer.CHUNK_VISIBILITY_THRESHOLD`: a section's block entities wait for it.
-const CHUNK_VISIBILITY_THRESHOLD: f32 = 0.3;
 /// A new value for `Renderer::block_entity_revision`.
 fn next_block_entity_revision() -> u64 {
    static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
@@ -1176,6 +1125,8 @@ pub struct Renderer {
    /// Sections upload their solid quads in the compact layout (`mesher::packed`): the solid
    /// passes read the arena themselves (`flat`) and no shader pack reads it as vertices.
    packed_quads: bool,
+    /// The compact layout is allowed (`HORIZON_PACKED_QUADS`, `set_packed_layout`).
+    packed_on: bool,
    /// The visibility buffer for flat frames' solid terrain (`visbuffer`,
    /// `HORIZON_VISBUFFER=1`).
    visbuf: Option<visbuffer::Visbuffer>,
@@ -1545,7 +1496,7 @@ pub struct Renderer {
    shadow_seen_scratch: crate::fast_hash::FxHashSet<SectionKey>,
    /// Shadow translucent section draws, retained between frames.
    shadow_translucent_scratch: Vec<(u64, [u32; 5], (u32, Option<u32>))>,
-    /// Lava's sprite layers, which a pack's solid terrain draws (`pack_atlas::terrain_parts`).
+    /// Lava's sprite layers, which a pack's solid terrain draws (`pack_atlas::game_terrain`).
    pack_lava_layers: Vec<u16>,
    pub hud: HudRenderer,
    /// Vanilla's menu background blur, made on first use.
@@ -4953,8 +4904,8 @@ impl Renderer {
            }
            None => (solid, solid_opaque, solid_cutout, solid_mirror),
        };
-        // The solid quads in the compact layout, while no shader pack reads the arena
-        // (`follow_packed_layout`).
+        // The solid quads in the compact layout where every pass reads it; the first world
+        // frames settle it for the picked pack (`follow_packed_layout`).
        let packed_quads = flat.is_some() && !shader_pack && packed_wanted();
        packed::pack_quads(packed_quads);
        // A native mod's world warp builds its pipelines with these layouts once it is given one.
@@ -5122,6 +5073,7 @@ impl Renderer {
            world_warps,
            flat_on: flat.is_some(),
            packed_quads,
+            packed_on: packed_wanted(),
            cull_on: cull.is_some(),
            sides_on: true,
            gpu_culling: None,
@@ -6758,13 +6710,17 @@ impl Renderer {
            flat.set_translucent_page_vertices(arena.page_vertices());
        }
    }
-    /// Uploads solid quads in the compact layout (`packed_quads`) while no shader pack runs:
-    /// a pack's terrain and shadow programs, and Horizon's own packs' stages, read the
-    /// arena's vertices as `TerrainVertex`es. Leaving it drops every section and far tile
-    /// for the game to mesh again, as `follow_translucent_layout` does.
+    /// Uploads solid quads in the compact layout (`packed_quads`) unless a pack reads the
+    /// arena's vertices as `TerrainVertex`es: Horizon's own packs' stages, and a `shaders/`
+    /// pack's terrain and shadow programs outside flat draws (flat ones unpack the records,
+    /// `pack_atlas::PULL_FLAT`). Leaving it drops every section and far tile for the game to
+    /// mesh again, as `follow_translucent_layout` does.
    fn follow_packed_layout(&mut self) {
        let pack = self.pack_post.as_ref().and_then(|p| p.1.as_ref()).is_some();
-        let want = self.flat.is_some() && !pack && self.native.is_none() && packed_wanted();
+        let want = self.flat.is_some()
+            && (!pack || self.pack_terrain_flat)
+            && self.native.is_none()
+            && self.packed_on;
        if want == self.packed_quads {
            return;
        }
@@ -6775,6 +6731,10 @@ impl Renderer {
            let waiting = self.hold.take_all();
            self.place_held(waiting);
        }
+        log::info!(
+            "Horizon: compact solid terrain {}",
+            if want { "on" } else { "off" }
+        );
        self.packed_quads = want;
        packed::pack_quads(want);
        let laid_out = self.sections.values().any(|s| s.packed)
@@ -6784,6 +6744,17 @@ impl Renderer {
            self.clear_sections(self.layout);
        }
    }
+    /// Allows the compact layout of solid quads or not, for A/B checks: every section and far
+    /// tile is meshed again in the layout that follows. Replies whether sections now use it.
+    pub fn set_packed_layout(&mut self, on: bool) -> bool {
+        if on != self.packed_on {
+            self.packed_on = on;
+            self.follow_packed_layout();
+            self.sections_dropped = true;
+            self.clear_sections(self.layout);
+        }
+        self.packed_quads
+    }
    /// Whether every section and far tile was dropped since the last call, to be
    /// laid out again (`follow_translucent_layout`): the game meshes them again,
    /// as for a new renderer.
@@ -7226,7 +7197,8 @@ impl Renderer {
                    .as_ref()
                    .map_or([1, 1], |t| [t.width(), t.height()]),
                terrain: self.pack_atlas.as_ref().map(|_| pack_post::Geometry {
-                    buffers: if flat { &buffers[..1] } else { &buffers },
+                    // Flat terrain programs pull their vertices (`pack_atlas::PULL_FLAT`).
+                    buffers: if flat { &[] } else { &buffers },
                    table: self.flat.as_ref().filter(|_| flat).map(|f| &f.draw_layout),
                    depth_write: true,
                    atlas: None,
@@ -7396,7 +7368,8 @@ impl Renderer {
                lightmap,
                gui_size,
                terrain: terrain.then(|| pack_post::Geometry {
-                    buffers: if flat { &buffers[..1] } else { &buffers },
+                    // Flat terrain programs pull their vertices (`pack_atlas::PULL_FLAT`).
+                    buffers: if flat { &[] } else { &buffers },
                    table: table.as_ref(),
                    depth_write: true,
                    atlas: None,
@@ -7561,15 +7534,12 @@ impl Renderer {
                );
                horizon_shaders::GeometryInputs {
                    inputs,
-                    pull: pack_atlas::PULL.to_owned(),
+                    // Flat terrain inputs pull their own vertex (`PULL_FLAT`, `gl_VertexIndex` → `hz_vertex_index`).
+                    pull: String::new(),
                    index: "hz_indices[@]".to_owned(),
                }
            });
        horizon_shaders::GameInputs {
-            terrain_parts: terrain
-                .as_ref()
-                .map(|t| pack_atlas::terrain_parts(t, &self.pack_lava_layers)),
-            terrain,
            terrain_geometry,
            entity_geometry: Some(pack_entities::geometry_inputs()),
            sky: Some(pack_sky::inputs()),
@@ -7579,6 +7549,7 @@ impl Renderer {
            weather: Some(pack_weather::inputs()),
            lines: Some(pack_lines::inputs()),
            hand: Some(pack_hand::inputs()),
+            ..pack_atlas::game_terrain(terrain, &self.pack_lava_layers)
        }
    }

@@ -15306,8 +15277,8 @@ fn log_os_reported(reported: Option<crate::graphics::Reported>) {
    });
 }
 /// What the OS reports in absolute nits, HDR output's scale (Windows: DXGI's SDR white level,
-/// the brightness slider's, as Paper White, and its `MaxLuminance`, mostly the display's EDID
-/// guess, as Peak Brightness), kept within the settings' ranges. The player's values win.
+/// the brightness slider's, as Paper White, and its `MaxLuminance`, the display's or a calibration
+/// profile's, as Peak Brightness), kept within the settings' ranges. The player's values win.
 fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported> {
    let luminance = info.luminance?;
    let usable = |n: f32| n.is_finite() && n > 0.0;
@@ -0,0 +1,42 @@
+//! A bind group's validity depends on the identity of its buffers and the
+//! bound slice, not on the bytes written into those buffers.
+
+pub(super) struct BindingKey<B, const N: usize> {
+    pub first: u64,
+    pub count: u64,
+    pub buffers: [B; N],
+}
+
+impl<B: PartialEq, const N: usize> BindingKey<B, N> {
+    pub fn matches(&self, first: u64, count: u64, buffers: [&B; N]) -> bool {
+        self.first == first
+            && self.count == count
+            && self
+                .buffers
+                .iter()
+                .zip(buffers)
+                .all(|(old, new)| old == new)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn changes_to_any_resource_or_range_invalidate_the_binding() {
+        let key = BindingKey {
+            first: 16,
+            count: 8,
+            buffers: [1u64, 2, 3, 4],
+        };
+        assert!(key.matches(16, 8, [&1, &2, &3, &4]));
+        assert!(!key.matches(0, 8, [&1, &2, &3, &4]));
+        assert!(!key.matches(16, 9, [&1, &2, &3, &4]));
+        for i in 0..4 {
+            let mut resources = [1u64, 2, 3, 4];
+            resources[i] += 100;
+            assert!(!key.matches(16, 8, resources.each_ref()));
+        }
+    }
+}
@@ -19,7 +19,10 @@
 //! start, and the run is drawn indirectly with the count the copy reached.
 use super::SolidPipeline;
 use super::arena::GRAIN;
-use smallvec::SmallVec;
+
+#[path = "binding_cache.rs"]
+mod binding_cache;
+use binding_cache::BindingKey;

 /// One section draw for `flatten.wgsl`: index count, first sorted index (or
 /// `QUADS` for a solid draw; phase 2: its entry in phase 2's draws), base
@@ -85,6 +88,11 @@ pub struct Call {
    pub count: u32,
 }

+struct CachedGroup<const N: usize> {
+    key: BindingKey<wgpu::Buffer, N>,
+    group: wgpu::BindGroup,
+}
+
 pub struct Flat {
    /// The solid draws in one pass (`fs_solid`), where the GPU doesn't hide pixels
    /// by tiles (`split_solid` in `Renderer::draw_frame`: elsewhere than Metal).
@@ -109,8 +117,9 @@ pub struct Flat {
    phase2_call_data: Vec<[u32; 5]>,
    /// GPU culling's phase 2 uses indirect draws; flat draws without culling do not.
    indirect_execution: bool,
-    /// The copy of phase 2's draws, and its ranges.
-    phase2_group: Option<(wgpu::BindGroup, u32)>,
+    /// Bindings reused while the range and all GPU buffers are unchanged.
+    phase2_group: Option<CachedGroup<4>>,
+    groups: Vec<CachedGroup<3>>,
    /// The layout of a page's bind group 1 (shader packs' terrain pipelines share it).
    pub(super) draw_layout: wgpu::BindGroupLayout,
    blocks_per_page: u64,
@@ -515,6 +524,7 @@ impl Flat {
            phase2_call_data: Vec::new(),
            indirect_execution,
            phase2_group: None,
+            groups: Vec::new(),
            draw_layout,
            blocks_per_page: page_vertices.div_ceil(GRAIN),
            translucent_blocks_per_page: page_vertices.div_ceil(GRAIN),
@@ -626,6 +636,8 @@ impl Flat {
    }
    pub fn clear(&mut self) {
        self.pages.clear();
+        self.groups.clear();
+        self.phase2_group = None;
        self.free_ids.clear();
        self.next_id = 0;
    }
@@ -665,7 +677,6 @@ impl Flat {
        sorted_page: impl Fn(u32) -> wgpu::Buffer,
        timing: Option<&mut super::pack_timing::PassTiming>,
    ) -> bool {
-        self.phase2_group = None;
        let phase2 = phase2.filter(|_| self.indirect_execution);
        let phase1_draws = if phase2.is_some() {
            phase1_draws
@@ -729,6 +740,9 @@ impl Flat {
        self.shadow_calls = shadow_calls;
        self.pass_calls = pass_calls;
        if total == 0 || total * 4 > device.limits().max_storage_buffer_binding_size {
+            // Do not retain bindings for a frame that cannot use flat draws.
+            self.phase2_group = None;
+            self.groups.clear();
            self.calls.clear();
            self.phase1_calls = 0;
            self.solid_calls = 0;
@@ -802,39 +816,63 @@ impl Flat {
            phase2,
            self.segments.iter().find(|(s, ..)| *s == Source::Seen),
        ) {
-            let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-                label: Some("Flatten phase 2 section draws"),
-                layout: &self.seen_layout,
-                entries: &[
-                    wgpu::BindGroupEntry {
-                        binding: 0,
-                        resource: ranges_at(first, count),
+            let buffers = [&self.ranges, &self.indices, phase2, &self.phase2_calls];
+            if !self
+                .phase2_group
+                .as_ref()
+                .is_some_and(|cached| cached.key.matches(first, count, buffers))
+            {
+                let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                    label: Some("Flatten phase 2 section draws"),
+                    layout: &self.seen_layout,
+                    entries: &[
+                        wgpu::BindGroupEntry {
+                            binding: 0,
+                            resource: ranges_at(first, count),
+                        },
+                        wgpu::BindGroupEntry {
+                            binding: 2,
+                            resource: self.indices.as_entire_binding(),
+                        },
+                        wgpu::BindGroupEntry {
+                            binding: 3,
+                            resource: phase2.as_entire_binding(),
+                        },
+                        wgpu::BindGroupEntry {
+                            binding: 4,
+                            resource: self.phase2_calls.as_entire_binding(),
+                        },
+                    ],
+                });
+                self.phase2_group = Some(CachedGroup {
+                    key: BindingKey {
+                        first,
+                        count,
+                        buffers: buffers.map(|b| b.clone()),
                    },
-                    wgpu::BindGroupEntry {
-                        binding: 2,
-                        resource: self.indices.as_entire_binding(),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 3,
-                        resource: phase2.as_entire_binding(),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 4,
-                        resource: self.phase2_calls.as_entire_binding(),
-                    },
-                ],
-            });
-            self.phase2_group = Some((group, count as u32));
+                    group,
+                });
+            }
+        } else {
+            self.phase2_group = None;
        }
-        let groups: SmallVec<[(wgpu::BindGroup, u32); 8]> = self
-            .segments
-            .iter()
-            .filter_map(|&(source, first, count)| {
-                let sorted = match source {
-                    Source::Quads => None,
-                    Source::Seen => return None,
-                    Source::Sorted(page) => Some(sorted_page(page)),
-                };
+        let mut groups = 0;
+        for &(source, first, count) in &self.segments {
+            let sorted = match source {
+                Source::Quads => None,
+                Source::Seen => continue,
+                Source::Sorted(page) => Some(sorted_page(page)),
+            };
+            let buffers = [
+                &self.ranges,
+                sorted.as_ref().unwrap_or(&self.empty),
+                &self.indices,
+            ];
+            if self
+                .groups
+                .get(groups)
+                .is_none_or(|cached| !cached.key.matches(first, count, buffers))
+            {
                let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
                    label: Some("Flatten section draws"),
                    layout: &self.compute_layout,
@@ -845,7 +883,7 @@ impl Flat {
                        },
                        wgpu::BindGroupEntry {
                            binding: 1,
-                            resource: sorted.as_ref().unwrap_or(&self.empty).as_entire_binding(),
+                            resource: buffers[1].as_entire_binding(),
                        },
                        wgpu::BindGroupEntry {
                            binding: 2,
@@ -853,17 +891,32 @@ impl Flat {
                        },
                    ],
                });
-                Some((group, count as u32))
-            })
-            .collect();
+                let cached = CachedGroup {
+                    key: BindingKey {
+                        first,
+                        count,
+                        buffers: buffers.map(|b| b.clone()),
+                    },
+                    group,
+                };
+                if groups < self.groups.len() {
+                    self.groups[groups] = cached;
+                } else {
+                    self.groups.push(cached);
+                }
+            }
+            groups += 1;
+        }
+        self.groups.truncate(groups);
        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
            label: Some("Flatten section draws"),
            timestamp_writes: timing.and_then(|t| t.compute_writes("Flatten")),
        });
        pass.set_pipeline(&self.flatten);
-        for (group, count) in &groups {
-            pass.set_bind_group(0, group, &[]);
-            pass.dispatch_workgroups((*count).min(GROUP_LIMIT), count.div_ceil(GROUP_LIMIT), 1);
+        for cached in &self.groups {
+            let count = cached.key.count as u32;
+            pass.set_bind_group(0, &cached.group, &[]);
+            pass.dispatch_workgroups(count.min(GROUP_LIMIT), count.div_ceil(GROUP_LIMIT), 1);
        }
        drop(pass);
        true
@@ -919,16 +972,17 @@ impl Flat {
        encoder: &mut wgpu::CommandEncoder,
        timing: Option<&mut super::pack_timing::PassTiming>,
    ) {
-        let Some((group, count)) = &self.phase2_group else {
+        let Some(cached) = &self.phase2_group else {
            return;
        };
+        let count = cached.key.count as u32;
        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
            label: Some("Flatten phase 2 section draws"),
            timestamp_writes: timing.and_then(|t| t.compute_writes("Flatten phase 2")),
        });
        pass.set_pipeline(&self.flatten_seen);
-        pass.set_bind_group(0, group, &[]);
-        pass.dispatch_workgroups((*count).min(GROUP_LIMIT), count.div_ceil(GROUP_LIMIT), 1);
+        pass.set_bind_group(0, &cached.group, &[]);
+        pass.dispatch_workgroups(count.min(GROUP_LIMIT), count.div_ceil(GROUP_LIMIT), 1);
    }

    /// The camera's translucent calls.
@@ -169,7 +169,8 @@ pub struct Hdr {
    hand_mark: wgpu::RenderPipeline,
    params: wgpu::Buffer,
    /// The same pass drawing HDR10 for a screenshot (`capture`), with its own parameters,
-    /// so it can differ from the swapchain's in one frame.
+    /// so it can differ from the swapchain's in one frame, and without the swapchain's dither:
+    /// a screenshot keeps the exact codes.
    capture_pipeline: wgpu::RenderPipeline,
    capture_params: wgpu::Buffer,
    pub output: Output,
@@ -286,8 +287,9 @@ impl Hdr {
                entries: &entries,
            })
        };
-        // One full-screen pass of hdr.wgsl's `entry` into `format`, reading `layout`.
-        let pass = |label, layout: &wgpu::BindGroupLayout, entry, format| {
+        // One full-screen pass of hdr.wgsl's `entry` into `format`, reading `layout`; `dither`
+        // for the last pass into the HDR10 swapchain (`pq_dither`).
+        let pass = |label, layout: &wgpu::BindGroupLayout, entry, format, dither: bool| {
            let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                label: Some(label),
                bind_group_layouts: &[Some(layout)],
@@ -308,7 +310,10 @@ impl Hdr {
                fragment: Some(wgpu::FragmentState {
                    module: &shader,
                    entry_point: Some(entry),
-                    compilation_options: Default::default(),
+                    compilation_options: wgpu::PipelineCompilationOptions {
+                        constants: &[("pq_dither", f64::from(u8::from(dither)))],
+                        ..Default::default()
+                    },
                    targets: &[Some(wgpu::ColorTargetState {
                        format,
                        blend: None,
@@ -321,7 +326,8 @@ impl Hdr {
        };
        let layout_bindings: &[u32] = if coverage { &[0, 3, 4, 5] } else { &[0, 1, 3] };
        let display = layout("Horizon HDR bindings", layout_bindings, true);
-        let pipeline_for = |format| pass("Horizon HDR", &display, entry_point, format);
+        let pipeline_for =
+            |format, dither| pass("Horizon HDR", &display, entry_point, format, dither);
        let params = || {
            device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Horizon HDR parameters"),
@@ -333,7 +339,7 @@ impl Hdr {
        let layered = coverage.then(|| {
            let with = |label, textures: &[u32], params, entry, format| {
                let layout = layout(label, textures, params);
-                let pipeline = pass(label, &layout, entry, format);
+                let pipeline = pass(label, &layout, entry, format, false);
                (layout, pipeline)
            };
            let hud = super::hud_coverage::HUD_FORMAT;
@@ -395,8 +401,8 @@ impl Hdr {
        );
        Self {
            logo: logo_mask(device, queue),
-            pipeline: pipeline_for(output.format()),
-            capture_pipeline: pipeline_for(Output::Pq.format()),
+            pipeline: pipeline_for(output.format(), output == Output::Pq),
+            capture_pipeline: pipeline_for(Output::Pq.format(), false),
            layout: display,
            clear_alpha,
            hand_mark,
@@ -1709,19 +1715,32 @@ struct ReferenceParams { peak: f32, scene: f32, world: f32, debug: f32, share: v
                    super::super::hud_coverage::clear(&mut encoder, &hdr.coverage_view().unwrap());
                    hdr.begin(&queue, true);
                    hdr.present(&queue, &mut encoder, &target, true, None);
-                    let got = texel(&device, &queue, encoder, &target);
-                    for c in &got[..3] {
-                        let c = f64::from(*c);
-                        let ok = match output {
-                            // 10-bit codes, a step either way for rounding.
-                            Output::Pq => (c - 1023.0 * pq(want)).abs() <= 1.0,
-                            // 80 nits a unit, in half floats.
-                            Output::ScRgb => (c * 80.0 - want).abs() <= 2e-3 * want + 1e-4,
+                    // HDR10's exact codes are a screenshot's copy: the swapchain's own get a
+                    // code of dither either way.
+                    let exact = (output == Output::Pq)
+                        .then(|| hdr.capture(&device, &queue, &mut encoder, true).unwrap());
+                    let presented = texel(&device, &queue, encoder, &target);
+                    let exact = exact.map(|copy| {
+                        let encoder = device.create_command_encoder(&Default::default());
+                        texel(&device, &queue, encoder, &copy)
+                    });
+                    for (got, codes) in [(Some(presented), 2.0), (exact, 1.0)] {
+                        let Some(got) = got else {
+                            continue;
                        };
-                        assert!(
-                            ok,
-                            "{output:?} black {black}, light {light}: {got:?}, not {want} nits"
-                        );
+                        for c in &got[..3] {
+                            let c = f64::from(*c);
+                            let ok = match output {
+                                // 10-bit codes, a step either way for rounding.
+                                Output::Pq => (c - 1023.0 * pq(want)).abs() <= codes,
+                                // 80 nits a unit, in half floats.
+                                Output::ScRgb => (c * 80.0 - want).abs() <= 2e-3 * want + 1e-4,
+                            };
+                            assert!(
+                                ok,
+                                "{output:?} black {black}, light {light}: {got:?}, not {want} nits"
+                            );
+                        }
                    }
                }
            }
@@ -2078,3 +2097,7 @@ mod lighting_tests {
 #[cfg(test)]
 #[path = "hdr_written_tests.rs"]
 mod written_tests;
+
+#[cfg(test)]
+#[path = "hdr_dither_tests.rs"]
+mod dither_tests;
@@ -0,0 +1,313 @@
+//! HDR10's dither (`hdr.wgsl`, `dithered`): the last pass into the 10-bit swapchain, and what
+//! must stay without it.
+use super::{
+    Hdr, Output,
+    tests::{fill, gpu},
+};
+use wgpu::TextureFormat as F;
+
+const SIZE: [u32; 2] = [64, 1024];
+/// The ramp: grey rising by one half-float step every `ROWS` rows from `FIRST / 2048`. That is
+/// three PQ codes down the picture around 91 nits: as slow as a clear sky, and as fine as the
+/// float frame holds.
+const FIRST: u32 = 1434;
+const ROWS: u32 = 52;
+
+/// SMPTE ST 2084: nits as a 10-bit PQ code, before rounding.
+fn code(nits: f64) -> f64 {
+    let y = (nits / 10_000.0).powf(0.1593017578125);
+    1023.0 * ((0.8359375 + 18.8515625 * y) / (1.0 + 18.6875 * y)).powf(78.84375)
+}
+
+/// The ramp's row `y` as a PQ code, at the 200-nit paper white `Hdr` starts with.
+fn ramp_code(y: u32) -> f64 {
+    code(200.0 * (f64::from(FIRST + y / ROWS) / 2048.0).powf(2.2))
+}
+
+fn ramp(device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, frame: &wgpu::Texture) {
+    let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: None,
+        source: wgpu::ShaderSource::Wgsl(
+            format!(
+                r#"
+@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {{
+    return vec4(vec2(f32((i << 1u) & 2u), f32(i & 2u)) * 2.0 - 1.0, 0.0, 1.0);
+}}
+@fragment fn fs(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {{
+    return vec4(vec3(f32({FIRST}u + u32(pos.y) / {ROWS}u) / 2048.0), 1.0);
+}}
+"#
+            )
+            .into(),
+        ),
+    });
+    let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: None,
+        layout: None,
+        vertex: wgpu::VertexState {
+            module: &shader,
+            entry_point: Some("vs"),
+            compilation_options: Default::default(),
+            buffers: &[],
+        },
+        primitive: Default::default(),
+        depth_stencil: None,
+        multisample: Default::default(),
+        fragment: Some(wgpu::FragmentState {
+            module: &shader,
+            entry_point: Some("fs"),
+            compilation_options: Default::default(),
+            targets: &[Some(frame.format().into())],
+        }),
+        multiview_mask: None,
+        cache: None,
+    });
+    let view = frame.create_view(&Default::default());
+    let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+        color_attachments: &[Some(super::super::hud_coverage::attachment(&view))],
+        ..Default::default()
+    });
+    pass.set_pipeline(&pipeline);
+    pass.draw(0..3, 0..1);
+}
+
+/// What `hdr` writes for the float frame `paint` fills, with no HUD over it: its last pass into
+/// a swapchain image of its output (`Hdr::present`), or a screenshot's HDR10 copy
+/// (`Hdr::capture`). Every pixel's bytes, row by row.
+fn shown(
+    (device, queue): &(wgpu::Device, wgpu::Queue),
+    hdr: &mut Hdr,
+    screenshot: bool,
+    paint: impl Fn(&mut wgpu::CommandEncoder, &wgpu::Texture),
+) -> Vec<u8> {
+    let frame = hdr.frame(device, SIZE);
+    let mut encoder = device.create_command_encoder(&Default::default());
+    paint(&mut encoder, &frame);
+    hdr.keep_world(&mut encoder, None);
+    super::super::hud_coverage::clear(&mut encoder, &hdr.coverage_view().unwrap());
+    let image = if screenshot {
+        hdr.capture(device, queue, &mut encoder, true).unwrap()
+    } else {
+        let image = device.create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            size: frame.size(),
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: hdr.output.format(),
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            view_formats: &[],
+        });
+        hdr.present(queue, &mut encoder, &image, true, None);
+        image
+    };
+    let row = SIZE[0] * image.format().block_copy_size(None).unwrap();
+    let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+        label: None,
+        size: u64::from(row * SIZE[1]),
+        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+        mapped_at_creation: false,
+    });
+    encoder.copy_texture_to_buffer(
+        image.as_image_copy(),
+        wgpu::TexelCopyBufferInfo {
+            buffer: &buffer,
+            layout: wgpu::TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(row),
+                rows_per_image: None,
+            },
+        },
+        image.size(),
+    );
+    queue.submit([encoder.finish()]);
+    buffer.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+    buffer.get_mapped_range(..).unwrap().to_vec()
+}
+
+fn float_hdr((device, queue): &(wgpu::Device, wgpu::Queue), output: Output) -> Hdr {
+    Hdr::with_debug(device, queue, F::Rgba16Float, output, true, None)
+}
+
+/// An HDR10 picture's 10-bit codes, red, green and blue.
+fn codes(bytes: &[u8]) -> Vec<[u32; 3]> {
+    let pixels = bytes.as_chunks::<4>().0.iter();
+    pixels
+        .map(|p| [0, 10, 20].map(|shift| (u32::from_le_bytes(*p) >> shift) & 0x3ff))
+        .collect()
+}
+
+/// Down every column of a channel: the longest run of rows with one code, and the runs' mean
+/// length.
+fn runs(codes: &[[u32; 3]], channel: usize) -> (u32, f64) {
+    let (mut longest, mut count) = (0, 0);
+    for x in 0..SIZE[0] {
+        let mut run = 0;
+        for y in 0..SIZE[1] {
+            let at = |y: u32| codes[(y * SIZE[0] + x) as usize][channel];
+            if y > 0 && at(y) != at(y - 1) {
+                (longest, count, run) = (longest.max(run), count + 1, 0);
+            }
+            run += 1;
+        }
+        (longest, count) = (longest.max(run), count + 1);
+    }
+    (longest, f64::from(SIZE[0] * SIZE[1]) / f64::from(count))
+}
+
+/// Whether every row of a picture is one value from side to side: no noise in it.
+fn rows_are_flat(bytes: &[u8]) -> bool {
+    let pixel = bytes.len() / (SIZE[0] * SIZE[1]) as usize;
+    bytes
+        .chunks(pixel * SIZE[0] as usize)
+        .all(|row| row.chunks(pixel).all(|p| p == &row[..pixel]))
+}
+
+#[test]
+fn a_slow_gradient_gets_grain_instead_of_bands_on_hdr10() {
+    let Some(gpu) = gpu() else {
+        return;
+    };
+    let ramp = |encoder: &mut wgpu::CommandEncoder, frame: &wgpu::Texture| {
+        ramp(&gpu.0, encoder, frame);
+    };
+    let mut hdr = float_hdr(&gpu, Output::Pq);
+    // The ramp is what the test says: three codes, top to bottom.
+    let span = ramp_code(SIZE[1] - 1) - ramp_code(0);
+    assert!((2.9..3.2).contains(&span), "{span}");
+    // Without dither, as a screenshot's copy stays: each row its nearest code, in bands hundreds
+    // of rows tall. A GPU need not round at exactly half a code: an NVIDIA one rounds up from
+    // 0.55 here, which shows as 0.05 of a code less, so the bounds below leave a quarter code.
+    let plain = codes(&shown(&gpu, &mut hdr, true, ramp));
+    let dithered = codes(&shown(&gpu, &mut hdr, false, ramp));
+    let want = |i: usize| ramp_code(i as u32 / SIZE[0]);
+    for channel in 0..3 {
+        for (i, p) in plain.iter().enumerate() {
+            let off = (f64::from(p[channel]) - want(i)).abs();
+            assert!(
+                off <= 0.75,
+                "plain {channel} at {i}: {p:?}, not {}",
+                want(i)
+            );
+        }
+        let (longest, _) = runs(&plain, channel);
+        assert!(longest >= 250, "plain {channel}: bands of {longest} rows");
+        // With it: each pixel within the noise's one code of its light (and half a code of
+        // rounding), no column holds a code for long, and a run is a few rows on average.
+        for (i, d) in dithered.iter().enumerate() {
+            let off = (f64::from(d[channel]) - want(i)).abs();
+            assert!(
+                off <= 1.75,
+                "dithered {channel} at {i}: {d:?}, not {}",
+                want(i)
+            );
+        }
+        let (longest, mean) = runs(&dithered, channel);
+        eprintln!(
+            "HDR10 dither GPU, channel {channel}: longest run {longest} rows, mean {mean:.2}"
+        );
+        assert!(longest <= 64, "dithered {channel}: a run of {longest} rows");
+        assert!(mean < 4.0, "dithered {channel}: runs of {mean} rows");
+        // The mean of each 64-row block is the light meant.
+        let mut worst = 0.0_f64;
+        for block in 0..SIZE[1] / 64 {
+            let rows = (block * 64 * SIZE[0]) as usize..((block + 1) * 64 * SIZE[0]) as usize;
+            let n = rows.len() as f64;
+            let got = dithered[rows.clone()]
+                .iter()
+                .map(|d| f64::from(d[channel]))
+                .sum::<f64>()
+                / n;
+            let meant = rows.map(want).sum::<f64>() / n;
+            worst = worst.max((got - meant).abs());
+            assert!(
+                (got - meant).abs() < 0.25,
+                "block {block} of {channel}: {got}, not {meant}"
+            );
+        }
+        eprintln!("HDR10 dither GPU, channel {channel}: block means within {worst:.3} of a code");
+    }
+}
+
+#[test]
+fn hdr10s_dither_keeps_both_ends_exact_and_leans_to_them_in_their_last_code() {
+    let Some(gpu) = gpu() else {
+        return;
+    };
+    let mut hdr = float_hdr(&gpu, Output::Pq);
+    let grey = |g: f64| {
+        move |encoder: &mut wgpu::CommandEncoder, frame: &wgpu::Texture| {
+            fill(encoder, frame, [g, g, g, 1.0]);
+        }
+    };
+    // How far the picture's mean code is from `end`.
+    let mean_from = |picture: &[[u32; 3]], end: f64| {
+        let sum: f64 = picture.iter().flatten().map(|c| f64::from(*c)).sum();
+        (sum / (picture.len() * 3) as f64 - end).abs()
+    };
+    // Within a code of an end the noise shrinks to the distance to it. A third of a code from
+    // the end, the signal plus that noise passes half a code only where the noise is over half
+    // its range, an eighth of a triangle: so the picture's mean is an eighth of a code from the
+    // end, not a third. That lean to the end, in the last code alone, is the price of keeping
+    // the end itself exact. Bound: a GPU that rounds a tenth of a code off the half (as above)
+    // shows between 0.02 and 0.32 of a code, always short of the third.
+    let leans = |mean: f64| (0.015..0.325).contains(&mean);
+
+    // Black gets no noise: every pixel stays off.
+    let black = codes(&shown(&gpu, &mut hdr, false, grey(0.0)));
+    assert!(black.iter().all(|p| *p == [0; 3]));
+    // A third of a code above black (this grey is a half float): 0 or 1, never lifted past it.
+    let dim = 0.00038433074951171875;
+    let meant = code(200.0 * f64::powf(dim, 2.2));
+    assert!((meant - 1.0 / 3.0).abs() < 0.001, "{meant}");
+    let near_black = codes(&shown(&gpu, &mut hdr, false, grey(dim)));
+    assert!(near_black.iter().flatten().all(|c| *c <= 1));
+    let mean = mean_from(&near_black, 0.0);
+    eprintln!("HDR10 dither GPU: a third of a code above black shows as {mean:.3}");
+    assert!(leans(mean), "{mean} above black");
+
+    // The top of the range, PQ's 10 000 nits, stays the top: nothing wraps or dims. Light past
+    // the peak is held at it, so the Peak setting is the signal here.
+    hdr.peak = 10_000.0;
+    let top = codes(&shown(&gpu, &mut hdr, false, grey(20.0)));
+    assert!(top.iter().all(|p| *p == [1023; 3]));
+    // A third of a code under the top, mirrored: 1022 or 1023.
+    let (mut under, mut over) = (9000.0, 10_000.0);
+    for _ in 0..60 {
+        let middle = (under + over) / 2.0;
+        if code(middle) < 1023.0 - 1.0 / 3.0 {
+            under = middle;
+        } else {
+            over = middle;
+        }
+    }
+    hdr.peak = under as f32;
+    let meant = code(f64::from(hdr.peak));
+    assert!((1023.0 - meant - 1.0 / 3.0).abs() < 0.001, "{meant}");
+    let near_top = codes(&shown(&gpu, &mut hdr, false, grey(20.0)));
+    assert!(near_top.iter().flatten().all(|c| *c >= 1022));
+    let mean = mean_from(&near_top, 1023.0);
+    eprintln!("HDR10 dither GPU: a third of a code under the top shows as {mean:.3} under");
+    assert!(leans(mean), "{mean} under the top");
+}
+
+#[test]
+fn scrgb_and_screenshots_get_no_dither() {
+    let Some(gpu) = gpu() else {
+        return;
+    };
+    let ramp = |encoder: &mut wgpu::CommandEncoder, frame: &wgpu::Texture| {
+        ramp(&gpu.0, encoder, frame);
+    };
+    let (mut hdr10, mut scrgb) = (float_hdr(&gpu, Output::Pq), float_hdr(&gpu, Output::ScRgb));
+    // scRGB's swapchain is float: every row is one value from side to side.
+    assert!(rows_are_flat(&shown(&gpu, &mut scrgb, false, ramp)));
+    // A screenshot's HDR10 copy is the same bytes whichever swapchain is presented, the
+    // dithered one included, and has no noise in it.
+    let screenshot = shown(&gpu, &mut hdr10, true, ramp);
+    assert!(rows_are_flat(&screenshot));
+    assert_eq!(screenshot, shown(&gpu, &mut scrgb, true, ramp));
+    // The swapchain's own picture differs from it: the dither is on there.
+    assert_ne!(screenshot, shown(&gpu, &mut hdr10, false, ramp));
+}
@@ -8,7 +8,7 @@

 use glam::{Mat4, Vec3};
 use horizon_shader_api::{
-    Api, Frame as FrameInputs, StageKind, check::CheckedStage, stages::GROUP,
+    Api, Frame as FrameInputs, Primaries, StageKind, check::CheckedStage, stages::GROUP,
 };

 use super::Frame;
@@ -1596,7 +1596,11 @@ pub fn frame_inputs(
        paper_white: 80.0,
        peak: 80.0,
        black_level: 0.0,
-        padding: [0; 3],
+        // No pack is served another space yet (`[frame] primaries`).
+        primaries: Primaries::Bt709 as u32,
+        luminance_gap: [0; 2],
+        luminance: Primaries::Bt709.luminance(),
+        padding: 0,
    }
 }

@@ -548,27 +548,107 @@ impl PackAtlas {
    }
 }

-/// A `TerrainVertex` of flat draws' arena page (`hz_vertices`, six words each) into the vertex
-/// inputs, for vertex `hz_vertex_index`.
-pub const PULL: &str = "        uint hz_pw = hz_vertex_index * 6u;\n        \
-    hz_v_pos = uintBitsToFloat(uvec3(hz_vertices[hz_pw], hz_vertices[hz_pw + 1u], hz_vertices[hz_pw + 2u]));\n        \
-    hz_v_uv = uvec2(hz_vertices[hz_pw + 3u] & 65535u, hz_vertices[hz_pw + 3u] >> 16u);\n        \
-    hz_v_layer = hz_vertices[hz_pw + 4u] & 65535u;\n        \
-    uint hz_pl = hz_vertices[hz_pw + 4u] >> 16u;\n        \
-    hz_v_light = uvec2(hz_pl & 255u, hz_pl >> 8u);\n        \
-    hz_v_color = unpackUnorm4x8(hz_vertices[hz_pw + 5u]);\n";
+/// GLSL: terrain.wgsl's `section_corner` over the arena page (`hz_vertices`), by quad: a
+/// vertex's words as `TerrainVertex` holds them (position, then UV, layer with light, colour),
+/// from vertices below `PACKED_BASE` or a compact record (`mesher/packed.rs`) past it. Records
+/// give back their quad's vertices bit for bit, so packs read either layout alike.
+/// `hz_arena_corner`: a vertex's position and UV words; `hz_record_corner`: corner `k`'s of the
+/// record `lo`, `hi`; `hz_record_rest`: its layer-with-light and colour words.
+const CORNER_FN: &str = "void hz_arena_corner(uint hz_av, out uvec3 hz_p, out uint hz_uv) {\n    \
+    uint hz_w = hz_av * 6u;\n    \
+    hz_p = uvec3(hz_vertices[hz_w], hz_vertices[hz_w + 1u], hz_vertices[hz_w + 2u]);\n    \
+    hz_uv = hz_vertices[hz_w + 3u];\n\
+}\n\
+uint hz_corner_offset(uint hz_rel, uint hz_side, uint hz_du, uint hz_dw) {\n    \
+    return hz_rel == 0u ? hz_side : (hz_rel == 1u ? hz_du : hz_dw);\n\
+}\n\
+void hz_record_corner(uvec3 hz_lo, uvec3 hz_hi, uint hz_k, out uvec3 hz_p, out uint hz_uv) {\n    \
+    uint hz_o = (hz_hi.z >> 12u) & 0x3ffffu;\n    \
+    uvec3 hz_block = uvec3(hz_o & 15u, (hz_o >> 4u) & 15u, (hz_o >> 8u) & 15u);\n    \
+    uint hz_axis = (hz_o >> 12u) & 3u;\n    \
+    uint hz_side = (hz_o >> 14u) & 1u;\n    \
+    uint hz_step = (((hz_o >> 15u) & 3u) + (((hz_o >> 17u) & 1u) == 1u ? 4u - hz_k : hz_k)) & 3u;\n    \
+    uint hz_du = (hz_step == 1u || hz_step == 2u) ? 1u : 0u;\n    \
+    uint hz_dw = hz_step >= 2u ? 1u : 0u;\n    \
+    uvec3 hz_pos = hz_block + uvec3(hz_corner_offset((3u - hz_axis) % 3u, hz_side, hz_du, hz_dw),\n        \
+        hz_corner_offset((4u - hz_axis) % 3u, hz_side, hz_du, hz_dw),\n        \
+        hz_corner_offset((5u - hz_axis) % 3u, hz_side, hz_du, hz_dw));\n    \
+    uint hz_sel = hz_lo.z >> 24u;\n    \
+    uint hz_u = (hz_lo.z >> (6u * ((hz_sel >> (2u * hz_k)) & 1u))) & 63u;\n    \
+    uint hz_v = (hz_lo.z >> (12u + 6u * ((hz_sel >> (2u * hz_k + 1u)) & 1u))) & 63u;\n    \
+    hz_p = floatBitsToUint(vec3(hz_pos));\n    \
+    hz_uv = (hz_u << 10u) | (hz_v << 26u);\n\
+}\n\
+uvec2 hz_record_rest(uvec3 hz_lo, uvec3 hz_hi, uint hz_k) {\n    \
+    uint hz_l = hz_k == 0u ? hz_hi.x >> 16u : (hz_k == 1u ? hz_hi.y : (hz_k == 2u ? hz_hi.y >> 12u : hz_hi.z));\n    \
+    hz_l &= 0xfffu;\n    \
+    uint hz_pl = ((hz_l & 63u) << 2u) | (((hz_l >> 6u) & 63u) << 10u);\n    \
+    uint hz_g = (hz_lo.y >> (8u * hz_k)) & 255u;\n    \
+    uint hz_t = hz_lo.x;\n    \
+    uint hz_code = hz_k == 1u ? (hz_hi.x >> 28u) & 7u : (hz_k == 2u ? (hz_hi.y >> 24u) & 7u\n        \
+        : (hz_k == 3u ? (hz_hi.y >> 27u) & 7u : 0u));\n    \
+    uint hz_alpha = hz_code == 0u ? hz_t & 0xff000000u : (hz_code * 51u) << 24u;\n    \
+    uint hz_c = (hz_g * ((hz_t >> 16u) & 255u) / 255u) | ((hz_g * ((hz_t >> 8u) & 255u) / 255u) << 8u)\n        \
+        | ((hz_g * (hz_t & 255u) / 255u) << 16u) | hz_alpha;\n    \
+    return uvec2((hz_hi.x & 0xffffu) | (hz_pl << 16u), hz_c);\n\
+}\n";
+
+/// GLSL: a flat-drawn vertex's inputs, and its quad's four corners' positions (`hz_cp0`..) and
+/// UV words (`hz_uv0`..), pulled from the arena page as terrain.wgsl's `vs_section_flat` pulls
+/// them (`CORNER_FN`): a record is read once for all four, and only the vertex's own light and
+/// colour are worked out. `hz_slot`: the slot its block is found by (`hz_block_slots`, 256 a
+/// block). The colour as the vertex fetch converts a Unorm8x4 (terrain.wgsl's `unorm8x4`).
+const PULL_FLAT: &str = "    uint hz_qv = uint(gl_VertexIndex);\n    \
+    uint hz_own = hz_qv & 3u;\n    \
+    uint hz_av = hz_qv & ~3u;\n    \
+    uint hz_slot = hz_qv;\n    \
+    bool hz_rec = false;\n    \
+    uvec3 hz_lo = uvec3(0u);\n    \
+    uvec3 hz_hi = uvec3(0u);\n    \
+    if (hz_av >= 0x10000000u) {\n        \
+        hz_slot = (hz_av - 0x10000000u) >> 2u;\n        \
+        uint hz_rw = hz_slot * 6u;\n        \
+        hz_lo = uvec3(hz_vertices[hz_rw], hz_vertices[hz_rw + 1u], hz_vertices[hz_rw + 2u]);\n        \
+        hz_hi = uvec3(hz_vertices[hz_rw + 3u], hz_vertices[hz_rw + 4u], hz_vertices[hz_rw + 5u]);\n        \
+        hz_rec = (hz_hi.z & 0x80000000u) == 0u;\n        \
+        hz_av = hz_slot + hz_lo.x;\n    \
+    }\n    \
+    uvec3 hz_cp0; uvec3 hz_cp1; uvec3 hz_cp2; uvec3 hz_cp3;\n    \
+    uint hz_uv0; uint hz_uv1; uint hz_uv2; uint hz_uv3;\n    \
+    uvec2 hz_rest;\n    \
+    if (hz_rec) {\n        \
+        hz_record_corner(hz_lo, hz_hi, 0u, hz_cp0, hz_uv0);\n        \
+        hz_record_corner(hz_lo, hz_hi, 1u, hz_cp1, hz_uv1);\n        \
+        hz_record_corner(hz_lo, hz_hi, 2u, hz_cp2, hz_uv2);\n        \
+        hz_record_corner(hz_lo, hz_hi, 3u, hz_cp3, hz_uv3);\n        \
+        hz_rest = hz_record_rest(hz_lo, hz_hi, hz_own);\n    \
+    } else {\n        \
+        hz_arena_corner(hz_av, hz_cp0, hz_uv0);\n        \
+        hz_arena_corner(hz_av + 1u, hz_cp1, hz_uv1);\n        \
+        hz_arena_corner(hz_av + 2u, hz_cp2, hz_uv2);\n        \
+        hz_arena_corner(hz_av + 3u, hz_cp3, hz_uv3);\n        \
+        uint hz_ow = (hz_av + hz_own) * 6u;\n        \
+        hz_rest = uvec2(hz_vertices[hz_ow + 4u], hz_vertices[hz_ow + 5u]);\n    \
+    }\n    \
+    uvec3 hz_vp = hz_own == 0u ? hz_cp0 : (hz_own == 1u ? hz_cp1 : (hz_own == 2u ? hz_cp2 : hz_cp3));\n    \
+    uvec3 hz_vr = uvec3(hz_own == 0u ? hz_uv0 : (hz_own == 1u ? hz_uv1 : (hz_own == 2u ? hz_uv2 : hz_uv3)), hz_rest);\n    \
+    hz_v_pos = uintBitsToFloat(hz_vp);\n    \
+    hz_v_uv = uvec2(hz_vr.x & 65535u, hz_vr.x >> 16u);\n    \
+    hz_v_layer = hz_vr.y & 65535u;\n    \
+    hz_v_light = uvec2((hz_vr.y >> 16u) & 255u, hz_vr.y >> 24u);\n    \
+    hz_v_color = vec4(float(hz_vr.z & 255u), float((hz_vr.z >> 8u) & 255u), float((hz_vr.z >> 16u) & 255u),\n        \
+        float(hz_vr.z >> 24u)) * (1.0 / 255.0);\n";

 /// GLSL: the face normal and tangent of a flat-drawn vertex, from its quad's first three corners
-/// (quads are four consecutive vertices of the page; position words 0-2, UV word 3).
-const FACE: &str = "    uint hz_q = (uint(gl_VertexIndex) & ~3u) * 6u;\n    \
-    vec3 hz_p0 = uintBitsToFloat(uvec3(hz_vertices[hz_q], hz_vertices[hz_q + 1u], hz_vertices[hz_q + 2u]));\n    \
-    vec3 hz_p1 = uintBitsToFloat(uvec3(hz_vertices[hz_q + 6u], hz_vertices[hz_q + 7u], hz_vertices[hz_q + 8u]));\n    \
-    vec3 hz_p2 = uintBitsToFloat(uvec3(hz_vertices[hz_q + 12u], hz_vertices[hz_q + 13u], hz_vertices[hz_q + 14u]));\n    \
-    uvec3 hz_w = uvec3(hz_vertices[hz_q + 3u], hz_vertices[hz_q + 9u], hz_vertices[hz_q + 15u]);\n    \
+/// (`PULL_FLAT`'s corners: four consecutive vertex indices, in either layout).
+const FACE: &str = "    vec3 hz_p0 = uintBitsToFloat(hz_cp0);\n    \
+    vec3 hz_p1 = uintBitsToFloat(hz_cp1);\n    \
+    vec3 hz_p2 = uintBitsToFloat(hz_cp2);\n    \
+    uvec3 hz_w = uvec3(hz_uv0, hz_uv1, hz_uv2);\n    \
    vec2 hz_t0 = vec2(hz_w.x & 65535u, hz_w.x >> 16u);\n    \
    vec2 hz_d1 = vec2(hz_w.y & 65535u, hz_w.y >> 16u) - hz_t0;\n    \
    vec2 hz_d2 = vec2(hz_w.z & 65535u, hz_w.z >> 16u) - hz_t0;\n    \
-    uint hz_w3 = hz_vertices[hz_q + 21u];\n    \
+    uint hz_w3 = hz_uv3;\n    \
    vec2 hz_t3 = vec2(hz_w3 & 65535u, hz_w3 >> 16u);\n    \
    hz_mid = (clamp(hz_t0 * hz_uv_scale, 0.0, 1.0) + clamp((hz_t0 + hz_d1) * hz_uv_scale, 0.0, 1.0)\n        \
        + clamp((hz_t0 + hz_d2) * hz_uv_scale, 0.0, 1.0) + clamp(hz_t3 * hz_uv_scale, 0.0, 1.0)) * 0.25;\n    \
@@ -586,45 +666,71 @@ const FACE: &str = "    uint hz_q = (uint(gl_VertexIndex) & ~3u) * 6u;\n    \
        }\n    \
    }\n";

-/// `terrain` (`PackAtlas::terrain_inputs`) drawing only solid terrain, then only cutout terrain:
-/// each leaves the other part's quads outside the clip volume. Solid: the quads over opaque
-/// texels and opaque leaves (`mesher::OPAQUE_LAYER`), as vanilla picks `ChunkSectionLayer.SOLID`
-/// per quad (`FaceBakery.computeMaterialTransparency`, `SectionCompiler.compile`), and lava's
-/// faces (sprite layers `lava`, its still and flowing sprites), which Iris 1.11.7 drew with
-/// `gbuffers_terrain_solid` in our probes, with and without `separateAo`.
+/// GLSL: whether a terrain vertex's quad is solid terrain rather than cutout. Solid: the quads
+/// over opaque texels and opaque leaves (`mesher::OPAQUE_LAYER`), as vanilla picks
+/// `ChunkSectionLayer.SOLID` per quad (`FaceBakery.computeMaterialTransparency`,
+/// `SectionCompiler.compile`), and lava's faces (sprite layers `lava`, its still and flowing
+/// sprites), which Iris 1.11.7 drew with `gbuffers_terrain_solid` in our probes, with and
+/// without `separateAo`.
 ///
 /// The test reads only the vertex's sprite layer, which all four vertices of a quad share: a
 /// quad lands whole in one part. The colour's alpha can't decide it, as with `separateAo` it
 /// holds each vertex's own ambient occlusion.
-pub fn terrain_parts(
-    terrain: &horizon_shaders::GbuffersInputs,
-    lava: &[u16],
-) -> [horizon_shaders::GbuffersInputs; 2] {
+fn solid(lava: &[u16]) -> String {
    let opaque = crate::mesher::OPAQUE_LAYER;
    let lava: String = lava
        .iter()
        .map(|l| format!(" || hz_v_layer == {l}u"))
        .collect();
-    let part = |solid: bool| {
+    format!("(hz_v_layer & {opaque}u) != 0u{lava}")
+}
+
+/// The game's `terrain` inputs (`PackAtlas::terrain_inputs`) for a pack: whole; drawing only
+/// solid terrain, then only cutout terrain (`solid`), each leaving the other part's quads outside
+/// the clip volume; and drawing both in one pass, each quad with its part's alpha test.
+pub fn game_terrain(
+    terrain: Option<horizon_shaders::GbuffersInputs>,
+    lava: &[u16],
+) -> horizon_shaders::GameInputs {
+    let solid = solid(lava);
+    let part = |terrain: &horizon_shaders::GbuffersInputs, part: bool| {
        let mut inputs = terrain.clone();
        inputs.after.push_str(&format!(
-            "    bool hz_solid = (hz_v_layer & {opaque}u) != 0u{lava};\n    \
-             if (hz_solid != {solid}) gl_Position = vec4(2.0, 2.0, 2.0, 1.0);\n"
+            "    if (({solid}) != {part}) gl_Position = vec4(2.0, 2.0, 2.0, 1.0);\n"
        ));
        inputs
    };
-    [part(true), part(false)]
+    horizon_shaders::GameInputs {
+        terrain_parts: terrain.as_ref().map(|t| [part(t, true), part(t, false)]),
+        terrain_one_pass: terrain.as_ref().map(|t| horizon_shaders::GbuffersInputs {
+            parts: Some(horizon_shaders::Parts {
+                solid: solid.clone(),
+                cutout_alpha_test: None,
+            }),
+            ..t.clone()
+        }),
+        terrain,
+        ..Default::default()
+    }
 }

 impl PackAtlas {
    /// The vertex inputs of a gbuffers program drawing terrain (`TerrainVertex`, terrain.wgsl's
    /// `vs_terrain` or, for `flat` draws, `vs_terrain_flat`), in atlas coordinates.
    pub fn terrain_inputs(&self, flat: bool) -> horizon_shaders::GbuffersInputs {
-        let mut declarations = String::from(
-            "layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in uvec2 hz_v_uv;\n\
-             layout(location = 2) in uint hz_v_layer;\nlayout(location = 3) in vec4 hz_v_color;\n\
-             layout(location = 4) in uvec2 hz_v_light;\n",
-        );
+        // Flat draws pull their vertices from the arena page (`PULL_FLAT`), which may hold
+        // solid quads in the compact layout; others read them as vertex attributes.
+        let mut declarations = if flat {
+            String::from(
+                "vec3 hz_v_pos; uvec2 hz_v_uv; uint hz_v_layer; vec4 hz_v_color; uvec2 hz_v_light;\n",
+            )
+        } else {
+            String::from(
+                "layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in uvec2 hz_v_uv;\n\
+                 layout(location = 2) in uint hz_v_layer;\nlayout(location = 3) in vec4 hz_v_color;\n\
+                 layout(location = 4) in uvec2 hz_v_light;\n",
+            )
+        };
        let origin = if flat {
            declarations.push_str(
                "layout(set = 1, binding = 0) readonly buffer HzBlockSlots { uint hz_block_slots[]; };\n\
@@ -637,7 +743,8 @@ impl PackAtlas {
                 layout(set = 3, binding = 1) readonly buffer HzVertices { uint hz_vertices[]; };\n\
                 layout(set = 3, binding = 2) readonly buffer HzTerrainTables { int hz_tables[]; };\n",
            );
-            "hz_slot_origins[hz_block_slots[uint(gl_VertexIndex) >> 8u]]"
+            declarations.push_str(CORNER_FN);
+            "hz_slot_origins[hz_block_slots[hz_slot >> 8u]]"
        } else {
            declarations.push_str("layout(location = 5) in vec4 hz_v_origin;\n");
            "hz_v_origin"
@@ -700,6 +807,7 @@ impl PackAtlas {
        );
        let mut body = body;
        if flat {
+            body.insert_str(0, PULL_FLAT);
            body.push_str(FACE);
            body.push_str(
                "    uint hz_quad = uint(gl_VertexIndex) / 4u;\n    \
@@ -762,6 +870,7 @@ impl PackAtlas {
                .collect(),
            after: String::new(),
            alpha_test: None,
+            parts: None,
            item_id_declared: false,
            far_depth: false,
            paged_maps: false,
@@ -125,7 +125,7 @@ fn terrain_fade_reaches_pack_pixels_through_real_instances() {
                        terrain: Some(atlas.terrain_inputs(flat)),
                        terrain_geometry: geometry.then(|| horizon_shaders::GeometryInputs {
                            inputs: atlas.terrain_inputs(true),
-                            pull: super::PULL.to_owned(),
+                            pull: String::new(),
                            index: "@".to_owned(),
                        }),
                        ..Default::default()
@@ -245,6 +245,135 @@ fn terrain_vertices_go_down_to_the_32768th_below_them() {
    assert!(failures.is_empty(), "{}", failures.join("\n"));
 }

+/// A shader pack's flat terrain inputs read a compact record (`mesher::packed`) as the four
+/// vertices it holds: a whole tinted face with its own ambient occlusion per corner
+/// (`separateAo`), two more, and a slab's top kept as its vertices (`packed::FULL`).
+#[test]
+fn compact_records_feed_a_pack_the_vertices_they_hold() {
+    use crate::mesher::packed;
+    let instance = crate::gfx::test_gpu::instance();
+    let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+        return;
+    };
+    let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap();
+    let texture = device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: 16,
+            height: 16,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_SRC,
+        view_formats: &[],
+    });
+    let mut encoder = device.create_command_encoder(&Default::default());
+    let mut atlas = PackAtlas::new(&device, &mut encoder, &[texture], 1, 1, 16).unwrap();
+    queue.submit([encoder.finish()]);
+    atlas.separate_ao = true;
+    let tint = 0x7F_B238u32;
+    let ao = [255u32, 153, 102, 204];
+    let face = |x: f32, y: f32| {
+        let pos = [
+            [x, y, 5.0],
+            [x, y, 6.0],
+            [x + 1.0, y, 6.0],
+            [x + 1.0, y, 5.0],
+        ];
+        let uv = [[0, 0], [16 << 10, 0], [16 << 10, 16 << 10], [0, 16 << 10]];
+        (0..4).map(move |i| {
+            let [r, g, b] = [16, 8, 0].map(|s| 200 * (tint >> s & 255) / 255);
+            TerrainVertex {
+                pos: pos[i],
+                uv: uv[i],
+                layer: 0x8000,
+                light: 0xF0 | 0x40 << 8,
+                color: r | g << 8 | b << 16 | ao[i] << 24,
+            }
+        })
+    };
+    let solid: Vec<_> = [(3.0, 16.0), (5.0, 16.0), (7.0, 16.0), (3.0, 8.5)]
+        .into_iter()
+        .flat_map(|(x, y)| face(x, y))
+        .collect();
+    let records = packed::layout(&solid, &[tint; 4]);
+    assert_eq!(
+        packed::packed_quads(&records, 4),
+        3,
+        "whole faces pack, the slab doesn't"
+    );
+    let page = bytemuck::cast_slice(&records);
+    let packed_range = packed::PACKED_BASE..packed::PACKED_BASE + 16;
+    let origin = f32::from_bits((1. / UV_STEPS).to_bits());
+    let mut failures = Vec::new();
+    for expression in [
+        "gl_Vertex",
+        "gl_Color",
+        "vec4(gl_MultiTexCoord0.xy, gl_MultiTexCoord1.xy)",
+        "vec4(gl_Normal, 0.0)",
+        "at_tangent",
+        "at_midBlock",
+        "vec4(mc_midTexCoord, mc_Entity.xy)",
+    ] {
+        for shadow in [false, true] {
+            let flags = [true, shadow];
+            let wide = sample_probe(&device, &queue, &atlas, &solid, origin, flags, expression);
+            let compact = sample_page(
+                &device,
+                &queue,
+                &atlas,
+                page,
+                packed_range.clone(),
+                origin,
+                flags,
+                expression,
+            );
+            let bits = |v: &[[f32; 4]]| v.iter().flatten().map(|f| f.to_bits()).collect::<Vec<_>>();
+            if bits(&wide) != bits(&compact) {
+                failures.push(format!(
+                    "{expression} shadow={shadow}: {wide:?} != {compact:?}"
+                ));
+            }
+            if expression == "gl_Color" {
+                for (corner, want) in ao.iter().enumerate() {
+                    let got = compact[corner][3];
+                    if (got - *want as f32 / 255.0).abs() > 1e-6 {
+                        failures.push(format!("corner {corner}'s alpha {got} != {want}/255"));
+                    }
+                }
+            }
+        }
+    }
+    // A pack's frames keep the translucent quads in the section arena after the solid range: three
+    // records and no `FULL` quad, then a water quad, whose corners must read as its own.
+    let mut page: Vec<[u32; 6]> = packed::layout(&solid[..12], &[tint; 3]);
+    let water: Vec<_> = face(9.0, 15.0).collect();
+    let at = page.len() as u32;
+    page.extend(water.iter().map(|v| bytemuck::cast::<_, [u32; 6]>(*v)));
+    for expression in ["vec4(gl_Normal, 0.0)", "at_tangent", "at_midBlock"] {
+        let flags = [true, false];
+        let wide = sample_probe(&device, &queue, &atlas, &water, origin, flags, expression);
+        let page = bytemuck::cast_slice(&page);
+        let after = sample_page(
+            &device,
+            &queue,
+            &atlas,
+            page,
+            at..at + 4,
+            origin,
+            flags,
+            expression,
+        );
+        if wide != after {
+            failures.push(format!("water {expression}: {wide:?} != {after:?}"));
+        }
+    }
+    assert!(failures.is_empty(), "{}", failures.join("\n"));
+}
+
 fn sample(
    device: &wgpu::Device,
    queue: &wgpu::Queue,
@@ -271,18 +400,38 @@ fn sample_probe(
    atlas: &PackAtlas,
    vertices: &[TerrainVertex],
    scale: f32,
+    flags: [bool; 2],
+    expression: &str,
+) -> Vec<[f32; 4]> {
+    let page = bytemuck::cast_slice(vertices);
+    let drawn = 0..vertices.len() as u32;
+    sample_page(device, queue, atlas, page, drawn, scale, flags, expression)
+}
+
+/// `sample_probe` of the vertex indices `drawn` of an arena page holding `page`.
+#[allow(clippy::too_many_arguments)]
+fn sample_page(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    atlas: &PackAtlas,
+    page: &[u8],
+    drawn: std::ops::Range<u32>,
+    scale: f32,
    [flat, shadow]: [bool; 2],
    expression: &str,
 ) -> Vec<[f32; 4]> {
+    let count = drawn.len() as u32;
    let pp = |code| horizon_shaders::Preprocessed {
        code,
        ..Default::default()
    };
    let vertex = pp(format!(
-        "attribute vec2 mc_midTexCoord;\nvarying vec4 probe;\nvoid main() {{\n\
+        "attribute vec2 mc_midTexCoord;\nattribute vec4 at_tangent;\n\
+         attribute vec4 at_midBlock;\nattribute vec4 mc_Entity;\nvarying vec4 probe;\nvoid main() {{\n\
         probe = {expression};\n\
-         gl_Position = vec4((float(gl_VertexID) + 0.5) * {} - 1.0, 0.0, 0.0, 1.0);\n}}",
-        2. / vertices.len() as f32,
+         gl_Position = vec4((float(gl_VertexID - {}) + 0.5) * {} - 1.0, 0.0, 0.0, 1.0);\n}}",
+        drawn.start,
+        2. / count as f32,
    ));
    // Integer attachments retain the float bits without requiring float-render-target
    // capabilities on the adapter that the test runner picks.
@@ -369,7 +518,8 @@ fn sample_probe(
            module: &vs,
            entry_point: Some("main"),
            compilation_options: Default::default(),
-            buffers: &vertex_layouts[..if flat { 1 } else { 2 }],
+            // Flat draws pull their vertices from the page (`PULL_FLAT`), as in the game.
+            buffers: if flat { &[] } else { &vertex_layouts[..] },
        },
        primitive: wgpu::PrimitiveState {
            topology: wgpu::PrimitiveTopology::PointList,
@@ -408,7 +558,7 @@ fn sample_probe(
    );
    let ids = buffer(bytemuck::bytes_of(&[0u32; 2]), wgpu::BufferUsages::STORAGE);
    let data = buffer(
-        bytemuck::cast_slice(vertices),
+        page,
        wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::VERTEX,
    );
    let rects = buffer(
@@ -444,7 +594,7 @@ fn sample_probe(
    let output = device.create_texture(&wgpu::TextureDescriptor {
        label: None,
        size: wgpu::Extent3d {
-            width: vertices.len() as u32,
+            width: count,
            height: 1,
            depth_or_array_layers: 1,
        },
@@ -457,7 +607,7 @@ fn sample_probe(
    });
    let read = device.create_buffer(&wgpu::BufferDescriptor {
        label: None,
-        size: vertices.len() as u64 * 16,
+        size: u64::from(count) * 16,
        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
        mapped_at_creation: false,
    });
@@ -481,11 +631,11 @@ fn sample_probe(
        for (k, group) in groups.iter().enumerate() {
            pass.set_bind_group(k as u32, group, &[]);
        }
-        pass.set_vertex_buffer(0, data.slice(..));
        if !flat {
+            pass.set_vertex_buffer(0, data.slice(..));
            pass.set_vertex_buffer(1, origin.slice(..));
        }
-        pass.draw(0..vertices.len() as u32, 0..1);
+        pass.draw(drawn, 0..1);
    }
    encoder.copy_texture_to_buffer(
        output.as_image_copy(),
@@ -125,6 +125,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
            op: ">",
            reference: 0.1,
        }),
+        parts: None,
        item_id_declared: false,
        far_depth: false,
        // Entities, items and block entities read the shared atlas: its own maps (paged_maps.rs).
@@ -192,6 +193,7 @@ pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
            .collect(),
        after: String::new(),
        alpha_test: None,
+        parts: None,
        item_id_declared: false,
        far_depth: false,
        paged_maps: false,
@@ -50,6 +50,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
            .collect(),
        after,
        alpha_test: None,
+        parts: None,
        item_id_declared: false,
        far_depth: false,
        paged_maps: false,
@@ -2964,17 +2964,13 @@ impl PackPost {
                p.name
            ));
        }
-        match (&terrain, &mut terrain_cutout) {
+        match (&terrain, &terrain_cutout) {
            (Some(t), None) => notes.push(format!("terrain draws with {}", t.name)),
            (t, Some(c)) => {
                if let Some(t) = t {
                    notes.push(format!("solid terrain draws with {}", t.name));
                }
                notes.push(format!("cutout terrain draws with {}", c.name));
-                // Timed (and labelled) apart from the solid part when it runs the same program.
-                if t.as_ref().is_some_and(|t| t.name == c.name) {
-                    c.name.push_str(" (cutout)");
-                }
            }
            (None, None) => {}
        }
@@ -3911,8 +3907,8 @@ impl PackPost {
    }

    /// Terrain (or, `translucent`, translucent terrain) with the pack's program; `draw` issues
-    /// the game's draws. Solid terrain in two parts has its cutout part drawn second, from the
-    /// same draws.
+    /// the game's draws. Solid terrain in two parts (a pack's `gbuffers_terrain_solid` and
+    /// `_cutout`) has its cutout part drawn second, from the same draws.
    fn draw_terrain(
        &mut self,
        device: &wgpu::Device,
@@ -322,7 +322,7 @@ fn check(sampler: &str, stage: Stage, scene: Scene, expected: [u8; 4]) {
    let hand = matches!(scene, Scene::Terrain { hand: true, .. });
    let water = matches!(scene, Scene::Terrain { water: true, .. } | Scene::WaterOnly);
    let inputs=horizon_shaders::GameInputs {
-        terrain:terrain.then(|| horizon_shaders::GbuffersInputs { declarations:"layout(location=0)in vec3 fixture_position;\n".into(),body:"hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n".into(),attributes:vec![],after:String::new(),alpha_test:None,item_id_declared:false,far_depth:false,paged_maps:false,water_mask:false,water_patches:false }),
+        terrain:terrain.then(|| horizon_shaders::GbuffersInputs { declarations:"layout(location=0)in vec3 fixture_position;\n".into(),body:"hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n".into(),attributes:vec![],after:String::new(),alpha_test:None,parts:None,item_id_declared:false,far_depth:false,paged_maps:false,water_mask:false,water_patches:false }),
        hand:hand.then(crate::gfx::pack_hand::inputs),..Default::default()
    };
    let mut post = gpu.load(
@@ -717,6 +717,7 @@ fn shadow_depth_map_reads(
            attributes: vec![],
            after: String::new(),
            alpha_test: None,
+            parts: None,
            item_id_declared: false,
            far_depth: false,
            paged_maps: false,
@@ -48,6 +48,7 @@ fn pack(outputs: u32) -> Post {
    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
    let inputs = horizon_shaders::GameInputs {
        terrain: Some(horizon_shaders::GbuffersInputs {
+            parts: None,
            item_id_declared: false,
            far_depth: false,
            paged_maps: false,
@@ -44,6 +44,7 @@ fn pack() -> Post {
    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
    let inputs = horizon_shaders::GameInputs {
        terrain: Some(horizon_shaders::GbuffersInputs {
+            parts: None,
            item_id_declared: false,
            far_depth: false,
            paged_maps: false,
@@ -89,14 +89,7 @@ fn strips_of(
            .into(),
        ..Default::default()
    };
-    let inputs = horizon_shaders::GameInputs {
-        terrain_parts: Some(super::super::pack_atlas::terrain_parts(
-            &terrain,
-            &[LAVA, LAVA + 1],
-        )),
-        terrain: Some(terrain),
-        ..Default::default()
-    };
+    let inputs = super::super::pack_atlas::game_terrain(Some(terrain), &[LAVA, LAVA + 1]);
    const ATTRS: [wgpu::VertexAttribute; 3] =
        wgpu::vertex_attr_array![0=>Float32x3,2=>Uint32,3=>Unorm8x4];
    let layouts = [Some(wgpu::VertexBufferLayout {
@@ -346,3 +339,64 @@ fn alpha_test_ref_is_0_for_solid_terrain_and_0_5_for_cutout() {
        assert_eq!(got, [Some(RED), Some(YELLOW), Some(RED)], "{names:?}");
    }
 }
+
+/// `alphaTest.gbuffers_terrain` replaces both parts' tests when one program draws them, as it
+/// did when they drew in two passes: over `GREATER 0.25`, alpha 0.3 keeps cutout terrain too
+/// and 0.2 loses solid terrain too, and `alphaTestRef` reads 0.25 in both.
+#[test]
+fn a_packs_terrain_alpha_test_applies_to_both_parts() {
+    let properties = || {
+        (
+            "shaders.properties".to_owned(),
+            "alphaTest.gbuffers_terrain=GREATER 0.25\n".to_owned(),
+        )
+    };
+    for (alpha, kept) in [(0.3, true), (0.2, false)] {
+        let mut files = program("gbuffers_terrain", RED, alpha).to_vec();
+        files.push(properties());
+        let Some((got, _)) = strips_of(files, [255; 4]) else {
+            return;
+        };
+        assert_eq!(got, [kept.then_some(RED); 3], "alpha {alpha}");
+    }
+    let files = vec![
+        (
+            "gbuffers_terrain.vsh".to_owned(),
+            "#version 120\nvoid main(){gl_Position=vec4(gl_Vertex.xy,0.0,1.0);}".to_owned(),
+        ),
+        (
+            "gbuffers_terrain.fsh".to_owned(),
+            "#version 120\nuniform float alphaTestRef;\n/* DRAWBUFFERS:0 */\n\
+             void main(){gl_FragData[0]=vec4(1.0,alphaTestRef*4.0,0.0,1.0);}"
+                .to_owned(),
+        ),
+        properties(),
+    ];
+    let Some((got, _)) = strips_of(files, [255; 4]) else {
+        return;
+    };
+    assert_eq!(got, [Some([255, 255, 0]); 3]);
+}
+
+/// The vertex stage reads its own quad's `alphaTestRef` too: 0 for solid, 0.5 for cutout.
+#[test]
+fn the_vertex_stage_reads_its_parts_alpha_test_ref() {
+    let files = vec![
+        (
+            "gbuffers_terrain.vsh".to_owned(),
+            "#version 120\nuniform float alphaTestRef;\nvarying float ref;\n\
+             void main(){ref=alphaTestRef;gl_Position=vec4(gl_Vertex.xy,0.0,1.0);}"
+                .to_owned(),
+        ),
+        (
+            "gbuffers_terrain.fsh".to_owned(),
+            "#version 120\nvarying float ref;\n/* DRAWBUFFERS:0 */\n\
+             void main(){gl_FragData[0]=vec4(1.0,ref*2.0,0.0,1.0);}"
+                .to_owned(),
+        ),
+    ];
+    let Some((got, _)) = strips_of(files, [255; 4]) else {
+        return;
+    };
+    assert_eq!(got, [Some(RED), Some([255, 255, 0]), Some(RED)]);
+}
@@ -102,6 +102,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
        // depth. Its fragments read their own depth, as in Iris.
        after: String::new(),
        alpha_test: None,
+        parts: None,
        item_id_declared: false,
        far_depth: true,
        paged_maps: false,
@@ -132,6 +133,7 @@ pub fn celestial_inputs() -> horizon_shaders::GbuffersInputs {
        ],
        after: String::new(),
        alpha_test: None,
+        parts: None,
        item_id_declared: false,
        far_depth: true,
        paged_maps: false,
@@ -1137,6 +1137,10 @@ fn components(name: &str) -> usize {
        | "endFlashPosition" => 3,
        "eyeBrightness" | "eyeBrightnessSmooth" | "atlasSize" => 2,
        "entityColor" => 4,
+        // Horizon's own vec4s, a dynamic light and half a boat's water patch box; their counts
+        // are ints.
+        n if n.starts_with("horizonDynamicLight") && n != "horizonDynamicLightCount" => 4,
+        n if n.starts_with("horizonWaterPatch") && n != "horizonWaterPatchCount" => 4,
        n if n.starts_with("gbuffer") || n.starts_with("shadow") && n != "shadowAngle" => 16,
        _ => 1,
    }
@@ -1208,6 +1212,28 @@ mod tests {
            (&matrix, "gbufferModelView", "mat4", true),
            (&matrix, "gbufferModelView", "mat3", false),
            (&Value::i(&[1]), GBUFFERS_FOG_MODE, "int", true),
+            // Horizon's own: a dynamic light and a water patch box half are vec4s, their counts
+            // ints.
+            (
+                &Value::f(&[1.0, 64.0, 2.0, 14.0]),
+                "horizonDynamicLight0",
+                "vec4",
+                true,
+            ),
+            (
+                &Value::f(&[1.0, 64.0, 2.0, 14.0]),
+                "horizonDynamicLight0",
+                "float",
+                false,
+            ),
+            (
+                &Value::f(&[0.5, -1.0, 62.0, 62.5]),
+                "horizonWaterPatch0",
+                "vec4",
+                true,
+            ),
+            (&Value::i(&[3]), "horizonDynamicLightCount", "int", true),
+            (&Value::i(&[1]), "horizonWaterPatchCount", "int", true),
        ] {
            assert_eq!(value.read_as(name, ty), kept, "{ty} {name}");
        }
@@ -44,6 +44,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
            op: ">",
            reference: 0.1,
        }),
+        parts: None,
        item_id_declared: false,
        far_depth: false,
        paged_maps: false,
@@ -0,0 +1,60 @@
+//! How far through vanilla's chunk fade-in a section is, and the instance that carries it to `terrain.wgsl`.
+use crate::fast_hash::FxHashMap;
+use std::time::Instant;
+
+/// A section's instance: its camera-relative origin and its UV step, negated
+/// past its fade code while it fades in over far terrain (`lod::instance`).
+pub(super) fn section_instance(origin: [f32; 3], fade: u32, visibility: f32) -> [f32; 4] {
+    let step = 1.0 / crate::mesher::UV_STEPS;
+    [
+        origin[0],
+        origin[1],
+        origin[2],
+        if fade == 0 {
+            // The step is a power of two, so its mantissa is free: it holds the vanilla
+            // chunk fade-in's `1 - visibility` in 23 bits (terrain.wgsl's `instance_step` and
+            // `instance_visibility` read it back). A whole section is the bare step.
+            let faded = ((1.0 - visibility) * 8_388_608.0)
+                .round()
+                .clamp(0.0, 8_388_607.0) as u32;
+            f32::from_bits(step.to_bits() | faded)
+        } else {
+            -(fade as f32 + step)
+        },
+    ]
+}
+/// `SectionRenderDispatcher.RenderSection.getVisibility`: how far through its fade-in a section
+/// uploaded `elapsed_ms` ago is.
+pub(super) fn chunk_visibility(elapsed_ms: u64, fade_ms: u64) -> f32 {
+    if elapsed_ms >= fade_ms {
+        1.0
+    } else {
+        elapsed_ms as f32 / fade_ms as f32
+    }
+}
+/// `Util.toMillis`: `Mth.floor(seconds * 1000.0)`.
+pub(super) fn fade_millis(seconds: f32) -> u64 {
+    (f64::from(seconds) * 1000.0).floor().max(0.0) as u64
+}
+/// `chunk_visibility` at `now` of a section first uploaded at `uploaded`
+/// (`Renderer::section_uploaded`; none: one that fades in over far terrain, or
+/// whose column left), with the chunk fade-in `fade_ms`.
+pub(super) fn section_visibility(uploaded: Option<&Instant>, fade_ms: u64, now: Instant) -> f32 {
+    uploaded.map_or(1.0, |&t| {
+        let elapsed = now.saturating_duration_since(t).as_millis() as u64;
+        chunk_visibility(elapsed, fade_ms)
+    })
+}
+/// What a section's fade depends on besides the section itself
+/// (`SectionGpu::drawn_faded`): the time, the chunk fade-in time, the sections'
+/// first uploads (`Renderer::section_uploaded`) and those held while far
+/// terrain comes in (`Renderer::lod_retiring`).
+#[derive(Clone, Copy)]
+pub(super) struct FadeInputs<'a> {
+    pub(super) now: Instant,
+    pub(super) fade_ms: u64,
+    pub(super) uploaded: &'a FxHashMap<super::SectionKey, Instant>,
+    pub(super) retiring: &'a crate::fast_hash::FxHashSet<super::SectionKey>,
+}
+/// `LevelRenderer.CHUNK_VISIBILITY_THRESHOLD`: a section's block entities wait for it.
+pub(super) const CHUNK_VISIBILITY_THRESHOLD: f32 = 0.3;
@@ -30,8 +30,9 @@ fn marker_driver(text: &str) -> &str {
 pub struct Reported {
    pub paper_white: u32,
    pub peak: u32,
-    /// The peak is the display's own claim (DXGI's `MaxLuminance`, mostly its EDID figure),
-    /// which often runs high: Auto still uses it, but the HDR page asks to calibrate.
+    /// The peak is the system's own figure (DXGI's `MaxLuminance`): the display's, or a
+    /// calibration profile's (Windows HDR Calibration), which Horizon can't tell apart. Auto
+    /// uses it, and the HDR page offers calibration.
    pub peak_guessed: bool,
 }

@@ -40,7 +41,7 @@ pub struct Reported {
 pub enum HdrSetup {
    /// The system says nothing: the player calibrates.
    Unknown,
-    /// The system says, but only guesses the peak: the player calibrates.
+    /// The system says, but not where its peak comes from: the page offers calibration.
    Guessed,
    /// Peak Brightness and Paper White follow the system.
    Automatic,
@@ -1355,7 +1356,7 @@ mod tests {
    }

    #[test]
-    fn hdr_setup_asks_to_calibrate_where_the_peak_is_guessed() {
+    fn hdr_setup_offers_calibration_where_the_peaks_source_is_unknown() {
        let wayland = Reported {
            paper_white: 203,
            peak: 1015,
@@ -1370,7 +1371,7 @@ mod tests {
        assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
        assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Automatic);
        assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Guessed);
-        // Auto still takes the guess, over the 1000-nit default.
+        // Auto still takes the reported peak, over the 1000-nit default.
        assert_eq!(g.peak_nits(Some(windows)), 1000);
        assert_eq!(g.paper_white_nits(Some(windows)), 400);
        for (peak, paper_white) in [(800, 0), (0, 240)] {
@@ -1896,10 +1897,12 @@ mod tests {
        let g = Graphics::default();
        assert_eq!(g.workers, 0);
        let cores = horizon_threads::worker_count();
+        // Vanilla's bound: one core is always left for the render and server threads.
        assert!((1..=cores.saturating_sub(1).max(1)).contains(&g.worker_threads()));
-        if !cfg!(target_vendor = "apple") {
-            assert_eq!(g.worker_threads(), cores.saturating_sub(1).max(1));
-        }
+        // The count itself is `horizon_threads::default_workers`, which is one less than
+        // the *smaller* of the machine's cores and its performance cores (a Linux hybrid
+        // CPU reports fewer of the latter), so it is not always `cores - 1`.
+        assert_eq!(g.worker_threads(), horizon_threads::default_workers());
        // A manual count is the player's own choice, kept as asked.
        let manual = Graphics { workers: 3, ..g };
        assert_eq!(manual.worker_threads(), 3);
@@ -697,7 +697,7 @@ fn description(
            "Your display didn't say how bright it gets: calibrate to set it up."
        }
        (Item::Horizon(H::HdrCalibrate), Setup::Guessed) => {
-            "Your display's reported peak is often too high: calibrate to set it up."
+            "Auto uses the peak Windows reports. Calibrate if highlights look clipped."
        }
        (Item::Horizon(H::HdrCalibrate), Setup::Automatic) => {
            "Already set up for your display. Only calibrate if HDR looks wrong."
@@ -705,7 +705,7 @@ fn description(
        (Item::Horizon(H::HdrCalibrate), Setup::Changed) => {
            "Puts Peak Brightness and Paper White back to your display's setup."
        }
-        // A guessed peak's Auto is what calibration replaced; paper white is the player's own.
+        // A peak of unknown source isn't said to be set up; paper white is the player's own.
        (Item::Horizon(h @ (H::HdrPeak | H::HdrPaperWhite)), Setup::Automatic | Setup::Changed)
            if h == H::HdrPaperWhite || out.reported.is_some_and(|r| !r.peak_guessed) =>
        {
@@ -1219,10 +1219,13 @@ impl Item {
    }
    pub fn label(self, s: &Settings, out: &EffectiveOutput) -> Text {
        match self {
-            Item::Vanilla(Opt::RenderDistance) if s.horizon.lod_distance > 0 => labelled(
-                "Full Detail Distance",
-                lang::tr("%s chunks", &[&s.render_distance]),
-            ),
+            // Far terrain renames the row; its value stays vanilla's `options.chunks`.
+            Item::Vanilla(Opt::RenderDistance) if s.horizon.lod_distance > 0 => {
+                Text::option_name_value(
+                    Text::literal(lang::get("Full Detail Distance")),
+                    Text::tr("options.chunks", &[&s.render_distance]),
+                )
+            }
            Item::Vanilla(o) => o.label(s),
            Item::Horizon(h) => h.label(s, out),
            Item::Extra(e) => Text::option_name_value(
@@ -1318,7 +1321,11 @@ impl Item {

 /// Whether a setting is on the screen now: Upscaling only while TAA is, which does it.
 fn shown(item: Item, s: &Settings) -> bool {
-    item != Item::Horizon(H::Upscaling) || s.horizon.taa
+    match item {
+        Item::Horizon(H::Upscaling) => s.horizon.taa,
+        Item::Extra(crate::extras::Item::Fullbright) => !s.fullbright_held,
+        _ => true,
+    }
 }
 /// A control's label as its name and its value ("Render Distance" and "12 chunks").
 fn parts(item: Item, s: &Settings, out: &EffectiveOutput) -> (String, Option<String>) {
@@ -1430,7 +1437,7 @@ impl Screen for GraphicsScreen {
            g::gpu_culling_offer(),
            g::reduced_far_detail_suggested(),
        );
-        shell::stamp_of(&(read(s), offers))
+        shell::stamp_of(&(read(s), s.fullbright_held, offers))
    }
    fn sheets(&self, s: &Settings) -> Vec<Sheet<Page, Item>> {
        let sheet = |(page, groups): (Page, Vec<(&'static str, Vec<Setting>)>)| Sheet {
@@ -1990,6 +1997,31 @@ mod tests {
        assert_eq!(key(&mut ui, &mut s, K::Escape), [Output::Done]);
    }

+    /// On another's server Fullbright's row is gone and the screen draws again; its choice is
+    /// kept for the next world that allows it (#3823).
+    #[test]
+    fn fullbright_row_is_hidden_while_held_and_keeps_its_choice() {
+        let mut s = Settings::default();
+        s.extras.fullbright = true;
+        let screen = GraphicsScreen::default();
+        let listed = |s: &Settings, item| {
+            let sheets = screen.sheets(s);
+            let groups = sheets.into_iter().flat_map(|sheet| sheet.groups);
+            groups.flat_map(|group| group.rows).any(|r| r.id == item)
+        };
+        let fullbright = Item::Extra(crate::extras::Item::Fullbright);
+        let lights = Item::Extra(crate::extras::Item::DynamicLights);
+        assert!(listed(&s, fullbright));
+        let free = screen.stamp(&s);
+        s.fullbright_held = true;
+        assert!(!listed(&s, fullbright));
+        assert!(listed(&s, lights));
+        assert_ne!(screen.stamp(&s), free);
+        assert!(s.extras.fullbright);
+        s.fullbright_held = false;
+        assert!(listed(&s, fullbright));
+    }
+
    /// The strip says what a row does, what its chosen value does where that differs, and why a
    /// greyed row can't be used; the search finds a row by what it does.
    #[test]
@@ -2110,10 +2142,36 @@ mod tests {
        assert_eq!(item.slider(&s), Some(13.0 / 23.0));
        s.horizon.lod_distance = 12;
        assert_eq!(item.slider(&s), Some(1.0 / 23.0));
-        assert_eq!(
-            Item::Vanilla(Opt::RenderDistance).label(&s, &NONE).plain(),
-            format!("Full Detail Distance: {near} chunks")
-        );
+    }
+
+    /// With far terrain on, Render Distance reads "Full Detail Distance" but keeps vanilla's
+    /// `options.chunks` value: it was Horizon's "%s chunks", so "12 Chunks" became "12 chunks"
+    /// (#14880).
+    #[test]
+    fn full_detail_distance_keeps_the_vanilla_chunk_count() {
+        struct Vanilla;
+        impl lang::ResourceSource for Vanilla {
+            fn read(&self, path: &str) -> Option<Vec<u8>> {
+                (path == "assets/minecraft/lang/en_us.json").then(|| {
+                    serde_json::to_vec(&serde_json::json!({
+                        "options.renderDistance": "Render Distance",
+                        "options.chunks": "%s Chunks",
+                        "options.generic_value": "%s: %s"
+                    }))
+                    .unwrap()
+                })
+            }
+        }
+        let mut s = Settings::default();
+        let near = s.render_distance;
+        let render = Item::Vanilla(Opt::RenderDistance);
+        let ((off, on), _) = lang::scoped(lang::Language::load(&[&Vanilla], "en_us"), || {
+            let off = render.label(&s, &NONE).plain();
+            s.horizon.lod_distance = 256;
+            (off, render.label(&s, &NONE).plain())
+        });
+        assert_eq!(off, format!("Render Distance: {near} Chunks"));
+        assert_eq!(on, format!("Full Detail Distance: {near} Chunks"));
    }

    #[test]
@@ -164,7 +164,7 @@ fn auto_levels_and_setup_read_their_own_renderers_report() {
 }

 /// The setup rows' label and description for each kind of report: none, a compositor's
-/// (Wayland), and Windows', whose peak is the display's own guess.
+/// (Wayland), and Windows', whose peak may be the display's or a calibration profile's.
 #[test]
 fn the_setup_rows_ask_to_calibrate_unless_the_system_set_the_display_up() {
    let trusted = offering(true, Some(true));
@@ -200,7 +200,7 @@ fn the_setup_rows_ask_to_calibrate_unless_the_system_set_the_display_up() {
        [
            (
                calibrate.into(),
-                "Your display's reported peak is often too high: calibrate to set it up."
+                "Auto uses the peak Windows reports. Calibrate if highlights look clipped."
            ),
            ("Peak Brightness: Auto (1000)".into(), "-"),
            ("Paper White: Auto (400)".into(), "-"),
@@ -219,7 +219,7 @@ fn the_setup_rows_ask_to_calibrate_unless_the_system_set_the_display_up() {
    );
    // Calibrated or set by hand, either report offers its automatic setup back.
    s.horizon.hdr_peak = 800;
-    // Peak's Auto stays a guess on Windows: only Paper White is said to be set up there.
+    // Peak's Auto has no known source on Windows: only Paper White is said to be set up there.
    let changed = |peak| {
        [
            (
@@ -348,3 +348,30 @@ fn undo_never_restores_a_held_hdr_start() {
    screen.undo(&mut s, &opened);
    assert_eq!(s.horizon, opened.horizon);
 }
+
+/// The Calibrate row's descriptions fit the strip's two lines at vanilla's 427-wide GUI (a
+/// 1080p window at scale 4 is wider): a longer one would end in "…".
+#[test]
+fn the_calibrate_descriptions_fit_the_strip() {
+    let atlas = crate::hud::HudAtlas::build(std::path::Path::new("/nonexistent")).unwrap();
+    let mut guessed = offering(true, Some(true));
+    guessed.reported = guessed.reported.map(|r| crate::graphics::Reported {
+        peak_guessed: true,
+        ..r
+    });
+    let mut changed = Settings::default();
+    changed.horizon.hdr_peak = 800;
+    let item = Item::Horizon(H::HdrCalibrate);
+    let width = Columns::of(427.0, 240.0).dock[2] - 24.0;
+    for (s, out) in [
+        (Settings::default(), NONE),
+        (Settings::default(), guessed),
+        (Settings::default(), offering(true, Some(true))),
+        (changed, guessed),
+    ] {
+        let text = description(item, &s, &out, "-");
+        assert_ne!(text, "-");
+        let lines = atlas.font.split(&Text::literal(text.to_owned()), width);
+        assert!(lines.len() <= 2, "{text}");
+    }
+}
@@ -173,13 +173,52 @@ fn calibration_picture(pos: vec4<f32>) -> vec4<f32> {
    return vec4(nits / 80.0, 1.0);
 }

-// Light in units of paper white, as the swapchain takes it: HDR10 or scRGB, the black level
-// lifted.
-fn display(light: vec3<f32>) -> vec4<f32> {
+// On for the HDR10 swapchain alone (Hdr::new): its 10 bits get dither. A screenshot's HDR10 copy
+// (Hdr::capture) keeps the exact codes, and scRGB's floats need none.
+override pq_dither: bool = false;
+
+// Three even random values in [0, 1) for `at`: PCG's 3D hash (Jarzynski and Olano, "Hash Functions
+// for GPU Rendering", JCGT 2020). Integers only, so it is the same on every GPU and at every
+// resolution, where hashes built on `fract(sin())` repeat or streak at 4K's coordinates.
+// Copyright 2020 Mark Jarzynski & Marc Olano, MIT (github.com/markjarzynski/PCG3D; the license is in
+// THIRD_PARTY_NOTICES.md).
+fn hash3(at: vec3<u32>) -> vec3<f32> {
+    var v = at * 1664525u + 1013904223u;
+    v.x += v.y * v.z;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+    v ^= v >> vec3(16u);
+    v.x += v.y * v.z;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+    return vec3<f32>(v >> vec3(8u)) / 16777216.0;
+}
+
+// The PQ signal `e` with dither for its 10 bits: triangular noise of one code either way, each
+// channel's own, so a slow gradient (a clear sky is a few codes tall) shows as grain a code deep
+// instead of bands, and its mean is the light meant. The noise is the pixel's alone: no frame
+// counter, so a still picture stays still. Within a code of black or of the top it shrinks to
+// what fits: the signal never leaves 0..1, and black stays exactly black (an OLED's pixel off).
+// The price is in that last code alone: the smaller noise keeps the signal's mean but not the
+// rounded one, which leans to the end (a third of a code from it shows as an eighth). Under
+// 0.00004 nits at black, that is the accepted cost of a true 0.
+fn dithered(e: vec3<f32>, pixel: vec2<f32>) -> vec3<f32> {
+    let at = vec2<u32>(pixel);
+    let noise = hash3(vec3(at, 0u)) + hash3(vec3(at, 1u)) - 1.0;
+    return e + noise * min(min(e, 1.0 - e), vec3(1.0 / 1023.0));
+}
+
+// Light in units of paper white at the pixel `pos`, as the swapchain takes it: HDR10 or scRGB,
+// the black level lifted.
+fn display(light: vec3<f32>, pos: vec4<f32>) -> vec4<f32> {
    let scrgb = light * params.paper;
    if params.pq > 0.5 {
        let e = pq(BT709_TO_BT2020 * scrgb * 80.0);
-        return vec4(select(e, lift_black(e), params.black > 0.0), 1.0);
+        let lifted = select(e, lift_black(e), params.black > 0.0);
+        if pq_dither {
+            return vec4(dithered(lifted, pos.xy), 1.0);
+        }
+        return vec4(lifted, 1.0);
    }
    if params.black > 0.0 {
        return vec4(pq_nits(lift_black(pq(scrgb * 80.0))) / 80.0, 1.0);
@@ -209,7 +248,7 @@ fn display(light: vec3<f32>) -> vec4<f32> {
    // The HUD and menus at their own brightness, by how much they cover, no brighter than the
    // peak (as `fs_hdr_layered`): UI Brightness can pass paper white.
    light = min(light * mix(1.0, params.ui, ui), vec3(params.peak));
-    return display(light);
+    return display(light, pos);
 }

 // The tone curve's knee: up to it light stays as it is. Where HDR lighting eased into the peak
@@ -328,5 +367,5 @@ override screenshot_shoulder: bool = true;
    if calibrating(pos) {
        return calibration_picture(pos);
    }
-    return display(min(pow(layered(vec2<i32>(pos.xy)), vec3(2.2)), vec3(params.peak)));
+    return display(min(pow(layered(vec2<i32>(pos.xy)), vec3(2.2)), vec3(params.peak)), pos);
 }
@@ -52,7 +52,7 @@ pub struct TextureFlags {
 impl TextureFlags {
    /// The `texture` section of a `.png.mcmeta` file, if it sets either flag.
    pub fn from_mcmeta(json: &str) -> Option<Self> {
-        let meta: serde_json::Value = serde_json::from_str(json).ok()?;
+        let meta = crate::packs::first_json(json.as_bytes())?;
        let section = meta.get("texture")?;
        let flag = |key| section.get(key).and_then(serde_json::Value::as_bool) == Some(true);
        let flags = Self {
@@ -387,7 +387,7 @@ fn strip_frame(pixels: &[u8], stride: u32, x: u32, y: u32, w: u32, h: u32) -> Ve
 }
 /// The `animation` section of a texture's `.mcmeta`.
 fn animation_of(mcmeta: Option<&str>) -> Option<AnimationMetadata> {
-    let meta: serde_json::Value = serde_json::from_str(mcmeta?).ok()?;
+    let meta = crate::packs::first_json(mcmeta?.as_bytes())?;
    AnimationMetadata::from_json(&meta.get("animation")?.to_string()).ok()
 }
 /// An animated strip's first frame: the region the mcmeta's frame size picks
@@ -3110,6 +3110,18 @@ mod coverage_tests;
 mod tests {
    use super::*;

+    #[test]
+    fn animated_texture_metadata_ignores_trailing_pack_signature() {
+        let meta = r#"{"animation":{"frametime":2,"width":2,"height":2}}
+// High Contrast pack signature"#;
+        let animation = animation_of(Some(meta)).expect("the first JSON value is metadata");
+        assert_eq!(animation.frame_size(8, 4), [2, 2]);
+        let pixels = (0..8 * 4).flat_map(|i| [i as u8, 0, 0, 255]).collect();
+        let (_, height, first) = first_frame((8, 4, pixels), Some(&animation));
+        assert_eq!(height, 2);
+        assert_eq!(first.len(), 2 * 2 * 4);
+    }
+
    #[test]
    fn object_skin_revision_tracks_changes_and_capacity_clear() {
        let mut atlas = HudAtlas::boot();
@@ -1,6 +1,7 @@
 //! Room: what of a view Horizon's own HUD overlays may use. Vanilla's HUD elements are
 //! keep-outs; an overlay asks the room where it fits instead of assuming a fixed spot, so it
-//! doesn't cover them. Today the only keep-out is the boss bars at the top centre.
+//! doesn't cover them. The keep-outs: the boss bars at the top centre, and the status rows above
+//! the hotbar at the bottom centre.
 //!
 //! The room is built once a frame from what the HUD shows (`Game::hud_room` in gameplay). With
 //! nothing showing it is empty, and every overlay stays exactly where it always was.
@@ -34,6 +35,16 @@ pub const GAP: f32 = 2.0;
 pub enum Keep {
    /// The boss bars and their names at the top centre (`hud_overlays::boss_bars_bottom`).
    BossBars,
+    /// The survival rows above the hotbar at the bottom centre: health with its absorption rows,
+    /// armour, food or the mount's hearts, and air; from the highest row's top to the view's
+    /// bottom.
+    StatusRows,
+}
+impl Keep {
+    /// It sits at the top of the view, not the bottom.
+    fn at_top(self) -> bool {
+        matches!(self, Self::BossBars)
+    }
 }

 /// A view and the keep-outs its HUD shows this frame.
@@ -90,10 +101,20 @@ impl Room {
    /// bars' bottom, or 0 with none.
    pub fn top(&self) -> f32 {
        self.keeps()
-            .map(|(Keep::BossBars, [_, y, _, h])| y + h)
+            .filter(|(keep, _)| keep.at_top())
+            .map(|(_, [_, y, _, h])| y + h)
            .fold(0.0, f32::max)
    }

+    /// How far, in GUI px from the view's top, the keep-outs at the bottom reach up: the status
+    /// rows' top, or the view's height with none.
+    pub fn bottom(&self) -> f32 {
+        self.keeps()
+            .filter(|(keep, _)| !keep.at_top())
+            .map(|(_, [_, y, _, _])| y)
+            .fold(self.height, f32::min)
+    }
+
    /// Where a centred overlay that wants its top at `wanted` (GUI px) goes: at `wanted` unless
    /// a keep-out reaches past it (`top() > wanted`, a real overlap; touching isn't one), else
    /// `GAP` below that keep-out.
@@ -134,4 +155,15 @@ mod tests {
        assert_eq!(bars(36.0).below_top(18.0), 38.0);
        assert_eq!(bars(36.0).usable(), [0.0, 38.0, 500.0, 262.0]);
    }
+
+    #[test]
+    fn the_status_rows_are_kept_at_the_bottom_and_leave_the_top_alone() {
+        let room = Room::new(427.0, 240.0);
+        assert_eq!(room.bottom(), 240.0);
+        // Hearts and armour from y 191 down.
+        let rows = room.with(Keep::StatusRows, [122.0, 191.0, 182.0, 49.0]);
+        assert_eq!(rows.bottom(), 191.0);
+        assert_eq!(rows.top(), 0.0);
+        assert_eq!(rows.below_top(18.0), 18.0);
+    }
 }
@@ -131,6 +131,23 @@ pub enum GuiDraw {

 pub const WHITE: u32 = 0xFFFF_FFFF;

+/// The highest top, in GUI px, of the draws that sit on the view (`None` for none): where a row
+/// of the HUD begins.
+pub fn draws_top(draws: &[GuiDraw]) -> Option<i32> {
+    draws
+        .iter()
+        .filter_map(|d| match *d {
+            GuiDraw::Sprite { y, .. }
+            | GuiDraw::AtlasSprite { y, .. }
+            | GuiDraw::Blit { y, .. }
+            | GuiDraw::Text { y, .. }
+            | GuiDraw::Item { y, .. } => Some(y),
+            GuiDraw::Fill { y0, .. } => Some(y0),
+            GuiDraw::Push(_) | GuiDraw::Pop => None,
+        })
+        .min()
+}
+
 fn sprite(sprite: &'static str, x: i32, y: i32, w: i32, h: i32) -> GuiDraw {
    GuiDraw::Sprite {
        sprite: Cow::Borrowed(sprite),
@@ -583,6 +583,9 @@ pub const BOSS_BAR_STEP: i32 = 10 + 9;
 pub const BOSS_BAR_HEIGHT: i32 = 5;
 /// A boss bar's sprite width, in GUI px; it is centred on the view.
 pub const BOSS_BAR_WIDTH: i32 = 182;
+/// Half the hotbar's width, in GUI px (`Hud`'s `screenWidth / 2 - 91`): the status rows above it
+/// span the same.
+pub const HOTBAR_HALF_WIDTH: i32 = 91;

 /// How many of `n` boss bars `BossHealthOverlay.extractRenderState` draws on a view `h` GUI px
 /// tall: it stops once the next bar's top reaches a third of the height (integer division,
@@ -110,6 +110,8 @@ pub mod preedit;
 pub mod providers;
 pub mod pvp;
 pub mod pvp_hud;
+pub mod radial_editor;
+pub mod radial_overlay;
 pub mod random_source;
 pub mod screen_draw;
 pub mod screen_effects;
@@ -170,6 +172,7 @@ pub use horizon_client_input::key_names;
 pub use horizon_client_input::keybinds;
 pub use horizon_client_input::keymapping;
 pub use horizon_client_input::mouse;
+pub use horizon_client_input::radial;
 pub use horizon_client_input::window;
 pub use horizon_command as command;
 pub use horizon_items::blocks;
@@ -22,6 +22,7 @@ use crate::{
 use horizon_core::geometry::{Direction, ShapeOp, VoxelShape};
 use horizon_world::registry::{BlockRegistry, BlockStateId};
 use std::{
+    cell::RefCell,
    collections::{HashMap, VecDeque},
    path::Path,
    sync::Arc,
@@ -365,6 +366,48 @@ fn give_scratch(scratch: LightScratch) {
    }
 }

+thread_local! {
+    static RELIGHT_SCRATCH: RefCell<RelightScratch> = RefCell::new(RelightScratch::new());
+}
+
+struct RelightScratch {
+    decrease: VecDeque<(Pos, u8)>,
+    cleared: Vec<Pos>,
+    increase: VecDeque<Pos>,
+    sources: FxHashMap<(i32, i32), i32>,
+}
+
+impl RelightScratch {
+    fn new() -> Self {
+        Self {
+            decrease: VecDeque::new(),
+            cleared: Vec::new(),
+            increase: VecDeque::new(),
+            sources: FxHashMap::default(),
+        }
+    }
+
+    fn clear(&mut self) {
+        const MAX_CAPACITY: usize = 16_384;
+        self.decrease.clear();
+        if self.decrease.capacity() > MAX_CAPACITY {
+            self.decrease.shrink_to(MAX_CAPACITY);
+        }
+        self.cleared.clear();
+        if self.cleared.capacity() > MAX_CAPACITY {
+            self.cleared.shrink_to(MAX_CAPACITY);
+        }
+        self.increase.clear();
+        if self.increase.capacity() > MAX_CAPACITY {
+            self.increase.shrink_to(MAX_CAPACITY);
+        }
+        self.sources.clear();
+        if self.sources.capacity() > MAX_CAPACITY {
+            self.sources.shrink_to(MAX_CAPACITY);
+        }
+    }
+}
+
 /// Where a section sits in the 48-wide region.
 #[derive(Clone, Copy)]
 struct At {
@@ -880,12 +923,12 @@ impl<'w> Region<'w> {
        Self {
            layout: world.layout(),
            world,
-            slots: Vec::new(),
+            slots: Vec::with_capacity(16),
            index: FxHashMap::default(),
            last: ((i32::MIN, 0, 0), NONE),
        }
    }
-    #[inline]
+    #[inline(always)]
    fn slot(&mut self, x: i32, y: i32, z: i32) -> Option<usize> {
        let s = self.layout.section_index(y)?;
        let key = (x >> 4, s as i32, z >> 4);
@@ -1142,10 +1185,25 @@ pub fn relight(
    force: bool,
    changed: &mut LightChanges,
 ) {
-    let mut region = Region::new(world);
-    changed.keyed(region.layout);
-    relight_region(&mut region, tables, sky_light, positions, force, changed);
-    region.finish();
+    changed.keyed(world.layout());
+    if positions.is_empty() {
+        return;
+    }
+    RELIGHT_SCRATCH.with_borrow_mut(|scratch| {
+        scratch.clear();
+        let mut region = Region::new(world);
+        relight_region(
+            &mut region,
+            tables,
+            sky_light,
+            positions,
+            force,
+            scratch,
+            changed,
+        );
+        region.finish();
+        scratch.clear();
+    });
 }
 /// The columns `changed` touched that border a loaded column not lit yet
 /// (`unlit`). `relight` reads and writes only lit columns, so an edit's
@@ -1170,10 +1228,11 @@ fn relight_region(
    sky_light: bool,
    positions: &[Pos],
    force: bool,
+    scratch: &mut RelightScratch,
    changed: &mut LightChanges,
 ) {
    crate::spans::time("lt_block", || {
-        relight_layer(world, tables, false, positions.to_vec(), force, changed)
+        relight_layer(world, tables, false, positions, force, scratch, changed)
    });
    if sky_light {
        let (min_y, max_y) = (world.layout.min_y(), world.layout.max_y());
@@ -1201,7 +1260,7 @@ fn relight_region(
            }
        });
        crate::spans::time("lt_sky", || {
-            relight_layer(world, tables, true, seeds, force, changed)
+            relight_layer(world, tables, true, &seeds, force, scratch, changed)
        });
    }
 }
@@ -1209,14 +1268,30 @@ fn relight_layer(
    world: &mut Region,
    tables: &LightTables,
    sky: bool,
-    seeds: Vec<Pos>,
+    seeds: &[Pos],
    force: bool,
+    scratch: &mut RelightScratch,
    changed: &mut LightChanges,
 ) {
-    let mut decrease: VecDeque<(Pos, u8)> = VecDeque::new();
-    let mut cleared: Vec<Pos> = Vec::new();
-    let mut increase: VecDeque<Pos> = VecDeque::new();
-    for p in seeds {
+    scratch.decrease.clear();
+    scratch.cleared.clear();
+    scratch.increase.clear();
+    scratch.sources.clear();
+
+    if seeds.len() > scratch.decrease.capacity() {
+        scratch.decrease.reserve(seeds.len());
+    }
+    if seeds.len() > scratch.cleared.capacity() {
+        scratch.cleared.reserve(seeds.len());
+    }
+    if seeds.len() > scratch.increase.capacity() {
+        scratch.increase.reserve(seeds.len());
+    }
+
+    let decrease = &mut scratch.decrease;
+    let cleared = &mut scratch.cleared;
+    let increase = &mut scratch.increase;
+    for &p in seeds {
        let Some(old) = level(world, sky, p) else {
            continue;
        };
@@ -1267,13 +1342,22 @@ fn relight_layer(
        }
    }
    // Sources inside the cleared area light up again.
-    let mut sources: FxHashMap<(i32, i32), i32> = FxHashMap::default();
+    let sources = &mut scratch.sources;
+    let mut last_xz = (i32::MIN, i32::MIN);
+    let mut last_lowest = 0;
    crate::spans::time("lt_sources", || {
-        for p in cleared {
+        for &p in cleared.iter() {
            let seed = if sky {
-                let lowest = *sources
-                    .entry((p.0, p.2))
-                    .or_insert_with(|| lowest_sky_source(world, tables, p.0, p.2));
+                let lowest = if (p.0, p.2) == last_xz {
+                    last_lowest
+                } else {
+                    let lowest = *sources
+                        .entry((p.0, p.2))
+                        .or_insert_with(|| lowest_sky_source(world, tables, p.0, p.2));
+                    last_xz = (p.0, p.2);
+                    last_lowest = lowest;
+                    lowest
+                };
                if p.1 >= lowest { 15 } else { 0 }
            } else {
                world
@@ -2119,9 +2203,39 @@ pub(crate) mod tests {
            relight(&mut w, &t, true, &positions, false, &mut changed);
        }
        println!(
-            "relight_bench: {:?}, {} sections",
-            start.elapsed(),
-            changed.sections().count()
+            "relight_bench (large batch: 400 rounds x 32 blocks): {:?}",
+            start.elapsed()
+        );
+    }
+
+    #[test]
+    #[ignore]
+    fn relight_single_block_bench() {
+        let mut w: FxHashMap<_, _> = world(|_| {}).into_iter().collect();
+        let t = tables();
+        let mut rng = 0x2545_f491_u32;
+        let mut next = |n: i32| {
+            rng ^= rng << 13;
+            rng ^= rng >> 17;
+            rng ^= rng << 5;
+            (rng % n as u32) as i32
+        };
+        let start = std::time::Instant::now();
+        let mut changed = LightChanges::default();
+        for round in 0..2000 {
+            let state = [TORCH, SLAB, AIR][round % 3];
+            let pos = (next(32) - 8, next(12), next(32) - 8);
+            Arc::make_mut(w.get_mut(&(pos.0 >> 4, pos.2 >> 4)).unwrap()).set(
+                pos.0 & 15,
+                pos.1,
+                pos.2 & 15,
+                state,
+            );
+            relight(&mut w, &t, true, &[pos], false, &mut changed);
+        }
+        println!(
+            "relight_single_block_bench (single block: 2000 rounds): {:?}",
+            start.elapsed()
        );
    }

@@ -58,6 +58,9 @@ pub struct OverlayColours {
    /// The main action, and its text.
    pub accent: u32,
    pub on_accent: u32,
+    /// A lit choice and its bright edge (the controller dial's sector).
+    pub lit: u32,
+    pub lit_edge: u32,
 }

 /// `ui_theme`'s type scale and shapes, in dp.
@@ -109,6 +112,8 @@ pub const NEUTRAL: MenuStyle = MenuStyle {
        rule: 0x303030,
        accent: 0xffffff,
        on_accent: 0x000000,
+        lit: 0xffffff,
+        lit_edge: 0xffffff,
    },
    sizes: Sizes {
        caption: 12.0,
@@ -13,8 +13,9 @@
 //! - word 1: each corner's grey level before the tint;
 //! - word 2: the UV rectangle in 1/32 of the sprite (u0, u1, v0, v1, 6 bits each) and, per
 //!   corner, which edge of it its u and v take;
-//! - word 3: the layer, and corner 0's light (sky and block light over 4, 6 bits each);
-//! - word 4: corners 1 and 2's light;
+//! - word 3: the layer, corner 0's light (sky and block light over 4, 6 bits each), and
+//!   corner 1's alpha code (`ALPHA_STEP` times it; 0: word 0's alpha);
+//! - word 4: corners 1 and 2's light, and corners 2 and 3's alpha codes;
 //! - word 5: corner 3's light, the face (block x, y, z, the axis it faces along, which side
 //!   of the block, and where and which way its corners go round), and `FULL` clear.
 use super::TerrainVertex;
@@ -27,6 +28,8 @@ pub const WHITE: u32 = 0xFF_FFFF;
 /// Word 5's bit of a quad kept as four vertices; word 0 is then the slots from the record
 /// to its first vertex.
 pub const FULL: u32 = 1 << 31;
+/// The step of a corner's own alpha (words 3 and 4's codes): 255 / 5.
+pub const ALPHA_STEP: u32 = 51;
 /// The draws' base vertex of a compact mesh: `PACKED_BASE + 4 * slot + corner` is a corner of
 /// the quad whose record is at `slot`; below it, vertex indices name vertices.
 pub const PACKED_BASE: u32 = 1 << 28;
@@ -133,12 +136,24 @@ pub fn pack_quad(quad: &[TerrainVertex; 4], tint: u32) -> Option<[u32; 6]> {
    for (i, v) in quad.iter().enumerate() {
        grays |= gray_of(v.color, tint)? << (8 * i);
    }
+    // Corners 1 to 3's alpha (a shader pack's `separateAo`: each corner's ambient occlusion,
+    // multiples of 51 on a whole face): `ALPHA_STEP` times the code, 0 for corner 0's.
+    let mut codes = [0u32; 3];
+    for (code, v) in codes.iter_mut().zip(&quad[1..]) {
+        let a = v.color >> 24;
+        if v.color & 0xFF00_0000 != alpha {
+            if a == 0 || a % ALPHA_STEP != 0 {
+                return None;
+            }
+            *code = a / ALPHA_STEP;
+        }
+    }
    let words = [
        tint | alpha,
        grays,
        rect | select << 24,
-        u32::from(quad[0].layer) | light[0] << 16,
-        light[1] | light[2] << 12,
+        u32::from(quad[0].layer) | light[0] << 16 | codes[0] << 28,
+        light[1] | light[2] << 12 | codes[1] << 24 | codes[2] << 27,
        light[3] | orient << 12,
    ];
    let exact = (0..4).all(|c| {
@@ -190,12 +205,18 @@ pub fn packed_vertex(words: &[u32; 6], corner: usize) -> TerrainVertex {
    let light = ((light & 63) << 2 | (light >> 6 & 63) << 10) as u16;
    let g = w1 >> (8 * i) & 255;
    let [r, gr, b] = channels(w0).map(|t| g * t / 255);
+    let code = [0, w3 >> 28 & 7, w4 >> 24 & 7, w4 >> 27 & 7][corner];
+    let alpha = if code == 0 {
+        w0 & 0xFF00_0000
+    } else {
+        (code * ALPHA_STEP) << 24
+    };
    TerrainVertex {
        pos: pos.map(|c| c as f32),
        uv,
        layer: (w3 & 0xFFFF) as u16,
        light,
-        color: r | gr << 8 | b << 16 | (w0 & 0xFF00_0000),
+        color: r | gr << 8 | b << 16 | alpha,
    }
 }

@@ -247,11 +268,10 @@ pub fn place_into(
    let n = quads.len();
    let packed = records.iter().filter(|r| r.is_some()).count();
    let full = n - packed;
-    let pad = if full > 0 {
-        n.next_multiple_of(4) - n
-    } else {
-        0
-    };
+    // Whole quads of slots: what follows (a quad's own vertices, the translucent ones after
+    // the solid range) then starts a quad, as a shader pack's vertex stage reads its quad's
+    // corners from the vertex index (`pack_atlas::PULL_FLAT`).
+    let pad = n.next_multiple_of(4) - n;
    if n + pad + 4 * full >= 4 * n {
        return;
    }
@@ -334,6 +354,22 @@ mod tests {
        }
    }

+    #[test]
+    fn each_corners_ambient_occlusion_alpha_packs_on_its_steps() {
+        // A shader pack's `separateAo`: the alpha byte is each corner's occlusion.
+        let mut quad = top([0, 1, 2, 3]);
+        for (v, a) in quad.iter_mut().zip([153u32, 255, 51, 204]) {
+            v.color = v.color & 0x00FF_FFFF | a << 24;
+        }
+        let words = pack_quad(&quad, TINT).expect("occlusion on the 51 steps packs");
+        for (corner, v) in quad.iter().enumerate() {
+            assert!(same(&packed_vertex(&words, corner), v), "corner {corner}");
+        }
+        // A partial face's blended occlusion falls between the steps.
+        quad[2].color = quad[2].color & 0x00FF_FFFF | 140 << 24;
+        assert!(pack_quad(&quad, TINT).is_none());
+    }
+
    #[test]
    fn quads_off_the_grid_or_the_steps_keep_their_vertices() {
        // Half a block up: a slab's top.
@@ -375,4 +411,13 @@ mod tests {
        // Nothing smaller to gain: no layout at all.
        assert!(layout(&odd, &[TINT]).is_empty());
    }
+
+    #[test]
+    fn the_records_end_on_a_whole_quad_of_slots() {
+        // Five whole faces, every one a record: the translucent vertices after them start a quad.
+        let solid: Vec<TerrainVertex> = (0..5).flat_map(|_| top([0, 1, 2, 3])).collect();
+        let out = layout(&solid, &[TINT; 5]);
+        assert_eq!(packed_quads(&out, 5), 5);
+        assert_eq!(out.len(), 8);
+    }
 }
@@ -18,6 +18,12 @@ use crate::{
    ui,
 };

+mod shell_pages;
+
+#[path = "options_ui_wheel.rs"]
+mod wheel;
+pub(crate) use wheel::slider_unsnapped;
+
 fn tr(key: &str) -> Text {
    Text::translate(key, &[])
 }
@@ -322,6 +328,8 @@ impl Opt {
            Opt::PadNintendoButtons => "horizon.options.nintendo_buttons",
            Opt::PadKeyboard => "horizon.options.on_screen_keyboard",
            Opt::PadGameplayGuide => "horizon.options.gameplay_guide",
+            Opt::PadRadialMode => "horizon.options.radial_mode",
+            Opt::PadRadialStick => "horizon.options.radial_stick",
            Opt::ModelPart(i) => [
                "options.modelPart.cape",
                "options.modelPart.jacket",
@@ -361,7 +369,7 @@ impl Opt {
            ),
            Opt::SimulationDistance => unit(s.simulation_distance as f32, 5.0, 32.0),
            Opt::Sensitivity => Kind::Slider(s.sensitivity),
-            Opt::WheelSensitivity => unit(s.mouse_wheel_sensitivity, 0.01, 10.0),
+            Opt::WheelSensitivity => wheel::kind(s.mouse_wheel_sensitivity),
            Opt::Volume(i) => Kind::Slider(if i == 0 {
                s.master_volume
            } else {
@@ -880,6 +888,7 @@ impl Opt {
                gamepad::TextKeyboard::Horizon => "horizon.options.keyboard.horizon",
                gamepad::TextKeyboard::Steam => "horizon.options.keyboard.steam",
            }),
+            Opt::PadRadialMode | Opt::PadRadialStick => self.radial_text(s),
            Opt::Page(page, row) => pages::slider_text(page, row),
            _ => Text::empty(),
        }
@@ -911,7 +920,7 @@ impl Opt {
            }
            Opt::SimulationDistance => s.simulation_distance = step(5.0, 32.0) as i32,
            Opt::Sensitivity => s.sensitivity = v,
-            Opt::WheelSensitivity => s.mouse_wheel_sensitivity = 0.01 + v * 9.99,
+            Opt::WheelSensitivity => s.mouse_wheel_sensitivity = wheel::from_slider(v),
            Opt::Volume(0) => s.master_volume = v,
            Opt::Volume(i) => s.volumes[i] = v,
            Opt::Gamma => s.gamma = v,
@@ -1201,6 +1210,7 @@ impl Opt {
                    .unwrap_or(0) as u8;
                s.controller.keyboard = all[usize::from(next(i, 3))];
            }
+            Opt::PadRadialMode | Opt::PadRadialStick => self.radial_step(s, back),
            _ => {}
        }
        if self.affects_preset() {
@@ -1352,6 +1362,11 @@ pub enum Page {
    /// Horizon's controller settings and button binds.
    Controller,
    PadBinds,
+    /// The radial menu's pages (`radial_editor`), on the settings shell, and a page's name.
+    ControllerRadial,
+    ControllerRadialName,
+    /// The list of every action for one of its slots.
+    ControllerRadialPick,
    Extras,
    /// PvP & HUD (`pvp`): the extras a PvP player sets, on their own page.
    Pvp,
@@ -1593,23 +1608,6 @@ pub struct MusicGroup {
    /// The rows, in `sounds.json` order.
    pub tracks: Vec<MusicTrack>,
 }
-/// `SliderableValueSet.applyValueImmediately`: these apply 600 ms after
-/// the last change (`OptionInstanceSliderButton.delayedApplyAt`).
-fn delays_apply(opt: Opt) -> bool {
-    matches!(
-        opt,
-        Opt::RenderDistance | Opt::SimulationDistance | Opt::BiomeBlend | Opt::WheelSensitivity
-    )
-}
-/// Whether a slider still shows its own position: while held, or for a
-/// delayed one until its value applies (both then `resetValue`).
-fn slider_unsnapped(opt: Opt, held: bool, moved: Instant) -> bool {
-    if delays_apply(opt) {
-        moved.elapsed().as_millis() < 600
-    } else {
-        held
-    }
-}
 pub struct OptionsUi {
    pub stack: Vec<Page>,
    scroll: f32,
@@ -1683,6 +1681,10 @@ pub struct OptionsUi {
    controller: shell::Shell<crate::controller_ui::ControllerScreen>,
    /// Horizon Extras, on the settings shell.
    extras: shell::Shell<crate::extras_ui::ExtrasScreen>,
+    /// The radial menu's pages, on the settings shell.
+    radial: shell::Shell<crate::radial_editor::RadialScreen>,
+    /// The list of actions for one of the radial menu's slots.
+    radial_pick: shell::Shell<crate::radial_editor::PickScreen>,
    /// Shaders: the shader packs and the picked one's options, on the settings shell.
    shader: shell::Shell<crate::shader_ui::ShaderScreen>,
    /// The Pack Options page, and the packs' Polytone config entries by pack id (the game
@@ -1767,6 +1769,8 @@ impl Default for OptionsUi {
            graphics: Default::default(),
            controller: Default::default(),
            extras: Default::default(),
+            radial: Default::default(),
+            radial_pick: Default::default(),
            shader: Default::default(),
            pack_options: Default::default(),
            pack_configs: Default::default(),
@@ -2112,6 +2116,7 @@ impl OptionsUi {
                    .pack_screen
                    .as_ref()
                    .is_some_and(|p| p.search_focused()),
+                Page::ControllerRadialName => self.radial_name_typing(),
                _ => match self.shell() {
                    Some(shell) => shell.typing(),
                    None => self.settings_search_active(),
@@ -2244,95 +2249,16 @@ impl OptionsUi {
            self.studio.refresh();
        }
    }
-    /// The open page's screen on the settings shell. This, with `shell_mut`, is all a screen
-    /// needs here: drawing, clicks, the wheel, a stick's scrolling, keys and typing all go
-    /// through them, so no input path can miss one.
-    fn shell(&self) -> Option<&dyn shell::Hosted> {
-        match self.page() {
-            Page::Extras => Some(&self.extras),
-            page if Self::graphics_page(page).is_some() => Some(&self.graphics),
-            page if Self::controller_page(page).is_some() => Some(&self.controller),
-            page if Self::shader_page(page).is_some() => Some(&self.shader),
-            _ => None,
-        }
-    }
-    fn shell_mut(&mut self) -> Option<&mut dyn shell::Hosted> {
-        self.graphics.screen.output = self.output;
-        match self.page() {
-            Page::Extras => Some(&mut self.extras),
-            page if Self::graphics_page(page).is_some() => Some(&mut self.graphics),
-            page if Self::controller_page(page).is_some() => Some(&mut self.controller),
-            page if Self::shader_page(page).is_some() => Some(&mut self.shader),
-            _ => None,
-        }
-    }
    /// A controller's or the keyboard's focus landed on `rect`: a row of a shell screen's list
    /// that is partly hidden scrolls all into view. How far it moved down, when it moved.
    pub fn reveal(&mut self, s: &Settings, size: (f32, f32), rect: [f32; 4]) -> Option<f32> {
        self.shell_mut()?.reveal(s, size, rect)
    }
-    /// The window's size, for the graphics and controller screens' rows that step an option
-    /// (`Opt::cycle`, which a fullscreen resolution needs): before each input that can press one.
-    fn shell_framebuffers(&mut self) {
-        self.graphics.screen.framebuffer = self.framebuffer;
-        self.controller.screen.framebuffer = self.framebuffer;
-    }
-    /// Who and what Controller Settings is about: the game sets it before each draw.
-    pub fn set_controller_context(&mut self, context: crate::controller_ui::Context) {
-        self.controller.screen.context = context;
-    }
-    /// The binding the screen waits on: a controller button's, else a key's.
-    fn waiting(&self) -> Option<shell::Capture> {
-        let pad = self.selected_pad_action.map(shell::Capture::Pad);
-        pad.or(self.selected_key.map(shell::Capture::Key))
-    }
-    /// What a shell screen's outputs do to these options.
-    fn shell_events(&mut self, s: &mut Settings, outputs: Vec<shell::Output>) -> Vec<Event> {
-        let mut events = Vec::new();
-        for output in outputs {
-            match output {
-                shell::Output::Event(event) => events.push(event),
-                shell::Output::Bind(shell::Capture::Key(name)) => self.selected_key = Some(name),
-                shell::Output::Bind(shell::Capture::Pad(action)) => {
-                    self.selected_pad_action = Some(action)
-                }
-                shell::Output::Push(page) => {
-                    if page == Page::HdrCalibration {
-                        self.calibration =
-                            Some(crate::hdr_calibration::Calibration::new(s, &self.output));
-                    }
-                    self.push(page);
-                }
-                shell::Output::Done => events.extend(self.back(s)),
-            }
-        }
-        events
-    }
-    /// Where the shader screen opens for `page`, if it is one of its pages.
-    fn shader_page(page: Page) -> Option<crate::shader_ui::Tab> {
-        match page {
-            Page::ShaderPacks => Some(crate::shader_ui::Tab::Packs),
-            Page::ShaderOptions => Some(crate::shader_ui::Tab::Screen(0)),
-            _ => None,
-        }
-    }
-    /// Where the controller screen opens for `page`, if it is one of its pages.
-    fn controller_page(page: Page) -> Option<crate::controller_ui::Page> {
-        match page {
-            Page::Controller => Some(crate::controller_ui::Page::General),
-            Page::PadBinds => Some(crate::controller_ui::Page::Bindings),
-            _ => None,
-        }
-    }
    /// Whether a video settings screen is open, Horizon's or vanilla's: the fullscreen mode
    /// waits for it to close, and Ctrl with the wheel steps the GUI scale.
    pub fn video_open(&self) -> bool {
        self.page() == Page::Video || Self::graphics_page(self.page()).is_some()
    }
-    /// Whether the controller screen is open: a controller button pressed now may bind.
-    pub fn controller_open(&self) -> bool {
-        Self::controller_page(self.page()).is_some()
-    }
    /// Where the graphics screen opens for `page`, if it is one of its pages.
    fn graphics_page(page: Page) -> Option<crate::graphics_ui::Page> {
        match page {
@@ -2369,6 +2295,9 @@ impl OptionsUi {
                "options.videoTitle"
            }
            Page::Controller | Page::PadBinds => "horizon.pages.controller",
+            Page::ControllerRadial => "horizon.pages.controller_radial",
+            Page::ControllerRadialName => "horizon.radial.name_title",
+            Page::ControllerRadialPick => "horizon.radial.pick_title",
            Page::Extras => "horizon.pages.extras",
            Page::Pvp => "horizon.pages.pvp",
            Page::Credits => "credits_and_attribution.screen.title",
@@ -3602,6 +3531,9 @@ impl OptionsUi {
        }
        let waiting = self.waiting();
        let in_world = self.in_world;
+        if self.draw_radial_name(batch, atlas, cursor, in_world) {
+            return;
+        }
        if let Some(shell) = self.shell_mut() {
            shell.draw(s, batch, atlas, cursor, in_world, waiting);
            // The keys lay the screen out at the size it was drawn at.
@@ -3953,6 +3885,9 @@ impl OptionsUi {
            let outcome = c.click(&atlas.font, (x, y), size, drag);
            return self.calibration_outcome(s, outcome);
        }
+        if self.page() == Page::ControllerRadialName {
+            return self.click_radial_name(s, atlas, (x, y), size, drag || right);
+        }
        if self.shell().is_some() {
            // Waiting on a controller button: a click cancels the wait.
            if !drag && self.selected_pad_action.take().is_some() {
@@ -4648,6 +4583,8 @@ impl OptionsUi {
            self.scroll = 0.0;
        } else if self.page() == Page::SplitProfiles {
            self.split_profiles.type_text(text);
+        } else if self.page() == Page::ControllerRadialName {
+            self.type_radial_name(text);
        } else if let Some(shell) = self.shell_mut() {
            if shell.typing() {
                shell.type_text(text);
@@ -4683,6 +4620,9 @@ impl OptionsUi {
        if self.page() == Page::SplitProfiles {
            return self.split_profiles.shortcut(shortcut, clipboard);
        }
+        if self.page() == Page::ControllerRadialName {
+            return self.radial_name_shortcut(shortcut, clipboard);
+        }
        if let Some(shell) = self.shell_mut() {
            return shell.shortcut(shortcut, clipboard);
        }
@@ -4786,6 +4726,9 @@ impl OptionsUi {
        if self.page() == Page::SplitProfiles && self.split_profiles.key(key, text) {
            return Vec::new();
        }
+        if self.page() == Page::ControllerRadialName {
+            return self.radial_name_key(s, key, text);
+        }

        // The size it was drawn at; before the first draw, one its keys can lay out at.
        let gui = if self.size.0 > 0.0 && self.size.1 > 0.0 {
@@ -0,0 +1,302 @@
+//! The pages Options shows on the settings shell (`settings_shell`): which shell each page
+//! opens, what a shell's outputs do here, and the radial menu's pages (`radial_editor`), whose
+//! name entry is drawn here in place of a shell, and whose rows of Controller Settings step here.
+use super::{Event, OptionsUi, Page, tr};
+use crate::{
+    gamepad,
+    hud::{HudAtlas, HudBatch},
+    radial_editor::Named,
+    settings::{Opt, Settings},
+    settings_shell as shell,
+    text::Text,
+};
+
+impl OptionsUi {
+    /// The open page's screen on the settings shell. This, with `shell_mut`, is all a screen
+    /// needs here: drawing, clicks, the wheel, a stick's scrolling, keys and typing all go
+    /// through them, so no input path can miss one.
+    pub(super) fn shell(&self) -> Option<&dyn shell::Hosted> {
+        match self.page() {
+            Page::Extras => Some(&self.extras),
+            page if Self::graphics_page(page).is_some() => Some(&self.graphics),
+            Page::ControllerRadial => Some(&self.radial),
+            Page::ControllerRadialPick => Some(&self.radial_pick),
+            page if Self::controller_page(page).is_some() => Some(&self.controller),
+            page if Self::shader_page(page).is_some() => Some(&self.shader),
+            _ => None,
+        }
+    }
+    pub(super) fn shell_mut(&mut self) -> Option<&mut dyn shell::Hosted> {
+        self.graphics.screen.output = self.output;
+        match self.page() {
+            Page::Extras => Some(&mut self.extras),
+            page if Self::graphics_page(page).is_some() => Some(&mut self.graphics),
+            Page::ControllerRadial => Some(&mut self.radial),
+            Page::ControllerRadialPick => Some(&mut self.radial_pick),
+            page if Self::controller_page(page).is_some() => Some(&mut self.controller),
+            page if Self::shader_page(page).is_some() => Some(&mut self.shader),
+            _ => None,
+        }
+    }
+    /// Where the open shell screen asked the focus to open (a radial slot's list, on the slot's
+    /// action), for a controller's focus to land there.
+    pub fn shell_opened_focus(&self) -> Option<[f32; 4]> {
+        self.shell()?.opened_focus()
+    }
+    /// The clicks until it is set back are a controller's Left or Right on a row: a choice of a
+    /// settings shell steps, rather than opens.
+    pub fn pad_clicks_step(&mut self, on: bool) {
+        if on {
+            if let Some(shell) = self.shell_mut() {
+                shell.clicks_step(true);
+            }
+            return;
+        }
+        // Every shell: the click may have changed the page.
+        let shells: [&mut dyn shell::Hosted; 6] = [
+            &mut self.extras,
+            &mut self.graphics,
+            &mut self.controller,
+            &mut self.radial,
+            &mut self.radial_pick,
+            &mut self.shader,
+        ];
+        for shell in shells {
+            shell.clicks_step(false);
+        }
+    }
+    /// The controller's focus landed there.
+    pub fn clear_shell_opened_focus(&mut self) {
+        if let Some(shell) = self.shell_mut() {
+            shell.clear_opened_focus();
+        }
+    }
+    /// The window's size, for the graphics and controller screens' rows that step an option
+    /// (`Opt::cycle`, which a fullscreen resolution needs): before each input that can press one.
+    pub(super) fn shell_framebuffers(&mut self) {
+        self.graphics.screen.framebuffer = self.framebuffer;
+        self.controller.screen.framebuffer = self.framebuffer;
+    }
+    /// Who and what Controller Settings is about: the game sets it before each draw.
+    pub fn set_controller_context(&mut self, context: crate::controller_ui::Context) {
+        self.controller.screen.context = context;
+    }
+    /// The binding the screen waits on: a controller button's, else a key's.
+    pub(super) fn waiting(&self) -> Option<shell::Capture> {
+        let pad = self.selected_pad_action.map(shell::Capture::Pad);
+        pad.or(self.selected_key.map(shell::Capture::Key))
+    }
+    /// What a shell screen's outputs do to these options.
+    pub(super) fn shell_events(
+        &mut self,
+        s: &mut Settings,
+        outputs: Vec<shell::Output>,
+    ) -> Vec<Event> {
+        let mut events = Vec::new();
+        for output in outputs {
+            match output {
+                shell::Output::Event(event) => events.push(event),
+                shell::Output::Bind(shell::Capture::Key(name)) => self.selected_key = Some(name),
+                shell::Output::Bind(shell::Capture::Pad(action)) => {
+                    self.selected_pad_action = Some(action)
+                }
+                shell::Output::Push(page) => {
+                    if page == Page::HdrCalibration {
+                        self.calibration =
+                            Some(crate::hdr_calibration::Calibration::new(s, &self.output));
+                    }
+                    self.push(page);
+                    // A slot's list, for the slot, opening on what it holds.
+                    if page == Page::ControllerRadialPick
+                        && let Some(at) = self.radial.screen.picking.take()
+                    {
+                        let row = self.radial_pick.screen.open_on(at, &s.controller.radial);
+                        self.radial_pick.focus_soon(row);
+                    }
+                }
+                shell::Output::Done => {
+                    // Back from a slot's list, the focus is on the slot.
+                    let slot = (self.page() == Page::ControllerRadialPick)
+                        .then(|| self.radial_pick.screen.at());
+                    events.extend(self.back(s));
+                    if let Some((page, slot)) = slot {
+                        self.radial
+                            .focus_soon(crate::radial_editor::RadialRow::Slot(page, slot));
+                    }
+                }
+            }
+        }
+        // A pick on a slot's list is a change of the radial page's, which its Undo takes back.
+        if self.radial_pick.screen.take_picked() {
+            self.radial.changed_elsewhere();
+        }
+        // A radial page added or deleted: the one to show now.
+        if let Some(page) = self.radial.screen.take_shown() {
+            self.radial.show(page);
+        }
+        events
+    }
+    /// What a press on a radial page's name does here.
+    pub(super) fn name_events(
+        &mut self,
+        named: crate::radial_editor::Named,
+        s: &mut Settings,
+    ) -> Vec<Event> {
+        use crate::radial_editor::Named;
+        let mut events = vec![Event::ButtonClick];
+        match named {
+            Named::Nothing => return Vec::new(),
+            Named::Done => {
+                let entry = self.radial.screen.naming.take();
+                if entry.is_some_and(|entry| entry.apply(&mut s.controller.radial)) {
+                    self.radial.changed_elsewhere();
+                }
+                events.push(Event::Changed);
+                events.extend(self.back(s));
+            }
+            Named::Back => events.extend(self.back(s)),
+        }
+        events
+    }
+    /// Where the shader screen opens for `page`, if it is one of its pages.
+    pub(super) fn shader_page(page: Page) -> Option<crate::shader_ui::Tab> {
+        match page {
+            Page::ShaderPacks => Some(crate::shader_ui::Tab::Packs),
+            Page::ShaderOptions => Some(crate::shader_ui::Tab::Screen(0)),
+            _ => None,
+        }
+    }
+    /// Where the controller screen opens for `page`, if it is one of its pages.
+    pub(super) fn controller_page(page: Page) -> Option<crate::controller_ui::Page> {
+        match page {
+            Page::Controller => Some(crate::controller_ui::Page::General),
+            Page::PadBinds => Some(crate::controller_ui::Page::Bindings),
+            _ => None,
+        }
+    }
+    /// Whether the controller screen is open: a controller button pressed now may bind.
+    pub fn controller_open(&self) -> bool {
+        Self::controller_page(self.page()).is_some()
+    }
+    /// The radial screens' glyphs this frame, and the name of a radial page being typed, drawn
+    /// in place of a shell: whether it was.
+    pub(super) fn draw_radial_name(
+        &mut self,
+        batch: &mut HudBatch,
+        atlas: &HudAtlas,
+        cursor: (f32, f32),
+        in_world: bool,
+    ) -> bool {
+        self.radial.screen.glyphs = self.pad_glyphs;
+        if self.page() == Page::ControllerRadialName
+            && let Some(entry) = &mut self.radial.screen.naming
+        {
+            entry.draw(batch, atlas, cursor, in_world);
+            return true;
+        }
+        false
+    }
+    /// A click on a radial page's name entry (`ignored`: a drag or a right click).
+    pub(super) fn click_radial_name(
+        &mut self,
+        s: &mut Settings,
+        atlas: &HudAtlas,
+        at: (f32, f32),
+        size: (f32, f32),
+        ignored: bool,
+    ) -> Vec<Event> {
+        let entry = self.radial.screen.naming.as_mut();
+        let named = match entry.filter(|_| !ignored) {
+            Some(entry) => entry.click(atlas, at, size),
+            None => Named::Nothing,
+        };
+        self.name_events(named, s)
+    }
+    /// Whether a radial page's name is being typed.
+    pub(super) fn radial_name_typing(&self) -> bool {
+        self.radial
+            .screen
+            .naming
+            .as_ref()
+            .is_some_and(|n| n.typing())
+    }
+    /// Text typed into a radial page's name.
+    pub(super) fn type_radial_name(&mut self, text: &str) {
+        if let Some(entry) = &mut self.radial.screen.naming {
+            entry.type_text(text);
+        }
+    }
+    /// An edit shortcut in a radial page's name: whether it did something.
+    pub(super) fn radial_name_shortcut(
+        &mut self,
+        shortcut: crate::clipboard::EditShortcut,
+        clipboard: &mut dyn crate::clipboard::Clipboard,
+    ) -> bool {
+        let entry = self.radial.screen.naming.as_mut();
+        entry.is_some_and(|entry| entry.shortcut(shortcut, clipboard))
+    }
+    /// A key on a radial page's name entry.
+    pub(super) fn radial_name_key(
+        &mut self,
+        s: &mut Settings,
+        key: winit::keyboard::KeyCode,
+        text: Option<&str>,
+    ) -> Vec<Event> {
+        let named = match &mut self.radial.screen.naming {
+            Some(entry) => entry.key(key, text),
+            // Nothing to name: Escape still leaves.
+            None if key == winit::keyboard::KeyCode::Escape => Named::Back,
+            None => Named::Nothing,
+        };
+        self.name_events(named, s)
+    }
+}
+
+impl Opt {
+    /// The radial menu's rows of Controller Settings: their value.
+    pub(super) fn radial_text(self, s: &Settings) -> Text {
+        match self {
+            Opt::PadRadialMode => tr(match s.controller.radial_mode {
+                gamepad::RadialMode::Hold => "options.key.hold",
+                gamepad::RadialMode::Toggle => "options.key.toggle",
+            }),
+            Opt::PadRadialStick => tr(match s.controller.radial_stick {
+                gamepad::RadialStick::Right => "horizon.options.radial_stick.right",
+                gamepad::RadialStick::Left => "horizon.options.radial_stick.left",
+                gamepad::RadialStick::Either => "horizon.options.radial_stick.either",
+            }),
+            _ => Text::empty(),
+        }
+    }
+    /// The radial menu's rows of Controller Settings: a step, back or on.
+    pub(super) fn radial_step(self, s: &mut Settings, back: bool) {
+        let next = |n: u8, count: u8| {
+            if back {
+                (n + count - 1) % count
+            } else {
+                (n + 1) % count
+            }
+        };
+        match self {
+            Opt::PadRadialMode => {
+                let all = gamepad::RadialMode::ALL;
+                let i = all
+                    .iter()
+                    .position(|m| *m == s.controller.radial_mode)
+                    .unwrap_or(0) as u8;
+                s.controller.radial_mode = all[usize::from(next(i, all.len() as u8))];
+            }
+            Opt::PadRadialStick => {
+                let all = gamepad::RadialStick::ALL;
+                let i = all
+                    .iter()
+                    .position(|k| *k == s.controller.radial_stick)
+                    .unwrap_or(0) as u8;
+                // An opener under the thumb that now selects goes unbound.
+                s.controller
+                    .set_radial_stick(all[usize::from(next(i, all.len() as u8))]);
+            }
+            _ => {}
+        }
+    }
+}
@@ -0,0 +1,71 @@
+//! `Options.mouseWheelSensitivity`'s logarithmic slider (`logMouse`/`unlogMouse`)
+//! and the delayed-apply test the slider buttons share.
+use super::*;
+use std::time::Instant;
+
+/// `SliderableValueSet.applyValueImmediately`: these apply 600 ms after
+/// the last change (`OptionInstanceSliderButton.delayedApplyAt`).
+fn delays_apply(opt: Opt) -> bool {
+    matches!(
+        opt,
+        Opt::RenderDistance | Opt::SimulationDistance | Opt::BiomeBlend | Opt::WheelSensitivity
+    )
+}
+/// Whether a slider still shows its own position: while held, or for a
+/// delayed one until its value applies (both then `resetValue`).
+pub(crate) fn slider_unsnapped(opt: Opt, held: bool, moved: Instant) -> bool {
+    if delays_apply(opt) {
+        moved.elapsed().as_millis() < 600
+    } else {
+        held
+    }
+}
+/// `Options.unlogMouse`: the stored sensitivity as its hundredth-log step,
+/// -200..=100, which the `IntRange(-200, 100)` slider runs over (0.01 to 10.0).
+pub(crate) fn step(value: f32) -> f32 {
+    (value.max(1.0e-6).log10() * 100.0)
+        .floor()
+        .clamp(-200.0, 100.0)
+}
+/// `IntRange(-200, 100).toSliderValue`: the step over the slider's span.
+pub(crate) fn kind(value: f32) -> Kind {
+    Kind::Slider(((step(value) + 200.0) / 300.0).clamp(0.0, 1.0))
+}
+/// `IntRange(-200, 100).fromSliderValue` then `Options.logMouse`:
+/// floor(map(v, 0, 1, -200, 101)), the last step clamped, as 10^(i/100).
+pub(crate) fn from_slider(v: f32) -> f32 {
+    let i = (v.clamp(0.0, 1.0) * 301.0).floor() - 200.0;
+    10.0_f32.powf(i.clamp(-200.0, 100.0) / 100.0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The slider position `Opt::WheelSensitivity`'s kind() gives a value.
+    fn wheel_pos(value: f32) -> f32 {
+        match kind(value) {
+            Kind::Slider(p) => p,
+            _ => panic!("the wheel sensitivity is a slider"),
+        }
+    }
+    /// `Options.mouseWheelSensitivity` runs over `IntRange(-200, 100)` through
+    /// `logMouse`/`unlogMouse`: 10^(i/100), 0.01 to 10.0, not a straight line.
+    #[test]
+    fn the_mouse_wheel_sensitivity_slider_is_logarithmic() {
+        // 1.0 is step 0: 200 of the 300 slider steps in, not at 0.099.
+        assert!((wheel_pos(1.0) - 2.0 / 3.0).abs() < 1e-6);
+        assert!((wheel_pos(0.01) - 0.0).abs() < 1e-6);
+        assert!((wheel_pos(10.0) - 1.0).abs() < 1e-6);
+        assert!((from_slider(2.0 / 3.0) - 1.0).abs() < 1e-5);
+        assert!((from_slider(0.0) - 0.01).abs() < 1e-6);
+        assert!((from_slider(1.0) - 10.0).abs() < 1e-4);
+        assert!((from_slider(1.0 / 3.0) - 0.1).abs() < 1e-5);
+        // The value setter goes through the same mapping.
+        let mut s = Settings::default();
+        set_slider(Opt::WheelSensitivity, &mut s, 2.0 / 3.0);
+        assert!((s.mouse_wheel_sensitivity - 1.0).abs() < 1e-5);
+        set_slider(Opt::WheelSensitivity, &mut s, 0.0);
+        assert!((s.mouse_wheel_sensitivity - 0.01).abs() < 1e-6);
+    }
+}
@@ -368,6 +368,57 @@ pub struct PackScreen {
    browser_search: TextField,
    /// The browser's search box has the keyboard.
    browser_focus: bool,
+    /// Which atlas slot holds which icon, kept from one frame to the next
+    /// ([`PackScreen::bind_icons`]).
+    icon_slots: std::cell::RefCell<IconSlots>,
+}
+
+/// The atlas's pack icon slots and the icon each holds. The atlas keeps what is
+/// written into a slot, so an icon is sent once, when it takes a slot, and not
+/// again every frame it is drawn.
+#[derive(Clone, Debug, Default)]
+struct IconSlots {
+    /// The atlas the pixels went into ([`HudAtlas::revision`]); a new atlas holds none of them.
+    revision: u64,
+    /// Frames bound so far: an icon drawn in this one keeps its slot.
+    frame: u64,
+    /// Least recently drawn first: the icon's texture key, its slot, its pixels, and the
+    /// frame it was last drawn in.
+    held: Vec<(String, usize, Arc<[u8]>, u64)>,
+}
+
+impl IconSlots {
+    /// Starts a frame on `atlas`; an atlas that is not the one the slots were filled in empties them.
+    fn begin(&mut self, atlas: &HudAtlas) {
+        if self.revision != atlas.revision {
+            self.held.clear();
+            self.revision = atlas.revision;
+        }
+        self.frame += 1;
+    }
+
+    /// The slot for the icon drawn under `texture`, and whether its pixels have to be sent. A new
+    /// icon takes a free slot, else the slot of the icon drawn longest ago; none when every slot
+    /// holds an icon drawn in this frame, and that icon keeps `unknown_pack`.
+    fn slot_for(&mut self, texture: &str, icon: &Arc<[u8]>) -> Option<(usize, bool)> {
+        if let Some(at) = self.held.iter().position(|h| h.0 == texture) {
+            let mut kept = self.held.remove(at);
+            let same = Arc::ptr_eq(&kept.2, icon);
+            kept.2 = icon.clone();
+            kept.3 = self.frame;
+            let slot = kept.1;
+            self.held.push(kept);
+            return Some((slot, !same));
+        }
+        let slot = match (0..PACK_ICON_SLOTS).find(|i| !self.held.iter().any(|h| h.1 == *i)) {
+            Some(free) => free,
+            None if self.held.first().is_some_and(|h| h.3 < self.frame) => self.held.remove(0).1,
+            None => return None,
+        };
+        self.held
+            .push((texture.to_owned(), slot, icon.clone(), self.frame));
+        Some((slot, true))
+    }
 }

 fn tr(key: &str) -> Text {
@@ -459,6 +510,7 @@ impl PackScreen {
                field
            },
            browser_focus: false,
+            icon_slots: Default::default(),
            changed: false,
        };
        s.reposition(m);
@@ -931,10 +983,13 @@ impl PackScreen {
        self.model.commit()
    }
    /// Points the icon blits of `draws` at the atlas's pack icon slots and
-    /// writes the icons into them, one slot per icon drawn (vanilla registers a
-    /// texture per pack). Icons past the last slot keep `unknown_pack`.
+    /// writes the icons into them (vanilla registers a texture per pack). An
+    /// icon keeps its slot from one frame to the next and is sent when it takes
+    /// the slot, not every frame; the slot of the icon drawn longest ago is
+    /// taken first. Icons past the last slot in one frame keep `unknown_pack`.
    pub fn bind_icons(&self, draws: &mut [Draw], atlas: &HudAtlas, patches: &mut Vec<Patch>) {
-        let mut slots = 0..PACK_ICON_SLOTS;
+        let mut slots = self.icon_slots.borrow_mut();
+        slots.begin(atlas);
        for draw in draws {
            let Draw::Blit { texture, .. } = draw else {
                continue;
@@ -942,20 +997,23 @@ impl PackScreen {
            let Some(icon) = self.icons.get(texture.as_str()) else {
                continue;
            };
-            let Some(slot) = slots.next() else {
-                return;
+            let Some((slot, send)) = slots.slot_for(texture, icon) else {
+                continue;
            };
            let sprite = format!("horizon/pack-icon{slot}");
            let Some(rect) = atlas.sprites.get(&sprite) else {
+                slots.held.pop();
                return;
            };
-            patches.push(Patch {
-                x: (rect.u0 * atlas.width as f32).round() as u32,
-                y: (rect.v0 * atlas.height as f32).round() as u32,
-                width: PACK_ICON_SIZE,
-                height: PACK_ICON_SIZE,
-                rgba: icon.to_vec(),
-            });
+            if send {
+                patches.push(Patch {
+                    x: (rect.u0 * atlas.width as f32).round() as u32,
+                    y: (rect.v0 * atlas.height as f32).round() as u32,
+                    width: PACK_ICON_SIZE,
+                    height: PACK_ICON_SIZE,
+                    rgba: icon.to_vec(),
+                });
+            }
            *texture = sprite;
        }
    }
@@ -1618,6 +1676,12 @@ impl PackScreen {
                        let hover = hovered == Some(i)
                            && d::inside(mouse, bx, by, OPTIONS_SIZE, OPTIONS_SIZE);
                        Self::draw_options_button(out, bx, by, hover);
+                        // A control for a pad's crosshair to glide onto and its D-pad to hop to,
+                        // while the list shows it whole.
+                        let mark = crate::widgets::targets_mark();
+                        let size = OPTIONS_SIZE as f32;
+                        crate::widgets::target([bx as f32, by as f32, size, size]);
+                        crate::widgets::clip_targets(mark, l.y as f32, l.bottom() as f32);
                        if hover {
                            tooltip = Some(tr("horizon.pack.optionsInfo"));
                        }
@@ -1745,9 +1809,14 @@ mod icon_tests {
            .unwrap();
        assert_eq!(id, "file/Configurable");
        let (cx, cy) = (bx + OPTIONS_SIZE / 2, by + OPTIONS_SIZE / 2);
-        // Hovered, it explains itself.
+        // Hovered, it explains itself; a pad's crosshair reaches it as a control.
        let draws = screen.draw(&m, (cx, cy), 0, 0);
        assert!(draws.iter().any(|d| matches!(d, Draw::Tooltip { .. })));
+        crate::widgets::end_frame(crate::widgets::generation() + 1);
+        let size = OPTIONS_SIZE as f32;
+        let button = [bx as f32, by as f32, size, size];
+        let targets = crate::widgets::last_targets();
+        assert!(targets.iter().any(|t| t.rect == button), "{targets:?}");
        assert_eq!(
            screen.click(&m, cx as f64, cy as f64),
            Action::Options("file/Configurable".into())
@@ -2070,3 +2139,177 @@ mod footer_label_tests {
        assert_eq!(lang::code(), before, "the global language was left alone");
    }
 }
+
+#[cfg(test)]
+mod icon_slot_tests {
+    use super::*;
+
+    fn atlas() -> HudAtlas {
+        HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
+    }
+
+    /// `count` packs with an icon each, the pixels of icon `i` all `i`.
+    fn packs(count: usize) -> Vec<PackInfo> {
+        let side = PACK_ICON_SIZE as usize;
+        (0..count)
+            .map(|i| PackInfo {
+                id: format!("file/pack{i:03}"),
+                title: Text::literal(format!("pack{i:03}")),
+                description: Text::literal(""),
+                description_style: Style::default(),
+                source: Source::BuiltIn,
+                compat: Compat::Compatible,
+                icon: Some(vec![i as u8; side * side * 4].into()),
+                required: false,
+                position: Position::Top,
+                fixed: false,
+            })
+            .collect()
+    }
+
+    /// One frame as `options_ui` draws it: the calls, then the icons bound. The icons drawn
+    /// (their texture keys before binding), the textures after, and the patches sent.
+    fn frame(screen: &PackScreen, atlas: &HudAtlas) -> (Vec<String>, Vec<String>, Vec<Patch>) {
+        let m = Measure(&atlas.font);
+        let mut draws = screen.draw(&m, (0, 0), 0, 0);
+        let drawn: Vec<String> = draws
+            .iter()
+            .filter_map(|d| match d {
+                Draw::Blit { texture, .. } if screen.icons.contains_key(texture) => {
+                    Some(texture.clone())
+                }
+                _ => None,
+            })
+            .collect();
+        let mut patches = Vec::new();
+        screen.bind_icons(&mut draws, atlas, &mut patches);
+        let bound = draws
+            .iter()
+            .filter_map(|d| match d {
+                Draw::Blit { texture, .. } if texture.contains("pack-icon") => {
+                    Some(texture.clone())
+                }
+                _ => None,
+            })
+            .collect();
+        (drawn, bound, patches)
+    }
+
+    /// Only the available list has packs: one row of 36 for each of `count` icons fits in a
+    /// window `height` high.
+    fn screen(m: &Measure, count: usize, height: i32) -> PackScreen {
+        PackScreen::new(
+            m,
+            tr("resourcePack.title"),
+            480,
+            height,
+            false,
+            packs(count),
+            &[],
+        )
+    }
+
+    /// Every frame sent every drawn icon again (a 128 by 128 RGBA copy each) into the same
+    /// atlas, which keeps what it is given: an icon is sent when it takes a slot, once.
+    #[test]
+    fn an_icon_is_sent_once_and_not_every_frame() {
+        let atlas = atlas();
+        let screen = screen(&Measure(&atlas.font), 5, 400);
+        let (drawn, bound, patches) = frame(&screen, &atlas);
+        assert_eq!((drawn.len(), bound.len(), patches.len()), (5, 5, 5));
+        for again in 0..3 {
+            let (_, rebound, resent) = frame(&screen, &atlas);
+            assert_eq!(rebound, bound, "frame {again}");
+            assert_eq!(resent.len(), 0, "frame {again}");
+        }
+    }
+
+    /// More icons drawn in one frame than there are slots: the first 64 get one, the rest keep
+    /// `unknown_pack`, and the next frame does not move them or send anything.
+    #[test]
+    fn past_the_slots_in_one_frame_the_rest_keep_unknown_pack() {
+        let atlas = atlas();
+        let screen = screen(&Measure(&atlas.font), PACK_ICON_SLOTS + 6, 4000);
+        let (drawn, bound, patches) = frame(&screen, &atlas);
+        assert_eq!(
+            drawn.len(),
+            PACK_ICON_SLOTS + 6,
+            "the window shows every row"
+        );
+        assert_eq!(
+            (bound.len(), patches.len()),
+            (PACK_ICON_SLOTS, PACK_ICON_SLOTS)
+        );
+        let (_, rebound, resent) = frame(&screen, &atlas);
+        assert_eq!((rebound, resent.len()), (bound, 0));
+    }
+
+    /// Scrolling through more packs than slots: every icon drawn gets a slot, each one is sent
+    /// once on the way down, and a frame that draws what the last one drew sends nothing.
+    #[test]
+    fn scrolling_sends_only_the_icons_that_come_into_view() {
+        let atlas = atlas();
+        let m = Measure(&atlas.font);
+        let mut screen = screen(&m, 70, 330);
+        let mut seen = std::collections::HashSet::new();
+        let mut sent = 0;
+        // 150 wheel steps of 18 are more than the 2520 high list.
+        for step in 0..150 {
+            let (drawn, bound, patches) = frame(&screen, &atlas);
+            assert_eq!(bound.len(), drawn.len(), "step {step}: none falls back");
+            let new = drawn.iter().filter(|t| seen.insert((*t).clone())).count();
+            assert_eq!(patches.len(), new, "step {step}");
+            sent += patches.len();
+            assert_eq!(frame(&screen, &atlas).2.len(), 0, "step {step}: same view");
+            screen.scroll(100.0, 200.0, -1.0);
+        }
+        assert_eq!((seen.len(), sent), (70, 70));
+    }
+
+    /// The slot of the icon drawn longest ago is the one taken, and the icon that left it is
+    /// sent again when it comes back.
+    #[test]
+    fn the_icon_drawn_longest_ago_gives_up_its_slot() {
+        let icons: Vec<Arc<[u8]>> = packs(PACK_ICON_SLOTS + 1)
+            .into_iter()
+            .map(|p| p.icon.unwrap())
+            .collect();
+        let mut slots = IconSlots::default();
+        let key = |i: usize| format!("k{i}");
+        slots.begin(&atlas());
+        for i in 0..PACK_ICON_SLOTS {
+            assert_eq!(slots.slot_for(&key(i), &icons[i]), Some((i, true)));
+        }
+        // The next frame draws icon 0 first, then a new one: slot 1, the oldest left, is taken.
+        slots.frame += 1;
+        assert_eq!(slots.slot_for(&key(0), &icons[0]), Some((0, false)));
+        assert_eq!(
+            slots.slot_for("new", &icons[PACK_ICON_SLOTS]),
+            Some((1, true))
+        );
+        // Icon 1 comes back: it is sent again, into the slot of the next oldest.
+        assert_eq!(slots.slot_for(&key(1), &icons[1]), Some((2, true)));
+    }
+
+    /// New pixels under the same key take the same slot and are sent; a new atlas holds none
+    /// of the icons, so all are sent again.
+    #[test]
+    fn changed_pixels_and_a_new_atlas_send_again() {
+        let atlas = atlas();
+        let mut screen = screen(&Measure(&atlas.font), 3, 400);
+        let (_, bound, patches) = frame(&screen, &atlas);
+        assert_eq!(patches.len(), 3);
+        let key = icon_texture("file/pack001");
+        screen
+            .icons
+            .insert(key, vec![200; patches[1].rgba.len()].into());
+        let (_, rebound, resent) = frame(&screen, &atlas);
+        assert_eq!(rebound, bound);
+        assert_eq!(resent.len(), 1);
+        assert_eq!((resent[0].x, resent[0].y), (patches[1].x, patches[1].y));
+        assert_eq!(resent[0].rgba[0], 200);
+        let other = self::atlas();
+        assert_ne!(other.revision, atlas.revision);
+        assert_eq!(frame(&screen, &other).2.len(), 3);
+    }
+}
@@ -466,6 +466,13 @@ fn read_meta(source: &Source) -> Option<serde_json::Value> {
 /// file with a comment after the closing brace. Gson reads past a UTF-8 byte order mark;
 /// serde_json rejects it.
 pub(crate) fn parse_meta(bytes: &[u8]) -> Option<serde_json::Value> {
+    first_json(bytes)
+}
+
+/// Reads the first JSON value from resource metadata, matching Gson's
+/// `JsonReader` (which ignores a trailing signature or comment). Resource
+/// packs commonly append such text to texture metadata as well as pack.mcmeta.
+pub(crate) fn first_json(bytes: &[u8]) -> Option<serde_json::Value> {
    serde_json::Deserializer::from_slice(bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes))
        .into_iter()
        .next()?
@@ -31,8 +31,10 @@ mod native;
 pub mod polytone;
 mod polytone_gpu;
 mod polytone_model;
+mod simple;
 mod spawn;
 pub use native::{ParticleController, ParticleUpdate};
+use simple::{PARALLEL_MIN, parallel_threads, sprite_from_age_in, tick_simple};

 /// `ParticleOptions` with the parameters of the option classes used here.
 #[derive(Clone, Debug)]
@@ -524,6 +526,8 @@ pub struct Particle {
    no_render: bool,
    /// Ticked once when created (`CritParticle` constructor).
    pre_tick: bool,
+    /// A Polytone particle with physics, which joins only where its box is clear of blocks.
+    spawn_check: bool,
    /// `Particle.random`: the particle's own generator (`RandomSource.create()`).
    random: LegacyRandom,
    controller: Option<Box<dyn native::Controller>>,
@@ -893,6 +897,7 @@ impl Particle {
            behaviour: Behaviour::Base,
            no_render: false,
            pre_tick: false,
+            spawn_check: false,
            frame_ticks: 0,
            random: LegacyRandom::new(0),
            controller: None,
@@ -1325,6 +1330,9 @@ pub struct ParticleEngine {
    /// A native mod's sprite sets, by namespaced particle name.
    mod_sets: HashMap<String, (u32, Option<ModBehaviour>)>,
    set_sprites: Vec<Vec<u32>>,
+    /// How many live particles it takes to tick them on several threads (`tick_all`), and how many threads.
+    parallel_min: usize,
+    parallel_threads: usize,
    /// Resource packs' Polytone custom particle types (#11486).
    polytone: Option<std::sync::Arc<polytone::Registry>>,
    /// Vanilla particle types a pack replaces with a custom one of the same id
@@ -1527,6 +1535,8 @@ impl ParticleEngine {
            sets: HashMap::new(),
            mod_sets: HashMap::new(),
            set_sprites: Vec::new(),
+            parallel_min: PARALLEL_MIN,
+            parallel_threads: parallel_threads(),
            polytone: None,
            polytone_overrides: HashMap::new(),
            polytone_gpu: Vec::new(),
@@ -1752,28 +1762,6 @@ impl ParticleEngine {
        particle.controller = Some(Box::new(controller));
        Some(particle)
    }
-    /// Sets (or clears) the resource packs' Polytone custom particle types.
-    pub fn set_polytone(&mut self, registry: Option<std::sync::Arc<polytone::Registry>>) {
-        let registry = registry.filter(|r| !r.is_empty());
-        let same = match (&self.polytone, &registry) {
-            (Some(a), Some(b)) => std::sync::Arc::ptr_eq(a, b),
-            (None, None) => true,
-            _ => false,
-        };
-        if !same {
-            self.polytone_gpu.clear();
-            self.polytone_overrides = registry
-                .iter()
-                .flat_map(|r| {
-                    ParticleType::ALL.iter().filter_map(|&ty| {
-                        let id = format!("minecraft:{}", ty.name());
-                        r.get(&id).is_some().then_some((ty, id))
-                    })
-                })
-                .collect();
-        }
-        self.polytone = registry;
-    }
    /// The quads the last render blends additively (`RenderPipelines` additive, src alpha and
    /// one), for the frame's additive pass.
    pub fn take_additive(&self) -> Vec<Vertex> {
@@ -2121,23 +2109,7 @@ impl ParticleEngine {
    }
    /// `SingleQuadParticle.setSpriteFromAge`.
    fn sprite_from_age(&self, p: &mut Particle) {
-        if p.removed {
-            return;
-        }
-        if let Some(set) = p.set {
-            // A sprite set's index can outlive the reload that rebuilt them.
-            let Some(sprites) = self.set_sprites.get(set as usize) else {
-                return;
-            };
-            let lifetime = p.lifetime.max(1);
-            let index = if p.frame_ticks > 0 {
-                (p.age.max(0) as i64 / i64::from(p.frame_ticks)) % sprites.len() as i64
-            } else {
-                (p.age.max(0) as i64 * (sprites.len() as i64 - 1) / i64::from(lifetime))
-                    .clamp(0, sprites.len() as i64 - 1)
-            };
-            p.sprite = Sprite::Index(sprites[index as usize]);
-        }
+        sprite_from_age_in(&self.set_sprites, p);
    }
    #[allow(clippy::too_many_lines)]
    /// `ParticleProvider.createParticle`: provider draws use the engine's
@@ -3630,13 +3602,14 @@ impl ParticleEngine {
        self.sprite_from_age(&mut q);
        q
    }
-    /// ClientLevel.createFireworks: a Starter (or poofs without explosions).
+    /// ClientLevel.createFireworks: a Starter (or poofs without explosions) with `playSound`.
    pub fn fireworks(
        &mut self,
        at: [f64; 3],
        v: [f64; 3],
        explosions: Vec<FireworkExplosion>,
        camera: [f64; 3],
+        play_sound: bool,
    ) {
        if explosions.is_empty() {
            for _ in 0..self.random.next_int_bound(3).unwrap_or(0) + 2 {
@@ -3660,17 +3633,17 @@ impl ParticleEngine {
            life: 0,
            lifetime,
            twinkle_delay: twinkle,
-            far,
+            sound: play_sound.then_some(far),
        });
    }
    fn tick_starters(&mut self) {
        for mut s in std::mem::take(&mut self.starters) {
-            if s.life == 0 {
+            if s.life == 0 && s.sound.is_some() {
                let large = s.explosions.len() >= 3
                    || s.explosions
                        .iter()
                        .any(|e| e.shape == FireworkShape::LargeBall);
-                let sound = match (large, s.far) {
+                let sound = match (large, s.sound == Some(true)) {
                    (true, true) => "minecraft:entity.firework_rocket.large_blast_far",
                    (true, false) => "minecraft:entity.firework_rocket.large_blast",
                    (false, true) => "minecraft:entity.firework_rocket.blast_far",
@@ -3713,16 +3686,13 @@ impl ParticleEngine {
                    (c & 255) as f32 / 255.0,
                    ((c >> 24) & 255) as f32 / 255.0,
                ];
-                self.create(
-                    &ParticleOptions::colored(ParticleType::Flash, rgba),
-                    s.at,
-                    [0.0; 3],
-                );
+                let flash = ParticleOptions::colored(ParticleType::Flash, rgba);
+                self.create(&flash, s.at, [0.0; 3]);
            }
            s.life += 1;
            if s.life > s.lifetime {
-                if s.twinkle_delay {
-                    let sound = if s.far {
+                if s.twinkle_delay && s.sound.is_some() {
+                    let sound = if s.sound == Some(true) {
                        "minecraft:entity.firework_rocket.twinkle_far"
                    } else {
                        "minecraft:entity.firework_rocket.twinkle"
@@ -3847,9 +3817,7 @@ impl ParticleEngine {
        self.emitters = emitters;
        let mut particles = std::mem::take(&mut self.particles);
        self.spawned_in_tick = Some(Vec::new());
-        for p in &mut particles {
-            self.tick_particle(p, level);
-        }
+        self.tick_all(&mut particles, level);
        particles.retain(|p| !p.removed);
        self.particles = particles;
        for (options, pos, velocity) in self.spawned_in_tick.take().unwrap_or_default() {
@@ -3857,6 +3825,9 @@ impl ParticleEngine {
        }
        let pending = std::mem::take(&mut self.pending);
        for mut p in pending {
+            if p.spawn_check && !polytone::unobstructed(level, p.bb) {
+                continue;
+            }
            if p.pre_tick {
                p.pre_tick = false;
                self.tick_particle(&mut p, level);
@@ -3954,7 +3925,15 @@ impl ParticleEngine {
    #[allow(clippy::too_many_lines)]
    fn tick_particle(&mut self, p: &mut Particle, level: &ParticleLevel) {
        match p.behaviour {
-            Behaviour::Base => p.base_tick(level),
+            Behaviour::Base
+            | Behaviour::Mod { .. }
+            | Behaviour::Animated
+            | Behaviour::Snowflake
+            | Behaviour::Crit
+            | Behaviour::Spark { .. } => {
+                let simple = tick_simple(&self.set_sprites, p, level);
+                self.finish_simple(p, simple);
+            }
            Behaviour::Controlled { .. } => {
                if let Some(mut controller) = p.controller.take() {
                    let update = controller.tick(p, level);
@@ -3973,23 +3952,6 @@ impl ParticleEngine {
                    p.remove();
                }
            }
-            Behaviour::Mod { size, alpha } => {
-                p.base_tick(level);
-                p.size = mod_curve(size, p.age, p.lifetime);
-                p.rgba[3] = mod_curve(alpha, p.age, p.lifetime);
-                self.sprite_from_age(p);
-            }
-            Behaviour::Animated => {
-                p.base_tick(level);
-                self.sprite_from_age(p);
-            }
-            Behaviour::Snowflake => {
-                p.base_tick(level);
-                self.sprite_from_age(p);
-                p.velocity[0] *= f64::from(0.95f32);
-                p.velocity[1] *= f64::from(0.9f32);
-                p.velocity[2] *= f64::from(0.95f32);
-            }
            Behaviour::Lava => {
                p.base_tick(level);
                if !p.removed && p.random.next_float() > p.age as f32 / p.lifetime as f32 {
@@ -4000,11 +3962,6 @@ impl ParticleEngine {
                    );
                }
            }
-            Behaviour::Crit => {
-                p.base_tick(level);
-                p.rgba[1] *= 0.96;
-                p.rgba[2] *= 0.9;
-            }
            Behaviour::Drip {
                fluid,
                stage,
@@ -4475,27 +4432,6 @@ impl ParticleEngine {
                    }
                }
            }
-            Behaviour::Spark {
-                fade,
-                trail,
-                twinkle,
-            } => {
-                p.base_tick(level);
-                self.sprite_from_age(p);
-                if p.age > p.lifetime / 2 {
-                    p.rgba[3] = 1.0 - (p.age as f32 - (p.lifetime / 2) as f32) / p.lifetime as f32;
-                    if let Some(f) = fade {
-                        for i in 0..3 {
-                            p.rgba[i] += (f[i] - p.rgba[i]) * 0.2;
-                        }
-                    }
-                }
-                if trail && p.age < p.lifetime / 2 && (p.age + p.lifetime) % 2 == 0 {
-                    let mut child = self.spark(p.position, [0.0; 3], p.rgba, fade, false, twinkle);
-                    child.age = child.lifetime / 2;
-                    self.pending.push(child);
-                }
-            }
            Behaviour::Spell { original_alpha } => {
                p.base_tick(level);
                self.sprite_from_age(p);
@@ -5100,7 +5036,9 @@ struct Starter {
    life: i32,
    lifetime: i32,
    twinkle_delay: bool,
-    far: bool,
+    /// `FireworkParticles.Starter.playSound`, with `isFarAwayFromCamera` when
+    /// it plays: `None` for a silent rocket.
+    sound: Option<bool>,
 }
 const STAR: [[f64; 2]; 6] = [
    [0.0, 1.0],
@@ -774,7 +774,7 @@ impl Host for Ctx<'_, '_> {
                // `r.noise(x, y)`: one simplex noise (named noises aren't read yet).
                let mut coords = args.iter().filter(|v| !matches!(v, V::Str(_))).map(V::num);
                let (x, y) = (coords.next().unwrap_or(0.0), coords.next().unwrap_or(0.0));
-                num(f64::from(crate::environment::polytone_noise().get2(x, y)))
+                num(crate::environment::polytone_noise().get(x, y))
            }
            (id, _) if id >= BLOCKS => {
                let at = *self
@@ -1090,6 +1090,16 @@ const INITIALIZED: [&str; 13] = [
    "dz",
 ];

+/// Whether no block's collision shape overlaps `bb` (where the query fails, nothing does).
+pub(super) fn unobstructed(level: &ParticleLevel<'_>, bb: horizon_core::geometry::Aabb) -> bool {
+    let mut scene = crate::collisions::SceneCollisions {
+        world: level.world,
+        binding: level.collision,
+        subject: None,
+    };
+    scene.cells_without_collision(bb) || scene.unobstructed(bb).unwrap_or(true)
+}
+
 impl super::ParticleController for Controller {
    fn tick(&mut self, p: &mut Particle, level: &ParticleLevel<'_>) -> ParticleUpdate {
        let mut update = ParticleUpdate::default();
@@ -1320,6 +1330,10 @@ pub(super) fn make(
    particle.polytone_type =
        (def.limit.is_some() || def.exclusion_radius > 0.0).then(|| Arc::from(name));
    particle.bb = super::aabb_at(position, particle.bb_width, particle.bb_height);
+    // A particle with physics whose box starts inside a block's collision never joins the world:
+    // it is not drawn and none of its emitters run (measured on the mod: one spawned just under a
+    // block, where falling leaves start, never shows; one 0.01 clear of it does).
+    particle.spawn_check = def.has_physics;
    particle.controller = Some(Box::new(Controller {
        def: def.clone(),
        registry: registry.clone(),
@@ -1531,6 +1545,31 @@ impl ParticleEngine {
    }
 }

+impl ParticleEngine {
+    /// Sets (or clears) the resource packs' Polytone custom particle types.
+    pub fn set_polytone(&mut self, registry: Option<Arc<Registry>>) {
+        let registry = registry.filter(|r| !r.is_empty());
+        let same = match (&self.polytone, &registry) {
+            (Some(a), Some(b)) => Arc::ptr_eq(a, b),
+            (None, None) => true,
+            _ => false,
+        };
+        if !same {
+            self.polytone_gpu.clear();
+            self.polytone_overrides = registry
+                .iter()
+                .flat_map(|r| {
+                    ParticleType::ALL.iter().filter_map(|&ty| {
+                        let id = format!("minecraft:{}", ty.name());
+                        r.get(&id).is_some().then_some((ty, id))
+                    })
+                })
+                .collect();
+        }
+        self.polytone = registry;
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -2244,6 +2283,144 @@ mod tests {
        std::fs::remove_dir_all(root).unwrap();
    }

+    /// `scene`, with the torch a full block of collision: something a particle's box can start in.
+    fn solid_scene(blocks: &'static BlockRegistry) -> Scene {
+        use horizon_core::geometry::{Axis, VoxelShape};
+        let tag = |shape: VoxelShape| {
+            let sizes = shape.sizes();
+            let occupied = (0..sizes[2])
+                .flat_map(|z| {
+                    (0..sizes[1]).flat_map(move |y| (0..sizes[0]).map(move |x| (x, y, z)))
+                })
+                .map(|(x, y, z)| u8::from(shape.is_full(x as i32, y as i32, z as i32)))
+                .collect();
+            let (min, max) = shape.discrete_bounds();
+            let axes = shape
+                .cube_coordinate_axes()
+                .iter()
+                .enumerate()
+                .fold(0, |mask, (i, on)| mask | (i8::from(*on) << i));
+            let mut fields = vec![
+                ("occupied", Tag::ByteArray(occupied)),
+                ("cube", Tag::Byte(i8::from(shape.is_cube()))),
+                ("cube_axes", Tag::Byte(axes)),
+                ("discrete_min", Tag::IntArray(min.to_vec())),
+                ("discrete_max", Tag::IntArray(max.to_vec())),
+            ];
+            for (axis, name) in [(Axis::X, "x"), (Axis::Y, "y"), (Axis::Z, "z")] {
+                let bits = shape.coordinates(axis).iter().map(|v| v.to_bits() as i64);
+                fields.push((name, Tag::LongArray(bits.collect())));
+            }
+            Tag::compound(fields)
+        };
+        let names = || Tag::List(STATES.iter().map(|s| Tag::String((*s).into())).collect());
+        let cached = CachedCollisionRegistry::from_nbt(
+            &Tag::compound([
+                ("DataVersion", Tag::Int(DATA_VERSION)),
+                ("states", names()),
+                (
+                    "shapes",
+                    Tag::List(vec![tag(VoxelShape::empty()), tag(VoxelShape::block())]),
+                ),
+                ("cached_shapes", Tag::IntArray(vec![0, 1])),
+            ]),
+            blocks,
+        )
+        .unwrap();
+        Scene {
+            collision: BlockCollisionRegistry::new(Arc::new(cached)).unwrap(),
+            ..scene(blocks)
+        }
+    }
+
+    #[test]
+    fn a_particle_with_physics_born_inside_a_block_never_joins() {
+        let blocks = blocks();
+        let leaf = |physics| {
+            serde_json::json!({"has_physics": physics, "render_type": "invisible",
+                "initializer": {"lifetime": "20", "hitbox_size": "0.08"},
+                "particle_emitters": [{"particle": "test:mark", "chance": "1"}]})
+        };
+        let root = pack(&[
+            (
+                "assets/test/polytone/custom_particles/leaf.json",
+                leaf(true),
+            ),
+            (
+                "assets/test/polytone/custom_particles/ghost.json",
+                leaf(false),
+            ),
+            (
+                "assets/test/polytone/custom_particles/mark.json",
+                serde_json::json!({"render_type": "invisible", "has_physics": false}),
+            ),
+            (
+                "assets/minecraft/polytone/entity_modifiers/player.json",
+                serde_json::json!({"emitters": [{"particle": "test:leaf", "chance": "1"}]}),
+            ),
+            (
+                "assets/test/polytone/custom_particles/wide.json",
+                serde_json::json!({"has_physics": true, "render_type": "invisible",
+                    "initializer": {"lifetime": "20", "hitbox_size": 10},
+                    "particle_emitters": [{"particle": "test:mark", "chance": "1"}]}),
+            ),
+            (
+                "assets/test/polytone/custom_particles/parent.json",
+                serde_json::json!({"has_physics": true, "render_type": "invisible",
+                    "initializer": {"lifetime": "20", "hitbox_size": "0.08"},
+                    "particle_emitters": [{"particle": "test:wide", "chance": "1", "y": "-0.05"}]}),
+            ),
+            (
+                "assets/minecraft/polytone/entity_modifiers/skeleton.json",
+                serde_json::json!({"emitters": [{"particle": "test:parent", "chance": "1", "x": "-4.5"}]}),
+            ),
+            (
+                "assets/minecraft/polytone/entity_modifiers/creeper.json",
+                serde_json::json!({"emitters": [{"particle": "test:wide", "chance": "1", "x": "-4.5"}]}),
+            ),
+            (
+                "assets/minecraft/polytone/entity_modifiers/zombie.json",
+                serde_json::json!({"emitters": [{"particle": "test:ghost", "chance": "1"}]}),
+            ),
+        ]);
+        let scene = solid_scene(blocks);
+        let level = ParticleLevel {
+            world: &scene.world,
+            facts: &scene.facts,
+            collision: &scene.collision,
+            player: None,
+            cached_chunk: std::cell::Cell::new(None),
+        };
+        let mut engine = engine(Registry::read(&root, Default::default(), blocks));
+        // The solid block is at (1, 64, 1): its bottom face is y 64.
+        // Spawns one particle, lets the engine take it in and tick it: whether it joined, and
+        // how many particles it emitted.
+        let mut spawn = |entity: &str, y: f64| {
+            engine.particles.clear();
+            engine.pending.clear();
+            engine.polytone_entity(&level, entity, [1.5, y, 1.5]);
+            engine.tick(&level);
+            let joined = engine.particles.len();
+            engine.tick(&level);
+            (
+                joined,
+                engine.particles.len() + engine.pending.len() - joined,
+            )
+        };
+        // The solid block is at (1, 64, 1): its bottom face is y 64.
+        // 0.05 under the block, a 0.08 box reaches into it: it never joins, nothing emitted.
+        assert_eq!(spawn("minecraft:player", 63.95), (0, 0));
+        // 0.01 clear of it, it joins and emits.
+        assert_eq!(spawn("minecraft:player", 63.91), (1, 1));
+        // Without physics nothing collides.
+        assert_eq!(spawn("minecraft:zombie", 63.95), (1, 1));
+        // A wide box reaching a block from five blocks away does not join either.
+        assert_eq!(spawn("minecraft:creeper", 60.0), (0, 0));
+        // Nor does one a clear particle emits there: the small one joins, its wide copy never.
+        assert_eq!(spawn("minecraft:skeleton", 60.0), (1, 0));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
    #[test]
    fn a_pack_custom_particle_replaces_the_vanilla_type_of_its_id() {
        let root = pack(&[(
@@ -0,0 +1,161 @@
+//! The particles that tick on their own (`tick_simple`): the behaviours that read and write only
+//! their own particle, the world and the sprite sets, which `ParticleEngine::tick_all` runs on several
+//! threads in a busy scene.
+use super::{Behaviour, Particle, ParticleEngine, ParticleLevel, Sprite, mod_curve};
+
+/// The live particles it takes before `tick_all` uses more than one thread: a scoped thread costs
+/// tens of microseconds to start and join, and a simple particle about a tenth of one.
+pub(super) const PARALLEL_MIN: usize = 2048;
+/// Threads for ticking particles: half the machine's workers, at most four (the chunk workers and
+/// the render thread need cores too); `HORIZON_WORKER_THREADS` caps them as it does every pool.
+pub(super) fn parallel_threads() -> usize {
+    (horizon_threads::worker_count() / 2).clamp(1, 4)
+}
+pub(super) fn sprite_from_age_in(set_sprites: &[Vec<u32>], p: &mut Particle) {
+    if p.removed {
+        return;
+    }
+    if let Some(set) = p.set {
+        // A sprite set's index can outlive the reload that rebuilt them.
+        let Some(sprites) = set_sprites.get(set as usize) else {
+            return;
+        };
+        let lifetime = p.lifetime.max(1);
+        let index = if p.frame_ticks > 0 {
+            (p.age.max(0) as i64 / i64::from(p.frame_ticks)) % sprites.len() as i64
+        } else {
+            (p.age.max(0) as i64 * (sprites.len() as i64 - 1) / i64::from(lifetime))
+                .clamp(0, sprites.len() as i64 - 1)
+        };
+        p.sprite = Sprite::Index(sprites[index as usize]);
+    }
+}
+/// The tick of the behaviours that read and write only their own particle, the world and the engine's
+/// sprite sets: no particle spawned, no sound, nothing drawn from the engine's random. Those are the
+/// bulk of a busy scene (flames, smoke, poofs, dust, crits), and `ParticleEngine::tick` runs them on
+/// several threads. Any other behaviour is left alone, for `ParticleEngine::tick_particle`.
+pub(super) fn tick_simple(
+    set_sprites: &[Vec<u32>],
+    p: &mut Particle,
+    level: &ParticleLevel,
+) -> Simple {
+    match p.behaviour {
+        Behaviour::Base => p.base_tick(level),
+        Behaviour::Mod { size, alpha } => {
+            p.base_tick(level);
+            p.size = mod_curve(size, p.age, p.lifetime);
+            p.rgba[3] = mod_curve(alpha, p.age, p.lifetime);
+            sprite_from_age_in(set_sprites, p);
+        }
+        Behaviour::Animated => {
+            p.base_tick(level);
+            sprite_from_age_in(set_sprites, p);
+        }
+        Behaviour::Snowflake => {
+            p.base_tick(level);
+            sprite_from_age_in(set_sprites, p);
+            p.velocity[0] *= f64::from(0.95f32);
+            p.velocity[1] *= f64::from(0.9f32);
+            p.velocity[2] *= f64::from(0.95f32);
+        }
+        Behaviour::Crit => {
+            p.base_tick(level);
+            p.rgba[1] *= 0.96;
+            p.rgba[2] *= 0.9;
+        }
+        Behaviour::Spark { fade, trail, .. } => {
+            p.base_tick(level);
+            sprite_from_age_in(set_sprites, p);
+            if p.age > p.lifetime / 2 {
+                p.rgba[3] = 1.0 - (p.age as f32 - (p.lifetime / 2) as f32) / p.lifetime as f32;
+                if let Some(f) = fade {
+                    for i in 0..3 {
+                        p.rgba[i] += (f[i] - p.rgba[i]) * 0.2;
+                    }
+                }
+            }
+            if trail && p.age < p.lifetime / 2 && (p.age + p.lifetime) % 2 == 0 {
+                return Simple::SparkTrail;
+            }
+        }
+        _ => return Simple::No,
+    }
+    Simple::Done
+}
+/// The same world with a one-chunk lookup cache of its own, for a worker thread.
+///
+/// `ParticleLevel::cached_chunk` is a `Cell`, which a level shared between threads may not hold:
+/// each thread gets a view with an empty cache, built here on the engine thread and moved in. A
+/// cache they shared could not hold "the last chunk looked up" for any one of them in any case.
+fn thread_view<'a>(level: &ParticleLevel<'a>) -> ParticleLevel<'a> {
+    ParticleLevel {
+        world: level.world,
+        facts: level.facts,
+        collision: level.collision,
+        player: level.player,
+        cached_chunk: std::cell::Cell::new(None),
+    }
+}
+/// What `tick_simple` did with a particle.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum Simple {
+    /// Not one of its behaviours: the engine ticks it.
+    No,
+    /// Ticked completely.
+    Done,
+    /// Ticked, except that a firework spark's trail wants a child. Only the engine can make one:
+    /// it takes the next seed, so the children come in the order the sparks have.
+    SparkTrail,
+}
+impl ParticleEngine {
+    /// What `tick_simple` leaves to the engine: a spark's trail child.
+    pub(super) fn finish_simple(&mut self, p: &Particle, simple: Simple) {
+        if simple != Simple::SparkTrail {
+            return;
+        }
+        if let Behaviour::Spark { fade, twinkle, .. } = p.behaviour {
+            let mut child = self.spark(p.position, [0.0; 3], p.rgba, fade, false, twinkle);
+            child.age = child.lifetime / 2;
+            self.pending.push(child);
+        }
+    }
+    /// One tick of every live particle. The ones `tick_simple` covers are independent of each
+    /// other and of the engine, so with enough of them they tick on several threads; every other
+    /// one then ticks here, in the order it had, so the particles, the engine's random and what
+    /// is spawned come out as when all of them ticked one after another.
+    pub(super) fn tick_all(&mut self, particles: &mut [Particle], level: &ParticleLevel) {
+        if particles.is_empty() || particles.len() < self.parallel_min || self.parallel_threads < 2
+        {
+            for p in particles {
+                self.tick_particle(p, level);
+            }
+            return;
+        }
+        let sets = &self.set_sprites;
+        let per = particles.len().div_ceil(self.parallel_threads);
+        let mut handled = vec![Simple::No; particles.len()];
+        std::thread::scope(|scope| {
+            let run = |part: &mut [Particle], done: &mut [Simple], level: &ParticleLevel| {
+                for (p, done) in part.iter_mut().zip(done) {
+                    *done = tick_simple(sets, p, level);
+                }
+            };
+            let mut parts = particles.chunks_mut(per).zip(handled.chunks_mut(per));
+            let own = parts.next();
+            for (part, done) in parts {
+                let view = thread_view(level);
+                scope.spawn(move || run(part, done, &view));
+            }
+            // This thread takes the first share, instead of waiting for the others.
+            if let Some((part, done)) = own {
+                run(part, done, level);
+            }
+        });
+        for (p, done) in particles.iter_mut().zip(handled) {
+            match done {
+                Simple::No => self.tick_particle(p, level),
+                simple => self.finish_simple(p, simple),
+            }
+        }
+    }
+}
@@ -1,8 +1,12 @@
-//! The particle stress scene's load on `ParticleEngine`, outside the game: `cargo test --profile fast
-//! -p horizon-client-render --lib particle_tick_cost -- --ignored --nocapture` (prepared resources;
-//! `PARTICLE_BENCH_SECS` sets the run, default 5). It spawns what tools/stress_scenes.py's `particles`
-//! scene makes each tick (flames, cosy smoke, end rods, TNT debris) over its stone floor and times the
-//! spawns and the engine tick apart, once the engine holds as many particles as it will.
+//! The particle stress scene's load on `ParticleEngine`, outside the game.
+//!
+//! - `parallel_tick_matches_serial_tick`: the engine ticking on several threads (`tick_all`) leaves
+//!   every particle, the engine's random and its sounds exactly as ticking them one after another.
+//! - `particle_tick_cost` (`cargo test --profile fast -p horizon-client-render --lib
+//!   particle_tick_cost -- --ignored --nocapture`, prepared resources; `PARTICLE_BENCH_SECS` sets
+//!   the run, default 2): spawns what tools/stress_scenes.py's `particles` scene makes each tick
+//!   (flames, cosy smoke, end rods, TNT debris, rockets) over its stone floor and times the spawns
+//!   and the engine tick apart, once the engine holds as many particles as it will.
 use super::*;
 use crate::{blocks::BlockFacts, chunk::Chunk, collisions, world::World};
 use std::sync::Arc;
@@ -25,6 +29,7 @@ impl Lcg {
    }
 }

+/// What to spawn each tick: a type, how many, around where, how far, how fast.
 type Emitter = (ParticleType, usize, [f64; 3], [f64; 3], f64);

 fn spawn_tick(engine: &mut ParticleEngine, rng: &mut Lcg, types: &[Emitter], rockets: usize) {
@@ -38,7 +43,7 @@ fn spawn_tick(engine: &mut ParticleEngine, rng: &mut Lcg, types: &[Emitter], roc
            twinkle: false,
        };
        let at = [-5.5 + rng.next() * 12.0, f64::from(FLOOR_Y + 20), 20.5];
-        engine.fireworks(at, [0.0, 0.1, 0.0], vec![explosion], engine.camera);
+        engine.fireworks(at, [0.0, 0.1, 0.0], vec![explosion], engine.camera, true);
    }
    for &(ty, count, center, delta, speed) in types {
        let options = ParticleOptions::simple(ty);
@@ -58,9 +63,29 @@ fn spawn_tick(engine: &mut ParticleEngine, rng: &mut Lcg, types: &[Emitter], roc
    }
 }

-#[test]
-#[ignore = "a measurement, not a check"]
-fn particle_tick_cost() {
+/// The scene's emitters, per tick: flames, cosy smoke, end rods, and TNT's debris (poof and smoke).
+fn emitters() -> [Emitter; 5] {
+    let ty = |name: &str| ParticleType::from_name(name).unwrap();
+    let (fx, fy, fz) = (0.5, f64::from(FLOOR_Y + 5), 20.5);
+    let tnt = [0.5, f64::from(FLOOR_Y + 24), 26.5];
+    [
+        (ty("flame"), 320, [fx, fy, fz], [8.0, 4.0, 8.0], 0.01),
+        (
+            ty("campfire_cosy_smoke"),
+            8,
+            [fx, fy, fz],
+            [8.0, 4.0, 8.0],
+            0.0,
+        ),
+        (ty("end_rod"), 80, [fx, fy, fz], [8.0, 4.0, 8.0], 0.05),
+        (ty("poof"), 258, tnt, [3.0, 3.0, 3.0], 0.4),
+        (ty("smoke"), 238, tnt, [3.0, 3.0, 3.0], 0.4),
+    ]
+}
+
+/// Runs `f` over the stress scene's world (a stone floor at y 289 under the particles). Skipped
+/// without prepared resources.
+fn with_scene(f: impl FnOnce(&ParticleLevel)) {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("../../.local/horizon-client")
        .join(horizon_core::VANILLA_VERSION);
@@ -88,69 +113,127 @@ fn particle_tick_cost() {
            world.set(x, FLOOR_Y, z, floor).unwrap();
        }
    }
-    let level = ParticleLevel {
+    f(&ParticleLevel {
        world: &world,
        facts: &facts,
        collision: &collision,
        player: None,
        cached_chunk: std::cell::Cell::new(None),
-    };
-    let ty = |name: &str| ParticleType::from_name(name).unwrap();
-    let (fx, fy, fz) = (0.5, f64::from(FLOOR_Y + 5), 20.5);
-    let tnt = [0.5, f64::from(FLOOR_Y + 24), 26.5];
-    // The scene's emitters, per tick, and TNT's debris (poof and smoke).
-    let flame: Emitter = (ty("flame"), 320, [fx, fy, fz], [8.0, 4.0, 8.0], 0.01);
-    let cosy: Emitter = (
-        ty("campfire_cosy_smoke"),
-        8,
-        [fx, fy, fz],
-        [8.0, 4.0, 8.0],
-        0.0,
+    });
+}
+
+fn engine(parallel_min: usize, threads: usize) -> ParticleEngine {
+    let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
+    engine.camera = [0.5, 298.0, 0.5];
+    engine.parallel_min = parallel_min;
+    engine.parallel_threads = threads;
+    engine
+}
+
+/// Every live particle's fields, as text.
+fn state(engine: &ParticleEngine) -> Vec<String> {
+    engine
+        .particles
+        .iter()
+        .map(|p| format!("{:?}", engine.snapshot(p)))
+        .collect()
+}
+
+#[test]
+fn parallel_tick_matches_serial_tick() {
+    with_scene(|level| {
+        let types = emitters();
+        // One engine ticks every particle in turn; the other on three threads. Same seeds, same spawns.
+        let mut serial = engine(usize::MAX, 1);
+        let mut threaded = engine(0, 3);
+        for e in [&mut serial, &mut threaded] {
+            e.seed_randoms(7, 8, 9);
+        }
+        let (mut a, mut b) = (Lcg(99), Lcg(99));
+        for tick in 0..90 {
+            spawn_tick(&mut serial, &mut a, &types, 3);
+            spawn_tick(&mut threaded, &mut b, &types, 3);
+            serial.tick(level);
+            threaded.tick(level);
+            assert_eq!(serial.len(), threaded.len(), "tick {tick}");
+            if tick % 10 == 9 {
+                assert_eq!(state(&serial), state(&threaded), "tick {tick}");
+            }
+        }
+        assert!(serial.len() > 1000, "{} particles", serial.len());
+        assert_eq!(serial.sounds.len(), threaded.sounds.len());
+        assert_eq!(serial.next_randoms(), threaded.next_randoms());
+    });
+}
+
+/// Spawns and ticks `types` once the engine is full, for `secs`, and prints the cost per tick.
+fn measure(
+    level: &ParticleLevel,
+    name: &str,
+    (types, rockets): (&[Emitter], usize),
+    (parallel_min, threads): (usize, usize),
+    secs: f64,
+) {
+    let mut engine = engine(parallel_min, threads);
+    let mut rng = Lcg(1234);
+    for _ in 0..600 {
+        spawn_tick(&mut engine, &mut rng, types, rockets);
+        engine.tick(level);
+    }
+    let (mut spawn, mut tick, mut ticks, mut alive) =
+        (Duration::ZERO, Duration::ZERO, 0u64, 0usize);
+    let end = Instant::now() + Duration::from_secs_f64(secs);
+    while Instant::now() < end {
+        let t = Instant::now();
+        spawn_tick(&mut engine, &mut rng, types, rockets);
+        spawn += t.elapsed();
+        let t = Instant::now();
+        engine.tick(level);
+        tick += t.elapsed();
+        alive += engine.len();
+        ticks += 1;
+    }
+    let per = |d: Duration| d.as_secs_f64() * 1000.0 / ticks as f64;
+    let alive = alive / ticks as usize;
+    eprintln!(
+        "{name:24} alive {alive:6} | per tick: spawn {:6.3} ms, engine tick {:6.3} ms | {:5.0} ns per particle",
+        per(spawn),
+        per(tick),
+        per(tick) * 1.0e6 / alive.max(1) as f64
    );
-    let rod: Emitter = (ty("end_rod"), 80, [fx, fy, fz], [8.0, 4.0, 8.0], 0.05);
-    let poof: Emitter = (ty("poof"), 258, tnt, [3.0, 3.0, 3.0], 0.4);
-    let smoke: Emitter = (ty("smoke"), 238, tnt, [3.0, 3.0, 3.0], 0.4);
-    let cases: [(&str, Vec<Emitter>, usize); 7] = [
-        ("flame 320/tick", vec![flame], 0),
-        ("cosy smoke 8/tick", vec![cosy], 0),
-        ("end rod 80/tick", vec![rod], 0),
-        ("poof 258/tick", vec![poof], 0),
-        ("smoke 238/tick", vec![smoke], 0),
-        ("3 rockets/tick", vec![], 3),
-        ("the whole scene", vec![flame, cosy, rod, poof, smoke], 3),
-    ];
-    let secs: f64 = std::env::var("PARTICLE_BENCH_SECS")
-        .ok()
-        .and_then(|s| s.parse().ok())
-        .unwrap_or(2.0);
-    for (name, types, rockets) in cases {
-        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
-        engine.camera = [0.5, 298.0, 0.5];
-        let mut rng = Lcg(1234);
-        for _ in 0..600 {
-            spawn_tick(&mut engine, &mut rng, &types, rockets);
-            engine.tick(&level);
+}
+
+#[test]
+#[ignore = "a measurement, not a check"]
+fn particle_tick_cost() {
+    with_scene(|level| {
+        let [flame, cosy, rod, poof, smoke] = emitters();
+        let all = [flame, cosy, rod, poof, smoke];
+        let secs: f64 = std::env::var("PARTICLE_BENCH_SECS")
+            .ok()
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(2.0);
+        let one = (usize::MAX, 1);
+        eprintln!("default threads: {}", parallel_threads());
+        for (name, types, rockets) in [
+            ("flame 320/tick", vec![flame], 0),
+            ("cosy smoke 8/tick", vec![cosy], 0),
+            ("end rod 80/tick", vec![rod], 0),
+            ("poof 258/tick", vec![poof], 0),
+            ("smoke 238/tick", vec![smoke], 0),
+            ("3 rockets/tick", vec![], 3),
+        ] {
+            measure(level, name, (&types, rockets), one, secs);
        }
-        let (mut spawn, mut tick, mut ticks, mut alive) =
-            (Duration::ZERO, Duration::ZERO, 0u64, 0usize);
-        let end = Instant::now() + Duration::from_secs_f64(secs);
-        while Instant::now() < end {
-            let t = Instant::now();
-            spawn_tick(&mut engine, &mut rng, &types, rockets);
-            spawn += t.elapsed();
-            let t = Instant::now();
-            engine.tick(&level);
-            tick += t.elapsed();
-            alive += engine.len();
-            ticks += 1;
+        measure(level, "whole scene, 1 thread", (&all, 3), one, secs);
+        for threads in [2, 3, 4, 6] {
+            measure(
+                level,
+                &format!("whole scene, {threads} threads"),
+                (&all, 3),
+                (PARALLEL_MIN, threads),
+                secs,
+            );
        }
-        let per = |d: Duration| d.as_secs_f64() * 1000.0 / ticks as f64;
-        let alive = alive / ticks as usize;
-        eprintln!(
-            "{name:20} alive {alive:6} | per tick: spawn {:6.3} ms, engine tick {:6.3} ms | {:5.0} ns per particle",
-            per(spawn),
-            per(tick),
-            per(tick) * 1.0e6 / alive.max(1) as f64
-        );
-    }
+    });
 }
@@ -7,13 +7,16 @@ use horizon_core::{
    geometry::{Vec3, traverse_blocks},
    position::BlockPos,
 };
+use horizon_world::collision_context::CollisionContext;

 /// `PotentSulfurBlock.ALLOWED_WATER_BLOCKS_ABOVE`.
 const ALLOWED_WATER_BLOCKS_ABOVE: i32 = 4;

 /// `PotentSulfurBlockEntity.isGeyserPassableBlock`: air, water, or a block
-/// with no collision shape.
-pub fn is_geyser_passable_block(level: &ParticleLevel, pos: [i32; 3]) -> bool {
+/// with no collision shape for `CollisionContext.positionContext(context_y)`.
+/// Vanilla passes the height of the block under the column it reads, so
+/// scaffolding seen from below lets the gas and the geyser through.
+pub fn is_geyser_passable_block(level: &ParticleLevel, pos: [i32; 3], context_y: i32) -> bool {
    let state = level.world.block(pos[0], pos[1], pos[2]);
    if level.facts.is_air(state) || &*level.facts.get(state).name == "minecraft:water" {
        return true;
@@ -23,7 +26,9 @@ pub fn is_geyser_passable_block(level: &ParticleLevel, pos: [i32; 3]) -> bool {
        binding: level.collision,
        subject: None,
    };
-    match level.collision.collision_shape(&mut scene, state, pos) {
+    let context = CollisionContext::position(f64::from(context_y));
+    let position = BlockPos::new(pos[0], pos[1], pos[2]);
+    match (level.collision).collision_shape_with_context(&mut scene, state, position, &context) {
        Ok(shape) => shape.is_empty(),
        Err(_) => !level.facts.get(state).full_collision,
    }
@@ -46,9 +51,9 @@ pub fn find_noxious_gas_source_block(level: &ParticleLevel, origin: [i32; 3]) ->
        let state = level.world.block(pos[0], pos[1], pos[2]);
        let is_water_block = &*level.facts.get(state).name == "minecraft:water";
        if !is_water_source(level, pos)
-            || (!is_water_block && !is_geyser_passable_block(level, pos))
+            || (!is_water_block && !is_geyser_passable_block(level, pos, origin[1]))
        {
-            if level.facts.is_air(state) || is_geyser_passable_block(level, pos) {
+            if level.facts.is_air(state) || is_geyser_passable_block(level, pos, origin[1]) {
                return Some(pos);
            }
            break;
@@ -63,7 +68,7 @@ pub fn find_noxious_gas_source_block(level: &ParticleLevel, origin: [i32; 3]) ->
 pub fn unobstructed_block_count(level: &ParticleLevel, pos: [i32; 3], water_blocks: i32) -> i32 {
    let geyser_force_height = 6 * water_blocks;
    for i in 0..geyser_force_height {
-        if !is_geyser_passable_block(level, [pos[0], pos[1] + i, pos[2]]) {
+        if !is_geyser_passable_block(level, [pos[0], pos[1] + i, pos[2]], pos[1] - 1) {
            return i;
        }
    }
@@ -79,7 +84,7 @@ pub fn can_be_reached_by_noxious_gas(
    pos: [f64; 3],
 ) -> bool {
    let block = ParticleLevel::block_at(pos);
-    if !is_geyser_passable_block(level, block) {
+    if !is_geyser_passable_block(level, block, block[1] - 1) {
        return false;
    }
    let center = source_block.map(|c| f64::from(c) + 0.5);
@@ -277,6 +277,14 @@ pub fn take_text_input_area() -> Option<[f32; 4]> {
 mod tests {
    use super::*;

+    /// The tests that change [`STATE`] take turns: it is one for the whole process, and
+    /// cargo runs tests in parallel, so one test's `reset` or `should_suppress_key` could
+    /// land in the middle of another (#14577).
+    static STATE_TESTS: Mutex<()> = Mutex::new(());
+    fn one_at_a_time() -> std::sync::MutexGuard<'static, ()> {
+        STATE_TESTS.lock().unwrap_or_else(|e| e.into_inner())
+    }
+
    #[test]
    fn empty_text_is_no_composition() {
        assert_eq!(PreeditEvent::from_sdl_text_editing(None, 0, 0), None);
@@ -352,6 +360,7 @@ mod tests {

    #[test]
    fn set_and_clear_preedit() {
+        let _turn = one_at_a_time();
        reset();
        set_preedit(PreeditEvent::from_winit("nihongo", Some((0, 7))));
        assert!(composing());
@@ -362,6 +371,7 @@ mod tests {

    #[test]
    fn empty_preedit_clears_composing_and_suppresses_trailing_enter_once() {
+        let _turn = one_at_a_time();
        reset();
        set_preedit(PreeditEvent::from_winit("こんにちは", Some((0, 15))));
        assert!(composing());
@@ -385,6 +395,7 @@ mod tests {

    #[test]
    fn mark_committed_suppresses_single_trailing_key() {
+        let _turn = one_at_a_time();
        reset();
        set_preedit(PreeditEvent::from_winit("漢字", Some((0, 6))));
        mark_committed();
@@ -0,0 +1,844 @@
+//! The radial menu's pages in the controller settings (Horizon's own; `radial.rs` has their
+//! rules, `radial_overlay.rs` draws them in play), on the settings shell (`settings_shell`): a
+//! sheet per page with its eight slots, what changes the page, and what changes them all. A
+//! page's own name is typed on a small page of its own, [`NameEntry`].
+use crate::{
+    gamepad::{self, GlyphOf, MenuJob},
+    graphics_style::{self as style, BUTTON_H},
+    hud::{HudAtlas, HudBatch},
+    lang,
+    options_ui::{Event, Page},
+    pad_glyph::{Glyph, Glyphs},
+    radial::{self, Pages, RadialAction, SLOTS, Slot},
+    radial_overlay::{page_label, slot_caption},
+    settings::Settings,
+    settings_shell::{
+        self as shell, Binding, Capture, Group, Output, Reset, Row, Screen, Sheet, Shown, Value,
+    },
+    text::Text,
+    ui,
+};
+
+const TITLE: &str = "horizon.pages.controller_radial";
+const SLOTS_GROUP: &str = "horizon.radial.group.slots";
+const PAGE_GROUP: &str = "horizon.radial.group.page";
+const ALL_GROUP: &str = "horizon.radial.group.all";
+/// The opener's row binds the menu's own pad action, in place.
+const OPENER: &str = gamepad::RADIAL;
+
+/// A row of a page; `usize`s are the page and the slot.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum RadialRow {
+    Slot(usize, usize),
+    Rename(usize),
+    NewPage,
+    Delete(usize),
+    Reset,
+    Opener,
+}
+
+/// A slot's action, that it holds none, or that its action is missing.
+fn slot_label(slot: &Slot) -> String {
+    slot_caption(slot).unwrap_or_else(|| lang::get("horizon.radial.empty"))
+}
+
+/// What the slot after `slot` (before, `back`) holds: Empty between the last action and the first.
+/// A missing action steps as Empty does.
+fn step(slot: &Slot, back: bool) -> Slot {
+    let order: Vec<_> = std::iter::once(None)
+        .chain(RadialAction::ALL.map(Some))
+        .collect();
+    let at = order
+        .iter()
+        .position(|entry| *entry == slot.action())
+        .unwrap_or(0);
+    let next = if back { at + order.len() - 1 } else { at + 1 };
+    order[next % order.len()].into()
+}
+
+fn page_of(page: usize, pages: usize) -> String {
+    lang::tr("horizon.radial.page_of", &[&(page + 1), &pages])
+}
+
+/// The opener's row: a binding of the menu's own pad action, in place, on its button's art. Its
+/// strip says what stands in the way (no button, or one another action shares); while it waits,
+/// the shell says how to bind it.
+fn opener_row(s: &Settings, glyphs: Glyphs) -> Row<RadialRow> {
+    let pad = &s.controller;
+    // Through the player's glyphs, so a Nintendo pad going by its letters names its own button.
+    let glyph = Glyph::of(GlyphOf::Bound(OPENER), pad, glyphs);
+    let warning = match pad.binding(OPENER) {
+        None => Some(lang::get("horizon.radial.unbound")),
+        Some(_) => pad
+            .conflicts(OPENER)
+            .then(|| lang::get("horizon.radial.conflict")),
+    };
+    let binding = Binding {
+        capture: Capture::Pad(OPENER),
+        shown: Shown::Pad {
+            glyph,
+            cancel: Glyph::menu(MenuJob::Start, glyphs),
+        },
+        shared: Vec::new(),
+        // The default (D-pad Right) is refused with some sticks: no reset, only a new button.
+        reset: Reset::None,
+    };
+    let name = lang::get("horizon.radial.opener");
+    Row {
+        chosen: warning,
+        ..Row::new(RadialRow::Opener, name, Value::Binding(binding))
+            .about(lang::get(opener_about(pad.radial_stick)))
+    }
+}
+
+/// What the opener's row says it can be, with the stick that selects: never under that thumb.
+fn opener_about(stick: gamepad::RadialStick) -> &'static str {
+    match stick {
+        gamepad::RadialStick::Right => "horizon.radial.opener.about",
+        gamepad::RadialStick::Left => "horizon.radial.opener.about.left",
+        gamepad::RadialStick::Either => "horizon.radial.opener.about.either",
+    }
+}
+
+/// The page's rows: its slots, then what changes it.
+fn page_groups(pages: &Pages, page: usize) -> [Group<RadialRow>; 2] {
+    let slots = (0..SLOTS).map(|slot| {
+        let name = lang::get(&format!("horizon.radial.slot.{slot}"));
+        let cell = pages.page(page).slot(slot);
+        let value = Value::Choice(slot_label(cell));
+        let missing = match cell {
+            Slot::Missing(id) => Some(lang::tr("horizon.radial.missing.about", &[id])),
+            _ => None,
+        };
+        Row {
+            chosen: missing,
+            ..Row::new(RadialRow::Slot(page, slot), name, value)
+                .about(lang::get("horizon.radial.slot.about"))
+        }
+    });
+    let full = (pages.len() >= radial::MAX_PAGES)
+        .then(|| lang::tr("horizon.radial.new_page.full", &[&radial::MAX_PAGES]));
+    let last = (pages.len() <= 1).then(|| lang::get("horizon.radial.delete_page.last"));
+    let changes = vec![
+        Row::new(
+            RadialRow::Rename(page),
+            lang::get("horizon.radial.rename"),
+            Value::Press,
+        )
+        .about(lang::get("horizon.radial.rename.about")),
+        Row::new(
+            RadialRow::NewPage,
+            lang::get(radial::NEW_PAGE_NAME),
+            Value::Press,
+        )
+        .about(lang::get("horizon.radial.new_page.about"))
+        .blocked(full),
+        Row::new(
+            RadialRow::Delete(page),
+            lang::get("horizon.radial.delete_page"),
+            Value::Press,
+        )
+        .about(lang::get("horizon.radial.delete_page.about"))
+        .blocked(last),
+    ];
+    [
+        Group {
+            name: SLOTS_GROUP,
+            rows: slots.collect(),
+        },
+        Group {
+            name: PAGE_GROUP,
+            rows: changes,
+        },
+    ]
+}
+
+/// The screen's own state; the pages are the player's settings.
+#[derive(Default)]
+pub(crate) struct RadialScreen {
+    /// The buttons' names follow the controller in use: the options screen says which.
+    pub(crate) glyphs: Glyphs,
+    /// The page to show next: one just added, or where a deleted one was.
+    show: Option<usize>,
+    /// The page whose name is being typed, on its own page (`Page::ControllerRadialName`).
+    pub(crate) naming: Option<NameEntry>,
+    /// The slot (page, slot) whose list of actions opens next (`Page::ControllerRadialPick`).
+    pub(crate) picking: Option<(usize, usize)>,
+}
+
+impl RadialScreen {
+    /// The page the shell should show now, once.
+    pub(crate) fn take_shown(&mut self) -> Option<usize> {
+        self.show.take()
+    }
+}
+
+impl Screen for RadialScreen {
+    type Page = usize;
+    type Row = RadialRow;
+    fn title(&self) -> &'static str {
+        TITLE
+    }
+    /// The rows read the pages, the opener's button, the stick that selects and the glyphs it is
+    /// named with.
+    fn stamp(&self, s: &Settings) -> u64 {
+        let pad = &s.controller;
+        let opener = (pad.binding(OPENER), pad.conflicts(OPENER));
+        shell::stamp_of(&(&pad.radial, opener, pad.radial_stick, self.glyphs))
+    }
+    fn sheets(&self, s: &Settings) -> Vec<Sheet<usize, RadialRow>> {
+        let pages = &s.controller.radial;
+        let default = *pages == Pages::default();
+        let all = Group {
+            name: ALL_GROUP,
+            rows: vec![
+                Row::new(
+                    RadialRow::Reset,
+                    lang::get("horizon.radial.reset"),
+                    Value::Press,
+                )
+                .about(lang::get("horizon.radial.reset.about"))
+                .blocked(default.then(|| lang::get("horizon.radial.reset.default"))),
+                opener_row(s, self.glyphs),
+            ],
+        };
+        (0..pages.len())
+            .map(|page| {
+                let [slots, changes] = page_groups(pages, page);
+                let all = Group {
+                    name: all.name,
+                    rows: all.rows.clone(),
+                };
+                Sheet::new(
+                    page,
+                    page_label(pages.page(page)),
+                    page_of(page, pages.len()),
+                    vec![slots, changes, all],
+                )
+            })
+            .collect()
+    }
+    fn press(&mut self, s: &mut Settings, row: RadialRow, back: bool) -> Vec<Output> {
+        let pages = &mut s.controller.radial;
+        match row {
+            RadialRow::Slot(page, slot) => {
+                let next = step(pages.page(page).slot(slot), back);
+                pages.set_slot(page, slot, next);
+            }
+            RadialRow::Rename(page) => {
+                self.naming = Some(NameEntry::new(page, &page_label(pages.page(page))));
+                return vec![Output::Push(Page::ControllerRadialName)];
+            }
+            RadialRow::NewPage => self.show = pages.add(),
+            RadialRow::Delete(page) => {
+                pages.remove(page);
+                self.show = Some(pages.clamp(page));
+            }
+            RadialRow::Reset => {
+                *pages = Pages::default();
+                self.show = Some(0);
+            }
+            // The shell starts its wait (`gamepad::opener_refused` refused, Start cancels).
+            RadialRow::Opener => return Vec::new(),
+        }
+        vec![Output::Event(Event::Changed)]
+    }
+    /// A press on a slot opens the list of every action for it; Left and Right still step it.
+    fn choose(&mut self, _s: &mut Settings, row: RadialRow) -> Option<Vec<Output>> {
+        let RadialRow::Slot(page, slot) = row else {
+            return None;
+        };
+        self.picking = Some((page, slot));
+        Some(vec![Output::Push(Page::ControllerRadialPick)])
+    }
+    /// The wheel over a slot steps it, as a press does.
+    fn wheel_step(&mut self, s: &mut Settings, row: RadialRow, back: bool) -> Option<Vec<Output>> {
+        matches!(row, RadialRow::Slot(..)).then(|| self.press(s, row, back))
+    }
+    /// Undo is how a delete or a reset is taken back: they act at once.
+    fn undoes(&self) -> bool {
+        true
+    }
+    /// The pages, and the opener's button, which its row binds.
+    fn undo(&mut self, s: &mut Settings, before: &Settings) -> Vec<Output> {
+        s.controller.radial = before.controller.radial.clone();
+        s.controller.bind(OPENER, before.controller.binding(OPENER));
+        Vec::new()
+    }
+}
+
+const PICK_TITLE: &str = "horizon.radial.pick_title";
+const PICK_GROUP: &str = "horizon.radial.group.actions";
+
+/// A row of a slot's list: the line naming the slot, then Empty and every action.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum PickRow {
+    Slot,
+    Pick(Option<RadialAction>),
+}
+
+/// One slot's list of every action and Empty, on the settings shell: it names the slot, marks
+/// what the slot holds and opens on it; a press puts that in the slot and goes back.
+#[derive(Default)]
+pub(crate) struct PickScreen {
+    /// The page and the slot.
+    at: (usize, usize),
+    picked: bool,
+}
+
+impl PickScreen {
+    /// For `at`; the row the focus opens on, what the slot holds.
+    pub(crate) fn open_on(&mut self, at: (usize, usize), pages: &Pages) -> PickRow {
+        *self = Self { at, picked: false };
+        self.current(pages).unwrap_or(PickRow::Pick(None))
+    }
+    /// The page and the slot it is for.
+    pub(crate) fn at(&self) -> (usize, usize) {
+        self.at
+    }
+    /// A pick changed the pages since the last call, which the editor's Undo takes back.
+    pub(crate) fn take_picked(&mut self) -> bool {
+        std::mem::take(&mut self.picked)
+    }
+    /// The row of what the slot holds; none for an action this game doesn't know.
+    fn current(&self, pages: &Pages) -> Option<PickRow> {
+        match pages.page(self.at.0).slot(self.at.1) {
+            Slot::Empty => Some(PickRow::Pick(None)),
+            Slot::Action(action) => Some(PickRow::Pick(Some(*action))),
+            Slot::Missing(_) => None,
+        }
+    }
+}
+
+impl Screen for PickScreen {
+    type Page = ();
+    type Row = PickRow;
+    fn title(&self) -> &'static str {
+        PICK_TITLE
+    }
+    fn stamp(&self, s: &Settings) -> u64 {
+        let (page, slot) = self.at;
+        shell::stamp_of(&(self.at, s.controller.radial.page(page).slot(slot)))
+    }
+    fn sheets(&self, s: &Settings) -> Vec<Sheet<(), PickRow>> {
+        let pages = &s.controller.radial;
+        let (page, slot) = self.at;
+        let direction = lang::get(&format!("horizon.radial.slot.{slot}"));
+        let named = lang::tr(
+            "horizon.radial.pick.slot",
+            &[&direction, &page_label(pages.page(page))],
+        );
+        let current = self.current(pages);
+        let about = lang::get("horizon.radial.pick.about");
+        let mut rows =
+            vec![Row::new(PickRow::Slot, named.clone(), Value::Note).about(about.clone())];
+        for action in std::iter::once(None).chain(RadialAction::ALL.map(Some)) {
+            let id = PickRow::Pick(action);
+            let value = if current == Some(id) {
+                Value::Choice(lang::get("horizon.radial.pick.current"))
+            } else {
+                Value::Press
+            };
+            let name = slot_label(&action.into());
+            rows.push(Row::new(id, name, value).about(about.clone()));
+        }
+        vec![Sheet::new(
+            (),
+            named,
+            about,
+            vec![Group {
+                name: PICK_GROUP,
+                rows,
+            }],
+        )]
+    }
+    fn press(&mut self, s: &mut Settings, row: PickRow, _back: bool) -> Vec<Output> {
+        let PickRow::Pick(action) = row else {
+            return Vec::new();
+        };
+        let (page, slot) = self.at;
+        s.controller.radial.set_slot(page, slot, action.into());
+        self.picked = true;
+        vec![Output::Event(Event::Changed), Output::Done]
+    }
+}
+
+/// The name field and its buttons, centred in the screen but under the title, one row apart.
+const NAME_W: f32 = 200.0;
+const NAME_BLOCK_H: f32 = 100.0;
+const NAME_TOP_MIN: f32 = 30.0;
+const NAME_STEP: f32 = 25.0;
+
+/// What a press on the name's page did.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Named {
+    Nothing,
+    /// Done: the page takes the name.
+    Done,
+    /// Cancel, keeping the old name.
+    Back,
+}
+
+/// A page's name being typed.
+pub(crate) struct NameEntry {
+    page: usize,
+    field: ui::EditBox,
+}
+
+impl NameEntry {
+    fn new(page: usize, name: &str) -> Self {
+        let mut field = ui::EditBox::new(0.0, 0.0, NAME_W, BUTTON_H);
+        field.max_length = radial::NAME_MAX;
+        field.set_value(name);
+        field.focused = true;
+        Self { page, field }
+    }
+
+    /// Done and Cancel, under the field.
+    fn buttons(w: f32, h: f32) -> [([f32; 4], Named); 2] {
+        let (x, top) = ((w / 2.0).floor() - NAME_W / 2.0, name_top(h));
+        let at = |row: f32| [x, top + row * NAME_STEP, NAME_W, BUTTON_H];
+        [(at(1.0), Named::Done), (at(2.0), Named::Back)]
+    }
+
+    pub(crate) fn draw(
+        &mut self,
+        batch: &mut HudBatch,
+        atlas: &HudAtlas,
+        cursor: (f32, f32),
+        in_world: bool,
+    ) {
+        let (w, h) = (batch.width.ceil(), batch.height.ceil());
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, in_world);
+        let title = Text::literal(lang::get("horizon.radial.name_title"));
+        style::title(batch, atlas, &title);
+        let field = &mut self.field;
+        let (x, top) = ((w / 2.0).floor() - NAME_W / 2.0, name_top(h));
+        (field.x, field.y, field.width, field.height) = (x, top, NAME_W, BUTTON_H);
+        field.draw(batch, atlas, None);
+        for ([x, y, bw, bh], named) in Self::buttons(w, h) {
+            let (label, action) = match named {
+                Named::Done => ("gui.done", crate::widgets::Action::Done),
+                _ => ("gui.cancel", crate::widgets::Action::Cancel),
+            };
+            let hover = ui::hovered(cursor, x, y, bw, bh);
+            let text = Text::literal(lang::get(label));
+            ui::action_button(batch, atlas, action, x, y, bw, bh, &text, true, hover);
+        }
+    }
+
+    /// A press at `(x, y)` on a screen `w` x `h`.
+    pub(crate) fn click(
+        &mut self,
+        atlas: &HudAtlas,
+        (x, y): (f32, f32),
+        (w, h): (f32, f32),
+    ) -> Named {
+        let hit = Self::buttons(w, h)
+            .into_iter()
+            .find(|([bx, by, bw, bh], _)| ui::hovered((x, y), *bx, *by, *bw, *bh));
+        if let Some((_, named)) = hit {
+            return named;
+        }
+        let field = &mut self.field;
+        field.focused = ui::hovered((x, y), field.x, field.y, field.width, field.height);
+        if field.focused {
+            field.click(atlas, x, false, false);
+        }
+        Named::Nothing
+    }
+
+    /// The name field takes the keys.
+    pub(crate) fn typing(&self) -> bool {
+        self.field.focused
+    }
+
+    pub(crate) fn type_text(&mut self, text: &str) {
+        if self.field.focused {
+            self.field.insert_text(text);
+        }
+    }
+
+    /// A key: Enter is Done, Escape is Cancel, the rest the field's.
+    pub(crate) fn key(&mut self, key: winit::keyboard::KeyCode, text: Option<&str>) -> Named {
+        use winit::keyboard::KeyCode as K;
+        match key {
+            K::Escape => return Named::Back,
+            K::Enter | K::NumpadEnter => return Named::Done,
+            _ if self.field.focused => {
+                if !self.field.key(key, false, false)
+                    && let Some(t) = text
+                {
+                    let typed: String = t.chars().filter(|c| !c.is_control()).collect();
+                    self.field.insert_text(&typed);
+                }
+            }
+            _ => {}
+        }
+        Named::Nothing
+    }
+
+    /// Ctrl+A/C/V/X in the name field; false when it hasn't the focus.
+    pub(crate) fn shortcut(
+        &mut self,
+        shortcut: crate::clipboard::EditShortcut,
+        clipboard: &mut dyn crate::clipboard::Clipboard,
+    ) -> bool {
+        if self.field.focused {
+            self.field.shortcut(shortcut, clipboard);
+        }
+        self.field.focused
+    }
+
+    /// The name into the pages. Left as it was, a default page keeps following the language.
+    pub(crate) fn apply(&self, pages: &mut Pages) -> bool {
+        let changed = self.field.value != page_label(pages.page(self.page));
+        if changed {
+            pages.rename(self.page, &self.field.value);
+        }
+        changed
+    }
+}
+
+/// The name field's top.
+fn name_top(h: f32) -> f32 {
+    ((h - NAME_BLOCK_H) / 2.0).floor().max(NAME_TOP_MIN)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::gamepad::Button as PadButton;
+    use crate::radial::PageName;
+    use crate::settings_shell::{Hosted, Shell};
+    use winit::keyboard::KeyCode as K;
+
+    const SIZE: (f32, f32) = (854.0, 480.0);
+
+    fn rows_of(s: &Settings, page: usize) -> Vec<Row<RadialRow>> {
+        let sheets = RadialScreen::default().sheets(s);
+        let groups = sheets.into_iter().nth(page).unwrap().groups;
+        groups.into_iter().flat_map(|group| group.rows).collect()
+    }
+    fn row(s: &Settings, id: RadialRow) -> Row<RadialRow> {
+        let page = match id {
+            RadialRow::Slot(page, _) | RadialRow::Rename(page) | RadialRow::Delete(page) => page,
+            _ => 0,
+        };
+        rows_of(s, page).into_iter().find(|r| r.id == id).unwrap()
+    }
+    /// A click on `id` through the shell, as the mouse or a controller's A gives it.
+    fn click(shell: &mut Shell<RadialScreen>, s: &mut Settings, id: RadialRow) -> Vec<Output> {
+        let at = shell.point_at(s, SIZE, id);
+        shell.click(s, at, SIZE, false, false, false)
+    }
+
+    /// Undo, at the foot over Done.
+    fn undo(shell: &mut Shell<RadialScreen>, s: &mut Settings) {
+        let [x, y, ..] = shell::Columns::of(SIZE.0, SIZE.1).button(1);
+        shell.click(s, (x + 2.0, y + 2.0), SIZE, false, false, false);
+    }
+
+    #[test]
+    fn a_slot_steps_through_empty_and_every_action_both_ways() {
+        let mut seen = vec![Slot::Empty];
+        let mut slot = Slot::Empty;
+        for _ in RadialAction::ALL {
+            slot = step(&slot, false);
+            seen.push(slot.clone());
+        }
+        assert_eq!(step(&slot, false), Slot::Empty, "the last wraps to Empty");
+        let actions: Vec<_> = seen.iter().filter_map(Slot::action).collect();
+        assert_eq!(actions, RadialAction::ALL.to_vec());
+        assert_eq!(
+            step(&Slot::Empty, true).action(),
+            RadialAction::ALL.last().copied()
+        );
+        let chat = Slot::Action(RadialAction::Chat);
+        assert_eq!(step(&step(&chat, true), false), chat);
+        // A missing action steps on as Empty would.
+        let missing = Slot::Missing("mymod:dash".to_owned());
+        assert_eq!(step(&missing, false), step(&Slot::Empty, false));
+    }
+
+    #[test]
+    fn a_press_on_a_slot_opens_its_list_and_left_and_right_still_step_it() {
+        let mut s = Settings::default();
+        let mut shell = Shell::<RadialScreen>::default();
+        let before = s.controller.radial.clone();
+        let outputs = click(&mut shell, &mut s, RadialRow::Slot(0, 2));
+        assert!(outputs.contains(&Output::Push(Page::ControllerRadialPick)));
+        assert_eq!(shell.screen.picking, Some((0, 2)));
+        assert_eq!(
+            s.controller.radial, before,
+            "the press itself changes nothing"
+        );
+        // Right on the focused row steps it.
+        shell.set_focus(Some(shell::Target::Row(RadialRow::Slot(0, 2))));
+        shell.key(&mut s, K::ArrowRight, None, false, SIZE);
+        let stepped = step(before.page(0).slot(2), false);
+        assert_eq!(*s.controller.radial.page(0).slot(2), stepped);
+    }
+
+    #[test]
+    fn the_list_names_the_slot_marks_its_action_and_a_pick_fills_it() {
+        let mut s = Settings::default();
+        let mut picker = PickScreen::default();
+        // General's right slot holds Commands.
+        let opens_on = picker.open_on((0, 2), &s.controller.radial);
+        assert_eq!(opens_on, PickRow::Pick(Some(RadialAction::Command)));
+        let rows: Vec<_> = picker
+            .sheets(&s)
+            .into_iter()
+            .flat_map(|sheet| sheet.groups)
+            .flat_map(|group| group.rows)
+            .collect();
+        assert_eq!(rows[0].id, PickRow::Slot);
+        assert_eq!(rows[0].value, Value::Note);
+        // Empty, then every action, each once; only the slot's own marked.
+        let picks: Vec<_> = rows[1..].iter().map(|row| row.id).collect();
+        let every: Vec<_> = std::iter::once(None)
+            .chain(RadialAction::ALL.map(Some))
+            .map(PickRow::Pick)
+            .collect();
+        assert_eq!(picks, every);
+        let marked: Vec<_> = rows
+            .iter()
+            .filter(|row| matches!(row.value, Value::Choice(_)))
+            .map(|row| row.id)
+            .collect();
+        assert_eq!(marked, [opens_on]);
+        let outputs = picker.press(&mut s, PickRow::Pick(Some(RadialAction::Chat)), false);
+        assert_eq!(outputs, [Output::Event(Event::Changed), Output::Done]);
+        assert_eq!(
+            *s.controller.radial.page(0).slot(2),
+            Slot::Action(RadialAction::Chat)
+        );
+        assert!(picker.take_picked() && !picker.take_picked());
+        // Empty empties it.
+        picker.press(&mut s, PickRow::Pick(None), false);
+        assert!(s.controller.radial.page(0).slot(2).is_empty());
+    }
+
+    #[test]
+    fn a_missing_action_says_which_it_is() {
+        let mut s = Settings::default();
+        s.controller
+            .radial
+            .set_slot(0, 1, Slot::Missing("mymod:dash".to_owned()));
+        let english = lang::Language::load(&[], "en_us");
+        let (chosen, _) = lang::scoped(english, || row(&s, RadialRow::Slot(0, 1)).chosen);
+        assert!(chosen.is_some_and(|text| text.contains("mymod:dash")));
+    }
+
+    #[test]
+    fn a_slot_changes_alone_and_undo_puts_back_what_the_screen_found() {
+        let mut s = Settings::default();
+        let mut shell = Shell::<RadialScreen>::default();
+        let before = s.controller.radial.page(0).clone();
+        shell.set_focus(Some(shell::Target::Row(RadialRow::Slot(0, 0))));
+        let outputs = shell.key(&mut s, K::ArrowRight, None, false, SIZE);
+        assert!(outputs.contains(&Output::Event(Event::Changed)));
+        let after = s.controller.radial.page(0);
+        assert_eq!(*after.slot(0), step(before.slot(0), false));
+        assert_eq!(after.slots()[1..], before.slots()[1..]);
+        assert!(shell.changed());
+        undo(&mut shell, &mut s);
+        assert_eq!(s.controller.radial, Pages::default());
+        assert!(!shell.changed());
+    }
+
+    #[test]
+    fn delete_and_reset_act_at_once_and_undo_takes_them_back() {
+        let mut s = Settings::default();
+        s.controller.radial.rename(1, "Mine");
+        let found = s.controller.radial.clone();
+        let mut shell = Shell::<RadialScreen>::default();
+        click(&mut shell, &mut s, RadialRow::Delete(0));
+        assert_eq!(s.controller.radial.len(), 1);
+        assert_eq!(page_label(s.controller.radial.page(0)), "Mine");
+        // One page left: it can't go, and the strip says why.
+        let delete = row(&s, RadialRow::Delete(0));
+        assert!(!delete.live && delete.why.is_some());
+        let reset = row(&s, RadialRow::Reset);
+        assert!(reset.live);
+        shell.screen.take_shown();
+        click(&mut shell, &mut s, RadialRow::Reset);
+        assert_eq!(s.controller.radial, Pages::default());
+        assert!(!row(&s, RadialRow::Reset).live, "already the defaults");
+        assert_eq!(shell.screen.take_shown(), Some(0));
+        undo(&mut shell, &mut s);
+        assert_eq!(s.controller.radial, found);
+    }
+
+    #[test]
+    fn new_pages_stop_at_the_most_and_the_new_one_shows() {
+        let mut s = Settings::default();
+        let mut screen = RadialScreen::default();
+        while row(&s, RadialRow::NewPage).live {
+            screen.press(&mut s, RadialRow::NewPage, false);
+            assert_eq!(screen.take_shown(), Some(s.controller.radial.len() - 1));
+        }
+        assert_eq!(s.controller.radial.len(), radial::MAX_PAGES);
+        assert!(row(&s, RadialRow::NewPage).why.is_some());
+        // Every page is a sheet, named as the overlay names it.
+        let sheets = screen.sheets(&s);
+        assert_eq!(sheets.len(), radial::MAX_PAGES);
+        assert_eq!(sheets[0].name, page_label(s.controller.radial.page(0)));
+    }
+
+    #[test]
+    fn a_deleted_last_page_leaves_the_one_before_it_showing() {
+        let mut s = Settings::default();
+        let mut screen = RadialScreen::default();
+        screen.press(&mut s, RadialRow::Delete(1), false);
+        assert_eq!(screen.take_shown(), Some(0));
+    }
+
+    #[test]
+    fn rename_opens_the_name_page_and_only_done_with_a_new_name_renames() {
+        let general = Pages::default().page(0).name.clone();
+        let mut s = Settings::default();
+        let mut screen = RadialScreen::default();
+        let outputs = screen.press(&mut s, RadialRow::Rename(0), false);
+        assert_eq!(outputs, vec![Output::Push(Page::ControllerRadialName)]);
+        let entry = screen.naming.as_mut().unwrap();
+        // Done with the name as it was: a default page keeps following the language.
+        assert_eq!(entry.key(K::Enter, None), Named::Done);
+        assert!(!entry.apply(&mut s.controller.radial));
+        assert_eq!(s.controller.radial.page(0).name, general);
+        entry.type_text("!");
+        assert_eq!(entry.key(K::Escape, None), Named::Back);
+        entry.field.set_value("Mine");
+        entry.type_text("!");
+        assert!(entry.apply(&mut s.controller.radial));
+        assert_eq!(
+            s.controller.radial.page(0).name,
+            PageName::Custom("Mine!".to_owned())
+        );
+    }
+
+    #[test]
+    fn undo_puts_back_a_name_given_on_the_name_page() {
+        let mut s = Settings::default();
+        s.controller.radial.rename(1, "Mine");
+        let mut shell = Shell::<RadialScreen>::default();
+        shell.show(1);
+        click(&mut shell, &mut s, RadialRow::Rename(1));
+        let entry = shell.screen.naming.as_mut().unwrap();
+        entry.field.set_value("Building");
+        // As the options screen does on Done: the name page changed what Undo puts back.
+        let entry = shell.screen.naming.take().unwrap();
+        assert!(entry.apply(&mut s.controller.radial));
+        shell.changed_elsewhere();
+        assert_eq!(page_label(s.controller.radial.page(1)), "Building");
+        assert!(shell.changed());
+        undo(&mut shell, &mut s);
+        assert_eq!(page_label(s.controller.radial.page(1)), "Mine");
+        assert!(!shell.changed());
+    }
+
+    #[test]
+    fn a_nintendo_pad_going_by_its_letters_names_its_own_opener() {
+        let mut s = Settings::default();
+        // Selecting with the left stick, the top face button (North) can open it.
+        s.controller.radial_stick = gamepad::RadialStick::Left;
+        s.controller.bind(OPENER, Some(gamepad::Button::North));
+        s.controller.glyphs = gamepad::GlyphStyle::Nintendo;
+        let label = |s: &Settings| {
+            let glyphs = Glyphs::of(&s.controller, gamepad::GlyphStyle::Nintendo);
+            match opener_row(s, glyphs).value {
+                Value::Binding(Binding {
+                    shown: Shown::Pad { glyph, .. },
+                    ..
+                }) => glyph.expect("bound").label().to_owned(),
+                other => panic!("{other:?}"),
+            }
+        };
+        // By places, the top button: printed X on a Nintendo pad.
+        s.controller.nintendo_letters = false;
+        assert_eq!(label(&s), "X");
+        // By letters, the part is played by the button printed Y (on the left).
+        s.controller.nintendo_letters = true;
+        assert_eq!(label(&s), "Y");
+    }
+
+    #[test]
+    fn the_opener_row_names_its_button_and_says_what_gets_in_the_way() {
+        let mut s = Settings::default();
+        let glyphs = Glyphs::of(&s.controller, gamepad::GlyphStyle::Xbox);
+        let shown = |s: &Settings| match opener_row(s, glyphs).value {
+            Value::Binding(Binding {
+                capture,
+                shown: Shown::Pad { glyph, .. },
+                ..
+            }) => {
+                assert_eq!(capture, Capture::Pad(OPENER));
+                glyph
+            }
+            other => panic!("{other:?}"),
+        };
+        let bound = s.controller.binding(OPENER).unwrap();
+        // The button on its glyph.
+        let glyph = shown(&s).expect("the opener's glyph");
+        assert_eq!(glyph.part(), bound);
+        assert_eq!(glyph.label(), "→");
+        assert_eq!(opener_row(&s, glyphs).chosen, None);
+        s.controller.bind("key.chat", Some(bound));
+        let shared = opener_row(&s, glyphs).chosen;
+        assert!(shared.is_some(), "a shared button");
+        s.controller.bind(OPENER, None);
+        let unbound = opener_row(&s, glyphs).chosen;
+        assert!(unbound.is_some() && unbound != shared && shown(&s).is_none());
+        // A press waits for a button on the row, and Undo takes a new one back.
+        let mut shell = Shell::<RadialScreen>::default();
+        s.controller.bind(OPENER, Some(bound));
+        let outputs = click(&mut shell, &mut s, RadialRow::Opener);
+        assert!(outputs.contains(&Output::Bind(Capture::Pad(OPENER))));
+        assert!(shell.changed());
+        s.controller.bind(OPENER, Some(PadButton::North));
+        undo(&mut shell, &mut s);
+        assert_eq!(s.controller.binding(OPENER), Some(bound));
+    }
+
+    #[test]
+    fn every_string_has_a_horizon_key() {
+        let atlas =
+            HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap();
+        let english = lang::Language::load(&[], "en_us");
+        let ((), missed) = lang::scoped(english, || {
+            let mut s = Settings::default();
+            s.controller.bind("key.chat", Some(PadButton::DPadRight));
+            let mut shell = Shell::<RadialScreen>::default();
+            let draw = |shell: &mut Shell<RadialScreen>, s: &Settings| {
+                let mut batch = HudBatch::new([854, 480]);
+                shell.draw(s, &mut batch, &atlas, (0.0, 0.0), false, None);
+            };
+            // Every page's rows are built, with what the strip says of each.
+            draw(&mut shell, &s);
+            s.controller.bind(OPENER, None);
+            s.controller.radial.remove(1);
+            while s.controller.radial.add().is_some() {}
+            draw(&mut shell, &s);
+            s.controller.radial = Pages::default();
+            s.controller.radial.remove(1);
+            draw(&mut shell, &s);
+            let mut batch = HudBatch::new([854, 480]);
+            let waiting = Some(Capture::Pad(OPENER));
+            shell.draw(&s, &mut batch, &atlas, (0.0, 0.0), false, waiting);
+            let mut entry = NameEntry::new(0, "Mine");
+            let mut batch = HudBatch::new([854, 480]);
+            entry.draw(&mut batch, &atlas, (0.0, 0.0), false);
+            let mut picker = Shell::<PickScreen>::default();
+            picker.screen.open_on((0, 1), &s.controller.radial);
+            let mut batch = HudBatch::new([854, 480]);
+            picker.draw(&s, &mut batch, &atlas, (0.0, 0.0), false, None);
+        });
+        // Vanilla's own (gui.done...) come from the game's resources, not bundled ones.
+        let missed: Vec<_> = missed
+            .iter()
+            .filter(|key| key.starts_with("horizon.") || !key.contains('.'))
+            .collect();
+        assert!(missed.is_empty(), "no text for {missed:?}");
+    }
+}
@@ -232,6 +232,8 @@ impl Selector {
 pub struct Tick {
    /// A vibration was chosen: its travel time (the particle starts).
    pub started: Option<(Info, i32)>,
+    /// A vibration was reloaded from save: particle resumes from interpolated pos.
+    pub resumed: Option<(Info, i32)>,
    /// A vibration arrived.
    pub received: Option<Info>,
    /// `onDataChanged`.
@@ -261,6 +263,10 @@ impl Data {
            self.selector.start_over();
        }
        if let Some(info) = self.current {
+            if self.reload_particle {
+                self.reload_particle = false;
+                out.resumed = Some((info, self.travel));
+            }
            let mut changed = self.travel > 0;
            self.travel = (self.travel - 1).max(0);
            if self.travel <= 0 {
@@ -293,8 +299,11 @@ impl Data {
        Tag::compound(entries)
    }
    pub fn from_nbt(tag: &Tag) -> Self {
+        let current = tag.get("event").and_then(info_from_nbt);
+        let reload_particle = current.is_some();
        let mut data = Self {
-            current: tag.get("event").and_then(info_from_nbt),
+            current,
+            reload_particle,
            ..Self::default()
        };
        if let Some(Tag::Int(t)) = tag.get("event_delay") {
@@ -979,4 +988,30 @@ mod tests {
        assert_eq!(back.spreader.cursors[0].charge, 1000);
        assert_eq!(back.spreader.cursors[1].charge, 500);
    }
+
+    #[test]
+    fn vibration_reloads_particle() {
+        let tag = Tag::compound([
+            (
+                "event",
+                Tag::compound([
+                    ("game_event", Tag::String("minecraft:step".into())),
+                    ("distance", Tag::Float(4.0f32.to_bits())),
+                    (
+                        "pos",
+                        Tag::List(vec![
+                            Tag::Double(1.0f64.to_bits()),
+                            Tag::Double(0),
+                            Tag::Double(0),
+                        ]),
+                    ),
+                ]),
+            ),
+            ("event_delay", Tag::Int(3)),
+        ]);
+        let mut d = Data::from_nbt(&tag);
+        assert!(d.reload_particle && d.current.is_some());
+        let tick = d.tick(10, true, true, |dist| dist as i32);
+        assert!(tick.resumed.is_some() && !d.reload_particle);
+    }
 }
@@ -203,6 +203,9 @@ pub struct Settings {
    pub startup_api: crate::graphics::GraphicsApi,
    /// `Monitor.videoModes` of the window's monitor, for the Video page (set by the game).
    pub video_modes: Vec<crate::window::VideoMode>,
+    /// Fullbright is held off: this window plays on another's server (set by the game, not
+    /// saved). The graphics screen hides its row; `extras.fullbright` keeps the choice.
+    pub fullbright_held: bool,
    /// Controller settings (`horizon-controller.txt`, Horizon's own).
    pub controller: crate::gamepad::PadSettings,
    /// Horizon's optional extras (`horizon-extras.txt`), all off by default.
@@ -293,6 +296,7 @@ impl Default for Settings {
            horizon: Default::default(),
            startup_api: Default::default(),
            video_modes: Vec::new(),
+            fullbright_held: false,
            controller: Default::default(),
            extras: Default::default(),
            mods: Default::default(),
@@ -514,6 +518,7 @@ impl Settings {
            horizon: Default::default(),
            startup_api: Default::default(),
            video_modes: Vec::new(),
+            fullbright_held: false,
            controller: Default::default(),
            extras: Default::default(),
            mods: Default::default(),
@@ -869,6 +874,10 @@ pub enum Opt {
    PadNintendoButtons,
    PadKeyboard,
    PadGameplayGuide,
+    /// The radial menu's opener held or pressed once (`PadSettings::radial_mode`).
+    PadRadialMode,
+    /// The stick the radial menu selects with (`PadSettings::radial_stick`).
+    PadRadialStick,
    /// `options.modelPart.*`: one skin layer (index into `options_file::MODEL_PARTS`).
    ModelPart(usize),
    /// A slider of a page a crate registered (`horizon_hooks::pages`): (page, row).
@@ -0,0 +1,815 @@
+use super::*;
+use crate::options_ui::Event;
+use winit::keyboard::KeyCode as K;
+
+const SIZE: (f32, f32) = (854.0, 480.0);
+const SHORT: (f32, f32) = (480.0, 240.0);
+const CHANGED: Output = Output::Event(Event::Changed);
+
+/// A screen with what Extras doesn't have: two pages, a slider, a value with descriptions of
+/// its own, and a row a wheel steps.
+#[derive(Default)]
+struct Probe {
+    slider: f32,
+    choice: usize,
+    pressed: Vec<(u32, bool)>,
+    /// How many times its rows were built.
+    built: std::cell::Cell<usize>,
+}
+const CHOICES: [(&str, &str); 2] = [("Red", "Paints it red."), ("Blue", "Paints it blue.")];
+const SLIDER: u32 = 0;
+const CHOICE: u32 = 1;
+const FIRST_FILLER: u32 = 10;
+const FILLERS: u32 = 40;
+const GREY: u32 = 100;
+const WHY: &str = "Not here.";
+impl Screen for Probe {
+    type Page = u8;
+    type Row = u32;
+    fn title(&self) -> &'static str {
+        "Probe"
+    }
+    /// Its rows read the field of view, besides its own state.
+    fn stamp(&self, s: &Settings) -> u64 {
+        stamp_of(&s.fov)
+    }
+    fn sheets(&self, s: &Settings) -> Vec<Sheet<u8, u32>> {
+        self.built.set(self.built.get() + 1);
+        let (value, chosen) = CHOICES[self.choice];
+        let mut rows = vec![
+            Row::new(
+                SLIDER,
+                "Level".to_owned(),
+                Value::Slider {
+                    position: self.slider,
+                    steps: Some(10),
+                    text: s.fov.to_string(),
+                },
+            ),
+            Row {
+                chosen: Some(chosen.to_owned()),
+                ..Row::new(CHOICE, "Paint".to_owned(), Value::Choice(value.to_owned()))
+                    .about("Picks a colour.".to_owned())
+            },
+            Row::new(GREY, "Greyed".to_owned(), Value::Press)
+                .about("Does a thing.".to_owned())
+                .blocked(Some(WHY.to_owned())),
+        ];
+        rows.extend((0..FILLERS).map(|i| {
+            Row::new(FIRST_FILLER + i, format!("Filler {i}"), Value::Press)
+                .about("Does nothing.".to_owned())
+        }));
+        let elsewhere = vec![Row::new(99, "Elsewhere".to_owned(), Value::Press)];
+        vec![
+            Sheet::new(
+                0,
+                "One".to_owned(),
+                "The first.".to_owned(),
+                vec![Group { name: "G", rows }],
+            ),
+            Sheet::new(
+                1,
+                "Two".to_owned(),
+                "The second.".to_owned(),
+                vec![Group {
+                    name: "H",
+                    rows: elsewhere,
+                }],
+            ),
+        ]
+    }
+    fn press(&mut self, s: &mut Settings, row: u32, back: bool) -> Vec<Output> {
+        self.pressed.push((row, back));
+        match row {
+            CHOICE => self.choice = (self.choice + 1) % CHOICES.len(),
+            FIRST_FILLER => s.fov += 1.0,
+            _ => {}
+        }
+        vec![CHANGED]
+    }
+    fn undoes(&self) -> bool {
+        true
+    }
+    fn undo(&mut self, s: &mut Settings, before: &Settings) -> Vec<Output> {
+        s.fov = before.fov;
+        Vec::new()
+    }
+    fn slide(&mut self, _: &mut Settings, _: u32, position: f32) {
+        self.slider = position;
+    }
+    fn wheel_step(&mut self, _: &mut Settings, row: u32, _: bool) -> Option<Vec<Output>> {
+        (row == CHOICE).then(|| {
+            self.choice = (self.choice + 1) % CHOICES.len();
+            vec![CHANGED]
+        })
+    }
+}
+
+fn middle_of(shell: &mut Shell<Probe>, row: u32, size: (f32, f32)) -> (f32, f32) {
+    shell.point_at(&Settings::default(), size, row)
+}
+
+fn atlas() -> HudAtlas {
+    HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
+}
+
+/// What one frame asks of a screen: a draw, then the stick's scroll, an arrow key and the wheel
+/// away from any row, at the size it was drawn at.
+fn frame(shell: &mut Shell<Probe>, s: &mut Settings, atlas: &HudAtlas) -> (f32, f32) {
+    let mut batch = HudBatch::new([1708, 960]);
+    shell.draw(s, &mut batch, atlas, (0.0, 0.0), false, None);
+    let size = (batch.width, batch.height);
+    shell.scroll(s, size, -1.0);
+    shell.key(s, K::ArrowDown, None, false, size);
+    shell.wheel(s, size, (0.0, 0.0), 1.0);
+    size
+}
+
+#[test]
+fn rows_are_built_once_and_again_only_when_what_they_read_changes() {
+    let atlas = atlas();
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let built = |shell: &Shell<Probe>| shell.screen.built.get();
+    let reads = |shell: &mut Shell<Probe>, s: &Settings, size, end: &str| {
+        let view = shell.view(s, size);
+        let mut labels = view.rows.iter().map(|r| r.label(r.value_text().as_deref()));
+        labels.any(|label| label.ends_with(end))
+    };
+    // Each of the four built them before: now the first frame builds them once, the next none.
+    let size = frame(&mut shell, &mut s, &atlas);
+    assert_eq!(built(&shell), 1);
+    frame(&mut shell, &mut s, &atlas);
+    assert_eq!(built(&shell), 1);
+    // A press changes the screen's own state: its row reads the new value.
+    let at = middle_of(&mut shell, CHOICE, size);
+    shell.click(&mut s, at, size, false, false, false);
+    assert!(reads(&mut shell, &s, size, "Blue"));
+    // A setting changed elsewhere (a key bound, a command) shows on the next frame.
+    s.fov = 90.0;
+    frame(&mut shell, &mut s, &atlas);
+    assert!(reads(&mut shell, &s, size, "90"));
+    let before = built(&shell);
+    frame(&mut shell, &mut s, &atlas);
+    assert_eq!(built(&shell), before);
+    // Searching, and another size, build them again.
+    shell.type_text("filler");
+    shell.view(&s, size);
+    assert_eq!(built(&shell), before + 1);
+    shell.view(&s, SHORT);
+    assert_eq!(built(&shell), before + 2);
+    // So does another language, and coming back from it.
+    lang::scoped(lang::Language::load(&[], "de_de"), || shell.view(&s, SHORT));
+    assert_eq!(built(&shell), before + 3);
+    shell.view(&s, SHORT);
+    assert_eq!(built(&shell), before + 4);
+}
+
+#[test]
+fn a_row_the_list_hides_part_of_scrolls_into_view_when_focused_and_then_takes_a_press() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let cols = Columns::of(SHORT.0, SHORT.1);
+    // A filler far down, scrolled to just over the bottom: its middle is under the list's edge.
+    let cut = FIRST_FILLER + 20;
+    let view = shell.view(&s, SHORT);
+    let (_, y) = shell.placed(&view).find(|(r, _)| r.id == cut).unwrap();
+    shell.scroll.amount = y - cols.bottom + style::ROW / 2.0 - 1.0;
+    let rect = cols.row(y - shell.scroll.amount);
+    assert!(
+        rect[1] + rect[3] / 2.0 >= cols.bottom,
+        "the row's middle is hidden"
+    );
+    let moved = Hosted::reveal(&mut shell, &s, SHORT, rect).unwrap();
+    let shown = [rect[0], rect[1] + moved, rect[2], rect[3]];
+    assert!(moved < 0.0 && shown[1] + shown[3] <= cols.bottom);
+    // All in view, it stays put.
+    assert_eq!(Hosted::reveal(&mut shell, &s, SHORT, shown), None);
+    let middle = (shown[0] + 4.0, shown[1] + shown[3] / 2.0);
+    assert_eq!(
+        shell.click(&mut s, middle, SHORT, false, false, false),
+        vec![CLICK, CHANGED]
+    );
+    assert_eq!(shell.screen.pressed, [(cut, false)]);
+}
+
+#[test]
+fn undo_appears_after_a_change_and_puts_back_what_the_screen_opened_with() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let undo = Columns::of(SIZE.0, SIZE.1).button(1);
+    let on_undo = (undo[0] + 2.0, undo[1] + 2.0);
+    // Nothing changed: there is no Undo to press.
+    assert!(
+        shell
+            .click(&mut s, on_undo, SIZE, false, false, false)
+            .is_empty()
+    );
+    let at = middle_of(&mut shell, FIRST_FILLER, SIZE);
+    shell.click(&mut s, at, SIZE, false, false, false);
+    assert_eq!(s.fov, 71.0);
+    // Another option changed meanwhile isn't the screen's to put back.
+    s.chat_opacity = 0.25;
+    assert_eq!(
+        shell.click(&mut s, on_undo, SIZE, false, false, false),
+        vec![CLICK, CHANGED]
+    );
+    assert_eq!((s.fov, s.chat_opacity), (70.0, 0.25));
+    assert!(
+        shell
+            .click(&mut s, on_undo, SIZE, false, false, false)
+            .is_empty()
+    );
+    // From the keyboard: Tab reaches it, Enter undoes and leaves the focus on Done.
+    shell.click(&mut s, at, SIZE, false, false, false);
+    let reached = (0..100).any(|_| {
+        shell.key(&mut s, K::Tab, None, false, SIZE);
+        shell.focus == Some(Target::Undo)
+    });
+    assert!(reached);
+    assert_eq!(
+        shell.key(&mut s, K::Enter, None, false, SIZE),
+        vec![CLICK, CHANGED]
+    );
+    assert_eq!(s.fov, 70.0);
+    assert_eq!(shell.focus, Some(Target::Done));
+}
+
+#[test]
+fn the_strip_says_why_a_greyed_row_cant_be_used() {
+    let atlas = atlas();
+    let s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let mut batch = HudBatch::new([1708, 960]);
+    let size = (batch.width, batch.height);
+    let strip = |batch: &mut HudBatch, shell: &mut Shell<Probe>, at| {
+        shell.draw(&s, batch, &atlas, at, false, None);
+        crate::widgets::end_frame(crate::widgets::generation() + 1);
+        let dock = Columns::of(size.0, size.1).dock;
+        let labelled = crate::widgets::last_labelled();
+        let found = labelled.iter().find(|w| [w.x, w.y, w.w, w.h] == dock);
+        found.map(|w| w.label.clone())
+    };
+    let grey = middle_of(&mut shell, GREY, size);
+    assert_eq!(strip(&mut batch, &mut shell, grey).as_deref(), Some(WHY));
+    let choice = middle_of(&mut shell, CHOICE, size);
+    assert_eq!(
+        strip(&mut batch, &mut shell, choice).as_deref(),
+        Some(CHOICES[0].1)
+    );
+}
+
+#[test]
+fn growing_the_window_keeps_the_scroll_within_the_list() {
+    let s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    shell.scroll(&s, SIZE, -1000.0);
+    assert!(shell.scroll.amount > 0.0);
+    let tall = (SIZE.0, 4000.0);
+    let view = shell.view(&s, tall);
+    assert_eq!(shell.scroll.amount, 0.0);
+    let first = shell.placed(&view).next().map(|(_, y)| y).unwrap();
+    assert!(first >= view.cols.top);
+}
+
+#[test]
+fn one_scroll_path_moves_the_list_for_wheel_and_stick_alike() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let rate = SCROLL_RATE;
+    // The wheel away from any row, and `scroll`, which a stick and a D-pad use.
+    shell.wheel(&mut s, SIZE, (0.0, 0.0), -1.0);
+    assert_eq!(shell.scroll.amount, rate);
+    shell.scroll(&s, SIZE, -2.0);
+    assert_eq!(shell.scroll.amount, 3.0 * rate);
+    shell.scroll(&s, SIZE, 100.0);
+    assert_eq!(shell.scroll.amount, 0.0);
+}
+
+#[test]
+fn the_wheel_steps_a_row_only_with_the_extra_on_and_only_where_the_screen_says() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let over_choice = middle_of(&mut shell, CHOICE, SIZE);
+    shell.wheel(&mut s, SIZE, over_choice, -1.0);
+    assert_eq!(shell.screen.choice, 0);
+    assert_eq!(shell.scroll.amount, SCROLL_RATE);
+    s.extras.wheel_cycles_settings = true;
+    shell.scroll.amount = 0.0;
+    let outputs = shell.wheel(&mut s, SIZE, over_choice, -1.0);
+    assert_eq!(outputs, vec![CHANGED]);
+    assert_eq!(shell.screen.choice, 1);
+    assert_eq!(shell.scroll.amount, 0.0);
+    // A row the screen doesn't step scrolls, the greyed one too.
+    let over_grey = middle_of(&mut shell, GREY, SIZE);
+    assert!(shell.wheel(&mut s, SIZE, over_grey, -1.0).is_empty());
+    assert_eq!(shell.scroll.amount, SCROLL_RATE);
+}
+
+#[test]
+fn a_row_says_what_its_chosen_value_does_and_is_found_by_what_it_does() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let about = |shell: &mut Shell<Probe>, s: &Settings| {
+        let view = shell.view(s, SIZE);
+        let row = view.rows.iter().find(|r| r.id == CHOICE).unwrap();
+        row.described().to_owned()
+    };
+    assert_eq!(about(&mut shell, &s), "Paints it red.");
+    let at = middle_of(&mut shell, CHOICE, SIZE);
+    shell.click(&mut s, at, SIZE, false, false, false);
+    assert_eq!(about(&mut shell, &s), "Paints it blue.");
+    // The search reads the row's own description, on every page.
+    shell.type_text("colour");
+    let view = shell.view(&s, SIZE);
+    let found: Vec<u32> = view.rows.iter().map(|r| r.id).collect();
+    assert!(found.contains(&CHOICE) && !found.contains(&99));
+    shell.search.set_value("elsewhere");
+    shell.focus = None;
+    let view = shell.view(&s, SIZE);
+    assert_eq!(view.rows.iter().map(|r| r.id).collect::<Vec<_>>(), [99]);
+}
+
+#[test]
+fn a_press_on_the_track_slides_and_on_the_name_only_focuses() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let at = middle_of(&mut shell, SLIDER, SIZE);
+    assert!(
+        shell
+            .click(&mut s, at, SIZE, false, false, false)
+            .is_empty()
+    );
+    assert_eq!(shell.screen.slider, 0.0);
+    let (track, width) = Columns::of(SIZE.0, SIZE.1).track();
+    let mid = (track + width / 2.0, at.1);
+    assert_eq!(
+        shell.click(&mut s, mid, SIZE, false, false, false),
+        vec![DRAGGED]
+    );
+    assert_eq!(shell.screen.slider, 0.5);
+    let end = (track + width, at.1);
+    assert_eq!(
+        shell.click(&mut s, end, SIZE, true, false, false),
+        vec![DRAGGED]
+    );
+    assert_eq!(shell.screen.slider, 1.0);
+    assert!(shell.release().is_some());
+    assert!(shell.release().is_none());
+}
+
+#[test]
+fn the_keyboard_walks_the_live_rows_past_the_view_and_presses_them() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let mut key = |shell: &mut Shell<Probe>, k| shell.key(&mut s, k, None, false, SHORT);
+    // Tab: the search, the two pages, then the first row.
+    for _ in 0..4 {
+        key(&mut shell, K::Tab);
+    }
+    assert_eq!(shell.focus, Some(Target::Row(SLIDER)));
+    // A slider Tab reaches changes with the arrows, in its steps.
+    key(&mut shell, K::ArrowRight);
+    assert!((shell.screen.slider - 0.1).abs() < f32::EPSILON);
+    // The arrows go on past the greyed row and rows out of view, which scroll in.
+    key(&mut shell, K::ArrowDown);
+    assert_eq!(shell.focus, Some(Target::Row(CHOICE)));
+    key(&mut shell, K::ArrowDown);
+    assert_eq!(shell.focus, Some(Target::Row(FIRST_FILLER)));
+    for _ in 0..30 {
+        key(&mut shell, K::ArrowDown);
+    }
+    assert_eq!(shell.focus, Some(Target::Row(FIRST_FILLER + 30)));
+    assert!(shell.scroll.amount > 0.0);
+    assert_eq!(key(&mut shell, K::Enter), vec![CLICK, CHANGED]);
+    assert_eq!(shell.screen.pressed, [(FIRST_FILLER + 30, false)]);
+    assert_eq!(key(&mut shell, K::Escape), vec![Output::Done]);
+}
+
+#[test]
+fn left_and_right_step_a_focused_choice_and_leave_other_rows() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let mut key = |shell: &mut Shell<Probe>, k| shell.key(&mut s, k, None, false, SIZE);
+    shell.set_focus(Some(Target::Row(CHOICE)));
+    // Right is a press, Left a Shift press: the screen's own way back, and the focus stays.
+    assert_eq!(key(&mut shell, K::ArrowRight), vec![CLICK, CHANGED]);
+    assert_eq!(key(&mut shell, K::ArrowLeft), vec![CLICK, CHANGED]);
+    assert_eq!(shell.screen.pressed, [(CHOICE, false), (CHOICE, true)]);
+    assert_eq!(shell.focus, Some(Target::Row(CHOICE)));
+    assert!(shell.changed);
+    // A row that isn't a choice: Left goes to the page list, as before.
+    shell.set_focus(Some(Target::Row(FIRST_FILLER)));
+    assert!(key(&mut shell, K::ArrowLeft).is_empty());
+    assert!(matches!(shell.focus, Some(Target::Page(_))));
+    assert_eq!(shell.screen.pressed.len(), 2);
+}
+
+#[test]
+fn a_drawn_choice_tells_the_pad_its_arrows_step_it() {
+    let atlas = atlas();
+    let s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let mut batch = HudBatch::new([1708, 960]);
+    shell.draw(&s, &mut batch, &atlas, (0.0, 0.0), false, None);
+    crate::widgets::end_frame(u64::MAX);
+    let view = shell.view(&s, (batch.width, batch.height));
+    let rect_of = |id| {
+        let mut placed = shell.placed(&view);
+        view.cols.row(placed.find(|(r, _)| r.id == id).unwrap().1)
+    };
+    assert!(crate::widgets::last_steps_value(rect_of(CHOICE)));
+    assert!(!crate::widgets::last_steps_value(rect_of(SLIDER)));
+    assert!(!crate::widgets::last_steps_value(rect_of(FIRST_FILLER)));
+}
+
+/// A controller presses with a click, then moves its own focus: only keys show this one.
+#[test]
+fn leaving_the_search_field_gives_the_keys_back() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let view = shell.view(&s, SIZE);
+    let [x, y, w, h] = view.cols.search();
+    shell.click(
+        &mut s,
+        (x + w / 2.0, y + h / 2.0),
+        SIZE,
+        false,
+        false,
+        false,
+    );
+    assert!(shell.typing());
+    Hosted::blur_search(&mut shell);
+    assert!(!shell.typing());
+    // Another focus isn't dropped.
+    let at = middle_of(&mut shell, FIRST_FILLER, SIZE);
+    shell.click(&mut s, at, SIZE, false, false, false);
+    Hosted::blur_search(&mut shell);
+    shell.key(&mut s, K::ArrowDown, None, false, SIZE);
+    assert!(shell.shows_focus(Target::Row(FIRST_FILLER + 1)));
+}
+
+#[test]
+fn a_key_that_moves_nothing_shows_no_focus() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let at = middle_of(&mut shell, FIRST_FILLER, SIZE);
+    shell.click(&mut s, at, SIZE, false, false, false);
+    shell.key(&mut s, K::ShiftLeft, None, false, SIZE);
+    assert!(!shell.shows_focus(Target::Row(FIRST_FILLER)));
+}
+
+#[test]
+fn a_cut_description_says_so() {
+    assert_eq!(cut_off("off, it never "), "off, it never…");
+}
+
+#[test]
+fn a_click_leaves_no_focus_showing_until_a_key_moves_it() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let at = middle_of(&mut shell, FIRST_FILLER, SIZE);
+    shell.click(&mut s, at, SIZE, false, false, false);
+    assert!(!shell.shows_focus(Target::Row(FIRST_FILLER)));
+    // The next key goes on from the row clicked, and shows where it went.
+    shell.key(&mut s, K::ArrowDown, None, false, SIZE);
+    assert!(shell.shows_focus(Target::Row(FIRST_FILLER + 1)));
+}
+
+#[test]
+fn a_taller_strip_takes_from_the_list_as_far_as_the_list_keeps_its_height() {
+    let (wide, base) = (
+        Columns::of(480.0, 270.0).with_note_lines(4),
+        Columns::of(480.0, 270.0),
+    );
+    assert_eq!(wide.note_lines, 4);
+    assert_eq!(wide.bottom, base.bottom - 2.0 * NOTE_LINE_H);
+    assert_eq!(wide.dock[1] + wide.dock[3], base.dock[1] + base.dock[3]);
+    assert_eq!(wide.button(0), base.button(0));
+    // A 720p window at scale 4 has room for one more line, not two.
+    let short = Columns::of(320.0, 180.0).with_note_lines(4);
+    assert_eq!(short.note_lines, 3);
+    assert!(short.bottom - short.top >= MIN_LIST_H);
+}
+
+#[test]
+fn shift_presses_a_row_backwards() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let at = middle_of(&mut shell, FIRST_FILLER, SIZE);
+    shell.click(&mut s, at, SIZE, false, false, true);
+    // The right button is not a press.
+    shell.click(&mut s, at, SIZE, false, true, false);
+    assert_eq!(shell.screen.pressed, [(FIRST_FILLER, true)]);
+}
+
+#[test]
+fn a_click_on_a_greyed_row_does_nothing_and_done_leaves() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let at = middle_of(&mut shell, GREY, SIZE);
+    assert!(
+        shell
+            .click(&mut s, at, SIZE, false, false, false)
+            .is_empty()
+    );
+    assert!(shell.screen.pressed.is_empty());
+    let [x, y, w, h] = Columns::of(SIZE.0, SIZE.1).button(0);
+    let at = (x + w / 2.0, y + h / 2.0);
+    assert_eq!(
+        shell.click(&mut s, at, SIZE, false, false, false),
+        vec![CLICK, Output::Done]
+    );
+}
+
+#[test]
+fn a_page_picked_shows_alone() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let [x, y, w, h] = Columns::of(SIZE.0, SIZE.1).page(1);
+    let at = (x + w / 2.0, y + h / 2.0);
+    assert_eq!(
+        shell.click(&mut s, at, SIZE, false, false, false),
+        vec![CLICK]
+    );
+    let view = shell.view(&s, SIZE);
+    assert_eq!(view.rows.iter().map(|r| r.id).collect::<Vec<_>>(), [99]);
+}
+
+/// A screen with more pages than a short view's page list has room for: a page of its own,
+/// then a section of `PAGES` under a line, one more page out of the list that the section's
+/// first page links to, and a change that waits for Apply.
+#[derive(Default)]
+struct Pages {
+    pending: bool,
+    applied: usize,
+}
+const PAGES: u8 = 12;
+const HOME: u8 = 0;
+const DEEP: u8 = 100;
+const LINK: u32 = 1000;
+const WAITS: u32 = 1001;
+const SECTION: &str = "Section";
+impl Screen for Pages {
+    type Page = u8;
+    type Row = u32;
+    fn title(&self) -> &'static str {
+        "Pages"
+    }
+    fn stamp(&self, _: &Settings) -> u64 {
+        stamp_of(&self.pending)
+    }
+    fn sheets(&self, _: &Settings) -> Vec<Sheet<u8, u32>> {
+        let page = |id: u8, name: String, rows| {
+            Sheet::new(id, name, String::new(), vec![Group { name: "G", rows }])
+        };
+        let change = Row::new(WAITS, "Change".to_owned(), Value::Press);
+        let mut sheets = vec![page(HOME, "Home".to_owned(), vec![change])];
+        for i in 1..=PAGES {
+            let mut rows = vec![Row::new(u32::from(i), format!("Row {i}"), Value::Press)];
+            if i == 1 {
+                rows.push(Row::new(LINK, "Deeper...".to_owned(), Value::Press));
+            }
+            let mut sheet = page(i, format!("Page {i}"), rows);
+            sheet.heading = (i == 1).then(|| SECTION.to_owned());
+            sheets.push(sheet);
+        }
+        let deep = Row::new(u32::from(DEEP), "Deep".to_owned(), Value::Press);
+        let mut deeper = page(DEEP, "Deeper".to_owned(), vec![deep]);
+        deeper.listed = false;
+        sheets.push(deeper);
+        sheets
+    }
+    fn press(&mut self, _: &mut Settings, row: u32, _: bool) -> Vec<Output> {
+        self.pending |= row == WAITS;
+        vec![CHANGED]
+    }
+    fn link(&self, row: u32) -> Option<u8> {
+        (row == LINK).then_some(DEEP)
+    }
+    fn undoes(&self) -> bool {
+        true
+    }
+    fn pending(&self, _: &Settings) -> bool {
+        self.pending
+    }
+    fn apply(&mut self, _: &mut Settings) -> Vec<Output> {
+        self.pending = false;
+        self.applied += 1;
+        vec![CHANGED]
+    }
+}
+
+/// A window of 854x960 (427x480 GUI px at its automatic scale) and one of 854x480 (427x240:
+/// the page list has room for six places).
+const TALL: [u32; 2] = [854, 960];
+const SHORT_WINDOW: [u32; 2] = [854, 480];
+
+/// One frame of `shell` in a window of `window`; the GUI size it was drawn at.
+fn drawn<S: Screen + Default>(shell: &mut Shell<S>, s: &Settings, window: [u32; 2]) -> (f32, f32) {
+    let mut batch = HudBatch::new(window);
+    shell.draw(s, &mut batch, &atlas(), (0.0, 0.0), false, None);
+    crate::widgets::end_frame(crate::widgets::generation() + 1);
+    (batch.width, batch.height)
+}
+
+fn middle([x, y, w, h]: [f32; 4]) -> (f32, f32) {
+    (x + w / 2.0, y + h / 2.0)
+}
+
+#[test]
+fn pages_that_fit_are_listed_and_more_collapse_into_one_row_leaving_none_out() {
+    let s = Settings::default();
+    let mut shell = Shell::<Pages>::default();
+    // Tall enough: each page under the last, the deeper page left out as it is in no list.
+    drawn(&mut shell, &s, TALL);
+    let tall = shell.page_places();
+    let pages: Vec<u8> = tall.iter().map(|p| p.0).collect();
+    assert_eq!(pages, (HOME..=PAGES).collect::<Vec<_>>());
+    assert!(tall.iter().all(|p| p.2 == Part::Tab));
+    assert!(tall.windows(2).all(|p| p[1].1[1] > p[0].1[1]));
+    assert_eq!(shell.strip_ends(), None);
+    // Short: the first page, then the section in one row, its first page between nothing and
+    // its next. Every place is inside the column, the row's on one line under the section's.
+    let size = drawn(&mut shell, &s, SHORT_WINDOW);
+    let short = shell.page_places();
+    let parts: Vec<(u8, Part)> = short.iter().map(|p| (p.0, p.2)).collect();
+    assert_eq!(
+        parts,
+        [(HOME, Part::Tab), (1, Part::Shown), (2, Part::Next)]
+    );
+    assert_eq!(shell.strip_ends(), Some((false, true)));
+    let cols = Columns::of(size.0, size.1);
+    for (_, [x, _, w, _], _) in &short {
+        assert!(*x >= cols.side_x && x + w <= cols.side_x + style::CONTROL_W);
+    }
+    assert_eq!(short[1].1[1], short[2].1[1]);
+    assert_eq!(short[1].1[1], cols.page(2)[1]);
+    // The line naming the section stays over it.
+    let labelled = crate::widgets::last_labelled();
+    let line = labelled.iter().find(|w| w.label == SECTION).unwrap();
+    assert!(line.y > cols.page(1)[1] && line.y < cols.page(2)[1]);
+}
+
+#[test]
+fn the_collapsed_rows_arrows_walk_every_page_and_its_ends_go_no_further() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Pages>::default();
+    shell.show(1);
+    let mut seen = vec![1];
+    let size = loop {
+        let size = drawn(&mut shell, &s, SHORT_WINDOW);
+        let places = shell.page_places();
+        let Some(&(next, rect, _)) = places.iter().find(|p| p.2 == Part::Next) else {
+            break size;
+        };
+        assert_eq!(
+            shell.click(&mut s, middle(rect), size, false, false, false),
+            [CLICK]
+        );
+        assert_eq!(shell.open_page(), Some(next));
+        seen.push(next);
+    };
+    assert_eq!(seen, (1..=PAGES).collect::<Vec<_>>());
+    assert_eq!(shell.strip_ends(), Some((true, false)));
+    // At the last page, the right of the row picks nothing: its arrow is dimmed.
+    let cols = Columns::of(size.0, size.1);
+    let [x, y, w, h] = cols.page(2);
+    assert!(
+        shell
+            .click(
+                &mut s,
+                (x + w - 2.0, y + h / 2.0),
+                size,
+                false,
+                false,
+                false
+            )
+            .is_empty()
+    );
+    assert_eq!(shell.open_page(), Some(PAGES));
+    // The page before it from the keyboard: Enter on its arrow opens it, and the focus follows
+    // it to the middle of the row.
+    let before = shell
+        .page_places()
+        .iter()
+        .find(|p| p.0 == PAGES - 1)
+        .unwrap()
+        .2;
+    assert_eq!(before, Part::Prev);
+    shell.set_focus(Some(Target::Page(PAGES - 1)));
+    assert_eq!(shell.key(&mut s, K::Enter, None, false, size), [CLICK]);
+    drawn(&mut shell, &s, SHORT_WINDOW);
+    let now = shell
+        .page_places()
+        .iter()
+        .find(|p| p.0 == PAGES - 1)
+        .unwrap()
+        .2;
+    assert_eq!(now, Part::Shown);
+}
+
+#[test]
+fn while_searching_the_collapsed_rows_arrows_skip_pages_without_matches() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Pages>::default();
+    // Rows 1, 10, 11 and 12: none before the first. The first page stays, as it has no match.
+    shell.set_search("row 1");
+    let size = drawn(&mut shell, &s, SHORT_WINDOW);
+    let pages = |shell: &Shell<Pages>| shell.page_places().iter().map(|p| p.0).collect::<Vec<_>>();
+    assert_eq!(pages(&shell), [HOME, 1, 10]);
+    assert_eq!(shell.strip_ends(), Some((false, true)));
+    // Its arrow goes to the next match, which has the first one before it and the last after.
+    let next = shell.page_places()[2].1;
+    shell.click(&mut s, middle(next), size, false, false, false);
+    drawn(&mut shell, &s, SHORT_WINDOW);
+    assert_eq!(pages(&shell), [HOME, 1, 10, 11]);
+    assert_eq!(shell.strip_ends(), Some((true, true)));
+}
+
+#[test]
+fn a_controllers_bumpers_find_the_collapsed_rows_parts_as_tabs() {
+    let s = Settings::default();
+    let mut shell = Shell::<Pages>::default();
+    shell.show(5);
+    drawn(&mut shell, &s, SHORT_WINDOW);
+    let tabs: Vec<(f32, bool)> = crate::widgets::last_targets()
+        .into_iter()
+        .filter_map(|t| match t.kind {
+            crate::widgets::Kind::Tab(open) => Some((t.rect[0], open)),
+            _ => None,
+        })
+        .collect();
+    // The first page, the page before, the open one (lit) and the one after.
+    assert_eq!(tabs.len(), 4, "{tabs:?}");
+    assert_eq!(tabs.iter().filter(|t| t.1).count(), 1);
+    let (before, open, after) = (tabs[1].0, tabs[2], tabs[3].0);
+    assert!(open.1 && before < open.0 && open.0 < after);
+    // The arrows are vanilla's Previous Page and Next Page to the narrator.
+    let labels = crate::widgets::last_labelled();
+    let named = |key| {
+        labels
+            .iter()
+            .any(|w| w.label == lang::get(key) && w.enabled)
+    };
+    assert!(named(PREVIOUS_PAGE) && named(NEXT_PAGE));
+}
+
+#[test]
+fn a_link_opens_a_page_out_of_the_list_and_escape_comes_back_to_the_links_page() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Pages>::default();
+    // Found by the search from another page: back is the page the link is on.
+    shell.show(HOME);
+    shell.set_search("deeper");
+    let at = shell.point_at(&s, SIZE, LINK);
+    assert_eq!(shell.click(&mut s, at, SIZE, false, false, false), [CLICK]);
+    // The page opens alone, the search cleared; the list lights the page the link was on.
+    assert_eq!(shell.open_page(), Some(DEEP));
+    assert_eq!(shell.listed(&s, SIZE), [(DEEP, u32::from(DEEP))]);
+    drawn(&mut shell, &s, TALL);
+    assert_eq!(shell.lit_page(), Some(1));
+    assert!(shell.key(&mut s, K::Escape, None, false, SIZE).is_empty());
+    assert_eq!(shell.open_page(), Some(1));
+    assert_eq!(
+        shell.key(&mut s, K::Escape, None, false, SIZE),
+        [Output::Done]
+    );
+}
+
+#[test]
+fn apply_shows_beside_undo_while_changes_wait_and_goes_with_them() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Pages>::default();
+    let done = Columns::of(SIZE.0, SIZE.1).button(0);
+    assert_eq!(shell.foot_at(&s, SIZE), [(Target::Done, done)]);
+    let at = shell.point_at(&s, SIZE, WAITS);
+    shell.click(&mut s, at, SIZE, false, false, false);
+    let foot = shell.foot_at(&s, SIZE);
+    let targets: Vec<_> = foot.iter().map(|f| f.0).collect();
+    assert_eq!(targets, [Target::Undo, Target::Apply, Target::Done]);
+    // Side by side over Done, as wide as it together.
+    let ([ux, uy, uw, _], [ax, ay, aw, _]) = (foot[0].1, foot[1].1);
+    assert_eq!((uy, ay), (foot[2].1[1] - FOOT_GAP - style::BUTTON_H, uy));
+    assert!(ux + uw < ax && ax + aw == done[0] + done[2] && ux == done[0]);
+    assert_eq!(
+        shell.click(&mut s, middle(foot[1].1), SIZE, false, false, false),
+        [CLICK, CHANGED]
+    );
+    assert_eq!(shell.screen.applied, 1);
+    let targets: Vec<_> = shell.foot_at(&s, SIZE).iter().map(|f| f.0).collect();
+    assert_eq!(targets, [Target::Undo, Target::Done]);
+}
+
+#[test]
+fn the_right_button_steps_no_choice_as_vanillas_cycle_button() {
+    let mut s = Settings::default();
+    let mut shell = Shell::<Probe>::default();
+    let choice = middle_of(&mut shell, CHOICE, SIZE);
+    assert!(
+        shell
+            .click(&mut s, choice, SIZE, false, true, false)
+            .is_empty()
+    );
+    assert!(shell.screen.pressed.is_empty());
+}
@@ -932,7 +932,56 @@ pub struct Downloader {
    failed: std::collections::HashMap<(Kind, String), std::time::Instant>,
    /// How long a failed texture download waits before it is tried again.
    retry_after: std::time::Duration,
+    /// The `states` keys, oldest first, so the oldest settled one can go ([`Bounds::states`]).
+    state_order: std::collections::VecDeque<(Kind, String)>,
+    /// The `resources` keys, oldest first ([`Bounds::resources`]).
+    resource_order: std::collections::VecDeque<String>,
+    /// Downloads started whose answer `state` has not taken yet: one thread each.
+    in_flight: usize,
+    /// Fetches a texture's body; the HTTP GET, but for a test.
+    fetch: fn(&str) -> Option<Vec<u8>>,
+    bounds: Bounds,
 }
+/// A download thread's answer to `state`. If the thread panics before giving it (a body that
+/// breaks the decoder, say), dropping this answers "failed" instead: the download's place in
+/// `in_flight` is given back and the texture is retried after the wait, where an answer that never
+/// came kept the key `Pending` for good and, with the bound, the place taken for the session.
+struct Answer {
+    send: std::sync::mpsc::Sender<((Kind, String), Option<Vec<u8>>)>,
+    key: Option<(Kind, String)>,
+}
+impl Answer {
+    fn give(&mut self, image: Option<Vec<u8>>) {
+        if let Some(key) = self.key.take() {
+            let _ = self.send.send((key, image));
+        }
+    }
+}
+impl Drop for Answer {
+    fn drop(&mut self) {
+        self.give(None);
+    }
+}
+
+/// What the downloader keeps and runs at most. Every texture URL a server (or a tab list of
+/// hundreds of players) names used to add a `states` entry and a thread of its own, and every
+/// `texture` id a `resources` entry, none of them ever dropped.
+#[derive(Clone, Copy, Debug)]
+struct Bounds {
+    /// Entries of `states`; the oldest settled (ready or failed) one is dropped past this. A
+    /// dropped texture is loaded again from the disk cache when it is asked for.
+    states: usize,
+    /// Entries of `resources`; the oldest is dropped past this, and read from the packs again.
+    resources: usize,
+    /// Downloads running at once. Past this `state` says `Pending` and starts nothing, so the
+    /// caller, which asks again every frame, starts it when one has finished.
+    downloads: usize,
+}
+const BOUNDS: Bounds = Bounds {
+    states: 4096,
+    resources: 4096,
+    downloads: 16,
+};
 /// `images` is bounded only so a long session on a busy server does not grow
 /// without end; the disk cache holds everything it drops.
 const MAX_SKIN_IMAGES: usize = 1024;
@@ -964,6 +1013,11 @@ impl Downloader {
            resources: Default::default(),
            failed: Default::default(),
            retry_after: std::time::Duration::from_secs(60),
+            state_order: Default::default(),
+            resource_order: Default::default(),
+            in_flight: 0,
+            fetch: http_get,
+            bounds: BOUNDS,
        }
    }
    /// The resource packs changed (or were first loaded) at `root`: patch
@@ -973,6 +1027,7 @@ impl Downloader {
            self.images.remove(&location);
            self.image_order.retain(|l| *l != location);
        }
+        self.resource_order.clear();
        self.resource_root = root;
    }
    /// `ClientAsset.ResourceTexture`: loads `<namespace>:textures/<path>.png`
@@ -1002,12 +1057,47 @@ impl Downloader {
            }
            None => Download::Failed,
        };
-        self.resources.insert(location.to_owned(), state);
+        if self.resources.insert(location.to_owned(), state).is_none() {
+            self.resource_order.push_back(location.to_owned());
+            while self.resources.len() > self.bounds.resources
+                && let Some(old) = self.resource_order.pop_front()
+            {
+                self.resources.remove(&old);
+            }
+        }
+    }
+    /// Forgets how `location` loaded, so `resource` reads it again.
+    fn forget_resource(&mut self, location: &str) {
+        if self.resources.remove(location).is_some() {
+            self.resource_order.retain(|l| l != location);
+        }
+    }
+    /// Records how `key` stands. A new key may push the oldest settled one out of `states`;
+    /// downloads running are never dropped, so their answer has a key to land on.
+    fn set_state(&mut self, key: (Kind, String), state: Download) {
+        if self.states.insert(key.clone(), state).is_some() {
+            return;
+        }
+        self.state_order.push_back(key);
+        while self.states.len() > self.bounds.states {
+            let Some(at) = self
+                .state_order
+                .iter()
+                .position(|k| self.states.get(k) != Some(&Download::Pending))
+            else {
+                break;
+            };
+            if let Some(old) = self.state_order.remove(at) {
+                self.states.remove(&old);
+                self.failed.remove(&old);
+            }
+        }
    }
    /// How the download of `url` stands, starting it the first time. A
    /// failure is permanent for `retry_after`, then tried again.
    pub fn state(&mut self, kind: Kind, url: &str) -> Download {
        while let Ok((key, image)) = self.done.try_recv() {
+            self.in_flight = self.in_flight.saturating_sub(1);
            let state = match image {
                Some(rgba) => {
                    match key.0 {
@@ -1023,29 +1113,42 @@ impl Downloader {
                    Download::Failed
                }
            };
-            self.states.insert(key, state);
+            self.set_state(key, state);
        }
        let Some(hash) = texture_hash(url) else {
            return Download::Failed;
        };
        let key = (kind, hash);
+        let full = self.in_flight >= self.bounds.downloads;
        if let Some(state) = self.states.get(&key).copied() {
            let due = self
                .failed
                .get(&key)
                .is_none_or(|at| at.elapsed() >= self.retry_after);
-            if state != Download::Failed || !due {
+            // A failure that is due waits for a free download like a new texture does.
+            if state != Download::Failed || !due || full {
                return state;
            }
            self.states.remove(&key);
            self.failed.remove(&key);
+            self.state_order.retain(|k| *k != key);
        }
-        self.states.insert(key.clone(), Download::Pending);
+        if full {
+            // Not recorded: the next call asks again, and starts it once one has finished.
+            return Download::Pending;
+        }
+        self.in_flight += 1;
+        self.set_state(key.clone(), Download::Pending);
        let digest: String = skin_location(&key.1)["skins/".len()..].to_owned();
        let (url, send, root) = (url.to_owned(), self.send.clone(), self.root.clone());
+        let fetch = self.fetch;
        std::thread::spawn(move || {
-            let image = Self::load_texture(&root, kind, &digest, &url, http_get);
-            let _ = send.send((key, image));
+            let mut answer = Answer {
+                send,
+                key: Some(key),
+            };
+            let image = Self::load_texture(&root, kind, &digest, &url, fetch);
+            answer.give(image);
        });
        Download::Pending
    }
@@ -1108,7 +1211,7 @@ impl Downloader {
        if location.starts_with("patch/") {
            let Some(image) = self.images.get(location).cloned() else {
                // Dropped from memory: read from the packs again.
-                self.resources.remove(location);
+                self.forget_resource(location);
                return false;
            };
            self.queue(location.to_owned(), image);
@@ -1925,3 +2028,225 @@ mod tests {
        assert_eq!(served.load(Ordering::SeqCst), 2);
    }
 }
+
+#[cfg(test)]
+mod download_bound_tests {
+    use super::{Bounds, Download, Downloader, Kind};
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    fn downloader(name: &str, bounds: Bounds, fetch: fn(&str) -> Option<Vec<u8>>) -> Downloader {
+        let root =
+            std::env::temp_dir().join(format!("horizon-test-skin-{name}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        let mut d = Downloader::new(root);
+        d.fetch = fetch;
+        d.bounds = bounds;
+        d
+    }
+
+    fn url(i: usize) -> String {
+        format!("https://textures.example/texture/skin{i:05}")
+    }
+
+    /// Asks again until the texture's download has settled.
+    fn wait(d: &mut Downloader, url: &str) -> Download {
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
+        loop {
+            let state = d.state(Kind::Skin, url);
+            if state != Download::Pending || std::time::Instant::now() > deadline {
+                return state;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(2));
+        }
+    }
+
+    static RUNNING: AtomicUsize = AtomicUsize::new(0);
+    static PEAK: AtomicUsize = AtomicUsize::new(0);
+
+    /// A fetch that is slow enough for the others to pile up behind it, and counts how many run.
+    fn slow_failure(_: &str) -> Option<Vec<u8>> {
+        let now = RUNNING.fetch_add(1, Ordering::SeqCst) + 1;
+        PEAK.fetch_max(now, Ordering::SeqCst);
+        std::thread::sleep(std::time::Duration::from_millis(20));
+        RUNNING.fetch_sub(1, Ordering::SeqCst);
+        None
+    }
+
+    /// The same, not counted: tests run side by side, and the count is another test's.
+    fn sleepy_failure(_: &str) -> Option<Vec<u8>> {
+        std::thread::sleep(std::time::Duration::from_millis(20));
+        None
+    }
+
+    /// A tab list of 60 players names 60 textures at once: no more than the bound run together,
+    /// the ones that waited start as the others finish, and every one ends. Every frame asks again.
+    #[test]
+    fn downloads_run_a_few_at_a_time_and_the_late_ones_start_later() {
+        let bounds = Bounds {
+            states: 4096,
+            resources: 4096,
+            downloads: 4,
+        };
+        let mut d = downloader("threads", bounds, slow_failure);
+        let urls: Vec<String> = (0..60).map(url).collect();
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
+        let mut first = true;
+        loop {
+            let states: Vec<Download> = urls.iter().map(|u| d.state(Kind::Skin, u)).collect();
+            if first {
+                // Asked all at once: four started, and the others were not even recorded.
+                assert_eq!(d.in_flight, 4);
+                assert_eq!(d.states.len(), 4);
+                assert!(states.iter().all(|s| *s == Download::Pending));
+                first = false;
+            }
+            if states.iter().all(|s| *s == Download::Failed) {
+                break;
+            }
+            assert!(
+                std::time::Instant::now() < deadline,
+                "{} still pending",
+                states.len()
+            );
+            std::thread::sleep(std::time::Duration::from_millis(2));
+        }
+        assert!(
+            PEAK.load(Ordering::SeqCst) <= 4,
+            "{}",
+            PEAK.load(Ordering::SeqCst)
+        );
+        assert_eq!(d.states.len(), 60);
+        assert_eq!(d.in_flight, 0);
+    }
+
+    /// More textures than `states` holds: the map keeps to its bound, the oldest settled ones go
+    /// (and their failure time with them), and one that went is asked again as a new texture.
+    #[test]
+    fn the_states_keep_to_their_bound_and_drop_the_oldest() {
+        let bounds = Bounds {
+            states: 8,
+            resources: 4096,
+            downloads: 16,
+        };
+        let mut d = downloader("states", bounds, |_| None);
+        for i in 0..40 {
+            let u = url(i);
+            assert_eq!(wait(&mut d, &u), Download::Failed, "{i}");
+            assert!(d.states.len() <= 8 && d.state_order.len() == d.states.len());
+            assert!(d.failed.len() <= 8);
+        }
+        let kept: Vec<usize> = (0..40)
+            .filter(|i| {
+                d.states
+                    .contains_key(&(Kind::Skin, super::texture_hash(&url(*i)).unwrap()))
+            })
+            .collect();
+        assert_eq!(kept, (32..40).collect::<Vec<_>>());
+        // The first one went: asked again, it starts again (and fails again).
+        assert_eq!(d.state(Kind::Skin, &url(0)), Download::Pending);
+        assert_eq!(d.in_flight, 1);
+    }
+
+    /// A fetch that panics, as a decoder can on a body a server chose.
+    fn panicking(_: &str) -> Option<Vec<u8>> {
+        panic!("a fetch that panics, on purpose");
+    }
+
+    /// A thread that panics before it answers still gives its place back: with two places and six
+    /// textures whose fetch panics, every one settles as failed instead of the places staying
+    /// taken for good.
+    #[test]
+    fn a_download_that_panics_gives_its_place_back() {
+        let bounds = Bounds {
+            states: 4096,
+            resources: 4096,
+            downloads: 2,
+        };
+        let mut d = downloader("panics", bounds, panicking);
+        for i in 0..6 {
+            assert_eq!(wait(&mut d, &url(i)), Download::Failed, "{i}");
+        }
+        assert_eq!(d.in_flight, 0);
+        assert_eq!(d.states.len(), 6);
+    }
+
+    /// A fetch long enough for a test to ask between its start and its end.
+    fn slowish_failure(_: &str) -> Option<Vec<u8>> {
+        std::thread::sleep(std::time::Duration::from_millis(150));
+        None
+    }
+
+    /// A failure whose wait is over is retried like a new texture: not while every place is taken
+    /// (it keeps answering `Failed`, and starts nothing), and as soon as one is free.
+    #[test]
+    fn a_failure_that_is_due_waits_for_a_free_place() {
+        let bounds = Bounds {
+            states: 4096,
+            resources: 4096,
+            downloads: 1,
+        };
+        let mut d = downloader("due", bounds, slowish_failure);
+        let wait_time = d.retry_after;
+        assert_eq!(wait(&mut d, &url(0)), Download::Failed);
+        // Another texture takes the only place; the first one's retry becomes due but has to wait.
+        assert_eq!(d.state(Kind::Skin, &url(1)), Download::Pending);
+        d.retry_after = std::time::Duration::ZERO;
+        assert_eq!(d.state(Kind::Skin, &url(0)), Download::Failed);
+        assert_eq!(d.in_flight, 1);
+        d.retry_after = wait_time;
+        assert_eq!(wait(&mut d, &url(1)), Download::Failed);
+        // The place is free: the retry starts.
+        d.retry_after = std::time::Duration::ZERO;
+        assert_eq!(d.state(Kind::Skin, &url(0)), Download::Pending);
+        assert_eq!(d.in_flight, 1);
+    }
+
+    /// A texture that is running is never the one dropped, however many settle behind it.
+    #[test]
+    fn a_running_download_keeps_its_place_in_the_states() {
+        let bounds = Bounds {
+            states: 2,
+            resources: 4096,
+            downloads: 16,
+        };
+        let mut d = downloader("running", bounds, sleepy_failure);
+        assert_eq!(d.state(Kind::Skin, &url(0)), Download::Pending);
+        for i in 1..6 {
+            d.set_state((Kind::Cape, format!("settled{i}")), Download::Ready);
+        }
+        assert_eq!(
+            d.states
+                .get(&(Kind::Skin, super::texture_hash(&url(0)).unwrap())),
+            Some(&Download::Pending)
+        );
+        assert!(d.states.len() <= 3);
+        assert_eq!(wait(&mut d, &url(0)), Download::Failed);
+    }
+
+    /// `resources` keeps to its bound too: a server's `texture` ids, one for each unique one, no
+    /// longer pile up, and one that was dropped is read from the packs again.
+    #[test]
+    fn the_resource_textures_keep_to_their_bound() {
+        let bounds = Bounds {
+            states: 4096,
+            resources: 8,
+            downloads: 16,
+        };
+        let mut d = downloader("resources", bounds, |_| None);
+        for i in 0..40 {
+            d.resource(&format!("patch/n/{i}"), "n", &format!("t{i}"));
+            assert!(d.resources.len() <= 8 && d.resource_order.len() == d.resources.len());
+        }
+        let kept: Vec<usize> = (0..40)
+            .filter(|i| d.resources.contains_key(&format!("patch/n/{i}")))
+            .collect();
+        assert_eq!(kept, (32..40).collect::<Vec<_>>());
+        // Forgetting one by hand (as `again` does) leaves no stale key behind.
+        d.forget_resource("patch/n/35");
+        assert_eq!(d.resource_order.len(), d.resources.len());
+        assert!(!d.resource_order.iter().any(|l| l == "patch/n/35"));
+        // New packs start the count over.
+        d.set_resource_root(std::env::temp_dir());
+        assert!(d.resources.is_empty() && d.resource_order.is_empty());
+    }
+}
@@ -12,6 +12,13 @@
 //! or an empty answer keeps the cached lists, `Retry-After` sets the poll interval, and
 //! `getFriendData` waits out a ten-second cooldown between reads. The presence statuses
 //! are `PresenceHandler.getPresenceStatus`'s, supplied by the client each tick.
+mod model;
+
+use model::presence_of;
+pub use model::{
+    Friend, FriendData, Presence, PresenceStatus, ResultCode, parse_friends, parse_presence,
+};
+
 use crate::auth::{self, AuthSession};
 use serde_json::{Value, json};
 use std::{
@@ -23,69 +30,6 @@ use std::{
    time::{Duration, Instant},
 };

-/// authlib's `FriendsService.ResultCode`.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum ResultCode {
-    Success,
-    Error,
-    ServiceNotAvailable,
-    TooManyRequests,
-    Forbidden,
-    UpgradeNeeded,
-    ConnectionIssue,
-    TemporaryUnavailable,
-    UnknownProfile,
-    Unauthorized,
-    GenericError,
-}
-
-/// `FriendDto`: one friend or one pending request.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Friend {
-    pub id: u128,
-    pub name: String,
-}
-
-/// authlib's `FriendData`: the three lists the service answers.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct FriendData {
-    pub friends: Vec<Friend>,
-    pub incoming: Vec<Friend>,
-    pub outgoing: Vec<Friend>,
-}
-
-/// authlib's `PresenceStatus`, as `updatePresence` stores it.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum PresenceStatus {
-    Online,
-    PlayingOffline,
-    PlayingRealms,
-    PlayingServer,
-    PlayingHostedServer,
-    Offline,
-}
-impl PresenceStatus {
-    /// `PresenceStatus.name()`: the string `updatePresence` sends and
-    /// `PresenceStatusDto.status` carries.
-    fn wire(self) -> &'static str {
-        match self {
-            Self::Online => "ONLINE",
-            Self::PlayingOffline => "PLAYING_OFFLINE",
-            Self::PlayingRealms => "PLAYING_REALMS",
-            Self::PlayingServer => "PLAYING_SERVER",
-            Self::PlayingHostedServer => "PLAYING_HOSTED_SERVER",
-            Self::Offline => "OFFLINE",
-        }
-    }
-}
-
-/// `PresenceStatusDto`.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Presence {
-    pub id: u128,
-    pub status: PresenceStatus,
-}
-
 /// `RemoteFriendListUpdateHandler.State`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum State {
@@ -726,104 +670,10 @@ fn http_error(error: ureq::Error) -> Failure {
    Failure { code }
 }

-/// authlib's `FriendsListResponse` (`getFriends`/`updateFriends` body).
-pub fn parse_friends(body: &str) -> Option<FriendData> {
-    let v: Value = serde_json::from_str(body).ok()?;
-    Some(FriendData {
-        friends: parse_friend_list(v.get("friends")),
-        incoming: parse_friend_list(v.get("incomingRequests")),
-        outgoing: parse_friend_list(v.get("outgoingRequests")),
-    })
-}
-
-fn parse_friend_list(value: Option<&Value>) -> Vec<Friend> {
-    value
-        .and_then(|v| v.as_array())
-        .into_iter()
-        .flatten()
-        .filter_map(|friend| {
-            Some(Friend {
-                id: auth::parse_uuid(friend.get("profileId")?.as_str()?)?,
-                name: friend.get("name")?.as_str()?.to_owned(),
-            })
-        })
-        .collect()
-}
-
-/// authlib's `PresenceResponse`.
-pub fn parse_presence(body: &str) -> Option<Vec<Presence>> {
-    let v: Value = serde_json::from_str(body).ok()?;
-    Some(presence_of(&v))
-}
-
-/// `PresenceResponse.presence`: a missing list reads as empty, as Gson's null does.
-fn presence_of(v: &Value) -> Vec<Presence> {
-    v.get("presence")
-        .and_then(Value::as_array)
-        .into_iter()
-        .flatten()
-        .filter_map(|entry| {
-            let status = entry.get("status")?.as_str()?;
-            let status = match status {
-                "ONLINE" => PresenceStatus::Online,
-                "PLAYING_OFFLINE" => PresenceStatus::PlayingOffline,
-                "PLAYING_REALMS" => PresenceStatus::PlayingRealms,
-                "PLAYING_SERVER" => PresenceStatus::PlayingServer,
-                "PLAYING_HOSTED_SERVER" => PresenceStatus::PlayingHostedServer,
-                _ => PresenceStatus::Offline,
-            };
-            Some(Presence {
-                id: auth::parse_uuid(entry.get("profileId")?.as_str()?)?,
-                status,
-            })
-        })
-        .collect()
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;

-    #[test]
-    fn a_friends_answer_reads_its_three_lists() {
-        let data = parse_friends(
-            r#"{"friends":[{"profileId":"0123456789abcdef0123456789abcdef","name":"Alex"}],
-                "incomingRequests":[],"outgoingRequests":[{"profileId":"fedcba9876543210fedcba9876543210","name":"Steve"}]}"#,
-        )
-        .unwrap();
-        assert_eq!(
-            data.friends,
-            vec![Friend {
-                id: 0x0123_4567_89ab_cdef_0123_4567_89ab_cdef,
-                name: "Alex".into()
-            }]
-        );
-        assert!(data.incoming.is_empty());
-        assert_eq!(data.outgoing[0].name, "Steve");
-        // The service's answer to an account with no friends, as the live check
-        // captured it: the three lists plus an `empty` flag the parser ignores.
-        let empty = parse_friends(
-            r#"{"empty":true,"friends":[],"incomingRequests":[],"outgoingRequests":[]}"#,
-        )
-        .unwrap();
-        assert_eq!(empty, FriendData::default());
-    }
-
-    #[test]
-    fn a_presence_answer_reads_each_status() {
-        let presence = parse_presence(
-            r#"{"presence":[
-                {"profileId":"0123456789abcdef0123456789abcdef","pmid":"00000000000000000000000000000000","status":"PLAYING_REALMS","lastUpdated":"2026-11-08T12:00:00Z"},
-                {"profileId":"fedcba9876543210fedcba9876543210","pmid":"00000000000000000000000000000000","status":"OFFLINE","lastUpdated":"2026-11-08T12:00:00Z"}]}"#,
-        )
-        .unwrap();
-        assert_eq!(presence[0].status, PresenceStatus::PlayingRealms);
-        assert_eq!(presence[1].status, PresenceStatus::Offline);
-        // `PresenceResponse` without its list is empty, not missing.
-        assert_eq!(parse_presence("{}"), Some(Vec::new()));
-        assert_eq!(parse_presence("not json"), None);
-    }
-
    #[test]
    fn result_codes_map_to_the_handlers_states() {
        assert_eq!(State::of(ResultCode::Success), State::Success);
@@ -0,0 +1,164 @@
+use crate::auth;
+use serde_json::Value;
+
+/// authlib's `FriendsService.ResultCode`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ResultCode {
+    Success,
+    Error,
+    ServiceNotAvailable,
+    TooManyRequests,
+    Forbidden,
+    UpgradeNeeded,
+    ConnectionIssue,
+    TemporaryUnavailable,
+    UnknownProfile,
+    Unauthorized,
+    GenericError,
+}
+
+/// `FriendDto`: one friend or one pending request.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Friend {
+    pub id: u128,
+    pub name: String,
+}
+
+/// authlib's `FriendData`: the three lists the service answers.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct FriendData {
+    pub friends: Vec<Friend>,
+    pub incoming: Vec<Friend>,
+    pub outgoing: Vec<Friend>,
+}
+
+/// authlib's `PresenceStatus`, as `updatePresence` stores it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PresenceStatus {
+    Online,
+    PlayingOffline,
+    PlayingRealms,
+    PlayingServer,
+    PlayingHostedServer,
+    Offline,
+}
+impl PresenceStatus {
+    /// `PresenceStatus.name()`: the string `updatePresence` sends and
+    /// `PresenceStatusDto.status` carries.
+    pub(super) fn wire(self) -> &'static str {
+        match self {
+            Self::Online => "ONLINE",
+            Self::PlayingOffline => "PLAYING_OFFLINE",
+            Self::PlayingRealms => "PLAYING_REALMS",
+            Self::PlayingServer => "PLAYING_SERVER",
+            Self::PlayingHostedServer => "PLAYING_HOSTED_SERVER",
+            Self::Offline => "OFFLINE",
+        }
+    }
+}
+
+/// `PresenceStatusDto`.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Presence {
+    pub id: u128,
+    pub status: PresenceStatus,
+}
+
+/// authlib's `FriendsListResponse` (`getFriends`/`updateFriends` body).
+pub fn parse_friends(body: &str) -> Option<FriendData> {
+    let v: Value = serde_json::from_str(body).ok()?;
+    Some(FriendData {
+        friends: parse_friend_list(v.get("friends")),
+        incoming: parse_friend_list(v.get("incomingRequests")),
+        outgoing: parse_friend_list(v.get("outgoingRequests")),
+    })
+}
+
+fn parse_friend_list(value: Option<&Value>) -> Vec<Friend> {
+    value
+        .and_then(|v| v.as_array())
+        .into_iter()
+        .flatten()
+        .filter_map(|friend| {
+            Some(Friend {
+                id: auth::parse_uuid(friend.get("profileId")?.as_str()?)?,
+                name: friend.get("name")?.as_str()?.to_owned(),
+            })
+        })
+        .collect()
+}
+
+/// authlib's `PresenceResponse`.
+pub fn parse_presence(body: &str) -> Option<Vec<Presence>> {
+    let v: Value = serde_json::from_str(body).ok()?;
+    Some(presence_of(&v))
+}
+
+/// `PresenceResponse.presence`: a missing list reads as empty, as Gson's null does.
+pub(super) fn presence_of(v: &Value) -> Vec<Presence> {
+    v.get("presence")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(|entry| {
+            let status = entry.get("status")?.as_str()?;
+            let status = match status {
+                "ONLINE" => PresenceStatus::Online,
+                "PLAYING_OFFLINE" => PresenceStatus::PlayingOffline,
+                "PLAYING_REALMS" => PresenceStatus::PlayingRealms,
+                "PLAYING_SERVER" => PresenceStatus::PlayingServer,
+                "PLAYING_HOSTED_SERVER" => PresenceStatus::PlayingHostedServer,
+                _ => PresenceStatus::Offline,
+            };
+            Some(Presence {
+                id: auth::parse_uuid(entry.get("profileId")?.as_str()?)?,
+                status,
+            })
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_friends_answer_reads_its_three_lists() {
+        let data = parse_friends(
+            r#"{"friends":[{"profileId":"0123456789abcdef0123456789abcdef","name":"Alex"}],
+                "incomingRequests":[],"outgoingRequests":[{"profileId":"fedcba9876543210fedcba9876543210","name":"Steve"}]}"#,
+        )
+        .unwrap();
+        assert_eq!(
+            data.friends,
+            vec![Friend {
+                id: 0x0123_4567_89ab_cdef_0123_4567_89ab_cdef,
+                name: "Alex".into()
+            }]
+        );
+        assert!(data.incoming.is_empty());
+        assert_eq!(data.outgoing[0].name, "Steve");
+        // The service's answer to an account with no friends, as the live check
+        // captured it: the three lists plus an `empty` flag the parser ignores.
+        let empty = parse_friends(
+            r#"{"empty":true,"friends":[],"incomingRequests":[],"outgoingRequests":[]}"#,
+        )
+        .unwrap();
+        assert_eq!(empty, FriendData::default());
+    }
+
+    #[test]
+    fn a_presence_answer_reads_each_status() {
+        let presence = parse_presence(
+            r#"{"presence":[
+                {"profileId":"0123456789abcdef0123456789abcdef","pmid":"00000000000000000000000000000000","status":"PLAYING_REALMS","lastUpdated":"2026-11-08T12:00:00Z"},
+                {"profileId":"fedcba9876543210fedcba9876543210","pmid":"00000000000000000000000000000000","status":"OFFLINE","lastUpdated":"2026-11-08T12:00:00Z"}]}"#,
+        )
+        .unwrap();
+        assert_eq!(presence[0].status, PresenceStatus::PlayingRealms);
+        assert_eq!(presence[1].status, PresenceStatus::Offline);
+        // `PresenceResponse` without its list is empty, not missing.
+        assert_eq!(parse_presence("{}"), Some(Vec::new()));
+        assert_eq!(parse_presence("not json"), None);
+    }
+}
@@ -127,6 +127,9 @@ pub struct Sprites {
    /// textures under their own names, and one layer serves them all (the GPU's array may
    /// hold as few as 2048).
    still: std::collections::HashMap<StillKey, u32>,
+    /// Names a connected-texture rule matches by name (`matchTiles`, `connectTiles`): each keeps a
+    /// layer of its own ([`Sprites::keep_apart`]).
+    apart: std::collections::HashSet<String>,
    /// Decoded textures kept on disk between launches ([`Sprites::with_disk_cache`]).
    disk: Option<crate::sprite_cache::SpriteCache>,
    /// Textures [`Sprites::prefetch`] decoded ahead of their insert, by sprite name or
@@ -218,6 +221,13 @@ impl Sprites {
            ..Self::default()
        }
    }
+    /// Keeps each of `names` on a layer of its own, never shared with an identical texture: the
+    /// connected-texture rules that name them find their faces by layer, so a texture sharing it
+    /// would be matched too (a tile a rule chains onto, and a model's transparent placeholder
+    /// with the same pixels). Before the textures that bear these names are inserted.
+    pub fn keep_apart(&mut self, names: impl IntoIterator<Item = String>) {
+        self.apart.extend(names);
+    }
    /// Write what this run decoded to the cache file.
    pub fn save_disk_cache(&mut self) {
        if let Some(disk) = &mut self.disk {
@@ -287,8 +297,13 @@ impl Sprites {
        let mut resized = Vec::with_capacity(self.native.len());
        self.pixels.clear();
        for (from, frames, initial) in &self.native {
-            let frames: Arc<Vec<Vec<u8>>> =
-                Arc::new(frames.iter().map(|f| resample(f, *from, size)).collect());
+            // Native frames already match the atlas size: share the immutable
+            // buffers with animations rather than copying every frame again.
+            let frames: Arc<Vec<Vec<u8>>> = if *from == size {
+                Arc::clone(frames)
+            } else {
+                Arc::new(frames.iter().map(|f| resample(f, *from, size)).collect())
+            };
            self.pixels.extend_from_slice(&frames[*initial]);
            resized.push(frames);
        }
@@ -686,23 +701,24 @@ impl Sprites {
                    .is_some_and(|(_, p)| p.starts_with("item/")),
            dither_cutouts: crate::mipmap::dither_cutouts(),
        };
-        let still = (animation.is_none() && frames.len() == 1).then(|| {
-            use std::hash::{Hash, Hasher};
-            let mut frame = std::collections::hash_map::DefaultHasher::new();
-            frames[0].hash(&mut frame);
-            let mut maps = std::collections::hash_map::DefaultHasher::new();
-            pbr.hash(&mut maps);
-            StillKey {
-                frame: frame.finish(),
-                pbr: maps.finish(),
-                side,
-                settings: [
-                    settings.strategy as u32,
-                    settings.alpha_cutoff_bias.to_bits(),
-                ],
-                flags: [settings.has_transparent, settings.item, opaque, translucent],
-            }
-        });
+        let still =
+            (animation.is_none() && frames.len() == 1 && !self.apart.contains(name)).then(|| {
+                use std::hash::{Hash, Hasher};
+                let mut frame = std::collections::hash_map::DefaultHasher::new();
+                frames[0].hash(&mut frame);
+                let mut maps = std::collections::hash_map::DefaultHasher::new();
+                pbr.hash(&mut maps);
+                StillKey {
+                    frame: frame.finish(),
+                    pbr: maps.finish(),
+                    side,
+                    settings: [
+                        settings.strategy as u32,
+                        settings.alpha_cutoff_bias.to_bits(),
+                    ],
+                    flags: [settings.has_transparent, settings.item, opaque, translucent],
+                }
+            });
        if let Some(&same) = still.as_ref().and_then(|k| self.still.get(k)) {
            self.layers.insert(name.to_owned(), same);
            return Ok(same);
@@ -872,6 +888,35 @@ mod tests {
    use super::*;
    use std::fs::{self, File};
    #[test]
+    fn native_frames_at_atlas_size_are_shared_without_resampling() {
+        let pixels = vec![
+            [10, 20, 30, 255].repeat((SPRITE_SIZE * SPRITE_SIZE) as usize),
+            [40, 50, 60, 255].repeat((SPRITE_SIZE * SPRITE_SIZE) as usize),
+        ];
+        let native = Arc::new(pixels.clone());
+        let smaller = Arc::new(vec![vec![12; 8 * 8 * 4], vec![34; 8 * 8 * 4]]);
+        let metadata = r#"{"frametime":2}"#;
+        let mut sprites = Sprites {
+            native: vec![
+                (SPRITE_SIZE, Arc::clone(&native), 1),
+                (8, Arc::clone(&smaller), 0),
+            ],
+            pbr: vec![[None, None], [None, None]],
+            animations: vec![
+                test_frames(0, pixels.clone(), metadata),
+                test_frames(1, smaller.as_ref().clone(), metadata),
+            ],
+            ..Default::default()
+        };
+        sprites.finish();
+        assert!(Arc::ptr_eq(&sprites.animations[0].frames, &native));
+        assert!(!Arc::ptr_eq(&sprites.animations[1].frames, &smaller));
+        assert_eq!(sprites.animations[0].pixels(1), pixels[1].as_slice());
+        let resized = resample(&smaller[0], 8, SPRITE_SIZE);
+        assert_eq!(sprites.animations[1].pixels(0), resized.as_slice());
+        assert_eq!(&sprites.pixels[..pixels[1].len()], pixels[1].as_slice());
+    }
+    #[test]
    fn the_texture_budget_picks_the_largest_side_that_fits() {
        // 1300 layers: vanilla's count, about.
        assert_eq!(side_within(512, 1300, DEFAULT_TEXTURE_BUDGET), 128);
@@ -1282,6 +1327,40 @@ mod tests {
        assert_eq!(sprites.pixels.len(), 3 * 16 * 16 * 4);
    }
    #[test]
+    fn a_texture_a_connected_rule_matches_keeps_a_layer_of_its_own() {
+        // A resource pack's transparent placeholders: a model's layer and a tile another
+        // connected-texture rule chains onto (`matchTiles=./19.png`) have the same pixels. The
+        // rule finds its faces by layer, so the one it names can't share the others'.
+        let root =
+            std::env::temp_dir().join(format!("horizon-sprite-apart-{}", std::process::id()));
+        let directory = root.join("assets/a/textures/block");
+        fs::create_dir_all(&directory).unwrap();
+        let write = |name: &str| {
+            let mut encoder =
+                png::Encoder::new(File::create(directory.join(name)).unwrap(), 16, 16);
+            encoder.set_color(png::ColorType::Rgba);
+            encoder.set_depth(png::BitDepth::Eight);
+            encoder
+                .write_header()
+                .unwrap()
+                .write_image_data(&[0; 16 * 16 * 4])
+                .unwrap();
+        };
+        for name in ["placeholder.png", "named.png", "again.png"] {
+            write(name);
+        }
+        let mut sprites = Sprites::default();
+        sprites.keep_apart(["a:block/named".to_owned()]);
+        let placeholder = sprites.insert(&root, "a:block/placeholder").unwrap();
+        let named = sprites.insert(&root, "a:block/named").unwrap();
+        let again = sprites.insert(&root, "a:block/again").unwrap();
+        fs::remove_dir_all(&root).unwrap();
+        // The named one alone; the others still share.
+        assert_ne!(named, placeholder);
+        assert_eq!(again, placeholder);
+        assert_eq!(sprites.count(), 2);
+    }
+    #[test]
    fn a_32px_only_atlas_does_not_add_an_extra_mipmap() {
        let mut sprites = Sprites {
            native: vec![
@@ -605,6 +605,9 @@ pub struct Streaming {
    /// Set while `update` runs, after it refreshed `cover`: nothing else can
    /// change `extra` meanwhile, so `cover` answers without comparing them.
    cover_current: bool,
+    /// `forced` and `mod_forced` as each column's distance to the nearest one, made again when
+    /// they change; read like `cover`, while `cover_current`.
+    forced_cover: Option<ForcedCover>,
    /// Mesh the sections for drawing (false on a server thread).
    pub mesh: bool,
    /// The pregeneration band (`set_band`).
@@ -806,6 +809,7 @@ impl GenerationScan {
                forced: input.ranges.forced,
                mod_forced: input.ranges.mod_forced,
                cover: input.ranges.cover,
+                forced_cover: None,
                band: input.ranges.band,
            };
            self.remember(ranges, input.world);
@@ -1066,8 +1070,10 @@ pub struct WorkerContext {
    pub light: Arc<LightTables>,
 }
 mod bounded;
+mod forced_cover;
 mod relight_now;
 use bounded::nearest_first;
+use forced_cover::ForcedCover;
 impl Streaming {
    pub fn new<G: ChunkGenerator>(
        generator: Arc<G>,
@@ -1176,6 +1182,7 @@ impl Streaming {
            extra: Vec::new(),
            cover: None,
            cover_current: false,
+            forced_cover: None,
            mesh: true,
            band: None,
            band_ranked: None,
@@ -1691,6 +1698,7 @@ impl Streaming {
        let mut columns = std::mem::take(&mut self.mesh_columns_scratch);
        columns.clear();
        ExtraCover::refresh(&mut self.cover, &self.extra);
+        ForcedCover::refresh(&mut self.forced_cover, &self.forced, &self.mod_forced);
        self.cover_current = true;
        // The sweeps below walk every loaded column and proto chunk. Run them
        // at once when the view moves and every eighth tick otherwise: a
@@ -1870,6 +1878,7 @@ impl Streaming {
                forced: &self.forced,
                mod_forced: &self.mod_forced,
                cover: ExtraCover::current(&self.cover, &self.extra, self.cover_current),
+                forced_cover: self.forced_cover.as_ref().filter(|_| self.cover_current),
                band: self.band.as_ref(),
            };
            let (protos, generating) = (&self.protos, &self.generating);
@@ -2040,6 +2049,7 @@ impl Streaming {
                forced: &self.forced,
                mod_forced: &self.mod_forced,
                cover: ExtraCover::current(&self.cover, &self.extra, self.cover_current),
+                forced_cover: self.forced_cover.as_ref().filter(|_| self.cover_current),
                band: self.band.as_ref(),
            };
            self.waiting.retain(|&(x, sy, z)| {
@@ -2145,6 +2155,7 @@ impl Streaming {
                forced: &self.forced,
                mod_forced: &self.mod_forced,
                cover: ExtraCover::current(&self.cover, &self.extra, self.cover_current),
+                forced_cover: self.forced_cover.as_ref().filter(|_| self.cover_current),
                band: self.band.as_ref(),
            },
            world,
@@ -2283,6 +2294,7 @@ impl Streaming {
            forced: &self.forced,
            mod_forced: &self.mod_forced,
            cover: ExtraCover::current(&self.cover, &self.extra, self.cover_current),
+            forced_cover: self.forced_cover.as_ref().filter(|_| self.cover_current),
            band: self.band.as_ref(),
        }
    }
@@ -2563,6 +2575,8 @@ struct Ranges<'a> {
    /// `extra` indexed by a grid or buckets: coverage queries without a
    /// scan of every area.
    cover: Option<&'a ExtraCover>,
+    /// `forced` and `mod_forced` by distance (`Streaming::forced_cover`), while they match it.
+    forced_cover: Option<&'a ForcedCover>,
    band: Option<&'a Band>,
 }
 /// The chunks a pregeneration task (`/pregen`) wants lit now: rows `z0..=z1`
@@ -2611,6 +2625,7 @@ impl Band {
            + i64::from(x - self.x0 + 8).max(0)
    }
 }
+
 /// For every column near the extra areas, how far it lies outside the
 /// nearest one's square (Chebyshev distance less its radius; 0 inside). A server has an area per player, and streaming asks of every
 /// loaded and wanted column whether one reaches it, several times a tick:
@@ -2918,16 +2933,6 @@ impl Ranges<'_> {
            .iter()
            .any(|&(c, radius)| (x - c.0).abs().max((z - c.1).abs()) <= radius + margin)
    }
-    /// Whether a `/forceload` or a native mod's ticket holds the chunk.
-    fn is_forced(&self, x: i32, z: i32) -> bool {
-        self.forced.contains(&(x, z)) || self.mod_forced.contains(&(x, z))
-    }
-    /// Every chunk a `/forceload` or a native mod's ticket holds, once each.
-    fn forced_chunks(&self) -> impl Iterator<Item = &(i32, i32)> + '_ {
-        self.forced
-            .iter()
-            .chain(self.mod_forced.iter().filter(|c| !self.forced.contains(c)))
-    }
    /// The columns meshed for drawing: those vanilla draws around the
    /// player (`in_view_distance`), and forced ones.
    fn in_view(&self, x: i32, z: i32) -> bool {
@@ -2939,18 +2944,7 @@ impl Ranges<'_> {
        if self.radius >= 0 && dx * dx + dz * dz <= r * r {
            return true;
        }
-        // A forced chunk holds a FORCED ticket at level 31
-        // (`ChunkMap.FORCED_TICKET_LEVEL`), and the level rises one per ring
-        // (`ChunkTracker.computeLevelFromNeighbor`): the margin is the
-        // vanilla status ring the caller asks for.
-        let reach = match margin {
-            1 => FORCED_FULL_RING,
-            2 => FORCED_FEATURES_RING,
-            3 => FORCED_TERRAIN_RING,
-            _ => margin + 1,
-        };
-        self.forced_chunks()
-            .any(|f| (x - f.0).abs() <= reach && (z - f.1).abs() <= reach)
+        self.near_forced(x, z, margin)
    }
 }
 impl Drop for Streaming {
@@ -3484,6 +3478,7 @@ mod tests {
            forced: &forced,
            mod_forced: &NO_CHUNKS,
            cover: None,
+            forced_cover: None,
            band: None,
        };
        let generate = |x, z, priority, order| Queued {
@@ -3724,6 +3719,7 @@ mod tests {
                    forced: &self.forced,
                    mod_forced: &NO_CHUNKS,
                    cover: None,
+                    forced_cover: None,
                    band: None,
                },
                world: &self.world,
@@ -4107,6 +4103,7 @@ mod tests {
                    forced: &forced,
                    mod_forced: &NO_CHUNKS,
                    cover: None,
+                    forced_cover: None,
                    band: None,
                };
                let square = |x: i32, z: i32, n: i32| {
@@ -4164,6 +4161,7 @@ mod tests {
                    forced: &forced,
                    mod_forced: &NO_CHUNKS,
                    cover: None,
+                    forced_cover: None,
                    band: None,
                };
                let span = radius * 3 + 20;
@@ -4201,6 +4199,7 @@ mod tests {
            forced: &forced,
            mod_forced: &NO_CHUNKS,
            cover: None,
+            forced_cover: None,
            band: None,
        };
        for x in -5i32..=15 {
@@ -4235,6 +4234,7 @@ mod tests {
                forced: &forced,
                mod_forced: &NO_CHUNKS,
                cover: None,
+                forced_cover: None,
                band: None,
            };
            let level = |x: i32, z: i32| 31 + ((x - 40).abs().max((z + 9).abs()) - view).max(0);
@@ -4290,6 +4290,7 @@ mod tests {
            forced: &forced,
            mod_forced: &NO_CHUNKS,
            cover: None,
+            forced_cover: None,
            band: None,
        };
        let level = |x: i32, z: i32| 31 + (x - 40).abs().max((z + 40).abs());
@@ -4430,6 +4431,7 @@ mod cover_tests {
                forced: &forced,
                mod_forced: &NO_CHUNKS,
                cover,
+                forced_cover: None,
                band: None,
            };
            let (scan, grid) = (ranges(None), ranges(Some(&cover)));
@@ -4473,6 +4475,7 @@ mod cover_tests {
                forced: &forced,
                mod_forced: &NO_CHUNKS,
                cover,
+                forced_cover: None,
                band: None,
            };
            let (scan, buckets) = (ranges(None), ranges(Some(&cover)));
@@ -4539,6 +4542,7 @@ mod cover_tests {
                forced: &forced,
                mod_forced: &NO_CHUNKS,
                cover,
+                forced_cover: None,
                band: None,
            };
            // The columns streaming asks about: everything kept, and the
@@ -0,0 +1,165 @@
+//! The chunks a `/forceload` or a native mod's ticket holds, as `Ranges` reads them, and their
+//! distance map.
+use super::{FORCED_FEATURES_RING, FORCED_FULL_RING, FORCED_TERRAIN_RING, Ranges};
+use crate::fast_hash::FxHashMap;
+use std::collections::HashSet;
+
+/// `Streaming::forced` and `mod_forced` as the Chebyshev distance from each column within
+/// `REACH` of one to the nearest: `Ranges::in_main_range` answers by one lookup instead of going
+/// through every forced chunk (it is asked for every column, several times a tick).
+pub(super) struct ForcedCover {
+    forced: HashSet<(i32, i32)>,
+    mod_forced: HashSet<(i32, i32)>,
+    near: FxHashMap<(i32, i32), u8>,
+}
+impl ForcedCover {
+    /// The widest ring `in_main_range` asks of a forced chunk (margins 1 to 4).
+    const REACH: i32 = FORCED_TERRAIN_RING + 1;
+    /// Past this many forced chunks the cover is not made: the scan answers.
+    const MOST: usize = 4096;
+    pub(super) fn refresh(
+        cover: &mut Option<Self>,
+        forced: &HashSet<(i32, i32)>,
+        mod_forced: &HashSet<(i32, i32)>,
+    ) {
+        if cover
+            .as_ref()
+            .is_some_and(|c| c.forced == *forced && c.mod_forced == *mod_forced)
+        {
+            return;
+        }
+        if forced.len() + mod_forced.len() > Self::MOST {
+            *cover = None;
+            return;
+        }
+        let mut near = FxHashMap::default();
+        for &(fx, fz) in forced.iter().chain(mod_forced) {
+            for dx in -Self::REACH..=Self::REACH {
+                for dz in -Self::REACH..=Self::REACH {
+                    let d = dx.abs().max(dz.abs()) as u8;
+                    near.entry((fx + dx, fz + dz))
+                        .and_modify(|e: &mut u8| *e = (*e).min(d))
+                        .or_insert(d);
+                }
+            }
+        }
+        *cover = Some(Self {
+            forced: forced.clone(),
+            mod_forced: mod_forced.clone(),
+            near,
+        });
+    }
+    /// Whether a forced chunk lies within `reach` of `(x, z)`, or `None` past `REACH`.
+    pub(super) fn within(&self, x: i32, z: i32, reach: i32) -> Option<bool> {
+        (reach <= Self::REACH).then(|| {
+            self.near
+                .get(&(x, z))
+                .is_some_and(|&d| i32::from(d) <= reach)
+        })
+    }
+}
+
+impl Ranges<'_> {
+    /// Whether a `/forceload` or a native mod's ticket holds the chunk.
+    pub(super) fn is_forced(&self, x: i32, z: i32) -> bool {
+        self.forced.contains(&(x, z)) || self.mod_forced.contains(&(x, z))
+    }
+    /// Every chunk a `/forceload` or a native mod's ticket holds, once each.
+    pub(super) fn forced_chunks(&self) -> impl Iterator<Item = &(i32, i32)> + '_ {
+        self.forced
+            .iter()
+            .chain(self.mod_forced.iter().filter(|c| !self.forced.contains(c)))
+    }
+    /// `in_main_range` past the player's circle: whether a forced chunk lies within the ring
+    /// `margin` asks for.
+    pub(super) fn near_forced(&self, x: i32, z: i32, margin: i32) -> bool {
+        // A forced chunk holds a FORCED ticket at level 31
+        // (`ChunkMap.FORCED_TICKET_LEVEL`), and the level rises one per ring
+        // (`ChunkTracker.computeLevelFromNeighbor`): the margin is the
+        // vanilla status ring the caller asks for.
+        let reach = match margin {
+            1 => FORCED_FULL_RING,
+            2 => FORCED_FEATURES_RING,
+            3 => FORCED_TERRAIN_RING,
+            _ => margin + 1,
+        };
+        if let Some(hit) = self.forced_cover.and_then(|c| c.within(x, z, reach)) {
+            return hit;
+        }
+        self.forced_chunks()
+            .any(|f| (x - f.0).abs() <= reach && (z - f.1).abs() <= reach)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn chunks(seed: &mut u64, n: usize, spread: i32) -> HashSet<(i32, i32)> {
+        let mut next = |m: i32| {
+            *seed ^= *seed << 13;
+            *seed ^= *seed >> 7;
+            *seed ^= *seed << 17;
+            (*seed % (2 * m as u64 + 1)) as i32 - m
+        };
+        (0..n).map(|_| (next(spread), next(spread))).collect()
+    }
+
+    /// With the forced chunks by distance, every column gets the answer the scan of every forced
+    /// chunk gives, at every margin streaming asks (and those past the map's reach), after the
+    /// forced chunks change too.
+    #[test]
+    fn the_distances_answer_as_the_scan() {
+        let mut seed = 0x2545_F491_4F6C_DD1Du64;
+        let mut cover = None;
+        for case in 0..24 {
+            let spread = [3, 12, 40][case % 3];
+            let forced = chunks(&mut seed, 1 + case % 9, spread);
+            // Some mod tickets on forced chunks, some apart.
+            let mut mod_forced = chunks(&mut seed, case % 4, spread);
+            mod_forced.extend(forced.iter().take(case % 2));
+            ForcedCover::refresh(&mut cover, &forced, &mod_forced);
+            let made = cover.as_ref().expect("a few forced chunks get a map");
+            let ranges = |forced_cover| Ranges {
+                // The player's circle far away: only the forced chunks answer.
+                center: (10_000, 10_000),
+                radius: 2,
+                extra: &[],
+                forced: &forced,
+                mod_forced: &mod_forced,
+                cover: None,
+                forced_cover,
+                band: None,
+            };
+            let (scan, map) = (ranges(None), ranges(Some(made)));
+            let span = spread + 10;
+            for z in -span..=span {
+                for x in -span..=span {
+                    for margin in 0..=7 {
+                        assert_eq!(
+                            map.in_main_range(x, z, margin),
+                            scan.in_main_range(x, z, margin),
+                            "case {case} ({x}, {z}) margin {margin}"
+                        );
+                    }
+                    for d in [false, true] {
+                        assert_eq!(map.requested(x, z, d), scan.requested(x, z, d));
+                        assert_eq!(map.chunk_kept(x, z, d), scan.chunk_kept(x, z, d));
+                        assert_eq!(map.unloaded(x, z, d), scan.unloaded(x, z, d));
+                    }
+                }
+            }
+        }
+    }
+
+    /// Too many forced chunks for a map: none is made, and the scan answers.
+    #[test]
+    fn past_the_most_no_map_is_made() {
+        let forced: HashSet<(i32, i32)> = (0..=ForcedCover::MOST as i32).map(|x| (x, 0)).collect();
+        let mut cover = None;
+        ForcedCover::refresh(&mut cover, &HashSet::new(), &HashSet::from([(0, 0)]));
+        assert!(cover.is_some());
+        ForcedCover::refresh(&mut cover, &forced, &HashSet::new());
+        assert!(cover.is_none());
+    }
+}
@@ -524,8 +524,18 @@ fn packed_corner(lo: vec3<u32>, hi: vec3<u32>, corner: u32) -> ArenaCorner {
    let packed_light = ((light & 63u) << 2u) | (((light >> 6u) & 63u) << 10u);
    let g = (lo.y >> (8u * corner)) & 255u;
    let t = lo.x;
+    // Corners 1 to 3's own alpha (`packed::ALPHA_STEP` times the code; 0: word 0's).
+    var code = 0u;
+    if corner == 1u {
+        code = (hi.x >> 28u) & 7u;
+    } else if corner == 2u {
+        code = (hi.y >> 24u) & 7u;
+    } else if corner == 3u {
+        code = (hi.y >> 27u) & 7u;
+    }
+    let alpha = select((code * 51u) << 24u, t & 0xff000000u, code == 0u);
    let color = (g * ((t >> 16u) & 255u) / 255u) | ((g * ((t >> 8u) & 255u) / 255u) << 8u)
-        | ((g * (t & 255u) / 255u) << 16u) | (t & 0xff000000u);
+        | ((g * (t & 255u) / 255u) << 16u) | alpha;
    return ArenaCorner(bitcast<vec3<u32>>(vec3<f32>(pos)),
        vec3((u << 10u) | (v << 26u), (hi.x & 0xffffu) | (packed_light << 16u), color));
 }
@@ -955,13 +965,13 @@ const PI: f32 = 3.14159265;
 fn disc_distance(d: vec3<f32>, y: f32) -> vec2<f32> {
    if d.y * y <= 0.0 { return vec2(-1.0); }
    let p = d * (y / d.y);
-    let h = length(p.xz);
-    let phi = atan2(p.z, p.x);
-    let sector = PI / 4.0;
-    let delta = phi - (floor(phi / sector) * sector + sector * 0.5);
-    let edge = 512.0 * cos(sector * 0.5) / cos(delta);
-    if h > edge { return vec2(-1.0); }
-    let s = h / edge;
+    // The regular octagon's edge parameter, directly from its half planes.
+    // max(|x| + tan(pi/8)*|z|, |z| + tan(pi/8)*|x|) / radius
+    // equals length(p.xz) / edge without atan2, floor or cos per pixel.
+    let a = abs(p.xz);
+    let diagonal = 0.41421356237309503;
+    let s = max(a.x + diagonal * a.y, a.y + diagonal * a.x) / 512.0;
+    if s > 1.0 { return vec2(-1.0); }
    let ay = abs(y);
    let rim = sqrt(512.0 * 512.0 + y * y);
    return vec2(ay + s * (rim - ay), ay + s * (512.0 - ay));
@@ -14,6 +14,8 @@ pub enum Cursor {
    Arrow,
    PointingHand,
    NotAllowed,
+    /// `CursorTypes.RESIZE_NS`: a scroller held vertically (`MerchantScreen`).
+    ResizeNs,
 }

 thread_local! {
@@ -1,4 +1,13 @@
 {
+  "horizon.no_resources.title": "No prepared game files",
+  "horizon.no_resources.prepare": "Prepare them with horizon-prepare --prepare, or pass --resources <folder>.",
+  "horizon.no_resources.looked_in": "No prepared game files in %s",
+  "horizon.no_resources.quit": "Quit",
+  "horizon.get_the_game.title": "Start Horizon from the launcher",
+  "horizon.get_the_game.about": "This is the game the Horizon launcher installs and starts. On its own it has none of Minecraft's files, so it can't start.",
+  "horizon.get_the_game.minecraft": "Horizon needs your own copy of Minecraft: Java Edition. The launcher signs you in and prepares the game files from it.",
+  "horizon.get_the_game.download": "Download the launcher at %s, then press Play there.",
+  "horizon.get_the_game.button": "Download the launcher",
  "horizon.extras.header.world": "World",
  "horizon.extras.pregen": "Chunk pregeneration",
  "horizon.extras.pregen.tooltip": "Enables /pregen in your single-player and LAN worlds. With cheats enabled, use /pregen start to generate an area before exploring it. Does not enable the command on servers you join.",
@@ -11,6 +20,18 @@
  "horizon.options.gameplay_guide.basic": "Basic",
  "horizon.options.gameplay_guide.full": "Full",
  "horizon.options.gameplay_guide.off": "Off",
+  "horizon.options.radial_mode": "Radial Menu",
+  "horizon.options.radial_mode.about": "Hold the opener for the radial menu, or press it once to open it and again to close it.",
+  "horizon.options.radial_mode.hold.about": "Hold the opener and let go to run what the stick points at.",
+  "horizon.options.radial_mode.toggle.about": "Press the opener to open it; A or the opener again runs what the stick points at, B closes it.",
+  "horizon.options.radial_stick": "Radial Menu Selects With",
+  "horizon.options.radial_stick.about": "The stick that points at the radial menu's slots.",
+  "horizon.options.radial_stick.right": "Right Stick",
+  "horizon.options.radial_stick.left": "Left Stick",
+  "horizon.options.radial_stick.either": "Either",
+  "horizon.options.radial_stick.right.about": "The right stick points at the slots; the left still walks.",
+  "horizon.options.radial_stick.left.about": "The left stick points and you stand still. D-pad Right is under that thumb: pick an opener on the Radial Menu page.",
+  "horizon.options.radial_stick.either.about": "The last stick pushed points; neither walks nor turns the view. Only a bumper, a trigger or View can open the menu.",
  "horizon.controller.guide.use": "Use",
  "horizon.controller.guide.open": "Open",
  "horizon.controller.guide.ride": "Ride",
@@ -129,6 +150,82 @@
  "horizon.pages.shader_options": "Shader Options",
  "horizon.pages.controller": "Controller Settings",
  "horizon.pages.controller_binds": "Controller Binds",
+  "horizon.pages.controller_radial": "Radial Menu",
+  "horizon.radial.page.general": "General",
+  "horizon.radial.page.camera": "Camera",
+  "horizon.radial.release_stick": "Let go of the stick",
+  "horizon.radial.action.key_inventory": "Inventory",
+  "horizon.radial.action.key_chat": "Chat",
+  "horizon.radial.action.key_command": "Commands",
+  "horizon.radial.action.key_advancements": "Advancements",
+  "horizon.radial.action.key_togglePerspective": "Perspective",
+  "horizon.radial.action.key_swapOffhand": "Swap Hands",
+  "horizon.radial.action.key_drop": "Drop",
+  "horizon.radial.action.key_pickItem": "Pick Block",
+  "horizon.radial.action.key_screenshot": "Screenshot",
+  "horizon.radial.action.key_toggleGui": "Hide HUD",
+  "horizon.radial.action.key_smoothCamera": "Cinematic Camera",
+  "horizon.radial.action.key_socialInteractions": "Social",
+  "horizon.radial.action.key_emote": "Emote",
+  "horizon.radial.action.pad_hotbarPrevious": "Previous Slot",
+  "horizon.radial.action.pad_hotbarNext": "Next Slot",
+  "horizon.radial.action.key_fullscreen": "Fullscreen",
+  "horizon.radial.action.key_quickActions": "Quick Actions",
+  "horizon.radial.action.key_debug_overlay": "Debug Screen",
+  "horizon.radial.missing": "Missing",
+  "horizon.radial.why.missing": "Unknown action",
+  "horizon.radial.why.cosmetics": "Needs cosmetics on",
+  "horizon.radial.why.quick_actions": "This server has no Quick Actions",
+  "horizon.radial.why.social": "Only on a server",
+  "horizon.radial.next": "→ %s",
+  "horizon.radial.state.first_person": "First Person",
+  "horizon.radial.state.third_person_back": "Third Person",
+  "horizon.radial.state.third_person_front": "Front View",
+  "horizon.radial.state.shown": "Shown",
+  "horizon.radial.state.hidden": "Hidden",
+  "horizon.radial.state.on": "On",
+  "horizon.radial.state.off": "Off",
+  "horizon.radial.pick_title": "Choose an Action",
+  "horizon.radial.group.actions": "Actions",
+  "horizon.radial.pick.slot": "%s slot of %s",
+  "horizon.radial.pick.about": "Puts this action in the slot and goes back. The slot's own is marked.",
+  "horizon.radial.pick.current": "Current",
+  "horizon.radial.missing.about": "This game doesn't know the action %s: the slot keeps it and runs nothing. Press or Right to put another here.",
+  "horizon.radial.page.new": "New Page",
+  "horizon.pages.open.controller_radial": "Radial Menu...",
+  "horizon.radial.group.slots": "Slots",
+  "horizon.radial.group.page": "Page",
+  "horizon.radial.group.all": "All Pages",
+  "horizon.radial.empty": "Empty",
+  "horizon.radial.page_of": "Page %s of %s. Each slot is a direction of the selecting stick while the opener is held.",
+  "horizon.radial.slot.0": "Up",
+  "horizon.radial.slot.1": "Up-Right",
+  "horizon.radial.slot.2": "Right",
+  "horizon.radial.slot.3": "Down-Right",
+  "horizon.radial.slot.4": "Down",
+  "horizon.radial.slot.5": "Down-Left",
+  "horizon.radial.slot.6": "Left",
+  "horizon.radial.slot.7": "Up-Left",
+  "horizon.radial.slot.about": "The action this direction runs. Press it for the list of actions, Right for the next one, Left or Shift-click for the one before.",
+  "horizon.radial.rename": "Rename Page",
+  "horizon.radial.rename.about": "Give this page a name of your own.",
+  "horizon.radial.name_title": "Name This Page",
+  "horizon.radial.new_page.about": "Adds an empty page after the last one, and shows it.",
+  "horizon.radial.new_page.full": "The menu holds at most %s pages.",
+  "horizon.radial.delete_page": "Delete Page",
+  "horizon.radial.delete_page.about": "Removes this page and its slots at once. Undo brings it back.",
+  "horizon.radial.delete_page.last": "The menu keeps at least one page.",
+  "horizon.radial.reset": "Reset All Pages",
+  "horizon.radial.reset.about": "Puts back the General and Camera pages and removes the rest, at once. Undo brings them back.",
+  "horizon.radial.reset.default": "The pages are the defaults already.",
+  "horizon.radial.opener": "Opener",
+  "horizon.radial.opener.about": "The button held to open the menu. Press, then press the controller button to use: a bumper or the D-pad, not A, B, X, Y or the right stick, which steer and cancel.",
+  "horizon.radial.opener.about.left": "The button held to open the menu. Press, then press the controller button to use: a bumper, A, X or Y, not the D-pad or the left stick, which steer, nor B, which cancels.",
+  "horizon.radial.opener.about.either": "The button held to open the menu. Press, then press the controller button to use: a bumper, a trigger or View; both thumbs steer, and B cancels.",
+  "horizon.radial.unbound": "No button opens the menu (one under the thumb that selects is let go): press, then press a controller button.",
+  "horizon.radial.conflict": "Shared with another action: in play the menu takes that button. Press to pick another.",
+  "Radial Menu": "Radial Menu",
+  "Named pages of eight actions, held open with a button.": "Named pages of eight actions, held open with a button.",
  "horizon.pages.extras": "Horizon Extras",
  "horizon.pages.settings": "Horizon Settings",
  "horizon.pages.studio": "Replay Studio",
@@ -442,7 +539,7 @@
  "HDR Calibration %s/%s: %s": "HDR Calibration %s/%s: %s",
  "Sets the three below full screen, one test picture at a time.": "Sets the three below full screen, one test picture at a time.",
  "Your display didn't say how bright it gets: calibrate to set it up.": "Your display didn't say how bright it gets: calibrate to set it up.",
-  "Your display's reported peak is often too high: calibrate to set it up.": "Your display's reported peak is often too high: calibrate to set it up.",
+  "Auto uses the peak Windows reports. Calibrate if highlights look clipped.": "Auto uses the peak Windows reports. Calibrate if highlights look clipped.",
  "Already set up for your display. Only calibrate if HDR looks wrong.": "Already set up for your display. Only calibrate if HDR looks wrong.",
  "Puts Peak Brightness and Paper White back to your display's setup.": "Puts Peak Brightness and Paper White back to your display's setup.",
  "Set up for your display. Leave on Auto unless it looks wrong.": "Set up for your display. Leave on Auto unless it looks wrong.",
@@ -1020,6 +1117,7 @@
  "Press the button for this. %s cancels.": "Press the button for this. %s cancels.",
  "This button also does: %s": "This button also does: %s",
  "Not bound: press this row, then the button that should do it.": "Not bound: press this row, then the button that should do it.",
+  "horizon.pad.action.radial": "Radial Menu",
  "horizon.pad.notice.connected.press": "Press to use it",
  "horizon.recipe_transfer.missing": "Missing Items",
  "horizon.recipe_transfer.no_room": "Inventory full",
@@ -1989,13 +1989,13 @@ mod tests {
    }
    /// The criteria an inventory change and a recipe unlock test, on vanilla's tree:
    /// `cargo test -p horizon-client --lib -- --ignored --nocapture index_on_vanilla_tree`
-    /// with HORIZON_RESOURCES set to the prepared resources.
+    /// with HORIZON_TEST_RESOURCES set to the prepared resources.
    #[test]
-    #[ignore = "needs the prepared resources"]
+    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
    fn index_on_vanilla_tree() {
-        let Some(root) = std::env::var_os("HORIZON_RESOURCES").map(std::path::PathBuf::from) else {
-            return;
-        };
+        let root = std::path::PathBuf::from(
+            std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"),
+        );
        let data = root.join("data");
        let t = std::time::Instant::now();
        let tree = Tree::load(&data);
@@ -274,8 +274,8 @@ impl ArrowState {
    /// `Arrow.getColor` of the server's own arrow: the colour of the potion on
    /// its pickup item, None for a plain arrow (`PotionContents.EMPTY`).
    pub fn potion_color(&self) -> Option<u32> {
-        let potion = self.pickup_item.potion()?;
-        Some(crate::brewing::potion_color(Some(potion)))
+        (!crate::brewing::contents_empty(&self.pickup_item))
+            .then(|| crate::brewing::contents_color(&self.pickup_item))
    }
    /// The `AbstractArrow` constructor's `pickupItemStack`: the drawn ammo
    /// (one item). Ammo drawn without being used up (`INTANGIBLE_PROJECTILE`)
@@ -85,6 +85,7 @@ pub mod join_seq;
 pub mod lan;
 pub mod landing;
 pub mod legacy_combat;
+pub mod living_death;
 pub mod locator_bar;
 pub mod lod_net;
 pub mod menu;
@@ -26,8 +26,9 @@ pub struct Tab {
    /// The page of tabs it is on: vanilla's are 0, mods' after, as NeoForge
    /// pages them.
    pub page: u32,
-    /// A Polytone creative tab modifier's `name`: its text and colour, over the tab's own.
-    pub name: Option<(String, Option<u32>)>,
+    /// A Polytone creative tab modifier's `name`: its text (a translation key when
+    /// the flag is set) and colour, over the tab's own.
+    pub name: Option<(String, Option<u32>, bool)>,
 }
 impl Tab {
    /// The tab without its stacks.
@@ -103,25 +104,28 @@ pub struct Creative {
    /// The packs' Polytone creative tab modifiers, applied by `rebuild`.
    pack: Vec<crate::polytone_creative_tabs::TabModifier>,
 }
-/// A text component's plain text and its colour (a name, or `#rrggbb`).
-fn component_text(json: &Value) -> (String, Option<u32>) {
+/// A text component's text, its colour (a name, or `#rrggbb`) and whether the
+/// text is a `translate` key, to be resolved when drawn.
+fn component_text(json: &Value) -> (String, Option<u32>, bool) {
    match json {
-        Value::String(s) => (s.clone(), None),
+        Value::String(s) => (s.clone(), None, false),
        Value::Object(o) => {
+            let translate = o.get("translate").and_then(Value::as_str);
            let text = o
                .get("text")
-                .or_else(|| o.get("translate"))
                .and_then(Value::as_str)
+                .or(translate)
                .unwrap_or("")
                .to_owned();
+            let translate = o.get("text").is_none() && translate.is_some();
            let color = o.get("color").and_then(Value::as_str).and_then(|c| {
                c.strip_prefix('#')
                    .and_then(|hex| u32::from_str_radix(hex, 16).ok())
                    .or_else(|| crate::text::named_color(c))
            });
-            (text, color)
+            (text, color, translate)
        }
-        _ => (String::new(), None),
+        _ => (String::new(), None, false),
    }
 }
 /// The grid's stacks for one tab, search text and language.
@@ -912,6 +916,16 @@ impl Creative {
        let y = if tab.top { -28.0 } else { Self::HEIGHT - 4.0 };
        (x, y)
    }
+    /// `CreativeModeInventoryScreen.checkTabHovering`: the tab whose icon
+    /// rectangle, 3 pixels in from its 26x32 slot (`isHovering(x + 3, y + 3,
+    /// 21, 27)`), holds the cursor. The screen draws its display name.
+    pub fn hovered_tab(tabs: &[Tab], origin: (f32, f32), cursor: (f32, f32)) -> Option<usize> {
+        tabs.iter().position(|tab| {
+            let (x, y) = Self::tab_position(tab);
+            let (x, y) = (origin.0 + x + 3.0, origin.1 + y + 3.0);
+            cursor.0 >= x && cursor.0 < x + 21.0 && cursor.1 >= y && cursor.1 < y + 27.0
+        })
+    }
    /// `CreativeModeInventoryScreen.extractTabButton`'s cursor: an unselected
    /// tab asks for the pointing hand when the whole-pixel mouse, relative to
    /// the screen origin, is strictly inside its 26x32 button.
@@ -1789,4 +1803,21 @@ mod tests {
        assert!(c.tab_headers().is_empty());
        assert_eq!(c.search_tab(), None);
    }
+
+    /// `CreativeModeInventoryScreen.checkTabHovering`: the 3-pixel inset of a
+    /// tab's 26x32 slot (21x27) is the hover area whose name the screen shows.
+    #[test]
+    fn only_a_tabs_inset_icon_is_hovered() {
+        let screen = tooltip_tabs();
+        let tab = &screen.tabs[0];
+        let (x, y) = Creative::tab_position(tab);
+        let at =
+            |dx: f32, dy: f32| Creative::hovered_tab(&screen.tabs, (0.0, 0.0), (x + dx, y + dy));
+        assert_eq!(at(4.0, 4.0), Some(0));
+        assert_eq!(at(23.5, 4.0), Some(0));
+        assert_eq!(at(2.0, 4.0), None);
+        assert_eq!(at(24.0, 4.0), None);
+        assert_eq!(at(4.0, 2.0), None);
+        assert_eq!(at(4.0, 30.0), None);
+    }
 }