Merge remote-tracking branch 'origin/main' into layers/packs-entity

# Conflicts: # crates/horizon-client/src/client_lib.rs
Merge pull request #14282 from horizon-rust/split/cosmetics-fx-api
2026-11-09 17:19:15 -10:00 · 2026-11-09 23:38:56 +01:00 · 2026-11-09 23:32:09 +01:00 · 2026-11-09 23:23:44 +01:00 · 2026-11-09 23:19:07 +01:00 · 2026-11-09 23:19:02 +01:00
489 changed files with 23664 additions and 17508 deletions
@@ -13,4 +13,3 @@
 87152661 rdbtCVS         # added by Ludovic, 2026-10-27
 84875247 Online5277      # added by Ludovic, 2026-10-27 (his top three by merged pull requests)
 86072227 levzzz5154      # added by Ludovic, 2026-10-28 (Horizon Team; author of horizon-mixins)
-169198624 itarqos5        # added by Ludovic, 2026-11-08 (Discord Literal; Horizon Team)
@@ -75,6 +75,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) |
 | `horizon-optifine` | OptiFine-format pack files below every feature that reads them: `.properties`, the name/range/block matchers, paths and `optifine/` folders, and custom entity models (`cem/`: `.jem`/`.jpm` parsing and baking) |
 | `horizon-polytone` | Polytone-format pack files (`assets/*/polytone/`), read clean-room from the public wiki: targets, biome and dimension modifiers and their environment attribute layers (#11486) |
+| `horizon-pack-options` | A resource pack's own options as the game lists and keeps them (entries, controls, values, presets), whatever pack format declares them; engine, no dependencies |
 | `horizon-shader-api` | Horizon's own WGSL shader packs ([docs/api/shaders.md](docs/api/shaders.md)): `horizon-shaders.toml`, the `.hshader` package; shared by the game, the launcher and the registry |
 | `horizon-shaders` | Shader packs (the `shaders/` folder format), rebuilt clean-room from a written spec of the format; no wgpu |
 | `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website |
@@ -186,7 +187,7 @@ state stays separate from the library tests. This compiles gameplay twice for ex
 | Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `mobs/cem.rs` + `mobs/cem_anim.rs` (OptiFine/EMF entity models and their animations); `horizon-client-core/src/lang.rs`; crates `horizon-assets`, `horizon-optifine`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
 | Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
-| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs` + `extras/` (each extra's glue: `mouse_tweaks.rs`, `sorting.rs`, `pvp.rs`, `reconnect.rs`), `options.rs` |
+| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |

 ## How `Game` is organised

@@ -13,6 +13,14 @@ else (videos, Discord and other community material) lives elsewhere.
 suggest something. A pull request for a roadmap item carries its `roadmap:<id>` label; ideas go to the suggestion
 queue (the hub, or `/suggest` on Discord) rather than to issues, which are for bugs.

+**Mod-related pull requests go to [arismoko/horizon](https://github.com/arismoko/horizon)**, the fork that carries the
+mod API and reviews and merges that work. That covers the mod API, native hooks and events for mods, native mods,
+content mods (`.hmod`), mixins, wasm mods, `cargo horizon-mod`, `horizon-mods`, mod builds and the registry, and
+their docs ([mods](docs/mods.md), [native mods](docs/native-mods.md)). Open the pull request there from your usual
+branch. Mod-related pull requests opened here are closed with a pointer to it. Engine extension points that Horizon's
+own crates register (the [layer split](docs/layers.md)), resource and shader pack formats, and gameplay fixes stay
+here.
+
 ## Build it

 - **Prerequisites:** Rust (stable), Python 3.10+, JDK 25, and on Linux the ALSA and udev headers
@@ -190,3 +198,5 @@ new pushes, we add it again.

 [Discord](https://discord.gg/playhorizon) for questions and ideas, [issues](https://github.com/horizon-rust/horizon/issues)
 for bugs. To take something on, `/claim` its issue ([above](#claim-before-you-start)).
+
+How Horizon is run, and how people join the Team or lead a group: [GOVERNANCE.md](GOVERNANCE.md).
@@ -1418,6 +1418,7 @@ dependencies = [
 name = "horizon-chat-filter"
 version = "0.1.0"
 dependencies = [
+ "horizon-server-files",
 "serde",
 "serde_json",
 "toml",
@@ -1528,7 +1529,6 @@ dependencies = [
 "horizon-client-render",
 "horizon-command",
 "horizon-core",
- "horizon-friends",
 "horizon-hdr",
 "horizon-hooks",
 "horizon-items",
@@ -1590,9 +1590,9 @@ dependencies = [
 "horizon-items",
 "horizon-narrator",
 "horizon-optifine",
+ "horizon-pack-options",
 "horizon-polytone",
 "horizon-protocol",
- "horizon-render-pipeline",
 "horizon-shader-api",
 "horizon-shaders",
 "horizon-system",
@@ -1651,6 +1651,15 @@ dependencies = [
 "ureq",
 ]

+[[package]]
+name = "horizon-discord"
+version = "0.1.0"
+dependencies = [
+ "horizon-platform",
+ "log",
+ "serde_json",
+]
+
 [[package]]
 name = "horizon-dualsense"
 version = "0.1.0"
@@ -1668,6 +1677,7 @@ dependencies = [
 "getrandom 0.3.4",
 "hkdf",
 "horizon-addresses",
+ "horizon-platform",
 "if-addrs",
 "serde",
 "serde_json",
@@ -1793,13 +1803,25 @@ dependencies = [
 name = "horizon-official"
 version = "0.1.0"
 dependencies = [
+ "horizon-discord",
+ "horizon-friends",
 "horizon-game",
 "horizon-heartbeat",
+ "horizon-official-servers",
 "horizon-platform",
 "log",
 "winresource",
 ]

+[[package]]
+name = "horizon-official-servers"
+version = "0.1.0"
+dependencies = [
+ "horizon-addresses",
+ "horizon-platform",
+ "log",
+]
+
 [[package]]
 name = "horizon-optifine"
 version = "0.1.0"
@@ -1810,6 +1832,10 @@ dependencies = [
 "regex",
 ]

+[[package]]
+name = "horizon-pack-options"
+version = "0.1.0"
+
 [[package]]
 name = "horizon-platform"
 version = "0.1.0"
@@ -1827,6 +1853,7 @@ dependencies = [
 name = "horizon-polytone"
 version = "0.1.0"
 dependencies = [
+ "horizon-pack-options",
 "log",
 "regex",
 "serde_json",
@@ -1891,10 +1918,6 @@ dependencies = [
 "ring",
 ]

-[[package]]
-name = "horizon-render-pipeline"
-version = "0.1.0"
-
 [[package]]
 name = "horizon-server"
 version = "0.1.0"
@@ -1957,7 +1980,6 @@ version = "0.1.0"
 dependencies = [
 "half",
 "horizon-core",
- "horizon-render-pipeline",
 "naga",
 "png",
 "zip",
@@ -34,6 +34,8 @@ members = [
    "crates/horizon-game",
    "crates/horizon-official",
    "crates/horizon-heartbeat",
+    "crates/horizon-discord",
+    "crates/horizon-official-servers",
    "crates/horizon-bench",
    "crates/horizon-friends",
    "crates/horizon-relay",
@@ -43,9 +45,9 @@ members = [
    "crates/cargo-horizon-mod",
    "crates/horizon-port-pack",
    "crates/horizon-shaders",
-    "crates/horizon-render-pipeline",
    "crates/horizon-optifine",
    "crates/horizon-polytone",
+    "crates/horizon-pack-options",
    "crates/horizon-shader-api",
    "crates/horizon-release-sign",
    "crates/horizon-mod-deps",
@@ -0,0 +1,483 @@
+# Horizon governance
+
+> Adopted 2026-11-09 by the founder as his last decision as head of the project. It takes effect when he
+> announces that he is stepping down. From then on only the council changes it, by a 2/3 poll (section 15).
+
+Horizon has no boss. A **council of equals** decides by polls. **Theme groups** do the work in their areas, each
+with a **lead**. The **Horizon Team** reviews and merges code. **Moderators** keep the Discord server and the
+official server safe. Every role of trust is earned with work the project can measure, and it ends when that work
+stops.
+
+## Contents
+
+1. [Principles](#1-principles)
+2. [The levels at a glance](#2-the-levels-at-a-glance)
+3. [Each level in detail](#3-each-level-in-detail)
+4. [The council and its polls](#4-the-council-and-its-polls)
+5. [The selection filter](#5-the-selection-filter)
+6. [Theme groups](#6-theme-groups)
+7. [Moderation and appeals](#7-moderation-and-appeals)
+8. [Conflicts and hard cases](#8-conflicts-and-hard-cases)
+9. [The age rule (18+)](#9-the-age-rule-18)
+10. [The agents](#10-the-agents)
+11. [Accounts and the handover path](#11-accounts-and-the-handover-path)
+12. [Money](#12-money)
+13. [Transparency](#13-transparency)
+14. [Rules that are never voted on](#14-rules-that-are-never-voted-on)
+15. [Changing this document](#15-changing-this-document)
+
+## 1. Principles
+
+- **Equals.** Every council member has one vote. Nobody, the founder included, stands above the others.
+- **The founder.** Ludovic keeps the title of **Founder**: his role stays at the top of the member list and he is
+  credited as Horizon's founder everywhere. The title is symbolic. It carries no extra vote or power: on the council
+  he counts exactly like every other member.
+- **Evidence, not popularity.** You get a role by doing the work first. Kira measures that work: merged pull
+  requests, reviews, triage, support answers and days active. A vote then confirms it.
+- **Small, clear powers.** Each role can do a short, written list of things. Anything else goes to the council.
+- **Roles are on loan.** Every role has a 30-day probation and an inactivity rule. Stepping down for inactivity is
+  not a sanction, and you can come back.
+- **Public by default.** Polls, results and rules are public. Only matters about a person stay private, and even then
+  the result is published.
+- **18+ for roles of trust** (section 9).
+- **Mojang's and Microsoft's rules come first.** They are never put to a vote (section 14).
+
+## 2. The levels at a glance
+
+From the most open level to the most trusted. A person can hold several levels at once: a group lead can also be on
+the Horizon Team, for example.
+
+| Level | What it can do | How you get in | How you leave | 18+ |
+| --- | --- | --- | --- | --- |
+| **Member** | Play, chat, report bugs, suggest ideas, open issues and pull requests, pick group roles | Join the Discord server or the GitHub repo | Leave, or get banned | No |
+| **Contributor** (⛏️ Iron, 🥇 Gold, 💎 Diamond, 🟪 Netherite ranks) | Write in #contributors; `/claim` issues; nominate people for group lead (if active in that group) | One merged pull request in a public horizon-rust repo, linked with `/link-github` and `/verify-github`. Ranks come from merged pull requests: 10, 40, 100 and 200 | Contributor status and ranks stay | No |
+| **Group member** | Read and write in the group's channel; get the group's pings; take part in the group's advisory poll on its lead | Pick the group's role in Channels & Roles, or with `/groups` | Remove the role | No |
+| **🤝 Support** | Answer and close posts in #horizon-support | `/apply`; vote of the mods and the Team (as today) | Resign, 30 days inactive, or removed by the Chief of Mods or the council | No |
+| **🛡️ Moderator** | Time out, delete messages, manage threads, quarantine. No bans | `/apply`, then the selection filter; mods' vote; the council may object within 24 h | Resign, 30 days inactive, suspended by the Chief of Mods, removed by a council poll (simple majority) | **Yes** |
+| **🛡️ Chief of Mods** | A moderator's powers, plus bans; leads the mods; suspends a mod at once pending the council | Council poll (simple majority), from the mods with at least 30 days | Resign, 30 days inactive, council poll (simple majority) | **Yes** |
+| **🧭 Group lead** | Decides inside the group's topic (section 6); manages the group's channel; triage on the group's GitHub issues | Nomination, the filter, a 24 h public discussion with an advisory group poll, then a council poll (simple majority); 30 days probation | Resign, 30 days inactive (automatic), council poll (simple majority); confirmed again every 6 months | **Yes** |
+| **🌌 Horizon Team** | Review and merge pull requests (GitHub `horizon-team`, write access); `/nightly` and triage commands (trusted reviewers); #horizon-team | Nomination, the filter, a 24 h public discussion, then a council poll (2/3); 30 days probation | Resign, 60 days without a merge or review (automatic), council poll (2/3, without the person) | **Yes** |
+| **🏛️ Council** | Decides everything else by poll (section 4); bans; emergency actions by any 2 members | Nominated by a council member, the filter, a 24 h public discussion, then a council poll (2/3); 30 days probation | Resign, inactivity (section 5.5), council poll (2/3, without the person) | **Yes** |
+
+**The account holder** isn't a level. The founder (Ludovic) still holds the project's accounts (GitHub organisation
+owner, Discord server owner, the Microsoft app approved by Mojang, the domains, Railway, money). He carries out the
+council's decisions on them and hands them over step by step (section 11). As a council member he has one vote,
+like everyone else.
+
+## 3. Each level in detail
+
+### Member
+
+Anyone in the Discord server or on GitHub. Members follow the server rules and Horizon's
+[contributing guide](CONTRIBUTING.md). They can propose anything: an idea in #horizon-ideas, a bug in #horizon-bugs,
+an issue or a pull request on GitHub, or a request for a council poll (any council member can pick it up).
+
+### Contributor
+
+- **Discord:** the 🛠️ Contributor role writes in #contributors and in the threads of #polls-and-decisions. A rank
+  role (⛏️ Iron at 10 merged pull requests, 🥇 Gold at 40, 💎 Diamond at 100, 🟪 Netherite at 200, counted over every
+  public horizon-rust repo) shows how much has been merged. Ranks only go up.
+- **GitHub:** no repository role. Anyone can `/claim` and `/unclaim` their own issues.
+- **Alone:** their own work.
+
+### Group member
+
+Each theme group (section 6) has a role that anyone can pick and drop. It opens the group's channel and receives the
+group's pings. Picking a role grants no power. A group member counts as **active in the group** when Kira has seen at
+least one counted action in the group's area (section 5.1) in the last 60 days. Only active group members can
+nominate a lead or vote in the group's advisory poll.
+
+### 🤝 Support
+
+Unchanged: Support members help players in #horizon-support. They answer every post there and mark posts solved.
+The role carries no permission, so it has no age rule. They join through `/apply`, and the mods and the Team vote.
+
+### 🛡️ Moderators and the Chief of Mods
+
+- **Discord:** time out members, delete messages, manage threads and nicknames, read the audit log, quarantine
+  through Kira, and see the staff channels. **Moderators don't ban.** Bans are done by council members and the Chief of
+  Mods. Kira's automatic actions (the honeypot, clear scams, illegal images) stay as they are.
+- **Official server:** server operators (ops) are moderators in game. They need the 18+ rule and are confirmed the
+  same way (section 6, Server and SMP).
+- **Alone:** a timeout, a deleted message, a quarantine, with a reason in the mod case.
+- **The Chief of Mods** is the first contact for moderation questions. They organise the mods, can ban, and can take a
+  moderator's role away at once when there is a problem. The council confirms or reverses that within 72 hours.
+
+### 🧭 Group leads
+
+Section 6 says what a lead decides alone and what goes to the council.
+
+- **Discord:** in their group's channel only, delete messages, manage and pin threads, and ping the group role. The
+  🧭 lead role carries no server-wide permission.
+- **GitHub:** triage on the issues and pull requests that carry their group's label (`/label`, `/unlabel`, `/close`,
+  `/reopen`, `/unclaim`), from a list of group leads that grants no repository role. Leads merge only if they are on
+  the Horizon Team too.
+
+### 🌌 Horizon Team
+
+The Horizon Team **merges pull requests**. Its rules are in [the release flow](docs/release-flow.md): read the whole
+diff, never merge your own pull request, and use `needs-proof` for anything risky.
+
+- **GitHub:** member of the `horizon-team` team (write access to the Horizon repos), on the trusted reviewers list
+  (`/nightly` and triage commands).
+- **Discord:** the 🌌 Horizon Team role, #horizon-team, and writing in #contributors and the read-only channels.
+  Moderation permissions belong to the moderators and the council: a Team member moderates only if they also hold
+  one of those roles.
+- **During the 30-day probation:** they merge only ordinary pull requests. They don't merge `needs-proof` pull
+  requests, don't approve files that CODEOWNERS guards, and don't use `/nightly`.
+
+### 🏛️ Council
+
+- **Discord:** the 🏛️ Council role: the moderators' permissions plus ban and mention @everyone; #council (private);
+  starting polls in #polls-and-decisions.
+- **GitHub:** the `council` team. Over time it takes over the founder's CODEOWNERS review and his owner powers in the
+  release tools (section 11).
+- **Alone (any one member):** start a poll; pick up a member's request for a poll; do anything their other roles
+  allow.
+- **Any two members together:** an emergency action (section 4.6).
+- **Everything else** is decided by poll.
+
+## 4. The council and its polls
+
+### 4.1 Founding council
+
+kacpherek, levzzz5154, rdbtCVS, Online5277, dezer-x and Ludovic: six members, one vote each. The founding members
+don't go through the filter or a probation. They do make the 18+ declaration (section 9). The council has at most
+**9** members. It adds a seat only when a 2/3 poll says it needs one.
+
+### 4.2 How a poll works
+
+| Rule | Value |
+| --- | --- |
+| Who starts one | Any council member, with `/poll` (Kira). Anyone else asks a council member to start it |
+| Where | #polls-and-decisions, in public. Polls about a person (removal, appeals, the age rule) run in #council, and only their result is public |
+| How long | 24 hours. It closes early only if every council member has voted |
+| Ballot | Yes, No or Abstain. You can change it until the poll closes |
+| Quorum | At least half of the council votes (Abstain counts). With 6 members, 3 votes |
+| Simple majority | More Yes than No |
+| Two-thirds | Yes is at least 2/3 of the Yes and No votes, **and at least 3 Yes votes** |
+| Tie | Nothing changes |
+| No quorum | Nothing changes. Kira reminds the members who haven't voted 12 hours and 2 hours before the end |
+| About yourself | You don't vote, and you don't count in the council's size for that poll |
+| Asking again | A poll that failed can't be asked again for 7 days, unless two members agree that new facts justify it |
+
+### 4.3 Which threshold applies
+
+| Simple majority | Two-thirds |
+| --- | --- |
+| Day-to-day project decisions: direction, priorities, settling disputes between groups, a public statement | Adding council members and Horizon Team members |
+| Group leads and co-leads: appointing, removing, confirming every 6 months | Removing a council member or a Team member (without the person concerned) |
+| Moderators, the Chief of Mods, Support: confirming, removing | Rules: this document, the server rules, the contributing policy, the licence |
+| Ending a probation early | Money (section 12) |
+| Confirming an emergency action | Account handover steps (section 11) |
+| Second-level moderation appeals | Waiving part of the selection filter (section 5.4) |
+| Bringing back someone who stepped down for inactivity, within 6 months | Changing the council's size |
+
+**When in doubt, two-thirds.** Any council member can say a poll needs 2/3, and Kira then counts it at 2/3.
+
+### 4.4 Discussion
+
+Polls that add someone to the council, the Team or a lead post start with a **24-hour public discussion** (section
+5.3). Other polls are discussed in their own thread while they run. A member who wants more time votes No and says
+why. A failed poll can come back after 7 days.
+
+### 4.5 Conflicts of interest
+
+A member doesn't vote on a poll about themselves: their own role, their own removal, an appeal of their own
+moderation action, or money paid to them. They say so in the poll's thread and Kira leaves them out of the count.
+
+### 4.6 Emergencies
+
+For **security** (a leaked secret, a malicious pull request or mod, a hijacked account), **Mojang or Microsoft** (a
+request from them, a risk to the approved sign-in) or **legal** matters (a takedown, the law), **any two council
+members act at once**. They may:
+
+- pause releases and the Nightly;
+- take a mod down from the registry;
+- remove someone's roles or access for now;
+- lock or hide channels and content;
+- ask the account holder to rotate a secret or a key.
+
+They record it with `/emergency` in Kira, and both of them confirm it there. Kira opens a council poll at once
+(simple majority) to confirm it. If the poll doesn't pass, the action is undone where it can be. An emergency never
+adds members, changes rules or spends money.
+
+### 4.7 Removing a council member
+
+A 2/3 poll of the other members, in #council. The person concerned doesn't vote and doesn't count in the quorum.
+Only the result is published, never the reasons. Other ways to leave: resigning, inactivity (section 5.5), or a
+false age declaration (section 9).
+
+### 4.8 When the council drops below a quorum
+
+- **Fewer than 5 members:** Kira opens nominations for the council at once. The council fills seats within 30 days.
+- **Fewer than 3 members, or fewer than 3 who voted in the last 30 days:** an **interim council** forms. It counts the
+  remaining council members, the Horizon Team and the group leads past probation. Its only task is adding council
+  members, by its own 2/3 poll with a quorum of half. Any two of its members can take emergency actions. All other
+  decisions wait. The Team keeps merging and the leads keep leading.
+- **Nobody left:** the Team and the group leads form the interim council in the same way.
+
+## 5. The selection filter
+
+Nobody becomes a lead, a Team member or a council member just because they are well liked or talk a lot. Kira
+measures the work, and only people above a floor can be nominated. The council then decides among them.
+
+### 5.1 What Kira measures
+
+| Signal | What counts | Source |
+| --- | --- | --- |
+| **Merged pull requests** | Pull requests merged in a public horizon-rust repo. For Modding, also in the mod API's fork (arismoko/horizon). Counted overall, and per group by label or by files touched | GitHub search, as the ranks are counted today |
+| **Reviews** | Others' pull requests you reviewed: approved, asked for changes, or left a review with comments. One per pull request | GitHub search `reviewed-by:` and Kira's GitHub webhook |
+| **Triage** | Triage commands run (`/label`, `/close`, duplicates), issues labelled or closed, bug posts routed on Discord | The triage workflow's comments and Kira's webhook |
+| **Support answers** | #horizon-support posts you answered that ended solved | Kira's support feature |
+| **Active days** | Distinct days with any of the above, or with messages in #contributors or a group's channel. Chat elsewhere doesn't count | Kira |
+| **Tenure** | Days since your first counted contribution (since you joined the server, for moderators) | GitHub, Discord |
+| **Clean record** | No timeout, quarantine or ban in the last 90 days | Kira's mod cases |
+| **Verified GitHub** | `/verify-github` done | Kira |
+| **18+ declaration** | Made (section 9) | Kira |
+
+Kira turns these into an **evidence card**: the person's numbers, overall and in the group's area, for the last 60
+days and in total. Anyone can see their own card with `/evidence`. A nomination shows the card publicly.
+
+### 5.2 The floors
+
+A nomination is refused below these floors.
+
+| Role | Floor |
+| --- | --- |
+| **Group lead** | Verified GitHub; tenure of 30 days or more; **in the group's area: 8 or more merged pull requests, or 20 or more reviews** (Translations: 5 or more merged translation pull requests; Server and SMP: 8 pull requests, or 30 days as an official server operator with activity); 15 or more active days in the last 60; clean record; 18+ |
+| **Moderator** | In the server for 30 days or more; Kira level 10 or more; 15 or more active days in the last 60; clean record; 18+ |
+| **Chief of Mods** | Moderator for 30 days or more, past probation; 18+ |
+| **Horizon Team** | 🥇 Gold rank (40 merged pull requests); 20 or more reviews of others' pull requests; tenure of 30 days or more; 20 or more active days in the last 60; clean record; verified GitHub; 18+ |
+| **Council** | Horizon Team member, group lead or Chief of Mods for 60 days or more, past probation; 20 or more active days in the last 60; clean record; 18+ |
+
+The numbers are checked again once a year (section 15). They should stay reachable for people who really work on
+Horizon and out of reach for people who don't.
+
+### 5.3 The path to a role
+
+1. **Nomination.** Run `/nominate member: role: [group:]` in Kira.
+   - A **group lead** can be nominated by an active member of that group or by a council member. A self-nomination
+     needs a second from another active group member or a council member.
+   - A **Team member** can be nominated by a council or Team member. Someone can also nominate themselves with
+     `/apply`, if a council or Team member sponsors them.
+   - A **council member** can only be nominated by a council member.
+   - **Moderators** apply with `/apply`.
+2. **The filter.** Kira checks the floor and the 18+ declaration. Below the floor, Kira refuses and says which line
+   is short.
+3. **Public discussion, 24 hours.** Kira posts the nomination and the evidence card in a thread of
+   #polls-and-decisions. Contributors and the council can comment. For a lead, Kira also runs an **advisory poll** in
+   the group's channel for the same 24 hours. Only active group members vote in it, and the council sees the result.
+4. **Council poll, 24 hours.** Simple majority for a lead, 2/3 for the Team and the council. For moderators, the mods'
+   vote replaces this step, and any two council members can object within 24 hours; the council then decides by poll.
+5. **Probation, 30 days.** The role is held in full, except for the Team limits in section 3. At day 25, Kira asks the
+   council in #council whether anything is wrong. Probation ends by itself at day 30, unless a council poll (simple
+   majority) ended it earlier.
+
+### 5.4 Exceptions
+
+Some valuable people don't show up in the numbers, such as a designer for the website. The council can **waive the
+tenure or the area floors** by a 2/3 poll that says why. The age rule and the clean record are never waived.
+
+### 5.5 Inactivity
+
+Kira checks every day. It warns the person in a DM and in #council, then posts the step-down in
+#polls-and-decisions with neutral wording ("stepped down: inactive"), and removes the Discord role. The account
+holder or an org owner removes GitHub access when the Team role ends.
+
+| Role | What counts as activity | Warning | Steps down |
+| --- | --- | --- | --- |
+| Group lead | A counted action in the group's area, or messages in the group's channel | Day 21 | Day 30 |
+| Horizon Team | A merge or a review | Day 45 | Day 60 |
+| Moderator, Chief of Mods | A moderation action, or messages in the staff channels | Day 21 | Day 30 |
+| Support | An answer in #horizon-support | Day 21 | Day 30 |
+| Council | A vote in a poll. At 30 days with no vote, while at least 2 polls were held | Day 23 | Day 30, or 45 days with no counted activity at all |
+
+- **Away.** Anyone can announce an absence with `/away` for up to 45 days, once every 6 months. Away days don't
+  count. A lead names someone from the group to cover for them.
+- **Coming back.** Within 6 months: a simple-majority poll, with no new probation. After 6 months: the normal path.
+
+### 5.6 Terms
+
+- **Group leads** are confirmed every 6 months by a simple-majority poll. If someone else in the group passes the
+  floor and is nominated, both go on the same poll.
+- **Council and Team** have no fixed term. They stay as long as they are active and keep the council's trust. Removal
+  is always possible (section 4.7).
+
+## 6. Theme groups
+
+### 6.1 The groups
+
+| Group | Covers | GitHub | Discord |
+| --- | --- | --- | --- |
+| **Modding** | The mod API, native and content mods, mixins, the mod registry, `cargo horizon-mod` | The mod API lives in Ari's fork **arismoko/horizon**. Its owner runs that repo by their own rules; the council governs only what is Horizon's: horizon-rust/horizon-mods, horizon-mixins, horizon-native-mod-template, the registry. Label `mods` | The 🧩 MODDING category (#modding, #horizon-modding-team); roles 🧩 Modder (picked) and 🧩 Horizon Modding Team (the lead gives it) |
+| **Shaders and rendering** | The renderer, shaders, shader packs, OptiFine and Polytone pack formats | Label `rendering`; `crates/horizon-client-render` (gfx), `*.wgsl`, `horizon-shaders`, `horizon-shader-api`, `horizon-optifine`, `horizon-polytone` | #shaders-rendering |
+| **Performance** | Frame rate, memory, server tick, benchmarks | Label `perf`; `horizon-bench`, the benchmark tools | #performance |
+| **Launcher** | The launcher: installs, updates, instances, its pages | Label `launcher`; `launcher/` | #launcher |
+| **Server and SMP** | Dedicated server, hosting, the anticheat, multiplayer, and the official SMP | Labels `server`, `multiplayer`; `horizon-server*`, `horizon-anticheat`, `lan/`, `dedicated*`; horizon-rust/horizon-server | #server-smp (plus #join-server, #server-chat) |
+| **Translations** | The game's and the launcher's languages | Label `roadmap:languages`; `launcher/lang/`, `crates/horizon-client/assets/horizon/lang/` | #translations and the 🌍 language channels |
+| **Website** | playhorizon.dev | horizon-rust/horizon-site; label `website`. The site's design stays as it is unless the council decides otherwise | #website |
+| **Vanilla accuracy** | Parity with vanilla 26.3: harnesses, oracles, the port ledger | Labels `parity`, `parity-regression`, `full-parity`; `tools/test_*_parity.py`, the Java oracles | #vanilla-accuracy |
+| **UI** | The game's menus, HUD, settings, controller navigation, the design system | Labels `ui`, `accessibility`; `title/`, `settings_shell.rs`, `hud*`, `ui.rs`, `docs/design-system.md`, `horizon-theme`. The launcher's look is shared with Launcher | #ui |
+
+A pull request can belong to two groups. Both leads can comment, and the Team merges as usual. If the leads disagree,
+the council decides.
+
+### 6.2 Leads per group
+
+- **One lead per group.** A group with 8 or more active members may also have **one co-lead**, chosen the same way.
+- A person leads **at most two groups**. Council members may lead a group, though a lead from outside the council is
+  preferred: it spreads the work.
+
+### 6.3 What a lead decides alone
+
+Inside their group's topic, and within this document, the contributing guide, the vanilla-first rule, the layers and
+the design system:
+
+- the group's priorities and the order of its roadmap items;
+- which issues are `good first issue`, and triage of the group's issues;
+- technical and design direction inside the area, when vanilla behaviour and the default look don't change;
+- accepting or declining an idea or a proposal in the area. Any two active group members or one council member can
+  take that decision to the council;
+- how the group organises itself (threads, meetings, the channel's rules on top of the server's);
+- asking the Team for reviews, adding `needs-proof`, and nominating people.
+
+### 6.4 What goes to the council
+
+- the rules, money, accounts and secrets;
+- who is on the council, the Team or the mods;
+- anything that changes vanilla behaviour or turns a Horizon-only feature on by default;
+- breaking a public promise: the mod API, server compatibility, save and file formats;
+- disputes between groups;
+- anything involving Mojang, Microsoft or the law;
+- speaking for the whole project outside the group's topic.
+
+### 6.5 A group without a lead
+
+The work goes on. The Team reviews and merges, and Kira still routes the group's issues and questions to its
+channel. Until a lead is chosen, any council member may take a lead's decision for that group and says so in the
+channel. Kira pins a "lead wanted" note with the floor. **No lead is better than a lead who doesn't do the work:**
+nobody is appointed just to fill the seat.
+
+## 7. Moderation and appeals
+
+- **The server rules** are in #rules. Moderators enforce them, the Chief of Mods leads the mods, and the council can
+  change the rules (2/3).
+- **Every action has a mod case**: who acted, what they did, and why. Kira keeps the cases.
+- **First appeal:** within 14 days, through #appeal (for a quarantine) or mod mail. A moderator who wasn't involved,
+  or the Chief of Mods, answers within 72 hours.
+- **Second appeal:** for bans, timeouts over 24 hours and quarantines, a council poll in #council (simple majority).
+  Members who were involved don't vote. The answer is final for 90 days.
+- **Not appealable here:** actions that Discord's rules or the law require. Those are reported where the law says.
+- **Removing a moderator:** the Chief of Mods can suspend a moderator at once, and the council decides within 72 hours
+  (simple majority). The council removes the Chief of Mods the same way.
+- **Staff are moderated like everyone.** When a council member is involved, the council decides without them.
+
+## 8. Conflicts and hard cases
+
+| Case | What happens |
+| --- | --- |
+| Two groups disagree | The leads talk first. If they still disagree, the council decides (simple majority) |
+| A lead's decision is contested | Any two active group members or one council member can bring it to the council |
+| A Team member merges against the rules | Any council member can revert the merge. The council can remove the member (2/3) |
+| A council member breaks the rules | The council decides without them. Removal takes 2/3 (section 4.7) |
+| Someone holds a role and is under 18 | Section 9 |
+| The council can't reach quorum | Section 4.8 |
+| The founder and the council disagree about one of his own accounts | Until a step of section 11 hands it over, the account stays his. He carries out the council's decisions on project matters, or he says publicly that he won't |
+
+## 9. The age rule (18+)
+
+**Who must be 18 or older:** members of the council and the Horizon Team, trusted reviewers, group leads and
+co-leads, the Chief of Mods and the moderators, official server operators, and anyone with admin rights anywhere in
+the project: Discord (Administrator, Manage Roles, Manage Channels, ban), GitHub (write, admin, organisation),
+server panels, Railway, or Kira's admin side. The same goes for anyone who holds a project secret.
+
+**Who doesn't have to be:** members, contributors (with any rank), group members and 🤝 Support. Contributors under
+18 are welcome and valued. They just can't hold the roles above.
+
+**How it's checked, without collecting ID:**
+
+- **A declaration.** Before taking such a role, and once at the start for everyone who holds one, the person presses
+  a button in Kira: "I confirm that I am 18 or older. I understand that a false declaration removes all my roles of
+  trust." Kira keeps only the Discord account, the date and the wording's version. It never stores a birth date, an
+  ID, a photo, or any outside age-checking service's result.
+- **No declaration, no role.** At the start, current role holders have 7 days to make it. Until they do, their role is
+  paused.
+- **When there's doubt** (the person says they are younger, or there is a credible private report), one council
+  member asks the person privately. If the doubt remains, any council member pauses the role, and the council decides
+  within 72 hours in #council.
+- **A false declaration** removes every role of trust at once, and the person can't hold one for 12 months.
+- **Privacy.** Age is never discussed in public. A role that ends for this reason ends with the same neutral line as
+  any other step-down.
+
+## 10. The agents
+
+Horizon uses AI agents: the founder's orchestrator, which runs coding agents, and Kira, the Discord bot.
+
+- **They obey council decisions only:** a passed poll recorded by Kira, a recorded emergency action of two council
+  members, and the standing rules in this document and the project's docs.
+- **The only exception is the founder's own things:** his spending, his machines (they run CI and the vanilla tests),
+  his personal accounts and his time. On those, his word decides. This list should get shorter over time (section 11).
+- **Role work isn't a decision.** A lead asking Kira to route issues, or a Team member asking an agent to prove a pull
+  request, is that person using their role. The agents help, within the role's powers.
+- **They check the source.** An agent acts on a decision only when it finds it in Kira's decisions log
+  (section 13). A message saying "the council decided", or a screenshot, is not enough.
+- **They post as agents.** Everything an agent posts says it comes from an agent, and states decisions as the
+  project's.
+
+## 11. Accounts and the handover path
+
+Today the founder holds every account. The aim is for him to hold fewer, in an order that never leaves the project
+unable to act, and never puts an account that is tied to a person into anyone else's hands.
+
+| 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 |
+| **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 |
+| **Domains** (playhorizon.dev and the others) | The founder's registrar account | Not without moving it | Auto-renewal on, registered for several years ahead. They move only to a legal entity, if one is created |
+| **The Microsoft app approved by Mojang** (sign-in) | The founder's Azure app registration; Mojang approved it after his application | **No.** The approval was given on his application. Moving the app or adding owners would change who Mojang deals with, and we have found no documented way to transfer an approval | **Never moves** without Mojang's written agreement. The only change considered: a legal entity, if one is created, and only if Mojang agrees |
+| **Signing** (Apple developer certificate, release signing keys) | The founder's | The Apple certificate is in his legal name: no | The Apple certificate never moves. Release keys stay in GitHub's protected environments, and the council team approves their use from step 2 |
+| **Money** (sponsorship, donations) | Personal accounts of the founder | Through a fiscal host | Section 12 |
+| **The founder's machines, AI accounts and password vault** | His | No | His own things: they never move. The project should depend on them less over time |
+
+**Order:** first the safety nets that remove a single point of failure (a second organisation owner, the bot's
+developer team, panel sub-users). Then the day-to-day powers (CODEOWNERS and release tools to the council team). Last,
+whatever needs a legal entity: domains, money, and with Mojang's agreement the sign-in app. Each step is a 2/3 poll,
+and the founder carries it out.
+
+## 12. Money
+
+*Placeholder: the options (Open Collective and others) are being researched.*
+
+- The council approves every expense by a **2/3 poll**.
+- **Every income and every expense is public.**
+- Nobody votes on money paid to themselves.
+
+## 13. Transparency
+
+- **#polls-and-decisions:** every poll and every result, posted by Kira, and the 24-hour discussions of nominations.
+  For polls that aren't about a person, each member's vote is shown once the poll closes.
+- **The decisions log:** Kira keeps an append-only record of every poll, emergency action, appointment and
+  step-down, with its date and result. It is public and machine-readable, so the agents can check a decision there.
+- **This document** lives in horizon-rust/horizon as `GOVERNANCE.md`. A short summary is pinned in #rules and in
+  #polls-and-decisions.
+- **Who holds which role:** the people page of playhorizon.dev's hub shows the council, the Team, the group leads,
+  the Chief of Mods, the moderators and Support.
+- **#council** is private for discussion and for polls about people. Everything the council decides is published.
+
+## 14. Rules that are never voted on
+
+These are Horizon's conditions for existing, not choices. No poll can change them:
+
+- Playing needs a **Microsoft account that owns Minecraft: Java Edition**. There is no play without one.
+- **No Mojang files** in Horizon's repos or downloads. Players' own copies stay on their own machines.
+- **No gambling**, in any form, including with in-game currency.
+- **Mojang's and Microsoft's terms and Usage Guidelines** apply to everything Horizon does.
+- **The law**, and the terms of service of Discord and GitHub.
+
+## 15. Changing this document
+
+A 2/3 council poll, then a pull request that a Team member merges. The council reviews the floors' numbers
+(section 5.2) once a year, or sooner if they turn out wrong.
@@ -135,6 +135,8 @@ python3 tools/pr_ready.py

 It runs rustfmt, clippy, the touched crates' tests, the Python tests, the public-tree check and the vanilla harnesses your change affects. Never commit game files, decompiled source or prepared resources.

+How Horizon is run (the council, theme groups and their leads, the Horizon Team, moderation): [GOVERNANCE.md](GOVERNANCE.md).
+
 ## Project status

 **Player-visible gaps: 0 open** of the 833 the [port ledger](tools/port_ledger.py) found, reading every vanilla 26.3 method against Horizon's code: vanilla behaviour a player would notice that Horizon doesn't have yet. By area: Animals [0](https://github.com/horizon-rust/horizon/issues/3512); Monsters and bosses [0](https://github.com/horizon-rust/horizon/issues/3513); Entities, projectiles, vehicles and decorations [0](https://github.com/horizon-rust/horizon/issues/3514); Items, enchantments and inventories [0](https://github.com/horizon-rust/horizon/issues/3515); Blocks, redstone and fluids [0](https://github.com/horizon-rust/horizon/issues/3516); World, world generation and saves [0](https://github.com/horizon-rust/horizon/issues/3517); Screens, HUD and client packets [0](https://github.com/horizon-rust/horizon/issues/3518); Entity and block rendering, models [0](https://github.com/horizon-rust/horizon/issues/3519); Server and players on the server [0](https://github.com/horizon-rust/horizon/issues/3520); Mob AI, villagers and raids [0](https://github.com/horizon-rust/horizon/issues/3521). This number goes down as gaps close (`tools/parity_gaps.py`); the table below says what the harnesses compare.
@@ -15,6 +15,10 @@ pub const OFFICIAL_SERVER: &str = "play.playhorizon.dev";
 /// `official_server_previous` in `launcher/links.json`).
 pub const OFFICIAL_SERVER_PREVIOUS: &[&str] = &["horizon.bunchy7s.dev"];

+/// Afri-Network, a partner server the game added once below the official server (#9299) until
+/// the partnership ended: kept so the game can take back out the entry it added.
+pub const WITHDRAWN_PARTNER_SERVER: &str = "afri-network.co.za";
+
 /// [`OFFICIAL_SERVER`] with the port its SRV record gives, for askers that don't look SRV up
 /// (the telemetry server's status checks).
 pub const OFFICIAL_SERVER_STATUS: &str = "play.playhorizon.dev:24454";
@@ -7,6 +7,8 @@ rust-version.workspace = true
 description = "The dedicated server's chat filter: its [chat_filter] settings, the slur list's matcher and the mutes, with no game state (docs/chat-filter.md)"

 [dependencies]
+# The moderation durations, shared with `/tempban`.
+horizon-server-files = { path = "../horizon-server-files" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 toml = "1.1"
@@ -10,6 +10,9 @@ use std::path::{Path, PathBuf};

 mod normalise;

+pub use horizon_server_files::duration::{
+    DurationUnit, duration_parts, duration_text, now_millis, parse_duration,
+};
 pub use normalise::{Run, Text};

 /// The list built into the game, used when `words_file` is empty.
@@ -474,61 +477,6 @@ pub fn append_log(path: &Path, line: &str) -> std::io::Result<()> {
    writeln!(f, "{line}")
 }

-/// `/tempmute`'s duration in milliseconds: a positive whole number and a unit, `s`, `m`, `h`, `d` or
-/// `w` (`10m`, `2h`, `1d`).
-pub fn parse_duration(text: &str) -> Option<i64> {
-    let unit = match text.chars().last()? {
-        's' => 1_000,
-        'm' => MINUTE,
-        'h' => 60 * MINUTE,
-        'd' => 24 * 60 * MINUTE,
-        'w' => 7 * 24 * 60 * MINUTE,
-        _ => return None,
-    };
-    let count: i64 = text[..text.len() - 1].parse().ok()?;
-    (count > 0).then(|| count.checked_mul(unit)).flatten()
-}
-
-/// The unit used when presenting a moderation duration to a player.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum DurationUnit {
-    Minute,
-    Hour,
-    Day,
-}
-
-/// A duration's rounded count and unit, shared by logs and translated replies.
-pub fn duration_parts(millis: i64) -> (i64, DurationUnit) {
-    let (unit, kind) = if millis <= 60 * MINUTE {
-        (MINUTE, DurationUnit::Minute)
-    } else if millis <= 48 * 60 * MINUTE {
-        (60 * MINUTE, DurationUnit::Hour)
-    } else {
-        (24 * 60 * MINUTE, DurationUnit::Day)
-    };
-    (
-        millis.div_euclid(unit) + i64::from(millis.rem_euclid(unit) > 0),
-        kind,
-    )
-}
-
-/// `millis` for logs, rounded up: minutes up to an hour, hours up to two days, then days.
-pub fn duration_text(millis: i64) -> String {
-    let (count, unit) = duration_parts(millis);
-    let unit = match unit {
-        DurationUnit::Minute => "minute",
-        DurationUnit::Hour => "hour",
-        DurationUnit::Day => "day",
-    };
-    format!("{count} {unit}{}", if count == 1 { "" } else { "s" })
-}
-
-pub fn now_millis() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .map_or(0, |d| d.as_millis() as i64)
-}
-
 /// `YYYY-MM-DDTHH:MM:SSZ` for epoch milliseconds.
 pub fn utc(millis: i64) -> String {
    let secs = millis.div_euclid(1000);
@@ -9,11 +9,13 @@ description = "The client's input layer: key bindings and their names, mouse, co
 [dependencies]
 horizon-client-core = { path = "../horizon-client-core" }
 winit = "0.30.13"
-# The window icon.
-horizon-theme = { path = "../horizon-theme" }
 png = "0.18"
 arboard = { version = "3.6.1", default-features = false, features = ["wayland-data-control"] }

+[dev-dependencies]
+# The window icon test decodes Horizon's icon.
+horizon-theme = { path = "../horizon-theme" }
+
 [features]
 controllers = []

@@ -1441,6 +1441,16 @@ pub enum Rumble {
    },
    Totem,
 }
+impl From<crate::input_source::Feedback> for Rumble {
+    fn from(event: crate::input_source::Feedback) -> Self {
+        use crate::input_source::Feedback;
+        match event {
+            Feedback::BlockBroken => Rumble::BlockBroken,
+            Feedback::Explosion { distance, radius } => Rumble::Explosion { distance, radius },
+            Feedback::Totem => Rumble::Totem,
+        }
+    }
+}
 /// A vibration: the heavy (low-frequency) and light motors, 0..1, and how
 /// long it lasts.
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -0,0 +1,15 @@
+//! The engine's side of the input source (docs/layers.md, "Controllers, splitscreen, replays and
+//! UI pages"): what gameplay tells a device beyond the keyboard and mouse. Gameplay names these
+//! types, never a controller's; the controller code answers.
+
+/// Something that happened to the player that a device may let them feel (a controller's
+/// vibration). The device decides how, or whether.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Feedback {
+    /// The player broke a block.
+    BlockBroken,
+    /// An explosion this far away (blocks) with this power.
+    Explosion { distance: f64, radius: f32 },
+    /// A totem of undying saved the player.
+    Totem,
+}
@@ -9,6 +9,7 @@ pub mod gamepad;
 pub mod gameplay_guide;
 pub mod held;
 pub mod input;
+pub mod input_source;
 pub mod interaction_input;
 pub mod key_names;
 pub mod keybinds;
@@ -638,10 +638,30 @@ pub fn fullscreen_request(
    }
 }

-/// Horizon's icon for the window's title bar and the task bar (X11 and Windows; Wayland takes
-/// it from the `horizon.desktop` entry, macOS from the app bundle). `None` if it can't be read.
+/// The PNG the windows show as their icon, given once at startup by the layer that brands the
+/// game (the engine has none of its own).
+static ICON_PNG: std::sync::OnceLock<&'static [u8]> = std::sync::OnceLock::new();
+
+/// Give the windows their icon, a PNG: call it before the first window opens. A second call
+/// keeps the first icon.
+pub fn set_icon_png(png: &'static [u8]) {
+    let _ = ICON_PNG.set(png);
+}
+
+/// The icon given to [`set_icon_png`], if any.
+pub fn icon_png() -> Option<&'static [u8]> {
+    ICON_PNG.get().copied()
+}
+
+/// The icon for the window's title bar and the task bar (X11 and Windows; Wayland takes it from
+/// the `.desktop` entry, macOS from the app bundle). `None` with no icon given, or one that
+/// can't be read.
 pub fn icon() -> Option<winit::window::Icon> {
-    let mut decoder = png::Decoder::new(std::io::Cursor::new(horizon_theme::ICON_PNG));
+    decode_icon(icon_png()?)
+}
+
+fn decode_icon(png: &[u8]) -> Option<winit::window::Icon> {
+    let mut decoder = png::Decoder::new(std::io::Cursor::new(png));
    decoder.ignore_checksums(true);
    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
    let mut reader = decoder.read_info().ok()?;
@@ -654,14 +674,15 @@ pub fn icon() -> Option<winit::window::Icon> {
    winit::window::Icon::from_rgba(bytes, info.width, info.height).ok()
 }

-/// Apply Horizon's icon to every window. Windows has a separate taskbar icon slot from the small
-/// window icon; requiring the decoded icon there prevents a generic taskbar icon from appearing.
-pub fn with_horizon_icon(
-    attributes: winit::window::WindowAttributes,
-) -> winit::window::WindowAttributes {
+/// Apply the icon given to [`set_icon_png`] to a window. Windows has a separate taskbar icon slot
+/// from the small window icon; requiring a given icon to decode there prevents a generic taskbar
+/// icon from appearing.
+pub fn with_icon(attributes: winit::window::WindowAttributes) -> winit::window::WindowAttributes {
+    #[cfg(not(target_os = "windows"))]
    let icon = icon();
    #[cfg(target_os = "windows")]
-    let icon = Some(icon.expect("Horizon's icon must be available on Windows"));
+    let icon =
+        icon_png().map(|png| decode_icon(png).expect("the window icon must decode on Windows"));

    let attributes = attributes.with_window_icon(icon.clone());
    #[cfg(target_os = "windows")]
@@ -670,6 +691,39 @@ pub fn with_horizon_icon(
    attributes
 }

+/// The screen a window is on: its size in physical pixels, its refresh rate where the OS gives
+/// it, and its scale. For `horizon-ctl status` and the performance statistics' `system.display`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Display {
+    pub width: u32,
+    pub height: u32,
+    pub refresh_hz: Option<u32>,
+    pub scale: f64,
+}
+
+/// The screen `window` is on, else the primary one, else the only one: right after the window
+/// is made, Wayland doesn't say yet which screen it is on.
+pub fn monitor(window: &winit::window::Window) -> Option<winit::monitor::MonitorHandle> {
+    let only = || {
+        let mut all = window.available_monitors();
+        all.next().filter(|_| all.next().is_none())
+    };
+    window
+        .current_monitor()
+        .or_else(|| window.primary_monitor())
+        .or_else(only)
+}
+
+/// [`monitor`]'s size, refresh rate and scale.
+pub fn display(window: &winit::window::Window) -> Option<Display> {
+    monitor(window).map(|m| Display {
+        width: m.size().width,
+        height: m.size().height,
+        refresh_hz: m.refresh_rate_millihertz().map(|r| r.div_ceil(1000)),
+        scale: m.scale_factor(),
+    })
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -706,7 +760,8 @@ mod tests {
    }
    #[test]
    fn the_window_icon_decodes() {
-        assert!(icon().is_some());
+        assert!(decode_icon(horizon_theme::ICON_PNG).is_some());
+        assert!(decode_icon(b"not a png").is_none());
    }

    #[test]
@@ -42,8 +42,6 @@ horizon-chat-filter = { path = "../horizon-chat-filter" }
 horizon-shaders = { path = "../horizon-shaders" }
 # Horizon's own shader packs: the format, the stages and the check (docs/shaders.md).
 horizon-shader-api = { path = "../horizon-shader-api" }
-# Play with Friends: invite codes and their tunnel; the `friends` feature.
-horizon-friends = { path = "../horizon-friends", optional = true }
 # The narrator (GameNarrator): text-to-speech of chat, system messages and screens.
 horizon-narrator = { path = "../horizon-narrator" }
 # Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md).
@@ -72,7 +70,6 @@ flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs",
 mio = { version = "1.2.4", features = ["os-poll", "net"] }
 # Shared chunk frames are found by one keyed 128-bit hash of their body (lan/conn.rs SharedFrames).
 xxhash-rust = { version = "0.8.19", features = ["xxh3"] }
-horizon-theme = { path = "../horizon-theme" }
 # Opt-in data collection: the game keeps, the launcher sends (docs/telemetry.md).
 horizon-telemetry = { path = "../horizon-telemetry", default-features = false }
 horizon-bench = { path = "../horizon-bench" }
@@ -111,16 +108,12 @@ objc2-foundation = { version = "0.3", default-features = false, features = ["std
 wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }

 [features]
-default = ["audio", "controllers", "discord", "friends"]
+default = ["audio", "controllers"]
 # Sound output. Without it (and `controllers`) the program links neither libasound nor libudev on
 # Linux: the server build (`--no-default-features`, released as horizon-engine; docs/server.md).
 audio = ["horizon-client-render/audio"]
 # Controllers: gilrs, and the DualSense's own output. Without it only `horizon-ctl pad`'s virtual pad.
 controllers = ["dep:gilrs", "horizon-client-input/controllers"]
-# "Playing Horizon" on the player's Discord profile (`discord_presence`).
-discord = []
-# Play with Friends, joining side (`net.rs`): without it no invite code joins.
-friends = ["dep:horizon-friends"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace"]
 # Compatibility with earlier experiment commands: main already uses mimalloc.
@@ -132,6 +125,8 @@ windows-segment-heap = []
 workspace = true

 [dev-dependencies]
+# ui_theme's unit tests draw text in the design system's fonts.
+horizon-theme = { path = "../horizon-theme" }
 horizon-client-render = { path = "../horizon-client-render", features = ["test-support"] }
 horizon-items = { path = "../horizon-items", features = ["test-support"] }
 # Every WGSL shader translated as wgpu's DirectX 12 backend does (gfx.rs tests).
@@ -24,13 +24,12 @@ horizon-narrator = { path = "../horizon-narrator" }
 # OptiFine-format pack files: random entity textures (hud.rs), connected textures
 # (connected.rs) and custom item texture rules (cit.rs).
 horizon-optifine = { path = "../horizon-optifine" }
+horizon-pack-options = { path = "../horizon-pack-options" }
 horizon-polytone = { path = "../horizon-polytone" }
 horizon-protocol = { path = "../horizon-protocol" }
-horizon-render-pipeline = { path = "../horizon-render-pipeline" }
 horizon-shader-api = { path = "../horizon-shader-api" }
 horizon-shaders = { path = "../horizon-shaders" }
 horizon-system = { path = "../horizon-system" }
-horizon-theme = { path = "../horizon-theme" }
 horizon-threads = { path = "../horizon-threads" }
 horizon-world = { path = "../horizon-world" }
 ab_glyph = "0.2.32"
@@ -77,10 +76,16 @@ wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
 audio = ["dep:cpal"]
 # Helpers horizon-client's tests build their fixtures with.
 test-support = []
+# horizon-client's `horizon-extras`: asking the device for hardware ray tracing on request
+# (`gfx/ray_query.rs`, `HORIZON_RAY_TRACING=1`). Without it the device is requested as without
+# the variable.
+horizon-extras = []

 [lints]
 workspace = true

 [dev-dependencies]
+# Tests: a TrueType font to load, and the design system the menus' motion curves match.
+horizon-theme = { path = "../horizon-theme" }
 horizon-items = { path = "../horizon-items", features = ["test-support"] }
 naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out", "glsl-out", "msl-out", "spv-out"] }
@@ -0,0 +1,158 @@
+//! Audio occlusion, attenuation and mixing benchmark.
+//! Run with: `cargo run --profile fast -p horizon-client-render --example audio_bench`
+use horizon_client_render::{
+    audio::Audio,
+    sound_engine::{MobSound, SoundInstance, Sounds, TickContext},
+};
+use std::{path::Path, time::Instant};
+
+fn main() {
+    println!("=== Horizon Audio Attenuation & Mixing Benchmark ===");
+
+    let mut audio = Audio::silent(Path::new("/nonexistent"));
+    audio.engine.loaded = true;
+    audio.backend_live_for_bench();
+    audio.record_heard = false;
+
+    // Register a sound event with attenuation distance 16
+    audio.engine.registry.add_file(
+        "minecraft",
+        br#"{"bench.loop":{"attenuation_distance":16,"sounds":[{"name":"bench/loop","stream":false}]}}"#,
+        &|_, _| true,
+    );
+    // Insert 1 second of audio into cache (48000 mono samples)
+    let samples: Vec<f32> = (0..48_000)
+        .map(|i| ((i as f32) * 440.0 * 2.0 * std::f32::consts::PI / 48000.0).sin() * 0.5)
+        .collect();
+    audio.insert_cached_sound("minecraft:bench/loop", samples, 48_000, 1);
+
+    // 1. Benchmark set_listener (called every client render frame)
+    let listener_iterations = 200_000;
+    let start = Instant::now();
+    for i in 0..listener_iterations {
+        let angle = (i as f32) * 0.01;
+        audio.set_listener(
+            [
+                100.0 + (angle.cos() as f64) * 5.0,
+                64.0,
+                200.0 + (angle.sin() as f64) * 5.0,
+            ],
+            angle,
+            0.0,
+        );
+    }
+    let listener_elapsed = start.elapsed();
+    println!(
+        "1. set_listener moving (render frame): {:?} for {} calls ({:.2} ns/call)",
+        listener_elapsed,
+        listener_iterations,
+        (listener_elapsed.as_nanos() as f64) / (listener_iterations as f64)
+    );
+
+    // 1b. Benchmark set_listener stationary (lock elimination early-out)
+    let stationary_iterations = 200_000;
+    let start = Instant::now();
+    for _ in 0..stationary_iterations {
+        audio.set_listener([100.0, 64.0, 200.0], 0.0, 0.0);
+    }
+    let stationary_elapsed = start.elapsed();
+    println!(
+        "1b. set_listener stationary (lock early-out): {:?} for {} calls ({:.2} ns/call)",
+        stationary_elapsed,
+        stationary_iterations,
+        (stationary_elapsed.as_nanos() as f64) / (stationary_iterations as f64)
+    );
+
+    // 2. Play 128 sounds in the world at various distances from listener at [100.0, 64.0, 200.0]
+    // 64 sounds within attenuation distance (<16 blocks)
+    // 64 sounds outside attenuation distance (>16 blocks)
+    for i in 0..128 {
+        let dist = if i < 64 {
+            (i as f64) * 0.24 // 0 to 15.1 blocks (audible)
+        } else {
+            17.0 + ((i - 64) as f64) * 1.5 // 17 to 111.5 blocks (out of attenuation range)
+        };
+        let pos = [100.0 + dist, 64.0, 200.0];
+        let instance = SoundInstance::new(
+            "minecraft:bench.loop",
+            crate_sound_source(i),
+            1.0,
+            1.0,
+            horizon_core::random::LegacyRandom::new(i as i64),
+            true, // looping
+            0,
+            horizon_client_render::sound_engine::Attenuation::Linear,
+            pos,
+            false,
+        );
+        audio.play_instance(instance, false);
+    }
+
+    // 3. Benchmark mix_buffer (5000 buffers of 1024 stereo frames @ 48kHz = ~106 seconds of audio mixing)
+    let mut buffer = vec![0.0f32; 1024 * 2];
+    let mix_iterations = 5_000;
+    let start = Instant::now();
+    for _ in 0..mix_iterations {
+        audio.mix_buffer(&mut buffer, 2, 48_000);
+    }
+    let mix_elapsed = start.elapsed();
+    println!(
+        "2. mix_buffer (128 active channels, 1024 stereo frames): {:?} for {} buffers ({:.2} µs/buffer)",
+        mix_elapsed,
+        mix_iterations,
+        (mix_elapsed.as_micros() as f64) / (mix_iterations as f64)
+    );
+
+    // 4. Benchmark SoundEngine::tick with ticking mob sounds
+    let mut mobs = Vec::new();
+    for i in 0..64 {
+        mobs.push(MobSound {
+            id: 2000 + i,
+            position: [100.0 + (i as f64) * 0.5, 64.0, 200.0 + (i as f64) * 0.5],
+            speed: 0.25,
+            baby: false,
+            angry: i % 2 == 0,
+            silent: false,
+            attack_scale: 0.5,
+            sniffer_digging: false,
+        });
+    }
+
+    let tick_ctx = TickContext {
+        player_underwater: false,
+        player_removed: false,
+        vehicle: None,
+        carts: Vec::new(),
+        mobs: mobs.clone(),
+        frozen: false,
+        player_position: [100.0, 64.0, 200.0],
+        player_speed_sqr: 0.1,
+        player_fall_flying: false,
+        ridden: None,
+        camera_position: [100.0, 64.0, 200.0],
+    };
+
+    let tick_iterations = 10_000;
+    let start = Instant::now();
+    for _ in 0..tick_iterations {
+        audio.tick(false, &tick_ctx);
+    }
+    let tick_elapsed = start.elapsed();
+    println!(
+        "3. SoundEngine::tick (64 channels + ticking): {:?} for {} ticks ({:.2} µs/tick)",
+        tick_elapsed,
+        tick_iterations,
+        (tick_elapsed.as_micros() as f64) / (tick_iterations as f64)
+    );
+}
+
+fn crate_sound_source(i: u32) -> usize {
+    match i % 6 {
+        0 => 0, // master
+        1 => 1, // music
+        2 => 2, // records
+        3 => 3, // weather
+        4 => 4, // blocks
+        _ => 5, // hostile
+    }
+}
@@ -288,6 +288,8 @@ fn zip_pack(id: &str, path: PathBuf) -> Pack {
 }

 fn main() {
+    // The pack formats the game installs at startup, so their loading is measured too.
+    horizon_client_render::pack_formats::install();
    let args: Vec<String> = std::env::args().collect();
    let scale = args
        .iter()
@@ -386,6 +386,7 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
                path: path.clone(),
                size: None,
                scaled: false,
+                background: false,
            });
            for _ in 0..32 {
                draw(&mut renderer)?;
@@ -207,6 +207,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        path: out.join("cpu.png"),
        size: None,
        scaled: false,
+        background: false,
    });
    renderer.render(&frame)?;
    let expected = read(&out.join("cpu.png"));
@@ -251,6 +252,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        path: out.join("gpu.png"),
        size: None,
        scaled: false,
+        background: false,
    });
    renderer.render(&frame)?;
    assert_eq!(
@@ -362,7 +364,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        outline: Vec::new(),
        outline_after_terrain: false,
        outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
        debug_lines: &[],
        debug_lines_on_top: &[],
        debug_crosshair: &[],
@@ -167,6 +167,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
            path: path.clone(),
            size: None,
            scaled: false,
+            background: false,
        });
        // twice: the first frame of a new warp builds it
        renderer.render(&frame).unwrap();
@@ -336,6 +337,7 @@ fn bench(renderer: &mut Renderer, out: &Path) -> Result<(), Box<dyn std::error::
            path: out.join("bench.png"),
            size: None,
            scaled: false,
+            background: false,
        });
        renderer.render(&frame).unwrap();
        renderer.render(&frame).unwrap();
@@ -430,7 +432,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        outline: Vec::new(),
        outline_after_terrain: false,
        outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
        debug_lines: &[],
        debug_lines_on_top: &[],
        debug_crosshair: &[],
@@ -99,10 +99,8 @@ pub struct RenderAssets {
    pub pbr_normals: Vec<u8>,
    pub pbr_specular: Vec<u8>,
    pub pbr_size: u32,
-    /// OptiFine connected textures (empty without `optifine/ctm` files).
-    pub connected: crate::connected::ConnectedTextures,
-    /// Fusion connected textures (empty without Fusion's connecting textures and models).
-    pub fusion: crate::fusion::FusionTextures,
+    /// The packs' connected textures (OptiFine's, Fusion's), when they have some.
+    pub connected: Option<crate::connected::Connected>,
    /// Counts up each time resources load, from 1: a native mod asks again where blocks'
    /// sprites are when it changes (`native_block_sprites_version`).
    pub generation: u64,
@@ -345,45 +343,32 @@ impl RenderAssets {
            sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
            sprites.insert(root, &format!("minecraft:block/destroy_oit_stage_{stage}"))?;
        }
-        let fusion = if draws {
-            let _step = crate::spans::startup::step("core.fusion");
-            crate::fusion::FusionTextures::load(root, registry, &mut sprites, &mut models.catalog)
-        } else {
-            Default::default()
-        };
        let mut emissive = Vec::new();
        let connected = if draws {
-            crate::native_emissive::load(root, &mut sprites);
-            // A side's sprite, for rules that connect by tile: the first quad facing it.
-            let catalog = &models.catalog;
-            let mut found = Vec::new();
-            crate::connected::ConnectedTextures::load(
+            // Native mods' emissive textures go where the pack format puts them (after its
+            // models' tiles, before its rules' tiles), else after both.
+            let mut native_loaded = false;
+            let mut native = |sprites: &mut crate::sprites::Sprites| {
+                if !std::mem::replace(&mut native_loaded, true) {
+                    crate::native_emissive::load(root, sprites);
+                }
+            };
+            let connected = crate::pack_hooks::formats().connected_textures(
                root,
                registry,
                &mut sprites,
-                |state, face| {
-                    let side = horizon_assets::model::Direction::ALL[face as usize];
-                    catalog
-                        .models_at(
-                            state,
-                            horizon_core::position::BlockPos::new(0, 0, 0),
-                            &mut found,
-                        )
-                        .ok()?;
-                    found
-                        .iter()
-                        .flat_map(|m| &m.faces)
-                        .find(|f| f.quad.facing == side)
-                        .map(|f| f.layer)
-                },
-            )
+                &mut models.catalog,
+                &mut native,
+            );
+            native(&mut sprites);
+            connected
        } else {
-            Default::default()
+            None
        };
        // After the connected tiles: a tile identical to a block shares its layer, and the
        // overlays skip shared layers.
-        if draws {
-            emissive = crate::native_emissive::load_optifine(root, &mut sprites);
+        if draws && let Some(suffix) = crate::pack_hooks::formats().emissive_suffix(root) {
+            emissive = crate::native_emissive::load_overlays(root, &suffix, &mut sprites);
        }
        sprites.save_disk_cache();
        if draws {
@@ -411,7 +396,6 @@ impl RenderAssets {
            pbr_specular: sprites.specular,
            pbr_size: sprites.pbr_size,
            connected,
-            fusion,
            generation: GENERATION.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1,
        })
    }
@@ -233,11 +233,11 @@ pub fn texture_path(root: &Path, texture: &str, directory: &str) -> PathBuf {
    }
    let (namespace, path) = texture.split_once(':').unwrap_or(("minecraft", texture));
    let rel = format!("assets/{namespace}/{directory}/{path}.png");
-    root.join(if horizon_optifine::paths::valid(&rel) {
-        &rel
-    } else {
-        NOWHERE
-    })
+    // No `.`, `..` or empty segment, and no `\` (a separator on Windows, where `..\..` climbs).
+    let stays = rel
+        .split('/')
+        .all(|segment| !matches!(segment, "" | "." | "..") && !segment.contains('\\'));
+    root.join(if stays { &rel } else { NOWHERE })
 }

 /// `SpriteSourceList.list`: every sprite id of the atlas and its origin.
@@ -478,6 +478,7 @@ pub struct Audio {
    pub record_heard: bool,
    pub listener: [f64; 3],
    pub listener_yaw: f32,
+    pub listener_pitch: f32,
    pub master: f32,
    /// Seeds of positional plays (the client level random's `nextLong`).
    random: LegacyRandom,
@@ -722,6 +723,29 @@ impl Backend for MixerBackend {
    fn set_unmuffled(&mut self, channel: ChannelId, unmuffled: bool) {
        self.with(channel, |c| c.unmuffled = unmuffled);
    }
+    fn update_channel(&mut self, channel: ChannelId, volume: f32, pitch: f32, position: [f64; 3]) {
+        if let Ok(mut m) = self.mixer.lock()
+            && let Some(c) = m.channels.get_mut(&channel)
+        {
+            c.gain = volume;
+            c.pitch = pitch;
+            c.at = [position[0] as f32, position[1] as f32, position[2] as f32];
+        }
+    }
+    fn filter_stopped(&mut self, live: &[(u64, ChannelId)], stopped: &mut Vec<u64>) {
+        if let Ok(m) = self.mixer.lock() {
+            for &(h, c) in live {
+                if m.channels
+                    .get(&c)
+                    .is_none_or(|ch| ch.state == State::Stopped)
+                {
+                    stopped.push(h);
+                }
+            }
+        } else {
+            stopped.extend(live.iter().map(|&(h, _)| h));
+        }
+    }
    /// `getCompleteBuffer` (cached, else decoded on the decoder thread) or
    /// `getStream` (decoded on a thread of its own), then attach and
    /// `alSourcePlay`. A sound that cannot load leaves its source initial,
@@ -822,18 +846,24 @@ impl Backend for MixerBackend {
 /// pinned client's) rendered through `ALC_SOFT_loopback` within 1e-5.
 fn stereo_gains(right: f32, up: f32, forward: f32) -> [f32; 2] {
    let length = (right * right + up * up + forward * forward).sqrt();
+    stereo_gains_with_length(right, up, forward, length)
+}
+#[inline]
+fn stereo_gains_with_length(right: f32, up: f32, forward: f32, length: f32) -> [f32; 2] {
    if length <= f32::EPSILON {
-        return stereo_gains(0.0, 0.0, 1.0);
+        return stereo_gains_with_length(0.0, 0.0, 1.0, 1.0);
    }
-    let elevation = (up / length).clamp(-1.0, 1.0).asin();
+    let u = (up / length).clamp(-1.0, 1.0);
+    let cos_elev = (1.0 - u * u).max(0.0).sqrt();
    let mut azimuth = right.atan2(forward);
    if azimuth.abs() < std::f32::consts::FRAC_PI_2 {
        azimuth = (azimuth.abs() * 1.5)
            .min(std::f32::consts::FRAC_PI_2)
            .copysign(azimuth);
    }
-    let side = azimuth.sin() * elevation.cos();
-    let front = azimuth.cos() * elevation.cos() * 0.095_660_8;
+    let (sin_az, cos_az) = azimuth.sin_cos();
+    let side = sin_az * cos_elev;
+    let front = cos_az * cos_elev * 0.095_660_8;
    [0.5 - 0.5 * side + front, 0.5 + 0.5 * side + front]
 }
 /// The gain OpenAL applies for distance (`AL_LINEAR_DISTANCE` with reference
@@ -853,16 +883,10 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
    // and OpenAL's right = forward x up.
    let basis = |yaw: f32, pitch: f32| {
        let (yaw, pitch) = (f64::from(yaw.to_radians()), f64::from(pitch.to_radians()));
-        let forward = [
-            -yaw.sin() * pitch.cos(),
-            -pitch.sin(),
-            yaw.cos() * pitch.cos(),
-        ];
-        let up = [
-            -yaw.sin() * pitch.sin(),
-            pitch.cos(),
-            yaw.cos() * pitch.sin(),
-        ];
+        let (yaw_sin, yaw_cos) = yaw.sin_cos();
+        let (pitch_sin, pitch_cos) = pitch.sin_cos();
+        let forward = [-yaw_sin * pitch_cos, -pitch_sin, yaw_cos * pitch_cos];
+        let up = [-yaw_sin * pitch_sin, pitch_cos, yaw_cos * pitch_sin];
        let right = [
            forward[1] * up[2] - forward[2] * up[1],
            forward[2] * up[0] - forward[0] * up[2],
@@ -896,7 +920,7 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
    // Gains and pans per source for this buffer.
    let mut voices = std::mem::take(&mut mixer.voices);
    voices.clear();
-    for (id, c) in &mixer.channels {
+    for (id, c) in &mut mixer.channels {
        let Some((_, source_rate, source_channels)) = &c.samples else {
            continue;
        };
@@ -907,6 +931,7 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        if c.state != State::Playing {
            continue;
        }
+
        let at = [f64::from(c.at[0]), f64::from(c.at[1]), f64::from(c.at[2])];
        let away = |listener: [f64; 3]| {
            [
@@ -915,45 +940,56 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
                at[2] - listener[2],
            ]
        };
-        let length = |d: [f64; 3]| d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
-        // The nearest camera hears it (one camera but in splitscreen).
-        let camera = mixer
-            .cameras
-            .iter()
-            .filter(|camera| c.relative || camera.2 == c.world)
-            .min_by(|a, b| length(away(a.0)).total_cmp(&length(away(b.0))))
-            .map(|camera| (camera.0, camera.1));
-        // Unheard sources still advance: returning to a world must not resume stale sounds.
+        let length_sq = |d: [f64; 3]| d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
+        let camera = if !shared {
+            let cam = &mixer.cameras[0];
+            if c.relative || cam.2 == c.world {
+                Some((cam.0, cam.1))
+            } else {
+                None
+            }
+        } else {
+            mixer
+                .cameras
+                .iter()
+                .filter(|camera| c.relative || camera.2 == c.world)
+                .min_by(|a, b| length_sq(away(a.0)).total_cmp(&length_sq(away(b.0))))
+                .map(|camera| (camera.0, camera.1))
+        };
        let (listener, (forward, up, right)) = camera.unwrap_or(([0.0; 3], basis(0.0, 0.0)));
        let d = if c.relative { at } else { away(listener) };
-        let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt() as f32;
-        let gain = if camera.is_some() {
-            c.gain.clamp(0.0, 1.0)
-                * if direct {
-                    1.0
-                } else {
-                    distance_gain(c.linear, distance)
+        let d_sqr = length_sq(d);
+
+        let (gain, [left, right]) = if camera.is_none() {
+            (0.0, [0.0, 0.0])
+        } else if direct {
+            let gain = c.gain.clamp(0.0, 1.0);
+            (gain, [gain, gain])
+        } else {
+            let mut zero = false;
+            if let Some(max) = c.linear {
+                let max_d = max as f64;
+                if max <= 0.0 || (!c.relative && d_sqr >= max_d * max_d) {
+                    zero = true;
                }
-        } else {
-            0.0
-        };
-        let [left, right] = if direct {
-            [gain, gain]
-        } else {
-            // Relative sources are already in OpenAL's listener space (-Z ahead).
-            let [mut left, mut right] = if c.relative {
-                stereo_gains(d[0] as f32, d[1] as f32, -d[2] as f32)
-            } else {
-                stereo_gains(dot(d, right), dot(d, up), dot(d, forward))
-            };
-            if shared {
-                // Several players on the speakers: half the stereo width, as left and right are
-                // nobody's in particular.
-                let middle = (left + right) / 2.0;
-                left = middle + (left - middle) / 2.0;
-                right = middle + (right - middle) / 2.0;
            }
-            [left * gain, right * gain]
+            if zero {
+                (0.0, [0.0, 0.0])
+            } else {
+                let distance = d_sqr.sqrt() as f32;
+                let gain = c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance);
+                let [mut left, mut right] = if c.relative {
+                    stereo_gains_with_length(d[0] as f32, d[1] as f32, -d[2] as f32, distance)
+                } else {
+                    stereo_gains_with_length(dot(d, right), dot(d, up), dot(d, forward), distance)
+                };
+                if shared {
+                    let middle = (left + right) * 0.5;
+                    left = middle + (left - middle) * 0.5;
+                    right = middle + (right - middle) * 0.5;
+                }
+                (gain, [left * gain, right * gain])
+            }
        };
        let step = f64::from(*source_rate) / f64::from(rate) * f64::from(c.pitch.max(0.0));
        voices.push((*id, [left, right, gain], step));
@@ -974,6 +1010,40 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        };
        let source_channels = source_channels as usize;
        let frames = samples.len() / source_channels;
+        let inaudible = if channels >= 2 {
+            left == 0.0 && right == 0.0
+        } else {
+            gain == 0.0
+        };
+        if inaudible {
+            let buffer_frames = data.len() / channels;
+            // As the loop below: a sound of one frame or none stops, looping or not.
+            if !c.looping || frames <= 1 {
+                // `frames` may be 0: no `frames - 1` in usize. A step of 0 never
+                // reaches the end, as in the loop below.
+                let needed = frames as f64 - 1.0 - c.position;
+                if needed <= 0.0 {
+                    c.state = State::Stopped;
+                } else if step > 0.0 {
+                    let steps_to_stop = needed / step;
+                    if (buffer_frames as f64) >= steps_to_stop {
+                        c.state = State::Stopped;
+                    } else {
+                        c.position += step * (buffer_frames as f64);
+                    }
+                }
+            } else {
+                for _ in 0..buffer_frames {
+                    let i = c.position as usize;
+                    if i + 1 >= frames {
+                        c.position = 0.0;
+                    }
+                    c.position += step;
+                }
+            }
+            continue;
+        }
+
        let out: &mut [f32] = if muffling && !c.unmuffled {
            &mut bus
        } else {
@@ -992,8 +1062,8 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
            }
            let t = (c.position - i as f64) as f32;
            if source_channels > 1 {
-                let l = samples[i * 2] * (1.0 - t) + samples[(i + 1) * 2] * t;
-                let r = samples[i * 2 + 1] * (1.0 - t) + samples[(i + 1) * 2 + 1] * t;
+                let l = samples[i * 2] + (samples[(i + 1) * 2] - samples[i * 2]) * t;
+                let r = samples[i * 2 + 1] + (samples[(i + 1) * 2 + 1] - samples[i * 2 + 1]) * t;
                if channels >= 2 {
                    frame[0] += l * left;
                    frame[1] += r * right;
@@ -1001,7 +1071,7 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
                    frame[0] += (l + r) * 0.5 * gain;
                }
            } else {
-                let s = samples[i] * (1.0 - t) + samples[i + 1] * t;
+                let s = samples[i] + (samples[i + 1] - samples[i]) * t;
                if channels >= 2 {
                    frame[0] += s * left;
                    frame[1] += s * right;
@@ -1412,6 +1482,7 @@ impl Audio {
            record_heard: false,
            listener: [0.0; 3],
            listener_yaw: 0.0,
+            listener_pitch: 0.0,
            master: 1.0,
            random: crate::random_source::create(),
            source_override: None,
@@ -1535,8 +1606,12 @@ impl Audio {
    /// `SoundManager.updateSource`: the camera position and rotation
    /// (`Listener.setTransform` takes its forward and up vectors).
    pub fn set_listener(&mut self, position: [f64; 3], yaw: f32, pitch: f32) {
+        if self.listener == position && self.listener_yaw == yaw && self.listener_pitch == pitch {
+            return;
+        }
        self.listener = position;
        self.listener_yaw = yaw;
+        self.listener_pitch = pitch;
        if let Ok(mut m) = self.backend.mixer.lock() {
            if self.backend.owner == 0 {
                m.listener = position;
@@ -1576,6 +1651,7 @@ impl Audio {
            record_heard: false,
            listener: [0.0; 3],
            listener_yaw: 0.0,
+            listener_pitch: 0.0,
            master: self.master,
            random: crate::random_source::create(),
            source_override: None,
@@ -2109,6 +2185,25 @@ impl Audio {
            })
            .collect()
    }
+    /// Mixes one buffer of audio into `data` (channels: 1 or 2, rate in Hz).
+    pub fn mix_buffer(&mut self, data: &mut [f32], channels: usize, rate: u32) {
+        if let Ok(mut m) = self.backend.mixer.lock() {
+            mix(&mut m, data, channels, rate);
+        }
+    }
+    #[doc(hidden)]
+    pub fn insert_cached_sound(&mut self, key: &str, samples: Vec<f32>, rate: u32, channels: u16) {
+        if let Ok(mut c) = self.backend.cache.lock() {
+            c.insert(
+                key.to_owned(),
+                Some((std::sync::Arc::new(samples), rate, channels)),
+            );
+        }
+    }
+    #[doc(hidden)]
+    pub fn backend_live_for_bench(&mut self) {
+        self.backend.live = true;
+    }
 }
 impl Sounds for Audio {
    fn engine(&mut self) -> &mut SoundEngine {
@@ -2613,6 +2708,25 @@ mod tests {
        assert_eq!(data, [0.0; 4], "returning must not resume the old one-shot");
    }

+    /// A sound of one frame or none, heard or not, looping or not, stops at its first
+    /// buffer as the mixing loop stops it: none stays playing (and holds its channel).
+    #[test]
+    fn sounds_too_short_to_mix_stop_even_unheard() {
+        for (samples, looping) in [(vec![], false), (vec![1.0], false), (vec![1.0], true)] {
+            let mut mixer = Mixer::default();
+            let mut source = channel(samples.clone(), None, [0.0; 3], looping);
+            source.gain = 0.0;
+            mixer.channels.insert(1, source);
+            let mut data = [0.0; 4];
+            mix(&mut mixer, &mut data, 2, 48_000);
+            assert_eq!(
+                mixer.channels[&1].state,
+                State::Stopped,
+                "{samples:?} {looping}"
+            );
+        }
+    }
+
    #[test]
    fn variants_of_one_sound_are_the_same_sound() {
        assert_eq!(
@@ -960,7 +960,7 @@ pub struct Scene<'a> {
    pub world: &'a World,
    pub sprites: &'a HashMap<String, Rect>,
    /// The packs' OptiFine emissive overlays of the sprites.
-    pub emissive: &'a horizon_optifine::emissive::Emissive,
+    pub emissive: &'a crate::entity_textures::Emissive,
    /// Atlas sprites that contain a texel with fractional alpha. Static
    /// geometry stays on the cutout pipeline; these models keep the blended
    /// entity path so resource packs retain their alpha behavior.
@@ -1039,7 +1039,7 @@ impl CacheOptions {
    }
 }
 /// The block-entity models and what is baked from them: vanilla's, or the packs' custom entity
-/// models over them ([`crate::block_entity_cem`]).
+/// models over them ([`crate::pack_hooks::PackFormats::block_entity_models`]).
 #[derive(Default)]
 pub struct BlockEntityShapes {
    models: HashMap<&'static str, ModelPart>,
@@ -1555,7 +1555,7 @@ impl BlockEntityRenderer {
    /// The models the packs under `root` give, their `.jem` files over vanilla's, for
    /// [`Self::set_shapes`] (a pack reload): vanilla's own, shared, without any.
    pub fn shapes_for(&self, root: &Path) -> Arc<BlockEntityShapes> {
-        match crate::block_entity_cem::reshape(root, &self.vanilla.models) {
+        match crate::pack_hooks::formats().block_entity_models(root, &self.vanilla.models) {
            Some((models, textures)) => Arc::new(BlockEntityShapes::new(models, textures)),
            None => self.vanilla.clone(),
        }
@@ -4768,7 +4768,8 @@ mod tests {

    #[test]
    fn a_chest_jem_reshapes_the_closed_chest_and_paints_its_texture() {
-        use crate::block_entity_cem::tests::{BOX, chest, pack};
+        use crate::pack_formats::block_entity_cem::tests::{BOX, chest, pack};
+        crate::pack_formats::install();
        let vanilla = Arc::new(BlockEntityShapes::new(
            HashMap::from([("chest", chest())]),
            HashMap::new(),
@@ -4864,8 +4865,8 @@ mod tests {
        };
        // The chest's three faces become the bottom's, the lock's and the custom lid's six, in
        // the `.jem`'s texture. Ender and copper chests have no file of their own: vanilla's
-        // three faces in their own textures. (Trapped chests: `block_entity_cem`'s tests; their
-        // texture turns festive in late December.)
+        // three faces in their own textures. (Trapped chests: `block_entity_cem`'s tests in
+        // `pack_formats`; their texture turns festive in late December.)
        for (block, texture, u0, faces) in [
            ("chest", "entity/chest/normal", 0.4, 8),
            ("ender_chest", "entity/chest/ender", 0.2, 3),
@@ -1,116 +1,157 @@
-//! OptiFine's Custom Item Textures (and CIT Resewn's): the rules of the enabled packs'
-//! `optifine/cit/**/*.properties`, read from the overlay resource root. The rules themselves are
-//! `horizon_optifine::cit`'s.
+//! Custom item textures: rules a pack format vanilla doesn't read (OptiFine's and CIT Resewn's
+//! `cit/` folders) gives, which change a stack's texture, model, worn armour layers or
+//! enchantment glint. The platform's pack formats read and match them ([`crate::pack_hooks`]);
+//! the engine draws what the matching rule says ([`Rule`]).

-pub use horizon_optifine::cit::{Hand, Kind, Rule};
-
-use crate::cit_glint::{Global, StackGlint};
-use horizon_client_core::component::name_text;
-use horizon_client_core::scoreboard::comp_text;
-use horizon_items::item_data::{canon_tag, encode_components};
-use horizon_items::items::ItemStack;
-use horizon_optifine::cit::{ComponentTest, Source, ValueTest};
-use horizon_optifine::{Properties, properties_files_in};
-use horizon_world::nbt::{JavaString, Tag, parse_snbt};
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::fs;
-use std::hash::{DefaultHasher, Hash, Hasher};
 use std::path::Path;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;

-/// Every rule under the root's `optifine/cit/`, `mcpatcher/cit/` and CIT Resewn's
-/// `citresewn/cit/` folders, the one chosen first when several match first (`Rule::priority`).
-/// The pack's global `cit.properties` is not a rule.
-pub fn load_rules(root: &Path) -> Vec<Rule> {
-    let tops = ["optifine", "mcpatcher", "citresewn"];
-    let mut rules: Vec<Rule> = properties_files_in(root, &tops, "cit")
-        .into_iter()
-        .filter(|path| !path.ends_with("/cit.properties"))
-        .filter_map(|path| {
-            let props = read_properties(&root.join(&path))?;
-            let rule = Rule::parse(&path, &props, |p| root.join(p).is_file());
-            if rule.is_none() {
-                log::warn!("custom item textures: {path} is not a rule Horizon can read");
-            }
-            rule
-        })
-        .collect();
-    rules.sort_by(Rule::priority);
-    rules
+use horizon_items::items::ItemStack;
+
+use crate::cit_glint::StackGlint;
+
+/// What a rule changes.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+    Item,
+    Armor,
+    Elytra,
+    Enchantment,
 }

-/// A `.properties` file as CIT Resewn reads them (`Properties::parse_equals_first`): UTF-8,
-/// else Latin-1 as Java reads them, so a pack saved that way still loads. `None` when it can't
-/// be read.
-pub fn read_properties(path: &Path) -> Option<Properties> {
-    let bytes = fs::read(path).ok()?;
-    let text = String::from_utf8(bytes)
-        .unwrap_or_else(|e| e.into_bytes().iter().map(|&b| char::from(b)).collect());
-    Some(Properties::parse_equals_first(&text))
+/// The hand a stack is drawn in; GUI items count as the main hand. `Any` is a rule's "either".
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Hand {
+    Any,
+    Main,
+    Off,
 }

-/// The rules with an index by item and a cache of what each stack matched.
-#[derive(Debug, Default)]
+/// An OpenGL blend factor (`GL_ONE`, `GL_SRC_ALPHA`...), as `glBlendFuncSeparate` takes them.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Factor {
+    Zero,
+    One,
+    SrcColor,
+    OneMinusSrcColor,
+    SrcAlpha,
+    OneMinusSrcAlpha,
+    DstAlpha,
+    OneMinusDstAlpha,
+    DstColor,
+    OneMinusDstColor,
+    SrcAlphaSaturate,
+}
+
+/// A glint layer's blend factors for colour and alpha.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Blend {
+    pub src: Factor,
+    pub dst: Factor,
+    pub src_alpha: Factor,
+    pub dst_alpha: Factor,
+}
+
+/// An enchantment rule's glint layer.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Glint {
+    pub layer: i32,
+    /// `None` draws without blending (replace).
+    pub blend: Option<Blend>,
+    /// Scroll speed: the texture runs through vanilla's glint periods at `speed` times the
+    /// clock in milliseconds.
+    pub speed: f32,
+    /// Degrees the texture turns by.
+    pub rotation: f32,
+    /// Seconds on this layer when the layers take turns.
+    pub duration: f32,
+    /// Multipliers of the texture's colour, never negative.
+    pub rgba: [f32; 4],
+    /// Whether the default glint still draws under this layer.
+    pub use_glint: bool,
+    /// Linear filtering, else nearest.
+    pub blur: bool,
+}
+
+/// A rule as the engine draws it.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Rule {
+    /// The rule's file, as a resource path.
+    pub path: String,
+    pub kind: Kind,
+    /// Its texture, as a resource path to a `.png`.
+    pub texture: Option<String>,
+    /// Its named textures: (name, resource path).
+    pub textures: Vec<(String, String)>,
+    /// Its model, as a resource path to a `.json`.
+    pub model: Option<String>,
+    /// Its named models.
+    pub models: Vec<(String, String)>,
+    /// What an Enchantment rule draws.
+    pub glint: Glint,
+}
+
+/// Which rules a stack matches: the pack format's own conditions.
+pub trait Matcher: Send + Sync {
+    /// The winning rule of `kind` (Item, Armor or Elytra) for this stack, as an index into
+    /// [`CitRules::rules`].
+    fn select(&self, kind: Kind, stack: &ItemStack, hand: Hand, max_damage: u32) -> Option<usize>;
+    /// Every matching Enchantment rule for the stack drawn in `hand`, in priority order.
+    fn enchantments(&self, stack: &ItemStack, hand: Hand, max_damage: u32) -> Vec<usize>;
+    /// The glint layers this stack draws in `hand`; `None` when the pack changes no glint.
+    /// `foil` is whether the stack draws a glint at all.
+    fn glint(
+        &self,
+        stack: &ItemStack,
+        hand: Hand,
+        max_damage: u32,
+        foil: bool,
+    ) -> Option<Arc<StackGlint>>;
+    /// Leave out the Enchantment rules `keep` refuses: they match no stack.
+    fn keep_glints(&mut self, keep: &dyn Fn(usize) -> bool);
+}
+
+/// The packs' custom item texture rules, the winner first, and their matcher.
 pub struct CitRules {
    pub rules: Vec<Rule>,
-    /// The pack's `cit.properties`.
-    pub global: Global,
-    /// Per kind (`Kind as usize`), the rules naming each item, in priority order.
-    by_item: [HashMap<String, Vec<u32>>; 4],
-    /// Enchantment rules without `items`, in priority order.
-    any_item: Vec<u32>,
-    /// Per rule, per component test: its literal read as SNBT and as a JSON text component.
-    literals: Vec<Vec<Prepared>>,
-    selected: Mutex<HashMap<u64, Option<u32>>>,
-    enchanted: Mutex<HashMap<u64, Vec<u32>>>,
-    glints: Mutex<HashMap<u64, Arc<StackGlint>>>,
+    /// Whether the default glint draws on items no enchantment rule matches.
+    pub use_glint: bool,
+    matcher: Option<Box<dyn Matcher>>,
 }

-#[derive(Debug, Default)]
-struct Prepared {
-    snbt: Option<Tag>,
-    json: Option<String>,
-}
-
-/// Cache entries kept before the cache starts over.
-const CACHE_LIMIT: usize = 4096;
-
-impl CitRules {
-    /// The enabled packs' rules under the overlay resource root.
-    pub fn load(root: &Path) -> Self {
+impl Default for CitRules {
+    fn default() -> Self {
        Self {
-            global: crate::cit_glint::load_global(root),
-            ..Self::new(load_rules(root))
+            rules: Vec::new(),
+            use_glint: true,
+            matcher: None,
        }
    }
+}

-    /// `rules` in priority order, the winner first.
-    pub fn new(rules: Vec<Rule>) -> Self {
-        let mut by_item: [HashMap<String, Vec<u32>>; 4] = Default::default();
-        let mut any_item = Vec::new();
-        for (i, rule) in rules.iter().enumerate() {
-            let i = i as u32;
-            if rule.kind == Kind::Enchantment && rule.items.is_empty() {
-                any_item.push(i);
-            }
-            for item in &rule.items {
-                let list = by_item[rule.kind as usize].entry(item.clone()).or_default();
-                if list.last() != Some(&i) {
-                    list.push(i);
-                }
-            }
-        }
-        let literals = rules
-            .iter()
-            .map(|r| r.components.iter().map(prepare).collect())
-            .collect();
+impl std::fmt::Debug for CitRules {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CitRules")
+            .field("rules", &self.rules)
+            .field("use_glint", &self.use_glint)
+            .finish_non_exhaustive()
+    }
+}
+
+impl CitRules {
+    /// The rules of the overlay at `root`, from the installed pack formats.
+    pub fn load(root: &Path) -> Self {
+        crate::pack_hooks::formats()
+            .item_textures(root)
+            .unwrap_or_default()
+    }
+
+    /// `rules`, in priority order, matched by `matcher`.
+    pub fn new(rules: Vec<Rule>, use_glint: bool, matcher: Box<dyn Matcher>) -> Self {
        Self {
            rules,
-            by_item,
-            any_item,
-            literals,
-            ..Default::default()
+            use_glint,
+            matcher: Some(matcher),
        }
    }

@@ -121,17 +162,12 @@ impl CitRules {
    /// Leave out the Enchantment rules `keep` refuses (those without a drawable texture): they
    /// match no stack, so vanilla's glint and the other rules of their layer stay.
    pub fn keep_glints(&mut self, keep: impl Fn(usize) -> bool) {
-        self.any_item.retain(|&i| keep(i as usize));
-        let named = &mut self.by_item[Kind::Enchantment as usize];
-        for list in named.values_mut() {
-            list.retain(|&i| keep(i as usize));
+        if let Some(matcher) = &mut self.matcher {
+            matcher.keep_glints(&keep);
        }
-        named.retain(|_, list| !list.is_empty());
-        lock(&self.enchanted).clear();
-        lock(&self.glints).clear();
    }

-    /// The winning rule of `kind` (Item, Armor or Elytra) for this stack, as an index into `rules`.
+    /// [`Matcher::select`].
    pub fn select(
        &self,
        kind: Kind,
@@ -139,51 +175,17 @@ impl CitRules {
        hand: Hand,
        max_damage: u32,
    ) -> Option<usize> {
-        let candidates = self.by_item[kind as usize].get(&*stack.item)?;
-        let comps = encode_components(stack);
-        let key = cache_key((0, kind, hand), stack, max_damage, comps.as_ref());
-        if let Some(hit) = lock(&self.selected).get(&key) {
-            return hit.map(|i| i as usize);
-        }
-        let found = candidates
-            .iter()
-            .copied()
-            .find(|&i| self.matches(i, stack, hand, max_damage, comps.as_ref()));
-        remember(&self.selected, key, found);
-        found.map(|i| i as usize)
+        self.matcher.as_ref()?.select(kind, stack, hand, max_damage)
    }

-    /// Every matching Enchantment rule for the stack drawn in `hand` (`Hand::Main` for one in a
-    /// GUI), in priority order.
+    /// [`Matcher::enchantments`].
    pub fn enchantments(&self, stack: &ItemStack, hand: Hand, max_damage: u32) -> Vec<usize> {
-        let named = self.by_item[Kind::Enchantment as usize]
-            .get(&*stack.item)
-            .map_or(&[][..], Vec::as_slice);
-        if named.is_empty() && self.any_item.is_empty() {
-            return Vec::new();
-        }
-        let comps = encode_components(stack);
-        let key = cache_key(
-            (1, Kind::Enchantment, hand),
-            stack,
-            max_damage,
-            comps.as_ref(),
-        );
-        let hit = lock(&self.enchanted).get(&key).cloned();
-        let found = hit.unwrap_or_else(|| {
-            let mut all: Vec<u32> = named.iter().chain(&self.any_item).copied().collect();
-            all.sort_unstable();
-            all.retain(|&i| self.matches(i, stack, hand, max_damage, comps.as_ref()));
-            remember(&self.enchanted, key, all.clone());
-            all
-        });
-        found.into_iter().map(|i| i as usize).collect()
+        self.matcher
+            .as_ref()
+            .map_or_else(Vec::new, |m| m.enchantments(stack, hand, max_damage))
    }

-    /// The glint layers this stack draws in `hand` (`Hand::Main` in a GUI) and whether
-    /// vanilla's still does (`StackGlint`), worked out once per stack and hand; `None` when the
-    /// pack changes no glint. `foil` is whether the stack draws a glint at all
-    /// (`ItemStack::has_foil`): one that doesn't gets no layers.
+    /// [`Matcher::glint`].
    pub fn glint(
        &self,
        stack: &ItemStack,
@@ -191,659 +193,6 @@ impl CitRules {
        max_damage: u32,
        foil: bool,
    ) -> Option<Arc<StackGlint>> {
-        let no_rules =
-            self.any_item.is_empty() && self.by_item[Kind::Enchantment as usize].is_empty();
-        // Before the cache, which `foil` is not part of.
-        if !foil || (no_rules && self.global.use_glint) {
-            return None;
-        }
-        let comps = encode_components(stack);
-        let key = cache_key(
-            (2, Kind::Enchantment, hand),
-            stack,
-            max_damage,
-            comps.as_ref(),
-        );
-        if let Some(hit) = lock(&self.glints).get(&key) {
-            return Some(hit.clone());
-        }
-        let matched = self.enchantments(stack, hand, max_damage);
-        let glint = Arc::new(StackGlint::new(
-            &self.rules,
-            &matched,
-            stack.crafting_enchantments(),
-            &self.global,
-        ));
-        remember(&self.glints, key, glint.clone());
-        Some(glint)
-    }
-
-    /// Whether rule `i` matches the stack drawn in `hand`.
-    fn matches(
-        &self,
-        i: u32,
-        stack: &ItemStack,
-        hand: Hand,
-        max_damage: u32,
-        comps: Option<&Tag>,
-    ) -> bool {
-        let rule = &self.rules[i as usize];
-        if rule.hand != Hand::Any && rule.hand != hand {
-            return false;
-        }
-        let count = i32::try_from(stack.count).unwrap_or(i32::MAX);
-        if rule.stack_size.as_ref().is_some_and(|r| !r.contains(count)) {
-            return false;
-        }
-        // CIT Resewn: only damageable items have damage.
-        let damage = if max_damage > 0 { stack.damage } else { 0 };
-        if rule
-            .damage
-            .as_ref()
-            .is_some_and(|d| !d.matches(damage, max_damage))
-        {
-            return false;
-        }
-        let enchantments = stack.crafting_enchantments();
-        let listed = |id: &str| rule.enchantments.iter().any(|e| e == id);
-        if !rule.enchantments.is_empty() && !enchantments.iter().any(|(id, _)| listed(id)) {
-            return false;
-        }
-        if let Some(levels) = &rule.enchantment_levels {
-            let level_in_range = enchantments.iter().any(|(id, level)| {
-                (rule.enchantments.is_empty() || listed(id))
-                    && levels.contains(i32::try_from(*level).unwrap_or(i32::MAX))
-            });
-            if !level_in_range {
-                return false;
-            }
-        }
-        let literals = &self.literals[i as usize];
-        rule.components
-            .iter()
-            .zip(literals)
-            .all(|(test, lit)| component_test(test, lit, stack, comps) != test.negate)
-    }
-}
-
-fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
-    m.lock().unwrap_or_else(|e| e.into_inner())
-}
-
-fn remember<V>(cache: &Mutex<HashMap<u64, V>>, key: u64, value: V) {
-    let mut cache = lock(cache);
-    if cache.len() >= CACHE_LIMIT {
-        cache.clear();
-    }
-    cache.insert(key, value);
-}
-
-/// What a cached answer depends on; `query` tells `select`, `enchantments` and `glint` apart.
-fn cache_key(query: (u8, Kind, Hand), stack: &ItemStack, max: u32, comps: Option<&Tag>) -> u64 {
-    let mut h = DefaultHasher::new();
-    (query.0, query.1 as u8, query.2 as u8, &*stack.item).hash(&mut h);
-    (stack.count, stack.damage, max, comps).hash(&mut h);
-    h.finish()
-}
-
-fn prepare(test: &ComponentTest) -> Prepared {
-    let ValueTest::Literal(lit) = &test.value else {
-        return Prepared::default();
-    };
-    let text = lit.text.trim();
-    let snbt = match parse_snbt(text) {
-        Ok((tag, read)) if read == text.len() && text.starts_with(['{', '[']) => Some(tag),
-        _ => None,
-    };
-    let json = json_plain(text);
-    Prepared { snbt, json }
-}
-
-/// The plain text of `s` read as a JSON text component.
-fn json_plain(s: &str) -> Option<String> {
-    if !s.starts_with(['{', '[', '"']) {
-        return None;
-    }
-    let value: serde_json::Value = serde_json::from_str(s).ok()?;
-    Some(comp_text(&value).plain())
-}
-
-/// Whether one test passes, before its `negate`.
-fn component_test(
-    test: &ComponentTest,
-    lit: &Prepared,
-    stack: &ItemStack,
-    comps: Option<&Tag>,
-) -> bool {
-    let legacy;
-    let (root, text_depth) = match &test.source {
-        Source::Component(id) => {
-            let depth = match id.as_str() {
-                "minecraft:custom_name" | "minecraft:item_name" => Some(0),
-                "minecraft:lore" => Some(1),
-                _ => None,
-            };
-            (comps.and_then(|c| c.get(id)), depth)
-        }
-        Source::LegacyEnchantments { stored } => {
-            let levels = if *stored {
-                stack.stored_enchantments()
-            } else {
-                stack.enchantments()
-            };
-            legacy = Tag::List(
-                levels
-                    .iter()
-                    .map(|(id, lvl)| {
-                        let lvl = i16::try_from(*lvl).unwrap_or(i16::MAX);
-                        Tag::compound([
-                            ("id", Tag::String((&**id).into())),
-                            ("lvl", Tag::Short(lvl)),
-                        ])
-                    })
-                    .collect(),
-            );
-            (Some(&legacy), None)
-        }
-    };
-    // Fields the component leaves out when 0, which pre-1.20.5 items always wrote.
-    let defaulted;
-    let root = match (&test.source, root, test.path.first()) {
-        (Source::Component(id), Some(Tag::Compound(map)), Some(field))
-            if matches!(
-                (id.as_str(), field.as_str()),
-                ("minecraft:written_book_content", "generation")
-                    | ("minecraft:fireworks", "flight_duration")
-            ) && !map.contains_key(&JavaString::from(field.as_str())) =>
-        {
-            let mut map = map.clone();
-            map.insert(JavaString::from(field.as_str()), Tag::Int(0));
-            defaulted = Tag::Compound(map);
-            Some(&defaulted)
-        }
-        (_, root, _) => root,
-    };
-    let Some(root) = root else {
-        return matches!(test.value, ValueTest::Exists(false));
-    };
-    if let ValueTest::Exists(want) = test.value {
-        return walk(root, &test.path, 0, &mut |_, _| true) == want;
-    }
-    walk(root, &test.path, 0, &mut |tag, depth| {
-        value_test(&test.value, lit, tag, text_depth == Some(depth))
-    })
-}
-
-/// Visits what `path` reaches from `tag`, true once `visit` is.
-fn walk(
-    tag: &Tag,
-    path: &[String],
-    depth: usize,
-    visit: &mut dyn FnMut(&Tag, usize) -> bool,
-) -> bool {
-    let Some((seg, rest)) = path.split_first() else {
-        return visit(tag, depth);
-    };
-    let mut next = |t: &Tag| walk(t, rest, depth + 1, visit);
-    let len = match tag {
-        Tag::Compound(map) if seg == "*" => return map.values().any(&mut next),
-        Tag::Compound(map) => return map.get(&JavaString::from(seg.as_str())).is_some_and(next),
-        Tag::List(v) => v.len(),
-        Tag::ByteArray(v) => v.len(),
-        Tag::IntArray(v) => v.len(),
-        Tag::LongArray(v) => v.len(),
-        _ => return false,
-    };
-    let element = |i: usize| match tag {
-        Tag::List(v) => Cow::Borrowed(&v[i]),
-        Tag::ByteArray(v) => Cow::Owned(Tag::Byte(v[i] as i8)),
-        Tag::IntArray(v) => Cow::Owned(Tag::Int(v[i])),
-        Tag::LongArray(v) => Cow::Owned(Tag::Long(v[i])),
-        _ => Cow::Owned(Tag::End),
-    };
-    if seg == "count" {
-        return next(&Tag::Int(i32::try_from(len).unwrap_or(i32::MAX)));
-    }
-    if seg == "*" {
-        return (0..len).any(|i| next(&element(i)));
-    }
-    seg.parse::<usize>()
-        .ok()
-        .filter(|&i| i < len)
-        .is_some_and(|i| next(&element(i)))
-}
-
-fn int_value(tag: &Tag) -> Option<i64> {
-    match *tag {
-        Tag::Byte(v) => Some(v.into()),
-        Tag::Short(v) => Some(v.into()),
-        Tag::Int(v) => Some(v.into()),
-        Tag::Long(v) => Some(v),
-        _ => None,
-    }
-}
-
-/// A number as Java's `String.valueOf` writes it (`3`, `3.0`).
-fn decimal(tag: &Tag) -> Option<String> {
-    let s = match *tag {
-        Tag::Float(b) => f32::from_bits(b).to_string(),
-        Tag::Double(b) => f64::from_bits(b).to_string(),
-        _ => return int_value(tag).map(|v| v.to_string()),
-    };
-    Some(if s.contains(['.', 'e', 'N', 'i']) {
-        s
-    } else {
-        s + ".0"
-    })
-}
-
-/// `text` against a string, its JSON text, or the plain text of a text component.
-fn text_matches(tag: &Tag, is_text: bool, text: impl Fn(&str) -> bool) -> bool {
-    match tag {
-        Tag::String(s) => {
-            let s = s.to_string_lossy();
-            text(&s)
-                || (is_text && text(&name_text(tag).plain()))
-                || json_plain(&s).is_some_and(|p| text(&p))
-        }
-        Tag::Compound(_) | Tag::List(_) => is_text && text(&name_text(tag).plain()),
-        _ => false,
-    }
-}
-
-fn value_test(test: &ValueTest, lit: &Prepared, tag: &Tag, is_text: bool) -> bool {
-    match test {
-        ValueTest::Exists(_) => true,
-        ValueTest::Range(r) => {
-            int_value(tag).is_some_and(|v| i32::try_from(v).is_ok_and(|v| r.contains(v)))
-        }
-        ValueTest::Raw(name) => name.matches(&canon_tag(tag)),
-        ValueTest::Text(name) => match decimal(tag) {
-            Some(n) => name.matches(&n),
-            None => text_matches(tag, is_text, |s| name.matches(s)),
-        },
-        ValueTest::Literal(l) => match tag {
-            Tag::Float(b) => l.text.trim().parse::<f32>().ok() == Some(f32::from_bits(*b)),
-            Tag::Double(b) => l.float == Some(f64::from_bits(*b)),
-            Tag::Compound(_) | Tag::List(_)
-                if lit.snbt.as_ref().is_some_and(|e| contains(e, tag)) =>
-            {
-                true
-            }
-            _ => match int_value(tag) {
-                Some(v) => l.int == Some(v),
-                None => text_matches(tag, is_text, |s| {
-                    s == l.text || lit.json.as_deref() == Some(s)
-                }),
-            },
-        },
-    }
-}
-
-/// `NbtUtils.compareNbt(expected, actual, true)`: every key and element of `expected` found in
-/// `actual`.
-fn contains(expected: &Tag, actual: &Tag) -> bool {
-    match (expected, actual) {
-        (Tag::Compound(e), Tag::Compound(a)) => e
-            .iter()
-            .all(|(k, v)| a.get(k).is_some_and(|a| contains(v, a))),
-        (Tag::List(e), Tag::List(a)) if e.is_empty() => a.is_empty(),
-        (Tag::List(e), Tag::List(a)) => e.iter().all(|e| a.iter().any(|a| contains(e, a))),
-        _ => expected == actual,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::sync::Arc;
-
-    /// Rules from (file stem, properties), sorted as `load_rules` sorts them.
-    fn rules(files: &[(&str, &str)]) -> CitRules {
-        let mut rules: Vec<Rule> = files
-            .iter()
-            .map(|(stem, text)| {
-                let path = format!("assets/minecraft/optifine/cit/{stem}.properties");
-                let text = format!("texture=x\n{text}");
-                Rule::parse(&path, &Properties::parse_equals_first(&text), |_| true).unwrap()
-            })
-            .collect();
-        rules.sort_by(Rule::priority);
-        CitRules::new(rules)
-    }
-
-    fn stem(cit: &CitRules, i: Option<usize>) -> Option<&str> {
-        let path = &cit.rules[i?].path;
-        path.rsplit('/').next()?.strip_suffix(".properties")
-    }
-
-    fn item(cit: &CitRules, stack: ItemStack) -> Option<&str> {
-        stem(cit, cit.select(Kind::Item, &stack, Hand::Main, 0))
-    }
-
-    fn new(id: &str) -> ItemStack {
-        ItemStack::new(&format!("minecraft:{id}"), 1)
-    }
-
-    fn string(s: &str) -> Tag {
-        Tag::String(s.into())
-    }
-
-    fn with(id: &str, component: &str, tag: Tag) -> ItemStack {
-        let mut stack = new(id);
-        let component = format!("minecraft:{component}");
-        stack.data_mut().other.push((component, tag));
-        stack
-    }
-
-    fn enchanted(id: &str, levels: &[(&str, u32)]) -> ItemStack {
-        let mut stack = new(id);
-        let levels = levels
-            .iter()
-            .map(|(e, l)| (Arc::from(format!("minecraft:{e}")), *l));
-        stack.data_mut().enchantments = levels.collect();
-        stack
-    }
-
-    #[test]
-    fn heavier_rules_win_and_kinds_stay_apart() {
-        let cit = rules(&[
-            ("plain", "items=stick"),
-            ("heavy", "items=stick\nweight=2\nstackSize=2-"),
-            ("offhand", "items=stick\nweight=5\nhand=off"),
-            ("armor", "type=armor\nitems=stick"),
-            ("wings", "type=elytra"),
-        ]);
-        assert_eq!(item(&cit, new("stick")), Some("plain"));
-        assert_eq!(
-            item(&cit, ItemStack::new("minecraft:stick", 3)),
-            Some("heavy")
-        );
-        let pick = |kind, id, hand, max| stem(&cit, cit.select(kind, &new(id), hand, max));
-        assert_eq!(pick(Kind::Item, "stick", Hand::Off, 0), Some("offhand"));
-        assert_eq!(item(&cit, new("stone")), None);
-        assert_eq!(item(&cit, new("elytra")), None);
-        assert_eq!(pick(Kind::Elytra, "elytra", Hand::Main, 432), Some("wings"));
-        assert_eq!(pick(Kind::Armor, "stick", Hand::Main, 0), Some("armor"));
-    }
-
-    #[test]
-    fn names_match_by_their_plain_text() {
-        let cit = rules(&[
-            ("glob", "items=stick\nnbt.display.Name=ipattern:*sword"),
-            ("exact", "items=stone\ncomponents.custom_name=My Sword"),
-            ("json", "items=dirt\nnbt.display.Name=[\"My \",\"Sword\"]"),
-        ]);
-        let named = |id: &str, name: Tag| {
-            let mut stack = new(id);
-            stack.data_mut().custom_name = Some(name);
-            stack
-        };
-        let styled = Tag::compound([("text", string("My Sword")), ("color", string("red"))]);
-        assert_eq!(item(&cit, named("stick", styled.clone())), Some("glob"));
-        assert_eq!(item(&cit, named("stick", string("Blade"))), None);
-        assert_eq!(item(&cit, new("stick")), None);
-        assert_eq!(item(&cit, named("stone", styled.clone())), Some("exact"));
-        assert_eq!(item(&cit, named("dirt", styled)), Some("json"));
-    }
-
-    #[test]
-    fn lore_lines_and_list_counts() {
-        let cit = rules(&[
-            (
-                "any_line",
-                "items=stick\nnbt.display.Lore.*=ipattern:*legendary*",
-            ),
-            ("two_lines", "items=stone\ncomponents.lore.count=2"),
-        ]);
-        let bold = Tag::compound([("text", string("A LEGENDARY item")), ("bold", Tag::Byte(1))]);
-        let lore = Tag::List(vec![string("Common"), bold]);
-        assert_eq!(
-            item(&cit, with("stick", "lore", lore.clone())),
-            Some("any_line")
-        );
-        assert_eq!(item(&cit, with("stone", "lore", lore)), Some("two_lines"));
-        let one = Tag::List(vec![string("A legendary item")]);
-        assert_eq!(item(&cit, with("stone", "lore", one)), None);
-    }
-
-    #[test]
-    fn custom_data_existence_and_negation() {
-        let cit = rules(&[
-            (
-                "aote",
-                "items=stick\nweight=2\nnbt.ExtraAttributes.id=ASPECT_OF_THE_END",
-            ),
-            (
-                "not_hyp",
-                "items=stick\nweight=1\ncomponent.custom_data.ExtraAttributes.id=!HYP",
-            ),
-            ("unnamed", "items=stick\nnbt.display.Name=exists:false"),
-        ]);
-        let data = |id: &str| {
-            let attributes =
-                Tag::compound([("ExtraAttributes", Tag::compound([("id", string(id))]))]);
-            with("stick", "custom_data", attributes)
-        };
-        assert_eq!(item(&cit, data("ASPECT_OF_THE_END")), Some("aote"));
-        assert_eq!(item(&cit, data("MIDAS")), Some("not_hyp"));
-        assert_eq!(item(&cit, data("HYP")), Some("unnamed"));
-        let mut named = data("HYP");
-        named.data_mut().custom_name = Some(string("Hyperion"));
-        assert_eq!(item(&cit, named), None);
-    }
-
-    #[test]
-    fn legacy_enchantment_lists_and_model_data() {
-        let cit = rules(&[
-            (
-                "sharp",
-                "items=stick\nnbt.Enchantments.*.id=minecraft:sharpness\nnbt.Enchantments.0.lvl=5",
-            ),
-            ("cmd", "items=stone\nnbt.CustomModelData=3"),
-            (
-                "cmd_snbt",
-                "items=dirt\ncomponents.custom_model_data={floats:[3.0f]}",
-            ),
-        ]);
-        assert_eq!(
-            item(&cit, enchanted("stick", &[("sharpness", 5)])),
-            Some("sharp")
-        );
-        assert_eq!(item(&cit, enchanted("stick", &[("sharpness", 4)])), None);
-        let model = |id: &str, f: f32| {
-            let floats = Tag::List(vec![Tag::Float(f.to_bits()), Tag::Float(7f32.to_bits())]);
-            with(id, "custom_model_data", Tag::compound([("floats", floats)]))
-        };
-        assert_eq!(item(&cit, model("stone", 3.0)), Some("cmd"));
-        assert_eq!(item(&cit, model("stone", 3.5)), None);
-        assert_eq!(item(&cit, model("dirt", 3.0)), Some("cmd_snbt"));
-        assert_eq!(item(&cit, model("dirt", 2.0)), None);
-    }
-
-    #[test]
-    fn fields_left_out_at_zero_read_as_zero() {
-        let cit = rules(&[("zero", "items=firework_rocket\nnbt.Fireworks.Flight=0")]);
-        let mut rocket = new("firework_rocket");
-        rocket.data_mut().fireworks = Some((0, Vec::new()));
-        assert_eq!(item(&cit, rocket.clone()), Some("zero"));
-        rocket.data_mut().fireworks = Some((2, Vec::new()));
-        assert_eq!(item(&cit, rocket), None);
-    }
-
-    #[test]
-    fn damage_counts_only_for_damageable_items() {
-        let cit = rules(&[
-            ("worn", "items=diamond_sword\ndamage=50-100%"),
-            ("new", "items=stick\ndamage=0"),
-        ]);
-        let damaged = |id: &str, damage: u32, max: u32| {
-            let mut stack = new(id);
-            stack.damage = damage;
-            stem(&cit, cit.select(Kind::Item, &stack, Hand::Main, max))
-        };
-        // Half of 1561 is 780.5.
-        assert_eq!(damaged("diamond_sword", 780, 1561), None);
-        assert_eq!(damaged("diamond_sword", 781, 1561), Some("worn"));
-        assert_eq!(damaged("stick", 5, 0), Some("new"));
-    }
-
-    #[test]
-    fn enchantment_levels_and_rules_for_any_item() {
-        let cit = rules(&[
-            (
-                "sharp3",
-                "items=stick\nenchantments=sharpness\nenchantmentLevels=3-",
-            ),
-            ("any3", "items=stone\nenchantmentLevels=3-"),
-            ("glint", "type=enchantment\nenchantments=sharpness"),
-            (
-                "sword_glint",
-                "type=enchantment\nitems=diamond_sword\nweight=2",
-            ),
-        ]);
-        let mixed = [("sharpness", 2), ("unbreaking", 3)];
-        assert_eq!(item(&cit, enchanted("stick", &mixed)), None);
-        assert_eq!(
-            item(&cit, enchanted("stick", &[("sharpness", 4)])),
-            Some("sharp3")
-        );
-        assert_eq!(item(&cit, enchanted("stone", &mixed)), Some("any3"));
-        let glints = |stack: ItemStack| -> Vec<&str> {
-            let found = cit.enchantments(&stack, Hand::Main, 0).into_iter();
-            found.map(|i| stem(&cit, Some(i)).unwrap()).collect()
-        };
-        let sharp = [("sharpness", 1)];
-        assert_eq!(
-            glints(enchanted("diamond_sword", &sharp)),
-            ["sword_glint", "glint"]
-        );
-        assert_eq!(glints(enchanted("stick", &sharp)), ["glint"]);
-        assert!(glints(new("stick")).is_empty());
-        // Glints are never an item's texture.
-        assert_eq!(item(&cit, enchanted("diamond_sword", &sharp)), None);
-    }
-
-    /// `CitRules::glint` in the main hand, with the stack's own `has_foil` as callers pass it.
-    fn glint(cit: &CitRules, stack: &ItemStack, item_glint: bool) -> Option<Arc<StackGlint>> {
-        cit.glint(stack, Hand::Main, 0, stack.has_foil(item_glint))
-    }
-
-    /// `stack` with its `enchantment_glint_override` set to `on`.
-    fn overridden(mut stack: ItemStack, on: bool) -> ItemStack {
-        let flag = (
-            "minecraft:enchantment_glint_override".to_owned(),
-            Tag::Byte(on.into()),
-        );
-        stack.data_mut().other.push(flag);
-        stack
-    }
-
-    #[test]
-    fn a_stack_glint_reads_the_book_and_the_pack_file() {
-        let mut cit = rules(&[
-            ("sharp", "type=enchantment\nenchantments=sharpness"),
-            (
-                "keep",
-                "type=enchantment\nlayer=1\nuseGlint=true\nenchantments=mending",
-            ),
-        ]);
-        // An enchanted book's glint follows its stored enchantments.
-        let mut book = new("enchanted_book");
-        book.data_mut().stored_enchantments = vec![
-            (Arc::from("minecraft:sharpness"), 3),
-            (Arc::from("minecraft:mending"), 1),
-        ];
-        let book = glint(&cit, &book, true).unwrap();
-        let weights: Vec<_> = book.layers.iter().map(|l| l.weight).collect();
-        assert_eq!(weights, [0.75, 0.25]);
-        assert!(book.vanilla);
-        let plain = glint(&cit, &enchanted("stick", &[("sharpness", 1)]), false).unwrap();
-        assert_eq!(plain.layers.len(), 1);
-        assert!(!plain.vanilla);
-        // No enchantment rules: nothing changes, unless the pack turns vanilla's glint off.
-        let mut bare = rules(&[("stick", "items=stick")]);
-        assert!(glint(&bare, &overridden(new("stick"), true), false).is_none());
-        bare.global.use_glint = false;
-        assert!(
-            !glint(&bare, &overridden(new("stick"), true), false)
-                .unwrap()
-                .vanilla
-        );
-        cit.global.use_glint = false;
-        assert!(
-            glint(&cit, &overridden(new("stick"), true), false)
-                .unwrap()
-                .is_empty()
-        );
-    }
-
-    #[test]
-    fn only_a_stack_with_a_glint_gets_layers() {
-        let cit = rules(&[("any", "type=enchantment")]);
-        assert!(glint(&cit, &new("stick"), false).is_none());
-        // The override turns an enchanted stack's glint off, and an unenchanted one's on.
-        let off = overridden(enchanted("stick", &[("sharpness", 1)]), false);
-        assert!(glint(&cit, &off, false).is_none());
-        let on = glint(&cit, &overridden(new("stick"), true), false).unwrap();
-        let weights: Vec<_> = on.layers.iter().map(|l| l.weight).collect();
-        assert_eq!(
-            weights,
-            [1.0],
-            "nothing to share: the rule at full strength"
-        );
-        // The same stack, asked again without its glint, is not answered from the cache.
-        assert!(
-            cit.glint(&overridden(new("stick"), true), Hand::Main, 0, false)
-                .is_none()
-        );
-    }
-
-    #[test]
-    fn a_rule_left_out_of_the_glints_matches_nothing() {
-        let mut cit = rules(&[
-            ("broken", "type=enchantment\nitems=diamond_sword\nweight=1"),
-            ("shown", "type=enchantment"),
-        ]);
-        let sword = enchanted("diamond_sword", &[("sharpness", 1)]);
-        let layers = |cit: &CitRules| -> Vec<String> {
-            let glint = glint(cit, &sword, false).unwrap();
-            let stems = glint
-                .layers
-                .iter()
-                .map(|l| stem(cit, Some(l.rule)).unwrap());
-            stems.map(str::to_owned).collect()
-        };
-        // The heavier rule wins the layer, until its texture is missing.
-        assert_eq!(layers(&cit), ["broken"]);
-        let broken = (0..cit.rules.len())
-            .find(|&i| stem(&cit, Some(i)) == Some("broken"))
-            .unwrap();
-        cit.keep_glints(|i| i != broken);
-        assert_eq!(layers(&cit), ["shown"]);
-        assert_eq!(cit.enchantments(&sword, Hand::Main, 0).len(), 1);
-        // None left: vanilla's glint stays.
-        cit.keep_glints(|_| false);
-        assert!(glint(&cit, &sword, false).is_none());
-    }
-
-    #[test]
-    fn an_off_hand_layer_draws_only_in_the_off_hand() {
-        let cit = rules(&[
-            ("left", "type=enchantment\nlayer=1\nhand=off"),
-            ("both", "type=enchantment"),
-        ]);
-        let sword = enchanted("diamond_sword", &[("sharpness", 1)]);
-        let layers = |hand| -> Vec<&str> {
-            let glint = cit.glint(&sword, hand, 0, true).unwrap();
-            glint
-                .layers
-                .iter()
-                .map(|l| stem(&cit, Some(l.rule)).unwrap())
-                .collect()
-        };
-        assert_eq!(layers(Hand::Off), ["both", "left"]);
-        // Asked in this order, a cache keyed without the hand would answer as for the off hand.
-        assert_eq!(layers(Hand::Main), ["both"]);
+        self.matcher.as_ref()?.glint(stack, hand, max_damage, foil)
    }
 }
@@ -6,8 +6,8 @@
 //! chestplate, boots) and `entity/equipment/humanoid_leggings/diamond` (layer 2), so the layers
 //! are mapped back to the old names here. An elytra rule's `texture` replaces the wings'.

+use crate::cit::{Kind, Rule};
 use crate::cit_assets::{rule_sprites, sprite_id};
-use horizon_optifine::cit::{Kind, Rule};
 use std::collections::BTreeSet;

 /// The pre-1.21.2 armour texture name of an equipment asset's layer: `asset` (`minecraft:gold`
@@ -114,10 +114,9 @@ pub fn armor_sprites(rules: &[Rule]) -> BTreeSet<String> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use horizon_optifine::Properties;

    fn rule(path: &str, text: &str) -> Rule {
-        Rule::parse(path, &Properties::parse_equals_first(text), |_| true).unwrap()
+        crate::pack_formats::cit::parse_rule(path, text).unwrap()
    }

    #[test]
@@ -5,8 +5,8 @@
 //! `horizon_cit:minecraft/optifine/cit/swords/flame`). A file already under `textures/` (or
 //! `models/`) keeps its vanilla id, so it is not packed twice.

+use crate::cit::{Kind, Rule};
 use horizon_assets::model::{CuboidModel, TextureSlot};
-use horizon_optifine::cit::{Kind, Rule};
 use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
 use std::path::Path;
@@ -55,7 +55,7 @@ pub fn model_id(resource: &str) -> Option<String> {
 /// and for one that would leave the resource root (a pack model may write any id).
 pub fn resource(id: &str, ext: &str) -> Option<String> {
    let rest = id.strip_prefix(NAMESPACE)?.strip_prefix(':')?;
-    horizon_optifine::paths::valid(rest).then(|| format!("assets/{rest}.{ext}"))
+    stays_in_root(rest).then(|| format!("assets/{rest}.{ext}"))
 }

 /// Sprite ids the rules whose kind passes `keep` draw: their `texture` and `texture.<name>`
@@ -102,7 +102,14 @@ fn relative(file: &str, value: &str, ext: &str) -> Option<String> {
        .and_then(|r| r.strip_suffix('.'))
        .unwrap_or(rest);
    let path = format!("{dir}/{rest}.{ext}");
-    horizon_optifine::paths::valid(&path).then_some(path)
+    stays_in_root(&path).then_some(path)
+}
+
+/// Whether a resource path stays in the root: no `.`, `..` or empty segment, and no `\` (a
+/// separator on Windows, where `..\..` would climb).
+fn stays_in_root(path: &str) -> bool {
+    path.split('/')
+        .all(|segment| !matches!(segment, "" | "." | "..") && !segment.contains('\\'))
 }

 /// The id a relative value of the model at `file` names, as `CuboidModel::from_json` read it
@@ -294,11 +301,11 @@ mod tests {
            "base.json",
            r#"{"parent":"item/handheld","textures":{"layer2":"./glow.png"}}"#,
        );
-        let props =
-            horizon_optifine::Properties::parse_equals_first("items=stick\nmodel=./swords/flame");
-        let rule = Rule::parse("assets/minecraft/optifine/cit/a.properties", &props, |p| {
-            root.join(p).is_file()
-        })
+        let rule = crate::pack_formats::cit::parse_rule_in(
+            &root,
+            "assets/minecraft/optifine/cit/a.properties",
+            "items=stick\nmodel=./swords/flame",
+        )
        .unwrap();
        let models = load_models(&root, &[rule]);
        let _ = fs::remove_dir_all(&root);
@@ -1,26 +1,6 @@
-//! Custom Item Textures' enchantment glints (`type=enchantment`): which of a stack's matching
-//! rules draw, in which order and how strongly, and whether vanilla's glint still draws under
-//! them. The pack's `cit.properties` (`Global`) says how layers share an item.
-//!
-//! Written from OptiFine's `cit.properties` doc and CIT Resewn's (MIT) `TypeEnchantment` of
-//! before its 1.21.11 port, which implemented `method`, `cap` and `fade`: the sums and the
-//! cycle's fading follow it, except where noted.
-
-pub use horizon_optifine::cit::{Global, Method};
-
-use crate::cit::read_properties;
-use horizon_optifine::cit::Rule;
-use std::path::Path;
-
-/// The pack's global `cit.properties` under the overlay resource root: the first of
-/// `Global::PATHS` that exists, else the defaults.
-pub fn load_global(root: &Path) -> Global {
-    Global::PATHS
-        .iter()
-        .find_map(|path| read_properties(&root.join(path)))
-        .map(|props| Global::parse(&props))
-        .unwrap_or_default()
-}
+//! Custom item textures' enchantment glints: the layers a stack draws over (or instead of)
+//! vanilla's glint, and how strongly each draws over time. Which layers a stack gets is the pack
+//! format's ([`crate::cit::Matcher::glint`]); a layer's look is its rule's [`crate::cit::Glint`].

 /// One glint layer a stack draws.
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -33,6 +13,17 @@ pub struct GlintLayer {
    duration: f32,
 }

+impl GlintLayer {
+    /// Rule `rule`'s layer at `weight`, on for `duration` seconds when the layers take turns.
+    pub fn new(rule: usize, weight: f32, duration: f32) -> Self {
+        Self {
+            rule,
+            weight,
+            duration,
+        }
+    }
+}
+
 /// What a stack's glint is made of, worked out when the stack changes.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct StackGlint {
@@ -45,84 +36,14 @@ pub struct StackGlint {
 }

 impl StackGlint {
-    /// The layers among `matched` (the stack's matching enchantment rules, in priority order,
-    /// as `CitRules::enchantments` gives them) that draw, for a stack with `enchantments`
-    /// (`ItemStack::crafting_enchantments`).
-    pub fn new(
-        rules: &[Rule],
-        matched: &[usize],
-        enchantments: &[(impl AsRef<str>, u32)],
-        global: &Global,
-    ) -> Self {
-        // The highest priority rule of each layer.
-        let mut layers: Vec<usize> = Vec::new();
-        for &i in matched {
-            let layer = rules[i].glint.layer;
-            if !layers.iter().any(|&j| rules[j].glint.layer == layer) {
-                layers.push(i);
-            }
-        }
-        layers.sort_by_key(|&i| rules[i].glint.layer);
-        let cycle = global.method == Method::Cycle;
-        // OptiFine's doc: `cap` is for `average` and `layered`, and keeps the topmost layers.
-        // `none`, which OptiFine lacks, is capped too, as CIT Resewn caps every method (it keeps
-        // the bottom layers, though, and caps cycles as well).
-        if let Some(cap) = global.cap.filter(|_| !cycle) {
-            let cap = usize::try_from(cap).unwrap_or(usize::MAX);
-            layers = layers.split_off(layers.len().saturating_sub(cap));
-        }
-        // CIT Resewn: any layer left asking for vanilla's glint keeps it, and the global
-        // `useGlint=false` removes it everywhere, as OptiFine's doc says too. `cap=0` leaves no
-        // custom layer, and vanilla's glint only if the pack's `useGlint` allows it.
-        let vanilla = global.use_glint
-            && (layers.is_empty() || layers.iter().any(|&i| rules[i].glint.use_glint));
-        // CIT Resewn: shares are against every enchantment of the stack, not only those the
-        // layers name.
-        let levels = enchantments.iter().map(|(_, level)| *level as f32);
-        let total = match global.method {
-            Method::Average => levels.sum::<f32>(),
-            Method::Layered => levels.fold(0.0, f32::max),
-            Method::None | Method::Cycle => 0.0,
-        };
-        let shared = matches!(global.method, Method::Average | Method::Layered);
-        let layers = layers
-            .into_iter()
-            .map(|i| {
-                let rule = &rules[i];
-                let named = &rule.enchantments;
-                let weight = if !shared || named.is_empty() {
-                    1.0
-                } else {
-                    // The highest level among the enchantments the rule names whose level also
-                    // passes its `enchantmentLevels` (CIT Resewn takes the first named one the
-                    // stack has, whatever its level).
-                    let in_range = |level: u32| {
-                        let level = i32::try_from(level).unwrap_or(i32::MAX);
-                        rule.enchantment_levels
-                            .as_ref()
-                            .is_none_or(|r| r.contains(level))
-                    };
-                    let level = enchantments
-                        .iter()
-                        .filter(|(id, level)| {
-                            let id: &str = id.as_ref();
-                            named.iter().any(|n| n == id) && in_range(*level)
-                        })
-                        .map(|(_, level)| *level as f32)
-                        .fold(0.0, f32::max);
-                    if total > 0.0 { level / total } else { 0.0 }
-                };
-                GlintLayer {
-                    rule: i,
-                    weight,
-                    duration: rule.glint.duration,
-                }
-            })
-            .collect();
+    /// `layers`, bottom first; `vanilla` whether vanilla's glint draws under them; `cycle_fade`
+    /// the seconds each layer fades into the next when they take turns, else `None` (each
+    /// draws at its weight).
+    pub fn from_parts(layers: Vec<GlintLayer>, vanilla: bool, cycle_fade: Option<f32>) -> Self {
        Self {
            layers,
            vanilla,
-            cycle_fade: cycle.then_some(global.fade),
+            cycle_fade,
        }
    }

@@ -179,208 +100,3 @@ fn cycle_intensity(layers: &[GlintLayer], fade: f32, index: usize, seconds: f64)
    // Not reached, as the last layer returns above; no layer rather than a panic.
    0.0
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use horizon_optifine::Properties;
-
-    const DIR: &str = "assets/minecraft/optifine/cit";
-
-    /// An enchantment rule named `name` with `text` after `type` and `texture`.
-    fn rule(name: &str, text: &str) -> Rule {
-        let text = format!("type=enchantment\ntexture=glint\n{text}");
-        let path = format!("{DIR}/{name}.properties");
-        Rule::parse(&path, &Properties::parse_equals_first(&text), |_| true).unwrap()
-    }
-
-    fn global(text: &str) -> Global {
-        Global::parse(&Properties::parse_equals_first(text))
-    }
-
-    fn rules_of(layers: &StackGlint) -> Vec<usize> {
-        layers.layers.iter().map(|l| l.rule).collect()
-    }
-
-    const SWORD: [(&str, u32); 2] = [("minecraft:sharpness", 3), ("minecraft:unbreaking", 1)];
-
-    #[test]
-    fn one_rule_per_layer_bottom_first() {
-        let rules = [
-            rule("a", "layer=2"),
-            rule("b", "layer=0"),
-            rule("c", "layer=2"),
-            rule("d", "layer=-1"),
-        ];
-        // Priority order a, b, c, d: c loses layer 2 to a.
-        let g = StackGlint::new(&rules, &[0, 1, 2, 3], &SWORD, &Global::default());
-        assert_eq!(rules_of(&g), [3, 1, 0]);
-        let g = StackGlint::new(&rules, &[2, 0], &SWORD, &Global::default());
-        assert_eq!(rules_of(&g), [2]);
-    }
-
-    #[test]
-    fn average_and_layered_shares() {
-        let rules = [
-            rule("sharp", "enchantments=sharpness smite"),
-            rule("unb", "layer=1\nenchantments=unbreaking"),
-            rule("any", "layer=2"),
-            rule("fire", "layer=3\nenchantments=fire_aspect"),
-        ];
-        let weights = |method: &str| {
-            let g = StackGlint::new(&rules, &[0, 1, 2, 3], &SWORD, &global(method));
-            g.layers.iter().map(|l| l.weight).collect::<Vec<_>>()
-        };
-        // Sharpness III and Unbreaking I: 3 / 4 and 1 / 4; against the highest, 3 / 3 and 1 / 3.
-        // A rule naming no enchantment is at full strength, one the stack lacks at none.
-        assert_eq!(weights("method=average"), [0.75, 0.25, 1.0, 0.0]);
-        assert_eq!(weights("method=layered"), [1.0, 1.0 / 3.0, 1.0, 0.0]);
-        assert_eq!(weights("method=cycle"), [1.0; 4]);
-        assert_eq!(weights("method=none"), [1.0; 4]);
-    }
-
-    #[test]
-    fn the_level_is_one_the_rules_levels_allow() {
-        let rules = [rule(
-            "holy",
-            "enchantments=sharpness smite\nenchantmentLevels=1-2",
-        )];
-        // Sharpness V is out of range, so Smite I sets the share: 1 / 5 of the highest level.
-        let stack = [("minecraft:sharpness", 5), ("minecraft:smite", 1)];
-        let g = StackGlint::new(&rules, &[0], &stack, &global("method=layered"));
-        assert_eq!(g.layers[0].weight, 1.0 / 5.0);
-    }
-
-    #[test]
-    fn cap_keeps_the_topmost_layers() {
-        let rules = [
-            rule("a", "layer=0"),
-            rule("b", "layer=1"),
-            rule("c", "layer=2"),
-        ];
-        let g = StackGlint::new(&rules, &[0, 1, 2], &SWORD, &global("cap=2"));
-        assert_eq!(rules_of(&g), [1, 2]);
-        let g = StackGlint::new(&rules, &[0, 1, 2], &SWORD, &global("cap=0"));
-        assert!(g.is_empty());
-        let g = StackGlint::new(&rules, &[0, 1, 2], &SWORD, &global("cap=1\nmethod=none"));
-        assert_eq!(rules_of(&g), [2]);
-        // Cycles show every layer in turn.
-        let g = StackGlint::new(&rules, &[0, 1, 2], &SWORD, &global("cap=1\nmethod=cycle"));
-        assert_eq!(rules_of(&g), [0, 1, 2]);
-    }
-
-    #[test]
-    fn vanilla_glint() {
-        let plain = rule("plain", "");
-        let keep = rule("keep", "layer=1\nuseGlint=true");
-        let rules = [plain, keep];
-        let vanilla = |matched: &[usize], text: &str| {
-            StackGlint::new(&rules, matched, &SWORD, &global(text)).vanilla
-        };
-        assert!(vanilla(&[], ""), "no rule: vanilla's glint");
-        assert!(!vanilla(&[0], ""), "a rule replaces it");
-        assert!(vanilla(&[0, 1], ""), "unless one keeps it");
-        assert!(!vanilla(&[], "useGlint=false"));
-        assert!(!vanilla(&[1], "useGlint=false"), "the pack's word is final");
-        // Only the layers `cap` keeps count.
-        let rules = [rule("keep", "useGlint=true"), rule("top", "layer=1")];
-        let g = StackGlint::new(&rules, &[0, 1], &SWORD, &global("cap=1"));
-        assert!(!g.vanilla);
-        let g = StackGlint::new(&rules, &[0, 1], &SWORD, &global("cap=0"));
-        assert!(g.is_empty() && g.vanilla);
-        let g = StackGlint::new(&rules, &[0, 1], &SWORD, &global("cap=0\nuseGlint=false"));
-        assert!(!g.vanilla);
-    }
-
-    #[test]
-    fn cycles_take_turns_and_fade() {
-        let rules = [
-            rule("a", "duration=2"),
-            rule("b", "layer=1\nduration=1"),
-            rule("c", "layer=2\nduration=1"),
-        ];
-        let g = StackGlint::new(
-            &rules,
-            &[0, 1, 2],
-            &SWORD,
-            &global("method=cycle\nfade=0.5"),
-        );
-        // a 0-2, a→b 2-2.5, b 2.5-3.5, b→c 3.5-4, c 4-5, c→a 5-5.5, then again.
-        let at = |t: f64| [0, 1, 2].map(|i| g.intensity(i, t));
-        assert_eq!(at(1.0), [1.0, 0.0, 0.0]);
-        assert_eq!(at(2.125), [0.75, 0.25, 0.0]);
-        assert_eq!(at(3.0), [0.0, 1.0, 0.0]);
-        assert_eq!(at(3.75), [0.0, 0.5, 0.5]);
-        assert_eq!(at(4.5), [0.0, 0.0, 1.0]);
-        assert_eq!(at(5.25), [0.5, 0.0, 0.5]);
-        assert_eq!(at(5.5 + 3.0), [0.0, 1.0, 0.0]);
-        // One layer always shows.
-        let one = StackGlint::new(&rules, &[1], &SWORD, &global("method=cycle"));
-        assert_eq!(one.intensity(0, 0.7), 1.0);
-    }
-
-    #[test]
-    fn a_cycle_always_shows_a_whole_layer() {
-        let rules = [
-            rule("a", "duration=0.1"),
-            rule("b", "layer=1\nduration=0.7"),
-            rule("c", "layer=2\nduration=0.2"),
-        ];
-        let g = StackGlint::new(
-            &rules,
-            &[0, 1, 2],
-            &SWORD,
-            &global("method=cycle\nfade=0.3"),
-        );
-        // Every millisecond of the first two seconds, and just under a period, the last fade's
-        // end. (Rounding has not been seen to leave time past it; the last fade's clamp is
-        // defensive.)
-        let period: f64 = [0.1f32, 0.7, 0.2]
-            .map(|d| f64::from(d) + f64::from(0.3f32))
-            .iter()
-            .sum();
-        let last = f64::from_bits(period.to_bits() - 1);
-        for t in (0..2000_i32)
-            .map(|i| f64::from(i) * 0.001)
-            .chain([last, period + last])
-        {
-            let sum: f32 = (0..3).map(|i| g.intensity(i, t)).sum();
-            assert!((sum - 1.0).abs() < 1e-5, "{sum} at {t}");
-        }
-        // No time at all: the bottom layer alone, never NaN.
-        let still = [rule("a", "duration=0"), rule("b", "layer=1\nduration=0")];
-        let g = StackGlint::new(&still, &[0, 1], &SWORD, &global("method=cycle\nfade=0"));
-        for t in [0.0, 0.5, 7.25] {
-            assert_eq!([0, 1].map(|i| g.intensity(i, t)), [1.0, 0.0]);
-        }
-    }
-
-    #[test]
-    fn the_first_global_file_wins() {
-        let root = std::env::temp_dir().join(format!("horizon-cit-glint-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&root);
-        assert_eq!(load_global(&root), Global::default());
-        let write = |path: &str, text: &[u8]| {
-            let file = root.join(path);
-            std::fs::create_dir_all(file.parent().unwrap()).unwrap();
-            std::fs::write(file, text).unwrap();
-        };
-        // Saved as Latin-1 (`é` is not UTF-8 alone), in the OptiFine doc's `cit/` folder.
-        write(
-            "assets/minecraft/optifine/cit/cit.properties",
-            b"# caf\xE9\nmethod=cycle",
-        );
-        assert_eq!(load_global(&root).method, Method::Cycle);
-        write("assets/minecraft/mcpatcher/cit.properties", b"method=none");
-        assert_eq!(load_global(&root).method, Method::Cycle);
-        write(
-            "assets/minecraft/optifine/cit.properties",
-            b"method=layered",
-        );
-        assert_eq!(load_global(&root).method, Method::Layered);
-        write("assets/minecraft/citresewn/cit.properties", b"cap=1");
-        let g = load_global(&root);
-        let _ = std::fs::remove_dir_all(&root);
-        assert_eq!((g.method, g.cap), (Method::Average, Some(1)));
-    }
-}
@@ -121,8 +121,8 @@ impl CommandBlock {
            condition_met: flag("conditionMet", false),
        }
    }
-    /// `CommandBlockEntity.saveAdditional`. The last output is written as a
-    /// plain string component.
+    /// `CommandBlockEntity.saveAdditional`. The last output is the component
+    /// itself (`ComponentSerialization.CODEC`), styles and click events kept.
    pub fn save(&self) -> Vec<(&'static str, Tag)> {
        let mut out = vec![
            ("Command", Tag::String(self.command.as_str().into())),
@@ -135,7 +135,7 @@ impl CommandBlock {
        if self.track_output
            && let Some(last) = &self.last_output
        {
-            out.push(("LastOutput", Tag::String(last.plain().as_str().into())));
+            out.push(("LastOutput", scoreboard::component_tag(&last.component())));
        }
        out.push((
            "UpdateLastExecution",
@@ -1,27 +1,34 @@
-//! OptiFine custom skies (`horizon_optifine::sky`) as the game draws them: a pack's layers with
-//! their decoded textures, read once with the pack, and each frame's choice of layers, their
-//! brightness and rotation ([`CustomSky::draws`]), which `gfx::custom_sky` draws over the
-//! vanilla sky. A pack without `optifine/sky` gives an empty [`CustomSky`] and the sky stays
-//! vanilla.
+//! Custom sky layers: skyboxes a pack draws over the vanilla sky, in a format vanilla doesn't read
+//! (OptiFine's), which the platform's pack formats fill ([`crate::pack_hooks`]). The layers'
+//! textures are read once with the pack; each frame the game asks for the layers to draw, their
+//! brightness and rotation ([`SkyLayers::draws`]), and `gfx::custom_sky` draws them over the
+//! vanilla sky. A pack without layers keeps the vanilla sky.

 use std::path::Path;
+use std::sync::Arc;

-use glam::{Mat4, Vec3};
-use horizon_optifine::sky::{Blend, Conditions, Skies, SkyLayer, Transition};
+use glam::Mat4;

-/// A layer's texture, RGBA8.
+/// A layer's texture, RGBA8: the skybox's six faces in a 3x2 grid, bottom, top and south in the
+/// top row, west, north and east below (`gfx::custom_sky`'s faces).
 pub struct Image {
    pub width: u32,
    pub height: u32,
    pub rgba: Vec<u8>,
 }

-/// The pack's layers, by world, with one texture per layer (`images[i]` for the `i`th layer
-/// over all worlds, in `worlds` order).
-#[derive(Default)]
-pub struct CustomSky {
-    worlds: Vec<(i32, Vec<SkyLayer>)>,
-    pub images: Vec<Image>,
+/// How a layer mixes with what is drawn below it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Blend {
+    Add,
+    Subtract,
+    Multiply,
+    Dodge,
+    Burn,
+    Screen,
+    Replace,
+    Overlay,
+    Alpha,
 }

 /// One layer of a frame: which texture, with which blend, how bright and turned how.
@@ -34,62 +41,44 @@ pub struct Draw {
    pub rotation: Mat4,
 }

+/// The weather of a frame: thunder is a storm's rain, so it is only `Thunder`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Weather {
+    Clear,
+    Rain,
+    Thunder,
+}
+
+/// What a frame's layers may depend on.
+#[derive(Clone, Copy, Debug)]
+pub struct Conditions<'a> {
+    /// Ticks of the day, counting the days.
+    pub day_time: i64,
+    pub weather: Weather,
+    /// The biome at the camera, namespaced.
+    pub biome: &'a str,
+    /// The camera's block height.
+    pub y: i32,
+}
+
 /// The eased brightness of each layer, kept by the game between frames.
 #[derive(Default)]
 pub struct State {
-    world: Option<i32>,
-    eased: Vec<Transition>,
+    /// The world the layers were last drawn for.
+    pub world: Option<i32>,
+    /// Each layer's eased visibility, 0 to 1.
+    pub eased: Vec<f32>,
 }

-/// Textures past this many texels in all are left out (a skybox is a few megapixels at most).
-const TEXEL_BUDGET: u64 = 64 << 20;
-
-impl CustomSky {
-    /// The custom skies of the overlay at `root`. A layer whose texture does not decode is
-    /// dropped with a warning.
-    pub fn load(root: &Path) -> Self {
-        let skies = Skies::scan(root);
-        let mut out = Self::default();
-        let mut texels = 0u64;
-        for (world, sky) in skies.worlds {
-            let mut layers = Vec::new();
-            for layer in sky.layers {
-                match crate::hud::decode(&root.join(&layer.source)) {
-                    Ok((width, height, rgba))
-                        if texels + u64::from(width) * u64::from(height) <= TEXEL_BUDGET =>
-                    {
-                        texels += u64::from(width) * u64::from(height);
-                        out.images.push(Image {
-                            width,
-                            height,
-                            rgba,
-                        });
-                        layers.push(layer);
-                    }
-                    Ok(_) => log::warn!("{}: past the custom sky's texture budget", layer.source),
-                    Err(e) => log::warn!("{}: {e:#}", layer.source),
-                }
-            }
-            if !layers.is_empty() {
-                out.worlds.push((world, layers));
-            }
-        }
-        out
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.worlds.is_empty()
-    }
-
-    /// Whether `world` has layers (`0` the Overworld, `1` the End).
-    pub fn has(&self, world: i32) -> bool {
-        self.worlds.iter().any(|(w, _)| *w == world)
-    }
-
-    /// This frame's layers of `world` into `out` (cleared first), in drawing order: those whose
-    /// conditions hold, eased over their `transition` by `seconds` since the last frame, at the
-    /// brightness of their fade times. `sun_turns` is the sun's angle over 360° (`0` at noon).
-    pub fn draws(
+/// A pack's custom sky layers, by world (`0` the Overworld, `1` the End).
+pub trait SkyLayers: Send + Sync {
+    /// Every layer's texture: [`Draw::image`] indexes it.
+    fn images(&self) -> &[Image];
+    /// Whether `world` has layers.
+    fn has(&self, world: i32) -> bool;
+    /// This frame's layers of `world` into `out` (cleared first), in drawing order, eased by
+    /// `seconds` since the last frame. `sun_turns` is the sun's angle over 360° (`0` at noon).
+    fn draws(
        &self,
        world: i32,
        conditions: &Conditions,
@@ -97,147 +86,30 @@ impl CustomSky {
        seconds: f32,
        state: &mut State,
        out: &mut Vec<Draw>,
-    ) {
+    );
+}
+
+/// No layers: the vanilla sky.
+struct NoLayers;
+
+impl SkyLayers for NoLayers {
+    fn images(&self) -> &[Image] {
+        &[]
+    }
+
+    fn has(&self, _: i32) -> bool {
+        false
+    }
+
+    fn draws(&self, _: i32, _: &Conditions, _: f32, _: f32, s: &mut State, out: &mut Vec<Draw>) {
        out.clear();
-        let mut first = 0;
-        let mut found = None;
-        for (w, layers) in &self.worlds {
-            if *w == world {
-                found = Some(layers);
-                break;
-            }
-            first += layers.len();
-        }
-        let Some(layers) = found else {
-            state.world = None;
-            return;
-        };
-        // A new world (or pack) starts each layer where its conditions put it: no fade in.
-        let snap = state.world != Some(world) || state.eased.len() != layers.len();
-        if snap {
-            state.world = Some(world);
-            state.eased.clear();
-            state.eased.resize(layers.len(), Transition::default());
-        }
-        for (i, (layer, eased)) in layers.iter().zip(&mut state.eased).enumerate() {
-            let target = if layer.shows(conditions) { 1.0 } else { 0.0 };
-            let shown = if snap {
-                eased.value = target;
-                target
-            } else {
-                eased.step(target, seconds, layer.transition)
-            };
-            let brightness = shown * layer.brightness(conditions.day_time);
-            if brightness <= 0.0 {
-                continue;
-            }
-            let turns = layer.turns(conditions.day_time, sun_turns);
-            let rotation = if turns == 0.0 {
-                Mat4::IDENTITY
-            } else {
-                Mat4::from_axis_angle(Vec3::from_array(layer.axis), turns * std::f32::consts::TAU)
-            };
-            out.push(Draw {
-                image: (first + i) as u16,
-                blend: layer.blend,
-                brightness,
-                rotation,
-            });
-        }
+        s.world = None;
    }
 }

-#[cfg(test)]
-mod tests {
-    use super::*;
-    use horizon_optifine::sky::Now;
-
-    fn pack(files: &[(&str, &str)]) -> (std::path::PathBuf, CustomSky) {
-        let root = std::env::temp_dir().join(format!(
-            "horizon-custom-sky-{}-{}",
-            std::process::id(),
-            files.len()
-        ));
-        let _ = std::fs::remove_dir_all(&root);
-        let dir = root.join("assets/minecraft/optifine/sky/world0");
-        std::fs::create_dir_all(&dir).unwrap();
-        let png = {
-            let mut bytes = Vec::new();
-            let mut encoder = png::Encoder::new(&mut bytes, 6, 4);
-            encoder.set_color(png::ColorType::Rgba);
-            encoder.set_depth(png::BitDepth::Eight);
-            let mut writer = encoder.write_header().unwrap();
-            writer
-                .write_image_data(&[255, 0, 0, 255].repeat(24))
-                .unwrap();
-            writer.finish().unwrap();
-            bytes
-        };
-        for (name, text) in files {
-            std::fs::write(dir.join(format!("{name}.properties")), text).unwrap();
-            std::fs::write(dir.join(format!("{name}.png")), &png).unwrap();
-        }
-        let sky = CustomSky::load(&root);
-        (root, sky)
-    }
-
-    fn noon(biome: &str) -> Conditions<'_> {
-        Conditions {
-            day_time: 6000,
-            weather: Now::Clear,
-            biome,
-            y: 64,
-        }
-    }
-
-    #[test]
-    fn layers_ease_in_at_a_biome_border_but_not_on_arrival() {
-        let (root, sky) = pack(&[
-            ("sky1", "biomes=desert\ntransition=2"),
-            ("sky2", "blend=alpha\nrotate=false"),
-        ]);
-        let _ = std::fs::remove_dir_all(root);
-        assert!(sky.has(0) && !sky.has(1));
-        assert_eq!(sky.images[0].width, 6);
-        let (mut state, mut out) = (State::default(), Vec::new());
-        sky.draws(
-            0,
-            &noon("minecraft:desert"),
-            0.0,
-            0.05,
-            &mut state,
-            &mut out,
-        );
-        assert_eq!(
-            out.iter().map(|d| d.brightness).collect::<Vec<_>>(),
-            [1.0, 1.0]
-        );
-        // Out of the desert: the first layer fades over its two seconds.
-        sky.draws(0, &noon("minecraft:plains"), 0.0, 0.5, &mut state, &mut out);
-        assert_eq!(out[0].brightness, 0.75);
-        assert_eq!(out[1].blend, Blend::Alpha);
-        sky.draws(0, &noon("minecraft:plains"), 0.0, 2.0, &mut state, &mut out);
-        assert_eq!(out.len(), 1, "a dark layer is not drawn");
-        assert_eq!(out[0].image, 1);
-        // Into the End, which has no layers, and back: no fade.
-        sky.draws(1, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
-        assert!(out.is_empty());
-        sky.draws(0, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
-        assert_eq!(out.len(), 2);
-    }
-
-    #[test]
-    fn a_layer_turns_west_like_the_sun() {
-        let (root, sky) = pack(&[("sky1", "")]);
-        let _ = std::fs::remove_dir_all(root);
-        let (mut state, mut out) = (State::default(), Vec::new());
-        // A quarter turn after noon (sunset): the skybox's zenith has gone down to the west.
-        let c = Conditions {
-            day_time: 12000,
-            ..noon("minecraft:plains")
-        };
-        sky.draws(0, &c, 0.25, 0.0, &mut state, &mut out);
-        let up = out[0].rotation.transform_vector3(Vec3::Y);
-        assert!((up - Vec3::NEG_X).length() < 1e-5, "{up}");
-    }
+/// The custom sky layers of the overlay at `root`, from the installed pack formats.
+pub fn load(root: &Path) -> Arc<dyn SkyLayers> {
+    crate::pack_hooks::formats()
+        .custom_sky(root)
+        .unwrap_or_else(|| Arc::new(NoLayers))
 }
@@ -0,0 +1,271 @@
+//! Entity textures a pack format vanilla doesn't read changes (OptiFine's random entities, ETF's
+//! blinking and emissive textures): the variants of each texture and how an entity picks one,
+//! the blink frames a texture shows now and then, and the overlays that glow over a texture.
+//! The platform's pack formats fill them once per pack load ([`crate::pack_hooks`]); drawing
+//! only looks them up in these tables.
+//!
+//! Textures have the names the entity atlas gives them (`entity/zombie/zombie`,
+//! `<ns>:<path>`); files outside `textures/` are listed with the name they take
+//! ([`RandomTextures::files`], [`Blinks::files`], [`Emissive::files`]) for the atlas to pack.
+
+use std::collections::{BTreeMap, HashMap};
+use std::path::Path;
+
+/// A pack's entity texture changes: variants, blinks and emissive overlays.
+#[derive(Debug, Default)]
+pub struct EntityTextures {
+    pub random: RandomTextures,
+    pub blinks: Blinks,
+    pub emissive: Emissive,
+}
+
+impl EntityTextures {
+    /// The changes of the overlay at `root`, from the installed pack formats.
+    pub fn load(root: &Path) -> Self {
+        crate::pack_hooks::formats()
+            .entity_textures(root)
+            .unwrap_or_default()
+    }
+}
+
+/// What a variant rule can ask about an entity. `None` is a fact the entity doesn't have (a
+/// creeper's profession): a rule asking for it doesn't match.
+#[derive(Clone, Debug, Default)]
+pub struct Facts<'a> {
+    /// Where the entity was first seen: its biome (`minecraft:plains`) and block height.
+    pub biome: Option<&'a str>,
+    pub y: Option<i32>,
+    /// The block it stood on and the block it stood in when first seen; empty when unknown.
+    pub blocks: &'a [Block<'a>],
+    /// Its custom name, with `§` formatting codes where the name has them.
+    pub name: Option<&'a str>,
+    /// Villager profession (`minecraft:farmer`) and level.
+    pub profession: Option<(&'a str, i32)>,
+    /// Collar, wool, carpet or shell colour, as a dye name (`light_blue`).
+    pub color: Option<&'a str>,
+    pub baby: Option<bool>,
+    /// Health and max health.
+    pub health: Option<(f32, f32)>,
+    /// When first seen: moon phase (0-7), time of day (0-23999) and weather.
+    pub moon_phase: Option<i32>,
+    pub day_time: Option<i32>,
+    pub weather: Option<Weather>,
+    /// Slime, magma cube or phantom size: 0 small, 1 medium, 3 big.
+    pub size: Option<i32>,
+}
+
+/// A block and the values of its state properties.
+#[derive(Clone, Copy, Debug)]
+pub struct Block<'a> {
+    pub id: &'a str,
+    pub states: &'a [(&'a str, &'a str)],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Weather {
+    Clear,
+    Rain,
+    Thunder,
+}
+
+/// How a pack format's rule files choose a variant.
+pub trait VariantRules: Send + Sync {
+    /// The variant rule file `rules` ([`Entry::rules`]) gives an entity with these facts and
+    /// seed, `None` when no rule matches.
+    fn matching(&self, rules: usize, facts: &Facts, seed: i32) -> Option<u32>;
+}
+
+/// Every texture a pack varies, by its atlas name.
+#[derive(Default)]
+pub struct RandomTextures {
+    entries: HashMap<String, Entry>,
+    /// Every variant's file (from the resource root) and atlas name.
+    files: Vec<(String, String)>,
+    rules: Option<Box<dyn VariantRules>>,
+    generation: u64,
+}
+
+impl std::fmt::Debug for RandomTextures {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RandomTextures")
+            .field("entries", &self.entries)
+            .field("generation", &self.generation)
+            .finish_non_exhaustive()
+    }
+}
+
+/// One texture's variants.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Entry {
+    /// The rule file that chooses this texture's variant ([`RandomTextures::matching`]).
+    pub rules: Option<usize>,
+    /// The atlas name of each variant, by its number.
+    pub variants: BTreeMap<u32, String>,
+}
+
+impl RandomTextures {
+    /// `entries` by atlas name, their variants' `files` (file, atlas name), the rule files
+    /// `rules` that choose, and `generation`: different for every load (never 0), so choices
+    /// made from another load's rules are known to be stale.
+    pub fn new(
+        entries: HashMap<String, Entry>,
+        files: Vec<(String, String)>,
+        rules: Box<dyn VariantRules>,
+        generation: u64,
+    ) -> Self {
+        Self {
+            entries,
+            files,
+            rules: Some(rules),
+            generation,
+        }
+    }
+
+    /// This load's number; 0 for the empty set.
+    pub fn generation(&self) -> u64 {
+        self.generation
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    /// The variants of the texture with this atlas name.
+    pub fn get(&self, texture: &str) -> Option<&Entry> {
+        self.entries.get(texture)
+    }
+
+    /// [`VariantRules::matching`].
+    pub fn matching(&self, rules: usize, facts: &Facts, seed: i32) -> Option<u32> {
+        self.rules.as_ref()?.matching(rules, facts, seed)
+    }
+
+    /// Every variant's file (its path from the resource root) and atlas name, for the entity
+    /// atlas to pack.
+    pub fn files(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.files.iter().map(|(f, n)| (f.as_str(), n.as_str()))
+    }
+}
+
+impl Entry {
+    /// The atlas name of variant `index`, or `None` for the texture itself.
+    pub fn texture(&self, index: u32) -> Option<&str> {
+        self.variants.get(&index).map(String::as_str)
+    }
+
+    /// The even choice of an entity with this seed when no rules apply: the texture and its
+    /// variants 2, 3... up to the first missing one.
+    pub fn even(&self, seed: i32) -> u32 {
+        let mut count = 1;
+        while self.variants.contains_key(&(count + 1)) {
+            count += 1;
+        }
+        seed.unsigned_abs() % count + 1
+    }
+}
+
+/// An entity's seed from its UUID (most then least significant 64 bits): Java's
+/// `UUID.hashCode`, so it is fixed for the entity's whole life, on every client.
+pub fn seed(most: i64, least: i64) -> i32 {
+    let x = most ^ least;
+    ((x >> 32) ^ x) as i32
+}
+
+/// The pack's blinking textures, by the atlas name of the texture they replace.
+#[derive(Debug, Default)]
+pub struct Blinks {
+    blinks: HashMap<String, Blink>,
+    /// The blink frames outside `textures/`: file and atlas name.
+    files: Vec<(String, String)>,
+}
+
+/// A texture's blink.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Blink {
+    /// The atlas names of the shut and half-shut frames.
+    pub shut: String,
+    pub half: Option<String>,
+    /// Ticks a blink lasts (at least 1) and ticks from one blink to the next (more).
+    pub length: u32,
+    pub frequency: u32,
+}
+
+impl Blinks {
+    /// `blinks` by the atlas name of the texture they replace, and the frames outside
+    /// `textures/` (file, atlas name).
+    pub fn new(blinks: HashMap<String, Blink>, files: Vec<(String, String)>) -> Self {
+        Self { blinks, files }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.blinks.is_empty()
+    }
+
+    pub fn get(&self, texture: &str) -> Option<&Blink> {
+        self.blinks.get(texture)
+    }
+
+    /// The frames outside `textures/`: file and atlas name, for the entity atlas to pack (it
+    /// walks `textures/` itself).
+    pub fn files(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.files.iter().map(|(f, n)| (f.as_str(), n.as_str()))
+    }
+}
+
+impl Blink {
+    /// The frame an entity shows `tick` ticks into its life: `None` with its eyes open. `phase`
+    /// spreads entities' blinks apart. With a half-shut frame, the first and last ticks of a
+    /// blink of 3 or more show it.
+    pub fn frame(&self, tick: u32, phase: u32) -> Option<&str> {
+        let t = (u64::from(tick) + u64::from(phase)) % u64::from(self.frequency);
+        let t = t as u32;
+        if t >= self.length {
+            return None;
+        }
+        match &self.half {
+            Some(half) if self.length >= 3 && (t == 0 || t == self.length - 1) => Some(half),
+            _ => Some(&self.shut),
+        }
+    }
+}
+
+/// The pack's emissive overlays, by the atlas name of the texture they glow over.
+#[derive(Debug, Default)]
+pub struct Emissive {
+    /// The name ending of the pack's emissive textures (`_e`).
+    pub suffix: String,
+    overlays: HashMap<String, String>,
+    /// Overlays outside `textures/`: file and atlas name.
+    files: Vec<(String, String)>,
+}
+
+impl Emissive {
+    /// `overlays` (texture → overlay, atlas names) with name ending `suffix`, and those outside
+    /// `textures/` (file, atlas name).
+    pub fn new(
+        suffix: String,
+        overlays: HashMap<String, String>,
+        files: Vec<(String, String)>,
+    ) -> Self {
+        Self {
+            suffix,
+            overlays,
+            files,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.overlays.is_empty()
+    }
+
+    /// The atlas name of the overlay that glows over `texture`.
+    pub fn overlay(&self, texture: &str) -> Option<&str> {
+        self.overlays.get(texture).map(String::as_str)
+    }
+
+    /// The overlays outside `textures/`: file (from the resource root) and atlas name, for the
+    /// entity atlas to pack (it walks `textures/` itself).
+    pub fn files(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.files.iter().map(|(f, n)| (f.as_str(), n.as_str()))
+    }
+}
@@ -265,7 +265,7 @@ impl horizon_polytone::expr::Host for FrameHost<'_> {
            ("config", [horizon_polytone::expr::Value::Str(id)]) => self
                .configs
                .get(id)
-                .map(horizon_polytone::pack::ConfigValue::to_value)
+                .map(horizon_polytone::pack::config_value)
                .ok_or_else(|| format!("no config {id}")),
            _ => Err(format!(
                "{name} is not available in an attribute expression"
@@ -569,6 +569,25 @@ pub(crate) fn polytone_noise() -> &'static horizon_core::noise::SimplexNoise {
 }

 impl horizon_polytone::expr::Host for BlockHost<'_> {
+    fn field(
+        &mut self,
+        root: horizon_polytone::expr::Root,
+        field: horizon_polytone::expr::Field,
+    ) -> Option<horizon_polytone::expr::Value> {
+        use horizon_polytone::expr::Field as F;
+        if root != horizon_polytone::expr::Root::Object {
+            return None;
+        }
+        Some(horizon_polytone::expr::Value::Num(match field {
+            F::X => f64::from(self.at[0]),
+            F::Y => f64::from(self.at[1]),
+            F::Z => f64::from(self.at[2]),
+            F::Temperature => f64::from(self.biome.temperature),
+            F::Downfall => f64::from(self.biome.downfall),
+            _ => return None,
+        }))
+    }
+
    fn root(&mut self, root: horizon_polytone::expr::Root) -> horizon_polytone::expr::Value {
        use horizon_polytone::expr::Root;
        horizon_polytone::expr::Value::Object(match root {
@@ -1084,6 +1103,7 @@ mod tests {
        for (path, text) in pack {
            write(&format!("pack/{path}"), text);
        }
+        crate::pack_formats::install();
        let modifiers = PackModifiers::read(&dir.join("pack")).with_configs(
            crate::packs::polytone_configs(&crate::packs::Source::Dir(dir.join("pack"))),
        );
@@ -1,5 +1,6 @@
 //! The Horizon Extras page, on the settings shell (`settings_shell`): which rows it has and what
-//! pressing them does. Each one's value and what it does stay in `extras::Item`.
+//! pressing them does. Each one's value and what it does stay in `extras::Item`; the sections crates
+//! add (`horizon_hooks::pages::Place::Extras`) keep theirs.
 use crate::{
    extras::{self, Item},
    lang,
@@ -7,6 +8,7 @@ use crate::{
    settings::Settings,
    settings_shell::{self as shell, Binding, Group, Output, Row, Screen, Sheet, Value},
 };
+use horizon_hooks::pages::{self as added, Act, Label};

 const TITLE: &str = "horizon.pages.extras";
 const ABOUT: &str = "horizon.pages.extras.tooltip";
@@ -31,6 +33,125 @@ pub(crate) enum ExtraRow {
    /// It isn't installed: where to get it. A note, not a button: Options > Mods already has the
    /// one way into the Mods page (`every_setting_and_page_is_reached_from_one_place`).
    ZoomInstall,
+    /// Row `.1` of the section registered page `.0` adds (`Place::Extras`).
+    Added(usize, usize),
+}
+
+#[cfg(test)]
+thread_local! {
+    /// A test's own pages, instead of the game's registered ones: each test runs on its thread.
+    static TEST_PAGES: std::cell::Cell<Option<&'static [&'static dyn added::Page]>> =
+        const { std::cell::Cell::new(None) };
+}
+
+/// The pages crates registered, all places.
+fn pages() -> &'static [&'static dyn added::Page] {
+    #[cfg(test)]
+    if let Some(pages) = TEST_PAGES.get() {
+        return pages;
+    }
+    added::engine::all()
+}
+
+/// The sections of this page, by their index among the registered pages.
+fn sections() -> impl Iterator<Item = (usize, &'static dyn added::Page)> {
+    let pages = pages().iter().copied().enumerate();
+    pages.filter(|(_, page)| page.place() == added::Place::Extras)
+}
+
+fn label_text(label: Label) -> String {
+    match label {
+        Label::Key(key) => lang::get(key),
+        Label::Value(text) => text,
+    }
+}
+
+/// The page's group named `name`, made at the end if it has none.
+fn group_named<'a>(
+    groups: &'a mut Vec<Group<ExtraRow>>,
+    name: &'static str,
+) -> &'a mut Group<ExtraRow> {
+    let at = groups.iter().position(|group| group.name == name);
+    let at = at.unwrap_or_else(|| {
+        groups.push(Group {
+            name,
+            rows: Vec::new(),
+        });
+        groups.len() - 1
+    });
+    &mut groups[at]
+}
+
+/// The sections' rows, in the groups their titles and headings name.
+fn add_sections(groups: &mut Vec<Group<ExtraRow>>) {
+    for (page, section) in sections() {
+        let mut rows = Vec::new();
+        section.rows(&mut rows);
+        let mut name = section.title();
+        for (r, row) in rows.into_iter().enumerate() {
+            let id = ExtraRow::Added(page, r);
+            let row = match row {
+                added::Row::Heading(key) => {
+                    name = key;
+                    continue;
+                }
+                added::Row::Note(text) => Row::new(id, text, Value::Note).live(false),
+                added::Row::Toggle { label, on } => {
+                    Row::new(id, lang::get(label), Value::Switch(on))
+                }
+                added::Row::Cycle { label, value } => {
+                    Row::new(id, lang::get(label), Value::Choice(label_text(value)))
+                }
+                added::Row::Slider { label, value, text } => {
+                    let position = value.clamp(0.0, 1.0);
+                    let text = label_text(text);
+                    let value = Value::Slider {
+                        position,
+                        steps: None,
+                        text,
+                    };
+                    Row::new(id, lang::get(label), value)
+                }
+                added::Row::Button {
+                    label,
+                    active: true,
+                    ..
+                } => Row::new(id, lang::get(label), Value::Press),
+                added::Row::Key { label, key } => {
+                    let key = crate::keybinds::display_name(&key).plain();
+                    Row::new(id, lang::get(label), Value::Read(key))
+                }
+                // A row kind newer than this engine.
+                _ => continue,
+            };
+            let row = match section.tooltip(r) {
+                Some(about) => row.about(label_text(about)),
+                None => row,
+            };
+            group_named(groups, name).rows.push(row);
+        }
+    }
+}
+
+/// Row `r` of registered page `page` was acted on: the options screen saves when it closes.
+fn act(page: usize, r: usize, act: Act) -> Vec<Output> {
+    let Some(section) = pages().get(page) else {
+        return Vec::new();
+    };
+    section.act(r, act);
+    vec![Output::Event(Event::Changed)]
+}
+
+/// Whether row `r` of registered page `page` steps (a switch or a cycle).
+fn steps(page: usize, r: usize) -> bool {
+    let mut rows = Vec::new();
+    if let Some(section) = pages().get(page) {
+        section.rows(&mut rows);
+    }
+    matches!(
+        rows.get(r),
+        Some(added::Row::Toggle { .. } | added::Row::Cycle { .. })
+    )
 }

 fn item_row(item: Item, s: &Settings) -> Row<ExtraRow> {
@@ -85,9 +206,14 @@ impl Screen for ExtrasScreen {
    fn note_lines(&self) -> usize {
        NOTE_LINES
    }
-    /// The rows read the extras, the mods and whether cosmetics are offered.
+    /// The rows read the extras, the mods, whether cosmetics are offered and the sections' rows.
    fn stamp(&self, s: &Settings) -> u64 {
-        shell::stamp_of(&(&s.extras, &s.mods, horizon_cosmetics::enabled()))
+        let mut added = Vec::new();
+        for (_, section) in sections() {
+            section.rows(&mut added);
+        }
+        let cosmetics = horizon_cosmetics::enabled();
+        shell::stamp_of(&(&s.extras, &s.mods, cosmetics, added))
    }
    fn sheets(&self, s: &Settings) -> Vec<Sheet<(), ExtraRow>> {
        let mut groups = vec![Group {
@@ -107,6 +233,7 @@ impl Screen for ExtrasScreen {
                }
            }
        }
+        add_sections(&mut groups);
        vec![Sheet::new((), lang::get(TITLE), lang::get(ABOUT), groups)]
    }
    fn press(&mut self, s: &mut Settings, row: ExtraRow, back: bool) -> Vec<Output> {
@@ -125,16 +252,29 @@ impl Screen for ExtrasScreen {
                Output::Event(Event::NativeSettings(i)),
            ],
            ExtraRow::ZoomInstall => Vec::new(),
+            ExtraRow::Added(page, r) => {
+                act(page, r, if back { Act::PressBack } else { Act::Press })
+            }
+        }
+    }
+    fn slide(&mut self, _s: &mut Settings, row: ExtraRow, position: f32) {
+        if let ExtraRow::Added(page, r) = row {
+            act(page, r, Act::Slide(position));
        }
    }
    /// With the wheel extra on, the wheel over an item changes it, without a click; the mod's rows
    /// let the list scroll.
    fn wheel_step(&mut self, s: &mut Settings, row: ExtraRow, back: bool) -> Option<Vec<Output>> {
-        let ExtraRow::Item(item) = row else {
-            return None;
-        };
-        item.cycle(&mut s.extras, back);
-        Some(vec![Output::Event(Event::Changed)])
+        match row {
+            ExtraRow::Item(item) => {
+                item.cycle(&mut s.extras, back);
+                Some(vec![Output::Event(Event::Changed)])
+            }
+            ExtraRow::Added(page, r) if steps(page, r) => {
+                Some(act(page, r, if back { Act::PressBack } else { Act::Press }))
+            }
+            _ => None,
+        }
    }
 }

@@ -292,4 +432,146 @@ mod tests {
        shell.key(&mut s, K::ArrowDown, None, false, size);
        assert_eq!(shell.focused_row(), Some(first));
    }
+
+    /// A section with a switch in the page's Multiplayer group, then a heading of its own with a
+    /// number that steps either way, a note and a volume.
+    struct Section {
+        on: std::sync::Mutex<bool>,
+        step: std::sync::Mutex<i32>,
+        volume: std::sync::Mutex<f32>,
+    }
+    impl added::Page for Section {
+        fn id(&self) -> &'static str {
+            "test.section"
+        }
+        fn title(&self) -> &'static str {
+            "horizon.extras.header.multiplayer"
+        }
+        fn place(&self) -> added::Place {
+            added::Place::Extras
+        }
+        fn rows(&self, rows: &mut Vec<added::Row>) {
+            rows.push(added::Row::Toggle {
+                label: "test.section.switch",
+                on: *self.on.lock().unwrap(),
+            });
+            rows.push(added::Row::Heading("test.section.heading"));
+            rows.push(added::Row::Cycle {
+                label: "test.section.step",
+                value: Label::Value(self.step.lock().unwrap().to_string()),
+            });
+            rows.push(added::Row::Note("a note".into()));
+            rows.push(added::Row::Slider {
+                label: "test.section.volume",
+                value: *self.volume.lock().unwrap(),
+                text: Label::Value(String::new()),
+            });
+        }
+        fn act(&self, row: usize, act: Act) {
+            match (row, act) {
+                (0, Act::Press | Act::PressBack) => {
+                    let mut on = self.on.lock().unwrap();
+                    *on = !*on;
+                }
+                (2, Act::Press) => *self.step.lock().unwrap() += 1,
+                (2, Act::PressBack) => *self.step.lock().unwrap() -= 1,
+                (4, Act::Slide(v)) => *self.volume.lock().unwrap() = v,
+                _ => {}
+            }
+        }
+    }
+
+    /// A page for Horizon Settings: never on Extras.
+    struct Elsewhere;
+    impl added::Page for Elsewhere {
+        fn id(&self) -> &'static str {
+            "test.elsewhere"
+        }
+        fn title(&self) -> &'static str {
+            "test.elsewhere"
+        }
+        fn place(&self) -> added::Place {
+            added::Place::HorizonSettings
+        }
+        fn rows(&self, rows: &mut Vec<added::Row>) {
+            rows.push(added::Row::button("test.elsewhere.button"));
+        }
+        fn act(&self, _: usize, _: Act) {}
+    }
+
+    fn with_section() -> &'static Section {
+        let section: &'static Section = Box::leak(Box::new(Section {
+            on: false.into(),
+            step: 0.into(),
+            volume: 0.5.into(),
+        }));
+        let pages: &'static [&'static dyn added::Page] = Box::leak(Box::new([
+            &Elsewhere as &dyn added::Page,
+            section as &dyn added::Page,
+        ]));
+        TEST_PAGES.set(Some(pages));
+        section
+    }
+
+    /// The section's first row joins the page's own Multiplayer group, after its rows; its heading
+    /// starts a group after the page's; a page for elsewhere adds nothing.
+    #[test]
+    fn a_section_joins_the_group_its_title_names_and_heads_its_own() {
+        with_section();
+        let s = Settings::default();
+        let sheets = ExtrasScreen.sheets(&s);
+        let groups = &sheets[0].groups;
+        let ids = |name: &str| -> Vec<ExtraRow> {
+            let group = groups.iter().find(|g| g.name == name).unwrap();
+            group.rows.iter().map(|r| r.id).collect()
+        };
+        let multiplayer = ids("horizon.extras.header.multiplayer");
+        assert_eq!(multiplayer.last(), Some(&ExtraRow::Added(1, 0)));
+        assert_eq!(groups.last().unwrap().name, "test.section.heading");
+        let own = [
+            ExtraRow::Added(1, 2),
+            ExtraRow::Added(1, 3),
+            ExtraRow::Added(1, 4),
+        ];
+        assert_eq!(ids("test.section.heading"), own);
+        let all = rows_of(&s);
+        assert!(!all.iter().any(|r| matches!(r.id, ExtraRow::Added(0, _))));
+    }
+
+    /// A click flips the switch, a Shift click steps the number back, the wheel steps it, and the
+    /// note takes no click; the rows show what the section holds after each.
+    #[test]
+    fn a_sections_rows_act_on_it() {
+        let section = with_section();
+        let mut s = Settings::default();
+        let mut shell = Shell::<ExtrasScreen>::default();
+        let switch = ExtraRow::Added(1, 0);
+        let at = shell.point_at(&s, SIZE, switch);
+        assert!(
+            !shell
+                .click(&mut s, at, SIZE, false, false, false)
+                .is_empty()
+        );
+        assert!(*section.on.lock().unwrap());
+        let value = |s: &Settings, id| rows_of(s).into_iter().find(|r| r.id == id).unwrap().value;
+        assert_eq!(value(&s, switch), Value::Switch(true));
+        let step = ExtraRow::Added(1, 2);
+        let mut screen = ExtrasScreen;
+        screen.press(&mut s, step, true);
+        assert_eq!(value(&s, step), Value::Choice("-1".into()));
+        assert!(screen.wheel_step(&mut s, step, false).is_some());
+        assert_eq!(*section.step.lock().unwrap(), 0);
+        assert_eq!(
+            screen.wheel_step(&mut s, ExtraRow::Added(1, 3), false),
+            None
+        );
+        let note = shell.point_at(&s, SIZE, ExtraRow::Added(1, 3));
+        assert!(
+            shell
+                .click(&mut s, note, SIZE, false, false, false)
+                .is_empty()
+        );
+        screen.slide(&mut s, ExtraRow::Added(1, 4), 0.25);
+        assert_eq!(*section.volume.lock().unwrap(), 0.25);
+    }
 }
@@ -231,8 +231,10 @@ pub struct FogInputs<'a> {
    /// `GameRenderer.nightVisionScale` while Night Vision is on without
    /// Darkness, else 0 (`FogRenderer.computeFogColor`'s brightenFactor).
    pub night_vision: f32,
-    /// The packs' Polytone `environment` fog settings.
-    pub environment: horizon_polytone::colors::Environment,
+    /// The packs' `environment` fog settings (Polytone's).
+    pub environment: crate::pack_palette::Environment,
+    /// The packs' fluid modifiers' fog.
+    pub fluid_fog: crate::pack_palette::FluidFogs,
 }

 /// `FogRenderer.setupFog` + `computeFogColor`.
@@ -397,6 +399,24 @@ pub fn setup_fog(tables: &FogTables, state: &FogState, input: &FogInputs) -> Fog
            }
        }
    }
+    // A pack's fluid modifier over its fluid's fog, after everything else (wiki "Custom Colors").
+    let fluid = match input.fog_type {
+        FogType::Lava => input.fluid_fog.lava,
+        FogType::Water if input.blindness.is_none() && input.darkness.is_none() => {
+            input.fluid_fog.water
+        }
+        _ => None,
+    };
+    if let Some(f) = fluid {
+        if let Some(rgb) = f.color {
+            let [r, g, b] = self::rgb(rgb);
+            fog.color = [r, g, b, 1.0];
+        }
+        let end = fog.environmental_end * f.radius;
+        let start = end - (end - fog.environmental_start * f.radius) * f.fade;
+        (fog.environmental_start, fog.environmental_end) = (start, end);
+        (fog.sky_end, fog.cloud_end) = (end, end);
+    }
    let span = (rd / 10.0).clamp(4.0, 64.0);
    fog.render_distance_start = rd - span;
    fog.render_distance_end = rd;
@@ -495,6 +515,7 @@ mod tests {
            full_water_vision: false,
            night_vision: 0.0,
            environment: Default::default(),
+            fluid_fog: Default::default(),
        }
    }
    #[test]
@@ -581,7 +602,7 @@ mod tests {
        let tables = FogTables {
            water_fog_end: vec![1.0],
        };
-        let environment = horizon_polytone::colors::Environment {
+        let environment = crate::pack_palette::Environment {
            powder_snow_fog: Some(0xFF0000),
            blindness_fog_distance: 40.0,
            water_fog_brightening: 0.0,
@@ -611,9 +632,41 @@ mod tests {
        let kept = setup_fog(&tables, &state, &input).color;
        assert_eq!(&kept[..3], &[0.1, 0.2, 0.4]);
    }
+    #[test]
+    fn a_fluid_modifier_scales_and_colours_its_fog_last() {
+        let sky = Sky {
+            fog_start: 10.0,
+            fog_end: 96.0,
+            ..Sky::default()
+        };
+        let tables = FogTables {
+            water_fog_end: vec![1.0],
+        };
+        let mut input = inputs(&sky);
+        input.fog_type = FogType::Lava;
+        input.fire_resistance = true;
+        let vanilla = setup_fog(&tables, &FogState::default(), &input);
+        assert_eq!(
+            (vanilla.environmental_start, vanilla.environmental_end),
+            (0.0, 5.0)
+        );
+        input.fluid_fog.lava = Some(crate::pack_palette::FluidFog {
+            color: Some(0x00FF00),
+            radius: 2.0,
+            fade: 0.5,
+        });
+        let fog = setup_fog(&tables, &FogState::default(), &input);
+        assert_eq!(fog.color, [0.0, 1.0, 0.0, 1.0]);
+        // The end doubles; half the fade from 0 to 10 starts it at 5.
+        assert_eq!(
+            (fog.environmental_start, fog.environmental_end),
+            (5.0, 10.0)
+        );
+        assert_eq!((fog.sky_end, fog.cloud_end), (10.0, 10.0));
+    }
    fn inputs_with<'a>(
        input: &FogInputs<'a>,
-        environment: horizon_polytone::colors::Environment,
+        environment: crate::pack_palette::Environment,
    ) -> FogInputs<'a> {
        FogInputs {
            environment,
@@ -201,6 +201,7 @@ pub use hdr::{Calibration as HdrCalibration, Output as HdrOutput};
 mod hold;
 pub use hold::WorldHold;
 pub use output::{DisplayReading, EffectiveOutput, FrameConfiguration, FrameRequest};
+pub use screenshot_save::Saved as SavedScreenshot;
 pub mod block_light;
 mod custom_sky;
 mod displace;
@@ -236,9 +237,11 @@ pub mod panorama;
 mod readback;
 mod resident;
 mod reuse;
+mod screenshot_save;
 mod stars;
 mod surface_setup;
 use surface_setup::{AdapterChoice, AdapterFailure, open_adapter, pick_adapter, set_up_surface};
+mod off_page;
 pub mod submit;
 mod sunrise_fan;
 mod timing;
@@ -250,6 +253,7 @@ mod wgsl_prefix;
 mod world_post;
 pub mod world_primitives;
 mod world_warp;
+use off_page::move_off_page;

 /// A section's instance: its camera-relative origin and, in `w`, the step of
 /// its fixed-point UVs (`terrain.wgsl`'s `terrain_uv`).
@@ -726,62 +730,6 @@ impl Part {
        }
    }
 }
-/// `Renderer::compact_arena`'s and `shrink_translucent`'s moves: what the meshes
-/// hold on `page` of `arena` (`part`) goes to its other pages in video memory,
-/// until the next range would pass `budget` bytes (it keeps what is left; the
-/// first range moves whatever its size, so none keeps the page closed), the
-/// copies into `encoder`, the ranges' flat draw ids (`flat`) and, in the
-/// section arena, GPU culling's records (`records`) along. False when the other
-/// pages have no room left.
-fn move_off_page<'a>(
-    arena: &mut arena::Arena,
-    encoder: &mut wgpu::CommandEncoder,
-    mut flat: Option<(&mut flat::Flat, &wgpu::Device, &mut upload::Uploads)>,
-    mut records: Option<&mut gpu_culling::Records>,
-    meshes: impl Iterator<Item = &'a mut SectionGpu>,
-    page: u32,
-    part: Part,
-    budget: &mut u64,
-) -> bool {
-    debug_assert!(
-        records.is_none() || matches!(part, Part::Section { .. }),
-        "records follow the section arena's ranges"
-    );
-    let mut moved = false;
-    for s in meshes {
-        // Nothing of a mesh here: split, one without solid quads (its (0, 0) is no
-        // range of page 0); in the other arenas, one without translucent quads.
-        let Some((_, start, vertices)) = part.of(s).filter(|r| r.0 == page) else {
-            continue;
-        };
-        let bytes = vertices * arena.stride();
-        if moved && bytes > *budget {
-            break;
-        }
-        let Some(to) = arena.alloc_moved(vertices) else {
-            return false;
-        };
-        arena.copy(encoder, (page, start), to, vertices);
-        arena.release(page, start, vertices);
-        if let (Some((flat, device, uploads)), Some(id)) = (&mut flat, s.flat_id) {
-            let key = match part {
-                Part::Translucent => to.0 + flat::TRANSLUCENT_KEYS,
-                _ => to.0,
-            };
-            flat.place(device, encoder, uploads, id, key, to.1, vertices);
-        }
-        part.set(s, to);
-        // Its solid quads start the range in either layout.
-        if let (Part::Section { .. }, Some(records), Some(id)) =
-            (part, records.as_deref_mut(), s.gpu_id)
-        {
-            records.relocate(id, to.0, u64::from(s.solid_base()));
-        }
-        *budget = budget.saturating_sub(bytes);
-        moved = true;
-    }
-    true
-}
 /// Starts moving a page of a large arena far larger than its ranges in use
 /// (`Arena::oversized`) into a new page of the size they get (`Arena::open_page`),
 /// for `Renderer::shrink_translucent`: the page closes and `move_off_page` empties
@@ -1001,8 +949,8 @@ pub struct Frame<'a> {
    pub outline_after_terrain: bool,
    /// `BlockOutlineRenderState.highContrast`: a thick black outline under a bright one.
    pub outline_high_contrast: bool,
-    /// The outline, hurt overlay and glint colours a crate above set (`horizon_hooks::look`).
-    pub look: horizon_hooks::look::Frame,
+    /// The PvP & HUD page's outline and hit colour (`pvp::Frame`; default: vanilla's).
+    pub pvp: crate::pvp::Frame,
    /// `lines` with a colour and pixel width (`gizmos::camera_relative`):
    /// the fishing line and debug gizmos, depth tested, then gizmos drawn
    /// over everything.
@@ -1138,6 +1086,9 @@ pub struct ScreenshotRequest {
    /// F2's: drawn at the game's resolution (Resolution Scale above 100%) times
    /// `Renderer::screenshot_quality`, not the window's.
    pub scaled: bool,
+    /// Written on a thread of its own (F2's, the world icon's): its outcome comes back a
+    /// frame or a few later in `Renderer::saved_screenshots`, not `screenshot_result`.
+    pub background: bool,
 }
 /// A solid terrain pipeline without HDR output's lighting (terrain.wgsl's `HDR_LIGHTING`),
 /// for the frames HDR is off, and with it where the display offers HDR output: the
@@ -1329,7 +1280,7 @@ pub struct Renderer {
    celestial_buffer: wgpu::Buffer,
    end_sky: end_sky::EndSky,
    stars: stars::Stars,
-    /// OptiFine custom sky layers (`crate::custom_sky`), and the frame's from the game.
+    /// Custom sky layers (`crate::custom_sky`), and the frame's from the game.
    custom_sky: custom_sky::CustomSky,
    custom_sky_draws: Vec<crate::custom_sky::Draw>,
    /// The glowing entities' outline (`LevelRenderer.entityOutlineTarget`).
@@ -1632,6 +1583,9 @@ pub struct Renderer {
    pub screenshot_result: Option<std::result::Result<[u32; 2], String>>,
    /// The HDR copy the last screenshot wrote beside it, if it wrote one.
    pub screenshot_hdr: Option<std::path::PathBuf>,
+    /// `background` screenshots written since the caller last took them.
+    pub saved_screenshots: Vec<SavedScreenshot>,
+    screenshot_saves: screenshot_save::Saves,
    /// Screenshot Quality (Horizon setting): a `scaled` screenshot's frame is this many
    /// times the game's resolution (1, 2, 4 or 8).
    pub screenshot_quality: u32,
@@ -5131,6 +5085,7 @@ impl Renderer {
            ));
        }
        let world_primitives = world_primitives::WorldPrimitives::new(&device, frame_format);
+        let screenshot_saves = screenshot_save::Saves::new(&device);
        Ok(Self {
            display: None,
            reading: display,
@@ -5402,6 +5357,8 @@ impl Renderer {
            screenshot: None,
            screenshot_result: None,
            screenshot_hdr: None,
+            saved_screenshots: Vec::new(),
+            screenshot_saves,
            screenshot_quality: 1,
            screenshot_halvings: 0,
            gamma: 0.5,
@@ -5517,11 +5474,11 @@ impl Renderer {
            ))
        });
    }
-    /// The pack's OptiFine custom sky layer textures (`crate::custom_sky::CustomSky::load`).
-    pub fn set_custom_sky(&mut self, pack: &crate::custom_sky::CustomSky) {
+    /// The pack's custom sky layer textures (`crate::custom_sky::load`).
+    pub fn set_custom_sky(&mut self, pack: &dyn crate::custom_sky::SkyLayers) {
        self.custom_sky.set_pack(&self.device, &self.queue, pack);
    }
-    /// The custom sky layers the next frame draws (`CustomSky::draws`): the game refills it each
+    /// The custom sky layers the next frame draws (`SkyLayers::draws`): the game refills it each
    /// frame, empty when the world's sky has none.
    pub fn custom_sky_draws(&mut self) -> &mut Vec<crate::custom_sky::Draw> {
        &mut self.custom_sky_draws
@@ -7095,8 +7052,10 @@ impl Renderer {
        }
    }
    /// This renderer's output as applied, with what its destination offers and reports.
-    pub fn output(&self) -> &output::EffectiveOutput {
-        &self.output
+    pub fn output(&self) -> output::EffectiveOutput {
+        let native = self.native.as_ref().map(|n| n.frame.api);
+        self.output
+            .with_pack(self.shader_pack_kind() == Some("iris"), native)
    }
    /// What this renderer's display last reported: a renderer made again for the window
    /// starts from it (`Renderer::new`'s `display`).
@@ -8029,6 +7988,8 @@ impl Renderer {
        if self.device_lost() {
            return Err("the graphics device was lost".into());
        }
+        let saved = self.screenshot_saves.finished();
+        self.saved_screenshots.extend(saved);
        if let Some(request) = self.capture.take() {
            let result = self.write_capture(&request, frame);
            self.capture_result = Some(result.map_err(|e| e.to_string()));
@@ -8373,9 +8334,7 @@ impl Renderer {
        let taa = !frame.title
            && self.pack_post.as_ref().is_none_or(|p| p.1.is_none())
            && self.native.as_ref().is_none_or(|n| n.post.is_none());
-        let hdr_lighting = self.native.is_none()
-            && self.pack_post.as_ref().is_none_or(|p| p.1.is_none())
-            && std::env::var_os("HORIZON_HDR_LIGHTING").is_none_or(|v| v != "0");
+        let hdr_lighting = self.shader_pack_kind().is_none();
        if let Some(hdr) = &mut self.hdr {
            hdr.lighting = hdr_lighting && hdr.look;
        }
@@ -8506,9 +8465,9 @@ impl Renderer {
            colored_count: [
                frame.colored_lights.len().min(crate::dynamic_light::MAX) as u32,
                // PvP & HUD's hit colour: entity.wgsl's hurt texel, 0 for vanilla's.
-                frame.look.hurt_texel,
+                frame.pvp.hurt_texel,
                // PvP & HUD's glint colour: entity.wgsl's `tinted_glint`, 0 for vanilla's.
-                frame.look.glint,
+                frame.pvp.glint,
                0,
            ],
            emissive_layers: {
@@ -9495,7 +9454,7 @@ impl Renderer {
                }
            };
            // A custom outline (PvP & HUD) takes the bright stroke's colour, scales both widths.
-            let (custom, scale) = frame.look.outline.map_or((None, 1.0), |o| (Some(o.0), o.1));
+            let (custom, scale) = frame.pvp.outline.map_or((None, 1.0), |(c, s)| (Some(c), s));
            if frame.outline_high_contrast {
                stroke(0xff00_0000, 7.0 * scale, lines);
                stroke(custom.unwrap_or(0xff57_ffe1), width * scale, lines);
@@ -10116,7 +10075,11 @@ impl Renderer {
        let pack_reads_world = pack_post || native_post;
        laps.lap("r_uploads");
        // Phase 2 of occlusion culling draws over the depth, and a shader pack or TAA reads it.
+        // Post effects (a resource pack's chains, `use_depth_buffer`) read the world's depth
+        // after the world pass, as `GameRenderer.render` hands them the main target's.
+        let post_reads_depth = !frame.title && !frame.post_effects.effects.is_empty();
        let keep_depth = pack_reads_world
+            || post_reads_depth
            || (taa && self.world_post.taa)
            || oit_on
            || native_render::render_needs().world_depth
@@ -12094,24 +12057,18 @@ impl Renderer {
                self.screenshot = Some(request);
            } else {
                self.screenshot_halvings = 0;
-                self.screenshot_hdr = None;
-                if let Some(hdr_buffer) = hdr_readback {
-                    let hdr_path = hdr_screenshot_path(&request.path);
-                    match self.write_hdr_screenshot(&hdr_path, &hdr_buffer) {
-                        Ok(()) => {
-                            log::info!("Saved HDR screenshot to {}", hdr_path.display());
-                            self.screenshot_hdr = Some(hdr_path);
-                        }
-                        Err(e) => log::warn!(
-                            "Horizon renderer: HDR screenshot {}: {e}",
-                            hdr_path.display()
-                        ),
-                    }
+                let size = [self.config.width, self.config.height];
+                let hdr = hdr_readback
+                    .filter(|_| self.hdr.is_some())
+                    .map(|b| (hdr_screenshot_path(&request.path), b));
+                let shot = screenshot_save::Shot::new(&request, size, self.config.format, hdr);
+                if request.background {
+                    self.screenshot_saves.start(shot, buffer);
+                } else {
+                    let saved = screenshot_save::save_now(&self.device, shot, &buffer);
+                    self.screenshot_hdr = saved.hdr;
+                    self.screenshot_result = Some(saved.result);
                }
-                self.screenshot_result = Some(
-                    self.write_screenshot(&request, &buffer)
-                        .map_err(|e| e.to_string()),
-                );
            }
        }
        // The frame's own waits for the submit thread (its queue writes and passes).
@@ -12714,96 +12671,22 @@ impl Renderer {
            let texture = copy.as_ref().unwrap_or(texture);
            Some((request, copy_frame(&self.device, encoder, texture, size)))
        } else {
-            self.screenshot_result = Some(Err(format!(
+            let error = format!(
                "screenshots need a 32-bit surface format, not {:?}",
                self.config.format
-            )));
+            );
+            if request.background {
+                self.saved_screenshots.push(screenshot_save::Saved {
+                    path: request.path,
+                    result: Err(error),
+                    hdr: None,
+                });
+            } else {
+                self.screenshot_result = Some(Err(error));
+            }
            None
        }
    }
-    /// The pixels `copy_frame` read back into `buffer`, 4 bytes each, row after row.
-    fn read_frame(&self, buffer: &wgpu::Buffer) -> Result<Vec<[u8; 4]>> {
-        let (sender, receiver) = std::sync::mpsc::channel();
-        buffer.map_async(wgpu::MapMode::Read, .., move |r| {
-            let _ = sender.send(r);
-        });
-        self.device
-            .poll(wgpu::PollType::wait_indefinitely())
-            .map_err(|e| e.to_string())?;
-        receiver
-            .recv()
-            .map_err(|e| e.to_string())?
-            .map_err(|e| e.to_string())?;
-        let (width, height, row) = (
-            self.config.width as usize,
-            self.config.height as usize,
-            padded_row(self.config.width) as usize,
-        );
-        let mut pixels = Vec::with_capacity(width * height);
-        {
-            let data = buffer.get_mapped_range(..).map_err(|e| e.to_string())?;
-            for y in 0..height {
-                pixels.extend_from_slice(data[y * row..y * row + width * 4].as_chunks::<4>().0);
-            }
-        }
-        buffer.unmap();
-        Ok(pixels)
-    }
-    fn write_screenshot(
-        &self,
-        request: &ScreenshotRequest,
-        buffer: &wgpu::Buffer,
-    ) -> Result<[u32; 2]> {
-        let bgra = matches!(
-            self.config.format.remove_srgb_suffix(),
-            wgpu::TextureFormat::Bgra8Unorm
-        );
-        let mut pixels = Vec::with_capacity((self.config.width * self.config.height * 4) as usize);
-        for px in self.read_frame(buffer)? {
-            let (r, b) = if bgra { (px[2], px[0]) } else { (px[0], px[2]) };
-            pixels.extend_from_slice(&[r, px[1], b, 255]);
-        }
-        // NativeImage.resizeSubRectTo on takeAutoScreenshot's grab: the icon
-        // is the frame's centre square averaged down to its size.
-        let (width, height, pixels) = match request.size {
-            Some(size) => (
-                size[0],
-                size[1],
-                square_downscale(&pixels, self.config.width, self.config.height, size),
-            ),
-            None => (self.config.width, self.config.height, pixels),
-        };
-        let mut encoder = png::Encoder::new(
-            std::io::BufWriter::new(std::fs::File::create(&request.path)?),
-            width,
-            height,
-        );
-        encoder.set_color(png::ColorType::Rgba);
-        encoder.set_depth(png::BitDepth::Eight);
-        encoder.write_header()?.write_image_data(&pixels)?;
-        Ok([width, height])
-    }
-    /// The HDR10 copy (`Hdr::capture`) as a 16-bit PNG tagged BT.2020 with PQ (cICP, PNG's
-    /// third edition), with the content light levels its pixels hold (cLLI), and
-    /// an ICC profile for the programs that don't read cICP (`hdr_icc`).
-    fn write_hdr_screenshot(&self, path: &std::path::Path, buffer: &wgpu::Buffer) -> Result<()> {
-        if self.hdr.is_none() {
-            return Ok(());
-        }
-        let pixels = hdr10_to_rgb16(&self.read_frame(buffer)?);
-        let mut info = png::Info::with_size(self.config.width, self.config.height);
-        info.color_type = png::ColorType::Rgb;
-        info.bit_depth = png::BitDepth::Sixteen;
-        info.icc_profile = Some(hdr_icc::profile().into());
-        let encoder =
-            png::Encoder::with_info(std::io::BufWriter::new(std::fs::File::create(path)?), info)?;
-        let mut writer = encoder.write_header()?;
-        // BT.2020 primaries, PQ, RGB, full range.
-        writer.write_chunk(png::chunk::cICP, &[9, 16, 0, 1])?;
-        writer.write_chunk(png::chunk::cLLI, &hdr_icc::content_light_levels(&pixels))?;
-        writer.write_image_data(&pixels)?;
-        Ok(())
-    }
 }
 /// `screenshots/2026-10-28_12.00.00.png` -> `screenshots/2026-10-28_12.00.00-hdr.png`.
 fn hdr_screenshot_path(path: &std::path::Path) -> PathBuf {
@@ -13714,6 +13597,7 @@ mod tests {
            Some(Reported {
                paper_white: 240,
                peak: 998,
+                peak_guessed: true,
            })
        );
        assert_eq!(
@@ -13721,6 +13605,7 @@ mod tests {
            Some(Reported {
                paper_white: 480,
                peak: 480,
+                peak_guessed: true,
            })
        );
        // White above the calibrated peak (a Samsung QD-OLED's 380, the slider at 456).
@@ -13729,6 +13614,7 @@ mod tests {
            Some(Reported {
                paper_white: 456,
                peak: 456,
+                peak_guessed: true,
            })
        );
        assert_eq!(os_reported(&info(Some(1000.0), None)), None);
@@ -15419,11 +15305,9 @@ fn log_os_reported(reported: Option<crate::graphics::Reported>) {
        None => "Horizon renderer: the system doesn't report the display's luminance".into(),
    });
 }
-/// What the OS reports in absolute nits (Windows: DXGI's `MaxLuminance` and the SDR
-/// white level the brightness slider sets), which is HDR output's scale there: SDR
-/// white is Paper White, the display's peak is Peak Brightness. Both are kept within
-/// the settings' ranges. The OS's figures often come from the display's EDID and may
-/// run optimistic; the player's own value always wins.
+/// What the OS reports in absolute nits, HDR output's scale (Windows: DXGI's SDR white level,
+/// the brightness slider's, as Paper White, and its `MaxLuminance`, mostly the display's EDID
+/// guess, as Peak Brightness), kept within the settings' ranges. The player's values win.
 fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported> {
    let luminance = info.luminance?;
    let usable = |n: f32| n.is_finite() && n > 0.0;
@@ -15435,6 +15319,7 @@ fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported>
        // Windows' SDR brightness slider can set white above the reported peak (480 against
        // a calibrated 380): the highlights then stay at white instead of dropping below it.
        peak: (peak.round() as u32).clamp(200, 10_000).max(paper_white),
+        peak_guessed: true,
    })
 }

@@ -15470,6 +15355,7 @@ fn reported(l: horizon_hdr::wayland::Luminances) -> crate::graphics::Reported {
    crate::graphics::Reported {
        paper_white: 203,
        peak: peak.clamp(200, 10_000),
+        peak_guessed: false,
    }
 }

@@ -15718,11 +15604,11 @@ mod shadow_caster_tests {
    #[test]
    fn the_shadow_pass_draws_terrain_outside_the_pack_s_planes() {
        let kept = |near: Option<f32>, far: Option<f32>, y: f64, min: [f32; 3], depth: bool| {
-            let shadow = horizon_render_pipeline::Shadow {
+            let shadow = horizon_shaders::Shadow {
                distance: 128.0,
                near,
                far,
-                ..horizon_render_pipeline::Shadow::default()
+                ..horizon_shaders::Shadow::default()
            };
            let camera = DVec3::new(13.5, y + 1.62, -13.5);
            let view = pack_post::ShadowView {
@@ -524,7 +524,7 @@ impl Scene {
            outline: Vec::new(),
            outline_after_terrain: false,
            outline_high_contrast: false,
-            look: Default::default(),
+            pvp: Default::default(),
            debug_lines: &[],
            debug_lines_on_top: &[],
            debug_crosshair: &[],
@@ -1,12 +1,11 @@
-//! OptiFine custom sky layers on the GPU: one texture per layer, kept with the renderer (its pack),
+//! Custom sky layers (`crate::custom_sky`) on the GPU: one texture per layer, kept with the renderer (its pack),
 //! a static skybox mesh of the 3x2 grid's six faces, and one pipeline per blend mode. A frame
 //! uploads one small uniform per drawn layer ([`crate::custom_sky::Draw`]) and draws 36 vertices
 //! each, after the vanilla sky's disc and sunrise and before the sun, moon and stars.
 use glam::Mat4;
-use horizon_optifine::sky::{Blend, Face};
 use wgpu::util::DeviceExt;

-use crate::custom_sky::{CustomSky as Pack, Draw};
+use crate::custom_sky::{Blend, Draw, SkyLayers};

 /// The blend modes in the shader's `mode` order (custom_sky.wgsl).
 const MODES: [Blend; 9] = [
@@ -85,6 +84,76 @@ fn blend(mode: Blend) -> wgpu::BlendComponent {
    }
 }

+/// A face of the skybox, as the 3x2 grid of its texture holds them: `Bottom`, `Top`, `South` in
+/// the top row, `West`, `North`, `East` below.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Face {
+    Bottom,
+    Top,
+    South,
+    West,
+    North,
+    East,
+}
+
+impl Face {
+    const ALL: [Self; 6] = [
+        Self::Bottom,
+        Self::Top,
+        Self::South,
+        Self::West,
+        Self::North,
+        Self::East,
+    ];
+
+    /// The face's cell of the texture, `[u0, v0, u1, v1]` in 0..1.
+    fn cell(self) -> [f32; 4] {
+        let (col, row) = match self {
+            Self::Bottom => (0, 0),
+            Self::Top => (1, 0),
+            Self::South => (2, 0),
+            Self::West => (0, 1),
+            Self::North => (1, 1),
+            Self::East => (2, 1),
+        };
+        let (u, v) = (col as f32 / 3.0, row as f32 / 2.0);
+        [u, v, u + 1.0 / 3.0, v + 0.5]
+    }
+
+    /// The face's corners (on the unit cube around the camera; x east, y up, z south) in the
+    /// order of its cell's `(u0, v0)`, `(u1, v0)`, `(u1, v1)`, `(u0, v1)`. The side faces are
+    /// seen from inside with up at the top of their cell; the top face has north at the bottom of
+    /// its cell, the bottom face north at the top (the template's `N` marks).
+    fn corners(self) -> [[f32; 3]; 4] {
+        match self {
+            // Seen looking north: west on the left.
+            Self::North => [
+                [-1., 1., -1.],
+                [1., 1., -1.],
+                [1., -1., -1.],
+                [-1., -1., -1.],
+            ],
+            Self::South => [[1., 1., 1.], [-1., 1., 1.], [-1., -1., 1.], [1., -1., 1.]],
+            Self::East => [[1., 1., -1.], [1., 1., 1.], [1., -1., 1.], [1., -1., -1.]],
+            Self::West => [
+                [-1., 1., 1.],
+                [-1., 1., -1.],
+                [-1., -1., -1.],
+                [-1., -1., 1.],
+            ],
+            // Looking up with north toward the cell's bottom edge: east on the right.
+            Self::Top => [[-1., 1., 1.], [1., 1., 1.], [1., 1., -1.], [-1., 1., -1.]],
+            // Looking down with north toward the cell's top edge: east on the right.
+            Self::Bottom => [
+                [-1., -1., -1.],
+                [1., -1., -1.],
+                [1., -1., 1.],
+                [-1., -1., 1.],
+            ],
+        }
+    }
+}
+
 /// The skybox's 36 vertices: two triangles per face, each corner with its cell's UV.
 fn mesh() -> Vec<Vertex> {
    let mut out = Vec::with_capacity(36);
@@ -256,10 +325,15 @@ impl CustomSky {
    }

    /// The pack's layer textures, replacing any before.
-    pub(super) fn set_pack(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, pack: &Pack) {
+    pub(super) fn set_pack(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        pack: &dyn SkyLayers,
+    ) {
        let limit = device.limits().max_texture_dimension_2d;
        self.groups = pack
-            .images
+            .images()
            .iter()
            .map(|image| {
                // Too large for this GPU: a 1x1 transparent texel, so the layer draws nothing.
@@ -413,6 +487,38 @@ impl CustomSky {
 mod tests {
    use super::*;

+    #[test]
+    fn the_grid_holds_each_face_once_and_faces_point_out() {
+        let mut cells: Vec<_> = Face::ALL
+            .iter()
+            .map(|f| f.cell().map(|x| (x * 6.0) as i32))
+            .collect();
+        cells.dedup();
+        assert_eq!(cells.len(), 6);
+        assert_eq!(Face::East.cell(), [2.0 / 3.0, 0.5, 1.0, 1.0]);
+        for face in Face::ALL {
+            let c = face.corners();
+            let sub = |a: [f32; 3], b: [f32; 3]| [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+            let (a, b) = (sub(c[1], c[0]), sub(c[3], c[0]));
+            let n = [
+                a[1] * b[2] - a[2] * b[1],
+                a[2] * b[0] - a[0] * b[2],
+                a[0] * b[1] - a[1] * b[0],
+            ];
+            let centre: [f32; 3] =
+                std::array::from_fn(|i| c.iter().map(|p| p[i]).sum::<f32>() / 4.0);
+            // Seen from inside, u runs right and v down, so u x v points away from the camera.
+            let dot: f32 = (0..3).map(|i| n[i] * centre[i]).sum();
+            assert!(dot > 0.0, "{face:?} is mirrored");
+        }
+        // The top cell's bottom edge (v1) is north: its corners 2 and 3 have z = -1.
+        assert_eq!(Face::Top.corners()[2][2], -1.0);
+        assert_eq!(Face::Top.corners()[3][2], -1.0);
+        // The bottom cell's top edge (v0) is north.
+        assert_eq!(Face::Bottom.corners()[0][2], -1.0);
+        assert_eq!(Face::Bottom.corners()[1][2], -1.0);
+    }
+
    /// What a blend leaves a sky texel of `dst` with when the shader outputs `src`
    /// (custom_sky.wgsl) for a layer texel `t` at brightness `b`, per channel.
    fn mix(mode: Blend, dst: f32, t: f32, a: f32, b: f32) -> f32 {
@@ -6,7 +6,7 @@ struct Layer {
    // Projection * view (camera-relative) * the layer's rotation.
    clip_from_sky: mat4x4<f32>,
    brightness: f32,
-    // horizon_optifine::sky::Blend, in gfx/custom_sky.rs's MODES order.
+    // crate::custom_sky::Blend, in gfx/custom_sky.rs's MODES order.
    mode: u32,
    pad: vec2<u32>,
    hdr_settings: vec4<f32>,
@@ -191,7 +191,7 @@ pub struct Hdr {
    pub masks: Masks,
    /// HDR lighting, whether Horizon lifts this frame's world: off under a Horizon shader pack
    /// that draws, while a `shaders/` pack's post or material stage runs (the pack's own),
-    /// with HDR Lighting (`look`) off, and with `HORIZON_HDR_LIGHTING=0`, to compare.
+    /// and with HDR Lighting (`look`) off.
    pub lighting: bool,
    /// The HDR Lighting setting: off, nothing in the world is lifted, light sources and the
    /// sun included, so the picture is SDR's on the HDR canvas.
@@ -1001,12 +1001,14 @@ impl Hdr {
    }
 }

-/// Horizon's icon (horizon-theme) as a 1-bit mask: its white strokes, one colour with hard
-/// edges, are the logo; everything else is not.
+/// The windows' icon (`window::set_icon_png`: Horizon's in the official game) as a 1-bit mask:
+/// its white strokes, one colour with hard edges, are the logo; everything else is not. No icon
+/// given: an empty mask.
 fn logo_mask(device: &wgpu::Device, queue: &wgpu::Queue) -> wgpu::TextureView {
    use wgpu::util::DeviceExt;
-    let (w, h, rgba) =
-        crate::hud::decode_bytes(horizon_theme::ICON_PNG).unwrap_or((1, 1, vec![0; 4]));
+    let (w, h, rgba) = horizon_client_input::window::icon_png()
+        .and_then(|png| crate::hud::decode_bytes(png).ok())
+        .unwrap_or((1, 1, vec![0; 4]));
    let mask: Vec<u8> = rgba
        .as_chunks::<4>()
        .0
@@ -338,7 +338,7 @@ pub struct NativeFrame {
    reflection_sampler: wgpu::Sampler,
    /// The shadow map the stages read, and the camera that draws it when the pack asks for one.
    pub shadow_map: super::native_shadow::ShadowMap,
-    shadow_camera: Option<horizon_render_pipeline::Shadow>,
+    shadow_camera: Option<horizon_shaders::Shadow>,
    /// Whether the pack's material reads `reflection` (`NativePack::new`): else no mirror
    /// is drawn and `has_reflection` stays 0.
    pub reflects: bool,
@@ -1497,7 +1497,7 @@ pub fn frame_inputs(
    size: [u32; 2],
    seconds: f32,
    index: u32,
-    shadow: Option<&horizon_render_pipeline::Shadow>,
+    shadow: Option<&horizon_shaders::Shadow>,
 ) -> FrameInputs {
    let aspect = size[0] as f32 / size[1].max(1) as f32;
    let view = crate::camera::view_matrix(frame.yaw, frame.pitch);
@@ -6,8 +6,8 @@
 //! draw lists (`ShadowView`) serve both; the map's texels are distorted toward the camera as the
 //! prelude's `shadow_position` undoes.

-use horizon_render_pipeline::Shadow;
 use horizon_shader_api::{Api, Frame as FrameInputs, manifest::Shadow as Settings, stages::GROUP};
+use horizon_shaders::Shadow;

 use super::native_material::TerrainShape;
 use super::wgsl_prefix::{TERRAIN, prefixed, section};
@@ -0,0 +1,59 @@
+//! `move_off_page`, moved out of `gfx.rs` unchanged.
+use super::*;
+
+/// `Renderer::compact_arena`'s and `shrink_translucent`'s moves: what the meshes
+/// hold on `page` of `arena` (`part`) goes to its other pages in video memory,
+/// until the next range would pass `budget` bytes (it keeps what is left; the
+/// first range moves whatever its size, so none keeps the page closed), the
+/// copies into `encoder`, the ranges' flat draw ids (`flat`) and, in the
+/// section arena, GPU culling's records (`records`) along. False when the other
+/// pages have no room left.
+pub(super) fn move_off_page<'a>(
+    arena: &mut arena::Arena,
+    encoder: &mut wgpu::CommandEncoder,
+    mut flat: Option<(&mut flat::Flat, &wgpu::Device, &mut upload::Uploads)>,
+    mut records: Option<&mut gpu_culling::Records>,
+    meshes: impl Iterator<Item = &'a mut SectionGpu>,
+    page: u32,
+    part: Part,
+    budget: &mut u64,
+) -> bool {
+    debug_assert!(
+        records.is_none() || matches!(part, Part::Section { .. }),
+        "records follow the section arena's ranges"
+    );
+    let mut moved = false;
+    for s in meshes {
+        // Nothing of a mesh here: split, one without solid quads (its (0, 0) is no
+        // range of page 0); in the other arenas, one without translucent quads.
+        let Some((_, start, vertices)) = part.of(s).filter(|r| r.0 == page) else {
+            continue;
+        };
+        let bytes = vertices * arena.stride();
+        if moved && bytes > *budget {
+            break;
+        }
+        let Some(to) = arena.alloc_moved(vertices) else {
+            return false;
+        };
+        arena.copy(encoder, (page, start), to, vertices);
+        arena.release(page, start, vertices);
+        if let (Some((flat, device, uploads)), Some(id)) = (&mut flat, s.flat_id) {
+            let key = match part {
+                Part::Translucent => to.0 + flat::TRANSLUCENT_KEYS,
+                _ => to.0,
+            };
+            flat.place(device, encoder, uploads, id, key, to.1, vertices);
+        }
+        part.set(s, to);
+        // Its solid quads start the range in either layout.
+        if let (Part::Section { .. }, Some(records), Some(id)) =
+            (part, records.as_deref_mut(), s.gpu_id)
+        {
+            records.relocate(id, to.0, u64::from(s.solid_base()));
+        }
+        *budget = budget.saturating_sub(bytes);
+        moved = true;
+    }
+    true
+}
@@ -144,6 +144,9 @@ pub struct EffectiveOutput {
    pub(crate) nits: [f32; 3],
    /// The HUD and menus' brightness, as a share of paper white: their nits over its.
    pub(crate) ui_brightness: f32,
+    /// The running shader pack lights the world itself: Horizon lifts none of it, so HDR
+    /// Lighting has nothing to switch (`with_pack`).
+    pub(crate) pack_lights: bool,
 }
 impl Default for EffectiveOutput {
    fn default() -> Self {
@@ -166,7 +169,22 @@ impl EffectiveOutput {
        },
        nits: [203.0, 1000.0, 0.0],
        ui_brightness: 1.0,
+        pack_lights: false,
    };
+    /// This output under the running shader pack: a `shaders/` one (`shaders`), or one of
+    /// Horizon's own of API `native`. Under a 0.1 pack on the 8- or 16-bit frame the last pass
+    /// still lifts the light sources and the sun its marks hold (`lifts_world` in
+    /// `Renderer::render`); under the rest Horizon lifts nothing.
+    pub(crate) fn with_pack(self, shaders: bool, native: Option<horizon_shader_api::Api>) -> Self {
+        let pack_lights = shaders
+            || native.is_some_and(|api| {
+                api != horizon_shader_api::Api::V0_1 || self.frame.format == super::LINEAR_FRAME
+            });
+        Self {
+            pack_lights,
+            ..self
+        }
+    }
    /// Whether the destination offers HDR output.
    pub fn hdr_offered(&self) -> bool {
        self.offered.is_some()
@@ -273,6 +291,7 @@ pub(crate) fn resolve_output(
        ],
        ui_brightness: settings.ui_nits(reading.luminance) as f32
            / settings.paper_white_nits(reading.luminance) as f32,
+        pack_lights: false,
    }
 }

@@ -300,6 +319,7 @@ pub(crate) mod tests {
                luminance: Some(Reported {
                    paper_white: 400,
                    peak: 1000,
+                    peak_guessed: false,
                }),
                hdr: system,
            },
@@ -650,6 +670,7 @@ pub(crate) mod tests {
        window_reading.luminance = Some(Reported {
            paper_white: 300,
            peak: 800,
+            peak_guessed: false,
        });
        assert_eq!(window_output(window_reading).nits[..2], [300.0, 800.0]);
        assert_eq!(
@@ -549,6 +549,7 @@ mod tests {
        reading.luminance = Some(Reported {
            paper_white: 250,
            peak: 600,
+            peak_guessed: false,
        });
        // 150 nits under the reported paper white of 250: 0.6 of it.
        settings.hdr_ui_nits = 150;
@@ -584,6 +585,7 @@ mod tests {
            reading.luminance = Some(Reported {
                paper_white,
                peak: 1000,
+                peak_guessed: false,
            });
            let next = candidate(&settings, caps, reading, &published);
            let again = commit(&mut swapchain, &published, next, caps, &mut rejected);
@@ -729,6 +731,7 @@ mod tests {
                luminance: (hdr == Some(true)).then_some(Reported {
                    paper_white: 300,
                    peak: 800,
+                    peak_guessed: false,
                }),
                hdr,
            };
@@ -4,8 +4,7 @@

 use std::collections::BTreeMap;

-use horizon_render_pipeline::{Format, Kind};
-use horizon_shaders::{BufferObject, CustomImage};
+use horizon_shaders::{BufferObject, CustomImage, Format, Kind};

 pub(super) struct PackImage {
    pub(super) def: CustomImage,
@@ -18,8 +18,7 @@
 use std::collections::HashMap;

 use glam::{DMat4, DVec3};
-use horizon_render_pipeline::{BUFFERS, Format, Kind, SHADOW_COLORS};
-use horizon_shaders::{Group, Post};
+use horizon_shaders::{BUFFERS, Format, Group, Kind, Post, SHADOW_COLORS};
 use smallvec::SmallVec;

 use super::pack_draw::DrawUniforms;
@@ -893,7 +892,7 @@ fn depth_linear(interface: &horizon_shaders::Interface, linear: u8) -> [f32; 4]
 }

 fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool) -> Source {
-    let shadow_color = horizon_render_pipeline::shadow_color(name);
+    let shadow_color = horizon_shaders::shadow_color(name);
    let shadow_depth = match name {
        "shadowtex0" | "watershadow" | "shadowtex0HW" => Some(0),
        "shadowtex1" | "shadowtex1HW" => Some(1),
@@ -912,7 +911,7 @@ fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool)
            };
        }
    }
-    if shadow_space && horizon_render_pipeline::buffer_index(name).is_some() {
+    if shadow_space && horizon_shaders::buffer_index(name).is_some() {
        // colortex buffers are not this pass's.
        return Source::Dummy;
    }
@@ -926,7 +925,7 @@ fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool)
        "normals" => Source::Normals,
        "specular" => Source::Specular,
        horizon_shaders::WATER_MASK => Source::WaterMask,
-        n => horizon_render_pipeline::buffer_index(n).map_or(Source::Dummy, Source::Color),
+        n => horizon_shaders::buffer_index(n).map_or(Source::Dummy, Source::Color),
    }
 }

@@ -1583,7 +1582,7 @@ fn bindings(
            !unbound
                && (t.stage != pack_textures::stage(group)
                    || released.0 != t.stage
-                    || horizon_render_pipeline::buffer_index(&t.name)
+                    || horizon_shaders::buffer_index(&t.name)
                        .is_none_or(|b| released.1 & 1 << b == 0))
        });
        let image = pack
@@ -2433,7 +2432,7 @@ impl PackPost {
        let shadow_config = post.config.shadow.clone();
        let noise_size = post.config.noise_resolution.unwrap_or(256);
        let half_lives = post.config.half_lives;
-        for (name, ticks) in horizon_render_pipeline::HALF_LIVES.iter().zip(half_lives) {
+        for (name, ticks) in horizon_shaders::HALF_LIVES.iter().zip(half_lives) {
            if let Some(t) = ticks {
                notes.push(format!("`{name}` is {t} ticks"));
            }
@@ -602,7 +602,7 @@ pub(super) fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        outline: Vec::new(),
        outline_after_terrain: false,
        outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
        debug_lines: &[],
        debug_lines_on_top: &[],
        debug_crosshair: &[],
@@ -440,7 +440,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        outline: Vec::new(),
        outline_after_terrain: false,
        outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
        debug_lines: &[],
        debug_lines_on_top: &[],
        debug_crosshair: &[],
@@ -10,7 +10,7 @@
 //! a fit to one driver's values, not a rule Iris states. `RGBA4` and `RGBA2` read back the `RGBA8`
 //! bytes in the same probe, as Horizon's 8-bit buffers already do.

-use horizon_render_pipeline::{Format, Kind};
+use horizon_shaders::{Format, Kind};
 use naga::{BinaryOperator, Expression, Literal, MathFunction, Statement, VectorSize};

 /// The bits each channel keeps in a buffer of format `f`, for the formats that keep fewer than
@@ -409,7 +409,7 @@ fn frame(hud: &HudBatch) -> Frame<'_> {
        outline: Vec::new(),
        outline_after_terrain: false,
        outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
        debug_lines: &[],
        debug_lines_on_top: &[],
        debug_crosshair: &[],
@@ -3,7 +3,7 @@
 //! with two sides that `shadowcomp` programs flip as composite programs flip colortex (6.1.6).
 //! Square, `shadowMapResolution` pixels.

-use horizon_render_pipeline::SHADOW_COLORS;
+use horizon_shaders::SHADOW_COLORS;

 type Ops<T> = wgpu::Operations<T>;
 type Color = wgpu::Color;
@@ -97,11 +97,7 @@ pub(super) fn stand_in(device: &wgpu::Device) -> wgpu::TextureView {
 }

 impl ShadowTargets {
-    pub fn reset_history(
-        &mut self,
-        device: &wgpu::Device,
-        shadow: &horizon_render_pipeline::Shadow,
-    ) {
+    pub fn reset_history(&mut self, device: &wgpu::Device, shadow: &horizon_shaders::Shadow) {
        let mut colors = 0;
        let mut doubled = 0;
        let formats = std::array::from_fn(|n| match &self.color[n] {
@@ -129,7 +125,7 @@ impl ShadowTargets {
    /// resolution is kept within the device's limit.
    pub fn new(
        device: &wgpu::Device,
-        shadow: &horizon_render_pipeline::Shadow,
+        shadow: &horizon_shaders::Shadow,
        formats: [wgpu::TextureFormat; SHADOW_COLORS],
        colors: u16,
        doubled: u16,
@@ -1,8 +1,7 @@
 //! A shader pack's custom textures (`texture.<stage>.<name>`, `texture.noise`) on the GPU, and
 //! which of them a program's sampler reads.

-use horizon_render_pipeline::Kind;
-use horizon_shaders::{CustomTexture, Group, Texels, Texture, TextureDim, TextureSource};
+use horizon_shaders::{CustomTexture, Group, Kind, Texels, Texture, TextureDim, TextureSource};

 /// What a custom texture is once uploaded: an image of ours, or one the game already has.
 pub(super) enum Image {
@@ -119,12 +118,12 @@ pub(super) fn find(textures: &[PackTexture], group: Group, ty: &str, name: &str)
    } else {
        wgpu::TextureViewDimension::D2
    };
-    let buffer = horizon_render_pipeline::buffer_index(name);
+    let buffer = horizon_shaders::buffer_index(name);
    let staged = textures.iter().position(|t| {
        t.stage == stage(group)
            && t.dimension == dimension
            && (t.name == name
-                || buffer.is_some() && horizon_render_pipeline::buffer_index(&t.name) == buffer)
+                || buffer.is_some() && horizon_shaders::buffer_index(&t.name) == buffer)
    });
    staged.or_else(|| {
        textures.iter().position(|t| {
@@ -28,7 +28,7 @@
 //! [-w, w], and the depth buffers packs read hold GL window depth.

 use glam::{DMat4, DVec3, Mat4, Vec3, Vec4};
-use horizon_render_pipeline::Shadow;
+use horizon_shaders::Shadow;

 use super::Frame;

@@ -440,7 +440,7 @@ pub struct FrameUniforms {
    center_depth: Option<f32>,
    /// The pack's shadow settings (7.1).
    pub shadow: Shadow,
-    /// The pack's smoothing half-lives in ticks (`horizon_render_pipeline::HALF_LIVES`).
+    /// The pack's smoothing half-lives in ticks (`horizon_shaders::HALF_LIVES`).
    pub half_lives: [Option<f32>; 4],
 }

@@ -2664,7 +2664,7 @@ pub(super) mod initial_history_tests {
            outline: Vec::new(),
            outline_after_terrain: false,
            outline_high_contrast: false,
-            look: Default::default(),
+            pvp: Default::default(),
            debug_lines: &[],
            debug_lines_on_top: &[],
            debug_crosshair: &[],
@@ -0,0 +1,79 @@
+//! Hardware ray queries, only on request (#13780, after the #1180 spike): `HORIZON_RAY_TRACING=1`
+//! at startup asks the device for wgpu's `EXPERIMENTAL_RAY_QUERY` when the GPU has it. Nothing
+//! draws with it yet. Without the variable, and in a build without `horizon-extras` (a Horizon
+//! extra, docs/layers.md), the device is opened exactly as before.
+
+/// The ray query feature.
+const RAY_QUERY: wgpu::Features = wgpu::Features::EXPERIMENTAL_RAY_QUERY;
+
+/// Whether the player asked for ray tracing (the device needs the feature from its creation).
+fn requested() -> bool {
+    asked(std::env::var("HORIZON_RAY_TRACING").ok().as_deref())
+}
+
+/// Whether `HORIZON_RAY_TRACING` set to `var` asks for ray tracing: only in a `horizon-extras`
+/// build.
+fn asked(var: Option<&str>) -> bool {
+    cfg!(feature = "horizon-extras") && var == Some("1")
+}
+
+/// The features to request on `adapter`: ray queries, when asked for and offered.
+pub(super) fn features(adapter: &wgpu::Adapter) -> wgpu::Features {
+    let features = pick(requested(), adapter.features());
+    if requested() {
+        let info = adapter.get_info();
+        if features.is_empty() {
+            log::warn!(
+                "Horizon renderer: ray tracing asked for, but {} on {:?} has no hardware ray \
+                 queries; it stays off",
+                info.name,
+                info.backend
+            );
+        } else {
+            log::info!(
+                "Horizon renderer: ray queries on ({} on {:?})",
+                info.name,
+                info.backend
+            );
+        }
+    }
+    features
+}
+
+fn pick(requested: bool, offered: wgpu::Features) -> wgpu::Features {
+    if requested {
+        offered & RAY_QUERY
+    } else {
+        wgpu::Features::empty()
+    }
+}
+
+/// The device's opt-in to `features`' experimental ones.
+pub(super) fn experimental(features: wgpu::Features) -> wgpu::ExperimentalFeatures {
+    if features.contains(RAY_QUERY) {
+        horizon_hdr::experimental_features()
+    } else {
+        wgpu::ExperimentalFeatures::disabled()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn only_an_extras_build_asks_for_ray_tracing() {
+        assert_eq!(asked(Some("1")), cfg!(feature = "horizon-extras"));
+        assert!(!asked(None));
+        assert!(!asked(Some("0")));
+    }
+
+    #[test]
+    fn ray_queries_only_when_asked_and_offered() {
+        let all = wgpu::Features::all();
+        assert_eq!(pick(true, all), RAY_QUERY);
+        assert!(pick(false, all).is_empty());
+        assert!(pick(true, all - RAY_QUERY).is_empty());
+        assert!(!experimental(wgpu::Features::empty()).is_enabled());
+    }
+}
@@ -0,0 +1,321 @@
+//! Writing a screenshot's PNG once its frame is read back: on the render thread for the
+//! requests that want the result with the frame (an agent's, a `screenshot-sequence`'s),
+//! on a thread of its own for F2's and the world icon's (`ScreenshotRequest::background`).
+//! The render thread then neither waits for the GPU to finish the frame nor encodes the
+//! PNG, which at 4K or a Screenshot Quality above 1x froze the game for a second or more.
+use super::{ScreenshotRequest, hdr_icc, hdr10_to_rgb16, padded_row, square_downscale};
+use std::path::PathBuf;
+use std::sync::mpsc::{Receiver, Sender, channel};
+use std::time::Duration;
+
+/// What a frame's readback holds and where its PNG goes.
+pub(super) struct Shot {
+    pub path: PathBuf,
+    /// `ScreenshotRequest::size`: the world icon's square.
+    pub size: Option<[u32; 2]>,
+    /// The frame's size, which the readback's rows hold (padded to `padded_row`).
+    pub frame: [u32; 2],
+    /// Blue first (`Bgra8Unorm`), swapped to PNG's red first.
+    pub bgra: bool,
+    /// The HDR10 copy's readback and its PNG's path, beside the SDR one.
+    pub hdr: Option<(PathBuf, wgpu::Buffer)>,
+}
+impl Shot {
+    pub fn new(
+        request: &ScreenshotRequest,
+        frame: [u32; 2],
+        format: wgpu::TextureFormat,
+        hdr: Option<(PathBuf, wgpu::Buffer)>,
+    ) -> Self {
+        Self {
+            path: request.path.clone(),
+            size: request.size,
+            frame,
+            bgra: format.remove_srgb_suffix() == wgpu::TextureFormat::Bgra8Unorm,
+            hdr,
+        }
+    }
+}
+/// A written screenshot: its path, its size or the error, and the HDR copy written beside it.
+pub struct Saved {
+    pub path: PathBuf,
+    pub result: Result<[u32; 2], String>,
+    pub hdr: Option<PathBuf>,
+}
+/// Waits for `buffer`'s mapping on the render thread and writes the PNG there.
+pub(super) fn save_now(device: &wgpu::Device, shot: Shot, buffer: &wgpu::Buffer) -> Saved {
+    let (sender, receiver) = channel();
+    map(buffer, &sender);
+    if let Some((_, hdr)) = &shot.hdr {
+        map(hdr, &sender);
+    }
+    let waited = device
+        .poll(wgpu::PollType::wait_indefinitely())
+        .map_err(|e| e.to_string());
+    let count = 1 + usize::from(shot.hdr.is_some());
+    let mapped = waited.and_then(|_| wait_mapped(&receiver, count));
+    write(shot, buffer, mapped)
+}
+/// Screenshots being written on their thread.
+pub(super) struct Saves {
+    device: wgpu::Device,
+    sender: Sender<Saved>,
+    receiver: Receiver<Saved>,
+    in_flight: usize,
+}
+impl Saves {
+    pub fn new(device: &wgpu::Device) -> Self {
+        let (sender, receiver) = channel();
+        Self {
+            device: device.clone(),
+            sender,
+            receiver,
+            in_flight: 0,
+        }
+    }
+    /// Maps `buffer` (and the HDR copy's), whose copy was just submitted, and writes the
+    /// PNG on a thread of its own once the GPU has finished the frame.
+    pub fn start(&mut self, shot: Shot, buffer: wgpu::Buffer) {
+        let (mapped, on_mapped) = channel();
+        map(&buffer, &mapped);
+        if let Some((_, hdr)) = &shot.hdr {
+            map(hdr, &mapped);
+        }
+        let done = self.sender.clone();
+        let path = shot.path.clone();
+        let spawned = std::thread::Builder::new()
+            .name("Screenshot writer".into())
+            .spawn(move || {
+                let count = 1 + usize::from(shot.hdr.is_some());
+                let ready = wait_mapped(&on_mapped, count);
+                let _ = done.send(write(shot, &buffer, ready));
+            });
+        match spawned {
+            Ok(_) => {}
+            Err(e) => {
+                let _ = self.sender.send(Saved {
+                    path,
+                    result: Err(format!("no thread to write it: {e}")),
+                    hdr: None,
+                });
+            }
+        }
+        self.in_flight += 1;
+    }
+    /// The screenshots written since the last call. Polls the device so a finished frame's
+    /// mapping reaches its writer: the render thread never waits for it.
+    pub fn finished(&mut self) -> Vec<Saved> {
+        if self.in_flight == 0 {
+            return Vec::new();
+        }
+        let _ = self.device.poll(wgpu::PollType::Poll);
+        let saved: Vec<Saved> = self.receiver.try_iter().collect();
+        self.in_flight -= saved.len();
+        saved
+    }
+}
+impl Drop for Saves {
+    /// A screenshot taken right before quitting is still written whole.
+    fn drop(&mut self) {
+        let deadline = std::time::Instant::now() + Duration::from_secs(10);
+        while self.in_flight > 0 && std::time::Instant::now() < deadline {
+            let _ = self.device.poll(wgpu::PollType::Poll);
+            if let Ok(saved) = self.receiver.recv_timeout(Duration::from_millis(20)) {
+                log_saved(&saved);
+                self.in_flight -= 1;
+            }
+        }
+    }
+}
+fn log_saved(saved: &Saved) {
+    match &saved.result {
+        Ok(_) => log::info!("Saved screenshot to {}", saved.path.display()),
+        Err(e) => log::warn!("Horizon renderer: screenshot {}: {e}", saved.path.display()),
+    }
+}
+fn map(buffer: &wgpu::Buffer, mapped: &Sender<Result<(), String>>) {
+    let mapped = mapped.clone();
+    buffer.map_async(wgpu::MapMode::Read, .., move |r| {
+        let _ = mapped.send(r.map_err(|e| e.to_string()));
+    });
+}
+/// `count` mappings done, or the first one that failed. A frame the GPU never finishes
+/// (a lost device) gives up after a while instead of keeping its thread.
+fn wait_mapped(mapped: &Receiver<Result<(), String>>, count: usize) -> Result<(), String> {
+    for _ in 0..count {
+        mapped
+            .recv_timeout(Duration::from_secs(30))
+            .map_err(|_| "the frame never came back from the GPU".to_string())??;
+    }
+    Ok(())
+}
+/// The PNG (and the HDR copy's beside it) from the mapped readbacks.
+fn write(shot: Shot, buffer: &wgpu::Buffer, mapped: Result<(), String>) -> Saved {
+    let mut hdr_written = None;
+    let result = mapped.and_then(|()| {
+        if let Some((hdr_path, hdr_buffer)) = &shot.hdr {
+            let pixels = read_rows(hdr_buffer, shot.frame);
+            match pixels.and_then(|p| write_hdr_png(hdr_path, shot.frame, &p)) {
+                Ok(()) => {
+                    log::info!("Saved HDR screenshot to {}", hdr_path.display());
+                    hdr_written = Some(hdr_path.clone());
+                }
+                Err(e) => log::warn!(
+                    "Horizon renderer: HDR screenshot {}: {e}",
+                    hdr_path.display()
+                ),
+            }
+        }
+        let pixels = read_rows(buffer, shot.frame)?;
+        write_png(&shot, &pixels)
+    });
+    Saved {
+        path: shot.path,
+        result,
+        hdr: hdr_written,
+    }
+}
+/// The pixels `copy_frame` read back into the mapped `buffer`, 4 bytes each, row after
+/// row; unmaps it.
+fn read_rows(buffer: &wgpu::Buffer, [width, height]: [u32; 2]) -> Result<Vec<[u8; 4]>, String> {
+    let (width, height, row) = (width as usize, height as usize, padded_row(width) as usize);
+    let mut pixels = Vec::with_capacity(width * height);
+    {
+        let data = buffer.get_mapped_range(..).map_err(|e| e.to_string())?;
+        for y in 0..height {
+            pixels.extend_from_slice(data[y * row..y * row + width * 4].as_chunks::<4>().0);
+        }
+    }
+    buffer.unmap();
+    Ok(pixels)
+}
+fn write_png(shot: &Shot, frame: &[[u8; 4]]) -> Result<[u32; 2], String> {
+    let [frame_w, frame_h] = shot.frame;
+    let mut pixels = Vec::with_capacity(frame.len() * 4);
+    for px in frame {
+        let (r, b) = if shot.bgra {
+            (px[2], px[0])
+        } else {
+            (px[0], px[2])
+        };
+        pixels.extend_from_slice(&[r, px[1], b, 255]);
+    }
+    // NativeImage.resizeSubRectTo on takeAutoScreenshot's grab: the icon
+    // is the frame's centre square averaged down to its size.
+    let (width, height, pixels) = match shot.size {
+        Some(size) => (
+            size[0],
+            size[1],
+            square_downscale(&pixels, frame_w, frame_h, size),
+        ),
+        None => (frame_w, frame_h, pixels),
+    };
+    let file = std::fs::File::create(&shot.path).map_err(|e| e.to_string())?;
+    let mut encoder = png::Encoder::new(std::io::BufWriter::new(file), width, height);
+    encoder.set_color(png::ColorType::Rgba);
+    encoder.set_depth(png::BitDepth::Eight);
+    encoder
+        .write_header()
+        .and_then(|mut w| w.write_image_data(&pixels))
+        .map_err(|e| e.to_string())?;
+    Ok([width, height])
+}
+/// The HDR10 copy (`Hdr::capture`) as a 16-bit PNG tagged BT.2020 with PQ (cICP, PNG's
+/// third edition), with the content light levels its pixels hold (cLLI), and
+/// an ICC profile for the programs that don't read cICP (`hdr_icc`).
+fn write_hdr_png(
+    path: &std::path::Path,
+    [width, height]: [u32; 2],
+    frame: &[[u8; 4]],
+) -> Result<(), String> {
+    let pixels = hdr10_to_rgb16(frame);
+    let mut info = png::Info::with_size(width, height);
+    info.color_type = png::ColorType::Rgb;
+    info.bit_depth = png::BitDepth::Sixteen;
+    info.icc_profile = Some(hdr_icc::profile().into());
+    let file = std::fs::File::create(path).map_err(|e| e.to_string())?;
+    let written = png::Encoder::with_info(std::io::BufWriter::new(file), info)
+        .and_then(|encoder| encoder.write_header())
+        .and_then(|mut writer| {
+            // BT.2020 primaries, PQ, RGB, full range.
+            writer.write_chunk(png::chunk::cICP, &[9, 16, 0, 1])?;
+            writer.write_chunk(png::chunk::cLLI, &hdr_icc::content_light_levels(&pixels))?;
+            writer.write_image_data(&pixels)
+        });
+    written.map_err(|e| e.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_background_save_writes_the_png_off_the_render_thread() {
+        let instance = crate::gfx::test_gpu::instance();
+        let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+            return;
+        };
+        let Ok((device, queue)) = pollster::block_on(adapter.request_device(&Default::default()))
+        else {
+            return;
+        };
+        let dir = std::env::temp_dir().join(format!("horizon-shot-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("shot.png");
+        let [w, h] = [3u32, 2];
+        // A frame of blue-first pixels, each row padded as `copy_frame` reads them back.
+        let row = padded_row(w) as usize;
+        let mut bytes = vec![0u8; row * h as usize];
+        for y in 0..h as usize {
+            for x in 0..w as usize {
+                bytes[y * row + x * 4..][..4].copy_from_slice(&[10 * x as u8, 20, 200, 0]);
+            }
+        }
+        let source = wgpu::util::DeviceExt::create_buffer_init(
+            &device,
+            &wgpu::util::BufferInitDescriptor {
+                label: None,
+                contents: &bytes,
+                usage: wgpu::BufferUsages::COPY_SRC,
+            },
+        );
+        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: bytes.len() as u64,
+            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+            mapped_at_creation: false,
+        });
+        let mut encoder = device.create_command_encoder(&Default::default());
+        encoder.copy_buffer_to_buffer(&source, 0, &buffer, 0, bytes.len() as u64);
+        queue.submit([encoder.finish()]);
+        let request = ScreenshotRequest {
+            path: path.clone(),
+            size: None,
+            scaled: false,
+            background: true,
+        };
+        let mut saves = Saves::new(&device);
+        saves.start(
+            Shot::new(&request, [w, h], wgpu::TextureFormat::Bgra8Unorm, None),
+            buffer,
+        );
+        let deadline = std::time::Instant::now() + Duration::from_secs(10);
+        let saved = loop {
+            if let Some(saved) = saves.finished().pop() {
+                break saved;
+            }
+            assert!(std::time::Instant::now() < deadline, "never written");
+            std::thread::sleep(Duration::from_millis(5));
+        };
+        assert_eq!(saved.path, path);
+        assert_eq!(saved.result, Ok([w, h]));
+        let decoder =
+            png::Decoder::new(std::io::BufReader::new(std::fs::File::open(&path).unwrap()));
+        let mut reader = decoder.read_info().unwrap();
+        let mut out = vec![0; reader.output_buffer_size().unwrap()];
+        reader.next_frame(&mut out).unwrap();
+        // Red first, opaque: the last pixel of the first row was [20, 20, 200] blue-first.
+        assert_eq!(&out[8..12], &[200, 20, 20, 255]);
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+}
@@ -5,6 +5,9 @@ use super::{
    Renderer, check_layers, cull, describe_adapter, is_software, oit, startup_step, surface_format,
    timing,
 };
+// Ray tracing on request, which the device needs from its creation (gfx.rs may not grow).
+#[path = "ray_query.rs"]
+mod ray_query;
 use std::sync::Arc;
 use winit::window::Window;

@@ -134,6 +137,7 @@ pub(super) async fn open_adapter(
    let features = timing::GpuTimer::features(adapter)
        | cull::Cull::features(adapter)
        | oit::features(adapter)
+        | ray_query::features(adapter)
        | (adapter.features()
            & (wgpu::Features::INDIRECT_FIRST_INSTANCE
                | wgpu::Features::MULTI_DRAW_INDIRECT_COUNT
@@ -166,6 +170,7 @@ pub(super) async fn open_adapter(
        // with the larger blocks a few small buffers kept whole blocks the arena's pages had
        // left, and over half the video memory reserved was unused (1,344 MiB for 500).
        memory_hints: wgpu::MemoryHints::MemoryUsage,
+        experimental_features: ray_query::experimental(features),
        ..Default::default()
    };
    #[cfg(not(target_os = "macos"))]
@@ -30,6 +30,22 @@ fn marker_driver(text: &str) -> &str {
 pub struct Reported {
    pub paper_white: u32,
    pub peak: u32,
+    /// The peak is the display's own claim (DXGI's `MaxLuminance`, mostly its EDID figure),
+    /// which often runs high: Auto still uses it, but the HDR page asks to calibrate.
+    pub peak_guessed: bool,
+}
+
+/// Whether HDR is set up for the display, and whether the player kept the system's setup.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum HdrSetup {
+    /// The system says nothing: the player calibrates.
+    Unknown,
+    /// The system says, but only guesses the peak: the player calibrates.
+    Guessed,
+    /// Peak Brightness and Paper White follow the system.
+    Automatic,
+    /// The system said, and the player changed them anyway.
+    Changed,
 }

 /// The top of Peak Brightness's scale: `peak_nits_at(PEAK_STEPS)` is PQ's 10 000 nits.
@@ -1207,6 +1223,15 @@ impl Graphics {
            n => n,
        }
    }
+    /// How HDR is set up for the display the system `reported`.
+    pub fn hdr_setup(&self, reported: Option<Reported>) -> HdrSetup {
+        match reported {
+            None => HdrSetup::Unknown,
+            Some(_) if self.hdr_peak != 0 || self.hdr_paper_white != 0 => HdrSetup::Changed,
+            Some(r) if r.peak_guessed => HdrSetup::Guessed,
+            Some(_) => HdrSetup::Automatic,
+        }
+    }
    /// The black level, in nits. Not the system's: files from before saved 0 for that
    /// (Auto), and a reported black would lift every display's shadows by default.
    pub fn black_level_nits(&self) -> f32 {
@@ -1320,6 +1345,7 @@ mod tests {
        let reported = Some(Reported {
            paper_white: 300,
            peak: 1000,
+            peak_guessed: false,
        });
        assert_eq!(g.ui_nits(reported), 300);
        g.hdr_paper_white = 120;
@@ -1328,6 +1354,33 @@ mod tests {
        assert_eq!((g.ui_nits(None), g.ui_nits(reported)), (400, 400));
    }

+    #[test]
+    fn hdr_setup_asks_to_calibrate_where_the_peak_is_guessed() {
+        let wayland = Reported {
+            paper_white: 203,
+            peak: 1015,
+            peak_guessed: false,
+        };
+        let windows = Reported {
+            paper_white: 400,
+            peak: 1000,
+            peak_guessed: true,
+        };
+        let mut g = Graphics::default();
+        assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
+        assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Automatic);
+        assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Guessed);
+        // Auto still takes the guess, over the 1000-nit default.
+        assert_eq!(g.peak_nits(Some(windows)), 1000);
+        assert_eq!(g.paper_white_nits(Some(windows)), 400);
+        for (peak, paper_white) in [(800, 0), (0, 240)] {
+            (g.hdr_peak, g.hdr_paper_white) = (peak, paper_white);
+            assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Changed);
+            assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Changed);
+            assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
+        }
+    }
+
    #[test]
    fn hdr_modes_keep_boolean_files_and_round_trip_auto() {
        assert_eq!(Graphics::parse("").hdr, HdrMode::Off);
@@ -2,16 +2,21 @@
 //! colours and the controls it draws with. The screen (`graphics_ui`) only
 //! lays out rows and handles input; a menu theme replaces this module.
 //!
-//! It takes the design system's Blocks palette (`horizon_theme::BLOCKS_DARK`,
-//! `docs/design-system.md`) in a lighter form: square panels of dark glass
-//! with a thin edge, so the world shows through, flat controls, and the violet
-//! face on the one main button, in vanilla's font.
+//! Its colours come from `menu_style`, given at startup (in the official game the design
+//! system's Blocks palette, `docs/design-system.md`), in a lighter form: square panels of
+//! dark glass with a thin edge, so the world shows through, flat controls, and the face on
+//! the one main button, in vanilla's font.
+use crate::menu_style::{self, SettingsColours};
 use crate::{
    hud::{HudAtlas, HudBatch},
    text::Text,
    ui,
 };
-use horizon_theme::BLOCKS_DARK as B;
+
+/// The settings pages' colours (`menu_style`, given at startup).
+fn b() -> &'static SettingsColours {
+    &menu_style::get().settings
+}

 /// What a setting costs in frame time, shown with its description.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -36,54 +41,91 @@ impl Cost {
    /// `0xRRGGBB`: the palette's success, warn and danger.
    pub fn rgb(self) -> u32 {
        match self {
-            Cost::None => B.ink_soft,
-            Cost::Low | Cost::Saves => B.success,
-            Cost::Medium => B.warn,
-            Cost::High => B.danger,
+            Cost::None => b().ink_soft,
+            Cost::Low | Cost::Saves => b().success,
+            Cost::Medium => b().warn,
+            Cost::High => b().danger,
        }
    }
 }

-/// `0xRRGGBB` and an alpha in the HUD's colour encoding.
-const fn hex(c: u32, a: u8) -> u32 {
-    (a as u32) << 24 | (c & 0xff) << 16 | (c >> 8 & 0xff) << 8 | (c >> 16 & 0xff)
-}
+use menu_style::hud_colour as hex;
 /// The plate and the strip: the page's dark, see-through, so the world shows behind them.
-const GLASS: u32 = hex(B.page, 118);
+fn glass() -> u32 {
+    hex(b().page, 118)
+}
 /// Their 1 px edge.
-const EDGE: u32 = hex(B.ink, 26);
+pub fn edge() -> u32 {
+    hex(b().ink, 26)
+}
 /// A group's panel, a little lighter than the plate it sits on.
-const GROUP: u32 = hex(B.ink, 11);
+fn group_fill() -> u32 {
+    hex(b().ink, 11)
+}
 /// A hovered or focused row, lit on its group's panel.
-pub const HOVER: u32 = hex(B.ink, 18);
+pub fn hover() -> u32 {
+    hex(b().ink, 18)
+}
 /// The open page in the page list.
-pub const OPEN: u32 = hex(B.ink, 26);
+pub fn open() -> u32 {
+    hex(b().ink, 26)
+}
 /// The rule under the plate's heading, and between two rows of a group.
-pub const HEAD_RULE: u32 = hex(B.ink, 31);
-pub const ROW_RULE: u32 = hex(B.ink, 15);
+pub fn head_rule() -> u32 {
+    hex(b().ink, 31)
+}
+pub fn row_rule() -> u32 {
+    hex(b().ink, 15)
+}
 /// Fields, boxes and the value stepper: sunk, see-through.
-const WELL: u32 = hex(B.outline, 102);
+fn well_fill() -> u32 {
+    hex(b().outline, 102)
+}
 /// A button, a slider's track, the scroller's thumb.
-const BUTTON: u32 = hex(B.ink, 20);
-const BUTTON_HOVER: u32 = hex(B.ink, 41);
-const TRACK: u32 = hex(B.ink, 64);
-const HANDLE: u32 = hex(B.ink, 255);
+fn button_fill() -> u32 {
+    hex(b().ink, 20)
+}
+fn button_hover() -> u32 {
+    hex(b().ink, 41)
+}
+fn track_fill() -> u32 {
+    hex(b().ink, 64)
+}
+fn handle_fill() -> u32 {
+    hex(b().ink, 255)
+}
 /// The one main button.
-const FACE: u32 = hex(B.face, 255);
-const FACE_HOVER: u32 = hex(0x6a50e6, 255);
+pub fn face() -> u32 {
+    hex(b().face, 255)
+}
+fn face_hover() -> u32 {
+    hex(b().face_hover, 255)
+}
 /// A tick box's edge when off.
-const BOX_EDGE: u32 = hex(B.ink_soft, 89);
-const OUTLINE: u32 = hex(B.outline, 255);
-pub const ACCENT: u32 = hex(B.accent, 255);
+fn box_edge() -> u32 {
+    hex(b().ink_soft, 89)
+}
+fn outline() -> u32 {
+    hex(b().outline, 255)
+}
+pub fn accent() -> u32 {
+    hex(b().accent, 255)
+}
 /// Vanilla's white text, and its grey for what can't be used now.
 pub const WHITE: u32 = u32::MAX;
-pub const MUTED: u32 = hex(B.muted, 255);
+pub fn muted() -> u32 {
+    hex(b().muted, 255)
+}
 /// A page that isn't open, a value at rest.
-pub const SOFT: u32 = hex(B.ink_soft, 255);
+pub fn soft() -> u32 {
+    hex(b().ink_soft, 255)
+}
 /// Vanilla's grey for a tooltip's lines under its first (`ChatFormatting.GRAY`).
 pub const GREY: u32 = hex(0xaaaaaa, 255);
 /// A light veil over the backdrop, under the panels.
-pub const VEIL: u32 = hex(B.page, 77);
+pub fn veil() -> u32 {
+    hex(b().page, 77)
+}

 /// Sizes in GUI pixels.
 /// Shorter screens than this (a 720p window at scale 3) keep a narrower margin on top.
@@ -120,21 +162,21 @@ pub fn ring(batch: &mut HudBatch, atlas: &HudAtlas, [x, y, w, h]: [f32; 4], colo
 }
 /// The screen's plate, and the strip under it: dark glass with a thin edge.
 pub fn panel(batch: &mut HudBatch, atlas: &HudAtlas, rect: [f32; 4]) {
-    fill(batch, atlas, rect, GLASS);
-    ring(batch, atlas, rect, EDGE);
+    fill(batch, atlas, rect, glass());
+    ring(batch, atlas, rect, edge());
 }
 /// A group's panel on the plate, its rows on it.
 pub fn group(batch: &mut HudBatch, atlas: &HudAtlas, rect: [f32; 4]) {
-    fill(batch, atlas, rect, GROUP);
+    fill(batch, atlas, rect, group_fill());
 }
 /// A sunk well: the search field, the value stepper.
 pub fn well(batch: &mut HudBatch, atlas: &HudAtlas, rect: [f32; 4]) {
-    fill(batch, atlas, rect, WELL);
+    fill(batch, atlas, rect, well_fill());
 }
 /// The scroller: a faint track and its thumb.
 pub fn scroller(batch: &mut HudBatch, atlas: &HudAtlas, track: [f32; 4], thumb: [f32; 4]) {
-    fill(batch, atlas, track, ROW_RULE);
-    fill(batch, atlas, thumb, TRACK);
+    fill(batch, atlas, track, row_rule());
+    fill(batch, atlas, thumb, track_fill());
 }
 /// `text` cut to `width` with an ellipsis, as a long name gives way to its control: the HUD
 /// kit's `fit::ellipsize`.
@@ -142,11 +184,11 @@ pub use crate::hud_kit::fit::ellipsize as fit;
 /// A 12 px tick box ending at `right`, centred in the row at `y`: its edge in the accent when on.
 pub fn checkbox(batch: &mut HudBatch, atlas: &HudAtlas, right: f32, y: f32, on: bool, live: bool) {
    let rect = [right - 12.0, y + 4.0, 12.0, 12.0];
-    fill(batch, atlas, rect, WELL);
+    fill(batch, atlas, rect, well_fill());
    let edge = match (on, live) {
-        (true, true) => ACCENT,
-        (true, false) => MUTED,
-        (false, _) => BOX_EDGE,
+        (true, true) => accent(),
+        (true, false) => muted(),
+        (false, _) => box_edge(),
    };
    ring(batch, atlas, rect, edge);
    if on {
@@ -169,7 +211,7 @@ fn tick(batch: &mut HudBatch, atlas: &HudAtlas, x: f32, y: f32, color: u32) {
        for (i, c) in row.chars().enumerate() {
            if c == '#' {
                let (px, py) = (x + i as f32, y + j as f32);
-                fill(batch, atlas, [px + 1.0, py + 1.0, 1.0, 1.0], OUTLINE);
+                fill(batch, atlas, [px + 1.0, py + 1.0, 1.0, 1.0], outline());
                fill(batch, atlas, [px, py, 1.0, 1.0], color);
            }
        }
@@ -198,17 +240,17 @@ pub fn button_with_room(
 ) {
    let [x, y, w, h] = rect;
    let face = match (live, primary, hover) {
-        (false, _, _) => WELL,
-        (true, true, false) => FACE,
-        (true, true, true) => FACE_HOVER,
-        (true, false, false) => BUTTON,
-        (true, false, true) => BUTTON_HOVER,
+        (false, _, _) => well_fill(),
+        (true, true, false) => face(),
+        (true, true, true) => face_hover(),
+        (true, false, false) => button_fill(),
+        (true, false, true) => button_hover(),
    };
    fill(batch, atlas, rect, face);
    if hover && live {
        ring(batch, atlas, rect, WHITE);
    }
-    let color = if live { WHITE } else { MUTED };
+    let color = if live { WHITE } else { muted() };
    let ty = y + ((h - 8.0) / 2.0).floor();
    let left = x + 2.0 + room;
    scrolling_label(
@@ -252,7 +294,7 @@ pub fn slider(
    (hover, live): (bool, bool),
 ) {
    let [x, y, w, h] = rect;
-    let color = if live { WHITE } else { MUTED };
+    let color = if live { WHITE } else { muted() };
    scrolling_label(
        batch,
        atlas,
@@ -263,17 +305,22 @@ pub fn slider(
    );
    let line = y + h - 3.0;
    let at = x + (position.clamp(0.0, 1.0) * (w - 4.0)).round();
-    fill(batch, atlas, [x, line, w, 2.0], TRACK);
+    fill(batch, atlas, [x, line, w, 2.0], track_fill());
    fill(
        batch,
        atlas,
        [x, line, at - x, 2.0],
-        if live { ACCENT } else { MUTED },
+        if live { accent() } else { muted() },
    );
    let handle = [at, line - 3.0, 4.0, 8.0];
-    fill(batch, atlas, handle, if live { HANDLE } else { MUTED });
+    fill(
+        batch,
+        atlas,
+        handle,
+        if live { handle_fill() } else { muted() },
+    );
    if hover && live {
-        ring(batch, atlas, [at - 1.0, line - 4.0, 6.0, 10.0], ACCENT);
+        ring(batch, atlas, [at - 1.0, line - 4.0, 6.0, 10.0], accent());
    }
 }
 /// A value that a press steps through: in a well, between the arrows that say so.
@@ -290,13 +337,13 @@ pub fn cycler(
        ring(batch, atlas, rect, WHITE);
    }
    let ty = y + ((h - 8.0) / 2.0).floor();
-    let arrows = if hover && live { WHITE } else { MUTED };
+    let arrows = if hover && live { WHITE } else { muted() };
    batch.text_styled(atlas, &Text::literal("<"), x + 3.0, ty, arrows, true);
    batch.text_styled(atlas, &Text::literal(">"), x + w - 8.0, ty, arrows, true);
    let color = match (live, hover) {
-        (false, _) => MUTED,
+        (false, _) => muted(),
        (true, true) => WHITE,
-        (true, false) => SOFT,
+        (true, false) => soft(),
    };
    scrolling_label(batch, atlas, value, [x + 9.0, ty, w - 18.0], (y, h), color);
 }
@@ -8,7 +8,8 @@ use crate::{
    gfx::EffectiveOutput,
    graphics::{
        EntityCullingMode, FarDetail, FrameGeneration, GpuCullingMode, GraphicsApi, HdrMode,
-        LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode, Preset, Upscaling,
+        HdrSetup as Setup, LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode,
+        Preset, Upscaling,
    },
    graphics_style::Cost,
    lang,
@@ -675,28 +676,9 @@ const LOD_STEPS: [u32; 24] = [
    crate::lod::MAX_CHUNKS,
 ];

-/// Whether the system set HDR up for the display, and whether the player kept it.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum Setup {
-    /// The system says nothing: the player calibrates.
-    Unknown,
-    /// Peak Brightness and Paper White follow the system.
-    Automatic,
-    /// The system said, and the player changed them anyway.
-    Changed,
-}
 /// `out`: the output of the renderer the settings are shown for, with what its display reports.
 fn setup(s: &Settings, out: &EffectiveOutput) -> Setup {
-    setup_of(&s.horizon, out.reported.is_some())
-}
-fn setup_of(g: &crate::graphics::Graphics, reported: bool) -> Setup {
-    if !reported {
-        Setup::Unknown
-    } else if g.hdr_peak == 0 && g.hdr_paper_white == 0 {
-        Setup::Automatic
-    } else {
-        Setup::Changed
-    }
+    s.horizon.hdr_setup(out.reported)
 }
 /// What the HDR page says while HDR output is held back on this window's graphics driver
 /// (`EffectiveOutput::held`): picking a mode tries again (`H::cycle`).
@@ -714,13 +696,19 @@ fn description(
        (Item::Horizon(H::HdrCalibrate), Setup::Unknown) => {
            "Your display didn't say how bright it gets: calibrate to set it up."
        }
+        (Item::Horizon(H::HdrCalibrate), Setup::Guessed) => {
+            "Your display's reported peak is often too high: calibrate to set it up."
+        }
        (Item::Horizon(H::HdrCalibrate), Setup::Automatic) => {
            "Already set up for your display. Only calibrate if HDR looks wrong."
        }
        (Item::Horizon(H::HdrCalibrate), Setup::Changed) => {
            "Puts Peak Brightness and Paper White back to your display's setup."
        }
-        (Item::Horizon(H::HdrPeak | H::HdrPaperWhite), Setup::Automatic | Setup::Changed) => {
+        // A guessed peak's Auto is what calibration replaced; paper white is the player's own.
+        (Item::Horizon(h @ (H::HdrPeak | H::HdrPaperWhite)), Setup::Automatic | Setup::Changed)
+            if h == H::HdrPaperWhite || out.reported.is_some_and(|r| !r.peak_guessed) =>
+        {
            "Set up for your display. Leave on Auto unless it looks wrong."
        }
        (Item::Horizon(H::GpuCulling), _) if s.horizon.gpu_culling == GpuCullingMode::Auto => {
@@ -944,7 +932,7 @@ impl H {
            H::FrameGeneration => labelled("Frame Generation", g.frame_generation.label()),
            H::Hdr => labelled("HDR", g.hdr.label()),
            H::HdrCalibrate => Text::literal(lang::get(match setup(s, out) {
-                Setup::Unknown => "Calibrate...",
+                Setup::Unknown | Setup::Guessed => "Calibrate...",
                Setup::Automatic => "Calibrate Anyway...",
                Setup::Changed => "Use Automatic Setup",
            })),
@@ -1122,7 +1110,8 @@ impl Item {
    /// active; saved values wait for it. Translucent Batching switches where the device can batch
    /// (`graphics::translucent_batching_offered`), its saved value waiting for one that can,
    /// Smooth Gradients only where it can draw the 16-bit frame, the same way, and GPU Culling
-    /// only where it is offered (`graphics::gpu_culling_offer`), with the reason it isn't.
+    /// only where it is offered (`graphics::gpu_culling_offer`), with the reason it isn't. HDR
+    /// Lighting has nothing to switch where the running shader pack lights the world itself.
    fn blocked(self, s: &Settings, out: &EffectiveOutput) -> Option<&'static str> {
        if !self.available() {
            return Some("This feature is not yet available in Horizon.");
@@ -1153,6 +1142,9 @@ impl Item {
            } else {
                "Turn HDR on to use it."
            }),
+            Item::Horizon(H::HdrLighting) if out.pack_lights => {
+                Some("The shader pack lights the world itself.")
+            }
            Item::Horizon(H::TranslucentBatching)
                if !crate::graphics::translucent_batching_offered() =>
            {
@@ -31,6 +31,49 @@ fn smooth_gradients_wait_for_a_device_that_draws_the_16_bit_frame() {
    assert_eq!(item.blocked(&s, &out), Some("Turn HDR on to use it."));
 }

+#[test]
+fn hdr_lighting_is_greyed_only_where_the_running_pack_lights_the_world() {
+    use horizon_shader_api::Api;
+    let mut s = Settings::default();
+    s.horizon.hdr = HdrMode::On;
+    let item = Item::Horizon(H::HdrLighting);
+    let lights = Some("The shader pack lights the world itself.");
+    let out = offering(true, None);
+    // No pack running, as with one picked but refused, missing or its mod off: live.
+    assert_eq!(item.blocked(&s, &out.with_pack(false, None)), None);
+    // A 0.1 pack on the 16-bit frame: the light sources and the sun still shine.
+    assert_eq!(
+        item.blocked(&s, &out.with_pack(false, Some(Api::V0_1))),
+        None
+    );
+    assert_eq!(
+        item.blocked(&s, &out.with_pack(false, Some(Api::V0_2))),
+        lights
+    );
+    assert_eq!(item.blocked(&s, &out.with_pack(true, None)), lights);
+    let float = EffectiveOutput {
+        frame: crate::gfx::FrameConfiguration {
+            format: wgpu::TextureFormat::Rgba16Float,
+            ..out.frame
+        },
+        ..out
+    };
+    assert_eq!(
+        item.blocked(&s, &float.with_pack(false, Some(Api::V0_1))),
+        lights
+    );
+    // HDR's own reasons come first.
+    assert_eq!(
+        item.blocked(&s, &NONE.with_pack(true, None)),
+        Some("Your display or system doesn't offer HDR output.")
+    );
+    s.horizon.hdr = HdrMode::Off;
+    assert_eq!(
+        item.blocked(&s, &out.with_pack(true, None)),
+        Some("Turn HDR on to use it.")
+    );
+}
+
 #[test]
 fn hdr_auto_can_be_selected_before_querying_and_brightness_waits_for_output() {
    let mut s = Settings::default();
@@ -120,14 +163,86 @@ fn auto_levels_and_setup_read_their_own_renderers_report() {
    assert_eq!(label(H::HdrCalibrate, &silent), "Calibrate...");
 }

+/// The setup rows' label and description for each kind of report: none, a compositor's
+/// (Wayland), and Windows', whose peak is the display's own guess.
 #[test]
-fn hdr_setup_follows_what_the_system_reported() {
-    let mut g = crate::graphics::Graphics::default();
-    assert_eq!(setup_of(&g, false), Setup::Unknown);
-    assert_eq!(setup_of(&g, true), Setup::Automatic);
-    g.hdr_paper_white = 80;
-    assert_eq!(setup_of(&g, true), Setup::Changed);
-    assert_eq!(setup_of(&g, false), Setup::Unknown);
+fn the_setup_rows_ask_to_calibrate_unless_the_system_set_the_display_up() {
+    let trusted = offering(true, Some(true));
+    let mut guessed = trusted;
+    guessed.reported = guessed.reported.map(|r| crate::graphics::Reported {
+        peak_guessed: true,
+        ..r
+    });
+    let rows = |s: &Settings, out: &EffectiveOutput| {
+        [H::HdrCalibrate, H::HdrPeak, H::HdrPaperWhite].map(|h| {
+            let item = Item::Horizon(h);
+            (item.label(s, out).plain(), description(item, s, out, "-"))
+        })
+    };
+    let calibrate = "Calibrate...";
+    let set_up = "Set up for your display. Leave on Auto unless it looks wrong.";
+    let mut s = Settings::default();
+    s.horizon.hdr = HdrMode::On;
+    let none = (
+        calibrate.into(),
+        "Your display didn't say how bright it gets: calibrate to set it up.",
+    );
+    assert_eq!(
+        rows(&s, &NONE),
+        [
+            none.clone(),
+            ("Peak Brightness: Auto (1000)".into(), "-"),
+            ("Paper White: Auto (203)".into(), "-"),
+        ]
+    );
+    assert_eq!(
+        rows(&s, &guessed),
+        [
+            (
+                calibrate.into(),
+                "Your display's reported peak is often too high: calibrate to set it up."
+            ),
+            ("Peak Brightness: Auto (1000)".into(), "-"),
+            ("Paper White: Auto (400)".into(), "-"),
+        ]
+    );
+    assert_eq!(
+        rows(&s, &trusted),
+        [
+            (
+                "Calibrate Anyway...".into(),
+                "Already set up for your display. Only calibrate if HDR looks wrong."
+            ),
+            ("Peak Brightness: Auto (1000)".into(), set_up),
+            ("Paper White: Auto (400)".into(), set_up),
+        ]
+    );
+    // Calibrated or set by hand, either report offers its automatic setup back.
+    s.horizon.hdr_peak = 800;
+    // Peak's Auto stays a guess on Windows: only Paper White is said to be set up there.
+    let changed = |peak| {
+        [
+            (
+                "Use Automatic Setup".into(),
+                "Puts Peak Brightness and Paper White back to your display's setup.",
+            ),
+            ("Peak Brightness: 800".into(), peak),
+            ("Paper White: Auto (400)".into(), set_up),
+        ]
+    };
+    assert_eq!(rows(&s, &guessed), changed("-"));
+    assert_eq!(rows(&s, &trusted), changed(set_up));
+    assert_eq!(rows(&s, &NONE)[0], none);
+    let mut ui = ui();
+    ui.screen.output = guessed;
+    let at = |[x, y, ..]: [f32; 4]| (x + 8.0, y + 4.0);
+    let calibrate = row(&mut ui, &s, Item::Horizon(H::HdrCalibrate));
+    assert_eq!(press(&mut ui, &mut s, at(calibrate)), [CLICK, CHANGED]);
+    assert_eq!((s.horizon.hdr_peak, s.horizon.hdr_paper_white), (0, 0));
+    assert_eq!(
+        press(&mut ui, &mut s, at(calibrate)),
+        [CLICK, Output::Push(OptionsPage::HdrCalibration)]
+    );
 }

 /// UI Brightness reads as Paper White does, in nits apart from it: Auto shows the paper white
@@ -111,11 +111,11 @@ pub struct HudAtlas {
    /// The packs' Polytone screen sprite modifiers.
    pub sprite_modifiers: std::sync::Arc<sprite_modifiers::SpriteModifiers>,
    /// The packs' OptiFine random entity textures, whose variants this atlas packs.
-    pub random_textures: horizon_optifine::random_textures::RandomTextures,
+    pub random_textures: crate::entity_textures::RandomTextures,
    /// Their emissive overlays (`_e`), packed here too.
-    pub emissive: std::sync::Arc<horizon_optifine::emissive::Emissive>,
+    pub emissive: std::sync::Arc<crate::entity_textures::Emissive>,
    /// ETF's blinking frames (`_blink`), packed here too.
-    pub blinks: horizon_optifine::blink::Blinks,
+    pub blinks: crate::entity_textures::Blinks,
    /// Of the shared atlas's textures, their LabPBR normal and specular maps as paged maps
    /// (`paged_maps.rs`), read while loading for shader packs (`sprites::labpbr_maps`).
    pub material_maps: std::sync::Arc<[Option<crate::paged_maps::PagedMap>; 2]>,
@@ -433,7 +433,7 @@ fn cit_sprites(
    packed: &[PackedImage],
 ) -> Vec<(PackedImage, Option<TextureFlags>, bool)> {
    let have: HashSet<&str> = packed.iter().map(|i| i.0.as_str()).collect();
-    let rules = crate::cit::load_rules(root);
+    let rules = crate::cit::CitRules::load(root).rules;
    let mut ids = crate::cit_assets::item_sprites(&rules);
    if !rules.is_empty() {
        let models = crate::cit_assets::load_models(root, &rules);
@@ -1204,25 +1204,18 @@ impl HudAtlas {
            let s = p.to_string_lossy().replace('\\', "/");
            !s.contains("title/background") && !s.contains("presets")
        });
-        // OptiFine random entity variants, under the names their scan gives them (those
-        // outside `textures/` are `<ns>:optifine/random/...`).
-        let random_textures = if folders.contains(&"entity") {
-            horizon_optifine::random_textures::RandomTextures::scan(root)
+        // Random entity variants, under the names their scan gives them (those outside
+        // `textures/` are `<ns>:optifine/random/...`), blink frames and emissive overlays.
+        let crate::entity_textures::EntityTextures {
+            random: random_textures,
+            blinks,
+            emissive,
+        } = if folders.contains(&"entity") {
+            crate::entity_textures::EntityTextures::load(root)
        } else {
            Default::default()
        };
-        let blinks = if folders.contains(&"entity") {
-            horizon_optifine::blink::Blinks::scan(root, &random_textures)
-        } else {
-            Default::default()
-        };
-        let emissive = std::sync::Arc::new(if folders.contains(&"entity") {
-            let mut e = horizon_optifine::emissive::Emissive::scan(root, &random_textures);
-            e.pair_beside(root, blinks.files());
-            e
-        } else {
-            Default::default()
-        });
+        let emissive = std::sync::Arc::new(emissive);
        let mut named: HashMap<PathBuf, String> = HashMap::new();
        let extra = random_textures
            .files()
@@ -3474,6 +3467,7 @@ mod tests {
    /// `RandomTextures` gives them; one beside its texture packs once, under its own.
    #[test]
    fn random_entity_variants_pack_under_their_scan_names() {
+        crate::pack_formats::install();
        let root =
            std::env::temp_dir().join(format!("horizon-atlas-random-{}", std::process::id()));
        let _ = fs::remove_dir_all(&root);
@@ -3496,6 +3490,7 @@ mod tests {
    /// A random variant's emissive overlay packs beside the variant, under its name.
    #[test]
    fn variant_overlays_pack_under_their_names() {
+        crate::pack_formats::install();
        let root =
            std::env::temp_dir().join(format!("horizon-atlas-overlay-{}", std::process::id()));
        let _ = fs::remove_dir_all(&root);
@@ -3810,6 +3805,7 @@ mod tests {
    }
    /// A resource root with one plain item texture and these CIT files (relative path, contents).
    fn cit_root(name: &str, files: &[(&str, &str)]) -> PathBuf {
+        crate::pack_formats::install();
        let root =
            std::env::temp_dir().join(format!("horizon-atlas-cit-{name}-{}", std::process::id()));
        let _ = fs::remove_dir_all(&root);
@@ -3899,7 +3895,7 @@ mod tests {
        );
        let cit = root.join("assets/minecraft/optifine/cit");
        write_strip(&cit.join("a.png"), 64, 32, &[[1, 2, 3, 255]], None);
-        let rules = crate::cit::load_rules(&root);
+        let rules = crate::cit::CitRules::load(&root).rules;
        assert_eq!(rules.len(), 1);
        let atlas = HudAtlas::build(&root).unwrap();
        let _ = fs::remove_dir_all(&root);
@@ -1,12 +1,12 @@
-//! OptiFine CIT enchantment glints on GUI items (`type=enchantment`, see `crate::cit_glint` for
+//! Custom item texture enchantment glints on GUI items (`Kind::Enchantment`, see `crate::cit_glint` for
 //! which layers a stack draws): every rule's texture in one texture array, each layer an extra
 //! pass over the item's quads with its rule's blend. A layer's vertices carry its texture slot
 //! (red) and its intensity (alpha) in their colour; its scrolled UV is worked out on the CPU, as
 //! vanilla's glint's is. Without enchantment rules nothing here is made.

 use super::HudVertex;
+use crate::cit::{Blend, Factor, Kind, Rule};
 use crate::gfx::hud_coverage::Pipeline;
-use horizon_optifine::cit::{Blend, Factor, Kind, Rule};
 use std::path::Path;

 /// Slots the shader's table holds; rules past it draw no layer (and match no stack).
@@ -438,13 +438,11 @@ impl CitGlintPass {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use horizon_optifine::Properties;
-    use horizon_optifine::cit::parse_blend;
+    use crate::pack_formats::cit::{parse_blend, parse_rule};

    fn rule(name: &str, text: &str) -> Rule {
        let path = format!("assets/minecraft/optifine/cit/{name}.properties");
-        let text = format!("texture=glint\n{text}");
-        Rule::parse(&path, &Properties::parse_equals_first(&text), |_| true).unwrap()
+        parse_rule(&path, &format!("texture=glint\n{text}")).unwrap()
    }

    #[test]
@@ -338,7 +338,7 @@ fn coverage_preserves_each_cit_blend_and_its_destination_alpha() {
    let Some(mut gpu) = Gpu::new() else {
        return;
    };
-    use horizon_optifine::cit::parse_blend;
+    use crate::pack_formats::cit::parse_blend;
    for (name, expected) in [
        ("alpha", 128),
        ("add", 0),
@@ -3,8 +3,9 @@
 //! where a tween is at the frame's [`Clock`]; nothing here holds state or runs on its own, and
 //! no motion ever decides what input does.
 //!
-//! The curves are the design system's (`horizon_theme::QUICK`, `MOVE`): a [`Tween`] takes one
-//! of them, at the theme's duration or a shorter one of its own.
+//! A [`Tween`] takes a duration and a CSS `cubic-bezier` curve: Horizon's overlays use the design
+//! system's (`horizon_theme::QUICK`, `MOVE`), at the theme's duration or a shorter one of their
+//! own.
 //!
 //! The game builds the clock once a frame (`Clock::new(now, still)`). A still clock (the game is
 //! paused, frame-stepped by `HORIZON_STILL` or a screenshot sequence, or a repro recording or
@@ -16,7 +17,7 @@
 //! use std::time::{Duration, Instant};
 //!
 //! let opened = Instant::now();
-//! let open = Tween::new(Duration::from_millis(90), horizon_theme::QUICK);
+//! let open = Tween::new(Duration::from_millis(90), [0.4, 0.0, 0.2, 1.0]);
 //! // Half way through: partly faded in, partly grown from 94%.
 //! let clock = Clock::new(opened + Duration::from_millis(45), false);
 //! let alpha = motion::fade(open, clock, opened);
@@ -26,7 +27,6 @@
 //! let still = Clock::new(opened, true);
 //! assert_eq!(motion::fade(open, still, opened), 1.0);
 //! ```
-use horizon_theme::Motion;
 use std::time::{Duration, Instant};

 /// The time a frame shows, built once a frame by the game.
@@ -50,28 +50,20 @@ impl Clock {
    }
 }

-/// A duration and one of the design system's easing curves.
+/// A duration and an easing curve.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Tween {
    /// How long it runs.
    pub duration: Duration,
-    /// The CSS `cubic-bezier` control points of its curve (a `horizon_theme::Motion`'s).
+    /// The CSS `cubic-bezier` control points of its curve.
    pub curve: [f32; 4],
 }

 impl Tween {
-    /// `motion`'s curve over `duration`: the dial's motions are shorter than the launcher's, on
-    /// the same curves.
-    pub const fn new(duration: Duration, motion: Motion) -> Self {
-        Self {
-            duration,
-            curve: motion.curve,
-        }
-    }
-
-    /// A theme motion as it is: its own duration and curve.
-    pub const fn of(motion: Motion) -> Self {
-        Self::new(motion.duration(), motion)
+    /// `curve` over `duration`: the dial's motions are shorter than the launcher's, on the same
+    /// curves.
+    pub const fn new(duration: Duration, curve: [f32; 4]) -> Self {
+        Self { duration, curve }
    }

    /// The linear progress, 0 to 1, `since` a start at this clock; 1 on a still clock.
@@ -84,7 +76,7 @@ impl Tween {

    /// The eased progress, 0 to 1, on the tween's curve.
    pub fn progress(self, clock: Clock, since: Instant) -> f32 {
-        horizon_theme::bezier(self.curve, self.linear(clock, since))
+        bezier(self.curve, self.linear(clock, since))
    }

    /// Whether it has finished (always, on a still clock).
@@ -98,6 +90,29 @@ impl Tween {
    }
 }

+/// A CSS `cubic-bezier(x1, y1, x2, y2)` at `t` in 0..1: solves x for the curve parameter,
+/// returns y.
+pub fn bezier([x1, y1, x2, y2]: [f32; 4], t: f32) -> f32 {
+    let t = t.clamp(0.0, 1.0);
+    if t == 0.0 || t == 1.0 {
+        return t;
+    }
+    let at = |a: f32, b: f32, s: f32| {
+        let u = 1.0 - s;
+        3.0 * u * u * s * a + 3.0 * u * s * s * b + s * s * s
+    };
+    let (mut lo, mut hi) = (0f32, 1f32);
+    for _ in 0..24 {
+        let mid = (lo + hi) / 2.0;
+        if at(x1, x2, mid) < t {
+            lo = mid;
+        } else {
+            hi = mid;
+        }
+    }
+    at(y1, y2, (lo + hi) / 2.0)
+}
+
 /// An alpha from 0 to 1 as something fades in.
 pub fn fade(tween: Tween, clock: Clock, since: Instant) -> f32 {
    tween.progress(clock, since)
@@ -145,7 +160,7 @@ mod tests {
    #[test]
    fn a_tween_runs_from_its_start_to_its_end_and_holds() {
        let t0 = Instant::now();
-        let tween = Tween::new(MS(80), horizon_theme::MOVE);
+        let tween = Tween::new(MS(80), horizon_theme::MOVE.curve);
        assert_eq!(tween.progress(at(t0, 0), t0), 0.0);
        assert_eq!(tween.progress(at(t0, 80), t0), 1.0);
        assert_eq!(tween.progress(at(t0, 500), t0), 1.0);
@@ -160,8 +175,7 @@ mod tests {
    fn a_still_clock_shows_every_motion_settled() {
        let t0 = Instant::now();
        let still = Clock::new(t0, true);
-        let tween = Tween::of(horizon_theme::QUICK);
-        assert_eq!(tween.duration, horizon_theme::QUICK.duration());
+        let tween = Tween::new(horizon_theme::QUICK.duration(), horizon_theme::QUICK.curve);
        assert_eq!(fade(tween, still, t0), 1.0);
        assert_eq!(fade_out(tween, still, t0), 0.0);
        assert_eq!(scale_in(tween, still, t0, 0.94), 1.0);
@@ -173,7 +187,7 @@ mod tests {
    #[test]
    fn the_helpers_start_where_they_say() {
        let t0 = Instant::now();
-        let tween = Tween::new(MS(100), horizon_theme::QUICK);
+        let tween = Tween::new(MS(100), horizon_theme::QUICK.curve);
        let c = at(t0, 0);
        assert_eq!(fade(tween, c, t0), 0.0);
        assert_eq!(fade_out(tween, c, t0), 1.0);
@@ -184,10 +198,25 @@ mod tests {
        assert!((flash(tween, at(t0, 25), t0) - 0.75).abs() < 1e-6);
    }

+    #[test]
+    fn the_curve_is_the_design_systems() {
+        for motion in horizon_theme::MOTION {
+            for i in 0..=20 {
+                let t = i as f32 / 20.0;
+                assert_eq!(
+                    bezier(motion.curve, t),
+                    motion.ease(t),
+                    "{} at {t}",
+                    motion.name
+                );
+            }
+        }
+    }
+
    #[test]
    fn a_turn_takes_the_short_way_round() {
        let t0 = Instant::now();
-        let tween = Tween::new(MS(80), horizon_theme::MOVE);
+        let tween = Tween::new(MS(80), horizon_theme::MOVE.curve);
        // From up-left (7/8 of a turn) to up-right: through up, not round the bottom.
        let from = 7.0 * FRAC_PI_4;
        let half = turn(tween, at(t0, 1), t0, from, FRAC_PI_4);
@@ -38,6 +38,12 @@
 //! ```
 use crate::hud::{HudAtlas, HudBatch};
 use crate::hud_kit::{colour, fit};
+use crate::menu_style::{self, OverlayColours};
+
+/// The overlays' colours (`menu_style`, given at startup).
+fn overlay() -> &'static OverlayColours {
+    &menu_style::get().overlay
+}

 /// A pip under the strip: its size and the step from one to the next, in GUI px.
 pub const PIP: [f32; 2] = [3.0, 2.0];
@@ -45,8 +51,12 @@ pub const PIP_STEP: f32 = 5.0;
 /// How far, in GUI px, the arrows sit from the name.
 pub const ARROW_GAP: f32 = 4.0;
 /// An arrow with a page that way, and one at an end, with none.
-pub const ARROW: u32 = colour(horizon_theme::BACKDROP_MUTED, 255);
-pub const ARROW_OFF: u32 = colour(horizon_theme::BACKDROP_MUTED, 77);
+pub fn arrow_colour() -> u32 {
+    colour(overlay().backdrop_muted, 255)
+}
+pub fn arrow_off_colour() -> u32 {
+    colour(overlay().backdrop_muted, 77)
+}
 /// The pips (the selected one is white).
 pub const PIP_OFF: u32 = colour(0xFFFFFF, 89);
 pub const PIP_ON: u32 = colour(0xFFFFFF, 255);
@@ -65,9 +75,15 @@ pub const EDGE_FADE: f32 = 12.0;
 pub const FADE: [f32; 5] = [1.0, 0.7, 0.35, 0.15, 0.1];
 /// The selected tab's fill and text, and the others'.
 pub const SELECTED_FILL: u32 = colour(0xFFFFFF, 242);
-pub const SELECTED_TEXT: u32 = colour(horizon_theme::DARK.page, 255);
-pub const TAB_FILL: u32 = colour(horizon_theme::DARK.page, 191);
-pub const TAB_TEXT: u32 = colour(horizon_theme::BACKDROP_MUTED, 255);
+pub fn selected_text() -> u32 {
+    colour(overlay().page, 255)
+}
+pub fn tab_fill() -> u32 {
+    colour(overlay().page, 191)
+}
+pub fn tab_text() -> u32 {
+    colour(overlay().backdrop_muted, 255)
+}
 /// The line of text's height in GUI px (vanilla's font, without its shadow).
 const LINE: f32 = 8.0;

@@ -144,7 +160,11 @@ pub fn draw(batch: &mut HudBatch, atlas: &HudAtlas, strip: &Strip) {
            arrow,
            ax,
            ay,
-            if on { ARROW } else { ARROW_OFF },
+            if on {
+                arrow_colour()
+            } else {
+                arrow_off_colour()
+            },
            true,
        );
    }
@@ -282,9 +302,9 @@ pub fn draw_tabs(batch: &mut HudBatch, atlas: &HudAtlas, strip: &TabStrip, alpha
    for tab in &row.tabs {
        let [tx, ty, tw, th] = tab.area;
        let (fill, text) = if tab.selected {
-            (SELECTED_FILL, SELECTED_TEXT)
+            (SELECTED_FILL, selected_text())
        } else {
-            (TAB_FILL, TAB_TEXT)
+            (tab_fill(), tab_text())
        };
        let tab_start = batch.vertices.len();
        // Cut where the edges' fades start, so each fade runs over its own piece.
@@ -380,15 +400,16 @@ mod tests {
            let [ax, _] = strip.arrows[i];
            (batch.vertices.iter())
                .filter(|v| {
-                    (v.pos[0] - ax).abs() < 4.0 && v.color & 0x00FF_FFFF == ARROW & 0x00FF_FFFF
+                    (v.pos[0] - ax).abs() < 4.0
+                        && v.color & 0x00FF_FFFF == arrow_colour() & 0x00FF_FFFF
                })
                .map(|v| v.color >> 24)
                .max()
                .unwrap_or(0)
        };
        let first = collapsed(&atlas, &pages, 0, AREA);
-        assert_eq!(alpha(&first, 0), ARROW_OFF >> 24);
-        assert_eq!(alpha(&first, 1), ARROW >> 24);
+        assert_eq!(alpha(&first, 0), arrow_off_colour() >> 24);
+        assert_eq!(alpha(&first, 1), arrow_colour() >> 24);
    }

    #[test]
@@ -14,7 +14,6 @@ pub mod biome;
 pub mod block_edit;
 pub mod block_entities;
 pub mod block_entity_anim;
-pub mod block_entity_cem;
 pub mod block_entity_render;
 pub mod block_sprites;
 pub mod block_states;
@@ -44,6 +43,7 @@ pub mod custom_sky;
 pub mod datapack;
 pub mod dynamic_light;
 pub mod effects;
+pub mod entity_textures;
 pub mod environment;
 pub mod extras;
 pub(crate) mod extras_ui;
@@ -51,7 +51,6 @@ pub mod fast_hash;
 pub mod fluid_render;
 pub mod fog;
 pub mod font;
-pub mod fusion;
 pub mod gfx;
 pub mod graphics;
 pub mod graphics_style;
@@ -67,7 +66,6 @@ mod jei_sprites;
 pub mod jigsaw_block;
 pub mod keypad;
 pub mod terrain_model;
-pub use horizon_polytone::colors as polytone_colors;
 pub use horizon_polytone::creative_tabs as polytone_creative_tabs;
 pub use horizon_world::json_folder;
 pub mod level_loading;
@@ -75,6 +73,7 @@ pub mod light;
 pub mod lod;
 pub mod logging;
 pub mod menu_blur;
+pub mod menu_style;
 pub mod mesher;
 pub mod minimap;
 pub mod mipmap;
@@ -89,6 +88,8 @@ pub mod options_fixes;
 pub mod options_ui;
 pub mod overlay;
 pub mod pack_browser;
+pub mod pack_formats;
+pub mod pack_hooks;
 pub mod pack_options_ui;
 pub mod pack_palette;
 pub mod pack_screen;
@@ -2593,8 +2593,7 @@ impl Lod {
        self.returned_at = std::time::Instant::now();
        let nodes = &self.plan.nodes;
        self.mesh_samples.retain(|key| nodes.contains(key));
-        // Queued tiles the view left are not sampled (a running one is
-        // dropped when it finishes, `finish_sample`).
+        // Queued tiles the view left are not sampled; a running one is dropped (`finish_sample`).
        drop_queued_samples(&self.shared, &mut self.pending, |key| {
            self.plan.nodes.contains(key)
        });
@@ -2680,6 +2679,7 @@ impl Lod {
            }
            if let Some((columns, mask)) = self.kept.take(&key) {
                self.ready.insert(key, columns);
+                self.sync_sample(key);
                if let Some(mask) = mask {
                    self.detail_masks.insert(key, mask);
                }
@@ -0,0 +1,145 @@
+//! The look of the screens vanilla doesn't have that the engine still draws: the settings pages
+//! (`graphics_style`), the HUD kit's tab strip, and the overlays drawn with `ui_theme` (the
+//! on-screen keyboard, the boot screen, the missing-resources window). Vanilla's screens never
+//! read it.
+//!
+//! The layer above gives it once at startup ([`install`]), before the first frame; the
+//! official game gives Horizon's design system (`docs/design-system.md`). With none given, the
+//! screens draw in [`NEUTRAL`]: vanilla's greys and chat colours, and no text where they would
+//! use their own fonts. A read is one atomic load, and only those screens make it.
+use std::sync::OnceLock;
+
+/// Colours as `0xRRGGBB`, sizes in dp (the launcher's logical pixels).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct MenuStyle {
+    pub settings: SettingsColours,
+    pub overlay: OverlayColours,
+    pub sizes: Sizes,
+    /// The overlays' TrueType faces; none: they draw no text.
+    pub fonts: Option<Fonts>,
+}
+
+/// The settings pages: square panels of dark glass over the world, flat controls, one face.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SettingsColours {
+    /// The plate behind everything, drawn see-through.
+    pub page: u32,
+    /// Text, and the light the panels, rules, hovers and controls are drawn in.
+    pub ink: u32,
+    /// Secondary text and values.
+    pub ink_soft: u32,
+    /// Labels, descriptions, what can't be used.
+    pub muted: u32,
+    /// Wells and the dark edge of small marks.
+    pub outline: u32,
+    /// Focus, a checked box, a slider's fill.
+    pub accent: u32,
+    /// The one main button, and while hovered.
+    pub face: u32,
+    pub face_hover: u32,
+    pub success: u32,
+    pub warn: u32,
+    pub danger: u32,
+}
+
+/// Overlays drawn over the game (the HUD kit's tab strip, `ui_theme`'s overlays).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct OverlayColours {
+    /// The dark page under text and tabs.
+    pub page: u32,
+    /// Muted text over a veiled backdrop.
+    pub backdrop_muted: u32,
+    /// Text and the light hover and pressed plates are drawn in.
+    pub ink: u32,
+    /// Secondary text and values.
+    pub ink_soft: u32,
+    /// One-pixel rules between rows.
+    pub rule: u32,
+    /// The main action, and its text.
+    pub accent: u32,
+    pub on_accent: u32,
+}
+
+/// `ui_theme`'s type scale and shapes, in dp.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Sizes {
+    pub caption: f32,
+    pub label: f32,
+    pub ui: f32,
+    pub body: f32,
+    pub title: f32,
+    /// The boot screen's wordmark at its smallest, and its console lines.
+    pub display: f32,
+    pub micro: f32,
+    /// Fields; plates (hover rows, selection); a large control's height.
+    pub radius: f32,
+    pub radius_plate: f32,
+    pub control_large: f32,
+}
+
+/// TrueType faces (`ui_theme::Face`).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Fonts {
+    pub regular: &'static [u8],
+    pub medium: &'static [u8],
+    pub semibold: &'static [u8],
+    pub mono: &'static [u8],
+}
+
+/// The look with nothing given: vanilla's greys and chat colours.
+pub const NEUTRAL: MenuStyle = MenuStyle {
+    settings: SettingsColours {
+        page: 0x101010,
+        ink: 0xffffff,
+        ink_soft: 0xe0e0e0,
+        muted: 0xa0a0a0,
+        outline: 0x000000,
+        accent: 0xffffff,
+        face: 0x555555,
+        face_hover: 0x6f6f6f,
+        success: 0x55ff55,
+        warn: 0xffff55,
+        danger: 0xff5555,
+    },
+    overlay: OverlayColours {
+        page: 0x101010,
+        backdrop_muted: 0xa0a0a0,
+        ink: 0xffffff,
+        ink_soft: 0xe0e0e0,
+        rule: 0x303030,
+        accent: 0xffffff,
+        on_accent: 0x000000,
+    },
+    sizes: Sizes {
+        caption: 12.0,
+        label: 13.0,
+        ui: 14.0,
+        body: 15.0,
+        title: 28.0,
+        display: 44.0,
+        micro: 11.0,
+        radius: 0.0,
+        radius_plate: 0.0,
+        control_large: 40.0,
+    },
+    fonts: None,
+};
+
+static STYLE: OnceLock<MenuStyle> = OnceLock::new();
+
+/// Give the menus their look: call it once at startup. A second call keeps the first look and
+/// returns false.
+pub fn install(style: MenuStyle) -> bool {
+    STYLE.set(style).is_ok()
+}
+
+/// The look given to [`install`], or [`NEUTRAL`].
+#[inline]
+pub fn get() -> &'static MenuStyle {
+    STYLE.get().unwrap_or(&NEUTRAL)
+}
+
+/// `0xRRGGBB` and an alpha in the HUD's colour encoding (`0xAABBGGRR`).
+pub const fn hud_colour(rgb: u32, alpha: u8) -> u32 {
+    (alpha as u32) << 24 | (rgb & 0xff) << 16 | (rgb >> 8 & 0xff) << 8 | (rgb >> 16 & 0xff)
+}
@@ -11,7 +11,7 @@ mod sides;
 #[cfg(test)]
 #[path = "mesher/source_tests.rs"]
 mod source_tests;
-use crate::connected::{Pick, TileLayer};
+use crate::connected::{ConnectedTextures, NoConnected, Pick, TileLayer};
 use crate::{
    assets::{Assets, RenderAssets},
    biome::{Biomes, GrassModifier},
@@ -24,7 +24,6 @@ use horizon_assets::model::Direction as ModelDirection;
 use horizon_core::{
    biome::BiomeZoom, geometry::Direction, position::BlockPos, random::position_seed,
 };
-use horizon_optifine::ctm::connect::{Axes as CtmAxes, Face as CtmFace};
 use horizon_world::{
    block_render::FaceVisibility,
    fluid::{FluidKind, FluidState},
@@ -1872,11 +1871,27 @@ impl Mesher<'_> {
        )
    }
    /// The meshing workers' path: `out`'s buffers and `scratch` are reused
-    /// rather than allocated per section.
+    /// rather than allocated per section. A pack's connected textures mesh through their
+    /// format's entry point ([`crate::connected::Connected::mesh`]).
    pub fn mesh_reusing(
        &mut self,
        region: &[[Option<&Chunk>; 3]; 3],
        sy: i32,
+        out: SectionMesh,
+        scratch: &mut MeshScratch,
+    ) -> SectionMesh {
+        let render = self.render;
+        match &render.connected {
+            Some(connected) => (connected.mesh)(self, &*connected.rules, region, sy, out, scratch),
+            None => self.mesh_with(&NoConnected, region, sy, out, scratch),
+        }
+    }
+    /// [`Self::mesh_reusing`] with the connected textures `connected`.
+    pub fn mesh_with<C: ConnectedTextures>(
+        &mut self,
+        connected: &C,
+        region: &[[Option<&Chunk>; 3]; 3],
+        sy: i32,
        mut out: SectionMesh,
        scratch: &mut MeshScratch,
    ) -> SectionMesh {
@@ -2021,7 +2036,6 @@ impl Mesher<'_> {
                                )
                                .unwrap_or(true);
                    }
-                    let connected = &self.render.connected;
                    let start = [out.solid.len(), out.translucent.len()];
                    for model in &models {
                        for face in &model.faces {
@@ -2052,6 +2066,7 @@ impl Mesher<'_> {
                                }
                            }
                            self.face(
+                                connected,
                                pad,
                                &mut tints,
                                &mut out,
@@ -2102,8 +2117,9 @@ impl Mesher<'_> {
        })
    }
    #[allow(clippy::too_many_arguments)]
-    fn face(
+    fn face<C: ConnectedTextures>(
        &self,
+        connected: &C,
        pad: &Padded,
        tints: &mut Tints,
        out: &mut SectionMesh,
@@ -2163,55 +2179,40 @@ impl Mesher<'_> {
            }
            None => tint,
        };
-        // Fusion's and then OptiFine's connected textures: another sprite, or one per quarter,
-        // and the overlays drawn over it (a few per face at most; more are dropped).
-        let (fusion, connected) = (&self.render.fusion, &self.render.connected);
+        // Connected textures: another sprite, or one per quarter, and the overlays drawn over it
+        // (a few per face at most; more are dropped).
        let mut overlays = [None; 8];
        let mut count = 0;
-        let mut push = |overlay| {
-            if let Some(slot) = overlays.get_mut(count) {
-                *slot = Some(overlay);
-                count += 1;
-            }
-        };
-        let neighbour = |n: [i32; 3]| pad.blocks[(cell as isize + step_index(n)) as usize];
-        let fused = face.fusion.and_then(|rule| {
-            fusion.pick(
-                rule,
-                id,
-                CtmFace::ALL[q.facing as usize],
-                q.tint_index,
-                neighbour,
+        let pick = if connected.is_empty() {
+            Pick::Keep
+        } else {
+            let mut push = |overlay| {
+                if let Some(slot) = overlays.get_mut(count) {
+                    *slot = Some(overlay);
+                    count += 1;
+                }
+            };
+            let tints = &*tints;
+            connected.pick(
+                &crate::connected::Face {
+                    state: id,
+                    layer: face.layer as u16,
+                    facing: q.facing as u8,
+                    pos: [world.x, world.y, world.z],
+                    positions: &q.positions,
+                    uv: &q.uv,
+                    pane: state.pane,
+                    tint_index: q.tint_index,
+                    rule: face.fusion,
+                },
+                |n: [i32; 3]| pad.blocks[(cell as isize + step_index(n)) as usize],
                |s| {
                    self.tables
                        .info
                        .get(s as usize)
                        .is_some_and(|i| i.opaque_cube)
                },
-                &mut push,
-            )
-        });
-        let pick = if let Some(pick) = fused {
-            pick
-        } else if connected.is_empty() {
-            Pick::Keep
-        } else {
-            let tints = &*tints;
-            connected.pick(
-                id,
-                face.layer as u16,
-                CtmFace::ALL[q.facing as usize],
-                [world.x, world.y, world.z],
-                neighbour,
                || Some(tints.biome(pos[0], pos[1], pos[2])),
-                // A pane's tiles are drawn with the cube's UVs (below), so that is its texture.
-                || {
-                    if state.pane {
-                        Some(CtmAxes::cube(CtmFace::ALL[q.facing as usize]))
-                    } else {
-                        CtmAxes::texture(&q.positions, &q.uv)
-                    }
-                },
                &mut push,
            )
        };
@@ -100,8 +100,7 @@ fn fixture() -> (Scratch, Assets, RenderAssets, MeshTables, Biomes) {
        pbr_normals: vec![],
        pbr_specular: vec![],
        pbr_size: 1,
-        connected: Default::default(),
-        fusion: Default::default(),
+        connected: None,
        generation: 1,
    };
    let assets = Assets {
@@ -1,6 +1,7 @@
 //! Optional, texture-matched overlays drawn full bright over their base texture in the same
-//! terrain fragment: native mods' (`<ns>:emissive/...`) and OptiFine's emissive block textures
-//! (`block/stone_e.png` beside `block/stone.png`). No extra draw calls or world light changes.
+//! terrain fragment: native mods' (`<ns>:emissive/...`) and a pack's emissive block textures
+//! (OptiFine's `block/stone_e.png` beside `block/stone.png`, the suffix from the pack formats,
+//! [`crate::pack_hooks`]). No extra draw calls or world light changes.
 use crate::sprites::Sprites;
 use std::{collections::BTreeMap, path::Path};

@@ -35,14 +36,12 @@ fn tile_file(name: &str) -> Option<&str> {
    name.strip_suffix(".png")
 }

-/// OptiFine's emissive overlays of the block sprites already loaded (what the terrain draws;
-/// items draw from the HUD atlas): for each
-/// `<ns>:block/<name>`, or connected-texture tile `assets/<ns>/.../<name>.png`, whose
-/// `<name><suffix>.png` sits beside it, the overlay is loaded too and paired with it, blocks
-/// first, then tiles, each by name, at most [`MAX`] - [`NATIVE`] (native mods keep their share of
-/// the table). A pack without such files adds nothing.
-pub fn load_optifine(root: &Path, sprites: &mut Sprites) -> Vec<(String, String)> {
-    let suffix = horizon_optifine::emissive::suffix(root);
+/// A pack's emissive overlays of the block sprites already loaded (what the terrain draws;
+/// items draw from the HUD atlas): for each `<ns>:block/<name>`, or connected-texture tile
+/// `assets/<ns>/.../<name>.png`, whose `<name><suffix>.png` sits beside it, the overlay is loaded
+/// too and paired with it, blocks first, then tiles, each by name, at most [`MAX`] - [`NATIVE`]
+/// (native mods keep their share of the table). A pack without such files adds nothing.
+pub fn load_overlays(root: &Path, suffix: &str, sprites: &mut Sprites) -> Vec<(String, String)> {
    // Blocks with identical pixels share a layer (and the shader pairs by layer): a shared
    // base would glow on every block that shares it, so it gets no overlay.
    let mut sharing: BTreeMap<u32, usize> = BTreeMap::new();
@@ -56,8 +55,8 @@ pub fn load_optifine(root: &Path, sprites: &mut Sprites) -> Vec<(String, String)
            sharing[layer] == 1
                && (name
                    .split_once(':')
-                    .is_some_and(|(_, p)| p.starts_with("block/") && !p.ends_with(&suffix))
-                    || tile_file(name).is_some_and(|stem| !stem.ends_with(&suffix)))
+                    .is_some_and(|(_, p)| p.starts_with("block/") && !p.ends_with(suffix))
+                    || tile_file(name).is_some_and(|stem| !stem.ends_with(suffix)))
        })
        .map(|(name, _)| name.clone())
        .collect();
@@ -110,7 +109,7 @@ pub fn load_optifine(root: &Path, sprites: &mut Sprites) -> Vec<(String, String)
 pub const CUTOUT: u32 = 1 << 31;

 /// The frame's overlay table: native mods' pairs (at most [`NATIVE`] requested), then the packs'
-/// OptiFine pairs flagged [`CUTOUT`] (at most [`MAX`] - [`NATIVE`], as [`load_optifine`] loads),
+/// OptiFine pairs flagged [`CUTOUT`] (at most [`MAX`] - [`NATIVE`], as [`load_overlays`] loads),
 /// one per base layer with native mods' first, sorted by base layer for the shader's early exit.
 pub fn table<'a>(
    layers: &BTreeMap<String, u32>,
@@ -204,7 +203,7 @@ mod tests {
        // Items draw from the HUD atlas, not the terrain: no pair.
        sprites.insert(&root, "minecraft:item/stick").unwrap();
        // glowstone isn't loaded: its overlay pairs with nothing.
-        let pairs = load_optifine(&root, &mut sprites);
+        let pairs = load_overlays(&root, "_e", &mut sprites);
        assert_eq!(
            pairs,
            [(
@@ -215,9 +214,6 @@ mod tests {
        assert!(sprites.layers.contains_key("minecraft:block/stone_e"));
        assert!(!sprites.layers.contains_key("minecraft:block/granite_e"));
        // The pack's own suffix.
-        let props = root.join("assets/minecraft/optifine/emissive.properties");
-        std::fs::create_dir_all(props.parent().unwrap()).unwrap();
-        std::fs::write(&props, "suffix.emissive=_glow").unwrap();
        // Connected-texture tiles pair with the overlay beside them.
        let tiles = root.join("assets/minecraft/optifine/ctm/lamp");
        png(&tiles.join("0.png"), 230);
@@ -234,7 +230,7 @@ mod tests {
                .insert_file(&root, &format!("assets/minecraft/optifine/{tile}.png"))
                .unwrap();
        }
-        let pairs = load_optifine(&root, &mut sprites);
+        let pairs = load_overlays(&root, "_glow", &mut sprites);
        assert_eq!(
            pairs,
            // Blocks first, then tiles.
@@ -339,6 +339,7 @@ impl Opt {
            Opt::SharePresence => "options.sharePresence",
            Opt::DirectionalAudio => "options.directionalAudio",
            Opt::MusicToast => "options.musicToast",
+            Opt::Page(page, row) => pages::slider_caption(page, row),
        }
    }
    pub(crate) fn kind(self, s: &Settings) -> Kind {
@@ -402,6 +403,7 @@ impl Opt {
            Opt::PadLookDeadzone => unit(s.controller.look_deadzone, 0.0, 0.5),
            Opt::PadTriggerThreshold => unit(s.controller.trigger_threshold, 0.1, 0.9),
            Opt::SprintWindow => unit(s.sprint_window as f32, 0.0, 10.0),
+            Opt::Page(page, row) => pages::slider_kind(page, row),
            _ => Kind::Cycle,
        }
    }
@@ -878,6 +880,7 @@ impl Opt {
                gamepad::TextKeyboard::Horizon => "horizon.options.keyboard.horizon",
                gamepad::TextKeyboard::Steam => "horizon.options.keyboard.steam",
            }),
+            Opt::Page(page, row) => pages::slider_text(page, row),
            _ => Text::empty(),
        }
    }
@@ -952,6 +955,7 @@ impl Opt {
            Opt::PadLookDeadzone => s.controller.look_deadzone = step(0.0, 50.0) / 100.0,
            Opt::PadTriggerThreshold => s.controller.trigger_threshold = step(10.0, 90.0) / 100.0,
            Opt::SprintWindow => s.sprint_window = step(0.0, 10.0) as i32,
+            Opt::Page(page, row) => pages::slide(page, row, v),
            _ => {}
        }
        if self.affects_preset() {
@@ -1497,7 +1501,7 @@ pub enum Event {
    /// ones that differ from their defaults (the others went back to theirs).
    PackOptions {
        entries: Vec<String>,
-        chosen: std::collections::BTreeMap<String, horizon_polytone::pack::ConfigValue>,
+        chosen: std::collections::BTreeMap<String, horizon_pack_options::ConfigValue>,
    },
    /// An accepted button press or the release of a slider.
    ButtonClick,
@@ -1624,8 +1628,6 @@ pub struct OptionsUi {
    /// The native mod's key waiting: (mod, key) in `mods.installed`, or a registered page's
    /// (page, row) ([`pages::PAGE_KEY`]).
    selected_native_key: Option<(usize, usize)>,
-    /// The pages crates registered (`horizon_hooks::pages`).
-    pages: &'static [&'static dyn horizon_hooks::pages::Page],
    /// Bindings: the action waiting for a pad button.
    pub selected_pad_action: Option<&'static str>,
    /// The glyphs menus show (`Glyphs::of`: the setting, else the pad's family, and a Nintendo
@@ -1686,7 +1688,7 @@ pub struct OptionsUi {
    /// The Pack Options page, and the packs' Polytone config entries by pack id (the game
    /// fills them beside `pack_infos`).
    pub pack_options: crate::pack_options_ui::PackOptionsUi,
-    pub pack_configs: std::collections::BTreeMap<String, horizon_polytone::pack::Configs>,
+    pub pack_configs: std::collections::BTreeMap<String, horizon_pack_options::Configs>,
    pub split_profiles: crate::split_profiles::SplitProfiles,
    /// HDR calibration while its page is open.
    pub calibration: Option<crate::hdr_calibration::Calibration>,
@@ -1737,7 +1739,6 @@ impl Default for OptionsUi {
            scrollbar_drag_y: None,
            selected_key: None,
            selected_native_key: None,
-            pages: horizon_hooks::pages::engine::all(),
            selected_pad_action: None,
            pad_glyphs: crate::pad_glyph::Glyphs::default(),
            pad_driving: false,
@@ -1869,25 +1870,6 @@ fn wide_extras(s: &Settings, width: impl Fn(&str) -> f32) -> Vec<crate::extras::
        })
        .collect()
 }
-/// What a button opening one of Horizon's pages says on hover.
-fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
-    Some(match page {
-        Page::Horizon => "horizon.pages.settings.tooltip",
-        Page::Studio => "horizon.pages.studio.tooltip",
-        Page::Graphics => "horizon.pages.graphics.tooltip",
-        Page::GraphicsAdvanced => "horizon.pages.graphics_advanced.tooltip",
-        Page::Controller => "horizon.pages.controller.tooltip",
-        Page::Extras => "horizon.pages.extras.tooltip",
-        Page::Pvp => "horizon.pages.pvp.tooltip",
-        Page::Agent => "horizon.pages.agent.tooltip",
-        Page::SplitProfiles => "horizon.pages.split_profiles.tooltip",
-        Page::ShaderPacks => "horizon.pages.shader_packs.tooltip",
-        Page::Mods => "horizon.pages.mods.tooltip",
-        Page::SplitSetup => "horizon.pages.split_setup.tooltip",
-        Page::Music => "horizon.pages.music.tooltip",
-        _ => return None,
-    })
-}
 /// Rows of an OptionsList: (big?, options) or a header.
 enum Row {
    Big(Opt),
@@ -1907,14 +1889,17 @@ fn tooltip_text(s: &Settings, wd: &Widget) -> Option<Text> {
            return None;
        };
        let key = opt.tooltip_key(s);
-        return lang::has(&key).then(|| tr(&key));
+        let Opt::Page(page, row) = opt else {
+            return lang::has(&key).then(|| tr(&key));
+        };
+        return pages::tooltip(*page, *row);
    };
    let mut tip = None;
    if let Act::Extra(item) = act {
        tip = Some(Text::literal(item.description_text()));
    }
    if let Act::Push(page) = act
-        && let Some(text) = horizon_page_tooltip(*page)
+        && let Some(text) = pages::horizon_page_tooltip(*page)
    {
        tip = Some(tr(text));
    }
@@ -1934,6 +1919,7 @@ fn tooltip_text(s: &Settings, wd: &Widget) -> Option<Text> {
    }
    match act {
        Act::Cycle(opt) if !opt.available() => Some(tr("horizon.options.unavailable")),
+        Act::PageRow(page, row) => pages::tooltip(*page, *row),
        Act::ToggleMod(i) => match s.mods.installed.get(*i) {
            Some(installed) => {
                let description = installed
@@ -4032,7 +4018,7 @@ impl OptionsUi {
                    events.push(Event::DownloadPack(i));
                }
                crate::pack_screen::Action::Options(id) => {
-                    let mut configs = horizon_polytone::pack::Configs::default();
+                    let mut configs = horizon_pack_options::Configs::default();
                    if let Some(own) = self.pack_configs.get(&id) {
                        configs.merge(own);
                    }
@@ -8,9 +8,88 @@ use horizon_hooks::pages as added;
 /// `selected_key` while a registered page's key waits (`selected_native_key`: page, row).
 pub(super) const PAGE_KEY: &str = "horizon.pageKey";

+#[cfg(test)]
+thread_local! {
+    /// A test's own pages, instead of the game's registered ones: each test runs on its thread.
+    static TEST_PAGES: std::cell::Cell<Option<&'static [&'static dyn added::Page]>> =
+        const { std::cell::Cell::new(None) };
+}
+
+/// The pages crates registered.
+fn registered() -> &'static [&'static dyn added::Page] {
+    #[cfg(test)]
+    if let Some(pages) = TEST_PAGES.get() {
+        return pages;
+    }
+    added::engine::all()
+}
+
 /// A registered page's title (a translation key).
 pub(super) fn title(page: usize) -> &'static str {
-    added::engine::all().get(page).map_or("", |p| p.title())
+    registered().get(page).map_or("", |p| p.title())
+}
+
+/// Row `r` of a registered page, as it is now.
+fn row(page: usize, r: usize) -> Option<added::Row> {
+    let mut rows = Vec::new();
+    registered().get(page)?.rows(&mut rows);
+    rows.into_iter().nth(r)
+}
+
+/// A registered page's slider ([`Opt::Page`]): its caption (a translation key).
+pub(super) fn slider_caption(page: usize, r: usize) -> &'static str {
+    match row(page, r) {
+        Some(added::Row::Slider { label, .. }) => label,
+        _ => "",
+    }
+}
+
+/// A registered page's slider: its position.
+pub(super) fn slider_kind(page: usize, r: usize) -> Kind {
+    match row(page, r) {
+        Some(added::Row::Slider { value, .. }) => Kind::Slider(value.clamp(0.0, 1.0)),
+        _ => Kind::Cycle,
+    }
+}
+
+/// A registered page's slider: the value its message shows after the caption.
+pub(super) fn slider_text(page: usize, r: usize) -> Text {
+    match row(page, r) {
+        Some(added::Row::Slider { text, .. }) => label_text(text),
+        _ => Text::empty(),
+    }
+}
+
+/// A registered page's slider moved.
+pub(super) fn slide(page: usize, r: usize, value: f32) {
+    if let Some(registered) = registered().get(page) {
+        registered.act(r, added::Act::Slide(value));
+    }
+}
+
+/// What a registered page's row says on hover.
+pub(super) fn tooltip(page: usize, r: usize) -> Option<Text> {
+    registered().get(page)?.tooltip(r).map(label_text)
+}
+
+/// What a button opening one of Horizon's pages says on hover.
+pub(super) fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
+    Some(match page {
+        Page::Horizon => "horizon.pages.settings.tooltip",
+        Page::Studio => "horizon.pages.studio.tooltip",
+        Page::Graphics => "horizon.pages.graphics.tooltip",
+        Page::GraphicsAdvanced => "horizon.pages.graphics_advanced.tooltip",
+        Page::Controller => "horizon.pages.controller.tooltip",
+        Page::Extras => "horizon.pages.extras.tooltip",
+        Page::Pvp => "horizon.pages.pvp.tooltip",
+        Page::Agent => "horizon.pages.agent.tooltip",
+        Page::SplitProfiles => "horizon.pages.split_profiles.tooltip",
+        Page::ShaderPacks => "horizon.pages.shader_packs.tooltip",
+        Page::Mods => "horizon.pages.mods.tooltip",
+        Page::SplitSetup => "horizon.pages.split_setup.tooltip",
+        Page::Music => "horizon.pages.music.tooltip",
+        _ => return None,
+    })
 }

 fn label_text(label: added::Label) -> Text {
@@ -66,8 +145,7 @@ impl OptionsUi {

    /// The entries of the pages registered for Horizon Settings, two to a row like the engine's.
    fn added_entries(&self, rows: &mut Vec<Row>) {
-        let mut entries = self
-            .pages
+        let mut entries = registered()
            .iter()
            .enumerate()
            .filter(|(_, page)| page.place() == added::Place::HorizonSettings)
@@ -79,15 +157,43 @@ impl OptionsUi {

    /// A registered page's rows, asked of it each time the page is drawn.
    pub(super) fn added_rows(&self, page: usize) -> Vec<Row> {
-        let Some(registered) = self.pages.get(page) else {
+        let Some(registered) = registered().get(page) else {
            return Vec::new();
        };
        let mut rows = Vec::new();
        registered.rows(&mut rows);
-        rows.into_iter()
-            .enumerate()
-            .map(|(r, row)| self.added_row(page, r, row))
-            .collect()
+        let mut out = Vec::new();
+        // The row a half-width button started, waiting for the next to sit beside it.
+        let mut half_open = false;
+        for (r, row) in rows.into_iter().enumerate() {
+            match row {
+                // Wrapped as the engine's own notes; space is for pages drawn as a screen.
+                added::Row::Text { text, .. } => {
+                    out.extend(wrap(&text, 64).into_iter().map(Row::Note))
+                }
+                added::Row::Space(_) => continue,
+                added::Row::Button {
+                    label,
+                    active,
+                    half: true,
+                    ..
+                } => {
+                    let mut half = button(0.0, 0.0, 150.0, tr(label), Act::PageRow(page, r));
+                    if !active {
+                        half = inactive(half);
+                    }
+                    match out.last_mut() {
+                        Some(Row::Buttons(_, second @ None)) if half_open => *second = Some(half),
+                        _ => out.push(Row::Buttons(half, None)),
+                    }
+                    half_open = !half_open;
+                    continue;
+                }
+                row => out.push(self.added_row(page, r, row)),
+            }
+            half_open = false;
+        }
+        out
    }

    fn added_row(&self, page: usize, r: usize, row: added::Row) -> Row {
@@ -98,7 +204,11 @@ impl OptionsUi {
            added::Row::Note(text) => Row::Note(text),
            added::Row::Toggle { label, on } => wide(generic(label, on_off(on))),
            added::Row::Cycle { label, value } => wide(generic(label, label_text(value))),
-            added::Row::Button { label } => wide(tr(label)),
+            added::Row::Slider { .. } => Row::Big(Opt::Page(page, r)),
+            added::Row::Button { label, active, .. } => {
+                let wide = button(0.0, 0.0, 310.0, tr(label), act);
+                Row::Buttons(if active { wide } else { inactive(wide) }, None)
+            }
            added::Row::Key { label, key } => {
                let mut message = keybinds::display_name(&key);
                if self.selected_key == Some(PAGE_KEY)
@@ -120,7 +230,7 @@ impl OptionsUi {

    /// A registered page's row was pressed: a key row waits for a key, any other row hears it.
    pub(super) fn page_act(&mut self, page: usize, r: usize, shift: bool) -> Vec<Event> {
-        let Some(registered) = self.pages.get(page) else {
+        let Some(registered) = registered().get(page) else {
            return Vec::new();
        };
        let mut rows = Vec::new();
@@ -199,7 +309,7 @@ impl OptionsUi {
    ) -> Vec<Event> {
        let (i, k) = self.selected_native_key.take().unwrap_or_default();
        if name == PAGE_KEY {
-            if let Some(page) = self.pages.get(i) {
+            if let Some(page) = registered().get(i) {
                page.act(k, added::Act::Bind(value));
            }
            return vec![Event::Changed];
@@ -221,11 +331,12 @@ mod tests {
    use super::*;
    use std::sync::Mutex;

-    /// A page with a heading, a switch, a number that steps either way and a key.
+    /// A page with a heading, a switch, a number that steps either way, a key and a volume.
    struct Sample {
        on: Mutex<bool>,
        step: Mutex<i32>,
        key: Mutex<String>,
+        volume: Mutex<f32>,
    }

    impl added::Page for Sample {
@@ -252,6 +363,12 @@ mod tests {
                label: "test.sample.key",
                key: self.key.lock().unwrap().clone(),
            });
+            let volume = *self.volume.lock().unwrap();
+            rows.push(added::Row::Slider {
+                label: "test.sample.volume",
+                value: volume,
+                text: added::Label::Value(format!("{}%", (volume * 100.0).round())),
+            });
        }
        fn act(&self, row: usize, act: added::Act) {
            match (row, act) {
@@ -262,15 +379,20 @@ mod tests {
                (2, added::Act::Press) => *self.step.lock().unwrap() += 1,
                (2, added::Act::PressBack) => *self.step.lock().unwrap() -= 1,
                (3, added::Act::Bind(key)) => *self.key.lock().unwrap() = key,
+                (4, added::Act::Slide(v)) => *self.volume.lock().unwrap() = v,
                other => panic!("row and act the page doesn't expect: {other:?}"),
            }
        }
+        fn tooltip(&self, row: usize) -> Option<added::Label> {
+            (row == 1).then_some(added::Label::Key("test.sample.switch.tooltip"))
+        }
    }

    static SAMPLE: Sample = Sample {
        on: Mutex::new(false),
        step: Mutex::new(0),
        key: Mutex::new(String::new()),
+        volume: Mutex::new(0.0),
    };
    static PAGES: [&dyn added::Page; 1] = [&SAMPLE];

@@ -297,10 +419,8 @@ mod tests {
    #[test]
    fn a_registered_page_opens_from_horizon_settings_and_hears_its_rows() {
        let mut s = Settings::default();
-        let mut ui = OptionsUi {
-            pages: &PAGES,
-            ..OptionsUi::default()
-        };
+        TEST_PAGES.set(Some(&PAGES));
+        let mut ui = OptionsUi::default();
        ui.show(Page::Horizon);
        press(&mut ui, &mut s, Act::Push(Page::Added(0)), false);
        assert_eq!(ui.page(), Page::Added(0));
@@ -323,5 +443,133 @@ mod tests {
        assert_eq!(events, [Event::Changed]);
        assert_eq!(*SAMPLE.key.lock().unwrap(), "key.keyboard.z");
        assert_eq!(ui.selected_key, None);
+        // The volume is one of the screen's own sliders: dragged to its middle, then let go.
+        let size = (480.0, 240.0);
+        let (widgets, ..) = ui.layout(&s, size.0, size.1);
+        let slider = widgets
+            .iter()
+            .find(|w| {
+                matches!(
+                    w.kind,
+                    WKind::Slider {
+                        opt: Opt::Page(0, 4),
+                        ..
+                    }
+                )
+            })
+            .expect("the volume's slider");
+        let (x, y) = (slider.x + slider.w / 2.0, slider.y + 1.0);
+        ui.click(&mut s, &atlas, x, y, size, [480, 240], false, false);
+        let volume = *SAMPLE.volume.lock().unwrap();
+        assert!((0.45..0.55).contains(&volume), "{volume}");
+        assert!(ui.release().contains(&Event::Changed));
+        // The slider shows the page's value once let go.
+        let (widgets, ..) = ui.layout(&s, size.0, size.1);
+        let shown = widgets.iter().find_map(|w| match w.kind {
+            WKind::Slider {
+                opt: Opt::Page(0, 4),
+                value,
+                ..
+            } => Some(value),
+            _ => None,
+        });
+        assert_eq!(shown, Some(volume));
+        // The page's tooltip for its switch.
+        let switch = widgets
+            .iter()
+            .find(|w| {
+                matches!(
+                    &w.kind,
+                    WKind::Button {
+                        act: Act::PageRow(0, 1),
+                        ..
+                    }
+                )
+            })
+            .expect("the switch");
+        assert_eq!(
+            tooltip_text(&s, switch).map(|t| t.plain()),
+            Some(tr("test.sample.switch.tooltip").plain())
+        );
+    }
+
+    /// Text, a grey note, space, two half buttons (the second inactive) and a footer button.
+    struct Shaped(Mutex<Vec<usize>>);
+
+    impl added::Page for Shaped {
+        fn id(&self) -> &'static str {
+            "test.shaped"
+        }
+        fn title(&self) -> &'static str {
+            "test.shaped.title"
+        }
+        fn place(&self) -> added::Place {
+            added::Place::HorizonSettings
+        }
+        fn rows(&self, rows: &mut Vec<added::Row>) {
+            rows.push(added::Row::text("ABCDE-FGHIJ").groups());
+            rows.push(added::Row::text("grey").quiet());
+            rows.push(added::Row::Space(6));
+            rows.push(added::Row::button("test.shaped.copy").half());
+            rows.push(added::Row::button("test.shaped.stop").half().active(false));
+            rows.push(added::Row::button("test.shaped.help").footer());
+        }
+        fn act(&self, row: usize, _: added::Act) {
+            self.0.lock().unwrap().push(row);
+        }
+    }
+
+    static SHAPED: Shaped = Shaped(Mutex::new(Vec::new()));
+    static SHAPED_PAGES: [&dyn added::Page; 1] = [&SHAPED];
+
+    #[test]
+    fn half_buttons_share_a_row_and_an_inactive_one_is_never_pressed() {
+        let mut s = Settings::default();
+        TEST_PAGES.set(Some(&SHAPED_PAGES));
+        let ui = OptionsUi::default();
+        let rows = ui.added_rows(0);
+        // The two texts as notes (space shows nothing here), the halves on one row, the
+        // footer button below them (the settings shell has no footer of its own).
+        assert!(matches!(&rows[0], Row::Note(t) if t == "ABCDE-FGHIJ"));
+        assert!(matches!(&rows[1], Row::Note(t) if t == "grey"));
+        let Row::Buttons(copy, Some(stop)) = &rows[2] else {
+            panic!("the halves sit side by side: {:?}", rows.len());
+        };
+        assert_eq!((copy.w, stop.w), (150.0, 150.0));
+        assert!(matches!(&rows[3], Row::Buttons(help, None) if help.w == 310.0));
+        assert_eq!(rows.len(), 4);
+        let mut ui = ui;
+        ui.show(Page::Added(0));
+        press(&mut ui, &mut s, Act::PageRow(0, 3), false);
+        press(&mut ui, &mut s, Act::PageRow(0, 5), false);
+        let (widgets, ..) = ui.layout(&s, 480.0, 240.0);
+        let stop = widgets
+            .iter()
+            .find(|w| {
+                matches!(
+                    &w.kind,
+                    WKind::Button {
+                        act: Act::PageRow(0, 4),
+                        ..
+                    }
+                )
+            })
+            .expect("Stop is drawn");
+        let atlas = super::super::tests::atlas();
+        ui.click(
+            &mut s,
+            &atlas,
+            stop.x + 1.0,
+            stop.y + 1.0,
+            (480.0, 240.0),
+            [480, 240],
+            false,
+            false,
+        );
+        assert_eq!(
+            *SHAPED.0.lock().unwrap(),
+            [3, 5],
+            "the inactive half heard nothing"
+        );
    }
 }
@@ -12,6 +12,7 @@
 //! block models here, so their files are not read; copper golem statues have no CEM name.

 use crate::block_entity_render::ModelPart;
+use crate::pack_hooks::Reshaped;
 use horizon_optifine::cem::{
    files::{atlas_name, jem_files, load_jem},
    model::{Bone, EntityModel},
@@ -140,12 +141,6 @@ const TARGETS: &[Target] = &[
    model("decorated_pot_sides", &["decorated_pot"], POT_SIDES),
 ];

-/// Every model, reshaped or vanilla's, and the atlas names of the `.jem` textures by model.
-pub type Reshaped = (
-    HashMap<&'static str, ModelPart>,
-    HashMap<&'static str, String>,
-);
-
 /// The models the packs under `root` reshape, over `vanilla`'s; None when no block entity has
 /// a `.jem` there.
 pub fn reshape(root: &Path, vanilla: &HashMap<&'static str, ModelPart>) -> Option<Reshaped> {
@@ -0,0 +1,969 @@
+//! OptiFine's Custom Item Textures (and CIT Resewn's): the rules of the enabled packs'
+//! `optifine/cit/**/*.properties`, read from the overlay resource root, and which of them a stack
+//! matches ([`crate::cit::Matcher`]). The rules themselves are `horizon_optifine::cit`'s; the
+//! engine gets them as [`crate::cit::Rule`]s.
+
+use super::cit_glint::{load_global, stack_glint};
+use crate::cit::{self as engine, CitRules};
+use crate::cit_glint::StackGlint;
+use horizon_client_core::component::name_text;
+use horizon_client_core::scoreboard::comp_text;
+use horizon_items::item_data::{canon_tag, encode_components};
+use horizon_items::items::ItemStack;
+use horizon_optifine::cit::{
+    Blend, ComponentTest, Factor, Glint, Global, Hand, Kind, Rule, Source, ValueTest,
+};
+use horizon_optifine::{Properties, properties_files_in};
+use horizon_world::nbt::{JavaString, Tag, parse_snbt};
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fs;
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Every rule under the root's `optifine/cit/`, `mcpatcher/cit/` and CIT Resewn's
+/// `citresewn/cit/` folders, the one chosen first when several match first (`Rule::priority`).
+/// The pack's global `cit.properties` is not a rule.
+pub fn load_rules(root: &Path) -> Vec<Rule> {
+    let tops = ["optifine", "mcpatcher", "citresewn"];
+    let mut rules: Vec<Rule> = properties_files_in(root, &tops, "cit")
+        .into_iter()
+        .filter(|path| !path.ends_with("/cit.properties"))
+        .filter_map(|path| {
+            let props = read_properties(&root.join(&path))?;
+            let rule = Rule::parse(&path, &props, |p| root.join(p).is_file());
+            if rule.is_none() {
+                log::warn!("custom item textures: {path} is not a rule Horizon can read");
+            }
+            rule
+        })
+        .collect();
+    rules.sort_by(Rule::priority);
+    rules
+}
+
+/// A `.properties` file as CIT Resewn reads them (`Properties::parse_equals_first`): UTF-8,
+/// else Latin-1 as Java reads them, so a pack saved that way still loads. `None` when it can't
+/// be read.
+pub fn read_properties(path: &Path) -> Option<Properties> {
+    let bytes = fs::read(path).ok()?;
+    let text = String::from_utf8(bytes)
+        .unwrap_or_else(|e| e.into_bytes().iter().map(|&b| char::from(b)).collect());
+    Some(Properties::parse_equals_first(&text))
+}
+
+/// The rules at `root` with the pack's `cit.properties`, as the engine draws and matches them.
+pub fn load(root: &Path) -> CitRules {
+    cit_rules(load_rules(root), load_global(root))
+}
+
+/// `rules` (in priority order, the winner first) under `global`, for the engine.
+pub fn cit_rules(rules: Vec<Rule>, global: Global) -> CitRules {
+    let drawn = rules.iter().map(rule).collect();
+    let use_glint = global.use_glint;
+    CitRules::new(drawn, use_glint, Box::new(Matcher::new(rules, global)))
+}
+
+/// A rule's file as the engine draws it: `text` read as the `.properties` file at `path`, every
+/// file it names taken to exist. For tests and tools.
+pub fn parse_rule(path: &str, text: &str) -> Option<engine::Rule> {
+    Rule::parse(path, &Properties::parse_equals_first(text), |_| true).map(|r| rule(&r))
+}
+
+/// [`parse_rule`] for a rule in the pack at `root`, whose files it looks for there.
+pub fn parse_rule_in(root: &Path, path: &str, text: &str) -> Option<engine::Rule> {
+    let props = Properties::parse_equals_first(text);
+    Rule::parse(path, &props, |p| root.join(p).is_file()).map(|r| rule(&r))
+}
+
+/// Rules from (path, `.properties` text) under the global `cit.properties` text `global`, in
+/// priority order, every file they name taken to exist. For tests and tools.
+pub fn parse_rules(files: &[(&str, &str)], global: &str) -> CitRules {
+    let mut rules: Vec<Rule> = files
+        .iter()
+        .filter_map(|(path, text)| {
+            Rule::parse(path, &Properties::parse_equals_first(text), |_| true)
+        })
+        .collect();
+    rules.sort_by(Rule::priority);
+    cit_rules(
+        rules,
+        Global::parse(&Properties::parse_equals_first(global)),
+    )
+}
+
+/// A `blend=` value as the engine draws it ([`horizon_optifine::cit::parse_blend`]). For tests
+/// and tools.
+pub fn parse_blend(value: &str) -> Option<Option<engine::Blend>> {
+    horizon_optifine::cit::parse_blend(value).map(|b| b.map(blend))
+}
+
+fn rule(r: &Rule) -> engine::Rule {
+    engine::Rule {
+        path: r.path.clone(),
+        kind: kind(r.kind),
+        texture: r.texture.clone(),
+        textures: r.textures.clone(),
+        model: r.model.clone(),
+        models: r.models.clone(),
+        glint: glint(&r.glint),
+    }
+}
+
+fn kind(k: Kind) -> engine::Kind {
+    match k {
+        Kind::Item => engine::Kind::Item,
+        Kind::Armor => engine::Kind::Armor,
+        Kind::Elytra => engine::Kind::Elytra,
+        Kind::Enchantment => engine::Kind::Enchantment,
+    }
+}
+
+fn of_kind(k: engine::Kind) -> Kind {
+    match k {
+        engine::Kind::Item => Kind::Item,
+        engine::Kind::Armor => Kind::Armor,
+        engine::Kind::Elytra => Kind::Elytra,
+        engine::Kind::Enchantment => Kind::Enchantment,
+    }
+}
+
+fn of_hand(h: engine::Hand) -> Hand {
+    match h {
+        engine::Hand::Any => Hand::Any,
+        engine::Hand::Main => Hand::Main,
+        engine::Hand::Off => Hand::Off,
+    }
+}
+
+fn glint(g: &Glint) -> engine::Glint {
+    engine::Glint {
+        layer: g.layer,
+        blend: g.blend.map(blend),
+        speed: g.speed,
+        rotation: g.rotation,
+        duration: g.duration,
+        rgba: g.rgba,
+        use_glint: g.use_glint,
+        blur: g.blur,
+    }
+}
+
+fn blend(b: Blend) -> engine::Blend {
+    engine::Blend {
+        src: factor(b.src),
+        dst: factor(b.dst),
+        src_alpha: factor(b.src_alpha),
+        dst_alpha: factor(b.dst_alpha),
+    }
+}
+
+fn factor(f: Factor) -> engine::Factor {
+    use engine::Factor as F;
+    match f {
+        Factor::Zero => F::Zero,
+        Factor::One => F::One,
+        Factor::SrcColor => F::SrcColor,
+        Factor::OneMinusSrcColor => F::OneMinusSrcColor,
+        Factor::SrcAlpha => F::SrcAlpha,
+        Factor::OneMinusSrcAlpha => F::OneMinusSrcAlpha,
+        Factor::DstAlpha => F::DstAlpha,
+        Factor::OneMinusDstAlpha => F::OneMinusDstAlpha,
+        Factor::DstColor => F::DstColor,
+        Factor::OneMinusDstColor => F::OneMinusDstColor,
+        Factor::SrcAlphaSaturate => F::SrcAlphaSaturate,
+    }
+}
+
+/// The rules with an index by item and a cache of what each stack matched.
+#[derive(Debug, Default)]
+struct Matcher {
+    rules: Vec<Rule>,
+    /// The pack's `cit.properties`.
+    global: Global,
+    /// Per kind (`Kind as usize`), the rules naming each item, in priority order.
+    by_item: [HashMap<String, Vec<u32>>; 4],
+    /// Enchantment rules without `items`, in priority order.
+    any_item: Vec<u32>,
+    /// Per rule, per component test: its literal read as SNBT and as a JSON text component.
+    literals: Vec<Vec<Prepared>>,
+    selected: Mutex<HashMap<u64, Option<u32>>>,
+    enchanted: Mutex<HashMap<u64, Vec<u32>>>,
+    glints: Mutex<HashMap<u64, Arc<StackGlint>>>,
+}
+
+#[derive(Debug, Default)]
+struct Prepared {
+    snbt: Option<Tag>,
+    json: Option<String>,
+}
+
+/// Cache entries kept before the cache starts over.
+const CACHE_LIMIT: usize = 4096;
+
+impl Matcher {
+    /// `rules` in priority order, the winner first.
+    fn new(rules: Vec<Rule>, global: Global) -> Self {
+        let mut by_item: [HashMap<String, Vec<u32>>; 4] = Default::default();
+        let mut any_item = Vec::new();
+        for (i, rule) in rules.iter().enumerate() {
+            let i = i as u32;
+            if rule.kind == Kind::Enchantment && rule.items.is_empty() {
+                any_item.push(i);
+            }
+            for item in &rule.items {
+                let list = by_item[rule.kind as usize].entry(item.clone()).or_default();
+                if list.last() != Some(&i) {
+                    list.push(i);
+                }
+            }
+        }
+        let literals = rules
+            .iter()
+            .map(|r| r.components.iter().map(prepare).collect())
+            .collect();
+        Self {
+            rules,
+            global,
+            by_item,
+            any_item,
+            literals,
+            ..Default::default()
+        }
+    }
+
+    /// Whether rule `i` matches the stack drawn in `hand`.
+    fn matches(
+        &self,
+        i: u32,
+        stack: &ItemStack,
+        hand: Hand,
+        max_damage: u32,
+        comps: Option<&Tag>,
+    ) -> bool {
+        let rule = &self.rules[i as usize];
+        if rule.hand != Hand::Any && rule.hand != hand {
+            return false;
+        }
+        let count = i32::try_from(stack.count).unwrap_or(i32::MAX);
+        if rule.stack_size.as_ref().is_some_and(|r| !r.contains(count)) {
+            return false;
+        }
+        // CIT Resewn: only damageable items have damage.
+        let damage = if max_damage > 0 { stack.damage } else { 0 };
+        if rule
+            .damage
+            .as_ref()
+            .is_some_and(|d| !d.matches(damage, max_damage))
+        {
+            return false;
+        }
+        let enchantments = stack.crafting_enchantments();
+        let listed = |id: &str| rule.enchantments.iter().any(|e| e == id);
+        if !rule.enchantments.is_empty() && !enchantments.iter().any(|(id, _)| listed(id)) {
+            return false;
+        }
+        if let Some(levels) = &rule.enchantment_levels {
+            let level_in_range = enchantments.iter().any(|(id, level)| {
+                (rule.enchantments.is_empty() || listed(id))
+                    && levels.contains(i32::try_from(*level).unwrap_or(i32::MAX))
+            });
+            if !level_in_range {
+                return false;
+            }
+        }
+        let literals = &self.literals[i as usize];
+        rule.components
+            .iter()
+            .zip(literals)
+            .all(|(test, lit)| component_test(test, lit, stack, comps) != test.negate)
+    }
+}
+
+impl engine::Matcher for Matcher {
+    fn keep_glints(&mut self, keep: &dyn Fn(usize) -> bool) {
+        self.any_item.retain(|&i| keep(i as usize));
+        let named = &mut self.by_item[Kind::Enchantment as usize];
+        for list in named.values_mut() {
+            list.retain(|&i| keep(i as usize));
+        }
+        named.retain(|_, list| !list.is_empty());
+        lock(&self.enchanted).clear();
+        lock(&self.glints).clear();
+    }
+
+    fn select(
+        &self,
+        kind: engine::Kind,
+        stack: &ItemStack,
+        hand: engine::Hand,
+        max_damage: u32,
+    ) -> Option<usize> {
+        let (kind, hand) = (of_kind(kind), of_hand(hand));
+        let candidates = self.by_item[kind as usize].get(&*stack.item)?;
+        let comps = encode_components(stack);
+        let key = cache_key((0, kind, hand), stack, max_damage, comps.as_ref());
+        if let Some(hit) = lock(&self.selected).get(&key) {
+            return hit.map(|i| i as usize);
+        }
+        let found = candidates
+            .iter()
+            .copied()
+            .find(|&i| self.matches(i, stack, hand, max_damage, comps.as_ref()));
+        remember(&self.selected, key, found);
+        found.map(|i| i as usize)
+    }
+
+    fn enchantments(&self, stack: &ItemStack, hand: engine::Hand, max_damage: u32) -> Vec<usize> {
+        let hand = of_hand(hand);
+        let named = self.by_item[Kind::Enchantment as usize]
+            .get(&*stack.item)
+            .map_or(&[][..], Vec::as_slice);
+        if named.is_empty() && self.any_item.is_empty() {
+            return Vec::new();
+        }
+        let comps = encode_components(stack);
+        let key = cache_key(
+            (1, Kind::Enchantment, hand),
+            stack,
+            max_damage,
+            comps.as_ref(),
+        );
+        let hit = lock(&self.enchanted).get(&key).cloned();
+        let found = hit.unwrap_or_else(|| {
+            let mut all: Vec<u32> = named.iter().chain(&self.any_item).copied().collect();
+            all.sort_unstable();
+            all.retain(|&i| self.matches(i, stack, hand, max_damage, comps.as_ref()));
+            remember(&self.enchanted, key, all.clone());
+            all
+        });
+        found.into_iter().map(|i| i as usize).collect()
+    }
+
+    /// Worked out once per stack and hand.
+    fn glint(
+        &self,
+        stack: &ItemStack,
+        hand: engine::Hand,
+        max_damage: u32,
+        foil: bool,
+    ) -> Option<Arc<StackGlint>> {
+        let no_rules =
+            self.any_item.is_empty() && self.by_item[Kind::Enchantment as usize].is_empty();
+        // Before the cache, which `foil` is not part of.
+        if !foil || (no_rules && self.global.use_glint) {
+            return None;
+        }
+        let comps = encode_components(stack);
+        let key = cache_key(
+            (2, Kind::Enchantment, of_hand(hand)),
+            stack,
+            max_damage,
+            comps.as_ref(),
+        );
+        if let Some(hit) = lock(&self.glints).get(&key) {
+            return Some(hit.clone());
+        }
+        let matched = self.enchantments(stack, hand, max_damage);
+        let glint = Arc::new(stack_glint(
+            &self.rules,
+            &matched,
+            stack.crafting_enchantments(),
+            &self.global,
+        ));
+        remember(&self.glints, key, glint.clone());
+        Some(glint)
+    }
+}
+
+fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
+    m.lock().unwrap_or_else(|e| e.into_inner())
+}
+
+fn remember<V>(cache: &Mutex<HashMap<u64, V>>, key: u64, value: V) {
+    let mut cache = lock(cache);
+    if cache.len() >= CACHE_LIMIT {
+        cache.clear();
+    }
+    cache.insert(key, value);
+}
+
+/// What a cached answer depends on; `query` tells `select`, `enchantments` and `glint` apart.
+fn cache_key(query: (u8, Kind, Hand), stack: &ItemStack, max: u32, comps: Option<&Tag>) -> u64 {
+    let mut h = DefaultHasher::new();
+    (query.0, query.1 as u8, query.2 as u8, &*stack.item).hash(&mut h);
+    (stack.count, stack.damage, max, comps).hash(&mut h);
+    h.finish()
+}
+
+fn prepare(test: &ComponentTest) -> Prepared {
+    let ValueTest::Literal(lit) = &test.value else {
+        return Prepared::default();
+    };
+    let text = lit.text.trim();
+    let snbt = match parse_snbt(text) {
+        Ok((tag, read)) if read == text.len() && text.starts_with(['{', '[']) => Some(tag),
+        _ => None,
+    };
+    let json = json_plain(text);
+    Prepared { snbt, json }
+}
+
+/// The plain text of `s` read as a JSON text component.
+fn json_plain(s: &str) -> Option<String> {
+    if !s.starts_with(['{', '[', '"']) {
+        return None;
+    }
+    let value: serde_json::Value = serde_json::from_str(s).ok()?;
+    Some(comp_text(&value).plain())
+}
+
+/// Whether one test passes, before its `negate`.
+fn component_test(
+    test: &ComponentTest,
+    lit: &Prepared,
+    stack: &ItemStack,
+    comps: Option<&Tag>,
+) -> bool {
+    let legacy;
+    let (root, text_depth) = match &test.source {
+        Source::Component(id) => {
+            let depth = match id.as_str() {
+                "minecraft:custom_name" | "minecraft:item_name" => Some(0),
+                "minecraft:lore" => Some(1),
+                _ => None,
+            };
+            (comps.and_then(|c| c.get(id)), depth)
+        }
+        Source::LegacyEnchantments { stored } => {
+            let levels = if *stored {
+                stack.stored_enchantments()
+            } else {
+                stack.enchantments()
+            };
+            legacy = Tag::List(
+                levels
+                    .iter()
+                    .map(|(id, lvl)| {
+                        let lvl = i16::try_from(*lvl).unwrap_or(i16::MAX);
+                        Tag::compound([
+                            ("id", Tag::String((&**id).into())),
+                            ("lvl", Tag::Short(lvl)),
+                        ])
+                    })
+                    .collect(),
+            );
+            (Some(&legacy), None)
+        }
+    };
+    // Fields the component leaves out when 0, which pre-1.20.5 items always wrote.
+    let defaulted;
+    let root = match (&test.source, root, test.path.first()) {
+        (Source::Component(id), Some(Tag::Compound(map)), Some(field))
+            if matches!(
+                (id.as_str(), field.as_str()),
+                ("minecraft:written_book_content", "generation")
+                    | ("minecraft:fireworks", "flight_duration")
+            ) && !map.contains_key(&JavaString::from(field.as_str())) =>
+        {
+            let mut map = map.clone();
+            map.insert(JavaString::from(field.as_str()), Tag::Int(0));
+            defaulted = Tag::Compound(map);
+            Some(&defaulted)
+        }
+        (_, root, _) => root,
+    };
+    let Some(root) = root else {
+        return matches!(test.value, ValueTest::Exists(false));
+    };
+    if let ValueTest::Exists(want) = test.value {
+        return walk(root, &test.path, 0, &mut |_, _| true) == want;
+    }
+    walk(root, &test.path, 0, &mut |tag, depth| {
+        value_test(&test.value, lit, tag, text_depth == Some(depth))
+    })
+}
+
+/// Visits what `path` reaches from `tag`, true once `visit` is.
+fn walk(
+    tag: &Tag,
+    path: &[String],
+    depth: usize,
+    visit: &mut dyn FnMut(&Tag, usize) -> bool,
+) -> bool {
+    let Some((seg, rest)) = path.split_first() else {
+        return visit(tag, depth);
+    };
+    let mut next = |t: &Tag| walk(t, rest, depth + 1, visit);
+    let len = match tag {
+        Tag::Compound(map) if seg == "*" => return map.values().any(&mut next),
+        Tag::Compound(map) => return map.get(&JavaString::from(seg.as_str())).is_some_and(next),
+        Tag::List(v) => v.len(),
+        Tag::ByteArray(v) => v.len(),
+        Tag::IntArray(v) => v.len(),
+        Tag::LongArray(v) => v.len(),
+        _ => return false,
+    };
+    let element = |i: usize| match tag {
+        Tag::List(v) => Cow::Borrowed(&v[i]),
+        Tag::ByteArray(v) => Cow::Owned(Tag::Byte(v[i] as i8)),
+        Tag::IntArray(v) => Cow::Owned(Tag::Int(v[i])),
+        Tag::LongArray(v) => Cow::Owned(Tag::Long(v[i])),
+        _ => Cow::Owned(Tag::End),
+    };
+    if seg == "count" {
+        return next(&Tag::Int(i32::try_from(len).unwrap_or(i32::MAX)));
+    }
+    if seg == "*" {
+        return (0..len).any(|i| next(&element(i)));
+    }
+    seg.parse::<usize>()
+        .ok()
+        .filter(|&i| i < len)
+        .is_some_and(|i| next(&element(i)))
+}
+
+fn int_value(tag: &Tag) -> Option<i64> {
+    match *tag {
+        Tag::Byte(v) => Some(v.into()),
+        Tag::Short(v) => Some(v.into()),
+        Tag::Int(v) => Some(v.into()),
+        Tag::Long(v) => Some(v),
+        _ => None,
+    }
+}
+
+/// A number as Java's `String.valueOf` writes it (`3`, `3.0`).
+fn decimal(tag: &Tag) -> Option<String> {
+    let s = match *tag {
+        Tag::Float(b) => f32::from_bits(b).to_string(),
+        Tag::Double(b) => f64::from_bits(b).to_string(),
+        _ => return int_value(tag).map(|v| v.to_string()),
+    };
+    Some(if s.contains(['.', 'e', 'N', 'i']) {
+        s
+    } else {
+        s + ".0"
+    })
+}
+
+/// `text` against a string, its JSON text, or the plain text of a text component.
+fn text_matches(tag: &Tag, is_text: bool, text: impl Fn(&str) -> bool) -> bool {
+    match tag {
+        Tag::String(s) => {
+            let s = s.to_string_lossy();
+            text(&s)
+                || (is_text && text(&name_text(tag).plain()))
+                || json_plain(&s).is_some_and(|p| text(&p))
+        }
+        Tag::Compound(_) | Tag::List(_) => is_text && text(&name_text(tag).plain()),
+        _ => false,
+    }
+}
+
+fn value_test(test: &ValueTest, lit: &Prepared, tag: &Tag, is_text: bool) -> bool {
+    match test {
+        ValueTest::Exists(_) => true,
+        ValueTest::Range(r) => {
+            int_value(tag).is_some_and(|v| i32::try_from(v).is_ok_and(|v| r.contains(v)))
+        }
+        ValueTest::Raw(name) => name.matches(&canon_tag(tag)),
+        ValueTest::Text(name) => match decimal(tag) {
+            Some(n) => name.matches(&n),
+            None => text_matches(tag, is_text, |s| name.matches(s)),
+        },
+        ValueTest::Literal(l) => match tag {
+            Tag::Float(b) => l.text.trim().parse::<f32>().ok() == Some(f32::from_bits(*b)),
+            Tag::Double(b) => l.float == Some(f64::from_bits(*b)),
+            Tag::Compound(_) | Tag::List(_)
+                if lit.snbt.as_ref().is_some_and(|e| contains(e, tag)) =>
+            {
+                true
+            }
+            _ => match int_value(tag) {
+                Some(v) => l.int == Some(v),
+                None => text_matches(tag, is_text, |s| {
+                    s == l.text || lit.json.as_deref() == Some(s)
+                }),
+            },
+        },
+    }
+}
+
+/// `NbtUtils.compareNbt(expected, actual, true)`: every key and element of `expected` found in
+/// `actual`.
+fn contains(expected: &Tag, actual: &Tag) -> bool {
+    match (expected, actual) {
+        (Tag::Compound(e), Tag::Compound(a)) => e
+            .iter()
+            .all(|(k, v)| a.get(k).is_some_and(|a| contains(v, a))),
+        (Tag::List(e), Tag::List(a)) if e.is_empty() => a.is_empty(),
+        (Tag::List(e), Tag::List(a)) => e.iter().all(|e| a.iter().any(|a| contains(e, a))),
+        _ => expected == actual,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cit::{Hand, Kind};
+    use std::sync::Arc;
+
+    /// Rules from (file stem, properties), sorted as `load_rules` sorts them, under the global
+    /// `cit.properties` text `global`.
+    fn rules_under(files: &[(&str, &str)], global: &str) -> CitRules {
+        let files: Vec<(String, String)> = files
+            .iter()
+            .map(|(stem, text)| {
+                let path = format!("assets/minecraft/optifine/cit/{stem}.properties");
+                (path, format!("texture=x\n{text}"))
+            })
+            .collect();
+        let files: Vec<(&str, &str)> = files.iter().map(|(p, t)| (&**p, &**t)).collect();
+        let cit = parse_rules(&files, global);
+        assert_eq!(cit.rules.len(), files.len(), "every rule parses");
+        cit
+    }
+
+    fn rules(files: &[(&str, &str)]) -> CitRules {
+        rules_under(files, "")
+    }
+
+    fn stem(cit: &CitRules, i: Option<usize>) -> Option<&str> {
+        let path = &cit.rules[i?].path;
+        path.rsplit('/').next()?.strip_suffix(".properties")
+    }
+
+    fn item(cit: &CitRules, stack: ItemStack) -> Option<&str> {
+        stem(cit, cit.select(Kind::Item, &stack, Hand::Main, 0))
+    }
+
+    fn new(id: &str) -> ItemStack {
+        ItemStack::new(&format!("minecraft:{id}"), 1)
+    }
+
+    fn string(s: &str) -> Tag {
+        Tag::String(s.into())
+    }
+
+    fn with(id: &str, component: &str, tag: Tag) -> ItemStack {
+        let mut stack = new(id);
+        let component = format!("minecraft:{component}");
+        stack.data_mut().other.push((component, tag));
+        stack
+    }
+
+    fn enchanted(id: &str, levels: &[(&str, u32)]) -> ItemStack {
+        let mut stack = new(id);
+        let levels = levels
+            .iter()
+            .map(|(e, l)| (Arc::from(format!("minecraft:{e}")), *l));
+        stack.data_mut().enchantments = levels.collect();
+        stack
+    }
+
+    #[test]
+    fn heavier_rules_win_and_kinds_stay_apart() {
+        let cit = rules(&[
+            ("plain", "items=stick"),
+            ("heavy", "items=stick\nweight=2\nstackSize=2-"),
+            ("offhand", "items=stick\nweight=5\nhand=off"),
+            ("armor", "type=armor\nitems=stick"),
+            ("wings", "type=elytra"),
+        ]);
+        assert_eq!(item(&cit, new("stick")), Some("plain"));
+        assert_eq!(
+            item(&cit, ItemStack::new("minecraft:stick", 3)),
+            Some("heavy")
+        );
+        let pick = |kind, id, hand, max| stem(&cit, cit.select(kind, &new(id), hand, max));
+        assert_eq!(pick(Kind::Item, "stick", Hand::Off, 0), Some("offhand"));
+        assert_eq!(item(&cit, new("stone")), None);
+        assert_eq!(item(&cit, new("elytra")), None);
+        assert_eq!(pick(Kind::Elytra, "elytra", Hand::Main, 432), Some("wings"));
+        assert_eq!(pick(Kind::Armor, "stick", Hand::Main, 0), Some("armor"));
+    }
+
+    #[test]
+    fn names_match_by_their_plain_text() {
+        let cit = rules(&[
+            ("glob", "items=stick\nnbt.display.Name=ipattern:*sword"),
+            ("exact", "items=stone\ncomponents.custom_name=My Sword"),
+            ("json", "items=dirt\nnbt.display.Name=[\"My \",\"Sword\"]"),
+        ]);
+        let named = |id: &str, name: Tag| {
+            let mut stack = new(id);
+            stack.data_mut().custom_name = Some(name);
+            stack
+        };
+        let styled = Tag::compound([("text", string("My Sword")), ("color", string("red"))]);
+        assert_eq!(item(&cit, named("stick", styled.clone())), Some("glob"));
+        assert_eq!(item(&cit, named("stick", string("Blade"))), None);
+        assert_eq!(item(&cit, new("stick")), None);
+        assert_eq!(item(&cit, named("stone", styled.clone())), Some("exact"));
+        assert_eq!(item(&cit, named("dirt", styled)), Some("json"));
+    }
+
+    #[test]
+    fn lore_lines_and_list_counts() {
+        let cit = rules(&[
+            (
+                "any_line",
+                "items=stick\nnbt.display.Lore.*=ipattern:*legendary*",
+            ),
+            ("two_lines", "items=stone\ncomponents.lore.count=2"),
+        ]);
+        let bold = Tag::compound([("text", string("A LEGENDARY item")), ("bold", Tag::Byte(1))]);
+        let lore = Tag::List(vec![string("Common"), bold]);
+        assert_eq!(
+            item(&cit, with("stick", "lore", lore.clone())),
+            Some("any_line")
+        );
+        assert_eq!(item(&cit, with("stone", "lore", lore)), Some("two_lines"));
+        let one = Tag::List(vec![string("A legendary item")]);
+        assert_eq!(item(&cit, with("stone", "lore", one)), None);
+    }
+
+    #[test]
+    fn custom_data_existence_and_negation() {
+        let cit = rules(&[
+            (
+                "aote",
+                "items=stick\nweight=2\nnbt.ExtraAttributes.id=ASPECT_OF_THE_END",
+            ),
+            (
+                "not_hyp",
+                "items=stick\nweight=1\ncomponent.custom_data.ExtraAttributes.id=!HYP",
+            ),
+            ("unnamed", "items=stick\nnbt.display.Name=exists:false"),
+        ]);
+        let data = |id: &str| {
+            let attributes =
+                Tag::compound([("ExtraAttributes", Tag::compound([("id", string(id))]))]);
+            with("stick", "custom_data", attributes)
+        };
+        assert_eq!(item(&cit, data("ASPECT_OF_THE_END")), Some("aote"));
+        assert_eq!(item(&cit, data("MIDAS")), Some("not_hyp"));
+        assert_eq!(item(&cit, data("HYP")), Some("unnamed"));
+        let mut named = data("HYP");
+        named.data_mut().custom_name = Some(string("Hyperion"));
+        assert_eq!(item(&cit, named), None);
+    }
+
+    #[test]
+    fn legacy_enchantment_lists_and_model_data() {
+        let cit = rules(&[
+            (
+                "sharp",
+                "items=stick\nnbt.Enchantments.*.id=minecraft:sharpness\nnbt.Enchantments.0.lvl=5",
+            ),
+            ("cmd", "items=stone\nnbt.CustomModelData=3"),
+            (
+                "cmd_snbt",
+                "items=dirt\ncomponents.custom_model_data={floats:[3.0f]}",
+            ),
+        ]);
+        assert_eq!(
+            item(&cit, enchanted("stick", &[("sharpness", 5)])),
+            Some("sharp")
+        );
+        assert_eq!(item(&cit, enchanted("stick", &[("sharpness", 4)])), None);
+        let model = |id: &str, f: f32| {
+            let floats = Tag::List(vec![Tag::Float(f.to_bits()), Tag::Float(7f32.to_bits())]);
+            with(id, "custom_model_data", Tag::compound([("floats", floats)]))
+        };
+        assert_eq!(item(&cit, model("stone", 3.0)), Some("cmd"));
+        assert_eq!(item(&cit, model("stone", 3.5)), None);
+        assert_eq!(item(&cit, model("dirt", 3.0)), Some("cmd_snbt"));
+        assert_eq!(item(&cit, model("dirt", 2.0)), None);
+    }
+
+    #[test]
+    fn fields_left_out_at_zero_read_as_zero() {
+        let cit = rules(&[("zero", "items=firework_rocket\nnbt.Fireworks.Flight=0")]);
+        let mut rocket = new("firework_rocket");
+        rocket.data_mut().fireworks = Some((0, Vec::new()));
+        assert_eq!(item(&cit, rocket.clone()), Some("zero"));
+        rocket.data_mut().fireworks = Some((2, Vec::new()));
+        assert_eq!(item(&cit, rocket), None);
+    }
+
+    #[test]
+    fn damage_counts_only_for_damageable_items() {
+        let cit = rules(&[
+            ("worn", "items=diamond_sword\ndamage=50-100%"),
+            ("new", "items=stick\ndamage=0"),
+        ]);
+        let damaged = |id: &str, damage: u32, max: u32| {
+            let mut stack = new(id);
+            stack.damage = damage;
+            stem(&cit, cit.select(Kind::Item, &stack, Hand::Main, max))
+        };
+        // Half of 1561 is 780.5.
+        assert_eq!(damaged("diamond_sword", 780, 1561), None);
+        assert_eq!(damaged("diamond_sword", 781, 1561), Some("worn"));
+        assert_eq!(damaged("stick", 5, 0), Some("new"));
+    }
+
+    #[test]
+    fn enchantment_levels_and_rules_for_any_item() {
+        let cit = rules(&[
+            (
+                "sharp3",
+                "items=stick\nenchantments=sharpness\nenchantmentLevels=3-",
+            ),
+            ("any3", "items=stone\nenchantmentLevels=3-"),
+            ("glint", "type=enchantment\nenchantments=sharpness"),
+            (
+                "sword_glint",
+                "type=enchantment\nitems=diamond_sword\nweight=2",
+            ),
+        ]);
+        let mixed = [("sharpness", 2), ("unbreaking", 3)];
+        assert_eq!(item(&cit, enchanted("stick", &mixed)), None);
+        assert_eq!(
+            item(&cit, enchanted("stick", &[("sharpness", 4)])),
+            Some("sharp3")
+        );
+        assert_eq!(item(&cit, enchanted("stone", &mixed)), Some("any3"));
+        let glints = |stack: ItemStack| -> Vec<&str> {
+            let found = cit.enchantments(&stack, Hand::Main, 0).into_iter();
+            found.map(|i| stem(&cit, Some(i)).unwrap()).collect()
+        };
+        let sharp = [("sharpness", 1)];
+        assert_eq!(
+            glints(enchanted("diamond_sword", &sharp)),
+            ["sword_glint", "glint"]
+        );
+        assert_eq!(glints(enchanted("stick", &sharp)), ["glint"]);
+        assert!(glints(new("stick")).is_empty());
+        // Glints are never an item's texture.
+        assert_eq!(item(&cit, enchanted("diamond_sword", &sharp)), None);
+    }
+
+    /// `CitRules::glint` in the main hand, with the stack's own `has_foil` as callers pass it.
+    fn glint(cit: &CitRules, stack: &ItemStack, item_glint: bool) -> Option<Arc<StackGlint>> {
+        cit.glint(stack, Hand::Main, 0, stack.has_foil(item_glint))
+    }
+
+    /// `stack` with its `enchantment_glint_override` set to `on`.
+    fn overridden(mut stack: ItemStack, on: bool) -> ItemStack {
+        let flag = (
+            "minecraft:enchantment_glint_override".to_owned(),
+            Tag::Byte(on.into()),
+        );
+        stack.data_mut().other.push(flag);
+        stack
+    }
+
+    #[test]
+    fn a_stack_glint_reads_the_book_and_the_pack_file() {
+        let files = [
+            ("sharp", "type=enchantment\nenchantments=sharpness"),
+            (
+                "keep",
+                "type=enchantment\nlayer=1\nuseGlint=true\nenchantments=mending",
+            ),
+        ];
+        let cit = rules(&files);
+        // An enchanted book's glint follows its stored enchantments.
+        let mut book = new("enchanted_book");
+        book.data_mut().stored_enchantments = vec![
+            (Arc::from("minecraft:sharpness"), 3),
+            (Arc::from("minecraft:mending"), 1),
+        ];
+        let book = glint(&cit, &book, true).unwrap();
+        let weights: Vec<_> = book.layers.iter().map(|l| l.weight).collect();
+        assert_eq!(weights, [0.75, 0.25]);
+        assert!(book.vanilla);
+        let plain = glint(&cit, &enchanted("stick", &[("sharpness", 1)]), false).unwrap();
+        assert_eq!(plain.layers.len(), 1);
+        assert!(!plain.vanilla);
+        // No enchantment rules: nothing changes, unless the pack turns vanilla's glint off.
+        let bare = rules(&[("stick", "items=stick")]);
+        assert!(glint(&bare, &overridden(new("stick"), true), false).is_none());
+        let bare = rules_under(&[("stick", "items=stick")], "useGlint=false");
+        assert!(!bare.use_glint);
+        assert!(
+            !glint(&bare, &overridden(new("stick"), true), false)
+                .unwrap()
+                .vanilla
+        );
+        let cit = rules_under(&files, "useGlint=false");
+        assert!(
+            glint(&cit, &overridden(new("stick"), true), false)
+                .unwrap()
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn only_a_stack_with_a_glint_gets_layers() {
+        let cit = rules(&[("any", "type=enchantment")]);
+        assert!(glint(&cit, &new("stick"), false).is_none());
+        // The override turns an enchanted stack's glint off, and an unenchanted one's on.
+        let off = overridden(enchanted("stick", &[("sharpness", 1)]), false);
+        assert!(glint(&cit, &off, false).is_none());
+        let on = glint(&cit, &overridden(new("stick"), true), false).unwrap();
+        let weights: Vec<_> = on.layers.iter().map(|l| l.weight).collect();
+        assert_eq!(
+            weights,
+            [1.0],
+            "nothing to share: the rule at full strength"
+        );
+        // The same stack, asked again without its glint, is not answered from the cache.
+        assert!(
+            cit.glint(&overridden(new("stick"), true), Hand::Main, 0, false)
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn a_rule_left_out_of_the_glints_matches_nothing() {
+        let mut cit = rules(&[
+            ("broken", "type=enchantment\nitems=diamond_sword\nweight=1"),
+            ("shown", "type=enchantment"),
+        ]);
+        let sword = enchanted("diamond_sword", &[("sharpness", 1)]);
+        let layers = |cit: &CitRules| -> Vec<String> {
+            let glint = glint(cit, &sword, false).unwrap();
+            let stems = glint
+                .layers
+                .iter()
+                .map(|l| stem(cit, Some(l.rule)).unwrap());
+            stems.map(str::to_owned).collect()
+        };
+        // The heavier rule wins the layer, until its texture is missing.
+        assert_eq!(layers(&cit), ["broken"]);
+        let broken = (0..cit.rules.len())
+            .find(|&i| stem(&cit, Some(i)) == Some("broken"))
+            .unwrap();
+        cit.keep_glints(|i| i != broken);
+        assert_eq!(layers(&cit), ["shown"]);
+        assert_eq!(cit.enchantments(&sword, Hand::Main, 0).len(), 1);
+        // None left: vanilla's glint stays.
+        cit.keep_glints(|_| false);
+        assert!(glint(&cit, &sword, false).is_none());
+    }
+
+    #[test]
+    fn an_off_hand_layer_draws_only_in_the_off_hand() {
+        let cit = rules(&[
+            ("left", "type=enchantment\nlayer=1\nhand=off"),
+            ("both", "type=enchantment"),
+        ]);
+        let sword = enchanted("diamond_sword", &[("sharpness", 1)]);
+        let layers = |hand| -> Vec<&str> {
+            let glint = cit.glint(&sword, hand, 0, true).unwrap();
+            glint
+                .layers
+                .iter()
+                .map(|l| stem(&cit, Some(l.rule)).unwrap())
+                .collect()
+        };
+        assert_eq!(layers(Hand::Off), ["both", "left"]);
+        // Asked in this order, a cache keyed without the hand would answer as for the off hand.
+        assert_eq!(layers(Hand::Main), ["both"]);
+    }
+}
@@ -0,0 +1,301 @@
+//! OptiFine's Custom Item Textures' enchantment glints (`type=enchantment`): which of a stack's
+//! matching rules draw, in which order and how strongly, and whether vanilla's glint still draws
+//! under them ([`crate::cit_glint::StackGlint`]). The pack's `cit.properties` (`Global`) says how
+//! layers share an item.
+//!
+//! Written from OptiFine's `cit.properties` doc and CIT Resewn's (MIT) `TypeEnchantment` of
+//! before its 1.21.11 port, which implemented `method`, `cap` and `fade`: the sums and the
+//! cycle's fading follow it, except where noted.
+
+use super::cit::read_properties;
+use crate::cit_glint::{GlintLayer, StackGlint};
+use horizon_optifine::cit::{Global, Method, Rule};
+use std::path::Path;
+
+/// The pack's global `cit.properties` under the overlay resource root: the first of
+/// `Global::PATHS` that exists, else the defaults.
+pub fn load_global(root: &Path) -> Global {
+    Global::PATHS
+        .iter()
+        .find_map(|path| read_properties(&root.join(path)))
+        .map(|props| Global::parse(&props))
+        .unwrap_or_default()
+}
+
+/// A stack's glint: the layers among `matched` (its matching enchantment rules, in priority
+/// order, as `CitRules::enchantments` gives them) that draw, for a stack with `enchantments`
+/// (`ItemStack::crafting_enchantments`).
+pub fn stack_glint(
+    rules: &[Rule],
+    matched: &[usize],
+    enchantments: &[(impl AsRef<str>, u32)],
+    global: &Global,
+) -> StackGlint {
+    // The highest priority rule of each layer.
+    let mut layers: Vec<usize> = Vec::new();
+    for &i in matched {
+        let layer = rules[i].glint.layer;
+        if !layers.iter().any(|&j| rules[j].glint.layer == layer) {
+            layers.push(i);
+        }
+    }
+    layers.sort_by_key(|&i| rules[i].glint.layer);
+    let cycle = global.method == Method::Cycle;
+    // OptiFine's doc: `cap` is for `average` and `layered`, and keeps the topmost layers.
+    // `none`, which OptiFine lacks, is capped too, as CIT Resewn caps every method (it keeps
+    // the bottom layers, though, and caps cycles as well).
+    if let Some(cap) = global.cap.filter(|_| !cycle) {
+        let cap = usize::try_from(cap).unwrap_or(usize::MAX);
+        layers = layers.split_off(layers.len().saturating_sub(cap));
+    }
+    // CIT Resewn: any layer left asking for vanilla's glint keeps it, and the global
+    // `useGlint=false` removes it everywhere, as OptiFine's doc says too. `cap=0` leaves no
+    // custom layer, and vanilla's glint only if the pack's `useGlint` allows it.
+    let vanilla =
+        global.use_glint && (layers.is_empty() || layers.iter().any(|&i| rules[i].glint.use_glint));
+    // CIT Resewn: shares are against every enchantment of the stack, not only those the
+    // layers name.
+    let levels = enchantments.iter().map(|(_, level)| *level as f32);
+    let total = match global.method {
+        Method::Average => levels.sum::<f32>(),
+        Method::Layered => levels.fold(0.0, f32::max),
+        Method::None | Method::Cycle => 0.0,
+    };
+    let shared = matches!(global.method, Method::Average | Method::Layered);
+    let layers = layers
+        .into_iter()
+        .map(|i| {
+            let rule = &rules[i];
+            let named = &rule.enchantments;
+            let weight = if !shared || named.is_empty() {
+                1.0
+            } else {
+                // The highest level among the enchantments the rule names whose level also
+                // passes its `enchantmentLevels` (CIT Resewn takes the first named one the
+                // stack has, whatever its level).
+                let in_range = |level: u32| {
+                    let level = i32::try_from(level).unwrap_or(i32::MAX);
+                    rule.enchantment_levels
+                        .as_ref()
+                        .is_none_or(|r| r.contains(level))
+                };
+                let level = enchantments
+                    .iter()
+                    .filter(|(id, level)| {
+                        let id: &str = id.as_ref();
+                        named.iter().any(|n| n == id) && in_range(*level)
+                    })
+                    .map(|(_, level)| *level as f32)
+                    .fold(0.0, f32::max);
+                if total > 0.0 { level / total } else { 0.0 }
+            };
+            GlintLayer::new(i, weight, rule.glint.duration)
+        })
+        .collect();
+    StackGlint::from_parts(layers, vanilla, cycle.then_some(global.fade))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_optifine::Properties;
+
+    const DIR: &str = "assets/minecraft/optifine/cit";
+
+    /// An enchantment rule named `name` with `text` after `type` and `texture`.
+    fn rule(name: &str, text: &str) -> Rule {
+        let text = format!("type=enchantment\ntexture=glint\n{text}");
+        let path = format!("{DIR}/{name}.properties");
+        Rule::parse(&path, &Properties::parse_equals_first(&text), |_| true).unwrap()
+    }
+
+    fn global(text: &str) -> Global {
+        Global::parse(&Properties::parse_equals_first(text))
+    }
+
+    fn rules_of(layers: &StackGlint) -> Vec<usize> {
+        layers.layers.iter().map(|l| l.rule).collect()
+    }
+
+    const SWORD: [(&str, u32); 2] = [("minecraft:sharpness", 3), ("minecraft:unbreaking", 1)];
+
+    #[test]
+    fn one_rule_per_layer_bottom_first() {
+        let rules = [
+            rule("a", "layer=2"),
+            rule("b", "layer=0"),
+            rule("c", "layer=2"),
+            rule("d", "layer=-1"),
+        ];
+        // Priority order a, b, c, d: c loses layer 2 to a.
+        let g = stack_glint(&rules, &[0, 1, 2, 3], &SWORD, &Global::default());
+        assert_eq!(rules_of(&g), [3, 1, 0]);
+        let g = stack_glint(&rules, &[2, 0], &SWORD, &Global::default());
+        assert_eq!(rules_of(&g), [2]);
+    }
+
+    #[test]
+    fn average_and_layered_shares() {
+        let rules = [
+            rule("sharp", "enchantments=sharpness smite"),
+            rule("unb", "layer=1\nenchantments=unbreaking"),
+            rule("any", "layer=2"),
+            rule("fire", "layer=3\nenchantments=fire_aspect"),
+        ];
+        let weights = |method: &str| {
+            let g = stack_glint(&rules, &[0, 1, 2, 3], &SWORD, &global(method));
+            g.layers.iter().map(|l| l.weight).collect::<Vec<_>>()
+        };
+        // Sharpness III and Unbreaking I: 3 / 4 and 1 / 4; against the highest, 3 / 3 and 1 / 3.
+        // A rule naming no enchantment is at full strength, one the stack lacks at none.
+        assert_eq!(weights("method=average"), [0.75, 0.25, 1.0, 0.0]);
+        assert_eq!(weights("method=layered"), [1.0, 1.0 / 3.0, 1.0, 0.0]);
+        assert_eq!(weights("method=cycle"), [1.0; 4]);
+        assert_eq!(weights("method=none"), [1.0; 4]);
+    }
+
+    #[test]
+    fn the_level_is_one_the_rules_levels_allow() {
+        let rules = [rule(
+            "holy",
+            "enchantments=sharpness smite\nenchantmentLevels=1-2",
+        )];
+        // Sharpness V is out of range, so Smite I sets the share: 1 / 5 of the highest level.
+        let stack = [("minecraft:sharpness", 5), ("minecraft:smite", 1)];
+        let g = stack_glint(&rules, &[0], &stack, &global("method=layered"));
+        assert_eq!(g.layers[0].weight, 1.0 / 5.0);
+    }
+
+    #[test]
+    fn cap_keeps_the_topmost_layers() {
+        let rules = [
+            rule("a", "layer=0"),
+            rule("b", "layer=1"),
+            rule("c", "layer=2"),
+        ];
+        let g = stack_glint(&rules, &[0, 1, 2], &SWORD, &global("cap=2"));
+        assert_eq!(rules_of(&g), [1, 2]);
+        let g = stack_glint(&rules, &[0, 1, 2], &SWORD, &global("cap=0"));
+        assert!(g.is_empty());
+        let g = stack_glint(&rules, &[0, 1, 2], &SWORD, &global("cap=1\nmethod=none"));
+        assert_eq!(rules_of(&g), [2]);
+        // Cycles show every layer in turn.
+        let g = stack_glint(&rules, &[0, 1, 2], &SWORD, &global("cap=1\nmethod=cycle"));
+        assert_eq!(rules_of(&g), [0, 1, 2]);
+    }
+
+    #[test]
+    fn vanilla_glint() {
+        let plain = rule("plain", "");
+        let keep = rule("keep", "layer=1\nuseGlint=true");
+        let rules = [plain, keep];
+        let vanilla = |matched: &[usize], text: &str| {
+            stack_glint(&rules, matched, &SWORD, &global(text)).vanilla
+        };
+        assert!(vanilla(&[], ""), "no rule: vanilla's glint");
+        assert!(!vanilla(&[0], ""), "a rule replaces it");
+        assert!(vanilla(&[0, 1], ""), "unless one keeps it");
+        assert!(!vanilla(&[], "useGlint=false"));
+        assert!(!vanilla(&[1], "useGlint=false"), "the pack's word is final");
+        // Only the layers `cap` keeps count.
+        let rules = [rule("keep", "useGlint=true"), rule("top", "layer=1")];
+        let g = stack_glint(&rules, &[0, 1], &SWORD, &global("cap=1"));
+        assert!(!g.vanilla);
+        let g = stack_glint(&rules, &[0, 1], &SWORD, &global("cap=0"));
+        assert!(g.is_empty() && g.vanilla);
+        let g = stack_glint(&rules, &[0, 1], &SWORD, &global("cap=0\nuseGlint=false"));
+        assert!(!g.vanilla);
+    }
+
+    #[test]
+    fn cycles_take_turns_and_fade() {
+        let rules = [
+            rule("a", "duration=2"),
+            rule("b", "layer=1\nduration=1"),
+            rule("c", "layer=2\nduration=1"),
+        ];
+        let g = stack_glint(
+            &rules,
+            &[0, 1, 2],
+            &SWORD,
+            &global("method=cycle\nfade=0.5"),
+        );
+        // a 0-2, a→b 2-2.5, b 2.5-3.5, b→c 3.5-4, c 4-5, c→a 5-5.5, then again.
+        let at = |t: f64| [0, 1, 2].map(|i| g.intensity(i, t));
+        assert_eq!(at(1.0), [1.0, 0.0, 0.0]);
+        assert_eq!(at(2.125), [0.75, 0.25, 0.0]);
+        assert_eq!(at(3.0), [0.0, 1.0, 0.0]);
+        assert_eq!(at(3.75), [0.0, 0.5, 0.5]);
+        assert_eq!(at(4.5), [0.0, 0.0, 1.0]);
+        assert_eq!(at(5.25), [0.5, 0.0, 0.5]);
+        assert_eq!(at(5.5 + 3.0), [0.0, 1.0, 0.0]);
+        // One layer always shows.
+        let one = stack_glint(&rules, &[1], &SWORD, &global("method=cycle"));
+        assert_eq!(one.intensity(0, 0.7), 1.0);
+    }
+
+    #[test]
+    fn a_cycle_always_shows_a_whole_layer() {
+        let rules = [
+            rule("a", "duration=0.1"),
+            rule("b", "layer=1\nduration=0.7"),
+            rule("c", "layer=2\nduration=0.2"),
+        ];
+        let g = stack_glint(
+            &rules,
+            &[0, 1, 2],
+            &SWORD,
+            &global("method=cycle\nfade=0.3"),
+        );
+        // Every millisecond of the first two seconds, and just under a period, the last fade's
+        // end. (Rounding has not been seen to leave time past it; the last fade's clamp is
+        // defensive.)
+        let period: f64 = [0.1f32, 0.7, 0.2]
+            .map(|d| f64::from(d) + f64::from(0.3f32))
+            .iter()
+            .sum();
+        let last = f64::from_bits(period.to_bits() - 1);
+        for t in (0..2000_i32)
+            .map(|i| f64::from(i) * 0.001)
+            .chain([last, period + last])
+        {
+            let sum: f32 = (0..3).map(|i| g.intensity(i, t)).sum();
+            assert!((sum - 1.0).abs() < 1e-5, "{sum} at {t}");
+        }
+        // No time at all: the bottom layer alone, never NaN.
+        let still = [rule("a", "duration=0"), rule("b", "layer=1\nduration=0")];
+        let g = stack_glint(&still, &[0, 1], &SWORD, &global("method=cycle\nfade=0"));
+        for t in [0.0, 0.5, 7.25] {
+            assert_eq!([0, 1].map(|i| g.intensity(i, t)), [1.0, 0.0]);
+        }
+    }
+
+    #[test]
+    fn the_first_global_file_wins() {
+        let root = std::env::temp_dir().join(format!("horizon-cit-glint-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        assert_eq!(load_global(&root), Global::default());
+        let write = |path: &str, text: &[u8]| {
+            let file = root.join(path);
+            std::fs::create_dir_all(file.parent().unwrap()).unwrap();
+            std::fs::write(file, text).unwrap();
+        };
+        // Saved as Latin-1 (`é` is not UTF-8 alone), in the OptiFine doc's `cit/` folder.
+        write(
+            "assets/minecraft/optifine/cit/cit.properties",
+            b"# caf\xE9\nmethod=cycle",
+        );
+        assert_eq!(load_global(&root).method, Method::Cycle);
+        write("assets/minecraft/mcpatcher/cit.properties", b"method=none");
+        assert_eq!(load_global(&root).method, Method::Cycle);
+        write(
+            "assets/minecraft/optifine/cit.properties",
+            b"method=layered",
+        );
+        assert_eq!(load_global(&root).method, Method::Layered);
+        write("assets/minecraft/citresewn/cit.properties", b"cap=1");
+        let g = load_global(&root);
+        let _ = std::fs::remove_dir_all(&root);
+        assert_eq!((g.method, g.cap), (Method::Average, Some(1)));
+    }
+}
@@ -0,0 +1,79 @@
+//! Polytone's custom colours (`horizon_polytone::colors`, `colors.json` or `color.properties`)
+//! as the engine's pack colours ([`crate::pack_palette::PackColors`]).
+use std::path::Path;
+
+use horizon_polytone::colors::PackColors;
+
+use crate::block_entity_render::DYES;
+use crate::pack_palette::{self, Environment};
+
+fn fluid(fog: horizon_polytone::colors::FluidFog) -> pack_palette::FluidFog {
+    pack_palette::FluidFog {
+        color: fog.color,
+        radius: fog.radius,
+        fade: fog.fade,
+    }
+}
+
+/// The colours of every namespace's file under the pack overlay at `root`.
+pub fn read(root: &Path) -> pack_palette::PackColors {
+    let colors = PackColors::read(root);
+    let by_dye = |f: &dyn Fn(&str) -> Option<u32>| std::array::from_fn(|i| f(DYES[i].0));
+    let env = colors.env;
+    pack_palette::PackColors {
+        dye_diffuse: by_dye(&|name| colors.dye(name, "diffuse")),
+        dye_text: by_dye(&|name| colors.dye(name, "text")),
+        sheep: by_dye(&|name| colors.sheep(name)),
+        redstone: std::array::from_fn(|i| colors.redstone(i as u8)),
+        effects: colors.effects(),
+        entity_shadows: colors.entity_shadows(),
+        xp_bar: colors.xp_bar(),
+        env: Environment {
+            powder_snow_fog: env.powder_snow_fog,
+            blindness_fog_distance: env.blindness_fog_distance,
+            darkness_fog_distance: env.darkness_fog_distance,
+            boss_fog_distance: env.boss_fog_distance,
+            water_fog_brightening: env.water_fog_brightening,
+            water_fog_brightening_time: env.water_fog_brightening_time,
+            horizon_height: env.horizon_height,
+        },
+        fluid_fog: pack_palette::FluidFogs {
+            water: colors.fluid_fog.water.map(fluid),
+            lava: colors.fluid_fog.lava.map(fluid),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::pack_palette::{diffuse, redstone, sheep_wool, text};
+
+    #[test]
+    fn a_pack_recolours_only_what_it_names() {
+        // Dyes no other test draws: the table is process-wide.
+        let dir = std::env::temp_dir().join(format!("pack-dyes-{}", std::process::id()));
+        let polytone = dir.join("assets/obs/polytone");
+        std::fs::create_dir_all(&polytone).unwrap();
+        std::fs::write(
+            polytone.join("colors.json"),
+            r#"{"dye": {"cyan": {"diffuse": "00ff00", "text": "0000ff"}}, "sheep": {"pink": "2040ff"}, "redstone": {"7": "0x123456"}}"#,
+        )
+        .unwrap();
+        crate::pack_palette::set(&read(&dir));
+        let (cyan, pink, purple) = (9, 6, 10);
+        assert_eq!(diffuse(cyan), 0x00ff00);
+        assert_eq!(text(cyan), 0x0000ff);
+        assert_eq!(sheep_wool(pink as u8), 0x2040ff);
+        // Wool reads vanilla's dye, not the pack's diffuse: 75% of 0x169C9C.
+        assert_eq!(sheep_wool(cyan as u8), 0x107575);
+        assert_eq!(diffuse(purple), 0x8932B8);
+        assert_eq!(text(purple), 0xA020F0);
+        assert_eq!((redstone(7), redstone(15)), (Some(0x123456), None));
+        crate::pack_palette::set(&Default::default());
+        assert_eq!(redstone(7), None);
+        assert_eq!(diffuse(cyan), 0x169C9C);
+        assert_eq!(sheep_wool(pink as u8), 0xB6687F);
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}
@@ -0,0 +1,136 @@
+//! OptiFine's and Fusion's connected textures as the mesher draws them
+//! ([`crate::connected::ConnectedTextures`]): a Fusion face first, then OptiFine's rules.
+
+use std::path::Path;
+use std::sync::Arc;
+
+use horizon_optifine::ctm::connect::{Axes, Face};
+use horizon_world::registry::{BlockRegistry, BlockStateId};
+
+use super::ctm::ConnectedTextures as Ctm;
+use super::fusion::FusionTextures;
+use crate::chunk::Chunk;
+use crate::connected::{self as engine, Connected, ConnectedTextures, Overlay, Pick};
+use crate::mesher::{MeshScratch, Mesher, SectionMesh};
+use crate::models::StateModels;
+use crate::sprites::Sprites;
+
+/// A pack's Fusion and OptiFine connected textures.
+pub struct Rules {
+    ctm: Ctm,
+    fusion: FusionTextures,
+}
+
+/// The connected textures under `root`: Fusion's models' tiles, native mods' sprites, then
+/// OptiFine's rules' tiles go into `sprites`, in that order. `None` without either format's files.
+pub fn load(
+    root: &Path,
+    registry: &BlockRegistry,
+    sprites: &mut Sprites,
+    models: &mut StateModels,
+    native_mods: &mut dyn FnMut(&mut Sprites),
+) -> Option<Connected> {
+    let fusion = {
+        let _step = crate::spans::startup::step("core.fusion");
+        FusionTextures::load(root, registry, sprites, models)
+    };
+    native_mods(sprites);
+    // A side's sprite, for rules that connect by tile: the first quad facing it.
+    let catalog = &*models;
+    let mut found = Vec::new();
+    let ctm = Ctm::load(
+        root,
+        registry,
+        sprites,
+        |state: BlockStateId, face: Face| {
+            let side = horizon_assets::model::Direction::ALL[face as usize];
+            catalog
+                .models_at(
+                    state,
+                    horizon_core::position::BlockPos::new(0, 0, 0),
+                    &mut found,
+                )
+                .ok()?;
+            found
+                .iter()
+                .flat_map(|m| &m.faces)
+                .find(|f| f.quad.facing == side)
+                .map(|f| f.layer)
+        },
+    );
+    let rules = Rules { ctm, fusion };
+    (!rules.is_empty()).then(|| Connected {
+        rules: Arc::new(rules),
+        mesh,
+    })
+}
+
+/// The mesher on [`Rules`].
+fn mesh(
+    mesher: &mut Mesher<'_>,
+    rules: &(dyn std::any::Any + Send + Sync),
+    region: &[[Option<&Chunk>; 3]; 3],
+    sy: i32,
+    out: SectionMesh,
+    scratch: &mut MeshScratch,
+) -> SectionMesh {
+    let rules = rules
+        .downcast_ref::<Rules>()
+        .expect("the connected textures this format loaded");
+    mesher.mesh_with(rules, region, sy, out, scratch)
+}
+
+impl ConnectedTextures for Rules {
+    fn is_empty(&self) -> bool {
+        self.ctm.is_empty() && self.fusion.is_empty()
+    }
+
+    fn stacked_pane_hides(&self, state: u32, other: u32, centre: [f32; 2]) -> bool {
+        !self.ctm.is_empty() && self.ctm.stacked_pane_hides(state, other, centre)
+    }
+
+    fn pick<'b>(
+        &self,
+        face: &engine::Face,
+        neighbour: impl Fn([i32; 3]) -> u32,
+        covers: impl Fn(u32) -> bool,
+        biome: impl Fn() -> Option<&'b str>,
+        mut overlay: impl FnMut(Overlay),
+    ) -> Pick {
+        let side = Face::ALL[usize::from(face.facing)];
+        let fused = face.rule.and_then(|rule| {
+            self.fusion.pick(
+                rule,
+                face.state,
+                side,
+                face.tint_index,
+                &neighbour,
+                covers,
+                &mut overlay,
+            )
+        });
+        if let Some(pick) = fused {
+            pick
+        } else if self.ctm.is_empty() {
+            Pick::Keep
+        } else {
+            self.ctm.pick(
+                face.state,
+                face.layer,
+                side,
+                face.pos,
+                &neighbour,
+                biome,
+                // A pane's tiles are drawn with the cube's UVs, so that is its texture.
+                || {
+                    if face.pane {
+                        Some(Axes::cube(side))
+                    } else {
+                        Axes::texture(face.positions, face.uv)
+                    }
+                },
+                &mut overlay,
+            )
+        }
+    }
+}
@@ -0,0 +1,252 @@
+//! OptiFine custom skies (`horizon_optifine::sky`) on the engine's sky layers
+//! ([`crate::custom_sky`]): a pack's layers with their decoded textures, read once with the pack,
+//! and each frame's choice of layers, their brightness and rotation. A pack without
+//! `optifine/sky` has none, and the sky stays vanilla.
+
+use std::path::Path;
+
+use glam::{Mat4, Vec3};
+use horizon_optifine::sky::{Blend, Conditions, Now, Skies, SkyLayer, Transition};
+
+use crate::custom_sky::{self as engine, Draw, Image, SkyLayers, State};
+
+/// The pack's layers, by world, with one texture per layer (`images[i]` for the `i`th layer
+/// over all worlds, in `worlds` order).
+#[derive(Default)]
+pub struct CustomSky {
+    worlds: Vec<(i32, Vec<SkyLayer>)>,
+    pub images: Vec<Image>,
+}
+
+/// Textures past this many texels in all are left out (a skybox is a few megapixels at most).
+const TEXEL_BUDGET: u64 = 64 << 20;
+
+impl CustomSky {
+    /// The custom skies of the overlay at `root`. A layer whose texture does not decode is
+    /// dropped with a warning.
+    pub fn load(root: &Path) -> Self {
+        let skies = Skies::scan(root);
+        let mut out = Self::default();
+        let mut texels = 0u64;
+        for (world, sky) in skies.worlds {
+            let mut layers = Vec::new();
+            for layer in sky.layers {
+                match crate::hud::decode(&root.join(&layer.source)) {
+                    Ok((width, height, rgba))
+                        if texels + u64::from(width) * u64::from(height) <= TEXEL_BUDGET =>
+                    {
+                        texels += u64::from(width) * u64::from(height);
+                        out.images.push(Image {
+                            width,
+                            height,
+                            rgba,
+                        });
+                        layers.push(layer);
+                    }
+                    Ok(_) => log::warn!("{}: past the custom sky's texture budget", layer.source),
+                    Err(e) => log::warn!("{}: {e:#}", layer.source),
+                }
+            }
+            if !layers.is_empty() {
+                out.worlds.push((world, layers));
+            }
+        }
+        out
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.worlds.is_empty()
+    }
+}
+
+/// The engine's sky blend for OptiFine's.
+fn blend(blend: Blend) -> engine::Blend {
+    match blend {
+        Blend::Add => engine::Blend::Add,
+        Blend::Subtract => engine::Blend::Subtract,
+        Blend::Multiply => engine::Blend::Multiply,
+        Blend::Dodge => engine::Blend::Dodge,
+        Blend::Burn => engine::Blend::Burn,
+        Blend::Screen => engine::Blend::Screen,
+        Blend::Replace => engine::Blend::Replace,
+        Blend::Overlay => engine::Blend::Overlay,
+        Blend::Alpha => engine::Blend::Alpha,
+    }
+}
+
+impl SkyLayers for CustomSky {
+    fn images(&self) -> &[Image] {
+        &self.images
+    }
+
+    /// Whether `world` has layers (`0` the Overworld, `1` the End).
+    fn has(&self, world: i32) -> bool {
+        self.worlds.iter().any(|(w, _)| *w == world)
+    }
+
+    /// The layers whose conditions hold, eased over their `transition`, at the brightness of
+    /// their fade times.
+    fn draws(
+        &self,
+        world: i32,
+        conditions: &engine::Conditions,
+        sun_turns: f32,
+        seconds: f32,
+        state: &mut State,
+        out: &mut Vec<Draw>,
+    ) {
+        let conditions = &Conditions {
+            day_time: conditions.day_time,
+            weather: match conditions.weather {
+                engine::Weather::Clear => Now::Clear,
+                engine::Weather::Rain => Now::Rain,
+                engine::Weather::Thunder => Now::Thunder,
+            },
+            biome: conditions.biome,
+            y: conditions.y,
+        };
+        out.clear();
+        let mut first = 0;
+        let mut found = None;
+        for (w, layers) in &self.worlds {
+            if *w == world {
+                found = Some(layers);
+                break;
+            }
+            first += layers.len();
+        }
+        let Some(layers) = found else {
+            state.world = None;
+            return;
+        };
+        // A new world (or pack) starts each layer where its conditions put it: no fade in.
+        let snap = state.world != Some(world) || state.eased.len() != layers.len();
+        if snap {
+            state.world = Some(world);
+            state.eased.clear();
+            state.eased.resize(layers.len(), 0.0);
+        }
+        for (i, (layer, eased)) in layers.iter().zip(&mut state.eased).enumerate() {
+            let target = if layer.shows(conditions) { 1.0 } else { 0.0 };
+            let shown = if snap {
+                *eased = target;
+                target
+            } else {
+                let mut t = Transition { value: *eased };
+                *eased = t.step(target, seconds, layer.transition);
+                *eased
+            };
+            let brightness = shown * layer.brightness(conditions.day_time);
+            if brightness <= 0.0 {
+                continue;
+            }
+            let turns = layer.turns(conditions.day_time, sun_turns);
+            let rotation = if turns == 0.0 {
+                Mat4::IDENTITY
+            } else {
+                Mat4::from_axis_angle(Vec3::from_array(layer.axis), turns * std::f32::consts::TAU)
+            };
+            out.push(Draw {
+                image: (first + i) as u16,
+                blend: blend(layer.blend),
+                brightness,
+                rotation,
+            });
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::custom_sky::{Conditions, Weather};
+
+    fn pack(files: &[(&str, &str)]) -> (std::path::PathBuf, CustomSky) {
+        let root = std::env::temp_dir().join(format!(
+            "horizon-custom-sky-{}-{}",
+            std::process::id(),
+            files.len()
+        ));
+        let _ = std::fs::remove_dir_all(&root);
+        let dir = root.join("assets/minecraft/optifine/sky/world0");
+        std::fs::create_dir_all(&dir).unwrap();
+        let png = {
+            let mut bytes = Vec::new();
+            let mut encoder = png::Encoder::new(&mut bytes, 6, 4);
+            encoder.set_color(png::ColorType::Rgba);
+            encoder.set_depth(png::BitDepth::Eight);
+            let mut writer = encoder.write_header().unwrap();
+            writer
+                .write_image_data(&[255, 0, 0, 255].repeat(24))
+                .unwrap();
+            writer.finish().unwrap();
+            bytes
+        };
+        for (name, text) in files {
+            std::fs::write(dir.join(format!("{name}.properties")), text).unwrap();
+            std::fs::write(dir.join(format!("{name}.png")), &png).unwrap();
+        }
+        let sky = CustomSky::load(&root);
+        (root, sky)
+    }
+
+    fn noon(biome: &str) -> Conditions<'_> {
+        Conditions {
+            day_time: 6000,
+            weather: Weather::Clear,
+            biome,
+            y: 64,
+        }
+    }
+
+    #[test]
+    fn layers_ease_in_at_a_biome_border_but_not_on_arrival() {
+        let (root, sky) = pack(&[
+            ("sky1", "biomes=desert\ntransition=2"),
+            ("sky2", "blend=alpha\nrotate=false"),
+        ]);
+        let _ = std::fs::remove_dir_all(root);
+        assert!(sky.has(0) && !sky.has(1));
+        assert_eq!(sky.images[0].width, 6);
+        let (mut state, mut out) = (State::default(), Vec::new());
+        sky.draws(
+            0,
+            &noon("minecraft:desert"),
+            0.0,
+            0.05,
+            &mut state,
+            &mut out,
+        );
+        assert_eq!(
+            out.iter().map(|d| d.brightness).collect::<Vec<_>>(),
+            [1.0, 1.0]
+        );
+        // Out of the desert: the first layer fades over its two seconds.
+        sky.draws(0, &noon("minecraft:plains"), 0.0, 0.5, &mut state, &mut out);
+        assert_eq!(out[0].brightness, 0.75);
+        assert_eq!(out[1].blend, engine::Blend::Alpha);
+        sky.draws(0, &noon("minecraft:plains"), 0.0, 2.0, &mut state, &mut out);
+        assert_eq!(out.len(), 1, "a dark layer is not drawn");
+        assert_eq!(out[0].image, 1);
+        // Into the End, which has no layers, and back: no fade.
+        sky.draws(1, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
+        assert!(out.is_empty());
+        sky.draws(0, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
+        assert_eq!(out.len(), 2);
+    }
+
+    #[test]
+    fn a_layer_turns_west_like_the_sun() {
+        let (root, sky) = pack(&[("sky1", "")]);
+        let _ = std::fs::remove_dir_all(root);
+        let (mut state, mut out) = (State::default(), Vec::new());
+        // A quarter turn after noon (sunset): the skybox's zenith has gone down to the west.
+        let c = Conditions {
+            day_time: 12000,
+            ..noon("minecraft:plains")
+        };
+        sky.draws(0, &c, 0.25, 0.0, &mut state, &mut out);
+        let up = out[0].rotation.transform_vector3(Vec3::Y);
+        assert!((up - Vec3::NEG_X).length() < 1e-5, "{up}");
+    }
+}
@@ -0,0 +1,88 @@
+//! OptiFine's random entity textures and ETF's blinking and emissive textures
+//! (`horizon_optifine::{random_textures, blink, emissive}`) as the engine's
+//! [`crate::entity_textures`] tables.
+
+use crate::entity_textures::{
+    self as engine, Blink, Blinks, Emissive, EntityTextures, Entry, RandomTextures,
+};
+use horizon_optifine::random::{self, Rules};
+use std::path::Path;
+
+/// The pack's variants, blinks and emissive overlays under the overlay resource root.
+pub fn load(root: &Path) -> EntityTextures {
+    let random = horizon_optifine::random_textures::RandomTextures::scan(root);
+    let blinks = horizon_optifine::blink::Blinks::scan(root, &random);
+    let mut emissive = horizon_optifine::emissive::Emissive::scan(root, &random);
+    emissive.pair_beside(root, blinks.files());
+    let files = random
+        .files()
+        .map(|(f, n)| (f.to_owned(), n.to_owned()))
+        .collect();
+    let generation = random.generation();
+    let (entries, rules) = random.into_parts();
+    let entries = entries
+        .into_iter()
+        .map(|(texture, entry)| {
+            let variants = entry
+                .variant_names()
+                .map(|(n, name)| (n, name.to_owned()))
+                .collect();
+            let rules = entry.rules;
+            (texture, Entry { rules, variants })
+        })
+        .collect();
+    let (blinks, blink_files) = blinks.into_parts();
+    let blinks = blinks
+        .into_iter()
+        .map(|(texture, b)| {
+            let blink = Blink {
+                shut: b.shut,
+                half: b.half,
+                length: b.length,
+                frequency: b.frequency,
+            };
+            (texture, blink)
+        })
+        .collect();
+    let (suffix, overlays, overlay_files) = emissive.into_parts();
+    EntityTextures {
+        random: RandomTextures::new(entries, files, Box::new(Variants(rules)), generation),
+        blinks: Blinks::new(blinks, blink_files),
+        emissive: Emissive::new(suffix, overlays, overlay_files),
+    }
+}
+
+/// The rule files of a scan.
+struct Variants(Vec<Rules>);
+
+impl engine::VariantRules for Variants {
+    fn matching(&self, rules: usize, facts: &engine::Facts, seed: i32) -> Option<u32> {
+        let blocks: Vec<random::Block> = facts
+            .blocks
+            .iter()
+            .map(|b| random::Block {
+                id: b.id,
+                states: b.states,
+            })
+            .collect();
+        let facts = random::Facts {
+            biome: facts.biome,
+            y: facts.y,
+            blocks: &blocks,
+            name: facts.name,
+            profession: facts.profession,
+            color: facts.color,
+            baby: facts.baby,
+            health: facts.health,
+            moon_phase: facts.moon_phase,
+            day_time: facts.day_time,
+            weather: facts.weather.map(|w| match w {
+                engine::Weather::Clear => random::Weather::Clear,
+                engine::Weather::Rain => random::Weather::Rain,
+                engine::Weather::Thunder => random::Weather::Thunder,
+            }),
+            size: facts.size,
+        };
+        self.0.get(rules)?.matching(&facts, seed)
+    }
+}
@@ -273,6 +273,10 @@ fn sheet(
 }

 impl FusionTextures {
+    pub fn is_empty(&self) -> bool {
+        self.rules.is_empty()
+    }
+
    /// The connecting textures under `root`: the tiles of those `fusion:connecting` models
    /// draw are inserted into `sprites` (before it finishes), and each face in `catalog` that
    /// shows one gets its rule.
@@ -0,0 +1,146 @@
+//! Polytone's item modifiers' durability bar colours, on the engine's
+//! [`crate::pack_palette::ItemBars`].
+use std::path::Path;
+use std::sync::Arc;
+
+/// An item modifier's `bar_color` of the `damage` type: a row of colours picked by the stack's
+/// damage, the first pixel undamaged, the last at full damage (measured on the real mod).
+struct DamageBar {
+    targets: horizon_polytone::Targets,
+    row: Vec<u32>,
+}
+
+/// The packs' damage bars, the last read first.
+struct Bars(Vec<DamageBar>);
+
+impl crate::pack_palette::ItemBars for Bars {
+    fn color(&self, item: &str, damage: f32) -> Option<u32> {
+        let bar = self
+            .0
+            .iter()
+            .rev()
+            .find(|b| b.targets.matches(item, |_| false))?;
+        let last = (bar.row.len() - 1) as f32;
+        Some(bar.row[(damage.clamp(0.0, 1.0) * last).round() as usize])
+    }
+}
+
+/// Reads the packs' item modifiers' durability bar colours under a pack overlay root: an
+/// `<item>_bar.png` alone, or a json whose `bar_color` is `damage` with its `<name>_bar.png` (or
+/// `<name>.png`) beside it. Colormap ids and inline colormaps aren't read. `None` without any.
+pub fn read(root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
+    let mut bars = Vec::new();
+    for namespace in std::fs::read_dir(root.join("assets"))
+        .into_iter()
+        .flatten()
+        .flatten()
+    {
+        let base = namespace.path().join("polytone/item_modifiers");
+        let mut stack = vec![base.clone()];
+        while let Some(dir) = stack.pop() {
+            for entry in std::fs::read_dir(&dir).into_iter().flatten().flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    stack.push(path);
+                } else if let Some(bar) = item_bar(root, &base, &path) {
+                    bars.push(bar);
+                }
+            }
+        }
+    }
+    (!bars.is_empty()).then(|| Arc::new(Bars(bars)) as _)
+}
+
+fn item_bar(root: &Path, base: &Path, path: &Path) -> Option<DamageBar> {
+    let name = path.file_name()?.to_str()?;
+    let row = |png: &Path| {
+        let (width, _, rgba) = crate::sprites::read_rgba(png).ok()?;
+        let row: Vec<u32> = rgba[..width as usize * 4]
+            .as_chunks::<4>()
+            .0
+            .iter()
+            .map(|p| u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
+            .collect();
+        (!row.is_empty()).then_some(row)
+    };
+    if let Some(stem) = name.strip_suffix("_bar.png") {
+        // A json of the same name owns its png.
+        if path.with_file_name(format!("{stem}.json")).exists() {
+            return None;
+        }
+        let relative = path.parent()?.strip_prefix(base).ok()?.join(stem);
+        let namespace = base.parent()?.parent()?.file_name()?.to_str()?;
+        let id = format!("{namespace}:{}", relative.to_str()?.replace('\\', "/"));
+        let targets = horizon_polytone::Targets::parse(None, Some(&id)).ok()?;
+        return Some(DamageBar {
+            targets,
+            row: row(path)?,
+        });
+    }
+    let stem = name.strip_suffix(".json")?;
+    let json: serde_json::Value = horizon_world::json_file::read(path).ok()?;
+    if json.get("bar_color")?.as_str()? != "damage" {
+        return None;
+    }
+    let png = [format!("{stem}_bar.png"), format!("{stem}.png")]
+        .into_iter()
+        .map(|png| path.with_file_name(png))
+        .find(|png| png.exists())?;
+    let relative = path.strip_prefix(root).unwrap_or(path).to_string_lossy();
+    let implicit = horizon_polytone::implicit_id(&relative, "item_modifiers");
+    let targets =
+        horizon_polytone::Targets::parse(json.get("targets"), implicit.as_deref()).ok()?;
+    Some(DamageBar {
+        targets,
+        row: row(&png)?,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn png_row(path: &Path, pixels: &[[u8; 3]]) {
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        let file = std::fs::File::create(path).unwrap();
+        let mut encoder = png::Encoder::new(file, pixels.len() as u32, 1);
+        encoder.set_color(png::ColorType::Rgba);
+        let data: Vec<u8> = pixels
+            .iter()
+            .flat_map(|p| [p[0], p[1], p[2], 255])
+            .collect();
+        encoder
+            .write_header()
+            .unwrap()
+            .write_image_data(&data)
+            .unwrap();
+    }
+
+    #[test]
+    fn a_damage_bar_picks_its_pixel_by_the_stacks_damage() {
+        let dir = std::env::temp_dir().join(format!("pack-bars-{}", std::process::id()));
+        let modifiers = dir.join("assets/minecraft/polytone/item_modifiers");
+        let rgby = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0]];
+        png_row(&modifiers.join("diamond_pickaxe_bar.png"), &rgby);
+        std::fs::write(
+            modifiers.join("tools.json"),
+            r#"{"targets": ["minecraft:iron_axe"], "bar_color": "damage"}"#,
+        )
+        .unwrap();
+        png_row(&modifiers.join("tools_bar.png"), &[[1, 2, 3], [4, 5, 6]]);
+        let bars = read(&dir).unwrap();
+        // The real mod: damage 200 of 1561 shows the first pixel, 1400 the last.
+        assert_eq!(
+            bars.color("minecraft:diamond_pickaxe", 200.0 / 1561.0),
+            Some(0xFF0000)
+        );
+        assert_eq!(
+            bars.color("minecraft:diamond_pickaxe", 1400.0 / 1561.0),
+            Some(0xFFFF00)
+        );
+        assert_eq!(bars.color("minecraft:iron_axe", 0.9), Some(0x040506));
+        assert_eq!(bars.color("minecraft:diamond_shovel", 0.5), None);
+        assert!(read(&dir.join("none")).is_none());
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}
@@ -0,0 +1,96 @@
+//! The resource pack formats vanilla doesn't read (OptiFine's, Polytone's) on the engine's
+//! extension points ([`crate::pack_hooks`]). This is platform code (docs/layers.md) kept in this
+//! crate until the platform's executable installs it: it uses only the crate's public API, so it
+//! moves to a platform crate unchanged, and nothing else in the crate names it.
+
+pub(crate) mod block_entity_cem;
+pub mod cit;
+mod cit_glint;
+mod colors;
+mod connected;
+mod ctm;
+mod custom_sky;
+mod entity_textures;
+mod fusion;
+mod item_bars;
+mod pack_options;
+
+use std::path::Path;
+use std::sync::Arc;
+
+use crate::pack_hooks::PackFormats;
+
+/// OptiFine's and Polytone's formats.
+pub struct Formats;
+
+impl PackFormats for Formats {
+    fn colors(&self, root: &Path) -> Option<crate::pack_palette::PackColors> {
+        Some(colors::read(root))
+    }
+
+    fn connected_textures(
+        &self,
+        root: &Path,
+        registry: &horizon_world::registry::BlockRegistry,
+        sprites: &mut crate::sprites::Sprites,
+        models: &mut crate::models::StateModels,
+        native_mods: &mut dyn FnMut(&mut crate::sprites::Sprites),
+    ) -> Option<crate::connected::Connected> {
+        connected::load(root, registry, sprites, models, native_mods)
+    }
+
+    fn emissive_suffix(&self, root: &Path) -> Option<String> {
+        Some(horizon_optifine::emissive::suffix(root))
+    }
+
+    fn item_textures(&self, root: &Path) -> Option<crate::cit::CitRules> {
+        Some(cit::load(root))
+    }
+
+    fn entity_textures(&self, root: &Path) -> Option<crate::entity_textures::EntityTextures> {
+        Some(entity_textures::load(root))
+    }
+
+    fn block_entity_models(
+        &self,
+        root: &Path,
+        vanilla: &std::collections::HashMap<&'static str, crate::block_entity_render::ModelPart>,
+    ) -> Option<crate::pack_hooks::Reshaped> {
+        block_entity_cem::reshape(root, vanilla)
+    }
+
+    fn custom_sky(&self, root: &Path) -> Option<Arc<dyn crate::custom_sky::SkyLayers>> {
+        let sky = custom_sky::CustomSky::load(root);
+        (!sky.is_empty()).then(|| Arc::new(sky) as _)
+    }
+
+    fn pack_options(&self, source: &crate::packs::Source) -> Option<horizon_pack_options::Configs> {
+        Some(pack_options::read(source))
+    }
+
+    fn overlay_active(
+        &self,
+        entry: &serde_json::Value,
+        options: &horizon_pack_options::Configs,
+        formats_apply: bool,
+    ) -> bool {
+        horizon_polytone::pack::overlay_active(entry, options, formats_apply)
+    }
+
+    fn sounds_without_unmet(
+        &self,
+        text: &[u8],
+        options: &horizon_pack_options::Configs,
+    ) -> Option<Vec<u8>> {
+        horizon_polytone::pack::sounds_without_unmet(text, options)
+    }
+
+    fn item_bars(&self, root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
+        item_bars::read(root)
+    }
+}
+
+/// Installs these formats ([`crate::pack_hooks::install`]); the game does at startup.
+pub fn install() {
+    crate::pack_hooks::install(&Formats);
+}
@@ -0,0 +1,62 @@
+//! Polytone's pack options (wiki "Polytone Configs") and the `polytone_condition`s that read
+//! them, on pack overlays and on `sounds.json` events.
+
+use crate::packs::Source;
+use crate::zip::Zip;
+use horizon_pack_options::Configs;
+use horizon_polytone::pack::add_entry;
+use std::fs;
+
+/// A pack's Polytone config entries (`assets/<namespace>/polytone/config_entries/<name>.json`,
+/// in the pack's base, not its overlays) at their default values.
+pub fn read(source: &Source) -> Configs {
+    let mut configs = Configs::default();
+    let id_of = |name: &str| -> Option<String> {
+        let rest = name.strip_prefix("assets/")?;
+        let (namespace, rest) = rest.split_once('/')?;
+        let entry = rest
+            .strip_prefix("polytone/config_entries/")?
+            .strip_suffix(".json")?;
+        Some(format!("{namespace}:{entry}"))
+    };
+    match source {
+        Source::Dir(d) => {
+            let Ok(namespaces) = fs::read_dir(d.join("assets")) else {
+                return configs;
+            };
+            for namespace in namespaces.flatten() {
+                let folder = namespace.path().join("polytone/config_entries");
+                for file in fs::read_dir(&folder).into_iter().flatten().flatten() {
+                    let name = format!(
+                        "assets/{}/polytone/config_entries/{}",
+                        namespace.file_name().to_string_lossy(),
+                        file.file_name().to_string_lossy()
+                    );
+                    if let (Some(id), Ok(bytes)) = (id_of(&name), fs::read(file.path()))
+                        && let Ok(json) = serde_json::from_slice(&bytes)
+                    {
+                        add_entry(&mut configs, id, &json);
+                    }
+                }
+            }
+        }
+        Source::Zip(z) => {
+            let Ok(zip) = Zip::open(z) else {
+                return configs;
+            };
+            let names: Vec<String> = zip
+                .names()
+                .filter(|n| id_of(n).is_some())
+                .map(str::to_owned)
+                .collect();
+            for name in names {
+                if let (Some(id), Ok(bytes)) = (id_of(&name), zip.read(&name))
+                    && let Ok(json) = serde_json::from_slice(&bytes)
+                {
+                    add_entry(&mut configs, id, &json);
+                }
+            }
+        }
+    }
+    configs
+}
@@ -0,0 +1,121 @@
+//! The engine's extension points for resource pack formats vanilla doesn't read (OptiFine's,
+//! Polytone's: platform code, docs/layers.md). The engine asks [`formats`] once per pack load and
+//! gets engine types back (tables, or an object it calls at most once a frame), never a format's
+//! own types. The platform installs its formats at startup ([`install`]); with none installed,
+//! packs load as vanilla reads them.
+
+use std::path::Path;
+use std::sync::{Arc, OnceLock};
+
+/// What the pack formats beyond vanilla's add to a pack. Each method reads one overlay of a pack
+/// (its folder at `root`); the default is "nothing in this format".
+pub trait PackFormats: Send + Sync {
+    /// The colours the overlay replaces where vanilla hardcodes them.
+    fn colors(&self, _root: &Path) -> Option<crate::pack_palette::PackColors> {
+        None
+    }
+
+    /// The name ending of the overlay's emissive textures (`stone_e.png` beside `stone.png`),
+    /// if its format has them.
+    fn emissive_suffix(&self, _root: &Path) -> Option<String> {
+        None
+    }
+
+    /// The overlay's connected textures: their tiles go into `sprites` (before it finishes), and
+    /// baked faces they draw on may get a rule (`crate::models::BakedFace::fusion`).
+    /// `native_mods` loads native mods' own sprites: call it after the tiles that go before them.
+    fn connected_textures(
+        &self,
+        _root: &Path,
+        _registry: &horizon_world::registry::BlockRegistry,
+        _sprites: &mut crate::sprites::Sprites,
+        _models: &mut crate::models::StateModels,
+        _native_mods: &mut dyn FnMut(&mut crate::sprites::Sprites),
+    ) -> Option<crate::connected::Connected> {
+        None
+    }
+
+    /// The overlay's custom item texture rules and their matcher.
+    fn item_textures(&self, _root: &Path) -> Option<crate::cit::CitRules> {
+        None
+    }
+
+    /// The overlay's entity texture variants, blinks and emissive overlays.
+    fn entity_textures(&self, _root: &Path) -> Option<crate::entity_textures::EntityTextures> {
+        None
+    }
+
+    /// The block entity models the overlay reshapes over `vanilla`'s, with their textures;
+    /// `None` when it reshapes none.
+    fn block_entity_models(
+        &self,
+        _root: &Path,
+        _vanilla: &std::collections::HashMap<&'static str, crate::block_entity_render::ModelPart>,
+    ) -> Option<Reshaped> {
+        None
+    }
+
+    /// The sky layers the overlay draws over the vanilla sky, if it has any.
+    fn custom_sky(&self, _root: &Path) -> Option<Arc<dyn crate::custom_sky::SkyLayers>> {
+        None
+    }
+
+    /// The options the pack (its base, not its overlays) declares, at their defaults.
+    fn pack_options(
+        &self,
+        _source: &crate::packs::Source,
+    ) -> Option<horizon_pack_options::Configs> {
+        None
+    }
+
+    /// Whether an `overlays.entries[]` item of `pack.mcmeta` is active, given the pack's options;
+    /// `formats_apply` is vanilla's answer from its `formats`.
+    fn overlay_active(
+        &self,
+        _entry: &serde_json::Value,
+        _options: &horizon_pack_options::Configs,
+        formats_apply: bool,
+    ) -> bool {
+        formats_apply
+    }
+
+    /// A pack's `sounds.json` without the events its options turn off; `None` when it keeps
+    /// them all.
+    fn sounds_without_unmet(
+        &self,
+        _text: &[u8],
+        _options: &horizon_pack_options::Configs,
+    ) -> Option<Vec<u8>> {
+        None
+    }
+
+    /// The durability bar colours the overlay sets by item, if any.
+    fn item_bars(&self, _root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
+        None
+    }
+}
+
+/// Every block entity model, reshaped by a pack or vanilla's, and the atlas names of the
+/// pack's textures by model ([`PackFormats::block_entity_models`]).
+pub type Reshaped = (
+    std::collections::HashMap<&'static str, crate::block_entity_render::ModelPart>,
+    std::collections::HashMap<&'static str, String>,
+);
+
+/// No format beyond vanilla's.
+struct Vanilla;
+
+impl PackFormats for Vanilla {}
+
+static FORMATS: OnceLock<&'static dyn PackFormats> = OnceLock::new();
+
+/// Installs the pack formats, before the first pack loads. The first call wins: later ones are
+/// ignored, so each test or probe that needs the formats may install them.
+pub fn install(formats: &'static dyn PackFormats) {
+    let _ = FORMATS.set(formats);
+}
+
+/// The installed pack formats, or vanilla's alone.
+pub fn formats() -> &'static dyn PackFormats {
+    FORMATS.get().copied().unwrap_or(&Vanilla)
+}
@@ -12,7 +12,7 @@ use crate::{
    text::Text,
    ui,
 };
-use horizon_polytone::pack::{ConfigKind, ConfigValue, Configs};
+use horizon_pack_options::{ConfigKind, ConfigValue, Configs};

 /// What a click asks of the options screen.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -481,17 +481,36 @@ impl PackOptionsUi {
 mod tests {
    use super::*;

+    use horizon_pack_options::ConfigEntry;
+
+    fn slider(default: f64) -> ConfigEntry {
+        let kind = ConfigKind::Number {
+            min: 0.0,
+            max: 1.0,
+            step: 0.1,
+        };
+        ConfigEntry::new(kind, ConfigValue::Number(default))
+    }
+
+    fn in_section(entry: ConfigEntry, section: &str, order: i64) -> ConfigEntry {
+        ConfigEntry {
+            section: Some(section.into()),
+            section_order: Some(order),
+            ..entry
+        }
+    }
+
    fn configs() -> Configs {
        let mut c = Configs::default();
-        c.add_entry(
-            "p:fog".into(),
-            &serde_json::json!({"default_value": 0.5, "section": "sky", "section_order": 2}),
-        );
-        c.add_entry("p:rain".into(), &serde_json::json!({"default_value": "drops", "allowed_values": ["drops", "streaks"], "section": "weather", "section_order": 1}));
-        c.add_entry(
-            "p:birds".into(),
-            &serde_json::json!({"default_value": true}),
+        c.insert("p:fog".into(), in_section(slider(0.5), "sky", 2));
+        let allowed = vec!["drops".into(), "streaks".into()];
+        let rain = ConfigEntry::new(
+            ConfigKind::Text { allowed },
+            ConfigValue::Text("drops".into()),
        );
+        c.insert("p:rain".into(), in_section(rain, "weather", 1));
+        let birds = ConfigEntry::new(ConfigKind::Bool, ConfigValue::Bool(true));
+        c.insert("p:birds".into(), birds);
        c
    }

@@ -537,9 +556,16 @@ mod tests {
    #[test]
    fn the_presets_row_cycles_the_pack_wide_presets_and_shows_custom_otherwise() {
        let mut c = Configs::default();
-        let entry = |default: f64, fast: f64, pretty: f64| serde_json::json!({"default_value": default, "presets": {"fast": fast, "pretty": pretty}});
-        c.add_entry("p:fog".into(), &entry(0.5, 0.0, 1.0));
-        c.add_entry("p:dust".into(), &entry(0.5, 0.0, 0.8));
+        let entry = |fast: f64, pretty: f64| ConfigEntry {
+            presets: [
+                ("fast".into(), ConfigValue::Number(fast)),
+                ("pretty".into(), ConfigValue::Number(pretty)),
+            ]
+            .into(),
+            ..slider(0.5)
+        };
+        c.insert("p:fog".into(), entry(0.0, 1.0));
+        c.insert("p:dust".into(), entry(0.0, 0.8));
        let mut ui = PackOptionsUi::open(c);
        // The defaults are no preset.
        assert_eq!(ui.current_preset(), None);
@@ -1,14 +1,106 @@
-//! Polytone's dye, sheep and redstone colours (`dye.<name>.diffuse|text`, `sheep.<name>`,
-//! `redstone.<power>`), for drawing only: the pack recolours collars, tropical fish, banners, wool,
-//! sign text and redstone wire and dust, while gameplay (crafting, item data, the beacon) keeps
-//! vanilla's `DyeColor`. Lock-free: the draw paths and the mesher's workers read it per face.
+//! The colours a pack replaces where vanilla hardcodes them (Polytone's `colors.json`, read by the
+//! platform's pack formats, [`crate::pack_hooks`]): dye, sheep and redstone colours, for drawing
+//! only (the pack recolours collars, tropical fish, banners, wool, sign text and redstone wire and
+//! dust, while gameplay keeps vanilla's `DyeColor`), mob effect colours, the experience number's,
+//! entity shadows, the effect fogs' settings and durability bar colours. Lock-free: the draw paths
+//! and the mesher's workers read the dye, sheep and redstone tables per face.
 use std::path::Path;
-use std::sync::RwLock;
 use std::sync::atomic::{AtomicU64, Ordering::Relaxed};
+use std::sync::{Arc, RwLock};

 use crate::block_entity_render::DYES;
 use crate::signs::DYE_TEXT;
-use horizon_polytone::colors::PackColors;
+
+/// The fog settings vanilla hardcodes, as the packs set them (vanilla's by default).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Environment {
+    /// The fog colour inside powder snow (RGB).
+    pub powder_snow_fog: Option<u32>,
+    /// The fog ends of Blindness (5), Darkness (15) and bosses that add world fog (96).
+    pub blindness_fog_distance: f32,
+    pub darkness_fog_distance: f32,
+    pub boss_fog_distance: f32,
+    /// How much the underwater fog colour washes out (1 vanilla, 0 none).
+    pub water_fog_brightening: f32,
+    /// The ticks under water it takes (vanilla's 600).
+    pub water_fog_brightening_time: f32,
+    /// Below it the sky draws its dark disc (vanilla's 63; flat worlds keep their floor).
+    pub horizon_height: f32,
+}
+
+impl Default for Environment {
+    fn default() -> Self {
+        Self {
+            powder_snow_fog: None,
+            blindness_fog_distance: 5.0,
+            darkness_fog_distance: 15.0,
+            boss_fog_distance: 96.0,
+            water_fog_brightening: 1.0,
+            water_fog_brightening_time: 600.0,
+            horizon_height: 63.0,
+        }
+    }
+}
+
+/// The packs' colours; `None` (and the defaults) where they keep vanilla's.
+#[derive(Clone, Debug, PartialEq)]
+pub struct PackColors {
+    /// By dye id (`DyeColor` order): `getTextureDiffuseColor`, `getTextColor`, the sheep's wool.
+    pub dye_diffuse: [Option<u32>; 16],
+    pub dye_text: [Option<u32>; 16],
+    pub sheep: [Option<u32>; 16],
+    /// `RedStoneWireBlock.COLORS` by power.
+    pub redstone: [Option<u32>; 16],
+    /// Mob effects' colours, by effect id without vanilla's namespace.
+    pub effects: Vec<(String, u32)>,
+    /// False hides every entity's round shadow, whatever the video option says.
+    pub entity_shadows: bool,
+    /// The experience level number's colour and outline.
+    pub xp_bar: [Option<u32>; 2],
+    /// The effect fogs' settings: the fog reads them every frame.
+    pub env: Environment,
+    /// The fog the packs' fluid modifiers give water and lava.
+    pub fluid_fog: FluidFogs,
+}
+
+/// A fluid modifier's fog: a flat colour (RGB), and the fog's radius and fade multipliers (1 is
+/// vanilla's).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct FluidFog {
+    pub color: Option<u32>,
+    pub radius: f32,
+    pub fade: f32,
+}
+
+/// The fog the packs' fluid modifiers give water and lava.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct FluidFogs {
+    pub water: Option<FluidFog>,
+    pub lava: Option<FluidFog>,
+}
+
+impl Default for PackColors {
+    fn default() -> Self {
+        Self {
+            dye_diffuse: [None; 16],
+            dye_text: [None; 16],
+            sheep: [None; 16],
+            redstone: [None; 16],
+            effects: Vec::new(),
+            entity_shadows: true,
+            xp_bar: [None; 2],
+            env: Environment::default(),
+            fluid_fog: FluidFogs::default(),
+        }
+    }
+}
+
+impl PackColors {
+    /// Whether entities draw their round shadow, as far as the packs say.
+    pub fn entity_shadows(&self) -> bool {
+        self.entity_shadows
+    }
+}

 /// 0 is unset, else `1 << 32 | rgb`.
 static DIFFUSE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
@@ -16,6 +108,30 @@ static TEXT: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 static SHEEP: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 static REDSTONE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];

+/// The colours of the pack overlay at `root`, from the installed pack formats; their dye, sheep
+/// and redstone colours go to the draw paths' tables ([`set`]).
+pub fn read(root: &Path) -> PackColors {
+    let formats = crate::pack_hooks::formats();
+    let colors = formats.colors(root).unwrap_or_default();
+    set(&colors);
+    *ITEM_BARS.write().unwrap_or_else(|e| e.into_inner()) = formats.item_bars(root);
+    colors
+}
+
+/// The packs' durability bar colours by item (Polytone's item modifiers' `bar_color`).
+pub trait ItemBars: Send + Sync {
+    /// The bar colour (RGB) of `item` at this damage (0 to 1), when a pack sets one.
+    fn color(&self, item: &str, damage: f32) -> Option<u32>;
+}
+
+static ITEM_BARS: RwLock<Option<Arc<dyn ItemBars>>> = RwLock::new(None);
+
+/// A pack's durability bar colour (RGB) for an item at this damage (0 to 1).
+pub fn item_bar_color(item: &str, damage: f32) -> Option<u32> {
+    let bars = ITEM_BARS.read().unwrap_or_else(|e| e.into_inner());
+    bars.as_ref()?.color(item, damage)
+}
+
 /// Takes the colours of the packs just loaded (vanilla's where they set none).
 pub fn set(colors: &PackColors) {
    let store = |table: &[AtomicU64; 16], i: usize, color: Option<u32>| {
@@ -24,129 +140,39 @@ pub fn set(colors: &PackColors) {
            Relaxed,
        );
    };
-    for (i, (name, _)) in DYES.iter().enumerate() {
-        store(&DIFFUSE, i, colors.dye(name, "diffuse"));
-        store(&TEXT, i, colors.dye(name, "text"));
-        store(&SHEEP, i, colors.sheep(name));
-        store(&REDSTONE, i, colors.redstone(i as u8));
+    for i in 0..16 {
+        store(&DIFFUSE, i, colors.dye_diffuse[i]);
+        store(&TEXT, i, colors.dye_text[i]);
+        store(&SHEEP, i, colors.sheep[i]);
+        store(&REDSTONE, i, colors.redstone[i]);
    }
 }

-/// An item modifier's `bar_color` of the `damage` type: a row of colours picked by the stack's
-/// damage, the first pixel undamaged, the last at full damage (measured on the real mod).
-struct DamageBar {
-    targets: horizon_polytone::Targets,
-    row: Vec<u32>,
-}
-static ITEM_BARS: RwLock<Vec<DamageBar>> = RwLock::new(Vec::new());
-
-/// Reads the packs' item modifiers' durability bar colours under a pack overlay root: an
-/// `<item>_bar.png` alone, or a json whose `bar_color` is `damage` with its `<name>_bar.png` (or
-/// `<name>.png`) beside it. Colormap ids and inline colormaps aren't read.
-pub fn set_item_bars(root: &Path) {
-    let mut bars = Vec::new();
-    for namespace in std::fs::read_dir(root.join("assets"))
-        .into_iter()
-        .flatten()
-        .flatten()
-    {
-        let base = namespace.path().join("polytone/item_modifiers");
-        let mut stack = vec![base.clone()];
-        while let Some(dir) = stack.pop() {
-            for entry in std::fs::read_dir(&dir).into_iter().flatten().flatten() {
-                let path = entry.path();
-                if path.is_dir() {
-                    stack.push(path);
-                } else if let Some(bar) = item_bar(root, &base, &path) {
-                    bars.push(bar);
-                }
-            }
-        }
-    }
-    *ITEM_BARS.write().unwrap_or_else(|e| e.into_inner()) = bars;
-}
-
-fn item_bar(root: &Path, base: &Path, path: &Path) -> Option<DamageBar> {
-    let name = path.file_name()?.to_str()?;
-    let row = |png: &Path| {
-        let (width, _, rgba) = crate::sprites::read_rgba(png).ok()?;
-        let row: Vec<u32> = rgba[..width as usize * 4]
-            .as_chunks::<4>()
-            .0
-            .iter()
-            .map(|p| u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
-            .collect();
-        (!row.is_empty()).then_some(row)
-    };
-    if let Some(stem) = name.strip_suffix("_bar.png") {
-        // A json of the same name owns its png.
-        if path.with_file_name(format!("{stem}.json")).exists() {
-            return None;
-        }
-        let relative = path.parent()?.strip_prefix(base).ok()?.join(stem);
-        let namespace = base.parent()?.parent()?.file_name()?.to_str()?;
-        let id = format!("{namespace}:{}", relative.to_str()?.replace('\\', "/"));
-        let targets = horizon_polytone::Targets::parse(None, Some(&id)).ok()?;
-        return Some(DamageBar {
-            targets,
-            row: row(path)?,
-        });
-    }
-    let stem = name.strip_suffix(".json")?;
-    let json: serde_json::Value = horizon_world::json_file::read(path).ok()?;
-    if json.get("bar_color")?.as_str()? != "damage" {
-        return None;
-    }
-    let png = [format!("{stem}_bar.png"), format!("{stem}.png")]
-        .into_iter()
-        .map(|png| path.with_file_name(png))
-        .find(|png| png.exists())?;
-    let relative = path.strip_prefix(root).unwrap_or(path).to_string_lossy();
-    let implicit = horizon_polytone::implicit_id(&relative, "item_modifiers");
-    let targets =
-        horizon_polytone::Targets::parse(json.get("targets"), implicit.as_deref()).ok()?;
-    Some(DamageBar {
-        targets,
-        row: row(&png)?,
-    })
-}
-
-/// A pack's durability bar colour (RGB) for an item at this damage (0 to 1).
-pub fn item_bar_color(item: &str, damage: f32) -> Option<u32> {
-    let bars = ITEM_BARS.read().unwrap_or_else(|e| e.into_inner());
-    let bar = bars
-        .iter()
-        .rev()
-        .find(|b| b.targets.matches(item, |_| false))?;
-    let last = (bar.row.len() - 1) as f32;
-    Some(bar.row[(damage.clamp(0.0, 1.0) * last).round() as usize])
-}
-
-fn read(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
+fn get(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
    let v = table[i & 15].load(Relaxed);
    (v != 0).then_some(v as u32)
 }

 /// `DyeColor.getTextureDiffuseColor` (RGB) as the packs draw it.
 pub fn diffuse(dye: usize) -> u32 {
-    read(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
+    get(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
 }

 /// `DyeColor.getTextColor` (RGB) as the packs draw it.
 pub fn text(dye: usize) -> u32 {
-    read(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
+    get(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
 }

 /// A pack's `RedStoneWireBlock.COLORS` entry for this power (RGB), when it sets one.
 pub fn redstone(power: u8) -> Option<u32> {
-    read(&REDSTONE, usize::from(power))
+    get(&REDSTONE, usize::from(power))
 }

 /// `ColorLerper.Type.SHEEP` wool colour: a pack's `sheep.<name>`, else white 0xE6E6E6 and the
 /// others 75% of vanilla's dye (a pack's `dye.*.diffuse` doesn't reach wool).
 pub fn sheep_wool(dye: u8) -> u32 {
    let i = usize::from(dye & 15);
-    if let Some(color) = read(&SHEEP, i) {
+    if let Some(color) = get(&SHEEP, i) {
        return color;
    }
    if i == 0 {
@@ -156,81 +182,3 @@ pub fn sheep_wool(dye: u8) -> u32 {
    let f = |c: u32| ((c as f32 * 0.75).floor() as u32).min(255);
    f(src >> 16 & 255) << 16 | f(src >> 8 & 255) << 8 | f(src & 255)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn a_pack_recolours_only_what_it_names() {
-        // Dyes no other test draws: the table is process-wide.
-        let dir = std::env::temp_dir().join(format!("pack-dyes-{}", std::process::id()));
-        let polytone = dir.join("assets/obs/polytone");
-        std::fs::create_dir_all(&polytone).unwrap();
-        std::fs::write(
-            polytone.join("colors.json"),
-            r#"{"dye": {"cyan": {"diffuse": "00ff00", "text": "0000ff"}}, "sheep": {"pink": "2040ff"}, "redstone": {"7": "0x123456"}}"#,
-        )
-        .unwrap();
-        set(&PackColors::read(&dir));
-        let (cyan, pink, purple) = (9, 6, 10);
-        assert_eq!(diffuse(cyan), 0x00ff00);
-        assert_eq!(text(cyan), 0x0000ff);
-        assert_eq!(sheep_wool(pink as u8), 0x2040ff);
-        // Wool reads vanilla's dye, not the pack's diffuse: 75% of 0x169C9C.
-        assert_eq!(sheep_wool(cyan as u8), 0x107575);
-        assert_eq!(diffuse(purple), 0x8932B8);
-        assert_eq!(text(purple), 0xA020F0);
-        assert_eq!((redstone(7), redstone(15)), (Some(0x123456), None));
-        set(&PackColors::default());
-        assert_eq!(redstone(7), None);
-        assert_eq!(diffuse(cyan), 0x169C9C);
-        assert_eq!(sheep_wool(pink as u8), 0xB6687F);
-        std::fs::remove_dir_all(&dir).ok();
-    }
-
-    fn png_row(path: &Path, pixels: &[[u8; 3]]) {
-        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
-        let file = std::fs::File::create(path).unwrap();
-        let mut encoder = png::Encoder::new(file, pixels.len() as u32, 1);
-        encoder.set_color(png::ColorType::Rgba);
-        let data: Vec<u8> = pixels
-            .iter()
-            .flat_map(|p| [p[0], p[1], p[2], 255])
-            .collect();
-        encoder
-            .write_header()
-            .unwrap()
-            .write_image_data(&data)
-            .unwrap();
-    }
-
-    #[test]
-    fn a_damage_bar_picks_its_pixel_by_the_stacks_damage() {
-        let dir = std::env::temp_dir().join(format!("pack-bars-{}", std::process::id()));
-        let modifiers = dir.join("assets/minecraft/polytone/item_modifiers");
-        let rgby = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0]];
-        png_row(&modifiers.join("diamond_pickaxe_bar.png"), &rgby);
-        std::fs::write(
-            modifiers.join("tools.json"),
-            r#"{"targets": ["minecraft:iron_axe"], "bar_color": "damage"}"#,
-        )
-        .unwrap();
-        png_row(&modifiers.join("tools_bar.png"), &[[1, 2, 3], [4, 5, 6]]);
-        set_item_bars(&dir);
-        // The real mod: damage 200 of 1561 shows the first pixel, 1400 the last.
-        assert_eq!(
-            item_bar_color("minecraft:diamond_pickaxe", 200.0 / 1561.0),
-            Some(0xFF0000)
-        );
-        assert_eq!(
-            item_bar_color("minecraft:diamond_pickaxe", 1400.0 / 1561.0),
-            Some(0xFFFF00)
-        );
-        assert_eq!(item_bar_color("minecraft:iron_axe", 0.9), Some(0x040506));
-        assert_eq!(item_bar_color("minecraft:diamond_shovel", 0.5), None);
-        set_item_bars(&dir.join("none"));
-        assert_eq!(item_bar_color("minecraft:diamond_pickaxe", 0.5), None);
-        std::fs::remove_dir_all(&dir).ok();
-    }
-}
@@ -38,7 +38,7 @@ pub struct Pack {
    /// Polytone `polytone_condition` turns on.
    pub overlays: Vec<String>,
    /// The values of the pack's Polytone config entries.
-    pub polytone_configs: horizon_polytone::pack::Configs,
+    pub polytone_configs: Configs,
    /// `filter.block` entries (namespace and path patterns) hiding resources
    /// of the packs below this one.
    pub filter: Vec<Filter>,
@@ -419,12 +419,13 @@ fn overlay_applies(entry: &serde_json::Value) -> bool {
        _ => false,
    }
 }
-fn overlays_of(meta: &serde_json::Value, configs: &horizon_polytone::pack::Configs) -> Vec<String> {
+fn overlays_of(meta: &serde_json::Value, configs: &Configs) -> Vec<String> {
+    let formats = crate::pack_hooks::formats();
    meta["overlays"]["entries"]
        .as_array()
        .into_iter()
        .flatten()
-        .filter(|e| horizon_polytone::pack::overlay_active(e, configs, overlay_applies(e)))
+        .filter(|e| formats.overlay_active(e, configs, overlay_applies(e)))
        .filter_map(|e| e["directory"].as_str().map(str::to_owned))
        // OverlayMetadataSection's DIR_VALIDATOR: one folder of the pack, `[-_a-zA-Z0-9.]+`.
        .filter(|d| {
@@ -471,57 +472,12 @@ pub(crate) fn parse_meta(bytes: &[u8]) -> Option<serde_json::Value> {
        .next()?
        .ok()
 }
-/// A pack's Polytone config entries (`assets/<namespace>/polytone/config_entries/<name>.json`,
-/// in the pack's base, not its overlays) at their default values.
-pub fn polytone_configs(source: &Source) -> horizon_polytone::pack::Configs {
-    let mut configs = horizon_polytone::pack::Configs::default();
-    let id_of = |name: &str| -> Option<String> {
-        let rest = name.strip_prefix("assets/")?;
-        let (namespace, rest) = rest.split_once('/')?;
-        let entry = rest
-            .strip_prefix("polytone/config_entries/")?
-            .strip_suffix(".json")?;
-        Some(format!("{namespace}:{entry}"))
-    };
-    match source {
-        Source::Dir(d) => {
-            let Ok(namespaces) = fs::read_dir(d.join("assets")) else {
-                return configs;
-            };
-            for namespace in namespaces.flatten() {
-                let folder = namespace.path().join("polytone/config_entries");
-                for file in fs::read_dir(&folder).into_iter().flatten().flatten() {
-                    let name = format!(
-                        "assets/{}/polytone/config_entries/{}",
-                        namespace.file_name().to_string_lossy(),
-                        file.file_name().to_string_lossy()
-                    );
-                    if let (Some(id), Ok(bytes)) = (id_of(&name), fs::read(file.path()))
-                        && let Ok(json) = serde_json::from_slice(&bytes)
-                    {
-                        configs.add_entry(id, &json);
-                    }
-                }
-            }
-        }
-        Source::Zip(z) => {
-            let Ok(zip) = Zip::open(z) else {
-                return configs;
-            };
-            let names: Vec<String> = zip
-                .names()
-                .filter(|n| id_of(n).is_some())
-                .map(str::to_owned)
-                .collect();
-            for name in names {
-                if let (Some(id), Ok(bytes)) = (id_of(&name), zip.read(&name))
-                    && let Ok(json) = serde_json::from_slice(&bytes)
-                {
-                    configs.add_entry(id, &json);
-                }
-            }
-        }
-    }
+/// A pack's own options (Polytone's config entries, in the pack's base, not its overlays) at
+/// the values the player chose, else their defaults.
+pub fn polytone_configs(source: &Source) -> Configs {
+    let mut configs = crate::pack_hooks::formats()
+        .pack_options(source)
+        .unwrap_or_default();
    for (id, value) in polytone_choices() {
        if configs.entries().contains_key(&id) {
            configs.set(&id, value);
@@ -530,15 +486,15 @@ pub fn polytone_configs(source: &Source) -> horizon_polytone::pack::Configs {
    configs
 }

-/// A pack's Polytone config entries and one's value, for the game's Pack Options.
-pub use horizon_polytone::pack::{ConfigValue, Configs};
+/// A pack's options and one's value, for the game's Pack Options.
+pub use horizon_pack_options::{ConfigValue, Configs};

 /// The player's Polytone config choices (#11486): what they changed from the packs' defaults,
 /// by entry id, for every pack. `polytone_configs` lays them over each pack's defaults.
-static POLYTONE_CHOICES: std::sync::RwLock<BTreeMap<String, horizon_polytone::pack::ConfigValue>> =
+static POLYTONE_CHOICES: std::sync::RwLock<BTreeMap<String, ConfigValue>> =
    std::sync::RwLock::new(BTreeMap::new());

-pub fn polytone_choices() -> BTreeMap<String, horizon_polytone::pack::ConfigValue> {
+pub fn polytone_choices() -> BTreeMap<String, ConfigValue> {
    POLYTONE_CHOICES
        .read()
        .map(|c| c.clone())
@@ -546,7 +502,7 @@ pub fn polytone_choices() -> BTreeMap<String, horizon_polytone::pack::ConfigValu
 }

 /// Replaces the player's Polytone config choices (packs read them when they load again).
-pub fn set_polytone_choices(choices: BTreeMap<String, horizon_polytone::pack::ConfigValue>) {
+pub fn set_polytone_choices(choices: BTreeMap<String, ConfigValue>) {
    if let Ok(mut c) = POLYTONE_CHOICES.write() {
        *c = choices;
    }
@@ -558,8 +514,7 @@ pub fn polytone_choices_file() -> std::path::PathBuf {
 }

 /// Reads the choices from `path` (none when it is missing or broken).
-pub fn load_polytone_choices(path: &Path) -> BTreeMap<String, horizon_polytone::pack::ConfigValue> {
-    use horizon_polytone::pack::ConfigValue;
+pub fn load_polytone_choices(path: &Path) -> BTreeMap<String, ConfigValue> {
    let Ok(bytes) = fs::read(path) else {
        return BTreeMap::new();
    };
@@ -583,9 +538,8 @@ pub fn load_polytone_choices(path: &Path) -> BTreeMap<String, horizon_polytone::
 /// Writes the choices to `path`.
 pub fn save_polytone_choices(
    path: &Path,
-    choices: &BTreeMap<String, horizon_polytone::pack::ConfigValue>,
+    choices: &BTreeMap<String, ConfigValue>,
 ) -> std::io::Result<()> {
-    use horizon_polytone::pack::ConfigValue;
    let map: serde_json::Map<String, serde_json::Value> = choices
        .iter()
        .map(|(id, v)| {
@@ -856,7 +810,8 @@ fn build_overlay_uncached(
                    packs
                        .get(*owner)
                        .and_then(|p| {
-                            horizon_polytone::pack::sounds_without_unmet(&b, &p.polytone_configs)
+                            crate::pack_hooks::formats()
+                                .sounds_without_unmet(&b, &p.polytone_configs)
                        })
                        .unwrap_or(b),
                ),
@@ -1606,6 +1561,7 @@ mod tests {
    }
    #[test]
    fn a_sound_entry_whose_polytone_condition_fails_is_left_out() {
+        crate::pack_formats::install();
        let base =
            std::env::temp_dir().join(format!("horizon-packs-sound-cond-{}", std::process::id()));
        let _ = fs::remove_dir_all(&base);
@@ -2121,6 +2077,7 @@ mod tests {
    }
    #[test]
    fn polytone_conditions_turn_overlays_on_from_the_packs_configs() {
+        crate::pack_formats::install();
        let dir =
            std::env::temp_dir().join(format!("horizon-packs-polytone-{}", std::process::id()));
        let _ = fs::remove_dir_all(&dir);
@@ -31,6 +31,7 @@ mod native;
 pub mod polytone;
 mod polytone_gpu;
 mod polytone_model;
+mod spawn;
 pub use native::{ParticleController, ParticleUpdate};

 /// `ParticleOptions` with the parameters of the option classes used here.
@@ -1222,8 +1223,9 @@ pub struct ParticleLevel<'a> {
    pub collision: &'a BlockCollisionRegistry<'a>,
    /// Local player feet position and vertical velocity (`PlayerCloudParticle`).
    pub player: Option<([f64; 3], f64)>,
+    pub cached_chunk: std::cell::Cell<Option<((i32, i32), Option<&'a crate::chunk::Chunk>)>>,
 }
-impl ParticleLevel<'_> {
+impl<'a> ParticleLevel<'a> {
    fn collide(&self, bb: Aabb, d: [f64; 3]) -> [f64; 3] {
        let mut scene = SceneCollisions {
            world: self.world,
@@ -1231,9 +1233,6 @@ impl ParticleLevel<'_> {
            subject: None,
        };
        let movement = Vec3::new(d[0], d[1], d[2]);
-        // `Entity.collideBoundingBox(null, ...)`: no entity shapes, no border. Where no
-        // block of the swept box's cells can collide, it finds no shape and the
-        // movement stands, as the resolution below would return it.
        if scene.cells_without_collision(bb.expand_towards(movement)) {
            return d;
        }
@@ -1249,38 +1248,46 @@ impl ParticleLevel<'_> {
            p[2].floor() as i32,
        ]
    }
+    #[inline]
+    pub fn block(&self, x: i32, y: i32, z: i32) -> horizon_world::registry::BlockStateId {
+        let (cx, cz) = (x >> 4, z >> 4);
+        let chunk = match self.cached_chunk.get() {
+            Some(((ccx, ccz), c)) if ccx == cx && ccz == cz => c,
+            _ => {
+                let c = self.world.chunks.get(&(cx, cz)).map(|c| c.as_ref());
+                self.cached_chunk.set(Some(((cx, cz), c)));
+                c
+            }
+        };
+        chunk.map_or(self.world.air, |c| c.block(x & 15, y, z & 15))
+    }
    /// The fluid at a block and `FluidState.getHeight`.
    fn fluid(&self, b: [i32; 3]) -> (Fluid, f64) {
-        let s = self.facts.get(self.world.block(b[0], b[1], b[2]));
+        let s = self.facts.get(self.block(b[0], b[1], b[2]));
        if s.fluid == Fluid::None {
            return (Fluid::None, 0.0);
        }
-        let above = self.facts.get(self.world.block(b[0], b[1] + 1, b[2]));
-        let height = if above.fluid == s.fluid {
+        let above = self.facts.get(self.block(b[0], b[1] + 1, b[2]));
+        let h = if above.fluid == s.fluid {
            1.0
        } else {
            f64::from(s.fluid_level) / 9.0
        };
-        (s.fluid, height)
+        (s.fluid, h)
    }
    /// The fluid at a block and whether it is a source (`FluidState.isSource`).
    pub(crate) fn fluid_source(&self, b: [i32; 3]) -> (Fluid, bool) {
-        let s = self.facts.get(self.world.block(b[0], b[1], b[2]));
+        let s = self.facts.get(self.block(b[0], b[1], b[2]));
        (s.fluid, s.fluid_level == 8 && !s.fluid_falling)
    }
    /// `getCollisionShape(...).max(Y, x, z)` for cached shapes.
    fn collision_top(&self, b: [i32; 3], fx: f64, fz: f64) -> f64 {
-        let state = self.world.block(b[0], b[1], b[2]);
+        let state = self.block(b[0], b[1], b[2]);
        match self.collision.cached_shapes().cached_shape(state) {
            Ok(Some(shape)) if !shape.is_empty() => shape.max_at(Axis::Y, fx, fz),
            Ok(Some(_)) => 0.0,
-            _ => {
-                if self.facts.get(state).full_collision {
-                    1.0
-                } else {
-                    0.0
-                }
-            }
+            _ if self.facts.get(state).full_collision => 1.0,
+            _ => 0.0,
        }
    }
 }
@@ -2020,73 +2027,6 @@ impl ParticleEngine {
            (eye[0] - pos[0]).powi(2) + (eye[1] - pos[1]).powi(2) + (eye[2] - pos[2]).powi(2) <= 9.0
        })
    }
-    /// `ClientPacketListener.handleParticleEvent` for `ServerLevel.sendParticles`.
-    pub fn send_particles(
-        &mut self,
-        options: &ParticleOptions,
-        at: [f64; 3],
-        spread: [f64; 3],
-        speed: f64,
-        count: u32,
-    ) {
-        if count == 0 {
-            let v = [speed * spread[0], speed * spread[1], speed * spread[2]];
-            self.add(options, at, v);
-            return;
-        }
-        for _ in 0..count {
-            let r = &mut self.random;
-            let p = [
-                at[0] + r.next_gaussian() * spread[0],
-                at[1] + r.next_gaussian() * spread[1],
-                at[2] + r.next_gaussian() * spread[2],
-            ];
-            let v = [
-                r.next_gaussian() * speed,
-                r.next_gaussian() * speed,
-                r.next_gaussian() * speed,
-            ];
-            self.add(options, p, v);
-        }
-    }
-    /// `ParticleEngine.createParticle`: always spawned, but `ParticleEngine.add`
-    /// drops a spore blossom air particle once `ParticleLimit.SPORE_BLOSSOM` is full.
-    pub fn create(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
-        if let Some(requests) = &mut self.created_requests {
-            requests.push((options.clone(), p, v));
-            return;
-        }
-        let seed = self.seeds.next_long();
-        if let Some(mut particle) = self.make(options, p, v, seed) {
-            *self.made.entry(options.ty.name()).or_default() += 1;
-            // Resource packs' Polytone particle modifiers (#11486), once as it spawns.
-            if let Some(registry) = &self.polytone
-                && registry.modifies_particles()
-            {
-                let id = match &options.mod_particle {
-                    Some(name) => name.clone(),
-                    None => format!("minecraft:{}", options.ty.name()),
-                };
-                polytone::modify(registry, &id, options.source.as_deref(), &mut particle);
-            }
-            // The provider has drawn, so rejecting here keeps vanilla's RNG order.
-            // shortcut: counts live plus queued particles by scanning instead of
-            // vanilla's counted map; use a counter if spore spawning shows in profiles.
-            if particle.ty == ParticleType::SporeBlossomAir
-                && self.particles.len() + self.pending.len() >= SPORE_BLOSSOM_LIMIT
-                && self
-                    .particles
-                    .iter()
-                    .chain(self.pending.iter())
-                    .filter(|q| q.ty == ParticleType::SporeBlossomAir)
-                    .count()
-                    >= SPORE_BLOSSOM_LIMIT
-            {
-                return;
-            }
-            self.pending.push(particle);
-        }
-    }
    /// How many particles of each type were made so far.
    pub fn made(&self) -> &std::collections::BTreeMap<&'static str, u64> {
        &self.made
@@ -4052,15 +3992,12 @@ impl ParticleEngine {
            }
            Behaviour::Lava => {
                p.base_tick(level);
-                if !p.removed {
-                    let odds = p.age as f32 / p.lifetime as f32;
-                    if p.random.next_float() > odds {
-                        self.add(
-                            &ParticleOptions::simple(ParticleType::Smoke),
-                            p.position,
-                            p.velocity,
-                        );
-                    }
+                if !p.removed && p.random.next_float() > p.age as f32 / p.lifetime as f32 {
+                    self.add(
+                        &ParticleOptions::simple(ParticleType::Smoke),
+                        p.position,
+                        p.velocity,
+                    );
                }
            }
            Behaviour::Crit => {
@@ -4144,9 +4081,7 @@ impl ParticleEngine {
                    *c *= f64::from(0.98f32);
                }
                if p.on_ground {
-                    if p.random.next_float() < 0.5 {
-                        p.removed = true;
-                    }
+                    p.removed |= p.random.next_float() < 0.5;
                    p.velocity[0] *= f64::from(0.7f32);
                    p.velocity[2] *= f64::from(0.7f32);
                }
@@ -4186,13 +4121,10 @@ impl ParticleEngine {
            } => {
                p.base_tick(level);
                let (fluid, source) = level.fluid_source(ParticleLevel::block_at(p.position));
-                if !(p.removed || (fluid == Fluid::Water && source)) {
-                    p.removed = true;
-                }
-                if !p.removed && p.position[1] >= y_end {
-                    p.removed = true;
-                }
-                if !p.removed && p.position[1] <= y_prev {
+                if !(fluid == Fluid::Water && source)
+                    || p.position[1] >= y_end
+                    || p.position[1] <= y_prev
+                {
                    p.removed = true;
                }
                // randomHorizontalWiggling, then a second, horizontal move.
@@ -4216,9 +4148,8 @@ impl ParticleEngine {
                p.base_tick(level);
                self.sprite_from_age(p);
                if p.age as f32 > fade_start {
-                    let frames_since_fade_out_start = p.age as f32 - fade_start;
                    p.rgba[3] =
-                        (p.lifetime as f32 - frames_since_fade_out_start) / p.lifetime as f32;
+                        (p.lifetime as f32 - (p.age as f32 - fade_start)) / p.lifetime as f32;
                }
            }
            Behaviour::NoxiousGasCloud => {
@@ -4682,7 +4613,7 @@ impl ParticleEngine {
                    self.sprite_from_age(p);
                    half(p);
                    let b = ParticleLevel::block_at(p.position);
-                    if level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
+                    if level.facts.is_air(level.block(b[0], b[1], b[2])) {
                        p.velocity[1] -= f64::from(0.0074f32);
                    }
                }
@@ -4690,7 +4621,7 @@ impl ParticleEngine {
            Behaviour::Firefly => {
                p.base_tick(level);
                let b = ParticleLevel::block_at(p.position);
-                if !level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
+                if !level.facts.is_air(level.block(b[0], b[1], b[2])) {
                    p.removed = true;
                } else {
                    p.rgba[3] = fade_amount(p.lifetime_progress(p.age as f32), 0.3, 0.5);
@@ -5154,11 +5085,12 @@ fn hdr_tier(ty: ParticleType) -> u8 {
 }
 /// `Particle.LifetimeAlpha.currentAlphaForAge`.
 fn lifetime_alpha(a: [f32; 4], age: i32, lifetime: i32, partial: f32) -> f32 {
-    if (a[0] - a[1]).abs() < 1.0e-5 {
-        return a[0];
-    }
    let t = ((age as f32 + partial) / lifetime as f32 - a[2]) / (a[3] - a[2]);
-    a[0] + (a[1] - a[0]) * t.clamp(0.0, 1.0)
+    if (a[0] - a[1]).abs() < 1.0e-5 {
+        a[0]
+    } else {
+        a[0] + (a[1] - a[0]) * t.clamp(0.0, 1.0)
+    }
 }

 struct Starter {
@@ -5589,6 +5521,7 @@ mod tests {
            facts: &facts,
            collision: &collision,
            player: None,
+            cached_chunk: std::cell::Cell::new(None),
        };
        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
        engine.set_sprites.push(vec![10, 11, 12]);
@@ -5680,6 +5613,7 @@ mod tests {
            facts: &facts,
            collision: &collision,
            player: None,
+            cached_chunk: std::cell::Cell::new(None),
        };
        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
        let mut particle = Particle::blank(ParticleType::Smoke, [0.0; 3]);
@@ -124,6 +124,7 @@ mod tests {
            facts: &facts,
            collision: &collision,
            player: None,
+            cached_chunk: std::cell::Cell::new(None),
        };
        let mut e = engine();
        let mut p = e
@@ -490,14 +490,14 @@ enum Subject<'a> {
 }

 /// What one expression runs against: its subject, the frame and the level.
-struct Ctx<'a> {
+struct Ctx<'a, 'l> {
    subject: Subject<'a>,
    random: &'a mut LegacyRandom,
    custom: &'a mut f64,
    customs: &'a mut BTreeMap<String, f64>,
    frame: &'a Frame,
    registry: &'a Registry,
-    level: Option<&'a ParticleLevel<'a>>,
+    level: Option<&'a ParticleLevel<'l>>,
    blocks: Vec<[i32; 3]>,
 }

@@ -515,7 +515,7 @@ fn axis(name: &str) -> usize {
    usize::from(name.as_bytes()[0] - b'x')
 }

-impl Ctx<'_> {
+impl Ctx<'_, '_> {
    fn position(&self) -> [f64; 3] {
        match &self.subject {
            Subject::Particle(p) => p.position,
@@ -683,7 +683,7 @@ impl Ctx<'_> {
    }
 }

-impl Host for Ctx<'_> {
+impl Host for Ctx<'_, '_> {
    fn root(&mut self, root: Root) -> V {
        match root {
            Root::Object => V::Object(SELF),
@@ -796,11 +796,31 @@ impl Host for Ctx<'_> {
                .registry
                .configs
                .get(id)
-                .map(horizon_polytone::pack::ConfigValue::to_value)
+                .map(horizon_polytone::pack::config_value)
                .ok_or_else(|| format!("no config {id}")),
            _ => Err(format!("{name} is not available here")),
        }
    }
+
+    /// A particle's own fields, as `particle_method` answers them.
+    fn field(&mut self, root: Root, field: horizon_polytone::expr::Field) -> Option<V> {
+        use horizon_polytone::expr::Field as F;
+        let Subject::Particle(p) = &self.subject else {
+            return None;
+        };
+        if root != Root::Object {
+            return None;
+        }
+        Some(V::Num(match field {
+            F::Age => f64::from(p.age),
+            F::Life => f64::from(p.lifetime),
+            F::Custom => *self.custom,
+            F::X => p.position[0],
+            F::Y => p.position[1],
+            F::Z => p.position[2],
+            F::Temperature | F::Downfall => return None,
+        }))
+    }
 }

 fn eval(program: &Program, ctx: &mut Ctx) -> Option<f64> {
@@ -1662,6 +1682,7 @@ mod tests {
            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));
        // Air has no emitters; the torch fires its first emitter only.
@@ -1701,6 +1722,7 @@ mod tests {
            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));
        engine.polytone_animate(&level, [1, 64, 1]);
@@ -1722,6 +1744,7 @@ mod tests {
            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));
        engine.polytone_animate(&level, [1, 64, 1]);
@@ -1767,6 +1790,7 @@ mod tests {
            facts: &scene.facts,
            collision: &scene.collision,
            player: None,
+            cached_chunk: std::cell::Cell::new(None),
        };
        let registry = Registry::read(&root, Default::default(), blocks);
        let frame = registry.frame.clone();
@@ -1820,6 +1844,7 @@ mod tests {
            facts: &scene.facts,
            collision: &scene.collision,
            player: None,
+            cached_chunk: std::cell::Cell::new(None),
        };
        let registry = Registry::read(&root, Default::default(), blocks);
        let mut engine = engine(registry);
@@ -1853,6 +1878,7 @@ mod tests {
            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 rect = crate::hud::Rect {
@@ -1905,6 +1931,7 @@ mod tests {
            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 rect = crate::hud::Rect {
@@ -1966,6 +1993,7 @@ mod tests {
            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));
        engine.polytone_entity(&level, "minecraft:player", [1.0, 70.0, 1.0]);
@@ -2014,6 +2042,7 @@ mod tests {
            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 rect = crate::hud::Rect {
@@ -2080,6 +2109,7 @@ mod tests {
            facts: &scene.facts,
            collision: &scene.collision,
            player: None,
+            cached_chunk: std::cell::Cell::new(None),
        };
        let registry = Arc::new(Registry::read(&root, Default::default(), blocks));
        // The chunk's biome is id 0: plains, whose foliage is #336699.
@@ -2198,6 +2228,7 @@ mod tests {
            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));
        engine.polytone_entity(&level, "minecraft:player", [1.5, 70.0, 1.5]);
@@ -2276,6 +2307,7 @@ mod tests {
            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 test chunk's biome is the table's first: a cold one first, then a warm one.
@@ -0,0 +1,73 @@
+//! Where particles come into the engine: a server's particle packet and a single particle made
+//! where the game asks for one.
+use super::*;
+
+impl ParticleEngine {
+    /// `ClientPacketListener.handleParticleEvent` for `ServerLevel.sendParticles`.
+    pub fn send_particles(
+        &mut self,
+        options: &ParticleOptions,
+        at: [f64; 3],
+        spread: [f64; 3],
+        speed: f64,
+        count: u32,
+    ) {
+        if count == 0 {
+            let v = [speed * spread[0], speed * spread[1], speed * spread[2]];
+            self.add(options, at, v);
+            return;
+        }
+        for _ in 0..count {
+            let r = &mut self.random;
+            let p = [
+                at[0] + r.next_gaussian() * spread[0],
+                at[1] + r.next_gaussian() * spread[1],
+                at[2] + r.next_gaussian() * spread[2],
+            ];
+            let v = [
+                r.next_gaussian() * speed,
+                r.next_gaussian() * speed,
+                r.next_gaussian() * speed,
+            ];
+            self.add(options, p, v);
+        }
+    }
+    /// `ParticleEngine.createParticle`: always spawned, but `ParticleEngine.add`
+    /// drops a spore blossom air particle once `ParticleLimit.SPORE_BLOSSOM` is full.
+    pub fn create(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
+        if let Some(requests) = &mut self.created_requests {
+            requests.push((options.clone(), p, v));
+            return;
+        }
+        let seed = self.seeds.next_long();
+        if let Some(mut particle) = self.make(options, p, v, seed) {
+            *self.made.entry(options.ty.name()).or_default() += 1;
+            // Resource packs' Polytone particle modifiers (#11486), once as it spawns.
+            if let Some(registry) = &self.polytone
+                && registry.modifies_particles()
+            {
+                let id = match &options.mod_particle {
+                    Some(name) => name.clone(),
+                    None => format!("minecraft:{}", options.ty.name()),
+                };
+                polytone::modify(registry, &id, options.source.as_deref(), &mut particle);
+            }
+            // The provider has drawn, so rejecting here keeps vanilla's RNG order.
+            // shortcut: counts live plus queued particles by scanning instead of
+            // vanilla's counted map; use a counter if spore spawning shows in profiles.
+            if particle.ty == ParticleType::SporeBlossomAir
+                && self.particles.len() + self.pending.len() >= SPORE_BLOSSOM_LIMIT
+                && self
+                    .particles
+                    .iter()
+                    .chain(self.pending.iter())
+                    .filter(|q| q.ty == ParticleType::SporeBlossomAir)
+                    .count()
+                    >= SPORE_BLOSSOM_LIMIT
+            {
+                return;
+            }
+            self.pending.push(particle);
+        }
+    }
+}
@@ -93,6 +93,7 @@ fn particle_tick_cost() {
        facts: &facts,
        collision: &collision,
        player: None,
+        cached_chunk: std::cell::Cell::new(None),
    };
    let ty = |name: &str| ParticleType::from_name(name).unwrap();
    let (fx, fy, fz) = (0.5, f64::from(FLOOR_Y + 5), 20.5);
@@ -7,7 +7,10 @@
 //! sections are immutable behind `Arc` and edited through `Arc::make_mut`, so
 //! a weak reference tells an edited or replaced section from the one the list
 //! was built from (see `random_tick_sections`), without keeping its blocks.
-use crate::{chunk::Section, fast_hash::FxHashMap};
+use crate::{
+    chunk::{Chunk, Section},
+    fast_hash::FxHashMap,
+};
 use std::sync::{Arc, Mutex, Weak};

 /// A section's POIs: the block index in the section (`y << 8 | z << 4 | x`)
@@ -18,13 +21,16 @@ struct Cached<T> {
    section: Weak<Section>,
    pois: SectionPois<T>,
 }
-/// Cached POI lists by section, `(chunk x, section index, chunk z)`.
+/// Cached POI lists by chunk column `(chunk x, chunk z)`, each by section
+/// index: a search through a column looks it up once.
 pub struct PoiSections<T> {
    sections: Mutex<Lists<T>>,
 }
 struct Lists<T> {
-    by_section: FxHashMap<(i32, i32, i32), Cached<T>>,
-    /// Size above which lists of sections no longer resident are dropped.
+    by_column: FxHashMap<(i32, i32), Vec<Option<Cached<T>>>>,
+    /// How many section lists are kept, and the count above which the lists
+    /// of sections no longer resident are dropped.
+    len: usize,
    prune_at: usize,
 }
 const MIN_PRUNE: usize = 4096;
@@ -32,27 +38,61 @@ impl<T> Default for PoiSections<T> {
    fn default() -> Self {
        Self {
            sections: Mutex::new(Lists {
-                by_section: FxHashMap::default(),
+                by_column: FxHashMap::default(),
+                len: 0,
                prune_at: MIN_PRUNE,
            }),
        }
    }
 }
-impl<T: Copy> PoiSections<T> {
-    /// The POIs of `section`, whose block states `kind` classifies. `kind`
-    /// must give the same answer for a state on every call.
-    pub fn get(
-        &self,
-        key: (i32, i32, i32),
-        section: &Arc<Section>,
-        mut kind: impl FnMut(u32) -> Option<T>,
-    ) -> SectionPois<T> {
-        let mut lists = self.sections.lock().unwrap_or_else(|e| e.into_inner());
-        if let Some(cached) = lists.by_section.get(&key)
-            && cached.section.as_ptr() == Arc::as_ptr(section)
-        {
-            return cached.pois.clone();
+impl<T: Copy> Lists<T> {
+    /// The column's lists, for sections up to `last`, after dropping the
+    /// lists of sections no longer resident if there are too many.
+    fn column(
+        &mut self,
+        column: (i32, i32),
+        last: usize,
+    ) -> (&mut [Option<Cached<T>>], &mut usize) {
+        if self.len >= self.prune_at {
+            self.prune();
        }
+        let lists = self.by_column.entry(column).or_default();
+        if lists.len() <= last {
+            lists.resize_with(last + 1, || None);
+        }
+        (lists, &mut self.len)
+    }
+
+    /// Drops the lists of sections no longer resident.
+    fn prune(&mut self) {
+        let mut len = 0;
+        self.by_column.retain(|_, lists| {
+            for c in lists.iter_mut() {
+                if c.as_ref().is_some_and(|c| c.section.strong_count() == 0) {
+                    *c = None;
+                }
+            }
+            let kept = lists.iter().filter(|c| c.is_some()).count();
+            len += kept;
+            kept > 0
+        });
+        self.len = len;
+        self.prune_at = (len * 2).max(MIN_PRUNE);
+    }
+}
+
+/// The POIs of `section` from `slot`, listed again (and kept there) unless
+/// `slot` was listed from this very section; `len` counts the slots filled.
+fn list<'a, T: Copy>(
+    slot: &'a mut Option<Cached<T>>,
+    len: &mut usize,
+    section: &Arc<Section>,
+    kind: &mut impl FnMut(u32) -> Option<T>,
+) -> &'a SectionPois<T> {
+    let fresh = slot
+        .as_ref()
+        .is_some_and(|c| c.section.as_ptr() == Arc::as_ptr(section));
+    if !fresh {
        let pois: SectionPois<T> = if section.blocks.maybe_has(|v| kind(v).is_some()) {
            let mut states = [0u32; 4096];
            section.unpack(&mut states);
@@ -64,18 +104,56 @@ impl<T: Copy> PoiSections<T> {
        } else {
            Arc::from([])
        };
-        if lists.by_section.len() >= lists.prune_at {
-            lists.by_section.retain(|_, c| c.section.strong_count() > 0);
-            lists.prune_at = (lists.by_section.len() * 2).max(MIN_PRUNE);
+        *len += usize::from(slot.is_none());
+        *slot = Some(Cached {
+            section: Arc::downgrade(section),
+            pois,
+        });
+    }
+    &slot.as_ref().expect("just listed").pois
+}
+
+impl<T: Copy> PoiSections<T> {
+    /// The POIs of `section`, the `key.1`-th section of the column
+    /// `(key.0, key.2)`, whose block states `kind` classifies. `kind` must give
+    /// the same answer for a state on every call.
+    pub fn get(
+        &self,
+        key: (i32, i32, i32),
+        section: &Arc<Section>,
+        mut kind: impl FnMut(u32) -> Option<T>,
+    ) -> SectionPois<T> {
+        let mut lists = self.sections.lock().unwrap_or_else(|e| e.into_inner());
+        let s = usize::try_from(key.1).expect("a section index");
+        let (column, len) = lists.column((key.0, key.2), s);
+        list(&mut column[s], len, section, &mut kind).clone()
+    }
+
+    /// The POIs of `chunk` from block Y `y0` to `y1`, its first section at
+    /// `min_y`, as [`Self::get`] gives them: each section that has any, with
+    /// the Y of its lowest blocks, in order, put in `out`. One lookup of the
+    /// column.
+    pub fn column(
+        &self,
+        chunk: &Chunk,
+        min_y: i32,
+        (y0, y1): (i32, i32),
+        mut kind: impl FnMut(u32) -> Option<T>,
+        out: &mut Vec<(i32, SectionPois<T>)>,
+    ) {
+        out.clear();
+        let (first, last) = ((y0 - min_y) >> 4, (y1 - min_y) >> 4);
+        if first > last {
+            return;
+        }
+        let mut lists = self.sections.lock().unwrap_or_else(|e| e.into_inner());
+        let (slots, len) = lists.column((chunk.x, chunk.z), last as usize);
+        for s in first as usize..=last as usize {
+            let pois = list(&mut slots[s], len, &chunk.sections[s], &mut kind);
+            if !pois.is_empty() {
+                out.push((min_y + s as i32 * 16, pois.clone()));
+            }
        }
-        lists.by_section.insert(
-            key,
-            Cached {
-                section: Arc::downgrade(section),
-                pois: pois.clone(),
-            },
-        );
-        pois
    }
 }

@@ -143,6 +221,48 @@ mod tests {
        assert!(index.get((0, 0, 0), &chunk.sections[0], kind).is_empty());
    }

+    /// A column gives each section's list as `get` does, the sections
+    /// without any left out, and keeps them until a section changes.
+    #[test]
+    fn a_column_gives_what_each_section_gives() {
+        let index = PoiSections::<u8>::default();
+        let kind = |v: u32| (v == 5).then_some(5);
+        let mut chunk = Arc::new(Chunk::empty(2, -3));
+        for (x, y, z) in [(1, MIN_Y + 2, 3), (4, MIN_Y + 40, 0), (0, MIN_Y + 41, 15)] {
+            Arc::make_mut(&mut chunk).set(x, y, z, 5);
+        }
+        let mut out = Vec::new();
+        index.column(&chunk, MIN_Y, (MIN_Y, MIN_Y + 63), kind, &mut out);
+        let bases: Vec<i32> = out.iter().map(|(base, _)| *base).collect();
+        assert_eq!(bases, [MIN_Y, MIN_Y + 32]);
+        for (base, pois) in &out {
+            let s = (base - MIN_Y) / 16;
+            let one = index.get((2, s, -3), &chunk.sections[s as usize], kind);
+            assert!(Arc::ptr_eq(pois, &one));
+        }
+        // Kept: no rescan.
+        index.column(
+            &chunk,
+            MIN_Y,
+            (MIN_Y, MIN_Y + 63),
+            |_| panic!("rescanned"),
+            &mut out,
+        );
+        assert_eq!(out.len(), 2);
+        // An edit lists that section again.
+        Arc::make_mut(&mut chunk).set(4, MIN_Y + 40, 0, 1);
+        let mut rescans = 0;
+        let counted = |v: u32| {
+            rescans += 1;
+            kind(v)
+        };
+        index.column(&chunk, MIN_Y, (MIN_Y + 20, MIN_Y + 63), counted, &mut out);
+        assert!(rescans > 0);
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].0, MIN_Y + 32);
+        assert_eq!(&*out[0].1, &[(9 << 8 | 15 << 4, 5)]);
+    }
+
    #[test]
    fn unloaded_sections_are_dropped() {
        let index = PoiSections::<u8>::default();
@@ -153,7 +273,7 @@ mod tests {
            index.get((1, i, 0), &Arc::new(Section::default()), kind);
        }
        let lists = index.sections.lock().unwrap();
-        assert!(lists.by_section.len() <= 2);
-        assert!(lists.by_section.contains_key(&(0, 0, 0)));
+        assert!(lists.len <= 2);
+        assert!(lists.by_column[&(0, 0)][0].is_some());
    }
 }
@@ -4,7 +4,6 @@
 //! Horizon Settings > PvP & HUD. Every option is off by default, so the game looks like
 //! vanilla until the player changes one, and none of them shows anything vanilla doesn't
 //! already tell the player.
-use horizon_hooks::look::Look;

 /// Colours the PvP options pick from. `Inverted` is vanilla's crosshair blend: the colour
 /// under it, inverted.
@@ -264,6 +263,15 @@ impl ViewWeather {
        Self::ALL.into_iter().find(|c| c.name() == s)
    }
 }
+/// The day time this player sees with `fixed` set: the same day (the moon's phase follows the
+/// world's), at that time.
+pub fn view_day_time(world: i64, fixed: Option<ViewTime>) -> i64 {
+    match fixed {
+        Some(t) => world.div_euclid(24000) * 24000 + t.day_time(),
+        None => world,
+    }
+}
+
 /// The crosshair's look. Its defaults draw vanilla's: a 15-pixel cross, one pixel thick,
 /// inverting what is under it.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -520,36 +528,24 @@ impl Hit {
    }
 }

+/// What the renderer reads of these options each frame (`FrameInputs::pvp`); the default is
+/// vanilla's look.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Frame {
+    /// The block outline's stroke ([`Outline::stroke`]).
+    pub outline: Option<(u32, f32)>,
+    /// The hurt overlay texel ([`Hit::texel`]), 0 for vanilla's.
+    pub hurt_texel: u32,
+    /// The glint's colour ([`Tweaks::glint_texel`]), 0 for vanilla's.
+    pub glint: u32,
+}
 impl Pvp {
-    /// What the engine reads of these options (`horizon_hooks::look`): all it draws differently.
-    /// Sets PvP & HUD's fields of `look`, the others' stay.
-    pub fn apply(&self, look: &mut Look) {
-        let (c, t) = (self.combat, self.tweaks);
-        look.legacy_pose = c.legacy;
-        look.hide_attack_indicator = c.legacy && !c.indicator;
-        look.mute_attack_sounds = c.legacy && c.sounds;
-        look.hide_attack_particles = c.legacy;
-        look.frame.outline = self.outline.stroke();
-        look.frame.hurt_texel = self.hit.texel();
-        look.frame.glint = t.glint_texel();
-        look.shield_size = t.shield_size;
-        look.totem_scale = f32::from(t.totem_size) / 100.0;
-        look.fire_lower = f32::from(t.fire_lower) / 100.0;
-        look.clear_lava = t.clear_lava;
-        look.clear_water = t.clear_water;
-        look.chat.timestamps = self.chat.timestamps;
-        look.chat.compact = self.chat.compact;
-        look.chat.copy = self.chat.copy;
-        look.chat.search = self.chat.search;
-        look.hide_effect_icons = self.hud.effects;
-        look.time_of_day = t.time.map(ViewTime::day_time);
-        look.weather = t.weather.map(ViewWeather::levels);
-    }
-    /// [`Pvp::apply`] on vanilla's look.
-    pub fn look(&self) -> Look {
-        let mut look = Look::default();
-        self.apply(&mut look);
-        look
+    pub fn frame(&self) -> Frame {
+        Frame {
+            outline: self.outline.stroke(),
+            hurt_texel: self.hit.texel(),
+            glint: self.tweaks.glint_texel(),
+        }
    }
 }

@@ -745,6 +741,15 @@ pub struct ChatOptions {
    /// Ctrl+F in the chat searches the chat's messages.
    pub search: bool,
 }
+impl ChatOptions {
+    /// What `chat::Chat` lays its lines out with.
+    pub fn qol(&self) -> crate::chat::ChatQol {
+        crate::chat::ChatQol {
+            timestamps: self.timestamps,
+            compact: self.compact,
+        }
+    }
+}

 /// Combat feel (`docs/pvp.md`): how fights look. Legacy draws them as 1.8.9 did; what the
 /// game sends to a server never changes, so a vanilla server and its anticheat see 26.3.
@@ -761,6 +766,21 @@ pub struct Combat {
    /// (`horizon_client::legacy_combat`). Never used as a client of a server.
    pub rules: bool,
 }
+impl Combat {
+    /// Whether this client leaves out sound `name` a server sent: under Legacy with its
+    /// sounds, the `entity.player.attack.*` family (strong, weak, crit, sweep, knockback,
+    /// nodamage), which 1.9 brought with the attack cooldown.
+    pub fn mutes_sound(&self, name: &str) -> bool {
+        let name = name.strip_prefix("minecraft:").unwrap_or(name);
+        self.legacy && self.sounds && name.starts_with("entity.player.attack.")
+    }
+    /// Whether this client leaves out particles of `ty` a server sent: under Legacy, the
+    /// sweep and the damage hearts, which 1.9 brought (1.8.9's hits show crits only).
+    pub fn hides_particle(&self, ty: crate::particles::ParticleType) -> bool {
+        use crate::particles::ParticleType as T;
+        self.legacy && matches!(ty, T::SweepAttack | T::DamageIndicator)
+    }
+}

 #[derive(Clone, Debug, PartialEq)]
 pub struct Pvp {
@@ -1687,6 +1707,18 @@ mod tests {
        assert_eq!(fresh.extras.pvp.tweaks.fire_lower, PRESET_FIRE_LOWER);
    }

+    #[test]
+    fn a_fixed_time_keeps_the_worlds_day() {
+        // Day 9 at 5000: the moon's phase (the day number) stays, the time of day is the chosen.
+        let world = 9 * 24000 + 5000;
+        assert_eq!(view_day_time(world, None), world);
+        assert_eq!(
+            view_day_time(world, Some(ViewTime::Midnight)),
+            9 * 24000 + 18000
+        );
+        assert_eq!(view_day_time(-100, Some(ViewTime::Noon)), -24000 + 6000);
+    }
+
    #[test]
    fn the_glint_colour_reaches_the_shaders_as_rgb_bytes() {
        let mut t = Tweaks::default();
@@ -1773,33 +1805,31 @@ mod tests {
        }
    }

-    /// Legacy leaves out what 1.9 added to a hit: its sounds only with the sounds option, the
-    /// sweep and hearts always; the indicator stays when kept. Modern changes nothing.
    #[test]
-    fn combat_feel_reaches_the_look() {
-        let mut pvp = Pvp::default();
-        assert_eq!(pvp.look(), Look::default(), "vanilla's look");
-        let strong = "minecraft:entity.player.attack.strong";
-        pvp.combat.legacy = true;
-        let look = pvp.look();
-        assert!(look.legacy_pose && look.hide_attack_particles && look.hide_attack_indicator);
-        assert!(!look.mutes_sound(strong), "only with the sounds option");
-        pvp.combat.sounds = true;
-        pvp.combat.indicator = true;
-        let look = pvp.look();
-        assert!(look.mutes_sound(strong) && !look.hide_attack_indicator);
-    }
-
-    #[test]
-    fn view_time_weather_and_sizes_reach_the_look() {
-        let mut pvp = Pvp::default();
-        pvp.tweaks.time = Some(ViewTime::Midnight);
-        pvp.tweaks.weather = Some(ViewWeather::Thunder);
-        pvp.tweaks.totem_size = 50;
-        pvp.tweaks.fire_lower = 40;
-        let look = pvp.look();
-        assert_eq!(look.day_time(9 * 24000 + 5000), 9 * 24000 + 18000);
-        assert_eq!(look.weather, Some((1.0, 1.0)));
-        assert_eq!((look.totem_scale, look.fire_lower), (0.5, 0.4));
+    fn legacy_leaves_out_what_1_9_added_to_a_hit() {
+        use crate::particles::ParticleType as T;
+        let modern = Combat::default();
+        let legacy = Combat {
+            legacy: true,
+            ..Combat::default()
+        };
+        let sounds = Combat {
+            sounds: true,
+            ..legacy
+        };
+        for name in [
+            "minecraft:entity.player.attack.strong",
+            "entity.player.attack.sweep",
+            "minecraft:entity.player.attack.nodamage",
+        ] {
+            assert!(sounds.mutes_sound(name), "{name}");
+            assert!(!legacy.mutes_sound(name), "only with the sounds option");
+            assert!(!modern.mutes_sound(name));
+        }
+        // 1.8.9 had the hurt sound: it stays.
+        assert!(!sounds.mutes_sound("minecraft:entity.player.hurt"));
+        assert!(legacy.hides_particle(T::SweepAttack) && legacy.hides_particle(T::DamageIndicator));
+        assert!(!legacy.hides_particle(T::Crit) && !legacy.hides_particle(T::EnchantedHit));
+        assert!(!modern.hides_particle(T::SweepAttack));
    }
 }
@@ -871,6 +871,8 @@ pub enum Opt {
    PadGameplayGuide,
    /// `options.modelPart.*`: one skin layer (index into `options_file::MODEL_PARTS`).
    ModelPart(usize),
+    /// A slider of a page a crate registered (`horizon_hooks::pages`): (page, row).
+    Page(usize, usize),
    /// 3D skin layers: the player's outer layer as extruded slabs.
    SkinLayers3d,
    MainHand,