Merge pull request #15050 from DUzzL/fix/15047-portpack-placeholder

port-pack: accept a lone placeholder mod id template
Merge pull request #15064 from ilguerro/fix/zombie-fire-aspect-rules
2026-11-11 17:19:31 -10:00 · 2026-11-11 22:12:46 +00:00 · 2026-11-11 22:12:41 +00:00 · 2026-11-11 22:12:36 +00:00 · 2026-11-11 22:12:30 +00:00 · 2026-11-11 22:12:24 +00:00
610 changed files with 28768 additions and 5124 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
@@ -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
@@ -35,7 +37,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 +48,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 +120,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.
@@ -103,8 +128,8 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 ## Build and test fast

 ```sh
-python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
-python3 tools/pr_ready.py --quick          # same without harnesses
+python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests; paste its block in the PR
+python3 tools/pr_ready.py --harnesses      # also the affected harnesses (by default only when you change a harness, oracle, probe or the runner, as in CI)
 cargo test -p horizon-client -p horizon-client-lib --lib --bins --tests   # skips the examples (pr_ready does this); `--doc` separately
 cargo test -p horizon-client-lib --lib mod_content::tests:: -- --ignored   # the slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
 cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
@@ -113,7 +138,8 @@ python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cov
 python3 tools/parity.py mob_ai sculk       # named harnesses
 python3 tools/lan_e2e.py --check chest     # two real games over LAN (server-thread host)
 python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
-python3 tools/lang_coverage.py --summary   # the keys each language still misses, and its English leftovers
+python3 tools/lang_coverage.py --summary   # one line per language: how many keys it carries and what it misses
+python3 tools/lang_coverage.py --summary --show-keys   # the same, then the keys behind the counts
 ```

 - Harnesses and the game need the vanilla data in `.local/` (`minecraft/`, `horizon-client/26.3`, `datagen/`,
@@ -152,7 +178,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 +242,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.
@@ -117,9 +109,10 @@ python3 tools/pr_ready.py --base upstream/main   # or origin/main if you work on
 ```

 It looks at what your branch changes and runs what matters: rustfmt, clippy with warnings denied, the tests of the
-crates you touched (and the launcher's), generated files, `Cargo.lock`, the Python tests, and the vanilla harnesses
-your change can affect. Without the vanilla data on your machine it lists those harnesses instead; CI runs them.
-`--quick` skips the harnesses. It exits non-zero when something fails.
+crates you touched (and the launcher's), generated files, `Cargo.lock` and the Python tests. Like CI, it runs the
+vanilla harnesses only when your branch changes a harness, an oracle, a probe or the runner; otherwise it lists the
+ones your change can affect, and main's parity run checks them after the merge. `--harnesses` runs them on your
+machine anyway (it needs the vanilla data). It exits non-zero when something fails.

 For the game workspace, Clippy checks all targets of the touched crates and their transitive workspace dependents,
 including examples. The dependency scope includes optional, platform, build and development dependencies. Tests run
@@ -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",
@@ -530,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 |
@@ -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,
 }
@@ -271,15 +271,31 @@ fn int_array(tag: Option<&Tag>) -> Option<&Vec<i32>> {
 fn is_pos(tag: &Tag) -> bool {
    matches!(tag, Tag::IntArray(v) if v.len() == 3)
 }
+/// The default `SignText`: four empty lines, black, not glowing.
+fn empty_sign_side() -> Tag {
+    Tag::compound([
+        ("messages", Tag::List(vec![string(""); 4])),
+        ("color", string("black")),
+        ("has_glowing_text", boolean(false)),
+    ])
+}
 /// The loaded `SignText` of one side, or the empty text.
 pub fn sign_side(tag: Option<&Tag>) -> Tag {
-    let empty = || string("");
-    let mut messages: Vec<Tag> = match tag.and_then(|t| t.get("messages")) {
-        Some(Tag::List(list)) => list.iter().filter_map(component).collect(),
-        _ => Vec::new(),
+    // `SignText.DIRECT_CODEC`: `messages` is a component list (an entry that
+    // fails is dropped, `ListCodec`'s partial result) cut to 4 lines by
+    // `Util.fixedSize`. Fewer than 4 valid lines fail the side, and
+    // `SignBlockEntity.loadAdditional` then loads an empty one; more keep the
+    // first 4 with the side's colour and glow.
+    let lines: Option<Vec<Tag>> = match tag.and_then(|t| t.get("messages")) {
+        Some(Tag::List(list)) => {
+            let lines: Vec<Tag> = list.iter().filter_map(component).take(4).collect();
+            (lines.len() == 4).then_some(lines)
+        }
+        _ => None,
+    };
+    let Some(messages) = lines else {
+        return empty_sign_side();
    };
-    messages.resize_with(4, empty);
-    messages.truncate(4);
    let mut out = vec![
        ("messages", Tag::List(messages)),
        (
@@ -957,6 +973,32 @@ mod tests {
        assert_eq!(structure.get("showboundingbox"), Some(&Tag::Byte(1)));
    }

+    #[test]
+    fn sign_side_needs_exactly_four_messages() {
+        let ok = snbt("{messages:[\"a\",\"\",\"\",\"\"],color:\"red\",has_glowing_text:1b}");
+        let side = sign_side(Some(&ok));
+        assert_eq!(side.get("color"), Some(&string("red")));
+        // A fifth line, or a bad entry among five, leaves the first 4 valid
+        // lines with the colour (checked against the 26.3 codec).
+        for kept in [
+            "{messages:[\"a\",\"\",\"\",\"\",\"e\"],color:\"red\",has_glowing_text:1b}",
+            "{messages:[\"a\",1,\"\",\"\",\"\"],color:\"red\",has_glowing_text:1b}",
+        ] {
+            let side = sign_side(Some(&snbt(kept)));
+            assert_eq!(side.get("messages"), ok.get("messages"), "{kept}");
+            assert_eq!(side.get("color"), Some(&string("red")), "{kept}");
+        }
+        for bad in [
+            "{color:\"red\",has_glowing_text:1b}",
+            "{messages:[\"a\",\"b\"],color:\"red\",has_glowing_text:1b}",
+            "{messages:[\"a\",\"\",\"\",1],color:\"red\",has_glowing_text:1b}",
+        ] {
+            let side = sign_side(Some(&snbt(bad)));
+            assert_eq!(side, sign_side(None), "{bad}");
+            assert_eq!(side.get("color"), Some(&string("black")));
+        }
+    }
+
    #[test]
    fn canonical_is_idempotent() {
        for id in TYPES.iter().chain(NEWEST.iter()) {
@@ -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 {
@@ -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}"),
@@ -356,6 +356,12 @@ impl KeyBinds {
    pub fn is_default(&self, name: &str) -> bool {
        self.get(name) == Self::default_of(name)
    }
+    /// `KeyBindsScreen.extractRenderState`: Reset All is active only while a
+    /// mapping differs from its default (`KeyMapping.isDefault`, the bound key
+    /// against `defaultKey`).
+    pub fn changed_from_defaults(&self) -> bool {
+        self.keys.keys().any(|name| !self.is_default(name))
+    }
    pub fn set(&mut self, name: &str, key: &str) {
        if let Some((n, _, _)) = all_mappings().find(|m| m.0 == name) {
            self.keys.insert(n, key.to_owned());
@@ -645,6 +651,22 @@ mod tests {
        assert_eq!(k.translate_all(KeyCode::Digit9), [Ok(KeyCode::Digit9)]);
        assert_eq!(k.translate_all(KeyCode::F3), [Ok(KeyCode::F3)]);
    }
+
+    /// `KeyBindsScreen.extractRenderState`: Reset All is active only while a
+    /// binding differs from its default.
+    #[test]
+    fn reset_all_is_active_only_after_a_binding_moves() {
+        let mut keys = KeyBinds::default();
+        assert!(!keys.changed_from_defaults());
+        keys.set("key.attack", "key.mouse.right");
+        assert!(keys.changed_from_defaults());
+        // Setting a mapping back to its own default leaves nothing to reset.
+        keys.set("key.attack", KeyBinds::default_of("key.attack"));
+        assert!(!keys.changed_from_defaults());
+        keys.set("key.jump", "key.keyboard.z");
+        keys.reset_all();
+        assert!(!keys.changed_from_defaults());
+    }
    #[test]
    fn display_names() {
        assert_eq!(display_name("key.keyboard.w").plain(), "W");
@@ -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);
+    }
 }
@@ -15,7 +15,7 @@ use crate::{
    font::{Font, Glyph},
    gfx::mark_oit,
    hud::Rect,
-    mesher::{CULL_BACK, Vertex},
+    mesher::{CULL_BACK, Vertex, cull_back},
    models::load_visibility,
    signs::{self, SignData, SignText},
    text::{Style, Text},
@@ -3093,9 +3093,9 @@ impl BlockEntityRenderer {
                    }
                }
                // `DecoratedPotRenderer` submits every part with `entitySolid`, which culls
-                // back faces: the flat `top` and `bottom` planes show one side each.
+                // back faces: the flat `top` and `bottom` planes show one side each (#15322).
                for vertex in &mut out[first..] {
-                    vertex.normal = CULL_BACK;
+                    vertex.normal = cull_back(vertex.normal);
                }
            }
            Kind::EndPortal => {
@@ -4760,9 +4760,12 @@ mod tests {
            28,
            "the pot submits all of vanilla's quads"
        );
+        // A part the shader shades keeps its normal (#15322): `w` alone says cull.
        assert!(
-            verts.iter().all(|v| v.normal == CULL_BACK),
-            "entitySolid culls the pot's back faces"
+            verts
+                .iter()
+                .all(|v| v.normal[3] == crate::mesher::SHADED_CULL_W && v.normal[..3] != [0; 3]),
+            "entitySolid culls the pot's back faces and shades it by its normals"
        );
    }

@@ -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);
+    }
 }
@@ -4,6 +4,7 @@
 use horizon_core::paletted::{PalettedContainer, Strategy};
 use horizon_world::nbt::{Compound, Tag};
 use horizon_world::registry::BlockStateId;
+use std::sync::atomic::{AtomicI16, AtomicU64, Ordering};
 use std::sync::{Arc, OnceLock};

 pub mod block_entity;
@@ -457,6 +458,44 @@ impl Light {
        }
    }
 }
+/// One of a chunk's heightmaps (`Chunk::surface`): the heights, built whole on the first read,
+/// and the columns a write may have moved since, each found again on its next read. Reads share
+/// the chunk (helper threads read the world): a stale column is found the same by any of them.
+#[derive(Default)]
+struct Heights {
+    heights: OnceLock<Box<[AtomicI16; 256]>>,
+    stale: [AtomicU64; 4],
+}
+impl Heights {
+    /// `Heightmap.update`: a write two or more below column `i`'s height can't move it; any
+    /// other marks the column.
+    fn write(&mut self, i: usize, y: i32) {
+        let Some(heights) = self.heights.get_mut() else {
+            return;
+        };
+        let stale = self.stale[i >> 6].get_mut();
+        if *stale & 1 << (i & 63) == 0 && y >= i32::from(*heights[i].get_mut()) - 1 {
+            *stale |= 1 << (i & 63);
+        }
+    }
+}
+impl Clone for Heights {
+    fn clone(&self) -> Self {
+        let copy = Self::default();
+        // A reader can refresh a height and then clear its stale bit while we clone. Copy the
+        // bits first: a stale snapshot will rescan; a clean one acquires the refreshed height.
+        // Copying heights first could keep an old height with a newly cleared bit.
+        for (to, from) in copy.stale.iter().zip(&self.stale) {
+            to.store(from.load(Ordering::Acquire), Ordering::Relaxed);
+        }
+        if let Some(heights) = self.heights.get() {
+            let _ = copy.heights.set(Box::new(std::array::from_fn(|i| {
+                AtomicI16::new(heights[i].load(Ordering::Relaxed))
+            })));
+        }
+        copy
+    }
+}
 #[inline]
 fn column(x: i32, z: i32) -> usize {
    ((z & 15) << 4 | (x & 15)) as usize
@@ -574,10 +613,10 @@ pub struct Chunk {
    pub sections: Vec<Arc<Section>>,
    /// `Heightmap.Types.WORLD_SURFACE` per column (`z << 4 | x`): one above
    /// the highest non-air block, or the column's minimum Y. Built on the first read; a
-    /// `set` that can move a column's surface drops it.
-    surface: OnceLock<Box<[i16; 256]>>,
+    /// `set` that can move a column's surface marks that column, found again on its next read.
+    surface: Heights,
    /// `Heightmap.Types.MOTION_BLOCKING` per column, kept like `surface`.
-    motion_blocking: OnceLock<Box<[i16; 256]>>,
+    motion_blocking: Heights,
    pub lit: bool,
    /// Light read from a save with `isLightOn`: no light job is needed.
    pub light_loaded: bool,
@@ -618,8 +657,8 @@ impl Chunk {
            z,
            min_y: layout.min_y(),
            sections: (0..layout.sections()).map(|_| empty.clone()).collect(),
-            surface: OnceLock::new(),
-            motion_blocking: OnceLock::new(),
+            surface: Heights::default(),
+            motion_blocking: Heights::default(),
            lit: false,
            light_loaded: false,
            fresh: false,
@@ -698,12 +737,7 @@ impl Chunk {
        // move it. Any other change rebuilds that map on the next read.
        if previous != v {
            for map in [&mut self.surface, &mut self.motion_blocking] {
-                if map
-                    .get()
-                    .is_some_and(|heights| y >= i32::from(heights[column(x, z)]) - 1)
-                {
-                    *map = OnceLock::new();
-                }
+                map.write(column(x, z), y);
            }
        }
        previous
@@ -714,24 +748,55 @@ impl Chunk {
        let section = Arc::make_mut(&mut self.sections[s]);
        section.blocks = Section::from_blocks(values);
        section.compact();
-        self.surface = OnceLock::new();
-        self.motion_blocking = OnceLock::new();
+        self.surface = Heights::default();
+        self.motion_blocking = Heights::default();
    }
    /// `getHeight(Heightmap.Types.WORLD_SURFACE, x, z)` (`x`, `z` within the
    /// chunk): one above the highest block that isn't `air`, or the column's
    /// minimum Y.
    /// Sections must change only through `set` once this has been read.
    pub fn world_surface(&self, x: i32, z: i32, air: impl Fn(u32) -> bool) -> i32 {
-        let surface = self.surface.get_or_init(|| self.prime(|v| !air(v)));
-        i32::from(surface[column(x, z)])
+        self.height(&self.surface, x, z, |v| !air(v))
    }
    /// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)` (`x`, `z` within
    /// the chunk): one above the highest state where `blocks` (a motion
    /// blocking block or a fluid), or the column's minimum Y. Kept as
    /// `world_surface` is.
    pub fn motion_blocking(&self, x: i32, z: i32, blocks: impl Fn(u32) -> bool) -> i32 {
-        let heights = self.motion_blocking.get_or_init(|| self.prime(blocks));
-        i32::from(heights[column(x, z)])
+        self.height(&self.motion_blocking, x, z, blocks)
+    }
+    /// One column's height in `map`: the whole map built on its first read, a column a write
+    /// marked found again down that column alone.
+    fn height(&self, map: &Heights, x: i32, z: i32, counts: impl Fn(u32) -> bool) -> i32 {
+        let heights = map.heights.get_or_init(|| {
+            let built = self.prime(&counts);
+            Box::new(std::array::from_fn(|i| AtomicI16::new(built[i])))
+        });
+        let i = column(x, z);
+        let (word, bit) = (i >> 6, 1u64 << (i & 63));
+        if map.stale[word].load(Ordering::Acquire) & bit != 0 {
+            let height = self.column_height(i, &counts);
+            heights[i].store(height, Ordering::Relaxed);
+            map.stale[word].fetch_and(!bit, Ordering::Release);
+            return i32::from(height);
+        }
+        i32::from(heights[i].load(Ordering::Relaxed))
+    }
+    /// [`Self::prime`] for column `i` alone.
+    fn column_height(&self, i: usize, counts: impl Fn(u32) -> bool) -> i16 {
+        for (s, section) in self.sections.iter().enumerate().rev() {
+            if section.blocks.uniform().is_some_and(|v| !counts(v)) {
+                continue;
+            }
+            let base = self.min_y + s as i32 * 16;
+            if let Some(dy) = (0..16)
+                .rev()
+                .find(|&dy| counts(section.blocks.get(dy << 8 | i)))
+            {
+                return (base + dy as i32 + 1) as i16;
+            }
+        }
+        self.min_y as i16
    }
    /// `Heightmap.primeHeightmaps`: each section from the top, skipping
    /// those of one state that doesn't count, until every column is found.
@@ -797,7 +862,7 @@ impl Chunk {
            + self.sections.capacity() * std::mem::size_of::<Arc<Section>>();
        census.heightmap_bytes += [&self.surface, &self.motion_blocking]
            .iter()
-            .filter(|map| map.get().is_some())
+            .filter(|map| map.heights.get().is_some())
            .count()
            * std::mem::size_of::<[i16; 256]>();
        for section in &self.sections {
@@ -1020,9 +1085,89 @@ mod tests {
        let before = chunk.world_surface(3, 3, is_air);
        chunk.set(3, MIN_Y + HEIGHT, 3, stone);
        chunk.set(3, before - 1, 3, chunk.get(3, before - 1, 3));
-        assert!(chunk.surface.get().is_some());
+        assert!(chunk.surface.heights.get().is_some());
        assert_eq!(chunk.world_surface(3, 3, |_| unreachable!()), before);
    }
+    /// A write two below a column's height can't move it, so the next read asks about no block;
+    /// a write at or above it (placing on top, clearing the top block) is found again on the next
+    /// read by looking down that column alone, and the other columns keep their heights.
+    #[test]
+    fn a_write_finds_its_own_column_again() {
+        // Each column holds its own state (16 + i), so a read that looks at another column's
+        // blocks shows up as a state that isn't air or this column's.
+        let state = |i: usize| 16 + i as u32;
+        let mut chunk = Chunk::empty(0, 0);
+        for i in 0..256 {
+            for y in MIN_Y..MIN_Y + 20 + (i as i32 % 7) {
+                chunk.set(i as i32 & 15, y, i as i32 >> 4, state(i));
+            }
+        }
+        let seen = std::cell::RefCell::new(Vec::new());
+        let surface = |c: &Chunk, i: usize| {
+            c.world_surface(i as i32 & 15, i as i32 >> 4, |v| {
+                seen.borrow_mut().push(v);
+                v == 0
+            })
+        };
+        let heights: Vec<i32> = (0..256).map(|i| surface(&chunk, i)).collect();
+        assert_eq!(heights[0], MIN_Y + 20);
+        assert_eq!(heights[6], MIN_Y + 26);
+        seen.borrow_mut().clear();
+
+        let (column, x, z) = (0x35, 5, 3);
+        let top = heights[column];
+        // Two below the height: the column keeps its map entry.
+        chunk.set(x, top - 2, z, 0);
+        assert_eq!(surface(&chunk, column), top);
+        assert!(seen.borrow().is_empty());
+        chunk.set(x, top - 2, z, state(column));
+
+        // At the height: placed on top, found again down this column only.
+        chunk.set(x, top, z, state(column));
+        assert_eq!(surface(&chunk, column), top + 1);
+        assert!(!seen.borrow().is_empty());
+        assert!(seen.borrow().iter().all(|&v| v == 0 || v == state(column)));
+        seen.borrow_mut().clear();
+        assert_eq!(surface(&chunk, column), top + 1);
+        for i in (0..256).filter(|&i| i != column) {
+            assert_eq!(surface(&chunk, i), heights[i]);
+        }
+        assert!(
+            seen.borrow().is_empty(),
+            "a read found again an untouched column"
+        );
+
+        // One below the height: the top block cleared, the height drops by one.
+        chunk.set(x, top, z, 0);
+        assert_eq!(surface(&chunk, column), top);
+        assert!(seen.borrow().iter().all(|&v| v == 0 || v == state(column)));
+    }
+    /// Chunk snapshots can be cloned while helper threads refresh a stale height. No snapshot
+    /// may retain the old height with its stale bit cleared, for either map.
+    #[test]
+    fn cloning_during_a_height_refresh_keeps_the_new_height() {
+        for _ in 0..4096 {
+            let mut chunk = Chunk::empty(0, 0);
+            chunk.set(0, MIN_Y + 4, 0, 1);
+            assert_eq!(chunk.world_surface(0, 0, |v| v == 0), MIN_Y + 5);
+            assert_eq!(chunk.motion_blocking(0, 0, |v| v != 0), MIN_Y + 5);
+            chunk.set(0, MIN_Y + 5, 0, 1);
+            let ready = std::sync::Barrier::new(2);
+            std::thread::scope(|scope| {
+                scope.spawn(|| {
+                    ready.wait();
+                    assert_eq!(chunk.world_surface(0, 0, |v| v == 0), MIN_Y + 6);
+                    assert_eq!(chunk.motion_blocking(0, 0, |v| v != 0), MIN_Y + 6);
+                });
+                ready.wait();
+                for _ in 0..4 {
+                    let snapshot = chunk.clone();
+                    assert_eq!(snapshot.world_surface(0, 0, |v| v == 0), MIN_Y + 6);
+                    assert_eq!(snapshot.motion_blocking(0, 0, |v| v != 0), MIN_Y + 6);
+                }
+            });
+        }
+    }
    /// MOTION_BLOCKING ignores states that don't count (air, grass) and
    /// follows writes as the surface map does, both maps kept at once.
    #[test]
@@ -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)]
@@ -4,11 +4,13 @@
 //!
 //! The pack's GLSL (26.3's `#include` or the older `#moj_import`, with explicit locations or
 //! without) is written again as the Vulkan-flavoured GLSL 450 naga reads:
+//! - GLSL vanilla's GL compiler takes and naga doesn't is rewritten first ([`glsl_fixups`]: a
+//!   helper taking the `sampler2D` it reads, an array sized by its initializer only);
 //! - includes are inlined, each file once (as `GlslPreprocessor` imported them), from `include`;
 //! - vanilla's uniform blocks get the bindings of [`BLOCKS`], and each of [`SAMPLERS`] is split
 //!   into a texture and a sampler object, combined again where the sampler is named;
 //! - the vertex inputs become globals the caller's [`Glue`] fills before the pack's `main`
-//!   (renamed `hz_main`) runs, and `gl_VertexID` reads the glue's expression;
+//!   (renamed `hz_main`) runs, and `gl_VertexID` and `gl_VertexIndex` read the glue's expression;
 //! - varyings get locations by name across the stages, the fragment output location 0.

 use std::collections::HashSet;
@@ -18,6 +20,8 @@ use naga::ShaderStage;
 use naga::front::glsl::{Frontend, Options};
 use naga::valid::{Capabilities, ValidationFlags, Validator};

+mod glsl_fixups;
+
 /// Vanilla's uniform blocks (`shaders/include/*.glsl`) and their bindings in set 0.
 pub const BLOCKS: [(&str, u32); 4] = [
    ("Globals", 0),
@@ -43,7 +47,7 @@ pub struct Glue<'a> {
    pub setup: &'a str,
    /// Statements after it, on `gl_Position`.
    pub finish: &'a str,
-    /// The expression `gl_VertexID` reads.
+    /// The expression the pack's `gl_VertexID` and `gl_VertexIndex` read.
    pub vertex_id: &'a str,
 }

@@ -64,8 +68,8 @@ pub fn translate_core(
    glue: &Glue,
 ) -> Result<CoreProgram, String> {
    const CORE: &str = "minecraft:shaders/core/";
-    let vertex_text = strip_comments(&expand(vertex, CORE, include)?);
-    let fragment_text = strip_comments(&expand(fragment, CORE, include)?);
+    let vertex_text = glsl_fixups::fixups(&strip_comments(&expand(vertex, CORE, include)?));
+    let fragment_text = glsl_fixups::fixups(&strip_comments(&expand(fragment, CORE, include)?));
    let mut names = Names::default();
    let vertex_code = rewrite(&vertex_text, ShaderStage::Vertex, glue, &mut names)
        .map_err(|e| format!("vertex shader: {e}"))?;
@@ -337,6 +341,8 @@ fn rewrite(
            writeln!(out, "{ty} {name};").unwrap();
        }
    }
+    // Where the pack's own code starts: the glue above it is left as it is.
+    let pack_start = out.len();
    let mut outputs: Vec<&str> = Vec::new();
    for source_line in text.lines() {
        for line in declaration_lines(source_line) {
@@ -462,11 +468,18 @@ fn rewrite(
    if !vertex {
        return Ok(out);
    }
-    let mut code = replace_ident(
-        &rename_main(&out),
-        "gl_VertexID",
-        &format!("({})", glue.vertex_id),
+    // The pack's `gl_VertexID` and 26.3's `gl_VertexIndex` both mean vanilla's vertex number
+    // (four per quad, an `int`): both read the glue's expression, which for a pipeline that
+    // draws six vertices per quad turns its own `gl_VertexIndex` back into that number. Only the
+    // pack's code is rewritten, so the glue's expression keeps reading the real index.
+    let vertex_id = format!("({})", glue.vertex_id);
+    let pack = replace_ident(
+        &rename_main(&out[pack_start..]),
+        "gl_VertexIndex",
+        &vertex_id,
    );
+    let pack = replace_ident(&pack, "gl_VertexID", &vertex_id);
+    let mut code = format!("{}{pack}", &out[..pack_start]);
    write!(
        code,
        "void main() {{\n{}\nhz_main();\n{}\n}}\n",
@@ -633,6 +646,43 @@ mod tests {
        assert_eq!(program.fragment.entry_points.len(), 1);
    }

+    /// A 26.3 pack's `gl_VertexIndex` means vanilla's vertex number, four per quad. The text
+    /// pipeline draws six per glyph, so the pack's code must read the glue's `hz_vertex_id()`
+    /// (as `gl_VertexID` does), never the raw index.
+    #[test]
+    fn a_packs_gl_vertex_index_reads_the_glues_vertex_number() {
+        let vsh = "#version 330\n#include <minecraft:dynamictransforms.glsl>\n#include <minecraft:projection.glsl>\n\
+            in vec3 Position;\nin vec4 Color;\nin vec2 UV0;\nout vec4 vertexColor;\nout vec2 texCoord0;\n\
+            void main() {\n    int corner = gl_VertexIndex % 4;\n\
+                gl_Position = ProjMat * ModelViewMat * vec4(Position + vec3(float(corner), 0.0, 0.0), 1.0);\n\
+                vertexColor = Color;\n    texCoord0 = UV0;\n}\n";
+        let program = translate_core(vsh, VANILLA_FSH, &["IS_GUI"], &include, &GLUE).unwrap();
+        let module = &program.vertex;
+        let named = |name: &str| {
+            module
+                .functions
+                .iter()
+                .find(|(_, f)| f.name.as_deref() == Some(name))
+                .unwrap_or_else(|| panic!("no {name}"))
+        };
+        let (vertex_id, _) = named("hz_vertex_id");
+        let (_, pack_main) = named("hz_main");
+        fn calls(block: &naga::Block, target: naga::Handle<naga::Function>) -> bool {
+            block.iter().any(|statement| match statement {
+                naga::Statement::Call { function, .. } => *function == target,
+                naga::Statement::Block(inner) => calls(inner, target),
+                naga::Statement::If { accept, reject, .. } => {
+                    calls(accept, target) || calls(reject, target)
+                }
+                naga::Statement::Loop {
+                    body, continuing, ..
+                } => calls(body, target) || calls(continuing, target),
+                _ => false,
+            })
+        }
+        assert!(calls(&pack_main.body, vertex_id));
+    }
+
    /// A 26.2-style pack shader as a HUD pack writes it: `#moj_import`, no locations, a flat
    /// varying, `gl_VertexID`, `texelFetch` and `textureSize` on the glyph atlas, `GameTime`.
    #[test]
@@ -0,0 +1,603 @@
+//! GLSL that vanilla's GL compiler takes and naga's front end doesn't (#9386), rewritten into
+//! what both take:
+//! - a function with `sampler2D` parameters is copied once per set of samplers its callers pass
+//!   (all of them a shader's global samplers), the copy reading those samplers by name;
+//! - an unsized array (`const float[] w = float[](...)`, `float w[] = ...`) takes the size its
+//!   initializer gives.
+
+/// The longest shader rewritten (vanilla's, includes expanded, are a few KiB).
+const MAX_LEN: usize = 64 * 1024;
+
+/// The bytes the rewrite may scan for calls (the whole text per call it rewrites): thousands of
+/// calls leave the text as it was rather than freeze a load.
+const SCAN_BUDGET: usize = 64 << 20;
+
+/// `text` with the rewrites, where they apply; anything they can't follow is left as it was.
+pub(super) fn fixups(text: &str) -> String {
+    if text.len() > MAX_LEN {
+        return text.to_owned();
+    }
+    size_unsized_arrays(&specialize_sampler_params(text))
+}
+
+fn is_ident(c: char) -> bool {
+    c.is_ascii_alphanumeric() || c == '_'
+}
+
+/// A name a sampler can have (`sampler2D ;` gives none, `t[2]` isn't one).
+fn is_name(s: &str) -> bool {
+    s.chars().all(is_ident) && s.starts_with(|c: char| !c.is_ascii_digit()) && s != "sampler2D"
+}
+
+/// The identifier that ends right before byte `end` (whitespace skipped), and where it starts.
+fn ident_before(text: &str, end: usize) -> Option<(usize, &str)> {
+    let trimmed = text[..end].trim_end();
+    let start = trimmed
+        .char_indices()
+        .rev()
+        .take_while(|(_, c)| is_ident(*c))
+        .last()?
+        .0;
+    let ident = &trimmed[start..];
+    (!ident.is_empty() && !ident.starts_with(|c: char| c.is_ascii_digit()))
+        .then_some((start, ident))
+}
+
+/// For each byte of `text`, the byte of the bracket closing the one opening there (counting
+/// that kind of bracket only), or `None`: one pass, so a scan asking for many stays linear.
+fn closings(text: &str) -> Vec<Option<usize>> {
+    let mut out = vec![None; text.len()];
+    let mut open: [Vec<usize>; 3] = Default::default();
+    for (i, b) in text.bytes().enumerate() {
+        let (kind, opens) = match b {
+            b'(' => (0, true),
+            b')' => (0, false),
+            b'[' => (1, true),
+            b']' => (1, false),
+            b'{' => (2, true),
+            b'}' => (2, false),
+            _ => continue,
+        };
+        if opens {
+            open[kind].push(i);
+        } else if let Some(at) = open[kind].pop() {
+            out[at] = Some(i);
+        }
+    }
+    out
+}
+
+/// The comma-separated parts of `list` at its own nesting level.
+fn split_top(list: &str) -> Vec<&str> {
+    let mut parts = Vec::new();
+    let (mut depth, mut start) = (0i32, 0);
+    for (i, c) in list.char_indices() {
+        match c {
+            '(' | '[' | '{' => depth += 1,
+            ')' | ']' | '}' => depth -= 1,
+            ',' if depth == 0 => {
+                parts.push(&list[start..i]);
+                start = i + 1;
+            }
+            _ => {}
+        }
+    }
+    if !list[start..].trim().is_empty() || !parts.is_empty() {
+        parts.push(&list[start..]);
+    }
+    parts
+}
+
+/// A function at the file's top level whose parameters include a `sampler2D`.
+struct SamplerFn {
+    name: String,
+    /// The header from its return type to its `{` (or `;` for a prototype), and the body after.
+    start: usize,
+    end: usize,
+    params: Vec<String>,
+    /// The indices of the `sampler2D` parameters and their names.
+    samplers: Vec<(usize, String)>,
+    /// `None` for a prototype.
+    body: Option<String>,
+    return_type: String,
+}
+
+fn sampler_functions(text: &str) -> Vec<SamplerFn> {
+    let closing = closings(text);
+    let mut out = Vec::new();
+    let mut depth = 0i32;
+    let bytes = text.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'{' => depth += 1,
+            b'}' => depth -= 1,
+            b'(' if depth == 0 => {
+                if let (Some((name_at, name)), Some(close)) = (ident_before(text, i), closing[i])
+                    && let Some((type_at, return_type)) = ident_before(text, name_at)
+                {
+                    let params: Vec<String> = split_top(&text[i + 1..close])
+                        .into_iter()
+                        .map(|p| p.trim().to_owned())
+                        .collect();
+                    let samplers: Vec<(usize, String)> = params
+                        .iter()
+                        .enumerate()
+                        .filter(|(_, p)| p.split_whitespace().any(|w| w == "sampler2D"))
+                        .map(|(n, p)| (n, p.split_whitespace().last().unwrap_or("").to_owned()))
+                        .collect();
+                    // One without a name is left for naga to refuse.
+                    if !samplers.iter().all(|(_, name)| is_name(name)) {
+                        i = close + 1;
+                        continue;
+                    }
+                    let after = text[close + 1..].trim_start();
+                    let next = close + 1 + (text[close + 1..].len() - after.len());
+                    if !samplers.is_empty() && (after.starts_with('{') || after.starts_with(';')) {
+                        let (end, body) = if after.starts_with('{') {
+                            let Some(body_end) = closing[next] else {
+                                break;
+                            };
+                            (body_end + 1, Some(text[next..=body_end].to_owned()))
+                        } else {
+                            (next + 1, None)
+                        };
+                        out.push(SamplerFn {
+                            name: name.to_owned(),
+                            start: type_at,
+                            end,
+                            params,
+                            samplers,
+                            body,
+                            return_type: return_type.to_owned(),
+                        });
+                        i = end;
+                        continue;
+                    }
+                }
+                // Any other header: no other one sits in its parentheses.
+                if let Some(close) = closing[i] {
+                    i = close + 1;
+                    continue;
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    out
+}
+
+/// The calls to `name` outside `skip` (its own header): each call's span and arguments. The
+/// bytes read are added to `scanned`.
+fn calls<'a>(
+    scanned: &std::cell::Cell<usize>,
+    text: &'a str,
+    name: &str,
+    skip: &[(usize, usize)],
+) -> Vec<(usize, usize, Vec<&'a str>)> {
+    scanned.set(scanned.get() + text.len());
+    let closing = closings(text);
+    let mut out = Vec::new();
+    let mut from = 0;
+    while let Some(found) = text[from..].find(name) {
+        let at = from + found;
+        from = at + name.len();
+        let before = text[..at].chars().next_back();
+        let rest = &text[at + name.len()..];
+        let open = at + name.len() + (rest.len() - rest.trim_start().len());
+        if before.is_some_and(is_ident)
+            || !text[open..].starts_with('(')
+            || skip.iter().any(|(s, e)| (*s..*e).contains(&at))
+        {
+            continue;
+        }
+        let Some(close) = closing[open] else {
+            continue;
+        };
+        scanned.set(scanned.get() + close - open);
+        out.push((at, close + 1, split_top(&text[open + 1..close])));
+    }
+    out
+}
+
+/// Every `from` standing as an identifier on its own, but not a member after a `.` (a
+/// parameter `s` leaves the swizzle `c.s` alone).
+fn replace_ident(text: &str, from: &str, to: &str) -> String {
+    if from.is_empty() {
+        return text.to_owned();
+    }
+    let mut out = String::with_capacity(text.len());
+    let mut done = 0;
+    while let Some(found) = text[done..].find(from) {
+        let at = done + found;
+        // Read in the whole text: a match right after another (`ss`) is part of it.
+        let before = text[..at].trim_end().chars().next_back();
+        let joined = text[..at].chars().next_back().is_some_and(is_ident);
+        let after = text[at + from.len()..].chars().next();
+        out.push_str(&text[done..at]);
+        if joined || before == Some('.') || after.is_some_and(is_ident) {
+            out.push_str(from);
+        } else {
+            out.push_str(to);
+        }
+        done = at + from.len();
+    }
+    out.push_str(&text[done..]);
+    out
+}
+
+/// A body with its sampler parameters reading `chosen`, all at once: a parameter named like
+/// another's sampler (`mix2(sampler2D Sampler0, sampler2D Sampler1)` called with them swapped)
+/// still reads its own.
+fn read_samplers(body: &str, params: &[(usize, String)], chosen: &[String]) -> String {
+    let mut body = body.to_owned();
+    for (n, (_, param)) in params.iter().enumerate() {
+        body = replace_ident(&body, param, &format!("hz_sampler_param_{n}"));
+    }
+    for (n, sampler) in chosen.iter().enumerate().take(params.len()) {
+        body = replace_ident(&body, &format!("hz_sampler_param_{n}"), sampler);
+    }
+    body
+}
+
+/// The byte after `uniform sampler2D <name>;`, where the shader declares that sampler.
+fn sampler_declaration_end(text: &str, name: &str) -> Option<usize> {
+    let mut from = 0;
+    while let Some(found) = text[from..].find("sampler2D") {
+        let at = from + found;
+        from = at + "sampler2D".len();
+        let before = text[..at].trim_end();
+        if !before.ends_with("uniform")
+            || before[..before.len() - 7]
+                .chars()
+                .next_back()
+                .is_some_and(is_ident)
+        {
+            continue;
+        }
+        let rest = &text[from..];
+        let ident = rest.trim_start();
+        let len = ident.chars().take_while(|c| is_ident(*c)).count();
+        if &ident[..len] != name {
+            continue;
+        }
+        let after = ident[len..].trim_start();
+        if after.starts_with(';') {
+            return Some(text.len() - after.len() + 1);
+        }
+    }
+    None
+}
+
+/// The samplers a call passes for `f`'s `sampler2D` parameters, in order.
+fn chosen_samplers(f: &SamplerFn, args: &[&str]) -> Vec<String> {
+    f.samplers
+        .iter()
+        .filter_map(|(n, _)| args.get(*n).map(|a| a.trim().to_owned()))
+        .collect()
+}
+
+/// One pass per function with `sampler2D` parameters, until none is left or one can't be
+/// followed (a caller passes something that is no sampler's name).
+fn specialize_sampler_params(original: &str) -> String {
+    let mut text = original.to_owned();
+    // Bytes scanned for calls so far, against [`SCAN_BUDGET`].
+    let scanned = std::cell::Cell::new(0usize);
+    let spent = || scanned.get() > SCAN_BUDGET;
+    for _ in 0..16 {
+        let functions = sampler_functions(&text);
+        // From the outside in: no call inside another function still to be copied.
+        let inside_another = |f: &SamplerFn, at: usize| {
+            functions
+                .iter()
+                .any(|g| g.name != f.name && g.body.is_some() && (g.start..g.end).contains(&at))
+        };
+        let spans_of = |f: &SamplerFn| -> Vec<(usize, usize)> {
+            functions
+                .iter()
+                .filter(|g| g.name == f.name)
+                .map(|g| (g.start, g.end))
+                .collect()
+        };
+        let Some(f) = functions.iter().find(|f| {
+            f.body.is_some()
+                && !spent()
+                && calls(&scanned, &text, &f.name, &spans_of(f))
+                    .iter()
+                    .all(|(at, ..)| !inside_another(f, *at))
+        }) else {
+            if spent() {
+                break;
+            }
+            // None left to copy.
+            return text;
+        };
+        let spans = spans_of(f);
+        let found = calls(&scanned, &text, &f.name, &spans);
+        // Each call's samplers must be plain names (a global's, or a later pass's parameter).
+        let mut variants: Vec<Vec<String>> = Vec::new();
+        let mut call_starts: Vec<usize> = Vec::new();
+        let mut followable = true;
+        for (at, _, args) in &found {
+            let chosen = chosen_samplers(f, args);
+            if chosen.len() != f.samplers.len() || !chosen.iter().all(|a| is_name(a)) {
+                followable = false;
+                break;
+            }
+            call_starts.push(*at);
+            if !variants.contains(&chosen) {
+                variants.push(chosen);
+            }
+            if variants.len() > 64 {
+                followable = false;
+                break;
+            }
+        }
+        // Overloads (`tap(sampler2D, vec2)` and `tap(sampler2D, vec3)`) each keep their own
+        // body; a call picks its samplers by position, so they must sit at the same places.
+        let same_places = functions.iter().filter(|g| g.name == f.name).all(|g| {
+            g.samplers
+                .iter()
+                .map(|s| s.0)
+                .eq(f.samplers.iter().map(|s| s.0))
+        });
+        if !followable || !same_places || spent() {
+            break;
+        }
+        // A body may call another overload of itself with its own sampler (vanilla's
+        // `sampleNearest` calls the six-argument one): once its sampler parameters read a
+        // sampler, those calls name that copy too, and their sets join the variants.
+        let rewrite_own_calls = |body: &str| -> Option<(String, Vec<Vec<String>>)> {
+            let mut body = body.to_owned();
+            let mut found = Vec::new();
+            let mut starts: Vec<usize> = calls(&scanned, &body, &f.name, &[])
+                .iter()
+                .map(|c| c.0)
+                .collect();
+            starts.sort_unstable_by(|a, b| b.cmp(a));
+            for start in starts {
+                if spent() {
+                    return None;
+                }
+                let (end, chosen, with) = {
+                    let (_, end, args) = calls(&scanned, &body, &f.name, &[])
+                        .into_iter()
+                        .find(|c| c.0 == start)?;
+                    let chosen = chosen_samplers(f, &args);
+                    let rest: Vec<&str> = args
+                        .iter()
+                        .enumerate()
+                        .filter(|(n, _)| !f.samplers.iter().any(|(s, _)| s == n))
+                        .map(|(_, a)| a.trim())
+                        .collect();
+                    let with = format!("{}_hz_{}({})", f.name, chosen.join("_"), rest.join(", "));
+                    (end, chosen, with)
+                };
+                if chosen.len() != f.samplers.len() || !chosen.iter().all(|a| is_name(a)) {
+                    return None;
+                }
+                found.push(chosen);
+                body.replace_range(start..end, &with);
+            }
+            Some((body, found))
+        };
+        let specialize = |g: &SamplerFn, chosen: &[String]| {
+            let body = read_samplers(g.body.as_deref().unwrap_or_default(), &g.samplers, chosen);
+            rewrite_own_calls(&body)
+        };
+        let same: Vec<&SamplerFn> = functions.iter().filter(|g| g.name == f.name).collect();
+        let mut next = 0;
+        while followable && next < variants.len() {
+            let chosen = variants[next].clone();
+            for g in same.iter().filter(|g| g.body.is_some()) {
+                match specialize(g, &chosen) {
+                    Some((_, inner)) => {
+                        for v in inner {
+                            if !variants.contains(&v) {
+                                variants.push(v);
+                            }
+                        }
+                    }
+                    None => followable = false,
+                }
+            }
+            next += 1;
+            followable &= variants.len() <= 64 && !spent();
+        }
+        if !followable {
+            break;
+        }
+        // One copy of an overload per set of samplers its callers pass, keeping its other
+        // parameters; a prototype becomes the copies' prototypes.
+        let signature = |g: &SamplerFn, chosen: &[String]| {
+            let params: Vec<&str> = g
+                .params
+                .iter()
+                .enumerate()
+                .filter(|(n, _)| !g.samplers.iter().any(|(s, _)| s == n))
+                .map(|(_, p)| p.as_str())
+                .collect();
+            format!(
+                "{} {}_hz_{}({})",
+                g.return_type,
+                g.name,
+                chosen.join("_"),
+                params.join(", ")
+            )
+        };
+        let copies_of = |g: &SamplerFn| -> String {
+            variants
+                .iter()
+                .map(|chosen| match &g.body {
+                    Some(_) => {
+                        let body = specialize(g, chosen).map(|(b, _)| b).unwrap_or_default();
+                        format!("{} {body}\n", signature(g, chosen))
+                    }
+                    None => format!("{};\n", signature(g, chosen)),
+                })
+                .collect()
+        };
+        // Rebuild from the back: the calls, then the function's own spans (each prototype and
+        // definition becomes its copies). A call nested in another's arguments starts after it,
+        // so it is rewritten first, and the call around it is read again from the text as it is
+        // then. A copy reads its samplers by name, so definitions above their samplers'
+        // declaration (vanilla's `sample_lightmap.glsl` is included above `uniform sampler2D
+        // Sampler2;`) move after it, together and in their order, as long as no call comes first.
+        let first_call = call_starts.iter().copied().min().unwrap_or(usize::MAX);
+        let declared = variants
+            .iter()
+            .flatten()
+            .filter_map(|s| sampler_declaration_end(&text, s))
+            .max();
+        let mut edits: Vec<(usize, Option<(usize, String)>)> =
+            call_starts.into_iter().map(|at| (at, None)).collect();
+        let (mut moved, mut move_to) = (String::new(), None);
+        for g in &same {
+            match (
+                &g.body,
+                declared.filter(|&end| end > g.start && end <= first_call),
+            ) {
+                (Some(_), Some(end)) => {
+                    edits.push((g.start, Some((g.end, String::new()))));
+                    moved.push_str(&copies_of(g));
+                    move_to = Some(end);
+                }
+                _ => edits.push((g.start, Some((g.end, copies_of(g))))),
+            }
+        }
+        if let Some(end) = move_to {
+            edits.push((end, Some((end, format!("\n{moved}")))));
+        }
+        // Pack text is untrusted: edits that overlap, or off the text, leave it as it was.
+        let mut spans: Vec<(usize, usize)> = edits
+            .iter()
+            .filter_map(|(s, e)| e.as_ref().map(|(end, _)| (*s, *end)))
+            .collect();
+        spans.sort_unstable();
+        if spans.windows(2).any(|w| w[1].0 < w[0].1) {
+            break;
+        }
+        edits.sort_by_key(|(start, _)| std::cmp::Reverse(*start));
+        let mut sound = true;
+        for (start, edit) in edits {
+            let (end, with) = match edit {
+                Some(span) => span,
+                None => {
+                    let found = calls(&scanned, &text, &f.name, &[])
+                        .into_iter()
+                        .find(|c| c.0 == start);
+                    let Some((_, end, args)) = found else {
+                        continue;
+                    };
+                    let rest: Vec<&str> = args
+                        .iter()
+                        .enumerate()
+                        .filter(|(n, _)| !f.samplers.iter().any(|(s, _)| s == n))
+                        .map(|(_, a)| a.trim())
+                        .collect();
+                    let copy = format!("{}_hz_{}", f.name, chosen_samplers(f, &args).join("_"));
+                    (end, format!("{copy}({})", rest.join(", ")))
+                }
+            };
+            if start > end || text.get(start..end).is_none() || spent() {
+                sound = false;
+                break;
+            }
+            text.replace_range(start..end, &with);
+        }
+        if !sound {
+            break;
+        }
+    }
+    // One that couldn't be followed: the shader as written, never half rewritten.
+    original.to_owned()
+}
+
+/// Each array declared without a size that an initializer sizes: `T[] name = T[](a, b)` and
+/// `T name[] = T[](a, b)` (or `T[2](...)`) are written with the size.
+fn size_unsized_arrays(text: &str) -> String {
+    let mut text = text.to_owned();
+    let mut closing = closings(&text);
+    // Each array sized reads the text's brackets again: a few hundred are plenty.
+    let mut left = 256;
+    let mut from = 0;
+    while let Some(found) = text[from..].find('=') {
+        let eq = from + found;
+        from = eq + 1;
+        // `==`, `<=`, `>=`, `!=`, `+=` ... are no initializers.
+        let prev = text[..eq].chars().next_back();
+        let next = text[eq + 1..].chars().next();
+        if matches!(
+            prev,
+            Some('=' | '<' | '>' | '!' | '+' | '-' | '*' | '/' | '%' | '&' | '|' | '^')
+        ) || next == Some('=')
+        {
+            continue;
+        }
+        // The constructor: `T [ n? ] (`.
+        let rest = &text[eq + 1..];
+        let ty_start = eq + 1 + (rest.len() - rest.trim_start().len());
+        let ty_len = text[ty_start..]
+            .chars()
+            .take_while(|c| is_ident(*c))
+            .count();
+        if ty_len == 0 {
+            continue;
+        }
+        let after_ty = &text[ty_start + ty_len..];
+        let bracket = ty_start + ty_len + (after_ty.len() - after_ty.trim_start().len());
+        if !text[bracket..].starts_with('[') {
+            continue;
+        }
+        let Some(bracket_end) = closing[bracket] else {
+            continue;
+        };
+        let after_bracket = &text[bracket_end + 1..];
+        let paren = bracket_end + 1 + (after_bracket.len() - after_bracket.trim_start().len());
+        if !text[paren..].starts_with('(') {
+            continue;
+        }
+        let Some(paren_end) = closing[paren] else {
+            continue;
+        };
+        // The declarator: `name []` or `T [] name`, between the statement's start and `=`.
+        // (Looked for on the line, at most 256 bytes back, so a long line stays linear.)
+        let mut back = eq.saturating_sub(256);
+        while !text.is_char_boundary(back) {
+            back += 1;
+        }
+        let statement_start = text[back..eq]
+            .rfind([';', '{', '}', '\n'])
+            .map_or(back, |i| back + i + 1);
+        let declarator = &text[statement_start..eq];
+        let Some(empty) = declarator.rfind('[') else {
+            continue;
+        };
+        let inside = &declarator[empty + 1..];
+        let Some(close) = inside.find(']') else {
+            continue;
+        };
+        if !inside[..close].trim().is_empty() {
+            continue;
+        }
+        let size = split_top(&text[paren + 1..paren_end]).len().to_string();
+        // Sized in the constructor too, where it isn't.
+        if text[bracket + 1..bracket_end].trim().is_empty() {
+            text.replace_range(bracket + 1..bracket_end, &size);
+        }
+        let at = statement_start + empty + 1;
+        text.replace_range(at..at + close, &size);
+        // The declarator is before `=`, so `=` moved by what its size changed.
+        from = eq + 1 + size.len() - close;
+        closing = closings(&text);
+        left -= 1;
+        if left == 0 {
+            break;
+        }
+    }
+    text
+}
+
+#[cfg(test)]
+mod tests;
@@ -0,0 +1,291 @@
+//! The rewrites on GLSL a pack writes, with the text each gives written out by hand.
+
+use super::*;
+
+#[test]
+fn a_sampler_parameter_becomes_a_copy_per_sampler_passed() {
+    let text = "vec4 blur(sampler2D tex, vec2 uv);\n\
+        vec4 blur(sampler2D tex, vec2 uv) { return texture(tex, uv) + texture(tex, uv * 2.0); }\n\
+        void main() { vec4 a = blur(Sampler0, uv); vec4 b = blur( Sampler1 , uv + 1.0); vec4 c = blur(Sampler0, uv); }\n";
+    let out = specialize_sampler_params(text);
+    assert!(!out.contains("sampler2D"), "{out}");
+    assert!(out.contains(
+        "vec4 blur_hz_Sampler0(vec2 uv) { return texture(Sampler0, uv) + texture(Sampler0, uv * 2.0); }"
+    ));
+    assert!(out.contains("vec4 blur_hz_Sampler1(vec2 uv)"));
+    assert!(out.contains("blur_hz_Sampler0(uv)"));
+    assert!(out.contains("blur_hz_Sampler1(uv + 1.0)"));
+    // One copy per sampler, not per call (and its prototype, from the prototype above).
+    assert_eq!(out.matches("vec4 blur_hz_Sampler0(vec2 uv) {").count(), 1);
+    assert_eq!(out.matches("vec4 blur_hz_Sampler0(vec2 uv);").count(), 1);
+}
+
+#[test]
+fn a_sampler_passed_on_through_another_function_is_followed() {
+    let text = "vec4 inner(sampler2D t, vec2 uv) { return texture(t, uv); }\n\
+        vec4 outer(vec2 uv, sampler2D s) { return inner(s, uv); }\n\
+        void main() { vec4 a = outer(uv, Sampler2); }\n";
+    let out = specialize_sampler_params(text);
+    assert!(!out.contains("sampler2D"), "{out}");
+    assert!(out.contains("outer_hz_Sampler2(uv)"), "{out}");
+    assert!(out.contains("inner_hz_Sampler2(uv)"), "{out}");
+}
+
+/// A call in another call's arguments is rewritten before the call around it, which is
+/// then read again: neither edit lands on the other's old text.
+#[test]
+fn a_call_nested_in_another_calls_arguments_is_rewritten_inside_out() {
+    let text = "vec2 tap(sampler2D s, vec2 uv) { return texture(s, uv).xy; }\n\
+        void main() { vec2 a = tap(Sampler0, tap(Sampler0, uv));\n\
+        vec2 b = tap(   Sampler1   ,   tap(  Sampler0  ,     uv      )   ); }\n";
+    let out = specialize_sampler_params(text);
+    assert!(!out.contains("sampler2D") && !out.contains("tap("), "{out}");
+    assert!(
+        out.contains("vec2 a = tap_hz_Sampler0(tap_hz_Sampler0(uv));"),
+        "{out}"
+    );
+    assert!(
+        out.contains("vec2 b = tap_hz_Sampler1(tap_hz_Sampler0(uv)); }"),
+        "{out}"
+    );
+    assert!(out.contains("vec2 tap_hz_Sampler0(vec2 uv) { return texture(Sampler0, uv).xy; }"));
+    assert!(out.contains("vec2 tap_hz_Sampler1(vec2 uv) { return texture(Sampler1, uv).xy; }"));
+}
+
+/// Overloads that differ past their sampler each keep their own body in their copies.
+#[test]
+fn overloads_with_a_sampler_each_keep_their_own_body() {
+    let text = "vec4 tap(sampler2D s, vec2 p) { return texture(s, p); }\n\
+        vec4 tap(sampler2D s, vec3 p) { return texture(s, p.xy / p.z); }\n\
+        void main() { vec4 a = tap(Sampler0, uv); vec4 b = tap(Sampler0, vec3(uv, 2.0)); }\n";
+    let out = specialize_sampler_params(text);
+    assert!(!out.contains("sampler2D"), "{out}");
+    assert!(
+        out.contains("vec4 tap_hz_Sampler0(vec2 p) { return texture(Sampler0, p); }"),
+        "{out}"
+    );
+    assert!(
+        out.contains("vec4 tap_hz_Sampler0(vec3 p) { return texture(Sampler0, p.xy / p.z); }"),
+        "{out}"
+    );
+    assert_eq!(out.matches("vec4 tap_hz_Sampler0(").count(), 2, "{out}");
+    assert!(out.contains("vec4 a = tap_hz_Sampler0(uv);"), "{out}");
+    assert!(
+        out.contains("vec4 b = tap_hz_Sampler0(vec3(uv, 2.0));"),
+        "{out}"
+    );
+}
+
+/// A copy reads its samplers by name, so it goes after a sampler declared below the helper
+/// (vanilla's world `text.vsh` includes `sample_lightmap.glsl` above `Sampler2`).
+#[test]
+fn a_copy_goes_after_its_samplers_declaration() {
+    let text = "vec4 tap(sampler2D s, vec2 uv) { return texture(s, uv); }\n\
+        uniform sampler2D Sampler2;\n\
+        void main() { vec4 c = tap(Sampler2, vec2(0.5)); }\n";
+    let out = specialize_sampler_params(text);
+    let declared = out
+        .find("uniform sampler2D Sampler2;")
+        .expect("declaration kept");
+    let copy = out
+        .find("vec4 tap_hz_Sampler2(vec2 uv)")
+        .expect("copy written");
+    let call = out
+        .find("tap_hz_Sampler2(vec2(0.5))")
+        .expect("call rewritten");
+    assert!(declared < copy && copy < call, "{out}");
+    assert_eq!(out.matches("tap_hz_Sampler2(vec2 uv)").count(), 1, "{out}");
+    assert!(!out.contains("tap(sampler2D"), "{out}");
+}
+
+/// A pack's text is untrusted: a sampler declared inside the helper itself (and text that
+/// isn't ASCII) gives edits that would overlap, so the shader is left as it is for the
+/// translator to refuse: never a panic, never a half-rewritten shader.
+#[test]
+fn a_sampler_declared_inside_the_helper_never_panics() {
+    let text = "vec4 tap(sampler2D s, vec2 uv) { é uniform sampler2D Sampler0; x return texture(s, uv); ééé }\n\
+        void main() { fragColor = tap(Sampler0, vec2(0.0)); }\n";
+    let out = specialize_sampler_params(text);
+    assert_eq!(out, text);
+}
+
+/// Vanilla's `texture_sampling.glsl` shape: one overload calls the other with its own
+/// sampler. That call is rewritten too, and both copies come after the sampler's declaration
+/// in their own order, the called one first.
+#[test]
+fn an_overload_passing_its_sampler_to_another_is_followed() {
+    let text = "vec4 sampleNearest(sampler2D source, vec2 uv, vec2 pixelSize, vec2 du, vec2 dv, vec2 texelSize) { return texture(source, uv + du + dv); }\n\
+        vec4 sampleNearest(sampler2D source, vec2 uv, vec2 pixelSize) { return sampleNearest(source, uv, pixelSize, dFdx(uv), dFdy(uv), pixelSize); }\n\
+        uniform sampler2D Sampler0;\n\
+        void main() { vec4 c = sampleNearest(Sampler0, uv, px); }\n";
+    let out = specialize_sampler_params(text);
+    assert!(
+        !out.contains("sampleNearest(") && !out.contains("sampler2D source"),
+        "{out}"
+    );
+    let declared = out
+        .find("uniform sampler2D Sampler0;")
+        .expect("declaration");
+    let six = out
+        .find("vec4 sampleNearest_hz_Sampler0(vec2 uv, vec2 pixelSize, vec2 du, vec2 dv, vec2 texelSize)")
+        .expect("six-argument copy");
+    let three = out
+        .find("vec4 sampleNearest_hz_Sampler0(vec2 uv, vec2 pixelSize) { return sampleNearest_hz_Sampler0(uv, pixelSize, dFdx(uv), dFdy(uv), pixelSize); }")
+        .expect("three-argument copy calling the six-argument one");
+    let call = out
+        .find("vec4 c = sampleNearest_hz_Sampler0(uv, px);")
+        .expect("call");
+    assert!(declared < six && six < three && three < call, "{out}");
+}
+
+/// A prototype above `main` with the definition below it becomes the copies' prototypes, so
+/// the call still has a declaration above it.
+#[test]
+fn a_prototype_becomes_the_copies_prototypes() {
+    let text = "uniform sampler2D Sampler0;\n\
+        vec4 tap(sampler2D s, vec2 uv);\n\
+        void main() { vec4 c = tap(Sampler0, uv); }\n\
+        vec4 tap(sampler2D s, vec2 uv) { return texture(s, uv); }\n";
+    let out = specialize_sampler_params(text);
+    let prototype = out
+        .find("vec4 tap_hz_Sampler0(vec2 uv);")
+        .expect("prototype copy");
+    let call = out.find("tap_hz_Sampler0(uv); }").expect("call");
+    let definition = out
+        .find("vec4 tap_hz_Sampler0(vec2 uv) { return texture(Sampler0, uv); }")
+        .expect("definition copy");
+    assert!(prototype < call && call < definition, "{out}");
+}
+
+/// Parameters named like the samplers they are passed, swapped, still read their own; and a
+/// parameter `s` leaves the swizzle `c.s` alone.
+#[test]
+fn sampler_parameters_are_replaced_at_once_and_not_as_members() {
+    let text = "uniform sampler2D Sampler0;\nuniform sampler2D Sampler1;\n\
+        vec4 mix2(sampler2D Sampler0, sampler2D Sampler1, vec2 uv) { return texture(Sampler0, uv) - texture(Sampler1, uv); }\n\
+        vec4 swz(sampler2D s, vec2 uv) { vec4 c = texture(s, uv); return vec4(c.s, c.t, 0.0, 1.0); }\n\
+        void main() { vec4 a = mix2(Sampler1, Sampler0, uv) + swz(Sampler0, uv); }\n";
+    let out = specialize_sampler_params(text);
+    assert!(
+        out.contains("{ return texture(Sampler1, uv) - texture(Sampler0, uv); }"),
+        "{out}"
+    );
+    assert!(
+        out.contains("{ vec4 c = texture(Sampler0, uv); return vec4(c.s, c.t, 0.0, 1.0); }"),
+        "{out}"
+    );
+}
+
+#[test]
+fn a_parameter_matched_twice_in_one_identifier_stays_whole() {
+    assert_eq!(replace_ident("c.ss + ss * s", "s", "t"), "c.ss + ss * t");
+    assert_eq!(replace_ident("brightness(s)", "s", "t"), "brightness(t)");
+}
+
+/// `fsh` translated beside a vertex shader that passes its position on.
+fn translate(fsh: &str) -> Result<crate::core_shader::CoreProgram, String> {
+    let vsh = "#version 330\nin vec3 Position;\nout vec2 texCoord0;\n\
+        void main() {\n    gl_Position = vec4(Position, 1.0);\n    texCoord0 = Position.xy;\n}\n";
+    let glue = crate::core_shader::Glue {
+        inputs: &[("Position", "vec3")],
+        prelude: "layout(location = 0) in vec3 hz_position;",
+        setup: "Position = hz_position;",
+        finish: "",
+        vertex_id: "int(gl_VertexIndex)",
+    };
+    crate::core_shader::translate_core(vsh, fsh, &[], &|_| None, &glue)
+}
+
+/// #9386 end to end: naga refuses a helper taking the sampler it reads, as GLSL vanilla's GL
+/// compiler takes it; the pack's shader translates, the helper a copy reading `Sampler0`.
+#[test]
+fn a_helper_taking_its_sampler_translates() {
+    let fsh = "#version 330\nuniform sampler2D Sampler0;\nin vec2 texCoord0;\nout vec4 fragColor;\n\
+        vec4 tap(sampler2D tex, vec2 at, float w) { return texture(tex, at) * w; }\n\
+        void main() {\n    fragColor = tap(Sampler0, texCoord0, 0.5) + tap(Sampler0, texCoord0 + 0.01, 0.5);\n}\n";
+    let program = translate(fsh).unwrap();
+    let names: Vec<_> = program
+        .fragment
+        .functions
+        .iter()
+        .filter_map(|(_, f)| f.name.as_deref())
+        .collect();
+    assert!(names.contains(&"tap_hz_Sampler0"), "{names:?}");
+    assert!(!names.contains(&"tap"), "{names:?}");
+}
+
+/// A sampler parameter with no name used to hand `replace_ident` an empty name to replace,
+/// which it found at the same place forever, growing the text until the game ran out of memory.
+#[test]
+fn a_sampler_parameter_without_a_name_is_left_as_it_was() {
+    let text = "uniform sampler2D Sampler0;\n\
+        vec4 tap(sampler2D ;, vec2 uv) { return texture(Sampler0, uv); }\n\
+        void main() { vec4 c = tap(Sampler0, uv); }\n";
+    assert_eq!(fixups(text), text);
+    assert_eq!(replace_ident("abc", "", "x"), "abc");
+}
+
+/// Each call rewritten reads the whole text again: thousands of them stop at the scan budget,
+/// the shader left as it was (never half rewritten) instead of freezing the load.
+#[test]
+fn thousands_of_calls_are_left_as_they_were() {
+    let shader = format!(
+        "uniform sampler2D S;\nvec4 t(sampler2D s) {{ return texture(s, vec2(0.0)); }}\n\
+         void main() {{ vec4 c; {}}}\n",
+        "c = t(S);".repeat(5000)
+    );
+    assert_eq!(fixups(&shader), shader);
+    // A few of them are rewritten.
+    let few = shader.replace(&"c = t(S);".repeat(5000), &"c = t(S);".repeat(3));
+    assert_eq!(
+        fixups(&few).matches("c = t_hz_S(").count(),
+        3,
+        "{}",
+        fixups(&few)
+    );
+}
+
+#[test]
+fn unsized_arrays_take_their_initializers_size() {
+    let text = "const float[] w = float[](0.25, 0.5, 0.25);\n\
+        const vec2 offsets[] = vec2[](vec2(1.0, 0.0), vec2(0.0, 1.0));\n\
+        float k[] = float[4](1.0, 2.0, 3.0, 4.0);\n\
+        bool same = a == b;\n";
+    let out = size_unsized_arrays(text);
+    assert!(
+        out.contains("const float[3] w = float[3](0.25, 0.5, 0.25);"),
+        "{out}"
+    );
+    assert!(
+        out.contains("const vec2 offsets[2] = vec2[2](vec2(1.0, 0.0), vec2(0.0, 1.0));"),
+        "{out}"
+    );
+    assert!(
+        out.contains("float k[4] = float[4](1.0, 2.0, 3.0, 4.0);"),
+        "{out}"
+    );
+    assert!(out.contains("bool same = a == b;"));
+}
+
+#[test]
+fn a_wide_character_after_a_sized_array_never_panics() {
+    // Ten values make the size two digits, which moves the `=` two bytes right: the scan
+    // went on from where it used to be, inside the `é`.
+    let text = "float w[]\u{e9}= float[](0.,1.,2.,3.,4.,5.,6.,7.,8.,9.);\n";
+    assert_eq!(
+        size_unsized_arrays(text),
+        "float w[10]\u{e9}= float[10](0.,1.,2.,3.,4.,5.,6.,7.,8.,9.);\n"
+    );
+}
+
+/// #9386 end to end: naga refuses an array sized by its initializer only.
+#[test]
+fn an_array_sized_by_its_initializer_translates() {
+    let fsh = "#version 330\nuniform sampler2D Sampler0;\nin vec2 texCoord0;\nout vec4 fragColor;\n\
+        const float[] weights = float[](0.25, 0.5, 0.25);\n\
+        void main() {\n    vec4 sum = vec4(0.0);\n\
+            for (int i = 0; i < 3; i++) {\n        sum += texture(Sampler0, texCoord0 + float(i) * 0.01) * weights[i];\n    }\n\
+            fragColor = sum;\n}\n";
+    let program = translate(fsh);
+    assert!(program.is_ok(), "{:?}", program.err());
+}
@@ -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());
+    }
+}
@@ -155,7 +155,8 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
    var back = c;
    // Normal w: 0 keeps the baked colour, +-127 shades by the normal, and a small positive 1
    // keeps the baked colour but culls back faces (entitySolid models such as the decorated pot).
-    // -126/127 shades like -127 and also culls (entityCutoutCull models such as the bat).
+    // -126/127 shades like -127 and also culls (entityCutoutCull models such as the bat, and the
+    // entitySolid decorated pot).
    out.cull = select(0u, 1u, (normal.w > 0.0 && normal.w < 0.5) || (normal.w < 0.0 && normal.w > -0.996));
    if abs(normal.w) >= 0.5 {
        c = vec4(c.rgb * entity_light(normal.xyz, globals.time.y != 0.0), c.a);
@@ -75,6 +75,7 @@ pub use entity_batch::{
    WATER_MASK_OVERLAY, WORLD_TEXT_OVERLAY, WORLD_TEXT_POLYGON_OFFSET_OVERLAY, is_native_terrain,
    mark_oit,
 };
+use external::{ShadowCull, shadow_box, shadow_casters, shadow_runs};
 use section_fade::{
    CHUNK_VISIBILITY_THRESHOLD, FadeInputs, chunk_visibility, fade_millis, section_instance,
    section_visibility,
@@ -194,6 +195,7 @@ mod cull;
 mod dx12_compiler;
 mod end_sky;
 pub mod entity_skin;
+pub mod external;
 mod flat;
 mod frame_gen;
 mod gpu_culling;
@@ -1369,8 +1371,10 @@ pub struct Renderer {
    /// Per-frame scratch, kept to avoid allocating every frame.
    visible: Vec<resident::Visible>,
    visible_lods: Vec<lod::Visible>,
-    /// The sections a shader pack's shadow camera sees (`pack_post::ShadowView`).
+    /// The sections a shader pack's shadow camera sees (`external::ShadowView`).
    shadow_visible: Vec<resident::Visible>,
+    /// The external shader pipeline world frames call (`external`); `None` draws vanilla's way.
+    external: Option<Box<dyn external::ExternalPipeline>>,
    translucent_draws: Vec<(u64, usize, [u32; 5], (u32, Option<u32>))>,
    origins: Vec<[f32; 4]>,
    /// `DrawIndexedIndirectArgs` words: index count, instance count, first
@@ -1496,7 +1500,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.
@@ -1577,9 +1581,9 @@ fn requested_split() -> Option<u32> {
        .and_then(|v| v.parse().ok())
        .filter(|&n| (1..=SPRITE_SPLIT).contains(&n))
 }
-fn adapter_requested_split(info: &wgpu::AdapterInfo, requested: Option<u32>) -> Option<u32> {
-    // Metal can fail to sample large mipmapped array textures despite advertising the layer limit.
-    requested.or_else(|| (info.backend == wgpu::Backend::Metal).then_some(512))
+fn adapter_requested_split(info: &wgpu::AdapterInfo, asked: Option<u32>, n: u32) -> Option<u32> {
+    // Metal can fail on big mipmapped arrays (#8471): 512 layers each, more only for n > 8 x 512.
+    asked.or((info.backend == wgpu::Backend::Metal).then(|| n.div_ceil(SPRITE_ARRAYS).max(512)))
 }
 /// The split the CPU mip chains are cut by before the adapter is known.
 fn sprite_split() -> u32 {
@@ -2108,7 +2112,7 @@ fn check_layers(adapter: &wgpu::Adapter, layers: u32) -> Result<u32> {
    Ok(layer_split(
        adapter.limits().max_texture_array_layers,
        info.backend == wgpu::Backend::Gl,
-        adapter_requested_split(&info, requested_split()),
+        adapter_requested_split(&info, requested_split(), layers),
        layers,
    )?)
 }
@@ -2823,10 +2827,8 @@ impl Renderer {
        // Computed once: the sprite arrays, the shaders' constants and the
        // shader pack atlas all cut the sprites by it.
        let split = check_layers(&adapter, layers)?;
-        if split < sprite_split() {
-            log::info!("Horizon: {split} block textures per array (the GPU's limit)");
-        }
        let info = adapter.get_info();
+        surface_setup::log_sprite_split(&info, split, layers);
        crate::graphics::suggest_reduced_far_detail(crate::graphics::lod_capped(&info));
        let size = window.inner_size();
        let max_side = device.limits().max_texture_dimension_2d;
@@ -5242,6 +5244,7 @@ impl Renderer {
            solid_runs: page_runs::PageRuns::default(),
            phase2_runs: page_runs::PageRuns::default(),
            shadow_runs: page_runs::PageRuns::default(),
+            external: None,
            block_entities: Default::default(),
            block_entity_section_revisions: Default::default(),
            block_entity_membership_revisions: Default::default(),
@@ -5625,6 +5628,9 @@ impl Renderer {
            self.offscreen = Some(Self::offscreen_target(&self.device, &self.config));
        }
        self.depth = Self::depth(&self.device, &self.config);
+        if let Some(pipeline) = &mut self.external {
+            pipeline.resize([width, height]);
+        }
    }
    /// Whether sections are drawn as one index list per frame (`flat`).
    pub fn flat_draws(&self) -> bool {
@@ -7261,12 +7267,19 @@ impl Renderer {
        }
        Ok(report)
    }
+    /// Sets the external shader pipeline world frames call (`external`), or none.
+    pub fn set_external_pipeline(&mut self, pipeline: Option<Box<dyn external::ExternalPipeline>>) {
+        self.external = pipeline;
+    }
    /// Makes the running shader pack, of either kind, forget what it kept from earlier frames:
    /// the next frame draws as a freshly loaded pack's first. Nothing to do without a pack.
    pub fn reset_shader_pack_history(&mut self) {
        // A frame still on the submit thread uses the targets and readbacks replaced
        // here.
        self.land_frame();
+        if let Some(pipeline) = &mut self.external {
+            pipeline.reset_history();
+        }
        if let Some((_, Some(post))) = &mut self.pack_post {
            post.reset_history(&self.device);
        }
@@ -7540,10 +7553,6 @@ impl Renderer {
                }
            });
        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()),
@@ -7553,6 +7562,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)
        }
    }

@@ -8603,6 +8613,13 @@ impl Renderer {
        // A shader pack's shadow pass draws the sections in its camera's box, all of them (the
        // occlusion graph follows the eye, not the light), within shadowDistanceRenderMul; for
        // an Iris-format pack, only those whose shadow can fall into the camera's view.
+        let state = external::FrameState {
+            frame,
+            output: &output,
+        };
+        if let Some(pipeline) = self.external.as_mut().filter(|_| !frame.title) {
+            pipeline.begin_frame(&state);
+        }
        let shadow_view = self
            .pack_post
            .as_ref()
@@ -8614,6 +8631,12 @@ impl Renderer {
                let native = self.native.as_ref().filter(|_| !frame.title)?;
                native.shadow.as_ref()?;
                native.frame.shadow_view(frame)
+            })
+            .or_else(|| {
+                self.external
+                    .as_ref()
+                    .filter(|_| !frame.title)?
+                    .shadow_request(&state)
            });
        // `LevelRenderer.extractSectionDrawGroups`' fade-in time, for the instances.
        let fade_ms = fade_millis(frame.chunk_fade);
@@ -11903,13 +11926,12 @@ impl Renderer {
        {
            self.readback.present(&self.device, &mut encoder, image);
        }
-        // A 0.2 pack is shown at paper white: HDR output lifts nothing of its world.
-        let lifts_world = !frame.title
-            && self.output.frame.format != LINEAR_FRAME
-            && self
-                .native
-                .as_ref()
-                .is_none_or(|n| n.frame.api == horizon_shader_api::Api::V0_1);
+        let lifts_world = output::lifts_world(
+            frame.title,
+            self.output.frame.format == LINEAR_FRAME,
+            self.shader_pack_kind() == Some("iris"),
+            self.native.as_ref().map(|n| n.frame.api),
+        );
        match (&self.hdr, &surface_frame) {
            (Some(hdr), Some(f)) => hdr.present(
                &self.queue,
@@ -12745,61 +12767,6 @@ impl Cull for Frusta {
        self.0.contains(min, max) || self.1.is_some_and(|f| f.contains(min, max))
    }
 }
-/// A shader pack's shadow camera's box, and with `casters` only what can shade the camera's view
-/// (`shadow_casters`): a box must meet all of them.
-#[derive(Clone, Copy, Debug)]
-pub struct ShadowCull {
-    pub light: Frustum,
-    pub casters: Option<[Frustum; 2]>,
-    /// `shadowDistance × shadowDistanceRenderMul`: only what lies within this many blocks of the
-    /// camera along each axis, a cube around it. Our probe's Iris 1.11.7 maps keep the sections
-    /// whose box, grown by `SHADOW_CASTER_MARGIN` as for the casters, meets that cube (#8464):
-    /// out to its corners, and a section 1 block past its side but not one 1.5 blocks past.
-    pub reach: Option<f32>,
-}
-impl ShadowCull {
-    /// Whether the camera-relative box `min..max`, grown by the margin, meets (`whole`: lies
-    /// within) `reach`'s cube.
-    fn within_reach(&self, min: Vec3, max: Vec3, whole: bool) -> bool {
-        let (min, max) = (min - SHADOW_CASTER_MARGIN, max + SHADOW_CASTER_MARGIN);
-        self.reach.is_none_or(|d| {
-            if whole {
-                min.cmpge(Vec3::splat(-d)).all() && max.cmple(Vec3::splat(d)).all()
-            } else {
-                max.cmpge(Vec3::splat(-d)).all() && min.cmple(Vec3::splat(d)).all()
-            }
-        })
-    }
-}
-/// How far past a section's 16 blocks the shadow pass looks for what can shade the view: our
-/// probes' Iris 1.11.7 maps keep the sections whose box, grown by this much on every side, meets
-/// `shadow_casters`' shape. Over 76 scenes at fields of view 30 to 110, Iris keeps every section
-/// that needs up to 1.1224 blocks and drops every one that needs 1.1252 or more (#8464): one
-/// growth, whatever the field of view, of 9/8 (a fit, not Iris's code). Without it the edges of
-/// the wedge lose a column of terrain.
-const SHADOW_CASTER_MARGIN: f32 = 1.125;
-impl Cull for ShadowCull {
-    fn intersects(&self, min: Vec3, max: Vec3) -> bool {
-        let (grown_min, grown_max) = (min - SHADOW_CASTER_MARGIN, max + SHADOW_CASTER_MARGIN);
-        self.within_reach(min, max, false)
-            && self.light.intersects(min, max)
-            && self
-                .casters
-                .is_none_or(|c| c.iter().all(|f| f.intersects(grown_min, grown_max)))
-    }
-    fn contains(&self, min: Vec3, max: Vec3) -> bool {
-        let (grown_min, grown_max) = (min - SHADOW_CASTER_MARGIN, max + SHADOW_CASTER_MARGIN);
-        self.within_reach(min, max, true)
-            && self.light.contains(min, max)
-            && self
-                .casters
-                .is_none_or(|c| c.iter().all(|f| f.contains(grown_min, grown_max)))
-    }
-    /// Our probe's Iris 1.11.7 maps fit testing the casters' whole sections (a guess that matched).
-    fn tight(&self) -> bool {
-        self.casters.is_none()
-    }
-}
 /// The block entities of `sections` whose box, a block wider on every side, comes within the
 /// 64 blocks block entities are drawn to (`Renderer::visible_block_entities_in_frustum`).
 fn block_entities_within_reach<'a>(
@@ -12822,17 +12789,6 @@ fn block_entities_within_reach<'a>(
        })
        .flatten()
 }
-/// The shadow camera's box that the shadow pass draws terrain in: the sides of `view.cull`, and
-/// its near and far planes only with `depth_planes`.
-fn shadow_box(view: &pack_post::ShadowView) -> Frustum {
-    let mut planes = frustum(view.cull);
-    if !view.depth_planes {
-        // `frustum`'s faces at depth 0 and 1 take in everything.
-        planes[4] = Vec4::W;
-        planes[5] = Vec4::W;
-    }
-    Frustum { planes }
-}
 /// Camera-relative clip planes (`Frustum`).
 #[derive(Clone, Copy, Debug)]
 pub struct Frustum {
@@ -12956,21 +12912,6 @@ fn projection_center(view_proj: Mat4) -> Option<Vec3> {
    let b = DVec3::new(rows[0].w, rows[1].w, rows[2].w);
    Some((a.inverse() * -b).as_vec3())
 }
-/// The runs of a section's solid quads the shadow pass draws: every face within the unculled
-/// distance, or everywhere for `every_face`; else the quads that can face the light.
-fn shadow_runs(
-    sides: &Sides,
-    view: &pack_post::ShadowView,
-    origin: [f32; 3],
-    draw: impl FnMut(u32, u32),
-) {
-    let unculled = view.unculled.is_some_and(|d| {
-        let o = Vec3::from(origin) + 8.0;
-        o.x.abs().max(o.z.abs()) <= d + 8.0
-    });
-    let toward = (!unculled && !view.every_face).then_some(view.light * 1.0e5);
-    facing_runs(sides, toward, origin, draw);
-}

 /// Calls `draw(first, quads)` for each run of a mesh's solid quads that can
 /// face `eye` (`projection_center`), the mesh at the camera-relative
@@ -12997,68 +12938,6 @@ fn facing_runs_from(
        None => sides.every(part, draw),
    }
 }
-/// The camera's view `view_proj` (wgpu depth, reversed or not) stretched without end toward
-/// `light` (a direction): the boxes whose shadow, cast away from the light, can fall into the
-/// view. Its planes are the view's faces turned toward the light, and through each edge between
-/// such a face and one turned away, the plane along the light; unused ones take in everything.
-fn shadow_casters(view_proj: Mat4, light: Vec3) -> [Frustum; 2] {
-    let faces = frustum(view_proj);
-    let toward = faces.map(|p| p.truncate().dot(light) >= 0.0);
-    let inverse = view_proj.inverse();
-    // Corner (x, y, z) of clip space's box; `frustum`'s faces at x -1 and 1 are 0 and 1, at
-    // y -1 and 1 are 2 and 3, at depth 0 and 1 are 4 and 5.
-    let corner = |c: [usize; 3]| {
-        inverse.project_point3(Vec3::new(
-            c[0] as f32 * 2.0 - 1.0,
-            c[1] as f32 * 2.0 - 1.0,
-            c[2] as f32,
-        ))
-    };
-    let corners: Vec<[usize; 3]> = (0..8).map(|i| [i & 1, (i >> 1) & 1, i >> 2]).collect();
-    let centre = corners.iter().map(|&c| corner(c)).sum::<Vec3>() / 8.0;
-    let mut planes = [Vec4::W; 12];
-    let mut n = 0;
-    for (k, &face) in faces.iter().enumerate() {
-        if toward[k] {
-            planes[n] = face;
-            n += 1;
-        }
-    }
-    for a in &corners {
-        for axis in 0..3 {
-            if a[axis] == 1 {
-                continue;
-            }
-            let mut b = *a;
-            b[axis] = 1;
-            // The edge from a to b lies on the faces of the two other axes.
-            let [f, g] = [(axis + 1) % 3, (axis + 2) % 3].map(|o| o * 2 + a[o]);
-            if toward[f] == toward[g] {
-                continue;
-            }
-            let (p, q) = (corner(*a), corner(b));
-            let normal = (q - p).cross(light);
-            if normal.length_squared() < 1e-12 {
-                continue;
-            }
-            let normal = normal.normalize();
-            let side = if normal.dot(centre - p) < 0.0 {
-                -1.0
-            } else {
-                1.0
-            };
-            // At most six such edges with at most four faces toward the light: 12 planes.
-            if let Some(plane) = planes.get_mut(n) {
-                *plane = (normal * side).extend(-normal.dot(p) * side);
-                n += 1;
-            }
-        }
-    }
-    let [a, b] = [0, 6].map(|i| Frustum {
-        planes: planes[i..i + 6].try_into().expect("six planes"),
-    });
-    [a, b]
-}
 fn taa_frustum(view_proj: Mat4, rendered_size: [u32; 2]) -> Frustum {
    // TAA shifts clip x/y by at most half a rendered pixel times clip w.
    // Widen x/y before extracting the planes: this includes every such shifted
@@ -15068,11 +14947,21 @@ mod sprite_upload_tests {
            limit_bucket: None,
        };
        info.backend = wgpu::Backend::Metal;
-        assert_eq!(adapter_requested_split(&info, None), Some(512));
-        assert_eq!(adapter_requested_split(&info, Some(1024)), Some(1024));
+        assert_eq!(adapter_requested_split(&info, None, 1200), Some(512));
+        assert_eq!(
+            adapter_requested_split(&info, None, 512 * SPRITE_ARRAYS),
+            Some(512)
+        );
+        assert_eq!(adapter_requested_split(&info, Some(1024), 1200), Some(1024));
+        // More sprites than the arrays hold at 512: the arrays grow, up to the GPU's layers.
+        let split = adapter_requested_split(&info, None, 10_271);
+        assert_eq!(split, Some(1284));
+        assert_eq!(layer_split(2048, false, split, 10_271), Ok(1284));
+        let split = adapter_requested_split(&info, None, 2048 * SPRITE_ARRAYS + 1);
+        assert!(layer_split(2048, false, split, 2048 * SPRITE_ARRAYS + 1).is_err());

        info.backend = wgpu::Backend::Vulkan;
-        assert_eq!(adapter_requested_split(&info, None), None);
+        assert_eq!(adapter_requested_split(&info, None, 10_271), None);
    }

    #[test]
@@ -15357,7 +15246,7 @@ mod shadow_face_tests {
    }

    /// The layers (faces) of the quads the shadow pass draws of `solid`.
-    fn drawn(view: &pack_post::ShadowView, origin: [f32; 3]) -> Vec<u16> {
+    fn drawn(view: &external::ShadowView, origin: [f32; 3]) -> Vec<u16> {
        let mut solid = block([7.0, 7.0, 7.0]);
        let sides = crate::mesher::sort_tinted(&mut solid, &mut Vec::new());
        let mut layers = Vec::new();
@@ -15370,8 +15259,8 @@ mod shadow_face_tests {
        layers
    }

-    fn view(every_face: bool) -> pack_post::ShadowView {
-        pack_post::ShadowView {
+    fn view(every_face: bool) -> external::ShadowView {
+        external::ShadowView {
            cull: Mat4::IDENTITY,
            light: Vec3::Y,
            distance: None,
@@ -15585,7 +15474,7 @@ mod shadow_caster_tests {
                ..horizon_shaders::Shadow::default()
            };
            let camera = DVec3::new(13.5, y + 1.62, -13.5);
-            let view = pack_post::ShadowView {
+            let view = external::ShadowView {
                cull: pack_uniforms::shadow_culling_at(Vec3::Y, camera, &shadow),
                light: Vec3::Y,
                distance: None,
@@ -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()));
+        }
+    }
+}
@@ -37,7 +37,9 @@
 //! are drawn in a pass of their own between the phases, which reads phase
 //! 1's depth as a texture and makes the same comparison in the shader: the
 //! fragment's depth against the stored one, greater or equal passing. The
-//! same fragments pass, so the same sections are seen.
+//! same fragments pass, so the same sections are seen. Adreno's Vulkan driver
+//! takes that path too: with the early test it now and then leaves sections
+//! out for a frame.
 use std::num::NonZeroU64;
 use std::sync::{
    Arc,
@@ -220,17 +222,42 @@ const RESULTS_USAGE: wgpu::BufferUsages =
 const READBACK_USAGE: wgpu::BufferUsages =
    wgpu::BufferUsages::MAP_READ.union(wgpu::BufferUsages::COPY_DST);

+/// The first `n` values of a packed lookup in WGSL `source` (`fn name`, as cull.wgsl's
+/// `box_triangle_corner`): four bits each, eight a word, its words in the order of its cases.
+#[cfg(test)]
+pub(super) fn packed_lookup(source: &str, name: &str, n: usize) -> Vec<u32> {
+    let body = &source[source.find(&format!("fn {name}(")).expect("the lookup")..];
+    let body = &body[..body.find("return").expect("its return")];
+    let words: Vec<u32> = body
+        .split(|c: char| !c.is_ascii_alphanumeric())
+        .filter_map(|t| t.strip_prefix("0x")?.strip_suffix('u'))
+        .map(|hex| u32::from_str_radix(hex, 16).expect("a hex word"))
+        .collect();
+    (0..n)
+        .map(|v| (words[v / 8] >> (v % 8 * 4)) & 0xf)
+        .collect()
+}
+
+/// Qualcomm's PCI vendor id, which wgpu reports for Adreno GPUs.
+const ADRENO: u32 = 0x5143;
+
 impl Cull {
    /// The device feature culling needs, where the adapter has it.
    pub fn features(adapter: &wgpu::Adapter) -> wgpu::Features {
        adapter.features() & wgpu::Features::SHADER_EARLY_DEPTH_TEST
    }
    /// Where the device can run the test, if it can: Vulkan with early
-    /// depth tests, or Metal and DirectX 12 with the test in the shader, all
-    /// drawing an indirect multi-draw's entries with the instance counts the
-    /// GPU wrote, with fragment shaders that write storage.
+    /// depth tests (Adreno's in the shader), or Metal and DirectX 12 with the
+    /// test in the shader, all drawing an indirect multi-draw's entries with
+    /// the instance counts the GPU wrote, with fragment shaders that write
+    /// storage.
    pub fn supported(adapter: &wgpu::Adapter, device: &wgpu::Device) -> Option<DepthTest> {
-        let depth_test = match adapter.get_info().backend {
+        let info = adapter.get_info();
+        let depth_test = match info.backend {
+            // Adreno's Vulkan driver (the AYANEO Pocket DS's Adreno 740, build 0676.41) now and
+            // then leaves sections out with the early test, the world flashing black or
+            // see-through as a block breaks; the test in the shader, as on Metal, holds.
+            wgpu::Backend::Vulkan if info.vendor == ADRENO => DepthTest::InShader,
            wgpu::Backend::Vulkan | wgpu::Backend::Gl
                if device
                    .features()
@@ -772,4 +799,20 @@ mod tests {
                .unwrap_or_else(|e| panic!("{depth_test:?}: {e:?}"));
        }
    }
+
+    /// The box's 12 triangles, as cull.wgsl and gpu_occlusion.wgsl draw them: two per face,
+    /// counter-clockwise seen from outside, corners by bit (x 1, y 2, z 4).
+    #[test]
+    fn the_packed_box_corners_are_the_box_triangles() {
+        let triangles = [
+            0, 6, 2, 0, 4, 6, 1, 3, 7, 1, 7, 5, 0, 1, 5, 0, 5, 4, 2, 7, 3, 2, 6, 7, 0, 3, 1, 0, 2,
+            3, 4, 5, 7, 4, 7, 6,
+        ];
+        for source in [
+            include_str!("cull.wgsl"),
+            include_str!("gpu_occlusion.wgsl"),
+        ] {
+            assert_eq!(packed_lookup(source, "box_triangle_corner", 36), triangles);
+        }
+    }
 }
@@ -34,11 +34,21 @@ struct Test {
@group(0) @binding(5) var<uniform> params: Params;

 // The corners (bit 0: x, bit 1: y, bit 2: z) of the box's 12 triangles,
-// counter-clockwise seen from outside.
-const CORNERS = array<u32, 36>(
-    0u, 6u, 2u, 0u, 4u, 6u, 1u, 3u, 7u, 1u, 7u, 5u, 0u, 1u, 5u, 0u, 5u, 4u,
-    2u, 7u, 3u, 2u, 6u, 7u, 0u, 3u, 1u, 0u, 2u, 3u, 4u, 5u, 7u, 4u, 7u, 6u,
-);
+// counter-clockwise seen from outside: 0 6 2, 0 4 6, 1 3 7, 1 7 5, 0 1 5, 0 5 4,
+// 2 7 3, 2 6 7, 0 3 1, 0 2 3, 4 5 7, 4 7 6.
+// Packed four bits each, eight a word, read through a switch: a constant array indexed by the
+// vertex would be a private array, which Adreno's Vulkan compiler (build 0676.41) fails to link.
+fn box_triangle_corner(v: u32) -> u32 {
+    var word: u32;
+    switch v / 8u {
+        case 0u: { word = 0x31640260u; }
+        case 1u: { word = 0x05105717u; }
+        case 2u: { word = 0x76237245u; }
+        case 3u: { word = 0x54320130u; }
+        default: { word = 0x00006747u; }
+    }
+    return (word >> (v % 8u * 4u)) & 0xfu;
+}

 struct Box {
    @builtin(position) position: vec4<f32>,
@@ -95,7 +105,7 @@ fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box
        out.position = select(vec4(0.0, 0.0, 0.0, 1.0), vec4(p, 1.0, 1.0), v < 3u);
        return out;
    }
-    out.position = globals.view_proj * vec4(corner(origin, low, high, CORNERS[v]), 1.0);
+    out.position = globals.view_proj * vec4(corner(origin, low, high, box_triangle_corner(v)), 1.0);
    return out;
 }

@@ -0,0 +1,214 @@
+//! The hook an external shader pipeline fills (#14035, layer plan M6). A shader pack's runtime
+//! (a platform crate, later) implements [`ExternalPipeline`]; the renderer calls it at fixed
+//! points of a world frame and draws vanilla's way wherever it doesn't answer. With none set
+//! (`Renderer::set_external_pipeline`), each point is one `Option` test.
+//!
+//! Workspace-internal: the trait names the engine's frame, its mesh format and its pass order,
+//! has one implementer in this workspace, carries no stability promise and is never exposed to
+//! mods. A mesher or pass change updates its implementer in the same PR. HDR output
+//! (`output.rs`, `frame_policy`) is not an implementer: it stays the one output stage after the
+//! frame, and a pipeline draws into the frame it gives.
+//!
+//! Shadows are an engine frame point, on request: a pipeline that wants a shadow pass answers
+//! [`ShadowView`], the engine culls the sections from it ([`ShadowCull`]) and hands back the
+//! terrain seen from the light. Vanilla's path never asks, so it never computes shadow
+//! visibility.
+
+use glam::{Mat4, Vec3, Vec4};
+
+use super::{Cull, EffectiveOutput, Frame, Frustum, Sides, facing_runs, frustum};
+
+/// What a world frame gives an external pipeline at its points: the frame's own values, and
+/// the display's from the renderer's one output snapshot (`EffectiveOutput`: whether HDR is on,
+/// paper white, peak), never worked out again, so each split-screen window keeps its own.
+pub struct FrameState<'a> {
+    pub frame: &'a Frame<'a>,
+    pub output: &'a EffectiveOutput,
+}
+
+/// An external shader pipeline, called by the renderer at fixed points of a world frame (not
+/// title frames). Every method has a default that leaves vanilla's way in place.
+pub trait ExternalPipeline: Send {
+    /// A world frame starts, before culling.
+    fn begin_frame(&mut self, _state: &FrameState<'_>) {}
+    /// The shadow pass this frame wants; `None` draws none.
+    fn shadow_request(&self, _state: &FrameState<'_>) -> Option<ShadowView> {
+        None
+    }
+    /// The window's drawable size changed.
+    fn resize(&mut self, _size: [u32; 2]) {}
+    /// Forget what was kept from earlier frames: the next is drawn as a fresh pipeline's first.
+    fn reset_history(&mut self) {}
+}
+
+/// What the shadow camera sees of the terrain, for the game's draw lists: its view and
+/// projection in wgpu's clip space, the direction toward the light, and how far from the camera
+/// terrain is drawn (`shadowDistanceRenderMul`).
+pub struct ShadowView {
+    pub cull: glam::Mat4,
+    pub light: glam::Vec3,
+    pub distance: Option<f32>,
+    /// Draw everything, every face, within this many blocks (`shadow.culling=false|reversed`):
+    /// packs that voxelize the world in their shadow pass need all of it.
+    pub unculled: Option<f32>,
+    /// Every face of the drawn sections, not only those that can face the light. Iris 1.11.7's
+    /// shadow map holds the faces turned away from the light too (#9033): under a hill at low sun
+    /// a cave's ceiling, which faces away, is often all that shadows the cave.
+    pub every_face: bool,
+    /// Only the sections whose shadow can fall into the camera's view: those the camera's
+    /// frustum, stretched toward the light, takes in (`shadow_casters`). Our probes' Iris 1.11.7
+    /// maps fit keeping only those with `shadow.culling` unset (#8464): under a noon sun, only
+    /// the terrain above the ground the camera sees; with a low sun ahead, none behind the camera.
+    pub view_casters: bool,
+    /// Whether the projection's near and far planes in `cull` drop sections too. Our probes'
+    /// Iris 1.11.7 maps hold the terrain at every depth we put it along the light (from 535 blocks
+    /// beyond the shadow camera to about 120 before it), whatever `shadowNearPlane` and
+    /// `shadowFarPlane` the pack sets, or none (#10403): only its sides cull.
+    pub depth_planes: bool,
+}
+
+/// A shader pack's shadow camera's box, and with `casters` only what can shade the camera's view
+/// (`shadow_casters`): a box must meet all of them.
+#[derive(Clone, Copy, Debug)]
+pub struct ShadowCull {
+    pub light: Frustum,
+    pub casters: Option<[Frustum; 2]>,
+    /// `shadowDistance × shadowDistanceRenderMul`: only what lies within this many blocks of the
+    /// camera along each axis, a cube around it. Our probe's Iris 1.11.7 maps keep the sections
+    /// whose box, grown by `SHADOW_CASTER_MARGIN` as for the casters, meets that cube (#8464):
+    /// out to its corners, and a section 1 block past its side but not one 1.5 blocks past.
+    pub reach: Option<f32>,
+}
+impl ShadowCull {
+    /// Whether the camera-relative box `min..max`, grown by the margin, meets (`whole`: lies
+    /// within) `reach`'s cube.
+    fn within_reach(&self, min: Vec3, max: Vec3, whole: bool) -> bool {
+        let (min, max) = (min - SHADOW_CASTER_MARGIN, max + SHADOW_CASTER_MARGIN);
+        self.reach.is_none_or(|d| {
+            if whole {
+                min.cmpge(Vec3::splat(-d)).all() && max.cmple(Vec3::splat(d)).all()
+            } else {
+                max.cmpge(Vec3::splat(-d)).all() && min.cmple(Vec3::splat(d)).all()
+            }
+        })
+    }
+}
+/// How far past a section's 16 blocks the shadow pass looks for what can shade the view: our
+/// probes' Iris 1.11.7 maps keep the sections whose box, grown by this much on every side, meets
+/// `shadow_casters`' shape. Over 76 scenes at fields of view 30 to 110, Iris keeps every section
+/// that needs up to 1.1224 blocks and drops every one that needs 1.1252 or more (#8464): one
+/// growth, whatever the field of view, of 9/8 (a fit, not Iris's code). Without it the edges of
+/// the wedge lose a column of terrain.
+const SHADOW_CASTER_MARGIN: f32 = 1.125;
+impl Cull for ShadowCull {
+    fn intersects(&self, min: Vec3, max: Vec3) -> bool {
+        let (grown_min, grown_max) = (min - SHADOW_CASTER_MARGIN, max + SHADOW_CASTER_MARGIN);
+        self.within_reach(min, max, false)
+            && self.light.intersects(min, max)
+            && self
+                .casters
+                .is_none_or(|c| c.iter().all(|f| f.intersects(grown_min, grown_max)))
+    }
+    fn contains(&self, min: Vec3, max: Vec3) -> bool {
+        let (grown_min, grown_max) = (min - SHADOW_CASTER_MARGIN, max + SHADOW_CASTER_MARGIN);
+        self.within_reach(min, max, true)
+            && self.light.contains(min, max)
+            && self
+                .casters
+                .is_none_or(|c| c.iter().all(|f| f.contains(grown_min, grown_max)))
+    }
+    /// Our probe's Iris 1.11.7 maps fit testing the casters' whole sections (a guess that matched).
+    fn tight(&self) -> bool {
+        self.casters.is_none()
+    }
+}
+/// The shadow camera's box that the shadow pass draws terrain in: the sides of `view.cull`, and
+/// its near and far planes only with `depth_planes`.
+pub(super) fn shadow_box(view: &ShadowView) -> Frustum {
+    let mut planes = frustum(view.cull);
+    if !view.depth_planes {
+        // `frustum`'s faces at depth 0 and 1 take in everything.
+        planes[4] = Vec4::W;
+        planes[5] = Vec4::W;
+    }
+    Frustum { planes }
+}
+
+/// The runs of a section's solid quads the shadow pass draws: every face within the unculled
+/// distance, or everywhere for `every_face`; else the quads that can face the light.
+pub(super) fn shadow_runs(
+    sides: &Sides,
+    view: &ShadowView,
+    origin: [f32; 3],
+    draw: impl FnMut(u32, u32),
+) {
+    let unculled = view.unculled.is_some_and(|d| {
+        let o = Vec3::from(origin) + 8.0;
+        o.x.abs().max(o.z.abs()) <= d + 8.0
+    });
+    let toward = (!unculled && !view.every_face).then_some(view.light * 1.0e5);
+    facing_runs(sides, toward, origin, draw);
+}
+
+/// The camera's view `view_proj` (wgpu depth, reversed or not) stretched without end toward
+/// `light` (a direction): the boxes whose shadow, cast away from the light, can fall into the
+/// view. Its planes are the view's faces turned toward the light, and through each edge between
+/// such a face and one turned away, the plane along the light; unused ones take in everything.
+pub(super) fn shadow_casters(view_proj: Mat4, light: Vec3) -> [Frustum; 2] {
+    let faces = frustum(view_proj);
+    let toward = faces.map(|p| p.truncate().dot(light) >= 0.0);
+    let inverse = view_proj.inverse();
+    // Corner (x, y, z) of clip space's box; `frustum`'s faces at x -1 and 1 are 0 and 1, at
+    // y -1 and 1 are 2 and 3, at depth 0 and 1 are 4 and 5.
+    let corner = |c: [usize; 3]| {
+        inverse.project_point3(Vec3::new(
+            c[0] as f32 * 2.0 - 1.0,
+            c[1] as f32 * 2.0 - 1.0,
+            c[2] as f32,
+        ))
+    };
+    let corners: Vec<[usize; 3]> = (0..8).map(|i| [i & 1, (i >> 1) & 1, i >> 2]).collect();
+    let centre = corners.iter().map(|&c| corner(c)).sum::<Vec3>() / 8.0;
+    let mut planes = [Vec4::W; 12];
+    let mut n = 0;
+    for (k, &face) in faces.iter().enumerate() {
+        if toward[k] {
+            planes[n] = face;
+            n += 1;
+        }
+    }
+    for a in &corners {
+        for axis in 0..3 {
+            if a[axis] == 1 {
+                continue;
+            }
+            let mut b = *a;
+            b[axis] = 1;
+            // The edge from a to b lies on the faces of the two other axes.
+            let [f, g] = [(axis + 1) % 3, (axis + 2) % 3].map(|o| o * 2 + a[o]);
+            if toward[f] == toward[g] {
+                continue;
+            }
+            let (p, q) = (corner(*a), corner(b));
+            let normal = (q - p).cross(light);
+            if normal.length_squared() < 1e-12 {
+                continue;
+            }
+            let normal = normal.normalize();
+            let side = if normal.dot(centre - p) < 0.0 {
+                -1.0
+            } else {
+                1.0
+            };
+            // At most six such edges with at most four faces toward the light: 12 planes.
+            if let Some(plane) = planes.get_mut(n) {
+                *plane = (normal * side).extend(-normal.dot(p) * side);
+                n += 1;
+            }
+        }
+    }
+    let [a, b] = [0, 6].map(|i| Frustum {
+        planes: planes[i..i + 6].try_into().expect("six planes"),
+    });
+    [a, b]
+}
@@ -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.
@@ -9,11 +9,20 @@
@group(0) @binding(12) var<storage, read> box_sections: array<Section>;

 // The corners (bit 0: x, bit 1: y, bit 2: z) of the box's 12 triangles,
-// counter-clockwise seen from outside (cull.wgsl's).
-const CORNERS = array<u32, 36>(
-    0u, 6u, 2u, 0u, 4u, 6u, 1u, 3u, 7u, 1u, 7u, 5u, 0u, 1u, 5u, 0u, 5u, 4u,
-    2u, 7u, 3u, 2u, 6u, 7u, 0u, 3u, 1u, 0u, 2u, 3u, 4u, 5u, 7u, 4u, 7u, 6u,
-);
+// counter-clockwise seen from outside (cull.wgsl's `box_triangle_corner`).
+// Packed four bits each, eight a word, read through a switch: a constant array indexed by the
+// vertex would be a private array, which Adreno's Vulkan compiler (build 0676.41) fails to link.
+fn box_triangle_corner(v: u32) -> u32 {
+    var word: u32;
+    switch v / 8u {
+        case 0u: { word = 0x31640260u; }
+        case 1u: { word = 0x05105717u; }
+        case 2u: { word = 0x76237245u; }
+        case 3u: { word = 0x54320130u; }
+        default: { word = 0x00006747u; }
+    }
+    return (word >> (v % 8u * 4u)) & 0xfu;
+}

 struct BoxOut {
    @builtin(position) position: vec4<f32>,
@@ -26,7 +35,7 @@ fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box
    let o = bitcast<vec3<f32>>(box_origins[id].xyz);
    var out: BoxOut;
    out.id = id;
-    out.position = params.view_proj * vec4(box_corner(o, box_sections[id].a.z, CORNERS[v]), 1.0);
+    out.position = params.view_proj * vec4(box_corner(o, box_sections[id].a.z, box_triangle_corner(v)), 1.0);
    return out;
 }

@@ -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,
    }
 }

@@ -42,6 +42,8 @@ const DISTANT_SQR: f64 = 3600.0;
 const SECTION_DIAGONAL: f64 = 28.0;
 /// In `Graph::rays`: the line from this corner stays in reached sections.
 const SEES: u8 = u8::MAX;
+/// Edits kept before a full resend.
+const EDIT_CAP: usize = 1 << 16;

 /// VisGraph connectivity per column, one entry per section (bottom first).
 /// A missing column or section connects every face.
@@ -611,6 +613,8 @@ pub struct Occlusion {
    queue: VecDeque<u32>,
    /// Changes whenever `contains` may answer differently (`generation`).
    generation: u64,
+    /// Set when edits were dropped; the next search resends every column.
+    resync: bool,
 }

 impl Occlusion {
@@ -631,6 +635,7 @@ impl Occlusion {
            vis: Vec::new(),
            queue: VecDeque::new(),
            generation: next_generation(),
+            resync: false,
        }
    }
    pub fn set(&mut self, key: SectionKey, vis: u64) {
@@ -639,13 +644,35 @@ impl Occlusion {
        }
    }
    fn changed(&mut self, key: SectionKey, vis: u64) {
-        self.edits.push(Edit::Set(key, vis));
        self.dirty = true;
+        if self.edits.len() >= EDIT_CAP || self.changed.len() >= EDIT_CAP {
+            // nobody drains these with cave culling off
+            self.resync = true;
+            self.edits.clear();
+            self.changed.clear();
+            self.changed_late.clear();
+        }
+        if self.resync {
+            return;
+        }
+        self.edits.push(Edit::Set(key, vis));
        self.changed.push(key);
        if self.running.is_some() {
            self.changed_late.push(key);
        }
    }
+    fn resync_edits(&mut self) {
+        self.resync = false;
+        self.edits.clear();
+        self.edits.push(Edit::Clear);
+        for (&(x, z), column) in &self.columns.map {
+            for (y, &vis) in column.iter().enumerate() {
+                if vis != ALL_VISIBLE {
+                    self.edits.push(Edit::Set((x, y as i32, z), vis));
+                }
+            }
+        }
+    }
    /// Every section of the column `x`, `z` goes (sees through every face).
    pub fn remove_column(&mut self, x: i32, z: i32) {
        let Some(column) = self.columns.map.remove(&(x, z)) else {
@@ -674,6 +701,7 @@ impl Occlusion {
        self.columns.map.clear();
        self.edits.clear();
        self.edits.push(Edit::Clear);
+        self.resync = false;
        self.dirty = true;
        // Another world: the old graph says nothing about it. Without one, every
        // section was visible already, and stays so.
@@ -769,6 +797,9 @@ impl Occlusion {
        let from = self.columns.section_of(camera);
        self.dirty = false;
        self.searched = Some((from, radius));
+        if self.resync {
+            self.resync_edits();
+        }
        let graph = std::mem::take(&mut self.spare);
        if let Some(worker) = &self.worker {
            let job = Job {
@@ -1793,4 +1824,36 @@ mod tests {
        assert_ne!(answers(&o, around, spread + radius), walled.1);
        assert_ne!(o.generation(), walled.0, "the graph went");
    }
+
+    #[test]
+    fn edit_queue_stays_bounded_without_searches() {
+        let mut o = Occlusion::new(0, 4);
+        let total = (1usize << 16) + 5000;
+        for i in 0..total {
+            o.set(((i % 700) as i32, 1, (i / 700) as i32), 1 + (i as u64 % 5));
+        }
+        assert!(o.edits.len() <= 1 << 16, "{} edits queued", o.edits.len());
+        assert!(
+            o.changed.len() <= 1 << 16,
+            "{} changed queued",
+            o.changed.len()
+        );
+
+        let mut fresh = Occlusion::new(0, 4);
+        for (&(x, z), column) in &o.columns.map {
+            for (y, &vis) in column.iter().enumerate() {
+                fresh.set((x, y as i32, z), vis);
+            }
+        }
+        let camera = at((0, 1, 0));
+        for _ in 0..2 {
+            o.settle(camera, 6);
+            fresh.settle(camera, 6);
+        }
+        assert_eq!(
+            reached(&o),
+            reached(&fresh),
+            "the worker saw the same world"
+        );
+    }
 }
@@ -295,6 +295,22 @@ pub(crate) fn resolve_output(
    }
 }

+/// Whether HDR output lifts the world's light-source marks above paper white. Not on the title
+/// screen or the float frame, and not under a pack that lights its world itself: a 0.2 pack is
+/// shown at paper white, and a `shaders/` pack's `final` pass leaves its own alpha in the
+/// frame, which isn't marks (HDR lighting is off under it too).
+pub(crate) fn lifts_world(
+    title: bool,
+    float_frame: bool,
+    shaders_pack: bool,
+    native_api: Option<horizon_shader_api::Api>,
+) -> bool {
+    !title
+        && !float_frame
+        && !shaders_pack
+        && native_api.is_none_or(|api| api == horizon_shader_api::Api::V0_1)
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
    use super::*;
@@ -337,6 +353,29 @@ pub(crate) mod tests {
        resolve_output(settings, caps, reading, frame, true)
    }

+    /// HDR output lifts light-source marks only on the 8/16-bit frame's world with no pack or
+    /// a 0.1 pack: a `shaders/` pack's alpha isn't marks, and a 0.2 pack is shown at paper white.
+    #[test]
+    fn only_horizons_own_gamma_world_is_lifted() {
+        use horizon_shader_api::Api::{V0_1, V0_2};
+        // (title, float frame, `shaders/` pack, Horizon pack) -> lifts
+        let cases = [
+            ((false, false, false, None), true),
+            ((false, false, false, Some(V0_1)), true),
+            ((false, false, true, None), false),
+            ((false, false, false, Some(V0_2)), false),
+            ((false, true, false, None), false),
+            ((true, false, false, None), false),
+        ];
+        for ((title, float, shaders, api), lifts) in cases {
+            assert_eq!(
+                lifts_world(title, float, shaders, api),
+                lifts,
+                "title {title}, float {float}, shaders/ pack {shaders}, pack {api:?}"
+            );
+        }
+    }
+
    /// Every mode against every offer, system report, pack and device: HDR output only where
    /// the mode asks for it and the destination offers it, and the frame each combination
    /// draws in, as `Renderer::new` picked it before the snapshot.
@@ -666,34 +666,52 @@ const FACE: &str = "    vec3 hz_p0 = uintBitsToFloat(hz_cp0);\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 {
@@ -852,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,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,
@@ -5,6 +5,7 @@
 use std::collections::BTreeMap;

 use horizon_shaders::{BufferObject, CustomImage, Format, Kind};
+use wgpu::util::DeviceExt;

 pub(super) struct PackImage {
    pub(super) def: CustomImage,
@@ -468,19 +469,33 @@ impl Buffers {
            .iter()
            .map(|(binding, o)| {
                let least = self.minimums.get(binding).copied().unwrap_or(0);
-                let wanted = buffer_size(*o, size, least);
+                let wanted = buffer_size(o, size, least);
                if wanted > largest {
                    log::warn!(
                        "shader pack: bufferObject.{binding} wants {wanted} bytes, this device \
                         binds at most {largest}"
                    );
                }
-                device.create_buffer(&wgpu::BufferDescriptor {
-                    label: Some("Shader pack buffer"),
-                    size: wanted.min(largest),
-                    usage: wgpu::BufferUsages::STORAGE,
-                    mapped_at_creation: false,
-                })
+                let size = wanted.min(largest);
+                // A buffer the pack initializes from a file starts with the file's bytes, the
+                // rest of it zero.
+                match o.initial_data() {
+                    Some(data) => {
+                        let mut contents = data.to_vec();
+                        contents.resize(size as usize, 0);
+                        device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                            label: Some("Shader pack buffer"),
+                            contents: &contents,
+                            usage: wgpu::BufferUsages::STORAGE,
+                        })
+                    }
+                    None => device.create_buffer(&wgpu::BufferDescriptor {
+                        label: Some("Shader pack buffer"),
+                        size,
+                        usage: wgpu::BufferUsages::STORAGE,
+                        mapped_at_creation: false,
+                    }),
+                }
            })
            .collect();
        let entries: Vec<_> = self
@@ -509,7 +524,7 @@ impl Buffers {
 /// The bytes a storage buffer is made with for a render size of `render`: what the pack
 /// declares, or more when a shader binds it as a larger block (`least`), which wgpu needs where
 /// OpenGL binds the smaller buffer; a multiple of 4.
-fn buffer_size(object: BufferObject, render: [u32; 2], least: u64) -> u64 {
+fn buffer_size(object: &BufferObject, render: [u32; 2], least: u64) -> u64 {
    object.size(render).max(least).next_multiple_of(4)
 }

@@ -612,18 +627,18 @@ mod tests {
    /// bound as a 48-byte block failed wgpu's validation, #7178); a larger one keeps its size.
    #[test]
    fn a_buffer_is_at_least_its_shaders_block() {
-        assert_eq!(buffer_size(BufferObject::Bytes(40), [1, 1], 48), 48);
+        assert_eq!(buffer_size(&BufferObject::Bytes(40), [1, 1], 48), 48);
        assert_eq!(
-            buffer_size(BufferObject::Bytes(40980), [1, 1], 40992),
+            buffer_size(&BufferObject::Bytes(40980), [1, 1], 40992),
            40992
        );
-        assert_eq!(buffer_size(BufferObject::Bytes(100), [1, 1], 48), 100);
-        assert_eq!(buffer_size(BufferObject::Bytes(41), [1, 1], 0), 44);
+        assert_eq!(buffer_size(&BufferObject::Bytes(100), [1, 1], 48), 100);
+        assert_eq!(buffer_size(&BufferObject::Bytes(41), [1, 1], 0), 44);
        let per_pixel = BufferObject::PerPixel {
            bytes: 4,
            scale: [0.5, 0.5],
        };
-        assert_eq!(buffer_size(per_pixel, [10, 10], 64), 100);
-        assert_eq!(buffer_size(per_pixel, [4, 4], 64), 64);
+        assert_eq!(buffer_size(&per_pixel, [10, 10], 64), 100);
+        assert_eq!(buffer_size(&per_pixel, [4, 4], 64), 64);
    }
 }
@@ -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,
@@ -1201,31 +1201,7 @@ pub(super) type TerrainDraw<'a> = dyn FnMut(
        Option<(u32, &wgpu::BindGroupLayout)>,
    ) + 'a;

-/// What the shadow camera sees of the terrain, for the game's draw lists: its view and
-/// projection in wgpu's clip space, the direction toward the light, and how far from the camera
-/// terrain is drawn (`shadowDistanceRenderMul`).
-pub(super) struct ShadowView {
-    pub cull: glam::Mat4,
-    pub light: glam::Vec3,
-    pub distance: Option<f32>,
-    /// Draw everything, every face, within this many blocks (`shadow.culling=false|reversed`):
-    /// packs that voxelize the world in their shadow pass need all of it.
-    pub unculled: Option<f32>,
-    /// Every face of the drawn sections, not only those that can face the light. Iris 1.11.7's
-    /// shadow map holds the faces turned away from the light too (#9033): under a hill at low sun
-    /// a cave's ceiling, which faces away, is often all that shadows the cave.
-    pub every_face: bool,
-    /// Only the sections whose shadow can fall into the camera's view: those the camera's
-    /// frustum, stretched toward the light, takes in (`shadow_casters`). Our probes' Iris 1.11.7
-    /// maps fit keeping only those with `shadow.culling` unset (#8464): under a noon sun, only
-    /// the terrain above the ground the camera sees; with a low sun ahead, none behind the camera.
-    pub view_casters: bool,
-    /// Whether the projection's near and far planes in `cull` drop sections too. Our probes'
-    /// Iris 1.11.7 maps hold the terrain at every depth we put it along the light (from 535 blocks
-    /// beyond the shadow camera to about 120 before it), whatever `shadowNearPlane` and
-    /// `shadowFarPlane` the pack sets, or none (#10403): only its sides cull.
-    pub depth_planes: bool,
-}
+pub(super) use super::external::ShadowView;

 /// An arena page's key, native vertices and optional per-quad source records.
 pub(super) type TerrainPage = (u32, wgpu::Buffer, Option<wgpu::Buffer>);
@@ -2964,17 +2940,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) => {}
        }
@@ -3835,7 +3807,7 @@ impl PackPost {
            timestamp_writes: self
                .timing
                .as_mut()
-                .and_then(|t| t.compute_writes(&pass.name)),
+                .and_then(|t| t.compute_writes(&format!("{} (compute)", pass.name))),
        });
        cp.set_pipeline(&pipeline);
        cp.set_bind_group(0, &group, &[]);
@@ -3911,8 +3883,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,
@@ -151,7 +151,9 @@ impl PassTiming {
        Some(stamps(&self.queries, i))
    }

-    /// Timestamp writes for the compute pass `name`, in a timed frame.
+    /// Timestamp writes for the compute pass `name`, in a timed frame. Shader packs' compute
+    /// passes come as `<program> (compute)`, apart from the fragment program of the same name
+    /// (`deferred2.csh` beside `deferred2.fsh`), whose time theirs would otherwise add to.
    pub fn compute_writes(&mut self, name: &str) -> Option<wgpu::ComputePassTimestampWrites<'_>> {
        let i = self.push(name)?;
        Some(compute_stamps(&self.queries, i))
@@ -236,23 +238,7 @@ impl PassTiming {
        drop(data);
        self.read.unmap();
        let times = pass_times(&stamps, self.period_ns);
-        for (name, ms) in self.names.iter().zip(times) {
-            let Some(ms) = ms.filter(|_| !name.is_empty()) else {
-                continue;
-            };
-            let i = match self.samples.iter().position(|s| s.0 == *name) {
-                Some(i) => i,
-                None => {
-                    self.samples.push((name.clone(), VecDeque::new()));
-                    self.samples.len() - 1
-                }
-            };
-            let window = &mut self.samples[i].1;
-            if window.len() == WINDOW {
-                window.pop_front();
-            }
-            window.push_back(ms);
-        }
+        record(&mut self.samples, self.names.iter().zip(times));
        self.reports += 1;
        if self.log && self.reports.is_multiple_of(REPORT) {
            let medians = self.medians();
@@ -283,6 +269,40 @@ impl PassTiming {
    }
 }

+/// Adds one timed frame's pass times to `samples`, each pass's window of its last `WINDOW`
+/// frames. Passes of one name in a frame (a program drawn over several render passes) count as
+/// one sample, their sum: as separate samples they shared one window, and its median was the
+/// time of neither. Unnamed and unstamped passes are left out.
+fn record<'a>(
+    samples: &mut Vec<(String, VecDeque<f32>)>,
+    frame: impl Iterator<Item = (&'a String, Option<f32>)>,
+) {
+    let mut sums: Vec<(&str, f32)> = Vec::new();
+    for (name, ms) in frame {
+        let Some(ms) = ms.filter(|_| !name.is_empty()) else {
+            continue;
+        };
+        match sums.iter_mut().find(|s| s.0 == name) {
+            Some(s) => s.1 += ms,
+            None => sums.push((name, ms)),
+        }
+    }
+    for (name, ms) in sums {
+        let i = match samples.iter().position(|s| s.0 == name) {
+            Some(i) => i,
+            None => {
+                samples.push((name.to_owned(), VecDeque::new()));
+                samples.len() - 1
+            }
+        };
+        let window = &mut samples[i].1;
+        if window.len() == WINDOW {
+            window.pop_front();
+        }
+        window.push_back(ms);
+    }
+}
+
 /// Pass `i`'s beginning and end timestamps.
 fn stamps(queries: &wgpu::QuerySet, i: u32) -> wgpu::RenderPassTimestampWrites<'_> {
    wgpu::RenderPassTimestampWrites {
@@ -323,7 +343,21 @@ fn pass_times(stamps: &[u64], period_ns: f32) -> Vec<Option<f32>> {

 #[cfg(test)]
 mod tests {
-    use super::pass_times;
+    use super::{pass_times, record};
+    use std::collections::VecDeque;
+
+    #[test]
+    fn passes_of_one_name_count_as_their_sum() {
+        let names = ["terrain", "sky", "terrain", "", "water"].map(String::from);
+        let times = [Some(1.0), Some(2.0), Some(3.0), Some(9.0), None];
+        let mut samples: Vec<(String, VecDeque<f32>)> = Vec::new();
+        record(&mut samples, names.iter().zip(times));
+        let got: Vec<(&str, Vec<f32>)> = samples
+            .iter()
+            .map(|(n, w)| (n.as_str(), w.iter().copied().collect()))
+            .collect();
+        assert_eq!(got, [("terrain", vec![4.0]), ("sky", vec![2.0])]);
+    }

    #[test]
    fn overlapping_passes_cost_from_the_previous_end() {
@@ -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,
@@ -399,6 +399,20 @@ impl Rotation {
 #[cfg(test)]
 mod tests {
    use super::*;
+
+    /// CubeMap's cube: its corners' indices, six faces of two triangles.
+    #[test]
+    fn the_packed_cube_corners_are_cubemaps_indices() {
+        let indices = [
+            4, 7, 6, 4, 6, 5, 5, 6, 2, 5, 2, 1, 1, 2, 3, 1, 3, 0, 0, 3, 7, 0, 7, 4, 7, 3, 2, 7, 2,
+            6, 0, 4, 5, 0, 5, 1,
+        ];
+        let source = include_str!("panorama.wgsl");
+        assert_eq!(
+            super::super::cull::packed_lookup(source, "cube_corner", 36),
+            indices
+        );
+    }
    use std::{
        fs,
        sync::atomic::{AtomicU32, Ordering},
@@ -8,19 +8,27 @@ struct Out {
    @builtin(position) clip: vec4<f32>,
    @location(0) direction: vec3<f32>,
 }
+// The cube's corner of each of its 36 vertices (CubeMap's indices): 4 7 6, 4 6 5, 5 6 2,
+// 5 2 1, 1 2 3, 1 3 0, 0 3 7, 0 7 4, 7 3 2, 7 2 6, 0 4 5, 0 5 1.
+// Packed four bits each, eight a word, read through a switch: a constant array indexed by the
+// vertex would be a private array, which Adreno's Vulkan compiler (build 0676.41) fails to link.
+fn cube_corner(v: u32) -> u32 {
+    var word: u32;
+    switch v / 8u {
+        case 0u: { word = 0x65564674u; }
+        case 1u: { word = 0x13211252u; }
+        case 2u: { word = 0x47073003u; }
+        case 3u: { word = 0x40627237u; }
+        default: { word = 0x00001505u; }
+    }
+    return (word >> (v % 8u * 4u)) & 0xfu;
+}
@vertex fn vs_panorama(@builtin(vertex_index) index: u32) -> Out {
-    let corners = array<vec3<f32>, 8>(
-        vec3(-1.0, -1.0, -1.0), vec3(1.0, -1.0, -1.0),
-        vec3(1.0, 1.0, -1.0), vec3(-1.0, 1.0, -1.0),
-        vec3(-1.0, -1.0, 1.0), vec3(1.0, -1.0, 1.0),
-        vec3(1.0, 1.0, 1.0), vec3(-1.0, 1.0, 1.0),
-    );
-    let indices = array<u32, 36>(
-        4, 7, 6, 4, 6, 5, 5, 6, 2, 5, 2, 1,
-        1, 2, 3, 1, 3, 0, 0, 3, 7, 0, 7, 4,
-        7, 3, 2, 7, 2, 6, 0, 4, 5, 0, 5, 1,
-    );
-    let position = corners[indices[index]];
+    // CubeMap's corners: -1 or 1 on each axis, x 1 at corners 1, 2, 5 and 6, y at 2, 3, 6
+    // and 7, z at 4 to 7.
+    let c = cube_corner(index);
+    let high = vec3((c ^ (c >> 1u)) & 1u, c & 2u, c & 4u) != vec3(0u);
+    let position = select(vec3(-1.0), vec3(1.0), high);
    var out: Out;
    out.clip = projection.view_proj * vec4(position, 1.0);
    out.direction = position;
@@ -221,6 +221,18 @@ pub(super) async fn open_adapter(
        configured,
    })
 }
+/// Logs a sprite split below the CPU's (the GPU's limit), and warns when Metal's arrays grew
+/// past 512 layers (#12155), so a big pack's texture-corruption report ties to it (#8471).
+pub(super) fn log_sprite_split(info: &wgpu::AdapterInfo, split: u32, layers: u32) {
+    if info.backend == wgpu::Backend::Metal && split > 512 {
+        log::warn!(
+            "Horizon: {split}-layer Metal sprite arrays for {layers} on {}",
+            info.name
+        );
+    } else if split < super::sprite_split() {
+        log::info!("Horizon: {split} block textures per array (the GPU's limit)");
+    }
+}
 #[cfg(test)]
 mod tests {
    use super::{AdapterChoice, pick_adapter};
@@ -1897,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);
@@ -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);
 }
@@ -12,8 +12,11 @@ use std::{
 };
 use wgpu::util::DeviceExt;

+use model_reducing::reducible_model_sprites;
+
 mod animate;
 pub mod cit_glint;
+mod model_reducing;
 mod pack_text;
 pub mod pictures;
 pub(crate) mod sprite_modifiers;
@@ -52,7 +55,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 +390,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
@@ -1057,25 +1060,6 @@ impl HudAtlas {
            blinks: Default::default(),
        }
    }
-    /// `layout`, but when `extras` (Custom Item Textures) make the images more than `max`
-    /// holds, without them: they are left out, not the packs.
-    fn layout_leaving_out(
-        images: &mut Vec<PackedImage>,
-        animated: &mut Vec<String>,
-        extras: &HashSet<String>,
-        max: u32,
-    ) -> Result<(u32, Vec<(u32, u32)>, u32)> {
-        match Self::layout(images, max) {
-            Err(e) if !extras.is_empty() => {
-                images.retain(|i| !extras.contains(&i.0));
-                animated.retain(|n| !extras.contains(n));
-                let layout = Self::layout(images, max)?;
-                log::warn!("left out the custom item textures: {e}");
-                Ok(layout)
-            }
-            layout => layout,
-        }
-    }
    /// Shelf placements of `images` (tallest first) in the narrowest atlas
    /// width from 4096 up that keeps the atlas, glyph rows included, within
    /// `max` texels a side; and the first row free for glyphs. High-resolution
@@ -1460,7 +1444,20 @@ impl HudAtlas {
        }
        images.sort_by(|a, b| b.2.cmp(&a.2).then(b.1.cmp(&a.1)));
        let (width, placements, glyph_region) =
-            Self::layout_leaving_out(&mut images, &mut animated, &cit_names, MAX_ATLAS_SIZE)?;
+            Self::layout_leaving_out(&mut images, &mut animated, &cit_names, MAX_ATLAS_SIZE)
+                .or_else(|error| -> Result<_> {
+                    let models = reducible_model_sprites(root, &images, &bordered);
+                    let layout = Self::layout_reducing_models(
+                        &mut images,
+                        &mut gui_sizes,
+                        &models,
+                        MAX_ATLAS_SIZE,
+                    )?;
+                    log::warn!(
+                        "reduced HUD model texture resolution to keep the resource pack: {error}"
+                    );
+                    Ok(layout)
+                })?;
        // A multiple of 1024 rather than a power of two: the default resources
        // need 4096x5120 (8192 rows before), Faithful 32x 4096x12288 (16384).
        let height = (glyph_region + GLYPH_ROWS).next_multiple_of(1024);
@@ -3110,6 +3107,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();
@@ -3766,6 +3775,47 @@ mod tests {
        assert_eq!(banner.texels((atlas.width, atlas.height)), (16, 32));
    }
    #[test]
+    fn a_root_single_sprite_strip_taller_than_the_atlas_packs_one_frame() {
+        let root = animated_root();
+        let atlases = root.join("assets/minecraft/atlases");
+        fs::create_dir_all(&atlases).unwrap();
+        fs::write(
+            atlases.join("items.json"),
+            r#"{"sources":[{"type":"single","resource":"nexo:abc123"},
+                {"type":"single","resource":"nexo:still"}]}"#,
+        )
+        .unwrap();
+        // Plugin-generated names need no item/ prefix. Keep the production
+        // strip's height, but use narrow frames to keep this fixture cheap.
+        let textures = root.join("assets/nexo/textures");
+        fs::create_dir_all(&textures).unwrap();
+        write_strip(
+            &textures.join("abc123.png"),
+            16,
+            32768,
+            &[[255, 0, 0, 255], [0, 0, 255, 255]],
+            Some(r#"{"animation":{"frames":[1024,0],"frametime":3}}"#),
+        );
+        write_strip(&textures.join("still.png"), 16, 32, &[[7, 8, 9, 255]], None);
+        let atlas = HudAtlas::build(&root).unwrap();
+        let _ = fs::remove_dir_all(&root);
+        let rect = atlas.sprites["nexo:abc123"];
+        assert_eq!(rect.texels((atlas.width, atlas.height)), (16, 16));
+        assert_eq!(texel_at(&atlas, rect, 0, 15), [0, 0, 255, 255]);
+        let (_, animation) = atlas
+            .sprite_animations
+            .iter()
+            .find(|(r, _)| r.u0 == rect.u0 && r.v0 == rect.v0)
+            .expect("the root-level single sprite animates");
+        assert_eq!(animation.frame(0), 1024);
+        assert_eq!(animation.frame(3), 0);
+        assert_eq!(animation.frame_count(), 2048);
+        assert_eq!(
+            atlas.sprites["nexo:still"].texels((atlas.width, atlas.height)),
+            (16, 32)
+        );
+    }
+    #[test]
    fn an_animated_gui_sprite_packs_its_first_frame_and_animates() {
        let root =
            std::env::temp_dir().join(format!("horizon-atlas-gui-anim-{}", std::process::id()));
@@ -4172,6 +4222,93 @@ texture=wide",
        assert_inside(&images, width, &placements, free);
    }
    #[test]
+    fn model_resolution_fallback_protects_font_sources_and_gui_aliases() {
+        let root = animated_root();
+        write_png(&root, "item/font_sheet", 32, 32);
+        write_png(&root, "gui/panel", 32, 32);
+        write_png(&root, "hash", 32, 32);
+        let font = root.join("assets/minecraft/font/default.json");
+        fs::create_dir_all(font.parent().unwrap()).unwrap();
+        fs::write(
+            font,
+            r#"{"providers":[{"type":"bitmap","file":"minecraft:item/font_sheet.png","ascent":7,"chars":["a"]}]}"#,
+        ).unwrap();
+        let atlases = root.join("assets/minecraft/atlases");
+        fs::create_dir_all(&atlases).unwrap();
+        fs::write(
+            atlases.join("items.json"),
+            r#"{"sources":[
+                {"type":"single","resource":"item/font_sheet","sprite":"font_alias"},
+                {"type":"single","resource":"gui/panel","sprite":"gui_alias"},
+                {"type":"single","resource":"hash"}
+            ]}"#,
+        )
+        .unwrap();
+        let images = vec![
+            ("item/font_sheet".to_owned(), 32, 32, Vec::new()),
+            ("item/blurred".to_owned(), 32, 32, Vec::new()),
+            ("block/stone".to_owned(), 32, 32, Vec::new()),
+        ];
+        let models =
+            reducible_model_sprites(&root, &images, &HashSet::from(["item/blurred".to_owned()]));
+        let _ = fs::remove_dir_all(root);
+        assert_eq!(
+            models,
+            HashSet::from(["hash".to_owned(), "block/stone".to_owned()])
+        );
+    }
+    #[test]
+    fn overflowing_model_textures_shrink_without_changing_gui_sizes_or_slots() {
+        let mut images = vec![
+            (
+                "nexo:hash".into(),
+                1024,
+                1024,
+                [10, 20, 30, 255].repeat(1024 * 1024),
+            ),
+            (
+                "gui/panel".into(),
+                32,
+                32,
+                [40, 50, 60, 255].repeat(32 * 32),
+            ),
+            ("horizon/map".into(), 128, 128, Vec::new()),
+        ];
+        let models = HashSet::from(["nexo:hash".to_owned(), "horizon/map".to_owned()]);
+        let mut sizes = HashMap::new();
+        assert!(HudAtlas::layout(&images, 1024).is_err());
+        let (width, placements, free) =
+            HudAtlas::layout_reducing_models(&mut images, &mut sizes, &models, 1024).unwrap();
+        assert_inside(&images, width, &placements, free);
+        assert!(free + GLYPH_ROWS <= 1024);
+        let model = images.iter().find(|i| i.0 == "nexo:hash").unwrap();
+        assert_eq!((model.1, model.2), (256, 256));
+        assert_eq!(model.3, [10, 20, 30, 255].repeat(256 * 256));
+        assert_eq!(sizes["nexo:hash"], (1024, 1024));
+        let gui = images.iter().find(|i| i.0 == "gui/panel").unwrap();
+        assert_eq!((gui.1, gui.2), (32, 32));
+        assert_eq!(gui.3, [40, 50, 60, 255].repeat(32 * 32));
+        let slot = images.iter().find(|i| i.0 == "horizon/map").unwrap();
+        assert_eq!((slot.1, slot.2), (128, 128));
+        assert!(slot.3.is_empty());
+    }
+    #[test]
+    fn fitting_models_keep_their_pixels_and_existing_logical_sizes() {
+        let mut images = vec![("item/gem".into(), 32, 32, [1, 2, 3, 255].repeat(32 * 32))];
+        let original = images.clone();
+        let mut sizes = HashMap::from([("item/gem".to_owned(), (16, 16))]);
+        let models = HashSet::from(["item/gem".to_owned()]);
+        HudAtlas::layout_reducing_models(&mut images, &mut sizes, &models, 1024).unwrap();
+        assert_eq!(images, original);
+        assert_eq!(sizes["item/gem"], (16, 16));
+        // Protected oversized images remain an error; no unbounded retry or
+        // silent removal of GUI/font resources when shrinking cannot help.
+        images.push(("font/sheet".into(), 1024, 1024, Vec::new()));
+        assert!(HudAtlas::layout_reducing_models(&mut images, &mut sizes, &models, 1024).is_err());
+        assert_eq!((images[0].1, images[0].2), (1024, 1024));
+        assert_eq!(sizes["item/gem"], (16, 16));
+    }
+    #[test]
    fn textures_that_cannot_fit_are_an_error_not_a_gpu_panic() {
        let error = HudAtlas::layout(&sized(300, 1024, 1024), MAX_ATLAS_SIZE).unwrap_err();
        assert!(error.to_string().contains("do not fit a 16384x16384 atlas"));
@@ -0,0 +1,105 @@
+//! Resolution fallback for model textures that exceed the shared HUD atlas.
+use super::{HashMap, HashSet, HudAtlas, PackedImage, Path, Result, bitmap_font_textures};
+
+/// Only model atlas sprites may lose resolution. Font sheets can also be
+/// model textures, so protect both their file names and renamed sources.
+pub(super) fn reducible_model_sprites(
+    root: &Path,
+    images: &[PackedImage],
+    bordered: &HashSet<String>,
+) -> HashSet<String> {
+    use crate::atlas_sources::{self, SpriteOrigin};
+    let fonts: HashSet<_> = bitmap_font_textures(root).into_iter().collect();
+    let protected = |name: &str| {
+        let path = name.split_once(':').map_or(name, |(_, path)| path);
+        path.starts_with("gui/")
+            || path.starts_with("font/")
+            || fonts.contains(&atlas_sources::texture_path(root, name, "textures"))
+    };
+    let mut models: HashSet<String> = images
+        .iter()
+        .filter(|(name, ..)| name.starts_with("item/") || name.starts_with("block/"))
+        .map(|(name, ..)| name.clone())
+        .collect();
+    let textures = atlas_sources::list_textures(root);
+    let mut protected_aliases = HashSet::new();
+    for (atlas, sources) in atlas_sources::atlases(root) {
+        if atlas != "minecraft:blocks" && atlas != "minecraft:items" {
+            continue;
+        }
+        for (id, origin) in atlas_sources::list(&sources, &textures) {
+            let name = id.strip_prefix("minecraft:").unwrap_or(&id).to_owned();
+            if let SpriteOrigin::File(texture) = origin {
+                if protected(&texture) {
+                    protected_aliases.insert(name);
+                } else {
+                    models.insert(name);
+                }
+            }
+        }
+    }
+    models.retain(|name| {
+        !bordered.contains(name) && !protected(name) && !protected_aliases.contains(name)
+    });
+    models
+}
+
+impl HudAtlas {
+    /// `layout`, but when `extras` (Custom Item Textures) make the images more than `max`
+    /// holds, without them: they are left out, not the packs.
+    pub(super) fn layout_leaving_out(
+        images: &mut Vec<PackedImage>,
+        animated: &mut Vec<String>,
+        extras: &HashSet<String>,
+        max: u32,
+    ) -> Result<(u32, Vec<(u32, u32)>, u32)> {
+        match Self::layout(images, max) {
+            Err(e) if !extras.is_empty() => {
+                images.retain(|i| !extras.contains(&i.0));
+                animated.retain(|n| !extras.contains(n));
+                let layout = Self::layout(images, max)?;
+                log::warn!("left out the custom item textures: {e}");
+                Ok(layout)
+            }
+            layout => layout,
+        }
+    }
+    /// Last resort for a pack that exceeds the shared atlas: halve model
+    /// textures until they fit, retaining their logical GUI sizes. Never
+    /// shrink run-time slots (empty pixels), or below the vanilla 16 texels.
+    pub(super) fn layout_reducing_models(
+        images: &mut [PackedImage],
+        gui_sizes: &mut HashMap<String, (u32, u32)>,
+        models: &HashSet<String>,
+        max: u32,
+    ) -> Result<(u32, Vec<(u32, u32)>, u32)> {
+        loop {
+            let error = match Self::layout(images, max) {
+                Ok(layout) => return Ok(layout),
+                Err(error) => error,
+            };
+            let mut changed = false;
+            for (name, w, h, pixels) in images.iter_mut() {
+                if !models.contains(name) || pixels.is_empty() || (*w <= 16 && *h <= 16) {
+                    continue;
+                }
+                let (nw, nh) = ((*w / 2).max((*w).min(16)), (*h / 2).max((*h).min(16)));
+                let mut scaled = Vec::with_capacity((nw * nh * 4) as usize);
+                for y in 0..nh {
+                    for x in 0..nw {
+                        let at = (((y * *h / nh) * *w + x * *w / nw) * 4) as usize;
+                        scaled.extend_from_slice(&pixels[at..at + 4]);
+                    }
+                }
+                gui_sizes.entry(name.clone()).or_insert((*w, *h));
+                *pixels = scaled;
+                (*w, *h) = (nw, nh);
+                changed = true;
+            }
+            if !changed {
+                return Err(error);
+            }
+            images.sort_by(|a, b| b.2.cmp(&a.2).then(b.1.cmp(&a.1)));
+        }
+    }
+}
@@ -39,11 +39,14 @@ pub fn text_with_backdrop(
    background: u32,
 ) {
    if background != 0 {
+        // Font.PreparedTextBuilder.markBackground: one pixel above and left of
+        // the glyphs, the glyph advance to the right and nine high: not a
+        // fixed two-pixel frame.
        out.push(fill(
-            x - 2,
-            y - 2,
-            x + w + 2,
-            y + 9 + 2,
+            x - 1,
+            y - 1,
+            x + w,
+            y + 9,
            multiply(background, color),
        ));
    }
@@ -1484,3 +1487,27 @@ mod boss_bar_room_tests {
        }
    }
 }
+#[cfg(test)]
+mod backdrop_tests {
+    use super::*;
+
+    /// `markBackground`: the backdrop reaches one pixel above and left of the
+    /// glyphs, their advance to the right and nine down, not 2 on every side.
+    #[test]
+    fn the_backdrop_frames_the_glyphs_by_one_pixel() {
+        let mut out = Vec::new();
+        text_with_backdrop(
+            &mut out,
+            Text::literal("X"),
+            10,
+            20,
+            6,
+            u32::MAX,
+            0xFF00_0000,
+        );
+        let Some(GuiDraw::Fill { x0, y0, x1, y1, .. }) = out.first() else {
+            panic!("a backdrop is a fill first");
+        };
+        assert_eq!((*x0, *y0, *x1, *y1), (9, 19, 16, 29));
+    }
+}
@@ -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()
        );
    }

@@ -59,6 +59,16 @@ pub const CULL_BACK: [i8; 4] = [0, 0, 0, 1];
 /// `Vertex::normal.w` of a shaded quad of an `entityCutoutCull` model (the bat): shaded by the
 /// normal like -127, and `entity.wgsl` also discards its back-facing pixels.
 pub const SHADED_CULL_W: i8 = -126;
+/// `Vertex::normal` of a quad of an `entitySolid` model, which culls its back faces: a quad
+/// the shader shades by its normal keeps it ([`SHADED_CULL_W`]), a baked-colour one (no
+/// normal) gets [`CULL_BACK`].
+pub fn cull_back(normal: [i8; 4]) -> [i8; 4] {
+    if normal == [0; 4] {
+        CULL_BACK
+    } else {
+        [normal[0], normal[1], normal[2], SHADED_CULL_W]
+    }
+}
 /// A section vertex: vanilla's `DefaultVertexFormat.BLOCK` (position, colour,
 /// UV0, UV2) with the sprite's array layer beside the light, in 24 bytes
 /// rather than vanilla's 28: the UV is fixed point, which holds model UVs
@@ -145,6 +155,17 @@ impl TerrainVertex {
    }
 }
 #[cfg(test)]
+mod cull_back_tests {
+    use super::{CULL_BACK, SHADED_CULL_W, cull_back};
+    /// #15322: a shaded `entitySolid` quad keeps its normal and culls; a baked one has
+    /// no normal and only culls.
+    #[test]
+    fn cull_back_keeps_a_shaded_normal() {
+        assert_eq!(cull_back([0; 4]), CULL_BACK);
+        assert_eq!(cull_back([0, 127, 0, 127]), [0, 127, 0, SHADED_CULL_W]);
+    }
+}
+#[cfg(test)]
 mod vertex_tests {
    use super::TerrainVertex;

@@ -6,6 +6,8 @@ use std::time::Instant;

 pub use crate::settings::Opt;

+#[path = "options_ui_widgets.rs"]
+mod widgets;
 use crate::{
    gamepad::{self, GlyphStyle},
    hdr_calibration::Picture,
@@ -17,9 +19,18 @@ use crate::{
    text::{self, Style, Text},
    ui,
 };
+pub(crate) use widgets::{button, inactive};
+
+#[path = "options_ui_values.rs"]
+mod values;
+pub(crate) use values::{chat_delay_label, chat_px, generic, on_off, percent};

 mod shell_pages;

+#[path = "options_ui_wheel.rs"]
+mod wheel;
+pub(crate) use wheel::slider_unsnapped;
+
 fn tr(key: &str) -> Text {
    Text::translate(key, &[])
 }
@@ -31,18 +42,6 @@ pub static HORIZON_EXTRAS: std::sync::atomic::AtomicBool = std::sync::atomic::At
 fn horizon_extras() -> bool {
    HORIZON_EXTRAS.load(std::sync::atomic::Ordering::Relaxed)
 }
-fn generic(caption: &str, value: Text) -> Text {
-    Text::translate("options.generic_value", &[tr(caption), value])
-}
-fn percent(caption: &str, value: f32) -> Text {
-    Text::translate(
-        "options.percent_value",
-        &[
-            tr(caption),
-            Text::literal(((f64::from(value) * 100.0) as i32).to_string()),
-        ],
-    )
-}
 /// `text` cut into lines of at most `width` characters, at spaces where it has them.
 fn wrap(text: &str, width: usize) -> Vec<String> {
    let mut lines = Vec::new();
@@ -67,20 +66,11 @@ fn wrap(text: &str, width: usize) -> Vec<String> {
    }
    lines
 }
-fn on_off(v: bool) -> Text {
-    tr(if v { "options.on" } else { "options.off" })
-}
 /// A music track's name as its row shows it: the file, without its folder
 /// (`minecraft:music/game/calm1` -> `calm1`; the group names the situation).
 fn track_name(id: &str) -> &str {
    id.rsplit('/').next().unwrap_or(id)
 }
-fn chat_px(caption: &str, px: f32) -> Text {
-    Text::translate(
-        "options.pixel_value",
-        &[tr(caption), Text::literal((px as i32).to_string())],
-    )
-}
 pub(crate) enum Kind {
    /// Slider position 0..1.
    Slider(f32),
@@ -349,6 +339,7 @@ impl Opt {
    pub(crate) fn kind(self, s: &Settings) -> Kind {
        let unit = |v: f32, lo: f32, hi: f32| Kind::Slider(((v - lo) / (hi - lo)).clamp(0.0, 1.0));
        match self {
+            Opt::ChatDelay => values::kind(s.file.double("chatDelay")),
            Opt::FovEffects | Opt::DarknessPulsing => {
                Kind::Slider(s.file.double(self.file_key().unwrap()).sqrt() as f32)
            }
@@ -365,7 +356,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 {
@@ -457,6 +448,7 @@ impl Opt {
    /// The discrete step count for stepped sliders, or `None` if continuous.
    pub fn slider_steps(self) -> Option<u32> {
        match self {
+            Opt::ChatDelay => Some(60),
            Opt::Fov => Some(80),
            Opt::RenderDistance => Some((crate::options_file::MAX_RENDER_DISTANCE - 2) as u32),
            Opt::SimulationDistance => Some(27),
@@ -507,7 +499,7 @@ impl Opt {
    pub fn label(self, s: &Settings) -> Text {
        let c = self.caption();
        match self {
-            Opt::ChatDelay => tr("options.chat.delay_none"),
+            Opt::ChatDelay => chat_delay_label(s),
            Opt::FovEffects
            | Opt::DarknessPulsing
            | Opt::DistortionEffects
@@ -712,7 +704,7 @@ impl Opt {
            } else {
                "options.narrator.notavailable"
            }),
-            Opt::ChatDelay => tr("options.chat.delay_none"),
+            Opt::ChatDelay => chat_delay_label(s),
            Opt::HideLightningFlashes => on_off(s.file.bool("hideLightningFlashes")),
            Opt::MonochromeLogo => on_off(s.file.bool("darkMojangStudiosBackground")),
            Opt::HideSplashTexts => on_off(s.file.bool("hideSplashTexts")),
@@ -897,6 +889,7 @@ impl Opt {
        let v = v.clamp(0.0, 1.0);
        let step = |lo: f32, hi: f32| (lo + v * (hi - lo)).round();
        match self {
+            Opt::ChatDelay => values::set(s, v),
            Opt::FovEffects | Opt::DarknessPulsing => s.file.set(
                self.file_key().unwrap(),
                crate::options_file::V::Double(f64::from(v).powi(2)),
@@ -916,7 +909,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,
@@ -924,7 +917,7 @@ impl Opt {
            Opt::CloudRange => s.cloud_range = step(2.0, 128.0) as i32,
            Opt::EntityDistance => s.entity_distance = step(2.0, 20.0) / 4.0,
            Opt::BiomeBlend => s.biome_blend = step(0.0, 7.0) as i32,
-            Opt::Preset => s.graphics_preset = PRESETS[step(0.0, 3.0) as usize].into(),
+            Opt::Preset => s.graphics_preset = PRESETS[preset_from_slider(v)].into(),
            Opt::Mipmaps => s.mipmap_levels = step(0.0, 4.0) as i32,
            Opt::MaxAnisotropy => s.file.set(
                "maxAnisotropyBit",
@@ -1214,92 +1207,6 @@ impl Opt {
        }
    }
 }
-const PRESETS: [&str; 4] = ["fast", "fancy", "fabulous", "custom"];
-fn preset_index(p: &str) -> usize {
-    PRESETS.iter().position(|x| *x == p).unwrap_or(1)
-}
-/// A slider moved to `v` (OptionInstance.set): the graphics preset applies
-/// its options when its value changes (`Options.applyGraphicsPreset`).
-pub fn set_slider(opt: Opt, s: &mut Settings, v: f32) {
-    let preset = preset_index(&s.graphics_preset);
-    opt.set_slider(s, v);
-    if opt == Opt::Preset && preset_index(&s.graphics_preset) != preset {
-        apply_preset(s);
-    }
-}
-/// A slider pressed or dragged to `v`: apply it live, and tell the game when
-/// a category volume changed (`Options.createSoundSliderOptionInstance`'s
-/// callback, which `OptionInstance.set` runs only for a new value).
-fn drag_slider(opt: Opt, s: &mut Settings, v: f32, events: &mut Vec<Event>) {
-    let volume = |s: &Settings| match opt {
-        Opt::Volume(0) => Some(s.master_volume),
-        Opt::Volume(i) => Some(s.volumes[i]),
-        _ => None,
-    };
-    let before = volume(s);
-    set_slider(opt, s, v);
-    events.push(Event::SliderDrag);
-    if let (Opt::Volume(source), Some(after)) = (opt, volume(s))
-        && before != Some(after)
-    {
-        events.push(Event::Volume(source, after));
-    }
-}
-/// GraphicsPreset.apply: the options Fast, Fancy and Fabulous set.
-pub fn apply_preset(s: &mut Settings) {
-    let fabulous = s.graphics_preset == "fabulous";
-    match s.graphics_preset.as_str() {
-        "fast" => {
-            s.biome_blend = 1;
-            s.render_distance = 8;
-            s.prioritize_chunk_updates = 0;
-            s.simulation_distance = 6;
-            s.smooth_lighting = false;
-            s.clouds = "fast".into();
-            s.particles = 1;
-            s.mipmap_levels = 2;
-            s.entity_shadows = false;
-            s.entity_distance = 0.75;
-            s.menu_blur = 2;
-            s.cloud_range = 32;
-            s.cutout_leaves = false;
-            s.improved_transparency = false;
-            s.weather_radius = 5;
-            set_filtering(s, 1, 0);
-        }
-        "fancy" | "fabulous" => {
-            s.biome_blend = 2;
-            s.render_distance = if fabulous { 32 } else { 16 };
-            s.prioritize_chunk_updates = 1;
-            s.simulation_distance = 12;
-            s.smooth_lighting = true;
-            s.clouds = "true".into();
-            s.particles = 0;
-            s.mipmap_levels = 4;
-            s.entity_shadows = true;
-            s.entity_distance = if fabulous { 1.25 } else { 1.0 };
-            s.menu_blur = 5;
-            s.cloud_range = if fabulous { 128 } else { 64 };
-            s.cutout_leaves = true;
-            s.improved_transparency = fabulous;
-            s.weather_radius = 10;
-            // Fabulous takes anisotropic filtering (RGSS on a device with known issues, which
-            // wgpu does not report).
-            set_filtering(
-                s,
-                if fabulous { 2 } else { 1 },
-                if fabulous { 2 } else { 1 },
-            );
-        }
-        _ => {}
-    }
-}
-/// The preset's `maxAnisotropyBit` and `textureFiltering` (0 none, 1 RGSS, 2 anisotropic).
-fn set_filtering(s: &mut Settings, anisotropy_bit: i32, filtering: i32) {
-    use crate::options_file::V;
-    s.file.set("maxAnisotropyBit", V::Int(anisotropy_bit));
-    s.file.set("textureFiltering", V::Int(filtering));
-}

 /// `Options.preferredGraphicsBackend`'s tooltip: the restart note once the choice differs from
 /// the startup one, the description, and Vulkan's warning.
@@ -1388,7 +1295,7 @@ pub enum Page {
    Music,
 }
 #[derive(Clone, Debug, PartialEq)]
-enum Act {
+pub(crate) enum Act {
    None,
    Push(Page),
    Done,
@@ -1453,7 +1360,7 @@ enum WKind {
        code: String,
    },
 }
-struct Widget {
+pub(crate) struct Widget {
    x: f32,
    y: f32,
    w: f32,
@@ -1604,23 +1511,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,
@@ -1806,27 +1696,6 @@ impl Default for OptionsUi {
        }
    }
 }
-fn button(x: f32, y: f32, w: f32, label: Text, act: Act) -> Widget {
-    Widget {
-        x,
-        y,
-        w,
-        h: 20.0,
-        kind: WKind::Button {
-            label,
-            active: true,
-            act,
-        },
-        list: false,
-        row: 0,
-    }
-}
-fn inactive(mut w: Widget) -> Widget {
-    if let WKind::Button { active, .. } = &mut w.kind {
-        *active = false;
-    }
-    w
-}
 fn option_widget(s: &Settings, opt: Opt, x: f32, y: f32, w: f32) -> Widget {
    // OptionsSubScreen.addContents: the narrator button is active only while
    // the narrator is (`narratorButton.active = narrator.isActive()`).
@@ -3193,13 +3062,20 @@ impl OptionsUi {
                }
                content = y + self.scroll - top + 2.0;
                out[list_start..].iter_mut().for_each(|w| w.list = true);
-                out.push(button(
+                let reset_all = button(
                    cx - 154.0,
                    h - 27.0,
                    150.0,
                    tr("controls.resetAll"),
                    Act::ResetKeys,
-                ));
+                );
+                // KeyBindsScreen.extractRenderState: active only while some
+                // binding differs from its default.
+                out.push(if s.keys.changed_from_defaults() {
+                    reset_all
+                } else {
+                    inactive(reset_all)
+                });
                out.push(button(cx + 4.0, h - 27.0, 150.0, tr("gui.done"), Act::Done));
            }
            Page::Language => {
@@ -8297,6 +8173,11 @@ mod tests {
    }
 }

+#[path = "options_ui_preset.rs"]
+mod preset;
+pub(crate) use preset::{
+    PRESETS, apply_preset, drag_slider, preset_from_slider, preset_index, set_slider,
+};
 #[cfg(test)]
 #[path = "options_ui_graphics_tests.rs"]
 mod graphics_tests;
@@ -174,3 +174,42 @@ fn a_held_hdr_start_shows_as_the_graphics_screen_opens() {
        assert_eq!(ui.graphics.screen.output.held, held);
    }
 }
+
+/// The slider position `Opt::ChatDelay`'s kind() gives the stored seconds.
+fn delay_pos(seconds: f64) -> f32 {
+    match values::kind(seconds) {
+        Kind::Slider(p) => p,
+        _ => panic!("the chat delay is a slider"),
+    }
+}
+/// `Options.chatDelay`: `IntRange(0, 60)` xmap(v / 10) — a slider in tenths of
+/// a second from 0 to 6, not a button with no value behind it.
+#[test]
+fn the_chat_delay_slider_steps_in_tenths() {
+    assert_eq!(delay_pos(0.0), 0.0);
+    assert!((delay_pos(3.0) - 0.5).abs() < 1e-6);
+    assert_eq!(delay_pos(6.0), 1.0);
+    // A value past the option's range clamps to its last step.
+    assert_eq!(delay_pos(6.5), 1.0);
+    assert_eq!(Opt::ChatDelay.slider_steps(), Some(60));
+    let mut s = Settings::default();
+    set_slider(Opt::ChatDelay, &mut s, 0.0);
+    assert_eq!(s.file.double("chatDelay"), 0.0);
+    set_slider(Opt::ChatDelay, &mut s, 0.5);
+    assert!((s.file.double("chatDelay") - 3.0).abs() < 1e-9);
+    set_slider(Opt::ChatDelay, &mut s, 1.0);
+    assert!((s.file.double("chatDelay") - 6.0).abs() < 1e-9);
+}
+
+/// `Options.chatDelay`'s message: None at zero, else the delay to one decimal.
+#[test]
+fn the_chat_delay_slider_says_its_delay() {
+    let mut s = Settings::default();
+    assert_eq!(chat_delay_label(&s).plain(), "options.chat.delay_none");
+    s.file.set("chatDelay", crate::options_file::V::Double(2.0));
+    assert_eq!(chat_delay_label(&s).plain(), "Chat Delay: 2.0 second(s)");
+    s.file.set("chatDelay", crate::options_file::V::Double(6.0));
+    assert_eq!(chat_delay_label(&s).plain(), "Chat Delay: 6.0 second(s)");
+    s.file.set("chatDelay", crate::options_file::V::Double(0.0));
+    assert_eq!(chat_delay_label(&s).plain(), "options.chat.delay_none");
+}
@@ -0,0 +1,121 @@
+//! The graphics preset: `Options.graphicsPreset`'s slider position and the
+//! options `GraphicsPreset.apply` sets.
+use super::*;
+
+pub(crate) const PRESETS: [&str; 4] = ["fast", "fancy", "fabulous", "custom"];
+/// `SliderableEnum.fromSliderValue`: the slider's 0..1 position maps by
+/// `floor(v * values)` with 1.0 just below it, clamped to the last stop (4
+/// graphics presets), not by rounding `v * 3`.
+pub(crate) fn preset_from_slider(v: f32) -> usize {
+    let v = if v >= 1.0 { 0.99999 } else { v };
+    ((v * 4.0).floor() as usize).min(3)
+}
+pub(crate) fn preset_index(p: &str) -> usize {
+    PRESETS.iter().position(|x| *x == p).unwrap_or(1)
+}
+/// A slider moved to `v` (OptionInstance.set): the graphics preset applies
+/// its options when its value changes (`Options.applyGraphicsPreset`).
+pub(crate) fn set_slider(opt: Opt, s: &mut Settings, v: f32) {
+    let preset = preset_index(&s.graphics_preset);
+    opt.set_slider(s, v);
+    if opt == Opt::Preset && preset_index(&s.graphics_preset) != preset {
+        apply_preset(s);
+    }
+}
+/// A slider pressed or dragged to `v`: apply it live, and tell the game when
+/// a category volume changed (`Options.createSoundSliderOptionInstance`'s
+/// callback, which `OptionInstance.set` runs only for a new value).
+pub(crate) fn drag_slider(opt: Opt, s: &mut Settings, v: f32, events: &mut Vec<Event>) {
+    let volume = |s: &Settings| match opt {
+        Opt::Volume(0) => Some(s.master_volume),
+        Opt::Volume(i) => Some(s.volumes[i]),
+        _ => None,
+    };
+    let before = volume(s);
+    set_slider(opt, s, v);
+    events.push(Event::SliderDrag);
+    if let (Opt::Volume(source), Some(after)) = (opt, volume(s))
+        && before != Some(after)
+    {
+        events.push(Event::Volume(source, after));
+    }
+}
+/// GraphicsPreset.apply: the options Fast, Fancy and Fabulous set.
+pub(crate) fn apply_preset(s: &mut Settings) {
+    let fabulous = s.graphics_preset == "fabulous";
+    match s.graphics_preset.as_str() {
+        "fast" => {
+            s.biome_blend = 1;
+            s.render_distance = 8;
+            s.prioritize_chunk_updates = 0;
+            s.simulation_distance = 6;
+            s.smooth_lighting = false;
+            s.clouds = "fast".into();
+            s.particles = 1;
+            s.mipmap_levels = 2;
+            s.entity_shadows = false;
+            s.entity_distance = 0.75;
+            s.menu_blur = 2;
+            s.cloud_range = 32;
+            s.cutout_leaves = false;
+            s.improved_transparency = false;
+            s.weather_radius = 5;
+            set_filtering(s, 1, 0);
+        }
+        "fancy" | "fabulous" => {
+            s.biome_blend = 2;
+            s.render_distance = if fabulous { 32 } else { 16 };
+            s.prioritize_chunk_updates = 1;
+            s.simulation_distance = 12;
+            s.smooth_lighting = true;
+            s.clouds = "true".into();
+            s.particles = 0;
+            s.mipmap_levels = 4;
+            s.entity_shadows = true;
+            s.entity_distance = if fabulous { 1.25 } else { 1.0 };
+            s.menu_blur = 5;
+            s.cloud_range = if fabulous { 128 } else { 64 };
+            s.cutout_leaves = true;
+            s.improved_transparency = fabulous;
+            s.weather_radius = 10;
+            // Fabulous takes anisotropic filtering (RGSS on a device with known issues, which
+            // wgpu does not report).
+            set_filtering(
+                s,
+                if fabulous { 2 } else { 1 },
+                if fabulous { 2 } else { 1 },
+            );
+        }
+        _ => {}
+    }
+}
+/// The preset's `maxAnisotropyBit` and `textureFiltering` (0 none, 1 RGSS, 2 anisotropic).
+fn set_filtering(s: &mut Settings, anisotropy_bit: i32, filtering: i32) {
+    use crate::options_file::V;
+    s.file.set("maxAnisotropyBit", V::Int(anisotropy_bit));
+    s.file.set("textureFiltering", V::Int(filtering));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `SliderableEnum.fromSliderValue`: the graphics preset slider's stops are
+    /// floor(v * 4), 1.0 landing on the last, and the value setter follows.
+    #[test]
+    fn the_graphics_preset_slider_uses_floor_stops() {
+        assert_eq!(preset_from_slider(0.0), 0);
+        assert_eq!(preset_from_slider(0.24), 0);
+        assert_eq!(preset_from_slider(0.25), 1);
+        assert_eq!(preset_from_slider(0.49), 1);
+        assert_eq!(preset_from_slider(0.5), 2);
+        assert_eq!(preset_from_slider(0.74), 2);
+        assert_eq!(preset_from_slider(0.75), 3);
+        assert_eq!(preset_from_slider(1.0), 3);
+        let mut s = Settings::default();
+        set_slider(Opt::Preset, &mut s, 0.2);
+        assert_eq!(s.graphics_preset, "fast");
+        set_slider(Opt::Preset, &mut s, 0.8);
+        assert_eq!(s.graphics_preset, "custom");
+    }
+}
@@ -0,0 +1,54 @@
+//! The small option value labels (`generic`, `percent`, `on_off`, `chat_px`,
+//! `chat_delay_label`) and `Options.chatDelay`'s slider mapping.
+use super::*;
+
+pub(crate) fn generic(caption: &str, value: Text) -> Text {
+    Text::translate("options.generic_value", &[tr(caption), value])
+}
+pub(crate) fn on_off(v: bool) -> Text {
+    tr(if v { "options.on" } else { "options.off" })
+}
+pub(crate) fn chat_px(caption: &str, px: f32) -> Text {
+    Text::translate(
+        "options.pixel_value",
+        &[tr(caption), Text::literal((px as i32).to_string())],
+    )
+}
+pub(crate) fn percent(caption: &str, value: f32) -> Text {
+    Text::translate(
+        "options.percent_value",
+        &[
+            tr(caption),
+            Text::literal(((f64::from(value) * 100.0) as i32).to_string()),
+        ],
+    )
+}
+/// `Options.chatDelay`'s message: `options.chat.delay_none` at zero, else
+/// `options.chat.delay` with the delay to one decimal (`%.1f` seconds).
+pub(crate) fn chat_delay_label(s: &Settings) -> Text {
+    let value = s.file.double("chatDelay") as f32;
+    if value <= 0.0 {
+        Text::translate("options.chat.delay_none", &[])
+    } else {
+        Text::translate_with_fallback(
+            "options.chat.delay",
+            "Chat Delay: %s second(s)",
+            &[Text::literal(format!("{value:.1}"))],
+        )
+    }
+}
+/// `IntRange(0, 60).toSliderValue` on the stored seconds (`xmap(v / 10.0)`):
+/// the tenth-of-a-second step over the slider's 60.
+pub(crate) fn kind(value: f64) -> Kind {
+    Kind::Slider(((value * 10.0).floor() / 60.0).clamp(0.0, 1.0) as f32)
+}
+/// `IntRange(0, 60).fromSliderValue` then `xmap`'s `/ 10.0`:
+/// floor(map(v, 0, 1, 0, 61)), the last step capped at 60, in tenths.
+pub(crate) fn from_slider(v: f32) -> f64 {
+    f64::from((v.clamp(0.0, 1.0) * 61.0).floor().min(60.0) / 10.0)
+}
+/// `Options.chatDelay.set`: the slider's value as the stored seconds.
+pub(crate) fn set(s: &mut Settings, v: f32) {
+    s.file
+        .set("chatDelay", crate::options_file::V::Double(from_slider(v)));
+}
@@ -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);
+    }
+}
@@ -0,0 +1,25 @@
+//! The option screens' widget constructors: a 20-pixel button row and the
+//! same widget turned inactive.
+use super::*;
+
+pub(crate) fn button(x: f32, y: f32, w: f32, label: Text, act: Act) -> Widget {
+    Widget {
+        x,
+        y,
+        w,
+        h: 20.0,
+        kind: WKind::Button {
+            label,
+            active: true,
+            act,
+        },
+        list: false,
+        row: 0,
+    }
+}
+pub(crate) fn inactive(mut w: Widget) -> Widget {
+    if let WKind::Button { active, .. } = &mut w.kind {
+        *active = false;
+    }
+    w
+}
@@ -1718,6 +1718,19 @@ impl PackScreen {
            [32, 2],
        );
        if l.scrollable() {
+            // AbstractScrollArea.extractScrollbar: over the bar, the pointer
+            // points, or resizes while the bar is held.
+            let over_bar = mouse.0 >= l.scroll_bar_x()
+                && mouse.0 < l.scroll_bar_x() + 6
+                && mouse.1 >= l.y
+                && mouse.1 < l.bottom();
+            if over_bar {
+                crate::widgets::request_cursor(if l.held.is_some() {
+                    crate::widgets::Cursor::ResizeNs
+                } else {
+                    crate::widgets::Cursor::PointingHand
+                });
+            }
            let sh = l.scroller_height().clamp(32, l.height - 8);
            let sy = (l.scroll as i32 * (l.height - sh) / l.max_scroll() + l.y).max(l.y);
            d::sprite(
@@ -2197,6 +2210,29 @@ mod icon_slot_tests {

    /// Only the available list has packs: one row of 36 for each of `count` icons fits in a
    /// window `height` high.
+    /// `AbstractScrollArea.extractScrollbar`: over a held pack list's bar the
+    /// pointer asks to resize vertically, at rest it points.
+    #[test]
+    fn the_pack_scrollbar_asks_for_its_cursor() {
+        let atlas = atlas();
+        let m = Measure(&atlas.font);
+        let mut screen = screen(&m, 30, 200);
+        let l = &screen.lists[0];
+        assert!(l.scrollable());
+        let at = (l.scroll_bar_x() + 2, l.y + 8);
+        let _ = crate::widgets::take_cursor();
+        screen.draw(&m, at, 0, 0);
+        assert_eq!(
+            crate::widgets::take_cursor(),
+            crate::widgets::Cursor::PointingHand
+        );
+        screen.lists[0].held = Some(f64::from(at.1));
+        screen.draw(&m, at, 0, 0);
+        assert_eq!(
+            crate::widgets::take_cursor(),
+            crate::widgets::Cursor::ResizeNs
+        );
+    }
    fn screen(m: &Measure, count: usize, height: i32) -> PackScreen {
        PackScreen::new(
            m,
@@ -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()?
@@ -526,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>>,
@@ -895,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,
@@ -1759,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> {
@@ -3621,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 {
@@ -3651,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",
@@ -3704,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"
@@ -3846,6 +3825,9 @@ impl ParticleEngine {
        }
        let pending = std::mem::take(&mut self.pending);
        for mut p in pending {
+            if !self.polytone_joins(&p, level) {
+                continue;
+            }
            if p.pre_tick {
                p.pre_tick = false;
                self.tick_particle(&mut p, level);
@@ -5054,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],
@@ -1090,6 +1090,40 @@ 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 ParticleEngine {
+    /// Whether a pending Polytone particle joins the world. One with physics whose box starts
+    /// inside a block's collision never does, and its type's `limit` is then counted among those
+    /// that joined, so one that never joins takes no place (measured on the mod: with `limit` 1,
+    /// one born inside a block and one clear of it in the same tick, the clear one shows).
+    pub(super) fn polytone_joins(&self, p: &Particle, level: &ParticleLevel<'_>) -> bool {
+        if !p.spawn_check {
+            return true;
+        }
+        if !unobstructed(level, p.bb) {
+            return false;
+        }
+        let Some(name) = p.polytone_type.as_deref() else {
+            return true;
+        };
+        let def = self.polytone.as_ref().and_then(|r| r.get(name));
+        let limit = def.and_then(|d| d.limit.filter(|_| d.gpu.is_none()));
+        limit.is_none_or(|limit| {
+            let same = |q: &&Particle| !q.removed && q.polytone_type.as_deref() == Some(name);
+            self.particles.iter().filter(same).count() < limit as usize
+        })
+    }
+}
+
 impl super::ParticleController for Controller {
    fn tick(&mut self, p: &mut Particle, level: &ParticleLevel<'_>) -> ParticleUpdate {
        let mut update = ParticleUpdate::default();
@@ -1204,7 +1238,8 @@ pub(super) fn make(
    velocity: [f64; 3],
    seed: i64,
 ) -> Option<Particle> {
-    // `limit`: at most that many of the type alive at once.
+    // `limit`: at most that many of the type alive at once. A pending one with physics may never
+    // join (`polytone_joins`), so it takes no place until it does.
    // (A GPU particle's `limit` is its ring of records instead.)
    if let Some(limit) = def.limit
        && def.gpu.is_none()
@@ -1212,7 +1247,7 @@ pub(super) fn make(
        let alive = engine
            .particles
            .iter()
-            .chain(&engine.pending)
+            .chain(engine.pending.iter().filter(|p| !p.spawn_check))
            .filter(|p| !p.removed && p.polytone_type.as_deref() == Some(name))
            .count();
        if alive >= limit as usize {
@@ -1220,10 +1255,11 @@ pub(super) fn make(
        }
    }
    // `exclusion_radius`: none spawns within that distance of a live one of its type (rain
-    // splashes, one per patch of ground).
+    // splashes, one per patch of ground from tick to tick). Only those already in the world count: measured on
+    // the mod, two spawned in the same tick a block apart both show, with or without physics.
    if def.exclusion_radius > 0.0 && def.gpu.is_none() {
        let r2 = def.exclusion_radius * def.exclusion_radius;
-        let crowded = engine.particles.iter().chain(&engine.pending).any(|p| {
+        let crowded = engine.particles.iter().any(|p| {
            !p.removed
                && p.polytone_type.as_deref() == Some(name)
                && (0..3)
@@ -1320,6 +1356,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 +1571,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::*;
@@ -1819,7 +1884,8 @@ mod tests {
        let root = pack(&[
            (
                "assets/test/polytone/custom_particles/splash.json",
-                serde_json::json!({"has_physics": false, "exclusion_radius": 1, "render_type": "invisible"}),
+                serde_json::json!({"has_physics": false, "exclusion_radius": 1, "render_type": "invisible",
+                    "initializer": {"lifetime": "100"}}),
            ),
            (
                "assets/test/polytone/custom_particles/drop.json",
@@ -1829,7 +1895,8 @@ mod tests {
                "assets/minecraft/polytone/entity_modifiers/player.json",
                serde_json::json!({"emitters": [
                    {"particle": "test:splash", "x": "0", "chance": "1"},
-                    // 0.5 from the first: excluded.
+                    // 0.5 from the first, in the same tick: the first isn't in the world yet,
+                    // so it spawns (measured on the mod).
                    {"particle": "test:splash", "x": "0.5", "chance": "1"},
                    // 3 away: spawns.
                    {"particle": "test:splash", "x": "3", "chance": "1"},
@@ -1851,7 +1918,15 @@ mod tests {
        engine.polytone_entity(&level, "minecraft:player", [1.0, 64.0, 1.0]);
        let mut xs: Vec<f64> = engine.pending.iter().map(|p| p.position[0]).collect();
        xs.sort_by(f64::total_cmp);
-        assert_eq!(xs, [1.0, 1.5, 4.0]);
+        assert_eq!(xs, [1.0, 1.5, 1.5, 4.0]);
+        // Once they are in the world, the next tick's splashes near them are excluded; ones
+        // farther than the radius from all of them spawn, again without excluding each other.
+        engine.tick(&level);
+        let splashes = |p: &&Particle| p.polytone_type.as_deref() == Some("test:splash");
+        engine.polytone_entity(&level, "minecraft:player", [1.0, 64.0, 1.0]);
+        assert_eq!(engine.pending.iter().filter(splashes).count(), 0);
+        engine.polytone_entity(&level, "minecraft:player", [9.0, 64.0, 1.0]);
+        assert_eq!(engine.pending.iter().filter(splashes).count(), 3);
        std::fs::remove_dir_all(root).unwrap();
    }

@@ -2244,6 +2319,208 @@ 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();
+    }
+
+    /// Measured on the mod: with `limit` 1, one particle born inside a block and one clear of it
+    /// in the same tick, the clear one shows. The one that never joins takes no place.
+    #[test]
+    fn a_particle_that_never_joins_takes_no_place_under_its_limit() {
+        let blocks = blocks();
+        let lim = |x: &str| serde_json::json!({"particle": "test:lim", "chance": "1", "x": x});
+        let root = pack(&[
+            (
+                "assets/test/polytone/custom_particles/lim.json",
+                serde_json::json!({"has_physics": true, "render_type": "invisible", "limit": 1,
+                    "initializer": {"lifetime": "20", "hitbox_size": "0.08"}}),
+            ),
+            // The first inside the block's reach, the second three blocks clear of it.
+            (
+                "assets/minecraft/polytone/entity_modifiers/player.json",
+                serde_json::json!({"emitters": [lim("0"), lim("3")]}),
+            ),
+            // Two clear of it: the limit still keeps one.
+            (
+                "assets/minecraft/polytone/entity_modifiers/zombie.json",
+                serde_json::json!({"emitters": [lim("3"), lim("6")]}),
+            ),
+            // `exclusion_radius` with physics: the one inside the block doesn't keep the clear
+            // one a block away from spawning.
+            (
+                "assets/test/polytone/custom_particles/exc.json",
+                serde_json::json!({"has_physics": true, "render_type": "invisible",
+                    "exclusion_radius": 2,
+                    "initializer": {"lifetime": "20", "hitbox_size": "0.08"}}),
+            ),
+            (
+                "assets/minecraft/polytone/entity_modifiers/skeleton.json",
+                serde_json::json!({"emitters": [
+                    {"particle": "test:exc", "chance": "1", "x": "0"},
+                    {"particle": "test:exc", "chance": "1", "x": "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));
+        let mut joined = |entity: &str| {
+            engine.particles.clear();
+            engine.pending.clear();
+            // The solid block is at (1, 64, 1): 0.05 under it, a 0.08 box reaches into it.
+            engine.polytone_entity(&level, entity, [1.5, 63.95, 1.5]);
+            engine.tick(&level);
+            engine
+                .particles
+                .iter()
+                .map(|p| p.position[0])
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(joined("minecraft:player"), vec![4.5]);
+        assert_eq!(joined("minecraft:zombie"), vec![4.5]);
+        assert_eq!(joined("minecraft:skeleton"), vec![2.5]);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
    #[test]
    fn a_pack_custom_particle_replaces_the_vanilla_type_of_its_id() {
        let root = pack(&[(
@@ -43,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);
@@ -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();
@@ -681,26 +681,36 @@ impl TextField {
    }
    /// `setValue`.
    pub fn set_value(&mut self, m: &Measure, value: &str) {
-        self.value = value.chars().take(self.max_length).collect();
+        self.value = crate::ui::utf16_prefix(value, self.max_length);
        self.move_cursor_to(m, chars(&self.value), false);
        self.set_highlight(m, self.cursor);
    }
    /// `insertText`: replaces the selection within the maximum length. True
-    /// when the value changed (its responder runs).
+    /// when the value changed (its responder runs). The limit is in UTF-16
+    /// code units, as Java's `String.length()` counts them.
    pub fn insert_text(&mut self, m: &Measure, input: &str) -> bool {
        let (start, end) = (
            self.cursor.min(self.highlight),
            self.cursor.max(self.highlight),
        );
-        let room = self.max_length as isize - chars(&self.value) as isize + (end - start) as isize;
-        if room <= 0 {
+        let selected_units: usize = self
+            .value
+            .chars()
+            .skip(start)
+            .take(end - start)
+            .map(char::len_utf16)
+            .sum();
+        let room = self
+            .max_length
+            .saturating_sub(crate::ui::utf16_len(&self.value) - selected_units);
+        if room == 0 {
            return false;
        }
        let filtered: String = input
            .chars()
            .filter(|c| *c >= ' ' && *c != '\u{7f}' && *c != '§')
            .collect();
-        let insert: String = filtered.chars().take(room as usize).collect();
+        let insert = crate::ui::utf16_prefix(&filtered, room);
        let n = chars(&insert);
        self.value = format!(
            "{}{}{}",
@@ -912,7 +922,8 @@ impl TextField {
            text_as_typed(out, t, draw_x, ty, color, self.text_shadow);
            draw_x += w + 1;
        }
-        let insert = self.cursor < len || len >= self.max_length;
+        // `value.length() >= maxLength` is Java's length: UTF-16 units.
+        let insert = self.cursor < len || crate::ui::utf16_len(&self.value) >= self.max_length;
        let mut cursor_x = draw_x;
        if !on_screen {
            cursor_x = if rel_cursor > 0 { tx + self.width } else { tx };
@@ -1427,3 +1438,32 @@ mod scissor_tests {
        );
    }
 }
+
+#[cfg(test)]
+mod max_length_tests {
+    use super::*;
+
+    fn atlas() -> HudAtlas {
+        HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
+    }
+
+    /// `EditBox.maxLength` counts Java `String.length()` (UTF-16 code units),
+    /// and the chat box is this field: ChatScreen's 256 takes 128 emoji, not
+    /// 256, and a half-fitted emoji is dropped rather than split.
+    #[test]
+    fn the_chat_box_maximum_counts_utf16_units() {
+        let atlas = atlas();
+        let m = Measure(&atlas.font);
+        let mut field = TextField::new(0, 0, 200, 20);
+        field.max_length = 3;
+        field.insert_text(&m, "ab😀");
+        assert_eq!(
+            field.value, "ab",
+            "three units: a, b and one of the emoji's"
+        );
+        field.set_value(&m, "");
+        field.max_length = 4;
+        field.insert_text(&m, "ab😀");
+        assert_eq!(field.value, "ab😀", "four units, both of the emoji's");
+    }
+}
@@ -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);
+    }
 }
@@ -501,7 +501,12 @@ pub(crate) fn row(batch: &mut HudBatch, atlas: &HudAtlas, cols: &Columns, y: f32
        let lit = [rect[0] + 2.0, y + 1.0, rect[2] - 4.0, style::ROW - 2.0];
        style::fill(batch, atlas, lit, style::hover());
    }
-    crate::widgets::widget_cursor(hover, live);
+    // AbstractSliderButton.handleCursor: a dragged slider resizes, buttons point.
+    if slider.is_some() {
+        crate::widgets::slider_cursor(hover, live, held);
+    } else {
+        crate::widgets::widget_cursor(hover, live);
+    }
    // The control socket's widget tree, the narrator and a controller's focus.
    let kind = match slider {
        Some(value) => crate::widgets::Kind::Slider {
@@ -12,6 +12,16 @@
 //! 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 list_updates;
+mod model;
+
+use list_updates::{Handler, spawn_updater};
+pub use list_updates::{State, set_foreground};
+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,99 +33,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 {
-    Loading,
-    UpgradeNeeded,
-    ConnectionIssue,
-    UserMayLackActiveProfile,
-    Unauthorized,
-    TemporaryUnavailable,
-    GenericError,
-    Success,
-}
-impl State {
-    /// `RemoteFriendListUpdateHandler.mapResultCodeToState`.
-    fn of(code: ResultCode) -> Self {
-        match code {
-            ResultCode::Success => Self::Success,
-            ResultCode::UpgradeNeeded => Self::UpgradeNeeded,
-            ResultCode::ConnectionIssue => Self::ConnectionIssue,
-            ResultCode::UnknownProfile => Self::UserMayLackActiveProfile,
-            ResultCode::Unauthorized => Self::Unauthorized,
-            ResultCode::TemporaryUnavailable
-            | ResultCode::Forbidden
-            | ResultCode::ServiceNotAvailable
-            | ResultCode::TooManyRequests => Self::TemporaryUnavailable,
-            ResultCode::Error | ResultCode::GenericError => Self::GenericError,
-        }
-    }
-}
-
 /// `Options.sharePresence` (`PresenceSharing`): how much of the player the service sees.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum SharePresence {
@@ -159,45 +76,6 @@ impl Service {
    }
 }

-/// `RemoteFriendListUpdateHandler`.
-struct Handler {
-    enabled: bool,
-    state: State,
-    latest: FriendData,
-    /// `lastUpdateNanos`: a read at that moment is due; `None` reads at once.
-    last_update: Option<Instant>,
-    /// A forced read (`forceUpdate`) is due, whatever the interval.
-    forced: bool,
-    /// `getUpdateIntervalNanos`'s foreground: the friends overlay is open.
-    foreground: bool,
-}
-
-impl Default for Handler {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            state: State::Loading,
-            latest: FriendData::default(),
-            last_update: None,
-            forced: false,
-            foreground: false,
-        }
-    }
-}
-
-impl Handler {
-    /// `getUpdateIntervalNanos`: the service's interval (a minute when it named none),
-    /// five times as long in the background.
-    fn interval(&self, service: &Service) -> Duration {
-        let foreground = service.friends_poll.unwrap_or(Duration::from_secs(60));
-        if self.foreground {
-            foreground
-        } else {
-            foreground * 5
-        }
-    }
-}
-
 /// `PresenceHandler`.
 struct PresenceHandler {
    latest: Vec<Presence>,
@@ -326,11 +204,6 @@ pub fn latest_presence() -> Vec<Presence> {
    lock().presence.latest.clone()
 }

-/// `RemoteFriendListUpdateHandler`'s foreground interval: the friends overlay is open.
-pub fn set_foreground(open: bool) {
-    lock().handler.foreground = open;
-}
-
 /// `Options.sharePresence`: what presence the handler posts.
 pub fn set_share_presence(share: SharePresence) {
    lock().share = share;
@@ -480,100 +353,6 @@ fn friend_action(body: Value) -> ResultCode {
    code
 }

-/// `RemoteFriendListUpdateHandler.start`'s worker: one read per interval while the list
-/// is enabled, the first one as soon as it starts.
-fn spawn_updater() {
-    static STARTED: AtomicBool = AtomicBool::new(false);
-    if STARTED.swap(true, Ordering::Relaxed) {
-        return;
-    }
-    let _ = thread::Builder::new()
-        .name("Friends List".into())
-        .spawn(|| {
-            loop {
-                thread::sleep(Duration::from_secs(1));
-                let due = {
-                    let inner = lock();
-                    if !inner.handler.enabled {
-                        continue;
-                    }
-                    inner.handler.forced
-                        || inner
-                            .handler
-                            .last_update
-                            .is_none_or(|at| at.elapsed() >= inner.handler.interval(&inner.service))
-                };
-                if due {
-                    update_friend_data();
-                }
-            }
-        });
-}
-
-/// `RemoteFriendListUpdateHandler.runUpdateFriendDataInternal`.
-fn update_friend_data() {
-    let etag = {
-        let mut inner = lock();
-        if inner.service.pending {
-            // Another read is in flight; its answer is the cache's.
-            return;
-        }
-        if !inner.service.can_make_request() {
-            inner.handler.forced = false;
-            inner.handler.state = State::Success;
-            inner.handler.latest = inner.service.friends_cache.clone();
-            inner.handler.last_update = Some(Instant::now());
-            return;
-        }
-        inner.service.pending = true;
-        inner.service.cooldown = Some(Instant::now() + Duration::from_secs(10));
-        inner.service.friends_etag.clone()
-    };
-    log::debug!("Performing Friends List update");
-    let result = match session() {
-        Some(session) => fetch_friends(&session, etag.as_deref()),
-        None => Err(Failure {
-            code: ResultCode::Unauthorized,
-        }),
-    };
-    let mut inner = lock();
-    inner.service.pending = false;
-    inner.handler.forced = false;
-    inner.handler.last_update = Some(Instant::now());
-    match result {
-        Ok(answer) => {
-            if let Some(retry) = answer.retry_after {
-                inner.service.friends_poll = Some(retry);
-            }
-            if let Some(etag) = answer.etag {
-                inner.service.friends_etag = Some(etag);
-            }
-            if answer.status != 304 && !answer.body.is_empty() {
-                match parse_friends(&answer.body) {
-                    Some(data) => inner.service.friends_cache = data,
-                    None => {
-                        // authlib's parse failure is an ERROR result: the handler keeps
-                        // the cached lists and shows the generic error.
-                        inner.handler.latest = inner.service.friends_cache.clone();
-                        inner.handler.state = State::GenericError;
-                        return;
-                    }
-                }
-            }
-            inner.handler.latest = inner.service.friends_cache.clone();
-            inner.handler.state = State::Success;
-        }
-        Err(failure) => {
-            inner.handler.latest = inner.service.friends_cache.clone();
-            inner.handler.state = State::of(failure.code);
-            log::warn!(
-                "Friends List update failed with result code: {:?}",
-                failure.code
-            );
-        }
-    }
-}
-
 /// `MinecraftServicesFriendsService.presence`: post one status, cache the answer.
 /// `None` means the answer said nothing new (304, an empty body or a failure); the
 /// handler keeps its last presence then.
@@ -726,122 +505,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);
-        assert_eq!(
-            State::of(ResultCode::TooManyRequests),
-            State::TemporaryUnavailable
-        );
-        assert_eq!(
-            State::of(ResultCode::UnknownProfile),
-            State::UserMayLackActiveProfile
-        );
-        assert_eq!(State::of(ResultCode::UpgradeNeeded), State::UpgradeNeeded);
-        assert_eq!(
-            State::of(ResultCode::ConnectionIssue),
-            State::ConnectionIssue
-        );
-    }
-
    #[test]
    fn the_share_presence_option_maps_to_its_levels() {
        assert_eq!(SharePresence::of(0), SharePresence::None);
@@ -0,0 +1,199 @@
+use super::{
+    Failure, FriendData, ResultCode, Service, fetch_friends, lock, parse_friends, session,
+};
+use std::{
+    sync::atomic::{AtomicBool, Ordering},
+    thread,
+    time::{Duration, Instant},
+};
+
+/// `RemoteFriendListUpdateHandler.State`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum State {
+    Loading,
+    UpgradeNeeded,
+    ConnectionIssue,
+    UserMayLackActiveProfile,
+    Unauthorized,
+    TemporaryUnavailable,
+    GenericError,
+    Success,
+}
+impl State {
+    /// `RemoteFriendListUpdateHandler.mapResultCodeToState`.
+    fn of(code: ResultCode) -> Self {
+        match code {
+            ResultCode::Success => Self::Success,
+            ResultCode::UpgradeNeeded => Self::UpgradeNeeded,
+            ResultCode::ConnectionIssue => Self::ConnectionIssue,
+            ResultCode::UnknownProfile => Self::UserMayLackActiveProfile,
+            ResultCode::Unauthorized => Self::Unauthorized,
+            ResultCode::TemporaryUnavailable
+            | ResultCode::Forbidden
+            | ResultCode::ServiceNotAvailable
+            | ResultCode::TooManyRequests => Self::TemporaryUnavailable,
+            ResultCode::Error | ResultCode::GenericError => Self::GenericError,
+        }
+    }
+}
+
+/// `RemoteFriendListUpdateHandler`.
+pub(super) struct Handler {
+    pub(super) enabled: bool,
+    pub(super) state: State,
+    pub(super) latest: FriendData,
+    /// `lastUpdateNanos`: a read at that moment is due; `None` reads at once.
+    pub(super) last_update: Option<Instant>,
+    /// A forced read (`forceUpdate`) is due, whatever the interval.
+    pub(super) forced: bool,
+    /// `getUpdateIntervalNanos`'s foreground: the friends overlay is open.
+    foreground: bool,
+}
+
+impl Default for Handler {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            state: State::Loading,
+            latest: FriendData::default(),
+            last_update: None,
+            forced: false,
+            foreground: false,
+        }
+    }
+}
+
+impl Handler {
+    /// `getUpdateIntervalNanos`: the service's interval (a minute when it named none),
+    /// five times as long in the background.
+    fn interval(&self, service: &Service) -> Duration {
+        let foreground = service.friends_poll.unwrap_or(Duration::from_secs(60));
+        if self.foreground {
+            foreground
+        } else {
+            foreground * 5
+        }
+    }
+}
+
+/// `RemoteFriendListUpdateHandler`'s foreground interval: the friends overlay is open.
+pub fn set_foreground(open: bool) {
+    lock().handler.foreground = open;
+}
+
+/// `RemoteFriendListUpdateHandler.start`'s worker: one read per interval while the list
+/// is enabled, the first one as soon as it starts.
+pub(super) fn spawn_updater() {
+    static STARTED: AtomicBool = AtomicBool::new(false);
+    if STARTED.swap(true, Ordering::Relaxed) {
+        return;
+    }
+    let _ = thread::Builder::new()
+        .name("Friends List".into())
+        .spawn(|| {
+            loop {
+                thread::sleep(Duration::from_secs(1));
+                let due = {
+                    let inner = lock();
+                    if !inner.handler.enabled {
+                        continue;
+                    }
+                    inner.handler.forced
+                        || inner
+                            .handler
+                            .last_update
+                            .is_none_or(|at| at.elapsed() >= inner.handler.interval(&inner.service))
+                };
+                if due {
+                    update_friend_data();
+                }
+            }
+        });
+}
+
+/// `RemoteFriendListUpdateHandler.runUpdateFriendDataInternal`.
+pub(super) fn update_friend_data() {
+    let etag = {
+        let mut inner = lock();
+        if inner.service.pending {
+            // Another read is in flight; its answer is the cache's.
+            return;
+        }
+        if !inner.service.can_make_request() {
+            inner.handler.forced = false;
+            inner.handler.state = State::Success;
+            inner.handler.latest = inner.service.friends_cache.clone();
+            inner.handler.last_update = Some(Instant::now());
+            return;
+        }
+        inner.service.pending = true;
+        inner.service.cooldown = Some(Instant::now() + Duration::from_secs(10));
+        inner.service.friends_etag.clone()
+    };
+    log::debug!("Performing Friends List update");
+    let result = match session() {
+        Some(session) => fetch_friends(&session, etag.as_deref()),
+        None => Err(Failure {
+            code: ResultCode::Unauthorized,
+        }),
+    };
+    let mut inner = lock();
+    inner.service.pending = false;
+    inner.handler.forced = false;
+    inner.handler.last_update = Some(Instant::now());
+    match result {
+        Ok(answer) => {
+            if let Some(retry) = answer.retry_after {
+                inner.service.friends_poll = Some(retry);
+            }
+            if let Some(etag) = answer.etag {
+                inner.service.friends_etag = Some(etag);
+            }
+            if answer.status != 304 && !answer.body.is_empty() {
+                match parse_friends(&answer.body) {
+                    Some(data) => inner.service.friends_cache = data,
+                    None => {
+                        // authlib's parse failure is an ERROR result: the handler keeps
+                        // the cached lists and shows the generic error.
+                        inner.handler.latest = inner.service.friends_cache.clone();
+                        inner.handler.state = State::GenericError;
+                        return;
+                    }
+                }
+            }
+            inner.handler.latest = inner.service.friends_cache.clone();
+            inner.handler.state = State::Success;
+        }
+        Err(failure) => {
+            inner.handler.latest = inner.service.friends_cache.clone();
+            inner.handler.state = State::of(failure.code);
+            log::warn!(
+                "Friends List update failed with result code: {:?}",
+                failure.code
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn result_codes_map_to_the_handlers_states() {
+        assert_eq!(State::of(ResultCode::Success), State::Success);
+        assert_eq!(
+            State::of(ResultCode::TooManyRequests),
+            State::TemporaryUnavailable
+        );
+        assert_eq!(
+            State::of(ResultCode::UnknownProfile),
+            State::UserMayLackActiveProfile
+        );
+        assert_eq!(State::of(ResultCode::UpgradeNeeded), State::UpgradeNeeded);
+        assert_eq!(
+            State::of(ResultCode::ConnectionIssue),
+            State::ConnectionIssue
+        );
+    }
+}
@@ -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);
+    }
+}
@@ -303,8 +303,12 @@ fn faded(code: u32, local: vec3<f32>, dx: vec3<f32>, dy: vec3<f32>) -> bool {
    let pixel = max(length(dx), length(dy));
    let unit = exp2(ceil(log2(max(pixel * 1.5, 1.0 / 16.0))));
    let p = vec2<u32>(bitcast<vec2<u32>>(vec2<i32>(floor(plane / unit)))) & vec2(3u);
-    let bayer = array<u32, 16>(0u, 8u, 2u, 10u, 12u, 4u, 14u, 6u, 3u, 11u, 1u, 9u, 15u, 7u, 13u, 5u);
-    return (f32(bayer[p.y * 4u + p.x]) + 0.5) / 16.0 >= shown;
+    // The 4x4 Bayer matrix by rows, 0 8 2 10, 12 4 14 6, 3 11 1 9, 15 7 13 5: four bits each,
+    // two rows a word (a constant array indexed by the pixel would be a private array, which
+    // Adreno's Vulkan compiler, build 0676.41, fails to link).
+    let rows = select(0x6e4ca280u, 0x5d7f91b3u, p.y >= 2u);
+    let bayer = (rows >> (((p.y & 1u) * 4u + p.x) * 4u)) & 0xfu;
+    return (f32(bayer) + 0.5) / 16.0 >= shown;
 }
 // A fading tile or section is drawn a hair toward the camera (depth is
 // reversed: nearer is larger), the newer the more, so it wins where it draws
@@ -965,13 +969,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));
@@ -1421,7 +1421,7 @@ pub fn append_field(
        batch.text(atlas, value, x, y, color, shadow);
        cursor_x += HudBatch::text_width(atlas, value) + 1.0;
    }
-    let insert = char_len(value) >= max_chars;
+    let insert = utf16_len(value) >= max_chars;
    if insert {
        cursor_x -= 1.0;
    }
@@ -1444,6 +1444,29 @@ fn byte_index(s: &str, chars: usize) -> usize {
 pub fn char_len(s: &str) -> usize {
    s.chars().count()
 }
+/// Java's `String.length()`: UTF-16 code units, the unit `EditBox.maxLength`
+/// counts. A character outside the BMP — an emoji, say — is two of them, so
+/// a box with room for one more character takes an `a` and rejects a `😀`.
+pub fn utf16_len(s: &str) -> usize {
+    s.encode_utf16().count()
+}
+/// The longest prefix of `s` that fits `max` UTF-16 code units without
+/// splitting a character. `EditBox.insertText` drops the half surrogate it
+/// would otherwise keep, so this is what vanilla inserts; Rust strings cannot
+/// hold the lone surrogate that `setValue`'s unguarded `substring` may leave,
+/// so a value too long by half a character keeps the whole characters before
+/// the cut.
+pub fn utf16_prefix(s: &str, max: usize) -> String {
+    let mut units = 0;
+    for (i, c) in s.char_indices() {
+        let n = c.len_utf16();
+        if units + n > max {
+            return s[..i].to_owned();
+        }
+        units += n;
+    }
+    s.to_owned()
+}
 /// `EditBox.getWordPosition(dir, from)`: the character index `dir` words away
 /// from `from`. Forward, past the rest of the word and its spaces; backward,
 /// over any spaces to the start of the word.
@@ -1585,7 +1608,7 @@ impl EditBox {
        self.focused && (self.focused_at.elapsed().as_millis() / 300).is_multiple_of(2)
    }
    pub fn set_value(&mut self, value: &str) {
-        self.value = value.chars().take(self.max_length).collect();
+        self.value = utf16_prefix(value, self.max_length);
        self.move_cursor_to_end(false);
    }
    fn selected(&self) -> (usize, usize) {
@@ -1598,7 +1621,9 @@ impl EditBox {
        let (a, b) = self.selected();
        self.value.chars().skip(a).take(b - a).collect()
    }
-    /// EditBox.insertText: replace the selection, respecting the maximum length.
+    /// EditBox.insertText: replace the selection, respecting the maximum
+    /// length. The limit is in UTF-16 code units, as Java's `String.length()`
+    /// counts them.
    pub fn insert_text(&mut self, text: &str) {
        // `EditBox.charTyped` only inserts through `canConsumeInput`, which a
        // read-only box fails; the screens here hand typed text to this method
@@ -1608,10 +1633,17 @@ impl EditBox {
        }
        let (a, b) = self.selected();
        let filtered = crate::clipboard::filter_text(text, self.multiline);
+        let selected_units: usize = self
+            .value
+            .chars()
+            .skip(a)
+            .take(b - a)
+            .map(char::len_utf16)
+            .sum();
        let room = self
            .max_length
-            .saturating_sub(char_len(&self.value) - (b - a));
-        let insert: String = filtered.chars().take(room).collect();
+            .saturating_sub(utf16_len(&self.value) - selected_units);
+        let insert = utf16_prefix(&filtered, room);
        let (ba, bb) = (byte_index(&self.value, a), byte_index(&self.value, b));
        self.value.replace_range(ba..bb, &insert);
        let pos = a + char_len(&insert);
@@ -1889,8 +1921,10 @@ impl EditBox {
            batch.text_styled(atlas, &t, draw_x, ty, color, true);
            draw_x += atlas.font.width_text(&t) + 1.0;
        }
+        // EditBox.extractWidgetRenderState: `value.length() >= maxLength`
+        // is Java's length, so the caret turns into a bar at the unit count.
        let insert =
-            self.cursor < char_len(&self.value) || char_len(&self.value) >= self.max_length;
+            self.cursor < char_len(&self.value) || utf16_len(&self.value) >= self.max_length;
        let mut cursor_x = draw_x;
        if !on_screen {
            cursor_x = if rel_cursor > 0 { tx + self.width } else { tx };
@@ -2636,6 +2670,31 @@ mod tests {
        );
    }

+    /// `EditBox.maxLength` counts Java `String.length()`: UTF-16 code units.
+    /// A pasted emoji takes two of them and is never split (vanilla's
+    /// `Character.isHighSurrogate` guard drops the half it would keep).
+    #[test]
+    fn an_edit_box_maximum_counts_utf16_units() {
+        assert_eq!(utf16_len("ab😀"), 4);
+        assert_eq!(utf16_prefix("ab😀", 3), "ab");
+        assert_eq!(utf16_prefix("ab😀", 4), "ab😀");
+        let mut edit = EditBox::new(0.0, 0.0, 200.0, 20.0);
+        edit.max_length = 3;
+        edit.insert_text("ab😀");
+        assert_eq!(edit.value, "ab", "three units: a, b and one of the emoji's");
+        edit.set_value("");
+        edit.max_length = 4;
+        edit.insert_text("ab😀");
+        assert_eq!(edit.value, "ab😀", "four units, both of the emoji's");
+        // The selection's own units give their room back: with "ab"
+        // selected there are two units left, enough for the emoji, not
+        // for the emoji and the x.
+        edit.set_cursor(0, false);
+        edit.set_cursor(2, true);
+        edit.insert_text("😀x");
+        assert_eq!(edit.value, "😀😀");
+    }
+
    /// `EditBox.setInvertHighlightedTextColor`: a selection inverts its text
    /// unless the box asks it not to (the anvil's rename box).
    #[test]
@@ -14,6 +14,10 @@ pub enum Cursor {
    Arrow,
    PointingHand,
    NotAllowed,
+    /// `CursorTypes.RESIZE_NS`: a scroller held vertically (`MerchantScreen`).
+    ResizeNs,
+    /// `CursorTypes.RESIZE_EW`: a slider held horizontally.
+    ResizeEw,
 }

 thread_local! {
@@ -37,6 +41,19 @@ pub fn widget_cursor(hovered: bool, active: bool) {
        });
    }
 }
+/// `AbstractSliderButton.handleCursor`: a dragged slider resizes, a hovered
+/// one points, and an inactive one is not allowed.
+pub fn slider_cursor(hovered: bool, active: bool, dragging: bool) {
+    if hovered {
+        request_cursor(if !active {
+            Cursor::NotAllowed
+        } else if dragging {
+            Cursor::ResizeEw
+        } else {
+            Cursor::PointingHand
+        });
+    }
+}

 /// The cursor the frame asked for, and back to the arrow for the next one
 /// (the window shows the arrow unless a widget asks).
@@ -412,6 +429,18 @@ pub fn record_as(label: &str, [x, y, w, h]: [f32; 4], enabled: bool, kind: Kind)
 mod cursor_tests {
    use super::*;

+    #[test]
+    fn a_dragged_slider_asks_for_the_horizontal_resize_cursor() {
+        let _ = take_cursor();
+        slider_cursor(false, true, true);
+        assert_eq!(take_cursor(), Cursor::Arrow);
+        slider_cursor(true, true, true);
+        assert_eq!(take_cursor(), Cursor::ResizeEw);
+        slider_cursor(true, true, false);
+        assert_eq!(take_cursor(), Cursor::PointingHand);
+        slider_cursor(true, false, true);
+        assert_eq!(take_cursor(), Cursor::NotAllowed);
+    }
    #[test]
    fn hovered_widgets_ask_for_the_hand_or_not_allowed() {
        let _ = take_cursor();
@@ -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.",
@@ -1053,5 +1053,100 @@
  "horizon.studio.topbar.add_marker": "Додати маркер",
  "horizon.studio.topbar.clear_keyframes": "🗑 Очистити ключові кадри",
  "horizon.studio.topbar.timeline_hud": "⏱ Шкала часу",
-  "horizon.studio.topbar.split_scene": "Розділити сцену"
+  "horizon.studio.topbar.split_scene": "Розділити сцену",
+  "horizon.options.radial_mode": "Радіальне меню",
+  "horizon.options.radial_mode.about": "Утримуйте кнопку відкриття радіального меню або натисніть її раз, щоб відкрити, і ще раз, щоб закрити.",
+  "horizon.options.radial_mode.hold.about": "Утримуйте кнопку відкриття й відпустіть, щоб виконати те, на що вказує стік.",
+  "horizon.options.radial_mode.toggle.about": "Натисніть кнопку відкриття, щоб відкрити меню; A або повторне натискання кнопки відкриття виконує те, на що вказує стік, B закриває.",
+  "horizon.options.radial_stick": "Вибір у радіальному меню",
+  "horizon.options.radial_stick.about": "Стік, яким ви вказуєте на комірки радіального меню.",
+  "horizon.options.radial_stick.right": "Правий стік",
+  "horizon.options.radial_stick.left": "Лівий стік",
+  "horizon.options.radial_stick.either": "Будь-який",
+  "horizon.options.radial_stick.right.about": "Правий стік вказує на комірки; лівим ви й далі ходите.",
+  "horizon.options.radial_stick.left.about": "Лівий стік вказує, а ви стоїте на місці. Під тим самим пальцем — хрестовина праворуч, тож оберіть кнопку відкриття на сторінці «Радіальне меню».",
+  "horizon.options.radial_stick.either.about": "Вказує стік, яким рухали останнім; жоден не рухає вас і не повертає огляд. Відкрити меню можна лише бампером, тригером або кнопкою View.",
+  "horizon.pages.controller_radial": "Радіальне меню",
+  "horizon.radial.page.general": "Загальне",
+  "horizon.radial.page.camera": "Камера",
+  "horizon.radial.release_stick": "Відпустіть стік",
+  "horizon.radial.action.key_inventory": "Інвентар",
+  "horizon.radial.action.key_chat": "Чат",
+  "horizon.radial.action.key_command": "Команди",
+  "horizon.radial.action.key_advancements": "Досягнення",
+  "horizon.radial.action.key_togglePerspective": "Перспектива",
+  "horizon.radial.action.key_swapOffhand": "Поміняти руки",
+  "horizon.radial.action.key_drop": "Викинути",
+  "horizon.radial.action.key_pickItem": "Вибрати блок",
+  "horizon.radial.action.key_screenshot": "Знімок екрана",
+  "horizon.radial.action.key_toggleGui": "Сховати HUD",
+  "horizon.radial.action.key_smoothCamera": "Кінематографічна камера",
+  "horizon.radial.action.key_socialInteractions": "Соціальне",
+  "horizon.radial.action.key_emote": "Емоція",
+  "horizon.radial.action.pad_hotbarPrevious": "Попередня комірка",
+  "horizon.radial.action.pad_hotbarNext": "Наступна комірка",
+  "horizon.radial.action.key_fullscreen": "Повний екран",
+  "horizon.radial.action.key_quickActions": "Швидкі дії",
+  "horizon.radial.action.key_debug_overlay": "Екран налагодження",
+  "horizon.radial.missing": "Відсутня",
+  "horizon.radial.why.missing": "Невідома дія",
+  "horizon.radial.why.cosmetics": "Потрібна увімкнена косметика",
+  "horizon.radial.why.quick_actions": "На цьому сервері немає швидких дій",
+  "horizon.radial.why.social": "Лише на сервері",
+  "horizon.radial.next": "→ %s",
+  "horizon.radial.state.first_person": "Від першої особи",
+  "horizon.radial.state.third_person_back": "Від третьої особи",
+  "horizon.radial.state.third_person_front": "Вигляд спереду",
+  "horizon.radial.state.shown": "Показано",
+  "horizon.radial.state.hidden": "Приховано",
+  "horizon.radial.state.on": "Увімк.",
+  "horizon.radial.state.off": "Вимк.",
+  "horizon.radial.pick_title": "Оберіть дію",
+  "horizon.radial.group.actions": "Дії",
+  "horizon.radial.pick.slot": "Комірка «%s» сторінки «%s»",
+  "horizon.radial.pick.about": "Ставить цю дію в комірку й повертається назад. Поточну дію комірки позначено.",
+  "horizon.radial.pick.current": "Поточна",
+  "horizon.radial.missing.about": "Ця гра не знає дії %s: комірка зберігає її, але нічого не виконує. Натисніть або «праворуч», щоб поставити сюди іншу.",
+  "horizon.radial.page.new": "Нова сторінка",
+  "horizon.pages.open.controller_radial": "Радіальне меню...",
+  "horizon.radial.group.slots": "Комірки",
+  "horizon.radial.group.page": "Сторінка",
+  "horizon.radial.group.all": "Усі сторінки",
+  "horizon.radial.empty": "Порожньо",
+  "horizon.radial.page_of": "Сторінка %s з %s. Кожна комірка — це напрямок стіка вибору, поки кнопку відкриття утримано.",
+  "horizon.radial.slot.0": "Угору",
+  "horizon.radial.slot.1": "Угору праворуч",
+  "horizon.radial.slot.2": "Праворуч",
+  "horizon.radial.slot.3": "Униз праворуч",
+  "horizon.radial.slot.4": "Униз",
+  "horizon.radial.slot.5": "Униз ліворуч",
+  "horizon.radial.slot.6": "Ліворуч",
+  "horizon.radial.slot.7": "Угору ліворуч",
+  "horizon.radial.slot.about": "Дія, яку виконує цей напрямок. Натисніть, щоб побачити список дій; «праворуч» — наступна, «ліворуч» або Shift+клік — попередня.",
+  "horizon.radial.rename": "Перейменувати сторінку",
+  "horizon.radial.rename.about": "Дайте цій сторінці власну назву.",
+  "horizon.radial.name_title": "Назва сторінки",
+  "horizon.radial.new_page.about": "Додає порожню сторінку після останньої й показує її.",
+  "horizon.radial.new_page.full": "Меню вміщує щонайбільше %s сторінок.",
+  "horizon.radial.delete_page": "Видалити сторінку",
+  "horizon.radial.delete_page.about": "Одразу видаляє цю сторінку та її комірки. «Скасувати» повертає її.",
+  "horizon.radial.delete_page.last": "У меню лишається щонайменше одна сторінка.",
+  "horizon.radial.reset": "Скинути всі сторінки",
+  "horizon.radial.reset.about": "Одразу повертає сторінки «Загальне» й «Камера» та видаляє решту. «Скасувати» повертає їх.",
+  "horizon.radial.reset.default": "Сторінки вже типові.",
+  "horizon.radial.opener": "Кнопка відкриття",
+  "horizon.radial.opener.about": "Кнопка, яку утримують, щоб відкрити меню. Натисніть, потім натисніть кнопку геймпада: бампер або хрестовину, але не A, B, X, Y чи правий стік, якими керують і скасовують.",
+  "horizon.radial.opener.about.left": "Кнопка, яку утримують, щоб відкрити меню. Натисніть, потім натисніть кнопку геймпада: бампер, A, X або Y, але не хрестовину чи лівий стік, якими керують, і не B, яка скасовує.",
+  "horizon.radial.opener.about.either": "Кнопка, яку утримують, щоб відкрити меню. Натисніть, потім натисніть кнопку геймпада: бампер, тригер або View; обидва великі пальці керують, а B скасовує.",
+  "horizon.radial.unbound": "Жодна кнопка не відкриває меню (кнопку під пальцем, яким обирають, звільнено): натисніть, потім натисніть кнопку геймпада.",
+  "horizon.radial.conflict": "Спільна з іншою дією: у грі цю кнопку забирає меню. Натисніть, щоб обрати іншу.",
+  "Radial Menu": "Радіальне меню",
+  "Named pages of eight actions, held open with a button.": "Іменовані сторінки по вісім дій, відкриті, поки утримуєте кнопку.",
+  "The shader pack lights the world itself.": "Пакет шейдерів сам освітлює світ.",
+  "How bright the HUD and menus are. Auto: at paper white.": "Яскравість HUD і меню. «Авто»: на рівні білої точки.",
+  "HDR output stopped the game the last time it started with this graphics driver. Choose a mode to try again.": "Минулого разу з цим графічним драйвером HDR-вивід зупинив гру. Оберіть режим, щоб спробувати знову.",
+  "horizon.pad.action.radial": "Радіальне меню",
+  "horizon.recipes.fuel.options": "Утримуйте SHIFT, щоб закріпити цю підказку, потім клацніть інгредієнт, щоб переглянути рецепти.",
+  "horizon.recipes.fuel.any": "Будь-яке паливо",
+  "horizon.recipes.fuel.minecraft": "Minecraft"
 }
@@ -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;
@@ -137,6 +137,15 @@ pub struct DebugKeys {
 }

 impl DebugKeys {
+    /// Window focus lost, or input reset: clear held modifier state.
+    pub fn reset(&mut self) {
+        self.modifier_down = false;
+        self.used_debug_key_as_modifier = false;
+        if self.crash_key_time > 0 {
+            self.crash_key_time = -1;
+        }
+    }
+
    /// `keyPress` once the open screen (if any) did not take the key. `key`
    /// is the physical key's name (`key.keyboard.f3`); `crash_key_down`
    /// whether the crash mapping's key is held (`InputConstants.isKeyDown`).
@@ -487,4 +496,18 @@ mod tests {
        press(&mut k, &mut h, &b, "key.keyboard.k", 2);
        assert_eq!(h.actions, [(DebugAction::ShowChunkBorders, false)]);
    }
+
+    #[test]
+    fn reset_on_focus_loss_clears_held_modifier_and_avoids_spurious_shortcuts() {
+        let (mut k, mut h, b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
+        press(&mut k, &mut h, &b, F3, 0);
+        assert!(k.modifier_down);
+        // Window loses focus while F3 was down (e.g. desktop shortcut Ctrl+F3)
+        k.reset();
+        assert!(!k.modifier_down);
+        assert!(!k.used_debug_key_as_modifier);
+        // User refocuses and presses 'b': it should NOT trigger ShowHitboxes
+        assert!(press(&mut k, &mut h, &b, "key.keyboard.b", 1));
+        assert!(h.actions.is_empty());
+    }
 }
@@ -39,6 +39,8 @@ pub fn conversion_tags(raw: Option<&Tag>) -> Option<Tag> {
 fn string(s: &str) -> Tag {
    Tag::String(s.into())
 }
+mod refs;
+pub use refs::who_by_uuid;
 /// Entity type ID (`id`).
 pub fn kind(tag: &Tag) -> Option<String> {
    horizon_client_core::identifier::normalize_id(&text(tag.get("id"))?)
@@ -284,28 +286,6 @@ pub fn migrate_player_uuid(tag: &mut Tag, old: [i32; 4], new: [i32; 4]) {
        _ => {}
    }
 }
-/// The entity a stored UUID names, while it is in the level: `player` (the
-/// player's own UUID, when one is in the level), or the mob `uuids` gives that
-/// UUID to. `uuids` is the game layer's id -> UUID map, so this is the read half
-/// of the pair [`who_uuid`] and `mob_to_nbt`'s `uuid_of` form. A UUID nothing
-/// loaded has, or one naming a kind `Who` cannot carry (an item, a projectile, a
-/// guest), is `None` - never some other entity as a stand-in.
-pub fn who_by_uuid(
-    uuids: &HashMap<u32, [i32; 4]>,
-    mobs: &[Mob],
-    player: Option<[i32; 4]>,
-    uuid: [i32; 4],
-) -> Option<Who> {
-    if player == Some(uuid) {
-        return Some(Who::Player);
-    }
-    // Only a loaded mob: the map also holds projectiles, vehicles and items,
-    // whose ids mean nothing to `Who`.
-    uuids
-        .iter()
-        .find(|(id, u)| **u == uuid && mobs.iter().any(|m| m.id == **id))
-        .map(|(id, _)| Who::Mob(*id))
-}
 /// `AngerManagement.SUSPECT_ANGER_PAIR`: one suspect's UUID and how angry the
 /// warden is at it.
 fn suspect_anger(uuid: [i32; 4], anger: i32) -> Tag {
@@ -1257,11 +1237,11 @@ pub fn mob_to_nbt(
                ));
            }
            // ITEM_PICKUP_COOLDOWN_TICKS (`Codec.INT`), which a throw sets to 60,
-            // while it runs.
-            if m.extra.ints[3] > 0 {
+            // while the memory is there (its value 0 included).
+            if let Some(ticks) = crate::mobs::allay::pickup_cooldown(m) {
                memories.push((
                    "minecraft:item_pickup_cooldown_ticks",
-                    Tag::compound([("value", Tag::Int(m.extra.ints[3]))]),
+                    Tag::compound([("value", Tag::Int(ticks))]),
                ));
            }
            // Always written, so a forgotten note block does not come back
@@ -2016,7 +1996,7 @@ pub fn mob_from_nbt_with_random(
    if crate::mobs::equine::is_equine(m.species()) {
        m.health = m.health.min(m.attrs.max_health);
    }
-    m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
+    m.hurt_time = i32::from(number(tag.get("HurtTime")).unwrap_or(0) as i16);
    // What it holds (equipment.mainhand / offhand), when saved.
    if let Some(eq) = tag.get("equipment") {
        m.extra
@@ -2054,7 +2034,7 @@ pub fn mob_from_nbt_with_random(
        // vanilla); a loaded mob holds only what its file lists.
        m.extra.set_main_hand(None);
    }
-    m.death_time = number(tag.get("DeathTime")).unwrap_or(0) as i32;
+    m.death_time = i32::from(number(tag.get("DeathTime")).unwrap_or(0) as i16);
    m.impulse_grace_time =
        number(tag.get("current_impulse_context_reset_grace_time")).unwrap_or(0) as i32;
    // Mob.readAdditionalSaveData overrides what the constructor set (copper
@@ -2063,6 +2043,7 @@ pub fn mob_from_nbt_with_random(
    m.extra.death_loot_table = text(tag.get("DeathLootTable"))
        .and_then(|t| horizon_client_core::identifier::normalize_id(&t));
    m.extra.death_loot_seed = number(tag.get("DeathLootTableSeed")).unwrap_or(0);
+    refs::read_last_hurt_by(&mut m, tag);
    // `NeutralMob.readPersistentAngerSaveData`: the anger end time and the
    // target come back with the mob.
    if persistent_anger(m.species()) {
@@ -2442,7 +2423,7 @@ pub fn mob_from_nbt_with_random(
        restore_axolotl_memories(&mut m, tag);
    }
    read_variant(&mut m, tag);
-    m.fire_ticks = number(tag.get("Fire")).unwrap_or(0) as i32;
+    m.fire_ticks = i32::from(number(tag.get("Fire")).unwrap_or(0) as i16);
    // Entity.load: `input.getIntOr("Air", getMaxAirSupply())`, 4800 for a dolphin.
    m.air = number(tag.get("Air")).map_or(m.max_air_supply(), |air| air as i32);
    if m.species() == crate::mobs::Species::Allay {
@@ -2488,8 +2469,8 @@ pub fn mob_from_nbt_with_random(
        };
        m.extra.ints[2] =
            number(memory("minecraft:liked_noteblock_cooldown_ticks")).unwrap_or(0) as i32;
-        m.extra.ints[3] =
-            number(memory("minecraft:item_pickup_cooldown_ticks")).unwrap_or(0) as i32;
+        let pickup = number(memory("minecraft:item_pickup_cooldown_ticks")).map(|t| t as i32);
+        crate::mobs::allay::set_pickup_cooldown(&mut m, pickup);
        if let Some(st) = m.extra.allay.as_mut()
            && let Some(noteblock) = memory("minecraft:liked_noteblock")
            && let Some(Tag::IntArray(p)) = noteblock.get("pos")
@@ -2628,7 +2609,7 @@ pub fn mob_from_nbt_with_random(
    }
    // Sheep.readAdditionalSaveData: white and unsheared when absent.
    if m.species() == crate::mobs::Species::Sheep {
-        m.extra.color = number(tag.get("Color")).map_or(0, |c| (c as u8) & 15);
+        m.extra.color = crate::mobs::farm::saved_color(tag.get("Color"));
        m.extra.sheared = flag(tag, "Sheared");
    }
    // GlowSquid.readAdditionalSaveData: not dimmed when absent.
@@ -2978,7 +2959,8 @@ pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> Option<ItemE
 /// `OminousItemSpawner.addAdditionalSaveData`: its item (left out when
 /// empty) and `spawn_item_after_ticks`. Its tick count is the entity's
 /// `tickCount`, which isn't saved: a reloaded spawner counts from 0 again.
-/// It never moves, so the `Motion` it was loaded with is what it saves.
+/// It never moves or turns: it saves the Motion, Rotation, OnGround and
+/// fall_distance it was loaded with (`Entity.load`).
 pub fn ominous_item_spawner_to_nbt(
    item: &crate::items::ItemStack,
    position: Vec3,
@@ -2991,13 +2973,12 @@ pub fn ominous_item_spawner_to_nbt(
        uuid,
        position,
        motion: raw.map_or(Vec3::ZERO, loaded_motion),
-        rotation: [0.0, 0.0],
-        on_ground: false,
-        fall_distance: 0.0,
+        rotation: raw.map_or([0.0, 0.0], rotation),
+        on_ground: raw.is_some_and(|t| flag(t, "OnGround")),
+        fall_distance: float(raw.and_then(|t| t.get("fall_distance"))).unwrap_or(0.0),
    };
    let mut tag = base.tag(raw);
-    // `ItemStack.CODEC` can't encode `ItemStack.EMPTY`, so an empty item
-    // writes no key.
+    // `ItemStack.CODEC` can't encode `ItemStack.EMPTY`: an empty item writes no key.
    if let Tag::Compound(map) = &mut tag {
        map.remove(&"item".into());
    }
@@ -3024,59 +3005,8 @@ pub fn ominous_item_spawner_from_nbt(tag: &Tag) -> Option<(crate::items::ItemSta
    Some((item, position(tag)?, after))
 }

-/// `ExperienceOrb`: Health, Age, Value, Count.
-pub fn orb_to_nbt(o: &ExperienceOrb, uuid: [i32; 4]) -> Tag {
-    let base = Base {
-        id: "minecraft:experience_orb",
-        uuid,
-        position: o.position,
-        motion: o.velocity,
-        rotation: o.rotation,
-        on_ground: o.on_ground,
-        fall_distance: 0.0,
-    };
-    let mut tag = base.tag(None);
-    for (key, value) in [
-        ("Health", Tag::Short(o.health as i16)),
-        ("Age", Tag::Short(o.age.min(i16::MAX as u32) as i16)),
-        ("Value", Tag::Short(o.value as i16)),
-        ("Count", Tag::Int(o.count.min(i32::MAX as u32) as i32)),
-    ] {
-        put(&mut tag, key, value);
-    }
-    // Entity.saveWithoutId writes NoGravity only when set.
-    if o.no_gravity {
-        put(&mut tag, "NoGravity", Tag::Byte(1));
-    }
-    tag
-}
-/// One orb with its merged `Count`.
-pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
-    let Some(position) = position(tag) else {
-        return Vec::new();
-    };
-    let count = number(tag.get("Count")).unwrap_or(1).max(1) as u32;
-    let orb = ExperienceOrb {
-        rotation: rotation(tag),
-        join: Default::default(),
-        no_gravity: flag(tag, "NoGravity"),
-        id: 0,
-        position,
-        previous: position,
-        velocity: motion(tag),
-        // `getShortOr("Value", 0)`, unclamped.
-        value: tag.get("Value").and_then(int_value).unwrap_or(0) as i16 as i32,
-        age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
-        on_ground: flag(tag, "OnGround"),
-        count,
-        ticks: 0,
-        health: number(tag.get("Health")).unwrap_or(5) as i32,
-        // ExperienceOrb's followingPlayer is transient: never saved, so a
-        // loaded orb starts without one.
-        following: None,
-    };
-    vec![orb]
-}
+mod orb;
+pub use orb::{orb_to_nbt, orbs_from_nbt};

 /// `Projectile` + `AbstractArrow.addAdditionalSaveData` of a live arrow;
 /// `in_block` is its `inBlockState`, `raw` the compound it was loaded with.
@@ -3868,19 +3798,7 @@ pub fn armor_stand_to_nbt(a: &ArmorStand, uuid: [i32; 4], raw: Option<&Tag>) ->
            ("AbsorptionAmount", Tag::Float(0)),
            ("FallFlying", Tag::Byte(0)),
            ("current_impulse_context_reset_grace_time", Tag::Int(0)),
-            // AttributeMap.pack: the movement_speed instance the stand's first
-            // tick makes (removeFrost), at the registry default.
-            (
-                "attributes",
-                Tag::List(if a.speed_instance {
-                    vec![Tag::compound([
-                        ("id", string(SPEED_ATTRIBUTE)),
-                        ("base", Tag::Double(0.7f64.to_bits())),
-                    ])]
-                } else {
-                    Vec::new()
-                }),
-            ),
+            ("attributes", Tag::List(Vec::new())),
            (
                "Brain",
                Tag::compound([("memories", Tag::Compound(Compound::new()))]),
@@ -3890,6 +3808,18 @@ pub fn armor_stand_to_nbt(a: &ArmorStand, uuid: [i32; 4], raw: Option<&Tag>) ->
        ] {
            map.entry(key.into()).or_insert(value);
        }
+        // `removeFrost`'s first-tick movement_speed, over a saved list without it.
+        if a.speed_instance
+            && let Some(Tag::List(list)) = map.get_mut(&"attributes".into())
+            && !list
+                .iter()
+                .any(|t| text(t.get("id")).as_deref() == Some(SPEED_ATTRIBUTE))
+        {
+            list.push(Tag::compound([
+                ("id", string(SPEED_ATTRIBUTE)),
+                ("base", Tag::Double(0.7f64.to_bits())),
+            ]));
+        }
    }
    tag
 }
@@ -3903,7 +3833,7 @@ pub fn armor_stand_from_nbt(tag: &Tag, id: u32) -> Option<ArmorStand> {
        if list.iter().any(|attr| text(attr.get("id")).as_deref() == Some(SPEED_ATTRIBUTE)));
    a.velocity = loaded_motion(tag);
    a.health = float(tag.get("Health")).unwrap_or(20.0) as f32;
-    a.fire_ticks = number(tag.get("Fire")).unwrap_or(0) as i32;
+    a.fire_ticks = i32::from(number(tag.get("Fire")).unwrap_or(0) as i16);
    a.custom_name = tag.get("CustomName").map(name_text);
    a.name_visible = flag(tag, "CustomNameVisible");
    if let Some(eq) = tag.get("equipment") {
@@ -4620,6 +4550,27 @@ mod tests {
        }
    }

+    /// `LivingEntity.readAdditionalSaveData` reads `HurtTime` and `DeathTime`
+    /// with `getShortOr`: an int tag is narrowed (`(short)(value & 65535)`),
+    /// so 40000 is -25536 and never counts down.
+    #[test]
+    fn a_mob_narrows_its_hurt_and_death_time_to_a_short() {
+        let kind = crate::mobs::sensor_scan_tests::kind();
+        let types = [(kind.id.to_string(), kind.clone())].into();
+        let load = |hurt: Tag, death: Tag| {
+            let raw = Tag::compound([
+                ("id", string(&kind.id)),
+                ("Pos", doubles(&[4.5, 220.0, 4.5])),
+                ("HurtTime", hurt),
+                ("DeathTime", death),
+            ]);
+            let m = mob_from_nbt(&raw, &types, 1, None).unwrap();
+            (m.hurt_time, m.death_time)
+        };
+        assert_eq!(load(Tag::Int(40000), Tag::Int(65546)), (-25536, 10));
+        assert_eq!(load(Tag::Short(7), Tag::Short(19)), (7, 19));
+    }
+
    /// A mount keeps its body armour and a helmet (say
    /// `/item replace entity <horse> armor.head with minecraft:iron_helmet`)
    /// in their own slots through a save: vanilla holds both (`equipment.body`
@@ -5910,6 +5861,43 @@ mod tests {
        assert_eq!(attributes(&armor_stand_from_nbt(&saved, 1).unwrap()), speed);
    }
    #[test]
+    fn a_loaded_stand_gains_the_speed_instance_its_first_tick_makes() {
+        // Vanilla 26.3: `/summon armor_stand ~ ~ ~ {attributes:[]}` saves `[]` until the
+        // first tick, whose removeFrost makes movement_speed (base 0.7d); a saved
+        // instance of another attribute stays in front of it.
+        let ids = |stand: &ArmorStand, raw: &Tag| match armor_stand_to_nbt(stand, [0; 4], Some(raw))
+            .get("attributes")
+        {
+            Some(Tag::List(attrs)) => attrs
+                .iter()
+                .map(|a| (text(a.get("id")).unwrap(), a.get("base").cloned()))
+                .collect::<Vec<_>>(),
+            other => panic!("attributes: {other:?}"),
+        };
+        let health = (
+            "minecraft:max_health".to_owned(),
+            Some(Tag::Double(20f64.to_bits())),
+        );
+        let speed = (
+            "minecraft:movement_speed".to_owned(),
+            Some(Tag::Double(0.7f64.to_bits())),
+        );
+        let empty = Tag::compound([("attributes", Tag::List(Vec::new()))]);
+        let saved = Tag::compound([(
+            "attributes",
+            Tag::List(vec![Tag::compound([
+                ("id", string("minecraft:max_health")),
+                ("base", Tag::Double(20f64.to_bits())),
+            ])]),
+        )]);
+        let mut stand = ArmorStand::new(1, Vec3::ZERO, 0.0);
+        assert_eq!(ids(&stand, &empty), []);
+        assert_eq!(ids(&stand, &saved), std::slice::from_ref(&health));
+        stand.speed_instance = true;
+        assert_eq!(ids(&stand, &empty), std::slice::from_ref(&speed));
+        assert_eq!(ids(&stand, &saved), [health, speed]);
+    }
+    #[test]
    fn summoned_trident_defaults_are_not_pickable_or_already_shot() {
        let raw = Tag::compound([
            ("Pos", doubles(&[0.0, 0.0, 0.0])),
@@ -7430,11 +7418,11 @@ mod sheep_nbt_tests {
        assert_eq!(number(tag.get("InWaterTime")), Some(300));
        assert_eq!(number(tag.get("DrownedConversionTime")), Some(-1));
        assert_eq!((back.extra.counter, back.extra.counter2), (300, 0));
-        (zombie.extra.counter, zombie.extra.counter2) = (600, 300);
+        (zombie.extra.counter, zombie.extra.counter2) = (600, 301);
        let (back, tag) = round_trip(&zombie);
        assert_eq!(number(tag.get("InWaterTime")), Some(600));
-        assert_eq!(number(tag.get("DrownedConversionTime")), Some(299));
-        assert_eq!((back.extra.counter, back.extra.counter2), (600, 300));
+        assert_eq!(number(tag.get("DrownedConversionTime")), Some(300));
+        assert_eq!((back.extra.counter, back.extra.counter2), (600, 301));
        // A skeleton outside powder snow is not afflicted: -1 whatever the
        // counter holds, as with a fresh or NoAI one.
        let (_, tag) = round_trip(&new("minecraft:skeleton"));
@@ -9481,6 +9469,34 @@ mod pickup_loot_save_tests {
 mod stand_fall_save_tests {
    use super::*;

+    /// `Entity.load` reads `Fire` with `getShortOr`: an int tag is narrowed
+    /// (`(short)(value & 65535)`), so 40000 is -25536 and the stand or mob
+    /// does not burn.
+    #[test]
+    fn a_stand_and_a_mob_narrow_a_loaded_fire_to_a_short() {
+        let kind = crate::mobs::sensor_scan_tests::kind();
+        let types = [(kind.id.to_string(), kind.clone())].into();
+        for (fire, expected) in [
+            (Tag::Int(40000), -25536),
+            (Tag::Int(65546), 10),
+            (Tag::Short(60), 60),
+        ] {
+            let input = Tag::compound([
+                ("id", string(&kind.id)),
+                ("Pos", doubles(&[4.5, 205.0, 4.5])),
+                ("Fire", fire),
+            ]);
+            assert_eq!(
+                armor_stand_from_nbt(&input, 1).unwrap().fire_ticks,
+                expected
+            );
+            assert_eq!(
+                mob_from_nbt(&input, &types, 1, None).unwrap().fire_ticks,
+                expected
+            );
+        }
+    }
+
    #[test]
    fn decoded_stand_fall_distance_survives_save_without_raw_or_with_stale_raw() {
        let stale = Tag::compound([("fall_distance", Tag::Double(99.0_f64.to_bits()))]);
@@ -39,10 +39,16 @@ fn attached_block_pos(tag: &Tag) -> Option<[i32; 3]> {
        }
    }
 }
+/// `Direction.from3DDataValue` / `from2DDataValue`: the byte read by
+/// `LEGACY_ID_CODEC` indexes the table as `abs(data % modulus)`, never clamped.
+fn wrap_data_value(raw: impl TryInto<i64> + Copy, modulus: i64) -> u8 {
+    let byte = raw.try_into().unwrap_or(0) as i8;
+    (i64::from(byte) % modulus).unsigned_abs() as u8
+}
 /// The block position, facing and variant (if saved) of a painting.
 pub fn painting_from_nbt(tag: &Tag) -> Option<([i32; 3], u8, Option<String>)> {
    let pos = attached_block_pos(tag)?;
-    let facing = (number(tag.get("facing")).unwrap_or(0) & 3) as u8;
+    let facing = wrap_data_value(number(tag.get("facing")).unwrap_or(0), 4);
    Some((pos, facing, text(tag.get("variant"))))
 }
 /// ItemFrame.addAdditionalSaveData.
@@ -92,7 +98,7 @@ pub fn item_frame_from_nbt(tag: &Tag, id: u32) -> Option<ItemFrame> {
    Some(ItemFrame {
        id,
        pos,
-        facing: number(tag.get("Facing")).unwrap_or(0).clamp(0, 5) as u8,
+        facing: wrap_data_value(number(tag.get("Facing")).unwrap_or(0), 6),
        glow: kind(tag).as_deref() == Some("minecraft:glow_item_frame"),
        item: tag
            .get("Item")
@@ -107,3 +113,26 @@ pub fn item_frame_from_nbt(tag: &Tag, id: u32) -> Option<ItemFrame> {
        random: crate::random_source::entity(),
    })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn negative_facing_wraps_like_vanilla_direction_codecs() {
+        // from3DDataValue: abs(-1 % 6) = 1 (UP); 7 -> 1; -6 -> 0.
+        for (raw, want) in [(-1i8, 1u8), (7, 1), (-6, 0), (5, 5), (0, 0)] {
+            let tag = Tag::compound([
+                ("Facing", Tag::Byte(raw)),
+                ("block_pos", Tag::IntArray(vec![0, 0, 0])),
+            ]);
+            assert_eq!(item_frame_from_nbt(&tag, 1).unwrap().facing, want);
+        }
+        // from2DDataValue: abs(-1 % 4) = 1.
+        let tag = Tag::compound([
+            ("facing", Tag::Byte(-1)),
+            ("block_pos", Tag::IntArray(vec![0, 0, 0])),
+        ]);
+        assert_eq!(painting_from_nbt(&tag).unwrap().1, 1);
+    }
+}
@@ -0,0 +1,56 @@
+//! Experience orbs: `ExperienceOrb` save data.
+use super::{Base, ExperienceOrb, Tag, flag, int_value, motion, number, position, put, rotation};
+
+/// `ExperienceOrb`: Health, Age, Value, Count.
+pub fn orb_to_nbt(o: &ExperienceOrb, uuid: [i32; 4]) -> Tag {
+    let base = Base {
+        id: "minecraft:experience_orb",
+        uuid,
+        position: o.position,
+        motion: o.velocity,
+        rotation: o.rotation,
+        on_ground: o.on_ground,
+        fall_distance: 0.0,
+    };
+    let mut tag = base.tag(None);
+    for (key, value) in [
+        ("Health", Tag::Short(o.health as i16)),
+        ("Age", Tag::Short(o.age.min(i16::MAX as u32) as i16)),
+        ("Value", Tag::Short(o.value as i16)),
+        ("Count", Tag::Int(o.count.min(i32::MAX as u32) as i32)),
+    ] {
+        put(&mut tag, key, value);
+    }
+    // Entity.saveWithoutId writes NoGravity only when set.
+    if o.no_gravity {
+        put(&mut tag, "NoGravity", Tag::Byte(1));
+    }
+    tag
+}
+/// One orb with its merged `Count`.
+pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
+    let Some(position) = position(tag) else {
+        return Vec::new();
+    };
+    let count = number(tag.get("Count")).unwrap_or(1).max(1) as u32;
+    let orb = ExperienceOrb {
+        rotation: rotation(tag),
+        join: Default::default(),
+        no_gravity: flag(tag, "NoGravity"),
+        id: 0,
+        position,
+        previous: position,
+        velocity: motion(tag),
+        // `getShortOr("Value", 0)`, unclamped.
+        value: tag.get("Value").and_then(int_value).unwrap_or(0) as i16 as i32,
+        age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
+        on_ground: flag(tag, "OnGround"),
+        count,
+        ticks: 0,
+        health: number(tag.get("Health")).unwrap_or(5) as i32,
+        // ExperienceOrb's followingPlayer is transient: never saved, so a
+        // loaded orb starts without one.
+        following: None,
+    };
+    vec![orb]
+}
@@ -0,0 +1,85 @@
+//! `EntityReference`s a mob's compound holds: a UUID, resolved against what is in
+//! the level.
+use super::{Who, number, uuid_from_tag};
+use crate::mobs::Mob;
+use horizon_world::nbt::Tag;
+use std::collections::HashMap;
+
+/// `LivingEntity.readAdditionalSaveData`: `last_hurt_by_mob` is a lazy
+/// `EntityReference` (the UUID, which the game resolves once the entity is in
+/// the level) and its timestamp is `tickCount - ticks_since_last_hurt_by_mob`.
+pub(super) fn read_last_hurt_by(m: &mut Mob, tag: &Tag) {
+    m.ai.last_hurt_by_ref = uuid_from_tag(tag.get("last_hurt_by_mob"));
+    m.ai.last_hurt_by_time = (m.age as i32)
+        .wrapping_sub(number(tag.get("ticks_since_last_hurt_by_mob")).unwrap_or(0) as i32);
+}
+
+/// The entity a stored UUID names, while it is in the level: `player` (the
+/// player's own UUID, when one is in the level), or the mob `uuids` gives that
+/// UUID to. `uuids` is the game layer's id -> UUID map, so this is the read half
+/// of the pair [`who_uuid`] and `mob_to_nbt`'s `uuid_of` form. A UUID nothing
+/// loaded has, or one naming a kind `Who` cannot carry (an item, a projectile, a
+/// guest), is `None` - never some other entity as a stand-in.
+pub fn who_by_uuid(
+    uuids: &HashMap<u32, [i32; 4]>,
+    mobs: &[Mob],
+    player: Option<[i32; 4]>,
+    uuid: [i32; 4],
+) -> Option<Who> {
+    if player == Some(uuid) {
+        return Some(Who::Player);
+    }
+    // Only a loaded mob: the map also holds projectiles, vehicles and items,
+    // whose ids mean nothing to `Who`.
+    uuids
+        .iter()
+        .find(|(id, u)| **u == uuid && mobs.iter().any(|m| m.id == **id))
+        .map(|(id, _)| Who::Mob(*id))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::*;
+    use crate::mobs::{Species, sensor_scan_tests::kind};
+
+    fn types() -> HashMap<String, std::sync::Arc<crate::mobs::MobType>> {
+        let mut pig = (*kind()).clone();
+        pig.id = "minecraft:pig".into();
+        pig.species = Species::Pig;
+        HashMap::from([("minecraft:pig".to_owned(), std::sync::Arc::new(pig))])
+    }
+
+    fn load(snbt: &str) -> Mob {
+        let tag = horizon_world::nbt::parse_snbt(snbt).unwrap().0;
+        mob_from_nbt(&tag, &types(), 7, None).unwrap()
+    }
+
+    /// `LivingEntity.readAdditionalSaveData`: `lastHurtByMob` is the UUID,
+    /// `lastHurtByMobTimestamp = tickCount - ticks_since_last_hurt_by_mob`, and a
+    /// freshly loaded entity has `tickCount` 0, so 30 saved ticks make -30.
+    #[test]
+    fn a_saved_hurt_by_mob_is_read_back_as_a_reference_and_a_timestamp() {
+        let m = load(
+            r#"{id:"minecraft:pig",UUID:[I;5,0,0,1],Pos:[2.5d,200d,4.5d],Health:10f,last_hurt_by_mob:[I;5,0,0,2],ticks_since_last_hurt_by_mob:30}"#,
+        );
+        assert_eq!(m.age, 0);
+        assert_eq!(m.ai.last_hurt_by_ref, Some([5, 0, 0, 2]));
+        assert_eq!(m.ai.last_hurt_by_time, -30);
+        // Not resolved yet: `getLastHurtByMob` answers nothing.
+        assert_eq!(m.ai.last_hurt_by, None);
+    }
+
+    /// Missing keys: no reference, and `getIntOr("ticks_since...", 0)` stamps the
+    /// timestamp at `tickCount`.
+    #[test]
+    fn a_save_without_a_hurt_by_mob_has_none() {
+        let m = load(r#"{id:"minecraft:pig",UUID:[I;5,0,0,1],Pos:[2.5d,200d,4.5d],Health:10f}"#);
+        assert_eq!(m.ai.last_hurt_by_ref, None);
+        assert_eq!(m.ai.last_hurt_by_time, 0);
+        // A key that is not a UUID int array is no reference (the codec fails).
+        let m = load(
+            r#"{id:"minecraft:pig",UUID:[I;5,0,0,1],Pos:[2.5d,200d,4.5d],Health:10f,last_hurt_by_mob:"x"}"#,
+        );
+        assert_eq!(m.ai.last_hurt_by_ref, None);
+    }
+}
@@ -28,6 +28,8 @@ pub fn main_with(mods: crate::mod_api::Mods) {
    // then the Horizon parts still in this crate; none registers after this point.
    game::player_hooks::register();
    horizon_hooks::engine::seal();
+    // The text crates ship (`horizon_hooks::lang`), loaded with the game's own languages.
+    horizon_client::lang::install_crate_files(horizon_hooks::lang::engine::all());
    horizon_client::spans::startup::init(std::time::Instant::now());
    horizon_client::spans::trace::start_from_env();
    let args: Vec<String> = std::env::args().skip(1).collect();
@@ -230,6 +232,14 @@ pub fn main_with(mods: crate::mod_api::Mods) {
        living_jump: |entity, kind| {
            crate::mod_api::dispatch_living_jump(crate::mod_api::mods(), entity, kind);
        },
+        living_death_message: |entity, kind, message| {
+            crate::mod_api::dispatch_living_death_message(
+                crate::mod_api::mods(),
+                entity,
+                kind,
+                message,
+            );
+        },
        register_goals: |mob| {
            crate::mod_api::dispatch_register_goals(crate::mod_api::mods(), mob);
        },
@@ -497,7 +497,7 @@ use horizon_client::random_source;
 pub use advancements::AdvancementDisplay;
 use horizon_client::actions::Action as Mapping;
 use horizon_client::held::Source;
-use horizon_client::spans::startup;
+use horizon_client::spans::{startup, time as span};
 use horizon_client::{
    Result,
    assets::{Assets, RenderAssets},
@@ -758,7 +758,6 @@ enum GuestUse {
    /// an entity again from the view.
    Entity(Hand, InteractTarget),
 }
-
 /// The entity an interact packet names and where its client clicked it (the
 /// packet's location, measured from the entity's position): what
 /// `ServerGamePacketListenerImpl.handleInteract` takes from
@@ -1505,7 +1504,7 @@ impl LevelAccess for GameLevel<'_> {
        {
            return signal;
        }
-        machines::container_signal(self.world, self.behaviours, self.items, self.registry, pos)
+        machines::container_signal(self, pos)
    }
    fn item_frame_analog_output(&self, pos: BlockPos, facing: Direction) -> Option<i32> {
        let mut frames = self
@@ -2328,6 +2327,8 @@ struct Game<'a> {
    last_device_recovery: Option<Instant>,
    /// CPU geometry storage retained across frames, including empty/title frames.
    entity_vertices: Vec<Vertex>,
+    /// Falling models by state and selected-model address list; cleared on pack/atlas replacement.
+    falling_vertices: RefCell<HashMap<BlockStateId, Vec<(Vec<usize>, Vec<Vertex>)>>>,
    /// Horizon Extras' dynamic lights this frame (`dynamic_lights.rs`), and how brightly each
    /// item glows (built the first time the extra is on).
    dynamic_lights: Vec<[f32; 4]>,
@@ -3888,6 +3889,7 @@ impl Game<'_> {
            golem_chests.extend(self.chest_other_half(key));
        }
        let native_authoritative = self.native_authoritative();
+        let environment_type = self.dimension_type();
        let mut level = GameLevel {
            gateway_servers: &mut self.be_anims.gateway_servers,
            border: self.border.geometry(),
@@ -3910,11 +3912,7 @@ impl Game<'_> {
            events: &mut self.level_events,
            dimension,
            darken,
-            environment: match dimension {
-                LevelDimension::Overworld => self.res.environment(),
-                LevelDimension::Nether => self.res.nether_environment(),
-                LevelDimension::End => self.res.end_environment(),
-            },
+            environment: self.res.environment_of(&environment_type.id),
            raining: rain > 0.2,
            thundering: thunder > 0.9,
            player_box,
@@ -5033,8 +5031,8 @@ impl Game<'_> {
            self.loot_block_entity(pos, &facts.name)
        };
        if let Some(entity) = self.world.block_entities.get(&key).cloned() {
-            let name = self.world.block_names.get(&key).cloned();
-            self.pending.record(pos, &entity, &facts.name, name);
+            self.pending
+                .record_from(&self.world, pos, &entity, &facts.name);
        } else if let Some(tag) = spill::saved_entity(&self.world, pos) {
            self.pending.record_saved(pos, &tag);
        }
@@ -5544,7 +5542,7 @@ impl Game<'_> {
        // the activated item counts down.
        self.boss_overlay.tick_darken(running);
        self.tick_item_activation();
-        self.native_inventory_ticks();
+        span("mods_inventory_ticks", || self.native_inventory_ticks());
        if running {
            // `MinecraftServer.tickChildren`: `commandFunctions` runs before
            // any level ticks, so a tick function reads the game time and the
@@ -5552,7 +5550,7 @@ impl Game<'_> {
            // long before this point; the lazy scoreboard/storage read has to
            // be done by then too, or a load tag writes over what it restores.
            self.load_scoreboard();
-            self.tick_functions();
+            span("tick_functions", || self.tick_functions());
            self.world.game_time += 1;
            if self.ui.rules.bool("advance_weather") {
                self.world.weather.tick_timers(&mut self.world.random);
@@ -5566,7 +5564,7 @@ impl Game<'_> {
        }
        // ClientLevel.tick: the sky flash fades in a frozen level too.
        self.tick_weather_effects();
-        let _ = self.finish_player_autosaves(false);
+        let _ = span("player_autosaves", || self.finish_player_autosaves(false));
        // MinecraftServer.tickServer's countdown, then autoSave: three
        // hundred seconds of ticks at the rate the server runs at now.
        self.ticks_until_autosave -= 1;
@@ -5575,7 +5573,7 @@ impl Game<'_> {
            serving.set_saving(self.autosaving);
        }
        if self.autosaving {
-            self.save_game_with(false)?;
+            span("autosave", || self.save_game_with(false))?;
            self.ticks_until_autosave = self.next_autosave_interval();
            if let Some(serving) = &self.serving {
                serving.set_saving(false);
@@ -5584,27 +5582,27 @@ impl Game<'_> {
        if running {
            self.advance_clock();
            // `ServerLevel.tickTime`, once the clock has moved on.
-            self.run_scheduled_functions();
+            span("scheduled_functions", || self.run_scheduled_functions());
        }
        if self.use_delay > 0 {
            self.use_delay -= 1;
        }
        self.tick_totem();
        self.update_totem_ready();
-        self.tick_command_extras();
-        self.native_tick();
-        self.tell_native_now();
+        span("tick_command_extras", || self.tick_command_extras());
+        span("mods_tick", || self.native_tick());
+        span("mods_tick", || self.tell_native_now());
        self.tick_world(running)
    }
    /// What the tick runs after the local player's own update: effects, the
    /// world's entities and blocks, and the network hub.
    fn tick_world(&mut self, running: bool) -> Result<()> {
        // Entities added since the last tick join the level before it ticks.
-        self.native_joins_flush(false, 0);
-        self.share_spawn_conditions();
+        span("mods_joins_flush", || self.native_joins_flush(false, 0));
+        span("share_spawn_conditions", || self.share_spawn_conditions());
        horizon_client::mobs::sulfur_cube::set_tnt_explodes(self.ui.rules.bool("tnt_explodes"));
-        self.update_chunk_tickets();
-        self.score_destroyed_entities();
+        span("chunk_tickets", || self.update_chunk_tickets());
+        span("score_destroyed", || self.score_destroyed_entities());
        horizon_client::spans::time("tick_effects", || self.tick_effects(running));
        self.tick_sign_editor();
        // Player.tick's ItemCooldowns.tick for the window's player (a
@@ -5628,8 +5626,8 @@ impl Game<'_> {
            sent = horizon_client::spans::time("tick_blocks", || self.tick_blocks())?;
            // What the blocks spawned (a dispensed minecart, a lit TNT, a
            // placed boat) joins before the entities tick.
-            self.native_joins_flush(false, 0);
-            self.lan_mark_synced();
+            span("mods_joins_flush", || self.native_joins_flush(false, 0));
+            span("lan_mark_synced", || self.lan_mark_synced());
            // `EntityTickList.forEach`: what joined before the entity pass
            // (function summons, dropped or dispensed items) ticks in it;
            // what joins during it waits for the next tick
@@ -5639,7 +5637,7 @@ impl Game<'_> {
        }
        // ChunkMap still ticks while /tick freeze holds block/entity ticks.
        if !running {
-            self.save_chunks_eagerly();
+            span("save_chunks_eagerly", || self.save_chunks_eagerly());
        }
        self.begin_ordered_ticks();
        if running {
@@ -5653,8 +5651,8 @@ impl Game<'_> {
            // ServerLevel.tick: the arrivals of this server tick are in the level
            // (`addDuringTeleport`), and each vehicle handles its portal as its
            // own tick opens.
-            self.land_portal_arrivals();
-            self.handle_vehicle_portals();
+            span("portal_arrivals", || self.land_portal_arrivals());
+            span("vehicle_portals", || self.handle_vehicle_portals());
            self.ordered_before(ordered_tick::Batch::Boats)?;
            horizon_client::spans::time("tick_boats", || self.tick_boats());
            self.ordered_before(ordered_tick::Batch::Carts)?;
@@ -5684,11 +5682,11 @@ impl Game<'_> {
            self.ordered_before(ordered_tick::Batch::Items)?;
            horizon_client::spans::time("tick_items", || self.tick_items());
            if self.remote.is_none() {
-                self.hoppers_catch_items();
+                span("hoppers_catch_items", || self.hoppers_catch_items());
            }
            // Merged, burnt, despawned or picked up.
-            self.native_leaves_flush();
-            self.native_joins_flush(false, 0);
+            span("mods_leaves_flush", || self.native_leaves_flush());
+            span("mods_joins_flush", || self.native_joins_flush(false, 0));
            horizon_client::spans::time("touch_arrows", || self.touch_arrows());
        }
        horizon_client::spans::time("spawn_loaded_entities", || self.spawn_loaded_entities());
@@ -5698,22 +5696,22 @@ impl Game<'_> {
            self.ordered_before(ordered_tick::Batch::Mobs)?;
            horizon_client::spans::time("tick_mobs", || self.tick_mobs())?;
            // Dead, despawned or gone into a hive.
-            self.native_leaves_flush();
+            span("mods_leaves_flush", || self.native_leaves_flush());
            horizon_client::spans::time("recheck_golem_openers", || self.recheck_golem_openers());
-            self.tick_mod_container_viewers();
+            span("mod_viewers", || self.tick_mod_container_viewers());
            // Orbs, primed TNT and falling blocks still to tick, in join order.
            self.run_ordered_ticks(horizon_client::join_seq::JoinSeq::MAX, false)?;
            horizon_client::spans::time("tick_experience", || self.tick_experience());
            // Merged, despawned or picked up.
-            self.native_leaves_flush();
+            span("mods_leaves_flush", || self.native_leaves_flush());
            horizon_client::spans::time("entity_portals", || {
                self.find_entity_portals();
                self.resolve_arrivals();
            });
        }
        // The rest of the tick's spawns join, and what left is told of.
-        self.native_joins_flush(false, 0);
-        self.native_leaves_flush();
+        span("mods_joins_flush", || self.native_joins_flush(false, 0));
+        span("mods_leaves_flush", || self.native_leaves_flush());
        // ServerLevel.tick broadcasts the changed blocks after the scheduled and
        // random ticks (`tick_blocks`), before the block events, the entities
        // and the block entities: what those change goes out with the next
@@ -5728,23 +5726,23 @@ impl Game<'_> {
        if let Some(log) = self.world.block_log.as_mut() {
            log.extend(held);
        }
-        self.tick_friends();
+        span("tick_friends", || self.tick_friends());
        horizon_client::spans::time("tick_hand", || self.tick_hand());
        horizon_client::spans::time("tick_sleep", || self.tick_sleep());
-        self.announce_sleep_status();
-        self.free_left_beds();
+        span("sleep_status", || self.announce_sleep_status());
+        span("sleep_status", || self.free_left_beds());
        if running {
            horizon_client::spans::time("tick_end", || self.tick_end())?;
            horizon_client::spans::time("end_gateways", || {
                self.find_end_gateway_portals();
                self.resolve_end_gateway_arrivals()
            })?;
-            self.keep_gateway_destinations();
+            span("end_gateways", || self.keep_gateway_destinations());
        }
        if running {
            // Primed TNT and falling blocks that joined since the spawn packets.
            self.run_ordered_ticks(horizon_client::join_seq::JoinSeq::MAX, true)?;
-            self.apply_late_wind_pushes();
+            span("late_wind_pushes", || self.apply_late_wind_pushes());
        }
        // Everything that has joined has had its spawn packet and, if it joined
        // before the entity passes (TNT a piston or repeater primed), its first
@@ -5763,21 +5761,21 @@ impl Game<'_> {
                self.tick_block_entity_anims()
            });
            // A conduit's hurt teleports an enderman now (`Enderman.hurtServer`).
-            self.settle_hurt_teleports()?;
+            span("settle_hurt_teleports", || self.settle_hurt_teleports())?;
            horizon_client::spans::time("tick_particles", || self.tick_particles());
-            self.tick_client_ambient();
+            span("tick_client_ambient", || self.tick_client_ambient());
        }
        // ServerLevel.tick's `entityManager.tick()`, frozen or not, after every
        // block entity ticker (the bells, conduits and gateways above too): the
        // chunks loaded before this pass have their entities loaded from the next.
        self.world.entities_pending.clear();
-        self.tick_frame_visuals(running);
+        span("tick_frame_visuals", || self.tick_frame_visuals(running));
        if running {
            // MinecraftServer.tickServer: GameTestTicker.SINGLETON.tick().
-            self.tick_game_tests();
+            span("tick_game_tests", || self.tick_game_tests());
        }
        // ServerBossEvent broadcasts, after this level's entities have ticked.
-        self.publish_boss_bars();
+        span("publish_boss_bars", || self.publish_boss_bars());
        // Minecraft.handleKeybinds: held use repeats only while no item is in
        // use (a raised shield or a drawn bow places and uses nothing).
        if self.right
@@ -6733,19 +6731,14 @@ impl Game<'_> {
        // Entity shadows (EntityRenderer.extractShadow); a native pack's sun shadows replace them.
        self.mark_translucent_entity(out.len(), "minecraft:entity_shadow");
        let pack_shadows = self.renderer.as_ref().is_some_and(|r| {
-            r.pack_entity_shadows() || (self.dim == Dim::Overworld && r.native_shadow())
+            r.pack_entity_shadows() || (self.overworld_skybox() && r.native_shadow())
        });
        let shadows = self.settings.entity_shadows && self.pack.polytone_colors.entity_shadows();
        let shadow_sprite = (shadows && !pack_shadows)
            .then(|| self.gui.atlas.sprites.get("misc/shadow").copied())
            .flatten();
        if let Some(sprite) = shadow_sprite {
-            // DimensionType.ambientLight: the_nether 0.1, the_end 0.25.
-            let ambient = match self.dim {
-                Dim::Nether => 0.1,
-                Dim::End => 0.25,
-                Dim::Overworld => 0.0,
-            };
+            let ambient = self.dimension_type().ambient_light;
            let darken = self.sky_darken();
            let a = alpha;
            let lerp = |p: Vec3, q: Vec3| {
@@ -6908,7 +6901,7 @@ impl Game<'_> {
                emissive: &self.gui.atlas.emissive,
                translucent_sprites: &self.gui.atlas.translucent,
                atlas_revision: self.gui.atlas.revision,
-                nether: self.dim == Dim::Nether,
+                nether: self.nether_lighting(),
                lid: &lid,
                sign: &|p| match self.world.block_entities.get(&(p[0], p[1], p[2])) {
                    Some(BlockEntity::Sign(sign)) => Some(sign),
@@ -7158,14 +7151,7 @@ impl Game<'_> {
            let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
            let start = out.len();
            self.mark_motion(start, Self::MOTION_OBJECT | u64::from(f.id));
-            self.block_model_vertices(
-                f.state,
-                horizon_core::random::position_seed(f.start_pos),
-                glam::Mat4::from_translation(o),
-                packed,
-                false,
-                &mut out,
-            );
+            self.falling_model_vertices(f.state, f.start_pos, o, packed, &mut out);
            let tint = horizon_client::mobs::render::abgr(tint);
            for vertex in &mut out[start..] {
                vertex.color = horizon_client::hud_layout::multiply(vertex.color, tint);
@@ -7633,8 +7619,10 @@ impl Game<'_> {
            r.clear_sections(self.world.layout());
        }
        self.apply_settings();
-        self.streaming.sky_light = dim != Dim::Nether;
-        self.streaming.nether_shading = dim == Dim::Nether;
+        let facts = self.dimension_type_of(dim);
+        self.streaming.sky_light = facts.height.has_skylight;
+        self.streaming.nether_shading =
+            facts.cardinal_light == horizon_world::dimension_type::CardinalLight::Nether;
        self.load_world_state();
        // The level the world opens in, before any of its chunks.
        self.native_level_opened(dim);
@@ -8211,10 +8199,7 @@ impl Game<'_> {
            }
            if let Some(kind) = mob {
                if let Some(id) = self.spawn_mob_at(kind, (target[0], target[1], target[2]), true) {
-                    if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
-                        horizon_client::entity_nbt::apply_item_components(m, stack);
-                    }
-                    self.mob_placed(id)?;
+                    self.mob_placed(id, stack)?;
                }
                self.post_block_game_event(
                    "minecraft:entity_place",
@@ -8490,6 +8475,7 @@ impl Game<'_> {
            None,
            self.settings.horizon.api,
            self.settings.horizon.translucent_batching,
+            self.settings.vsync,
            &self.settings.horizon,
            shader_packs::picked_pack_shape(&self.settings),
            display,
@@ -9325,10 +9311,10 @@ impl Game<'_> {
                game_time: self.world.game_time,
                day_time: self.view_day_time(),
                render_distance: self.streaming.radius,
-                sky_type: match self.dim {
-                    Dim::Overworld => 1,
-                    Dim::End => 2,
-                    Dim::Nether => 0,
+                sky_type: match self.dimension_type().skybox {
+                    horizon_world::dimension_type::Skybox::Overworld => 1,
+                    horizon_world::dimension_type::Skybox::End => 2,
+                    horizon_world::dimension_type::Skybox::None => 0,
                },
                dimension: match self.dim {
                    Dim::Overworld => "minecraft:overworld",
@@ -9670,13 +9656,13 @@ impl Game<'_> {
        pr.lap("pr_dragon_bolts");
        let (celestial, stars) = if title {
            (Vec::new(), None)
-        } else if self.dim == Dim::Overworld
+        } else if self.overworld_skybox()
            && self.potions.effects.get("darkness").is_none()
            && self.potions.effects.get("blindness").is_none()
        {
            // Camera.doesMobEffectBlockSky: no sun, moon or stars.
            self.celestial_geometry(&sky, rain)
-        } else if self.dim == Dim::End && self.settings.horizon.sky {
+        } else if self.end_skybox() && self.settings.horizon.sky {
            (self.end_flash_geometry(), None)
        } else {
            (Vec::new(), None)
@@ -9750,7 +9736,7 @@ impl Game<'_> {
        let frame = Frame {
            weather: &weather,
            weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32),
-            nether_lighting: self.dim == Dim::Nether,
+            nether_lighting: self.nether_lighting(),
            camera,
            yaw,
            pitch,
@@ -9790,8 +9776,8 @@ impl Game<'_> {
                    || self.potions.effects.get("darkness").is_some(),
                self.boss_overlay.should_create_world_fog(),
            ),
-            skybox: self.dim == Dim::Overworld && self.settings.horizon.sky,
-            end_sky: self.dim == Dim::End && self.settings.horizon.sky,
+            skybox: self.overworld_skybox() && self.settings.horizon.sky,
+            end_sky: self.end_skybox() && self.settings.horizon.sky,
            end_sky_sprite: self
                .gui
                .atlas
@@ -9815,7 +9801,7 @@ impl Game<'_> {
            glint_alpha: self.glint_frame.alpha,
            glint_ticks: self.glint_frame.scroll_ticks(),
            clouds: (!title
-                && self.dim == Dim::Overworld
+                && self.overworld_skybox()
                && horizon_client::clouds::visible(&self.settings.clouds, sky.cloud_color[3]))
            .then(|| self.gui.atlas.sprites.get("horizon/white"))
            .flatten()
@@ -9863,12 +9849,10 @@ impl Game<'_> {
            border,
            game_time: self.world.game_time as f32,
            shader_game_time: ((self.world.game_time % 24000) as f32 + alpha as f32) / 24000.0,
-            crumbling_sprite: self
-                .gui
-                .atlas
-                .sprites
-                .get("block/destroy_stage_0")
-                .map_or([0.0; 4], |r| [r.u0, r.v0, r.u1 - r.u0, r.v1 - r.v0]),
+            crumbling_sprite: frame_geometry::crumbling_sprite(
+                &self.gui.atlas.sprites,
+                self.settings.improved_transparency,
+            ),
            end_portal_sprites: ["environment/end_sky", "entity/end_portal/end_portal"].map(|n| {
                self.gui
                    .atlas
@@ -9972,20 +9956,10 @@ impl Game<'_> {
            self.drag_button = None;
        }
        if let WindowEvent::ModifiersChanged(m) = &event {
-            self.modifiers = m.state();
-            horizon_client_input::modifiers::reconcile(
-                self.modifiers,
-                &mut self.physical_keys,
-                &self.settings.keys,
-                &mut self.toggles,
-                [self.settings.toggle_crouch, self.settings.toggle_sprint],
-                [
-                    self.pad.holds_action("key.sneak"),
-                    self.pad.holds_action("key.sprint"),
-                ],
-            );
-            self.sync_toggle(SNEAK);
-            self.sync_toggle(SPRINT);
+            self.update_modifiers(m.state());
+        }
+        if let WindowEvent::Focused(false) = &event {
+            self.update_modifiers(winit::keyboard::ModifiersState::empty());
        }
        // `PackSelectionScreen.onFilesDrop` on the Create New World screen.
        if let WindowEvent::DroppedFile(path) = &event
@@ -10391,6 +10365,8 @@ impl Game<'_> {
                        let held = self.captured;
                        if self.control.is_none() {
                            self.keys.clear();
+                            self.modifiers = winit::keyboard::ModifiersState::empty();
+                            self.debug_keys.reset();
                            // Latched sneak/sprint live in `toggles`, not in the
                            // physical keys: put them back so a short alt-tab
                            // (no pause screen) does not drop them. Only a mapping
@@ -10398,21 +10374,18 @@ impl Game<'_> {
                            // no state to keep, and an unfocused window never gets
                            // its key release, so leaving it down would keep the
                            // player sneaking or sprinting until the key is tapped.
-                            for (slot, needs_toggle) in [
+                            let toggles = [
                                self.settings.toggle_crouch,
                                self.settings.toggle_sprint,
                                self.settings.toggle_attack,
                                self.settings.toggle_use,
-                            ]
-                            .into_iter()
-                            .enumerate()
-                            {
+                            ];
+                            for (slot, needs_toggle) in toggles.into_iter().enumerate() {
                                self.toggles.0[slot].set_down(false, needs_toggle);
                            }
                            self.sync_toggle(0);
                            self.sync_toggle(1);
-                            self.left = false;
-                            self.right = false;
+                            (self.left, self.right) = (false, false);
                            self.capture(false);
                        }
                        self.regrab_on_refocus = held;
@@ -11685,6 +11658,7 @@ impl<'a> Game<'a> {
            renderer: None,
            last_device_recovery: None,
            entity_vertices: Vec::new(),
+            falling_vertices: Default::default(),
            dynamic_lights: Vec::new(),
            luminance: Default::default(),
            see_through_vertices: Vec::new(),
@@ -12480,7 +12454,7 @@ pub fn run_with() -> Result<()> {
    horizon_world::datafix::set_resources(
        &std::path::absolute(&vanilla_root).unwrap_or_else(|_| vanilla_root.clone()),
    );
-    if let Some(error) = missing_resources(&vanilla_root) {
+    if let Some(error) = missing_resources(&vanilla_root, horizon_hooks::engine::get_the_game()) {
        // The game build started by hand (the release's zip), not by the
        // launcher: a window says where to get it. Scripts and servers get
        // the error.
@@ -230,15 +230,10 @@ impl adv::World for View<'_, '_> {
            _ => None,
        }
    }
+    /// `Level.canSeeSky`: sky light 15 at the position, whatever stands
+    /// above it, as `MobWorld` reads it for the spawn rules.
    fn can_see_sky(&self, p: [i32; 3]) -> bool {
-        (p[1] + 1..p[1] + 200).all(|y| {
-            !self
-                .0
-                .res
-                .facts()
-                .get(self.0.world.block(p[0], y, p[2]))
-                .full_collision
-        })
+        self.0.mob_world_base(&[]).can_see_sky(p[0], p[1], p[2])
    }
    fn light(&self, p: [i32; 3]) -> i32 {
        let l = self.0.world.light(p[0], p[1], p[2]);
@@ -4,6 +4,7 @@
 //! same on vanilla 26.3).
 use super::*;
 use horizon_client::chunk::Chunk;
+use horizon_client::mobs::allay;
 use horizon_core::position::ChunkPos;
 use horizon_world::nbt::Tag;
 use std::sync::Arc;
@@ -84,7 +85,7 @@ fn an_allay_keeps_its_item_pickup_cooldown_memory() {
    let mut game = game();
    let i = index(&mut game);
    // The supplied memory is loaded into the pickup cooldown and saved back.
-    assert_eq!(game.mobs[i].extra.ints[3], 30, "loaded");
+    assert_eq!(allay::pickup_cooldown(&game.mobs[i]), Some(30), "loaded");
    assert_eq!(
        saved(&mut game, i),
        Some(Tag::compound([("value", Tag::Int(30))])),
@@ -100,6 +101,53 @@ fn an_allay_keeps_its_item_pickup_cooldown_memory() {
        Some(Tag::compound([("value", Tag::Int(20))])),
        "after 10 ticks"
    );
+    // CountDownCooldownTicks: the memory reaches 0 and is erased a tick later
+    // (`stop`).
+    step(&mut game, 20);
+    assert_eq!(
+        saved(&mut game, i),
+        Some(Tag::compound([("value", Tag::Int(0))])),
+        "at 0"
+    );
+    step(&mut game, 1);
+    assert_eq!(saved(&mut game, i), None, "erased the tick after");
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn pickup_cooldown_saves_the_full_integer_value() {
+    let mut game = game();
+    let i = index(&mut game);
+    assert!(game.run_command(&format!(
+        "item replace entity {SUPPLIED} weapon.mainhand with minecraft:diamond 1"
+    )));
+    for ticks in [i32::MIN, -1, 0, 1, i32::MAX] {
+        allay::set_pickup_cooldown(&mut game.mobs[i], Some(ticks));
+        assert!(
+            !game.mobs[i].can_pick_up_loot(),
+            "memory present at {ticks}"
+        );
+        assert_eq!(
+            saved(&mut game, i),
+            Some(Tag::compound([("value", Tag::Int(ticks))])),
+            "saved {ticks}"
+        );
+        let tag = game.mob_tree_nbt(i);
+        let loaded = horizon_client::entity_nbt::mob_from_nbt(
+            &tag,
+            game.res.mob_types(),
+            game.mobs[i].id,
+            None,
+        )
+        .unwrap();
+        assert_eq!(
+            allay::pickup_cooldown(&loaded),
+            Some(ticks),
+            "loaded {ticks}"
+        );
+    }
+    allay::set_pickup_cooldown(&mut game.mobs[i], None);
+    assert!(game.mobs[i].can_pick_up_loot(), "memory erased");
 }

 // Added controls (after the frozen baseline above).
@@ -135,10 +183,10 @@ fn the_saved_pickup_cooldown_follows_the_model() {
    assert_eq!(saved(&mut game, plain), None, "no raw memory");
    // A loaded memory the model has ended: no key (the raw copy is not echoed).
    let supplied = index(&mut game);
-    game.mobs[supplied].extra.ints[3] = 0;
+    allay::set_pickup_cooldown(&mut game.mobs[supplied], None);
    assert_eq!(saved(&mut game, supplied), None, "stale raw memory");
    // A model mutation, as a throw does (`allays.rs`): saved with its value.
-    game.mobs[plain].extra.ints[3] = 60;
+    allay::set_pickup_cooldown(&mut game.mobs[plain], Some(60));
    let tag = saved(&mut game, plain);
    assert_eq!(
        tag,
@@ -149,7 +197,11 @@ fn the_saved_pickup_cooldown_follows_the_model() {
    let whole = game.mob_tree_nbt(plain);
    let reloaded =
        horizon_client::entity_nbt::mob_from_nbt(&whole, game.res.mob_types(), 99, None).unwrap();
-    assert_eq!(reloaded.extra.ints[3], 60, "load after save");
+    assert_eq!(
+        allay::pickup_cooldown(&reloaded),
+        Some(60),
+        "load after save"
+    );
    // NoAI: no Brain tick, the value stays.
    let frozen = at(&mut game, 2);
    step(&mut game, 5);
@@ -288,7 +288,7 @@ impl Game<'_> {
        });
        let m = &mut self.mobs[i];
        m.extra.allay.as_mut().unwrap().take(1);
-        m.extra.ints[3] = 60;
+        allay::set_pickup_cooldown(m, Some(60));
        // ItemEntity.setDefaultPickUpDelay.
        self.spawn_item(stack, from, v, 10);
        // BehaviorUtils.throwItem: ItemEntity.setThrower(the allay).
@@ -1954,8 +1954,7 @@ impl Game<'_> {
        mut skin: Option<&mut horizon_client::mobs::skin::Skin>,
        out: &mut Vec<Vertex>,
    ) {
-        let lights =
-            horizon_client::block_entity_render::diffuse_lights(self.dim == super::Dim::Nether);
+        let lights = horizon_client::block_entity_render::diffuse_lights(self.nether_lighting());
        let mut submit = |state: &horizon_client::item_render::ItemRenderState,
                          pose: glam::Mat4,
                          out: &mut Vec<Vertex>| {
@@ -2028,7 +2027,7 @@ impl Game<'_> {
                out,
                light,
                lights: Some(horizon_client::block_entity_render::diffuse_lights(
-                    self.dim == super::Dim::Nether,
+                    self.nether_lighting(),
                )),
                glint: self.glint(),
                tier: 0,
@@ -801,8 +801,17 @@ impl Game<'_> {
        let server = self.be_anims.gateway_servers.entry(key).or_insert(initial);
        let triggered = server.portal_tick();
        let age = server.age;
-        if let Some(BlockEntity::EndGateway(g)) = self.world.block_entities.get_mut(&pos) {
+        let mut aged = false;
+        if let Some(BlockEntity::EndGateway(g)) = self.world.block_entities.get_mut(&pos)
+            && g.age != age
+        {
            g.age = age;
+            aged = true;
+        }
+        if aged {
+            // `TheEndGatewayBlockEntity.portalTick` ends with `setChanged`: the
+            // age the beam and the chunk save read moved.
+            self.world.modified.insert((pos.0 >> 4, pos.2 >> 4));
        }
        if triggered {
            self.gateway_cooldown_event(key);
@@ -1108,3 +1117,41 @@ mod bell_ownership_tests {
        assert!(anims.bells.is_empty());
    }
 }
+
+#[cfg(test)]
+mod gateway_age_tests {
+    use super::*;
+    use crate::game::native_machines::tests::server_game;
+
+    /// `TheEndGatewayBlockEntity.portalTick`: an age that moved is a change
+    /// to save.
+    #[test]
+    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+    fn a_gateway_that_ages_marks_the_chunk() {
+        let mut game = server_game();
+        let state = game
+            .pack
+            .assets
+            .registry
+            .default_state("minecraft:end_gateway")
+            .unwrap();
+        let pos = (2, 4, 3);
+        game.world.set(pos.0, pos.1, pos.2, state).unwrap();
+        game.world.block_entities.insert(
+            pos,
+            BlockEntity::EndGateway(horizon_client::containers::EndGateway::default()),
+        );
+        game.world.modified.clear();
+
+        game.tick_end_gateway(pos);
+
+        let Some(BlockEntity::EndGateway(g)) = game.world.block_entities.get(&pos) else {
+            panic!("no gateway");
+        };
+        assert_eq!(g.age, 1, "the tick aged the gateway");
+        assert!(
+            game.world.modified.contains(&(0, 0)),
+            "the aged gateway left the chunk unmarked"
+        );
+    }
+}