Merge origin/main into split/cosmetics-settings

extras.rs: main dropped DiscordPresence, this branch dropped the cosmetics rows: both removals kept. layers.json: main dropped client-lib -> theme, this branch dropped client-render -> cosmetics: both removals kept. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Merge pull request #14291 from horizon-rust/split/cosmetics-fx
2026-11-10 02:21:33 -10:00 · 2026-11-09 23:51:45 +01:00 · 2026-11-09 23:37:32 +01:00 · 2026-11-09 23:37:28 +01:00 · 2026-11-09 23:37:24 +01:00 · 2026-11-09 23:32:09 +01:00
138 changed files with 8385 additions and 3351 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)
@@ -198,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).
@@ -1584,7 +1584,6 @@ dependencies = [
 "horizon-client-input",
 "horizon-command",
 "horizon-core",
- "horizon-cosmetics",
 "horizon-hdr",
 "horizon-hooks",
 "horizon-items",
@@ -1650,6 +1649,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"
@@ -1793,14 +1801,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"
@@ -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",
@@ -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";
@@ -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 = []

@@ -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")]
@@ -739,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]
@@ -70,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" }
@@ -109,17 +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", "horizon-extras"]
+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"]
-# Horizon's own parts (docs/forking.md, docs/layers.md): the features below, and the official
-# server in the list (`official_servers`).
-horizon-extras = ["discord"]
-# "Playing Horizon" on the player's Discord profile (`discord_presence`).
-discord = []
 # 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.
@@ -131,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).
@@ -9,7 +9,6 @@ description = "The client's world data, rendering and screens: chunks, meshing,
 [dependencies]
 # The settings stores of the crates above the engine (docs/layers.md, "Platform registries").
 horizon-hooks = { path = "../horizon-hooks" }
-horizon-cosmetics = { path = "../horizon-cosmetics" }
 # The GUI atlas's pixels, kept compressed once uploaded (hud.rs `pack_pixels`).
 lz4_flex = { version = "0.14", default-features = false, features = ["std", "safe-encode", "safe-decode", "checked-decode"] }
 horizon-assets = { path = "../horizon-assets" }
@@ -29,7 +28,6 @@ horizon-protocol = { path = "../horizon-protocol" }
 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"
@@ -85,5 +83,7 @@ horizon-extras = []
 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"] }
@@ -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!(
@@ -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();
@@ -2,7 +2,7 @@
 //! settings, kept in `horizon-extras.txt` next to `options.txt` so that file
 //! stays exactly vanilla's, and the logic behind them. Every extra is off by
 //! default; see `docs/extras.md`. Horizon's own switches outside the Extras page
-//! (No AI, Agent Control, Discord Rich Presence) are kept here too.
+//! (No AI, Agent Control) are kept here too.
 use std::{collections::VecDeque, fs, path::Path};

 pub const FILE: &str = "horizon-extras.txt";
@@ -145,8 +145,6 @@ pub struct Extras {
    /// F3+R and F3+E start/stop a repro recording and write its bundle (off by
    /// default: a recording copies the world).
    pub repro_keys: bool,
-    /// "Playing Horizon" on the player's Discord profile (`discord_presence`; on by default).
-    pub discord_presence: bool,
    /// Another controller can join P1's world (`splitscreen`, off by default).
    pub splitscreen: bool,
    /// Two players in one window: 0 auto (side by side when wider than tall), 1 side by side,
@@ -168,24 +166,6 @@ pub struct Extras {
    /// built-in track and leaving the off ones out (`musicPage`, off by
    /// default: vanilla plays exactly as before).
    pub music_page: bool,
-    /// Cosmetics (`horizon_cosmetics`, off unless enabled), the lines `horizon_cosmetics::prefs`
-    /// shares with the launcher's Wardrobe: Show my cosmetics (the account's, sent to the service;
-    /// on by default), how much of other players' to show (no line until chosen:
-    /// `effective_others`), and whether their trails and auras are hidden (off by default).
-    pub cosmetics_mine: bool,
-    pub cosmetics_others: Option<horizon_cosmetics::prefs::Others>,
-    pub cosmetics_hide_fx: bool,
-    /// My cosmetics in single player too (`cosmeticsSolo`, off by default): the window's own server
-    /// names the player by their offline profile, which the service doesn't know, so their own
-    /// cosmetics and name tag style show only with this on.
-    pub cosmetics_solo: bool,
-    /// Whether the signed-in account owns a cosmetic, as the service said (never saved; the game
-    /// sets it): with no choice made, others' cosmetics show only then.
-    pub cosmetics_owner: bool,
-    /// Horizon's mark before the names of other Horizon players (name tags, player list), and
-    /// whether the service may say this player plays Horizon: both on by default.
-    pub horizon_marks: bool,
-    pub horizon_listed: bool,
    /// 3D skin layers (`threeDSkinLayers`, Options → Skin Customization): each
    /// painted texel of a player's outer layer drawn as a slab
    /// (`horizon_client::mobs::skin_layers`).
@@ -233,7 +213,6 @@ impl Default for Extras {
            no_ai: false,
            agent_control: false,
            repro_keys: false,
-            discord_presence: true,
            splitscreen: false,
            splitscreen_two: 0,
            splitscreen_three: 0,
@@ -241,13 +220,6 @@ impl Default for Extras {
            wheel_cycles_settings: false,
            music_off: Vec::new(),
            music_page: false,
-            cosmetics_mine: true,
-            cosmetics_others: None,
-            cosmetics_hide_fx: false,
-            cosmetics_solo: false,
-            cosmetics_owner: false,
-            horizon_marks: true,
-            horizon_listed: true,
            three_d_skin_layers: false,
            pvp: Default::default(),
        }
@@ -257,11 +229,6 @@ fn bool_text(v: bool) -> &'static str {
    if v { "true" } else { "false" }
 }
 impl Extras {
-    /// How much of other players' cosmetics shows: the player's choice, else all of it for an
-    /// account that owns a cosmetic and none for any other (a vanilla game).
-    pub fn effective_others(&self) -> horizon_cosmetics::prefs::Others {
-        horizon_cosmetics::prefs::Others::effective(self.cosmetics_others, self.cosmetics_owner)
-    }
    pub fn load(dir: &Path) -> Self {
        fs::read_to_string(dir.join(FILE))
            .map(|t| Self::parse(&t))
@@ -338,7 +305,6 @@ impl Extras {
                horizon_core::no_ai::KEY => e.no_ai = flag(e.no_ai),
                "agentControl" => e.agent_control = flag(e.agent_control),
                "reproKeys" => e.repro_keys = flag(e.repro_keys),
-                "discordPresence" => e.discord_presence = flag(e.discord_presence),
                "splitscreen" => e.splitscreen = flag(e.splitscreen),
                "splitscreenTwo" => e.splitscreen_two = value.parse().unwrap_or(0).min(2),
                "splitscreenThree" => e.splitscreen_three = value.parse().unwrap_or(0).min(2),
@@ -357,15 +323,6 @@ impl Extras {
                        .collect()
                }
                "musicPage" => e.music_page = flag(e.music_page),
-                "cosmeticsMine" => e.cosmetics_mine = flag(e.cosmetics_mine),
-                "cosmeticsOthers" => {
-                    e.cosmetics_others =
-                        horizon_cosmetics::prefs::Others::parse(value).or(e.cosmetics_others)
-                }
-                "cosmeticsHideFx" => e.cosmetics_hide_fx = flag(e.cosmetics_hide_fx),
-                "cosmeticsSolo" => e.cosmetics_solo = flag(e.cosmetics_solo),
-                horizon_cosmetics::prefs::MARKS => e.horizon_marks = flag(e.horizon_marks),
-                horizon_cosmetics::prefs::LISTED => e.horizon_listed = flag(e.horizon_listed),
                SKIN_LAYERS_KEY => e.three_d_skin_layers = flag(e.three_d_skin_layers),
                key => {
                    e.pvp.parse_line(key, value);
@@ -376,7 +333,7 @@ impl Extras {
    }
    pub fn serialize(&self) -> String {
        let mut text = format!(
-            "packBrowser:{}\npregen:{}\nfullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nlodZoomDetail:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\nchatAnimation:{}\nchatIndicator:{}\n{}:{}\nagentControl:{}\nreproKeys:{}\ndiscordPresence:{}\nsplitscreen:{}\nsplitscreenTwo:{}\nsplitscreenThree:{}\nsplitscreenNames:{}\nwheelCyclesListSettings:{}\nmusicOff:{}\nmusicPage:{}\ncosmeticsMine:{}\n{}cosmeticsHideFx:{}\ncosmeticsSolo:{}\n{}:{}\n{}:{}\n{}:{}\n",
+            "packBrowser:{}\npregen:{}\nfullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nlodZoomDetail:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\nchatAnimation:{}\nchatIndicator:{}\n{}:{}\nagentControl:{}\nreproKeys:{}\nsplitscreen:{}\nsplitscreenTwo:{}\nsplitscreenThree:{}\nsplitscreenNames:{}\nwheelCyclesListSettings:{}\nmusicOff:{}\nmusicPage:{}\n{}:{}\n",
            bool_text(self.pack_browser),
            bool_text(self.pregen),
            bool_text(self.fullbright),
@@ -418,7 +375,6 @@ impl Extras {
            bool_text(self.no_ai),
            bool_text(self.agent_control),
            bool_text(self.repro_keys),
-            bool_text(self.discord_presence),
            bool_text(self.splitscreen),
            self.splitscreen_two,
            self.splitscreen_three,
@@ -426,16 +382,6 @@ impl Extras {
            bool_text(self.wheel_cycles_settings),
            self.music_off.join(","),
            bool_text(self.music_page),
-            bool_text(self.cosmetics_mine),
-            // Written once the player chose.
-            self.cosmetics_others
-                .map_or(String::new(), |o| format!("cosmeticsOthers:{}\n", o.name())),
-            bool_text(self.cosmetics_hide_fx),
-            bool_text(self.cosmetics_solo),
-            horizon_cosmetics::prefs::MARKS,
-            bool_text(self.horizon_marks),
-            horizon_cosmetics::prefs::LISTED,
-            bool_text(self.horizon_listed),
            SKIN_LAYERS_KEY,
            bool_text(self.three_d_skin_layers),
        );
@@ -613,8 +559,6 @@ pub enum Item {
    /// Not on the Extras page: Horizon Settings shows No AI, its AI Agent page Agent Control.
    NoAi,
    AgentControl,
-    /// On the Horizon Settings page.
-    DiscordPresence,
    /// On the AI Agent page, next to Agent Control: the F3 recording shortcuts.
    ReproKeys,
    /// On the Splitscreen settings page.
@@ -623,13 +567,6 @@ pub enum Item {
    /// The Select Resource Packs screen's Add button (Modrinth).
    PackBrowser,
    Pregen,
-    /// Shown only while cosmetics are enabled (`horizon_cosmetics::enabled`).
-    CosmeticsMine,
-    CosmeticsOthers,
-    CosmeticsHideFx,
-    CosmeticsSolo,
-    HorizonMarks,
-    HorizonMe,
    /// On the PvP & HUD page (`pvp::rows`).
    Pvp(crate::pvp::Opt),
 }
@@ -637,8 +574,10 @@ pub enum Item {
 pub fn rows() -> Vec<Result<Item, &'static str>> {
    use Item::*;
    // Fullbright, Dynamic lights and Hide block-break particles change the picture: they
-    // are on the graphics screen's Quality page (`graphics_ui::rows`), not here.
-    let mut rows = vec![
+    // are on the graphics screen's Quality page (`graphics_ui::rows`), not here. The Cosmetics
+    // group comes last, from the cosmetics' own section (`pages::Place::Extras`) while they are
+    // offered.
+    vec![
        Err("horizon.extras.header.third_person"),
        Ok(OwnNameTag),
        Err("horizon.extras.header.inventory"),
@@ -659,19 +598,7 @@ pub fn rows() -> Vec<Result<Item, &'static str>> {
        Err("horizon.extras.header.menus"),
        Ok(WheelCyclesSettings),
        Ok(PackBrowser),
-    ];
-    if horizon_cosmetics::enabled() {
-        rows.extend([
-            Err("horizon.extras.header.cosmetics"),
-            Ok(CosmeticsMine),
-            Ok(CosmeticsSolo),
-            Ok(CosmeticsOthers),
-            Ok(CosmeticsHideFx),
-            Ok(HorizonMarks),
-            Ok(HorizonMe),
-        ]);
-    }
-    rows
+    ]
 }
 impl Item {
    /// The language key of the caption (`horizon.*`, assets/horizon/lang).
@@ -691,19 +618,12 @@ impl Item {
            Item::NoAi => "horizon.extras.no_ai",
            Item::AgentControl => "horizon.extras.agent_control",
            Item::ReproKeys => "horizon.extras.repro_keys",
-            Item::DiscordPresence => "horizon.extras.discord_presence",
            Item::Splitscreen => "horizon.extras.splitscreen",
            Item::ChatAnimation => "horizon.extras.chat_animation",
            Item::ChatIndicator => "horizon.extras.chat_indicator",
            Item::WheelCyclesSettings => "horizon.extras.wheel_cycles_settings",
            Item::PackBrowser => "horizon.extras.pack_browser",
            Item::Pregen => "horizon.extras.pregen",
-            Item::CosmeticsMine => "horizon.extras.cosmetics_mine",
-            Item::CosmeticsOthers => "horizon.extras.cosmetics_others",
-            Item::CosmeticsHideFx => "horizon.extras.cosmetics_hide_fx",
-            Item::CosmeticsSolo => "horizon.extras.cosmetics_solo",
-            Item::HorizonMarks => "horizon.extras.horizon_marks",
-            Item::HorizonMe => "horizon.extras.horizon_me",
            Item::Pvp(o) => o.caption_key(),
        }
    }
@@ -724,19 +644,12 @@ impl Item {
            Item::NoAi => "horizon.extras.no_ai.tooltip",
            Item::AgentControl => "horizon.extras.agent_control.tooltip",
            Item::ReproKeys => "horizon.extras.repro_keys.tooltip",
-            Item::DiscordPresence => "horizon.extras.discord_presence.tooltip",
            Item::Splitscreen => "horizon.extras.splitscreen.tooltip",
            Item::ChatAnimation => "horizon.extras.chat_animation.tooltip",
            Item::ChatIndicator => "horizon.extras.chat_indicator.tooltip",
            Item::WheelCyclesSettings => "horizon.extras.wheel_cycles_list_settings.tooltip",
            Item::PackBrowser => "horizon.extras.pack_browser.tooltip",
            Item::Pregen => "horizon.extras.pregen.tooltip",
-            Item::CosmeticsMine => "horizon.extras.cosmetics_mine.tooltip",
-            Item::CosmeticsOthers => "horizon.extras.cosmetics_others.tooltip",
-            Item::CosmeticsHideFx => "horizon.extras.cosmetics_hide_fx.tooltip",
-            Item::CosmeticsSolo => "horizon.extras.cosmetics_solo.tooltip",
-            Item::HorizonMarks => "horizon.extras.horizon_marks.tooltip",
-            Item::HorizonMe => "horizon.extras.horizon_me.tooltip",
            Item::Pvp(o) => o.description_key(),
        }
    }
@@ -768,17 +681,10 @@ impl Item {
            Item::NoAi => "No AI",
            Item::AgentControl => "Agent Control",
            Item::ReproKeys => "Recording shortcuts",
-            Item::DiscordPresence => "Discord Rich Presence",
            Item::Splitscreen => "Splitscreen",
            Item::WheelCyclesSettings => "Scroll wheel changes settings",
            Item::PackBrowser => "Resource pack browser",
            Item::Pregen => "Chunk pregeneration",
-            Item::CosmeticsMine => "My cosmetics",
-            Item::CosmeticsOthers => "Other players' cosmetics",
-            Item::CosmeticsHideFx => "Hide other players' trails and auras",
-            Item::CosmeticsSolo => "In single player",
-            Item::HorizonMarks => "Horizon logos",
-            Item::HorizonMe => "Show me as Horizon",
            Item::Pvp(o) => o.caption(),
        }
    }
@@ -792,10 +698,8 @@ impl Item {
            ChatIndicator => ChatAnimation,
            Pvp(o) => return o.parent().map(Pvp),
            Fullbright | DynamicLights | OwnNameTag | HideBlockParticles | MouseTweaks | Sort
-            | AutoReconnect | NoAi | AgentControl | ReproKeys | DiscordPresence | Splitscreen
-            | ChatAnimation | WheelCyclesSettings | MusicPage | PackBrowser | CosmeticsMine
-            | CosmeticsOthers | CosmeticsHideFx | CosmeticsSolo | HorizonMarks | HorizonMe
-            | Pregen => {
+            | AutoReconnect | NoAi | AgentControl | ReproKeys | Splitscreen | ChatAnimation
+            | WheelCyclesSettings | MusicPage | PackBrowser | Pregen => {
                return None;
            }
        })
@@ -844,9 +748,6 @@ impl Item {
            Item::NoAi => {
                "Hides and turns off every AI feature: agent control, horizon-ctl and the MCP servers. The launcher's switch too."
            }
-            Item::DiscordPresence => {
-                "Shows Playing Horizon on your Discord profile while Discord runs: menus, single player or multiplayer, the dimension and the time played. Never a world's name or a server's address."
-            }
            Item::Splitscreen => {
                "In a world, another controller can join as a new player: press A when it asks, then pick a profile and where to play."
            }
@@ -856,24 +757,6 @@ impl Item {
            Item::ReproKeys => {
                "F3+R starts or stops a repro recording and F3+E writes its bundle. Off by default: a recording copies the world."
            }
-            Item::CosmeticsMine => {
-                "Hidden: every Horizon player sees you without your cosmetics, you included. The same switch as the launcher's Wardrobe."
-            }
-            Item::CosmeticsOthers => {
-                "What other Horizon players wear: everything, only their name tag styles, or nothing. Hidden unless you own cosmetics, until you choose. Hidden, the game never asks what they wear."
-            }
-            Item::CosmeticsHideFx => {
-                "Other players' trails and auras stay hidden; their other cosmetics still show. Off by default."
-            }
-            Item::CosmeticsSolo => {
-                "Show your cosmetics and your name tag's badge in your single-player worlds too (your name tag with Own name tag). Off: only on servers."
-            }
-            Item::HorizonMarks => {
-                "Show the Horizon logo next to Horizon players: a small logo before the names of other players who use Horizon, above their heads and in the player list. Only Horizon players see it: servers receive nothing."
-            }
-            Item::HorizonMe => {
-                "Show me as a Horizon player: other Horizon players see the logo by your name. On, the service answers anyone who asks about you that you played Horizon in the last 3 hours; off, it never reports you."
-            }
            Item::Pvp(o) => o.description(),
            Item::WheelCyclesSettings => {
                "The scroll wheel over a button in the settings changes its value, as in vanilla. Off, the wheel only scrolls the list."
@@ -900,12 +783,6 @@ impl Item {
            | Item::Splitscreen
            | Item::WheelCyclesSettings
            | Item::PackBrowser => Some(Cost::None),
-            Item::CosmeticsMine
-            | Item::CosmeticsOthers
-            | Item::CosmeticsHideFx
-            | Item::CosmeticsSolo
-            | Item::HorizonMarks
-            | Item::HorizonMe => Some(Cost::Low),
            _ => None,
        }
    }
@@ -927,15 +804,10 @@ impl Item {
            Item::NoAi => e.no_ai,
            Item::AgentControl => e.agent_control,
            Item::ReproKeys => e.repro_keys,
-            Item::DiscordPresence => e.discord_presence,
            Item::Splitscreen => e.splitscreen,
            Item::WheelCyclesSettings => e.wheel_cycles_settings,
            Item::PackBrowser => e.pack_browser,
            Item::Pregen => e.pregen,
-            Item::CosmeticsHideFx => e.cosmetics_hide_fx,
-            Item::CosmeticsSolo => e.cosmetics_solo,
-            Item::HorizonMarks => e.horizon_marks,
-            Item::HorizonMe => e.horizon_listed,
            Item::Pvp(o) => return o.switch(&e.pvp),
            _ => return None,
        })
@@ -945,30 +817,14 @@ impl Item {
        match self {
            Item::SortKey => crate::keybinds::display_name(&e.sort_key).plain(),
            Item::Pvp(o) if o.switch(&e.pvp).is_none() => o.value(&e.pvp).unwrap_or_default(),
-            Item::CosmeticsMine => match e.cosmetics_mine {
-                true => crate::lang::get_or("horizon.extras.cosmetics.shown", "Shown"),
-                false => crate::lang::get_or("horizon.extras.cosmetics.hidden", "Hidden"),
-            },
-            Item::CosmeticsOthers => {
-                use horizon_cosmetics::prefs::Others;
-                match e.effective_others() {
-                    Others::Shown => crate::lang::get_or("horizon.extras.cosmetics.shown", "Shown"),
-                    Others::NameTags => {
-                        crate::lang::get_or("horizon.extras.cosmetics.name_tags", "Name tags only")
-                    }
-                    Others::Hidden => {
-                        crate::lang::get_or("horizon.extras.cosmetics.hidden", "Hidden")
-                    }
-                }
-            }
            other => match other.switch(e) {
                Some(true) => crate::lang::get_or("On", "On"),
                _ => crate::lang::get_or("Off", "Off"),
            },
        }
    }
-    /// A click (`back` for the right button: it turns the three-way cosmetics button the other
-    /// way; every other item left is a switch, so both flip it). The sort key binds instead.
+    /// A click (`back` for the right button: a PvP & HUD choice steps back; a switch flips
+    /// either way). The sort key binds instead.
    pub fn cycle(self, e: &mut Extras, back: bool) {
        match self {
            Item::Fullbright => e.fullbright = !e.fullbright,
@@ -986,21 +842,10 @@ impl Item {
            Item::NoAi => e.no_ai = !e.no_ai,
            Item::AgentControl => e.agent_control = !e.agent_control,
            Item::ReproKeys => e.repro_keys = !e.repro_keys,
-            Item::DiscordPresence => e.discord_presence = !e.discord_presence,
            Item::Splitscreen => e.splitscreen = !e.splitscreen,
            Item::WheelCyclesSettings => e.wheel_cycles_settings = !e.wheel_cycles_settings,
            Item::PackBrowser => e.pack_browser = !e.pack_browser,
            Item::Pregen => e.pregen = !e.pregen,
-            Item::CosmeticsMine => e.cosmetics_mine = !e.cosmetics_mine,
-            Item::CosmeticsOthers => {
-                // From what the button shows; the result is the player's choice from now on.
-                let o = e.effective_others();
-                e.cosmetics_others = Some(if back { o.next().next() } else { o.next() });
-            }
-            Item::CosmeticsHideFx => e.cosmetics_hide_fx = !e.cosmetics_hide_fx,
-            Item::CosmeticsSolo => e.cosmetics_solo = !e.cosmetics_solo,
-            Item::HorizonMarks => e.horizon_marks = !e.horizon_marks,
-            Item::HorizonMe => e.horizon_listed = !e.horizon_listed,
            Item::Pvp(o) => o.cycle(&mut e.pvp, back),
            Item::SortKey => {}
        }
@@ -1019,73 +864,6 @@ impl Item {
 mod tests {
    use super::*;

-    #[test]
-    fn other_players_cosmetics_cycle_three_ways_and_read_the_old_switch() {
-        use horizon_cosmetics::prefs::Others;
-        let mut e = Extras {
-            cosmetics_owner: true,
-            ..Extras::default()
-        };
-        assert_eq!(
-            (e.effective_others(), e.cosmetics_hide_fx, e.cosmetics_mine),
-            (Others::Shown, false, true)
-        );
-        Item::CosmeticsOthers.cycle(&mut e, false);
-        assert_eq!(e.cosmetics_others, Some(Others::NameTags));
-        Item::CosmeticsOthers.cycle(&mut e, false);
-        assert_eq!(e.cosmetics_others, Some(Others::Hidden));
-        // The right button goes back.
-        Item::CosmeticsOthers.cycle(&mut e, true);
-        assert_eq!(e.cosmetics_others, Some(Others::NameTags));
-        // Ownership is the service's, never written.
-        assert_eq!(
-            Extras::parse(&e.serialize()),
-            Extras {
-                cosmetics_owner: false,
-                ..e.clone()
-            }
-        );
-        // The launcher's Wardrobe writes the same lines.
-        assert_eq!(
-            horizon_cosmetics::prefs::Prefs::parse(&e.serialize()).others,
-            Some(Others::NameTags)
-        );
-        // Before this, the line was on or off.
-        assert_eq!(
-            Extras::parse("cosmeticsOthers:false").cosmetics_others,
-            Some(Others::Hidden)
-        );
-    }
-
-    #[test]
-    fn others_cosmetics_are_off_for_a_player_who_owns_none_until_chosen() {
-        use horizon_cosmetics::prefs::Others;
-        let mut e = Extras::default();
-        // Nothing chosen, nothing owned: the button shows Hidden and no line is written.
-        assert_eq!(e.effective_others(), Others::Hidden);
-        assert_eq!(
-            Item::CosmeticsOthers.value(&e),
-            crate::lang::get_or("horizon.extras.cosmetics.hidden", "Hidden")
-        );
-        assert!(!e.serialize().contains("cosmeticsOthers"));
-        // The service says the account owns one: shown, still not a choice.
-        e.cosmetics_owner = true;
-        assert_eq!(e.effective_others(), Others::Shown);
-        assert!(!e.serialize().contains("cosmeticsOthers"));
-        // A non-owner pressing the button goes on from Hidden, and that choice is kept.
-        e.cosmetics_owner = false;
-        Item::CosmeticsOthers.cycle(&mut e, false);
-        assert_eq!(e.cosmetics_others, Some(Others::Shown));
-        let saved = Extras::parse(&e.serialize());
-        assert_eq!(saved.effective_others(), Others::Shown);
-        // An owner who chose Hidden keeps it.
-        let hidden = Extras {
-            cosmetics_owner: true,
-            ..Extras::parse("cosmeticsOthers:hidden\n")
-        };
-        assert_eq!(hidden.effective_others(), Others::Hidden);
-    }
-
    #[test]
    fn a_saved_wheel_setting_from_before_the_default_changed_is_dropped() {
        assert!(!Extras::parse("wheelCyclesSettings:true\n").wheel_cycles_settings);
@@ -1104,7 +882,7 @@ mod tests {
        assert!(!d.mouse_tweaks && !d.sort && !d.own_name_tag && !d.ui_sound_reserve);
        assert!(!d.hide_block_particles && !d.pregen);
        assert!(!d.music_page && d.music_off.is_empty());
-        assert!(d.discord_presence && !d.wheel_cycles_settings);
+        assert!(!d.wheel_cycles_settings);
        assert_eq!(Extras::parse(""), d);
        assert_eq!(Extras::parse(&d.serialize()), d);
        let mut e = d.clone();
@@ -1143,7 +921,6 @@ mod tests {
        e.sort_key = "key.keyboard.r".into();
        e.chat_animation = true;
        e.chat_indicator = false;
-        e.discord_presence = false;
        assert!(!e.splitscreen);
        Item::Splitscreen.cycle(&mut e, false);
        assert_eq!(Item::Splitscreen.switch(&e), Some(true));
@@ -112,7 +112,11 @@ fn add_sections(groups: &mut Vec<Group<ExtraRow>>) {
                    };
                    Row::new(id, lang::get(label), value)
                }
-                added::Row::Button { label } => Row::new(id, lang::get(label), Value::Press),
+                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))
@@ -202,14 +206,13 @@ impl Screen for ExtrasScreen {
    fn note_lines(&self) -> usize {
        NOTE_LINES
    }
-    /// The rows read the extras, the mods, whether cosmetics are offered and the sections' rows.
+    /// The rows read the extras, the mods and the sections' rows.
    fn stamp(&self, s: &Settings) -> u64 {
        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))
+        shell::stamp_of(&(&s.extras, &s.mods, added))
    }
    fn sheets(&self, s: &Settings) -> Vec<Sheet<(), ExtraRow>> {
        let mut groups = vec![Group {
@@ -317,22 +320,6 @@ mod tests {
        assert_ne!(s.extras.mouse_tweaks_wheel, before);
    }

-    #[test]
-    fn the_three_way_cosmetics_row_turns_both_ways() {
-        use horizon_cosmetics::prefs::Others;
-        let mut s = Settings::default();
-        let mut screen = ExtrasScreen;
-        let row = ExtraRow::Item(Item::CosmeticsOthers);
-        // Not chosen, nothing owned: it shows Hidden, and forward wraps to Shown.
-        assert_eq!(s.extras.effective_others(), Others::Hidden);
-        screen.press(&mut s, row, false);
-        assert_eq!(s.extras.cosmetics_others, Some(Others::Shown));
-        screen.press(&mut s, row, true);
-        assert_eq!(s.extras.cosmetics_others, Some(Others::Hidden));
-        screen.press(&mut s, row, true);
-        assert_eq!(s.extras.cosmetics_others, Some(Others::NameTags));
-    }
-
    /// The sort key binds instead of cycling; the wheel leaves it be.
    #[test]
    fn the_key_row_waits_for_a_key() {
@@ -490,9 +477,7 @@ mod tests {
            added::Place::HorizonSettings
        }
        fn rows(&self, rows: &mut Vec<added::Row>) {
-            rows.push(added::Row::Button {
-                label: "test.elsewhere.button",
-            });
+            rows.push(added::Row::button("test.elsewhere.button"));
        }
        fn act(&self, _: usize, _: Act) {}
    }
@@ -233,6 +233,8 @@ pub struct FogInputs<'a> {
    pub night_vision: f32,
    /// 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]
@@ -611,6 +632,38 @@ 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: crate::pack_palette::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,6 +237,7 @@ 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};
@@ -1084,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
@@ -1578,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,
@@ -5077,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,
@@ -5348,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,
@@ -7041,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`).
@@ -7975,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()));
@@ -8319,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;
        }
@@ -12044,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).
@@ -12664,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 {
@@ -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
@@ -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,
    }
 }

@@ -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();
+    }
+}
@@ -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);
 }
@@ -1110,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.");
@@ -1141,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();
@@ -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]
@@ -74,6 +74,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;
@@ -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)
+}
@@ -124,21 +124,15 @@ impl OptionsUi {
                Some(open("horizon.pages.open.studio", Page::Studio)),
            ),
            // No AI hides the AI Agent page and everything AI.
-            Row::Buttons(
-                self.extra_button(s, crate::extras::Item::DiscordPresence),
-                Some(if s.extras.no_ai {
-                    self.extra_button(s, crate::extras::Item::NoAi)
-                } else {
-                    open("horizon.pages.open.agent", Page::Agent)
-                }),
-            ),
-        ]
-        .into_iter()
-        .chain(
-            (!s.extras.no_ai)
-                .then(|| Row::Buttons(self.extra_button(s, crate::extras::Item::NoAi), None)),
-        )
-        .collect();
+            if s.extras.no_ai {
+                Row::Buttons(self.extra_button(s, crate::extras::Item::NoAi), None)
+            } else {
+                Row::Buttons(
+                    open("horizon.pages.open.agent", Page::Agent),
+                    Some(self.extra_button(s, crate::extras::Item::NoAi)),
+                )
+            },
+        ];
        self.added_entries(&mut rows);
        rows
    }
@@ -162,10 +156,38 @@ impl OptionsUi {
        };
        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 {
@@ -177,7 +199,10 @@ impl OptionsUi {
            added::Row::Toggle { label, on } => wide(generic(label, on_off(on))),
            added::Row::Cycle { label, value } => wide(generic(label, label_text(value))),
            added::Row::Slider { .. } => Row::Big(Opt::Page(page, r)),
-            added::Row::Button { label } => wide(tr(label)),
+            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)
@@ -461,4 +486,84 @@ mod tests {
            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"
+        );
+    }
 }
@@ -7,6 +7,14 @@ 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);
@@ -29,6 +37,10 @@ pub fn read(root: &Path) -> pack_palette::PackColors {
            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),
+        },
    }
 }

@@ -59,6 +59,24 @@ pub struct PackColors {
    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 {
@@ -72,6 +90,7 @@ impl Default for PackColors {
            entity_shadows: true,
            xp_bar: [None; 2],
            env: Environment::default(),
+            fluid_fog: FluidFogs::default(),
        }
    }
 }
@@ -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());
    }
 }
@@ -337,6 +337,13 @@ impl Settings {
            .and_then(|mode| self.video_modes.iter().position(|m| *m == mode))
            .map_or(-1, |i| i as i32)
    }
+    /// Loads only the crates' settings stores (`horizon_hooks::settings`) from the files next to
+    /// `path`, into the seat whose turn it is (`horizon_hooks::seat`): a splitscreen player whose
+    /// settings were made from P1's rather than loaded.
+    pub fn load_stores(path: &Path) {
+        let dir = path.parent();
+        horizon_hooks::settings::engine::load(&mut |file| fs::read_to_string(dir?.join(file)).ok());
+    }
    pub fn load(path: &Path) -> Self {
        let mut horizon = path
            .parent()
@@ -237,17 +237,17 @@ impl<P: Copy, S: Copy> Lines<P, S> {
 pub(crate) fn backdrop(batch: &mut HudBatch, atlas: &HudAtlas, in_world: bool) {
    let (w, h) = (batch.width, batch.height);
    ui::menu_background(batch, atlas, 0.0, 0.0, w, h, in_world);
-    style::fill(batch, atlas, [0.0, 0.0, w, h], style::VEIL);
+    style::fill(batch, atlas, [0.0, 0.0, w, h], style::veil());
 }

 /// The mark and the screen's name over the search field.
 pub(crate) fn mark(batch: &mut HudBatch, atlas: &HudAtlas, cols: &Columns, title: &str) {
    let (x, y) = (cols.side_x, cols.side_y);
-    style::fill(batch, atlas, [x, y + 2.0, 6.0, 6.0], style::ACCENT);
+    style::fill(batch, atlas, [x, y + 2.0, 6.0, 6.0], style::accent());
    let horizon = Text::literal("Horizon");
    batch.text_styled(atlas, &horizon, x + 10.0, y, style::WHITE, true);
    let title = Text::literal(title);
-    batch.text_styled(atlas, &title, x, y + 10.0, style::MUTED, true);
+    batch.text_styled(atlas, &title, x, y + 10.0, style::muted(), true);
 }

 /// A page in the page list: the open page on a plate with the accent's bar beside it, the
@@ -273,13 +273,13 @@ pub(crate) fn page_tab(
        crate::widgets::target_as(rect, crate::widgets::Kind::Tab(open));
    }
    if open {
-        style::fill(batch, atlas, rect, style::OPEN);
-        style::fill(batch, atlas, [px, py, 2.0, ph], style::ACCENT);
+        style::fill(batch, atlas, rect, style::open());
+        style::fill(batch, atlas, [px, py, 2.0, ph], style::accent());
    }
    let color = match (open || hover, has) {
        (true, _) => style::WHITE,
-        (false, true) => style::SOFT,
-        (false, false) => style::MUTED,
+        (false, true) => style::soft(),
+        (false, false) => style::muted(),
    };
    let ty = py + ((ph - 8.0) / 2.0).floor();
    let name = Text::literal(style::fit(atlas, name, pw - 12.0));
@@ -312,12 +312,12 @@ pub(crate) fn search_field(
    search.draw(batch, atlas, None);
    if search.value.is_empty() && !focused {
        let hint = Text::literal(search.message.clone());
-        batch.text_styled(atlas, &hint, x + 5.0, search.y, style::MUTED, true);
+        batch.text_styled(atlas, &hint, x + 5.0, search.y, style::muted(), true);
    }
    if !search.value.is_empty() {
        let hover = ui::hovered(cursor, clear[0], clear[1], clear[2], clear[3]);
        crate::widgets::widget_cursor(hover, true);
-        let color = if hover { style::WHITE } else { style::MUTED };
+        let color = if hover { style::WHITE } else { style::muted() };
        let cy = y + ((h - 8.0) / 2.0).floor();
        ui::centered_text(
            batch,
@@ -344,7 +344,7 @@ pub(crate) fn plate(batch: &mut HudBatch, atlas: &HudAtlas, cols: &Columns, head
        batch,
        atlas,
        [px + 8.0, py + 24.0, pw - 16.0, 1.0],
-        style::HEAD_RULE,
+        style::head_rule(),
    );
 }

@@ -383,9 +383,9 @@ pub(crate) fn list<P: Copy, S: Copy>(
        }
        let Some(setting) = line.setting else {
            let (name, color, dy) = match line.group {
-                Some(("", _)) => (page_name(line.page), style::MUTED, 3.0),
-                Some((name, _)) => (lang::get(name), style::MUTED, 3.0),
-                None => (page_name(line.page), style::ACCENT, 4.0),
+                Some(("", _)) => (page_name(line.page), style::muted(), 3.0),
+                Some((name, _)) => (lang::get(name), style::muted(), 3.0),
+                None => (page_name(line.page), style::accent(), 4.0),
            };
            let name = Text::literal(name);
            batch.text_styled(atlas, &name, cols.list_x + 2.0, y + dy, color, true);
@@ -393,7 +393,7 @@ pub(crate) fn list<P: Copy, S: Copy>(
        };
        if !after_name {
            let rule = [cols.list_x + 8.0, y, cols.list_w - 16.0, 1.0];
-            style::fill(batch, atlas, rule, style::ROW_RULE);
+            style::fill(batch, atlas, rule, style::row_rule());
        }
        row(batch, setting, y);
    }
@@ -404,7 +404,7 @@ pub(crate) fn list<P: Copy, S: Copy>(
            &none,
            cols.list_x + 2.0,
            cols.top + 4.0,
-            style::MUTED,
+            style::muted(),
            true,
        );
    }
@@ -499,7 +499,7 @@ pub(crate) fn row(batch: &mut HudBatch, atlas: &HudAtlas, cols: &Columns, y: f32
    let active = live && (hover || focused || held);
    if active {
        let lit = [rect[0] + 2.0, y + 1.0, rect[2] - 4.0, style::ROW - 2.0];
-        style::fill(batch, atlas, lit, style::HOVER);
+        style::fill(batch, atlas, lit, style::hover());
    }
    crate::widgets::widget_cursor(hover, live);
    // The control socket's widget tree, the narrator and a controller's focus.
@@ -523,8 +523,8 @@ pub(crate) fn row(batch: &mut HudBatch, atlas: &HudAtlas, cols: &Columns, y: f32
    if live {
        crate::widgets::target_as(rect, kind);
    }
-    let color = if live { style::WHITE } else { style::MUTED };
-    let soft = if live { style::SOFT } else { style::MUTED };
+    let color = if live { style::WHITE } else { style::muted() };
+    let soft = if live { style::soft() } else { style::muted() };
    let ty = y + ((style::ROW - 8.0) / 2.0).floor();
    let lit = live && (hover || held);
    let left = rect[0] + style::INSET;
@@ -611,7 +611,7 @@ fn lit(batch: &mut HudBatch, atlas: &HudAtlas, [x, y, w, _]: [f32; 4]) {
        batch,
        atlas,
        [x + 2.0, y + 1.0, w - 4.0, style::ROW - 2.0],
-        style::HOVER,
+        style::hover(),
    );
 }

@@ -644,7 +644,7 @@ fn read_row(
    let room = rect[2] - 2.0 * style::INSET - name_w - 8.0;
    let value = style::fit(atlas, value, room);
    let vx = rect[0] + rect[2] - style::INSET - atlas.font.width(&value);
-    batch.text_styled(atlas, &Text::literal(value), vx, ty, style::SOFT, true);
+    batch.text_styled(atlas, &Text::literal(value), vx, ty, style::soft(), true);
    if focused {
        style::ring(
            batch,
@@ -749,7 +749,7 @@ fn pad_row(batch: &mut HudBatch, atlas: &HudAtlas, cols: &Columns, y: f32, view:
        batch.text_styled(atlas, &yellow(close), right.ceil(), ty, style::WHITE, true);
    }
    let left = rect[0] + style::INSET;
-    let color = if live { style::WHITE } else { style::MUTED };
+    let color = if live { style::WHITE } else { style::muted() };
    let shown = Text::literal(style::fit(atlas, name, chip[0] - 6.0 - left));
    batch.text_styled(atlas, &shown, left, ty, color, true);
    if focused {
@@ -799,7 +799,7 @@ fn side_lines(
        ];
        crate::widgets::record(line, rect, false);
        let shown = Text::literal(style::fit(atlas, line, rect[2]));
-        batch.text_styled(atlas, &shown, rect[0], rect[1], style::MUTED, true);
+        batch.text_styled(atlas, &shown, rect[0], rect[1], style::muted(), true);
    }
 }
 /// A line under the page list: its inset, and its height.
@@ -881,7 +881,7 @@ fn heading(batch: &mut HudBatch, atlas: &HudAtlas, text: &str, [x, y, w, _]: [f3
    let rect = [x + SIDE_INSET, y + HEADING_Y, w - 2.0 * SIDE_INSET, 8.0];
    crate::widgets::record(text, rect, false);
    let shown = Text::literal(style::fit(atlas, text, rect[2]));
-    batch.text_styled(atlas, &shown, rect[0], rect[1], style::MUTED, true);
+    batch.text_styled(atlas, &shown, rect[0], rect[1], style::muted(), true);
 }

 /// Vanilla's scroller, inside the panel's right edge, sized as `ui::Scroll` drags it.
@@ -1896,8 +1896,8 @@ impl<S: Screen> Shell<S> {
            // The row's page is open: lit as the list's open page is.
            if list.lit == Some(*shown) {
                let row @ [x, y, _, h] = strip.area;
-                style::fill(batch, atlas, row, style::OPEN);
-                style::fill(batch, atlas, [x, y, 2.0, h], style::ACCENT);
+                style::fill(batch, atlas, row, style::open());
+                style::fill(batch, atlas, [x, y, 2.0, h], style::accent());
            }
            tabs::draw(batch, atlas, strip);
        }
@@ -2134,7 +2134,14 @@ impl<S: Screen> Shell<S> {
            crate::widgets::narratable(|| crate::widgets::Narratable::text(row.name.clone(), rect));
            let ty = y + ((style::ROW - 8.0) / 2.0).floor();
            let name = Text::literal(style::fit(atlas, &row.name, rect[2] - 2.0 * style::INSET));
-            batch.text_styled(atlas, &name, rect[0] + style::INSET, ty, style::MUTED, true);
+            batch.text_styled(
+                atlas,
+                &name,
+                rect[0] + style::INSET,
+                ty,
+                style::muted(),
+                true,
+            );
            return;
        }
        let over = |[x, y, w, h]: [f32; 4]| pointer.is_some_and(|at| ui::hovered(at, x, y, w, h));
@@ -2240,7 +2247,7 @@ impl<S: Screen> Shell<S> {
        // Labelled for the widget tree: what the strip says is what a test or an agent reads.
        crate::widgets::record(about, cols.dock, false);
        let color = if why.is_some() {
-            style::MUTED
+            style::muted()
        } else {
            style::GREY
        };
@@ -304,19 +304,19 @@ impl StudioUi {

                // Card background & highlight
                if is_selected {
-                    style::fill(batch, atlas, rect, style::OPEN);
+                    style::fill(batch, atlas, rect, style::open());
                } else if is_hovered {
-                    style::fill(batch, atlas, rect, style::HOVER);
+                    style::fill(batch, atlas, rect, style::hover());
                } else {
                    style::well(batch, atlas, rect);
                }

                let border_color = if is_selected {
-                    style::ACCENT
+                    style::accent()
                } else if is_hovered {
                    style::WHITE
                } else {
-                    style::ROW_RULE
+                    style::row_rule()
                };
                style::ring(batch, atlas, rect, border_color);

@@ -119,14 +119,11 @@ audio = ["horizon-client-render/audio", "horizon-client-lib/audio"]
 controllers = ["horizon-client-lib/controllers", "dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
 # Horizon's own extras over the vanilla game, for a fork that wants them out (docs/forking.md):
 # cosmetics and emotes, the "Horizon player" presence, the official server added to
-# the server list, the Horizon Settings and Mods pages, Discord and Play with Friends, and ray
-# tracing on request (`HORIZON_RAY_TRACING=1`). Players always get them; there is no switch. `grep -rn horizon-extras crates/` lists
+# the server list, the Horizon Settings and Mods pages and Play with Friends, and ray tracing on
+# request (`HORIZON_RAY_TRACING=1`). Players always get them; there is no switch. `grep -rn horizon-extras crates/` lists
 # every place it gates. Without it (`--no-default-features --features audio,controllers`) the
 # client is best effort: CI builds only the default.
-horizon-extras = ["horizon-client-lib/horizon-extras", "horizon-client-render/horizon-extras", "discord", "friends"]
-# Online extras a server or a port can leave out; the server build has none of them. "Playing Horizon"
-# on Discord (game/discord.rs).
-discord = ["horizon-client-lib/discord"]
+horizon-extras = ["horizon-client-render/horizon-extras", "friends"]
 # Play with Friends: sharing a world behind an invite code (game/friends.rs). Joining one is
 # horizon-friends' `game` side, which horizon-official registers (`horizon_hooks::tunnel`).
 friends = ["dep:horizon-friends"]
@@ -287,6 +287,7 @@
  "This feature is not yet available in Horizon.": "This feature is not yet available in Horizon.",
  "Your display or system doesn't offer HDR output.": "Your display or system doesn't offer HDR output.",
  "Turn HDR on to use it.": "Turn HDR on to use it.",
+  "The shader pack lights the world itself.": "The shader pack lights the world itself.",
  "Your GPU or graphics API doesn't support it.": "Your GPU or graphics API doesn't support it.",
  "Not with software rendering, which runs it on the CPU.": "Not with software rendering, which runs it on the CPU.",
  "Out of video memory: off until the next start.": "Out of video memory: off until the next start.",
@@ -17,8 +17,8 @@ pub use horizon_client_render::{
    containers, controller_ui, crash, custom_sky, datapack, dynamic_light, effects, environment,
    extras, fast_hash, fluid_render, fog, font, gfx, graphics, graphics_style, graphics_ui,
    hdr_calibration, hud, hud_kit, hud_layout, hud_overlays, inventory_effects, java_text,
-    jigsaw_block, json_folder, level_loading, light, lod, logging, menu_blur, mesher, minimap,
-    mipmap, mod_browser, mod_list, model_library, models, multiline_edit, native_emissive,
+    jigsaw_block, json_folder, level_loading, light, lod, logging, menu_blur, menu_style, mesher,
+    minimap, mipmap, mod_browser, mod_list, model_library, models, multiline_edit, native_emissive,
    options_file, options_fixes, options_ui, overlay, pack_browser, pack_formats, pack_hooks,
    pack_palette, pack_screen, packs, pad_cursor, pad_glyph, par, particles, poi_sections,
    polytone_creative_tabs, polytone_post, post_chain, potent_sulfur, preedit, providers, pvp,
@@ -58,8 +58,6 @@ pub mod debug_overlay;
 pub mod debugworld;
 pub mod dialog;
 pub mod dialog_screen;
-#[cfg(feature = "discord")]
-pub mod discord_presence;
 pub mod end_crystal;
 pub mod end_gateway;
 pub mod entities;
@@ -102,8 +100,6 @@ pub mod native_data;
 pub mod net;
 pub mod nether_portal;
 pub mod no_resources;
-#[cfg(feature = "horizon-extras")]
-pub mod official_servers;
 pub mod offline_name;
 pub mod old_world;
 pub mod osk;
@@ -13,6 +13,7 @@ pub fn main_with(mods: crate::mod_api::Mods) {
        log::warn!("Trait mods already installed; ignoring the second list");
    }
    horizon_threads::configure_allocator();
+    crate::horizon_look::give();
    // OptiFine's and Polytone's pack formats (platform, docs/layers.md), before any pack loads.
    horizon_client::pack_formats::install();
    // horizon-extras (docs/forking.md): without the feature, no Horizon Settings or Mods page.
@@ -23,8 +24,9 @@ pub fn main_with(mods: crate::mod_api::Mods) {
    horizon_client::telemetry::mark_start();
    // Opt-in telemetry keeps each crash report (docs/telemetry.md), whatever the mode.
    crash::on_report(horizon_client::telemetry::keep_crash);
-    // Crates above the engine registered their hooks before this (horizon-official's `main`);
-    // none registers after this point.
+    // Crates above the engine registered their hooks before this (horizon-official's `main`),
+    // then the Horizon parts still in this crate; none registers after this point.
+    game::player_hooks::register();
    horizon_hooks::engine::seal();
    horizon_client::spans::startup::init(std::time::Instant::now());
    horizon_client::spans::trace::start_from_env();
@@ -49,6 +49,7 @@ fn pack_files(world_tables: &Option<WorldTables>) -> horizon_world::loot::PackOv
    }
 }

+mod activity;
 mod advancements;
 mod advancements_screen;
 mod agent;
@@ -128,8 +129,6 @@ mod decorated_pot;
 mod dedicated;
 mod deflect;
 mod dialogs;
-#[cfg(feature = "discord")]
-mod discord;
 mod dispense_fixture;
 mod dispenser;
 mod dragon;
@@ -373,6 +372,7 @@ mod place_feature_tests;
 mod play_input;
 mod play_keys;
 mod player_equip;
+pub(crate) mod player_hooks;
 mod player_spawn;
 mod pointer_capture;
 #[cfg(test)]
@@ -402,6 +402,7 @@ mod remote_vehicles;
 mod render_control;
 mod render_settings;
 mod render_tick;
+mod replay;
 mod repro;
 mod resource_load;
 mod resource_loader;
@@ -1497,7 +1498,7 @@ impl LevelAccess for GameLevel<'_> {
            };
        }
        if let Some(signal) = books::lectern_signal(self.world, pos) {
-            return signal;
+            return signal * i32::from(books::has_book_state(self.registry, state));
        }
        if let Some(signal) =
            machines::shelf_signal(self.world, self.registry, state, pos, direction)
@@ -2882,19 +2883,9 @@ struct Game<'a> {
    /// The open connection joined from Realms: `ServerData.isRealm` for the friends
    /// service's presence status.
    realm_session: bool,
-    /// Active packet replay session (game/studio.rs).
-    pub(super) studio_replay: Option<horizon_client::studio::ReplayDriver>,
-    pub(super) studio_freecam: horizon_client::studio::StudioFreecam,
-    pub(super) studio_timeline: horizon_client::studio::TimelineUi,
-    pub(super) studio_topbar: horizon_client::studio::TopBarUi,
-    pub(super) studio_rmb_down: bool,
-    studio_camera_track_dirty: bool,
-    /// Camera perspective to restore after leaving replay playback.
-    studio_replay_previous_camera_type: Option<perspective::CameraType>,
-    /// Replay opened from the title screen owns the synthetic remote session.
-    studio_replay_standalone: bool,
-    last_replay_tick: Option<Instant>,
-    pub(super) studio_virtual_tick_ms: f32,
+    /// Replay playback (game/replay.rs), and Horizon Studio's editor on it (game/studio.rs).
+    pub(super) replay: replay::Replay,
+    pub(super) studio: studio::Studio,
    /// This world is open to the network (game/lan.rs).
    lan: Option<lan::LanHost>,
    /// Single player's server thread, which `remote` is connected to.
@@ -5942,8 +5933,7 @@ impl Game<'_> {
        // the sleep overlay, debug screen and open screens still draw.
        let spectator = self.spectator();
        let (wi, hi) = (w as i32, h as i32);
-        let in_studio = self.studio_replay.is_some();
-        let show_hud = !self.ui.hide_gui && !in_studio;
+        let show_hud = !self.ui.hide_gui && !self.replay.playing();
        // Hud.extractRenderState asks `Screen.isInGameUi` twice: such a screen
        // defers the subtitles over itself, and keeps them while F1 hides the
        // rest of the HUD.
@@ -6282,23 +6272,7 @@ impl Game<'_> {
            self.draw_sign_editor(&mut batch);
            self.draw_book(&mut batch);
        }
-        if !self.ui.hide_gui
-            && self.screen == Screen::Playing
-            && (self.studio_replay.is_some() || self.studio_freecam.active)
-        {
-            self.studio_topbar.render(
-                &mut batch,
-                &self.gui.atlas,
-                self.cursor,
-                self.studio_freecam.locked_to_path,
-            );
-            self.studio_timeline.render(
-                &mut batch,
-                &self.gui.atlas,
-                self.cursor,
-                &self.studio_freecam,
-            );
-        }
+        self.draw_studio_bars(&mut batch);
        if show_hud {
            self.draw_pad_guide(&mut batch, guide_from);
        }
@@ -6521,12 +6495,12 @@ impl Game<'_> {
    /// `Camera.setRotation`: the camera's orientation, turned round in
    /// third-person front view.
    pub(super) fn camera_orientation(&self) -> glam::Quat {
-        if self.studio_freecam.active {
+        if self.studio.flying() {
            return camera_rotation(
                perspective::CameraType::FirstPerson,
-                self.studio_freecam.yaw,
-                self.studio_freecam.pitch,
-            ) * glam::Quat::from_rotation_z(self.studio_freecam.roll.to_radians());
+                self.studio.freecam.yaw,
+                self.studio.freecam.pitch,
+            ) * glam::Quat::from_rotation_z(self.studio.freecam.roll.to_radians());
        }
        match self.posed_rotation {
            // The frame's camera, already turned round in front view.
@@ -6733,11 +6707,7 @@ impl Game<'_> {
        self.mark_player(out.len(), !self.own_body_in_view());
        let player_start = out.len();
        self.mark_motion(player_start, Self::MOTION_OWN_PLAYER);
-        let player_alpha = if self.studio_replay.is_some() {
-            (self.studio_virtual_tick_ms as f64 / 50.0).clamp(0.0, 1.0)
-        } else {
-            self.clock.camera_fraction()
-        };
+        let player_alpha = self.own_player_alpha();
        self.player_model_geometry(camera, player_alpha, &mut out);
        // A native pack's shadow pass alone gets the first-person model (no per-entity draws).
        if self.pack_ids.is_none() && !self.own_body_in_view() {
@@ -6746,8 +6716,8 @@ impl Game<'_> {
                .extend(out.drain(player_start..));
        }
        self.mark_motion(out.len(), 0);
-        // Companions in first person, trails and auras (game/cosmetics/fx.rs).
-        self.cosmetics_fx_geometry(camera, alpha, &mut out);
+        // What crates draw around players: first person, see-through (game/player_hooks.rs).
+        self.players_after_geometry(camera, alpha, &mut out);
        self.mark_entity(out.len(), "minecraft:evoker_fangs");
        self.fangs_geometry(camera, alpha, &mut out);
        self.block_item_display_geometry(camera, alpha, &mut out);
@@ -7466,7 +7436,6 @@ impl Game<'_> {
        self.spawn_phantoms();
        self.tick_advancements();
        self.tick_player_model();
-        self.tick_emotes();
        Ok(())
    }

@@ -9236,7 +9205,7 @@ impl Game<'_> {
        let camera_alpha = self.clock.camera_fraction();
        let vanilla = self.camera_view(camera_alpha as f32);
        let view = vanilla.map(|view| {
-            if self.shows_panorama() || self.studio_freecam.active {
+            if self.shows_panorama() || self.studio.flying() {
                view
            } else {
                self.native_camera_pose_now(camera_alpha as f32, view)
@@ -9414,14 +9383,7 @@ impl Game<'_> {
        // hitboxes (F3+G, F3+B).
        let mut lines = self.fishing_line(alpha, size);
        let mut g = self.debug_gizmos(alpha as f32, camera.to_array());
-        if self.studio_freecam.active || self.studio_replay.is_some() {
-            horizon_client::studio::render_camera_path(
-                &self.studio_freecam.track,
-                &mut g,
-                None,
-                100,
-            );
-        }
+        self.studio_camera_path(&mut g);
        lines.extend(g.lines);
        let on_top = g.on_top;
        pr.lap("pr_debug");
@@ -9443,7 +9405,7 @@ impl Game<'_> {
            Vec::new()
        };
        pr.lap("pr_native_visuals");
-        let view = if self.studio_freecam.active {
+        let view = if self.studio.flying() {
            glam::Mat4::from_quat(self.camera_orientation().conjugate())
        } else {
            horizon_client::camera::view_matrix(view_yaw, view_pitch)
@@ -9569,7 +9531,7 @@ impl Game<'_> {
        } else {
            self.fov_degrees(camera_alpha as f32, camera.to_array())
        };
-        let camera_effects = fov::camera_effects_enabled(title, self.studio_freecam.active);
+        let camera_effects = fov::camera_effects_enabled(title, self.studio.flying());
        let bob = if !camera_effects {
            glam::Mat4::IDENTITY
        } else {
@@ -10462,21 +10424,7 @@ impl Game<'_> {
                        let b = HudBatch::new([r.config.width, r.config.height]);
                        let previous = self.cursor;
                        self.cursor = (position.x as f32 / b.scale, position.y as f32 / b.scale);
-                        if self.screen == Screen::Playing
-                            && (self.studio_timeline.dragging_playhead
-                                || self.studio_timeline.dragging_keyframe.is_some())
-                        {
-                            let action = self.studio_timeline.handle_mouse_drag(
-                                self.cursor,
-                                b.width,
-                                &mut self.studio_freecam,
-                            );
-                            if matches!(
-                                action,
-                                horizon_client::studio::TimelineAction::KeyframeMoved
-                            ) {
-                                self.studio_camera_track_dirty = true;
-                            }
+                        if self.studio_mouse_dragged(b.width) {
                            return Ok(());
                        }
                        if self.screen_mouse_dragged(previous) {
@@ -10527,7 +10475,7 @@ impl Game<'_> {
                    }
                }
                WindowEvent::MouseWheel { .. }
-                    if self.screen == Screen::Playing && self.studio_replay.is_some() => {}
+                    if self.screen == Screen::Playing && self.replay.playing() => {}
                WindowEvent::MouseWheel { delta, .. } => {
                    let (raw_x, raw_y) = match delta {
                        MouseScrollDelta::LineDelta(x, y) => (f64::from(x), f64::from(y)),
@@ -10804,90 +10752,7 @@ impl Game<'_> {
                }
                WindowEvent::MouseInput { state, button, .. } => {
                    let pressed = state == ElementState::Pressed;
-                    if !pressed && button == MouseButton::Left {
-                        let action = self.studio_timeline.handle_mouse_up();
-                        if !matches!(action, horizon_client::studio::TimelineAction::None) {
-                            self.handle_studio_timeline_action(action);
-                        }
-                    }
-                    if (self.studio_freecam.active || self.studio_replay.is_some())
-                        && button == MouseButton::Right
-                    {
-                        if let Some(renderer) = &self.renderer {
-                            let batch =
-                                HudBatch::new([renderer.config.width, renderer.config.height]);
-                            if self.studio_timeline.visible
-                                && self.cursor.1 >= batch.height - self.studio_timeline.height()
-                            {
-                                if pressed
-                                    && let Some(index) = self.studio_timeline.keyframe_at_cursor(
-                                        self.cursor,
-                                        batch.width,
-                                        batch.height,
-                                        &self.studio_freecam,
-                                    )
-                                {
-                                    if index < self.studio_freecam.track.keyframes.len() {
-                                        self.studio_freecam.track.keyframes.remove(index);
-                                        self.studio_camera_track_dirty = true;
-                                    }
-                                    self.studio_timeline.selected_keyframe = None;
-                                }
-                                return Ok(());
-                            }
-                        }
-                        if pressed {
-                            self.studio_topbar.close_dropdown();
-                            self.studio_rmb_down = true;
-                            self.capture(true);
-                            return Ok(());
-                        } else if self.studio_rmb_down {
-                            self.studio_rmb_down = false;
-                            self.capture(false);
-                            return Ok(());
-                        }
-                    }
-                    if pressed
-                        && button == MouseButton::Left
-                        && self.screen == Screen::Playing
-                        && (self.studio_replay.is_some() || self.studio_freecam.active)
-                    {
-                        let size = self
-                            .renderer
-                            .as_ref()
-                            .map(|renderer| [renderer.config.width, renderer.config.height])
-                            .unwrap_or([1, 1]);
-                        let batch = HudBatch::new(size);
-                        let had_open_menu = self.studio_topbar.open_menu.is_some();
-                        let topbar_action = self.studio_topbar.handle_mouse_click(
-                            self.cursor,
-                            batch.width,
-                            batch.height,
-                        );
-                        if !matches!(topbar_action, horizon_client::studio::TopBarAction::None) {
-                            self.handle_studio_topbar_action(topbar_action);
-                            return Ok(());
-                        }
-                        if had_open_menu || self.cursor.1 <= self.studio_topbar.height {
-                            return Ok(());
-                        }
-                        if self.studio_timeline.visible {
-                            let action = self.studio_timeline.handle_mouse_down(
-                                self.cursor,
-                                batch.width,
-                                batch.height,
-                                &self.studio_freecam,
-                            );
-                            if !matches!(action, horizon_client::studio::TimelineAction::None) {
-                                self.handle_studio_timeline_action(action);
-                                return Ok(());
-                            }
-                            if self.cursor.1 >= batch.height - self.studio_timeline.height() {
-                                return Ok(());
-                            }
-                        }
-                    }
-                    if self.screen == Screen::Playing && self.studio_replay.is_some() {
+                    if self.studio_mouse_input(pressed, button) {
                        return Ok(());
                    }
                    if matches!(self.screen, Screen::Inventory | Screen::Creative)
@@ -11357,24 +11222,7 @@ impl Game<'_> {
                    let between = now.saturating_duration_since(self.frame_end);
                    self.frame_ticks = elapsed.as_secs_f32() * 20.0;
                    self.previous = now;
-                    if self.studio_freecam.active
-                        && self.screen == Screen::Playing
-                        && !self.dialog_open()
-                    {
-                        let held = |key| f64::from(u8::from(self.keys.raw(&key)));
-                        let forward = held(KeyCode::KeyW) - held(KeyCode::KeyS);
-                        let strafe = held(KeyCode::KeyD) - held(KeyCode::KeyA);
-                        let vertical =
-                            held(KeyCode::KeyE) - held(KeyCode::KeyQ) + held(KeyCode::Space);
-                        let fast = self.keys.raw(&KeyCode::ControlRight);
-                        self.studio_freecam.update_flight_motion(
-                            forward,
-                            strafe,
-                            vertical,
-                            fast,
-                            elapsed.as_secs_f64().min(0.1),
-                        );
-                    }
+                    self.studio_fly(elapsed);
                    // Arrow-key camera controls belong to gameplay; chat and
                    // other screens use the same keys for their own navigation.
                    if self.screen == Screen::Playing
@@ -11404,8 +11252,7 @@ impl Game<'_> {
                    self.heal_hold_latches();
                    // For the hooks above the engine (the "I'm playing" ping): said when it changes.
                    horizon_hooks::engine::published(self.is_published());
-                    #[cfg(feature = "discord")]
-                    self.update_discord_presence();
+                    self.report_activity();
                    let steps = self.clock.advance(elapsed);
                    for _ in 0..steps {
                        let started = Instant::now();
@@ -11559,17 +11406,18 @@ impl Game<'_> {
                        server.set_legacy_rules(self.settings.extras.pvp.combat.rules);
                    }
                    self.clock.end_frame(self.pause);
-                    let mut consumed = false;
+                    let saved = self
+                        .renderer
+                        .as_mut()
+                        .map(|r| std::mem::take(&mut r.saved_screenshots))
+                        .unwrap_or_default();
+                    for saved in saved {
+                        self.finish_screenshot(saved);
+                    }
                    let finished = self
                        .renderer
                        .as_mut()
                        .and_then(|r| r.screenshot_result.take());
-                    if let Some(result) = &finished
-                        && self.ui.screenshot_message.is_some()
-                    {
-                        self.finish_screenshot(result);
-                        consumed = true;
-                    }
                    if let Some(result) = &finished
                        && let Some(reply) = self.pending_screenshot.take()
                    {
@@ -11582,7 +11430,6 @@ impl Game<'_> {
                            }
                            .to_string(),
                        );
-                        consumed = true;
                    }
                    if let Some(result) =
                        self.renderer.as_mut().and_then(|r| r.capture_result.take())
@@ -11591,12 +11438,6 @@ impl Game<'_> {
                        let value = result.unwrap_or_else(|e| serde_json::json!({ "error": e }));
                        let _ = reply.send(value.to_string());
                    }
-                    // A result nobody asked for was the world icon's
-                    // (`tick_world_icon`): a failure tries again a second
-                    // later, as `tryTakeScreenshotIfNeeded` does.
-                    if !consumed && let Some(Err(error)) = finished {
-                        log::warn!("Horizon: couldn't save the world icon: {error}");
-                    }
                    if rendered {
                        self.frame_stats.record(elapsed.as_secs_f32() * 1000.0);
                        self.debug_charts.frame_times.log(elapsed.as_nanos() as i64);
@@ -12157,16 +11998,8 @@ impl<'a> Game<'a> {
            entity_attachments: Default::default(),
            remote: None,
            realm_session: false,
-            studio_replay: None,
-            studio_freecam: Default::default(),
-            studio_timeline: Default::default(),
-            studio_topbar: Default::default(),
-            studio_rmb_down: false,
-            studio_camera_track_dirty: false,
-            studio_replay_previous_camera_type: None,
-            studio_replay_standalone: false,
-            last_replay_tick: None,
-            studio_virtual_tick_ms: 0.0,
+            replay: Default::default(),
+            studio: Default::default(),
            lan: None,
            integrated: None,
            level_shapes: Default::default(),
@@ -12665,10 +12498,8 @@ pub fn run_with() -> Result<()> {
    // horizon-ctl drives: those start in a source checkout and wrote the list there.
    if !options.offscreen && !synchronous_startup(&options) {
        let version = horizon_client::telemetry::version();
-        horizon_hooks::engine::started(&horizon_hooks::Started::new(&version));
-        // horizon-extras: the official server is Horizon's (docs/forking.md).
-        #[cfg(feature = "horizon-extras")]
-        horizon_client::official_servers::update(&horizon_client::logging::player_dir());
+        let game_dir = horizon_client::logging::player_dir();
+        horizon_hooks::engine::started(&horizon_hooks::Started::new(&version, &game_dir));
    }
    mods::register_components(&vanilla_root)?;
    mods::register_standalone_models();
@@ -12696,15 +12527,8 @@ pub fn run_with() -> Result<()> {
    if options.execution_role.is_client() {
        narrator::start(&early_settings);
    }
-    // "Playing Horizon" on Discord: never for a server; an automated run only talks to a test's fake Discord.
-    #[cfg(feature = "discord")]
-    if options.dedicated.is_none() {
-        let automated = options.benchmark.is_some()
-            || options.offscreen
-            || options.frames.is_some()
-            || options.world_frames.is_some();
-        horizon_client::discord_presence::start(early_settings.extras.discord_presence, automated);
-    }
+    // A game window's hooks (Discord's presence): never for a server.
+    activity::client_started(&options);
    // Snapshots of derived tables live in the game folder, never beside the
    // shared resources.
    Behaviours::set_cache_dir(std::env::current_dir()?.join(".horizon-cache"));
@@ -0,0 +1,68 @@
+//! What the player is doing, for the hooks above the engine (`Hooks::activity`: the Horizon
+//! layer's Discord presence shows it).
+use super::*;
+use horizon_client::command::args::GameMode;
+use horizon_hooks::{Activity, Client, Dimension, Play};
+
+/// At startup, for a game window (never a dedicated server's): the player's first activity, then
+/// `Hooks::client_started`.
+pub(super) fn client_started(options: &Options) {
+    if options.dedicated.is_some() {
+        return;
+    }
+    let automated = options.benchmark.is_some()
+        || options.offscreen
+        || options.frames.is_some()
+        || options.world_frames.is_some();
+    horizon_hooks::engine::activity(Activity::Menus);
+    horizon_hooks::engine::client_started(&Client::new(automated));
+}
+
+impl Game<'_> {
+    /// Each frame: only a change reaches the hooks.
+    pub(super) fn report_activity(&self) {
+        // One status per computer: P1's, not a splitscreen player's.
+        if self.options.split_guest {
+            return;
+        }
+        horizon_hooks::engine::activity(self.activity());
+    }
+    fn activity(&self) -> Activity {
+        if self.title.is_some() {
+            return Activity::Menus;
+        }
+        let max = horizon_client::lan::MAX_PLAYERS;
+        let play = if let Some(host) = &self.lan {
+            Play::Hosting {
+                players: 1 + host.hub.guests.len(),
+                max,
+            }
+        } else if let Some(server) = &self.integrated {
+            match (server.published(), &self.remote) {
+                (Some(_), Some(remote)) => Play::Hosting {
+                    players: remote.player_count(),
+                    max,
+                },
+                _ => Play::Singleplayer,
+            }
+        } else if self.remote.is_some() {
+            Play::Multiplayer
+        } else {
+            Play::Singleplayer
+        };
+        Activity::World {
+            play,
+            dimension: match self.dim {
+                Dim::Overworld => Dimension::Overworld,
+                Dim::Nether => Dimension::Nether,
+                Dim::End => Dimension::End,
+            },
+            mode: match self.mode {
+                GameMode::Survival => horizon_hooks::GameMode::Survival,
+                GameMode::Creative => horizon_hooks::GameMode::Creative,
+                GameMode::Adventure => horizon_hooks::GameMode::Adventure,
+                GameMode::Spectator => horizon_hooks::GameMode::Spectator,
+            },
+        }
+    }
+}
@@ -848,34 +848,20 @@ impl Game<'_> {
            self.armor_stands[i].last_hit = time;
            return true;
        }
-        // brokenByPlayer: the stand item, then brokenByAnything: the equipment.
-        let a = self.armor_stands.remove(i);
-        let (width, height) = stand_box(&a);
-        self.audio
-            .play("minecraft:entity.armor_stand.break", Some(at), 1.0, 1.0);
-        self.show_breaking_particles(at, f64::from(width), f64::from(height));
-        let center = [at[0], at[1] + if a.small { 0.4875 } else { 0.9875 }, at[2]];
-        let stand = ItemStack {
-            item: Arc::from("minecraft:armor_stand"),
-            count: 1,
-            damage: 0,
-            extra: None,
-        };
-        self.spawn_item(stand, center, [0.0; 3], 10);
-        for stack in a.equipment.into_iter().flatten() {
-            let r = &mut self.world.random;
-            let v = [
-                f64::from(r.next_float()) * 0.2 - 0.1,
-                0.2,
-                f64::from(r.next_float()) * 0.2 - 0.1,
-            ];
-            self.spawn_item(stack, center, v, 10);
+        // brokenByPlayer: the stand item, with the stand's name, pops at its
+        // block, then brokenByAnything: the loot table and the equipment.
+        let (width, height) = stand_box(&self.armor_stands[i]);
+        let p = self.armor_stands[i].position;
+        let pos = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
+        let mut stand = ItemStack::new("minecraft:armor_stand", 1);
+        if let Some(name) = &self.armor_stands[i].custom_name {
+            stand.data_mut().custom_name =
+                Some(horizon_client::scoreboard::component_tag(&name.component()));
        }
+        self.pop_resource(pos, stand);
        // ArmorStand.kill(level, the causing entity), after the drops.
-        self.stand_game_event("minecraft:entity_die", at, by);
-        self.world
-            .modified
-            .insert(((at[0].floor() as i32) >> 4, (at[2].floor() as i32) >> 4));
+        self.break_armor_stand_with_source(i, by);
+        self.show_breaking_particles(at, f64::from(width), f64::from(height));
        true
    }
    /// `Entity.gameEvent(event, attributedTo)` for a stand at `at`: the
@@ -1202,6 +1188,8 @@ impl Game<'_> {
        let a = self.armor_stands.remove(i);
        let at = [a.position.x, a.position.y, a.position.z];
        let a_id = a.id;
+        self.audio
+            .play("minecraft:entity.armor_stand.break", Some(at), 1.0, 1.0);
        // brokenByAnything's dropAllDeathLoot, before the equipment.
        if !a.small && self.ui.rules.bool("mob_drops") {
            self.armor_stand_death_loot(at, a.fire_ticks > 0);
@@ -1210,8 +1198,6 @@ impl Game<'_> {
        for stack in drops {
            self.pop_resource(pos, stack);
        }
-        self.audio
-            .play("minecraft:entity.armor_stand.break", Some(at), 1.0, 1.0);
        self.entity_killed_event_by(at, source.or(Some(super::commands::Target::Stand(a_id))));
        self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
    }
@@ -1292,10 +1278,21 @@ impl Game<'_> {
            .raw
            .get(&id)
            .is_some_and(|tag| horizon_client::entity_nbt::flag(tag, "Invulnerable"));
+        // Entity.isInvulnerableTo: the flag, then EnchantmentHelper.isImmuneToDamage.
        let a = &self.armor_stands[i];
-        if (invulnerable && !creative) || a.invisible || a.marker {
+        if (invulnerable && !creative)
+            || a.invisible
+            || a.marker
+            || self.stand_immune_to_damage(i, damage_type, causing)
+        {
            return false;
        }
+        // ArmorStand.hurtServer attributes its game events to the source
+        // entity: the player, a LAN guest or the mob.
+        let by = match causing {
+            Some(Target::Player | Target::Guest(_) | Target::Mob(_)) => causing,
+            _ => None,
+        };
        let (explosion, ignites, burns) = (
            tagged("minecraft:is_explosion"),
            tagged("minecraft:ignites_armor_stands"),
@@ -1306,21 +1303,26 @@ impl Game<'_> {
            tagged("minecraft:always_kills_armor_stands"),
        );
        if explosion {
-            self.break_armor_stand_by_anything(i);
+            self.break_armor_stand_with_source(i, by);
            return false;
        }
        if ignites {
            if self.armor_stands[i].fire_ticks > 0 {
-                self.cause_stand_damage(i, 0.15);
+                self.cause_stand_damage(i, 0.15, by);
            } else {
-                // igniteForSeconds(5.0f): at least 100 ticks.
+                // igniteForSeconds(5.0f): at least 100 ticks, and
+                // Entity.igniteForTicks calls clearFreeze.
                let a = &mut self.armor_stands[i];
                a.fire_ticks = a.fire_ticks.max(100);
+                if let Some(horizon_world::nbt::Tag::Compound(map)) = self.persist.raw.get_mut(&id)
+                {
+                    map.remove(&"TicksFrozen".into());
+                }
            }
            return false;
        }
        if burns && self.armor_stands[i].health > 0.5 {
-            self.cause_stand_damage(i, 4.0);
+            self.cause_stand_damage(i, 4.0, by);
            return false;
        }
        if !breaks && !always_kills {
@@ -1335,22 +1337,85 @@ impl Game<'_> {
        if !may_build {
            return false;
        }
-        // ArmorStand.hurtServer attributes its game events to the source
-        // entity: the player, a LAN guest or the mob.
-        let by = match causing {
-            Some(Target::Player | Target::Guest(_) | Target::Mob(_)) => causing,
-            _ => None,
-        };
        self.break_armor_stand_by_hit(i, creative, always_kills, by)
    }
+    /// `EnchantmentHelper.isImmuneToDamage` for the stand at `i`: whether an
+    /// enchantment on an active equipment slot has a `minecraft:damage_immunity`
+    /// effect whose requirements hold for `damage_type` and `causing`.
+    fn stand_immune_to_damage(
+        &mut self,
+        i: usize,
+        damage_type: &str,
+        causing: Option<super::commands::Target>,
+    ) -> bool {
+        use super::commands::Target;
+        let mut checks = Vec::new();
+        let equipment = &self.armor_stands[i].equipment;
+        for (stack, slot) in equipment.iter().zip(ArmorStand::SLOTS) {
+            let Some(stack) = stack else { continue };
+            let armor = matches!(slot, "head" | "chest" | "legs" | "feet");
+            let hand = matches!(slot, "mainhand" | "offhand");
+            for (id, level) in stack.enchantments() {
+                let Some(def) = self.res.stations().enchantments.get(id) else {
+                    continue;
+                };
+                if !def.slots.iter().any(|s| {
+                    s == slot || s == "any" || (s == "armor" && armor) || (s == "hand" && hand)
+                }) {
+                    continue;
+                }
+                let immunity = &def.effects["minecraft:damage_immunity"];
+                for entry in immunity.as_array().into_iter().flatten() {
+                    checks.push((entry.get("requirements").cloned(), *level));
+                }
+            }
+        }
+        if checks.is_empty() {
+            return false;
+        }
+        let attacker = match causing {
+            Some(Target::Player | Target::Guest(_)) => Some("minecraft:player".to_owned()),
+            Some(Target::Mob(m_id)) => self
+                .mobs
+                .iter()
+                .find(|m| m.id == m_id)
+                .map(|m| m.kind.id.clone()),
+            Some(Target::Stand(_)) => Some("minecraft:armor_stand".to_owned()),
+            _ => None,
+        };
+        let canonical = if damage_type.contains(':') {
+            damage_type.to_owned()
+        } else {
+            format!("minecraft:{damage_type}")
+        };
+        let ctx = horizon_client::enchant::EffectContext {
+            items: Some(self.res.items()),
+            damage_type: Some(&canonical),
+            is_direct: attacker.is_some(),
+            this: Some("minecraft:armor_stand"),
+            attacker: attacker.as_deref(),
+            direct_attacker: attacker.as_deref(),
+            ..Default::default()
+        };
+        let ench = &self.res.stations().enchantments;
+        let rng = &mut self.world.random;
+        for (req, level) in checks {
+            if req.is_none_or(|r| ench.condition(&r, level, &ctx, rng)) {
+                return true;
+            }
+        }
+        false
+    }
    /// `ArmorStand.causeDamage`: the health less `amount`, broken by anything
-    /// at 0.5 or less.
-    fn cause_stand_damage(&mut self, i: usize, amount: f32) {
+    /// at 0.5 or less, else `gameEvent(ENTITY_DAMAGE, damageSource.getEntity())`.
+    fn cause_stand_damage(&mut self, i: usize, amount: f32, by: Option<super::commands::Target>) {
        let health = self.armor_stands[i].health - amount;
        if health <= 0.5 {
-            self.break_armor_stand_by_anything(i);
+            self.break_armor_stand_with_source(i, by);
        } else {
+            let at = self.armor_stands[i].position;
            self.armor_stands[i].health = health;
+            self.stand_game_event("minecraft:entity_damage", [at.x, at.y, at.z], by);
        }
    }
    /// ArmorStandRenderer: the stand with its default pose, then armor layers.
@@ -42,12 +42,25 @@ impl Game<'_> {
        self.trial_spawner_tick_positions.clear();
        self.item_columns = Some(Default::default());
        self.pass_mobs = Some(Default::default());
-        for slot in self.world.block_entity_tickers().iter().copied() {
+        let tickers = self.world.block_entity_tickers();
+        let mut last_chunk = (i32::MIN, i32::MIN);
+        let mut last_chunk_ticking = false;
+        for slot in tickers.iter().copied() {
            let pos = slot.0;
+            let chunk = (pos.0 >> 4, pos.2 >> 4);
+            let chunk_ticking = if chunk == last_chunk {
+                last_chunk_ticking
+            } else {
+                last_chunk = chunk;
+                last_chunk_ticking = ticking(pos.0, pos.2);
+                last_chunk_ticking
+            };
+            if !chunk_ticking {
+                continue;
+            }
            // Ticks before this one can remove it (`TickingBlockEntity.isRemoved`).
            if self.world.block_entities.is_asleep(&pos)
                || !self.world.block_entities.is_live(slot)
-                || !ticking(pos.0, pos.2)
                || !self.border.contains(f64::from(pos.0), f64::from(pos.2))
            {
                continue;
@@ -210,8 +223,14 @@ impl Game<'_> {
    /// (`ServerLevel.areEntitiesLoaded`).
    pub(super) fn block_ticking_area(&self) -> impl Fn(i32, i32) -> bool + use<> {
        let levels = self.tickets.levels();
-        let pending = self.world.entities_pending.clone();
-        move |x, z| levels.block_ticking_at(x, z) && !pending.contains(&(x >> 4, z >> 4))
+        let has_pending = !self.world.entities_pending.is_empty();
+        let pending = has_pending.then(|| self.world.entities_pending.clone());
+        move |x, z| {
+            levels.block_ticking_at(x, z)
+                && pending
+                    .as_ref()
+                    .is_none_or(|p| !p.contains(&(x >> 4, z >> 4)))
+        }
    }
    /// `DaylightDetectorBlock.tickEntity` of the detector at `pos`.
    fn tick_daylight_detector(&mut self, pos: Pos) {
@@ -1608,6 +1608,16 @@ impl Game<'_> {
        }
    }
 }
+/// `LecternBlock.getAnalogOutputSignal`'s `HAS_BOOK` check.
+pub(super) fn has_book_state(
+    registry: &'static horizon_world::registry::BlockRegistry,
+    state: horizon_world::registry::BlockStateId,
+) -> bool {
+    registry
+        .state(state)
+        .is_some_and(|s| s.properties.get("has_book").is_some_and(|v| v == "true"))
+}
+
 /// `LecternBlockEntity.getRedstoneSignal`.
 pub(super) fn lectern_signal(world: &horizon_client::world::World, pos: BlockPos) -> Option<i32> {
    match world.block_entities.get(&(pos.x, pos.y, pos.z)) {
@@ -1721,6 +1731,7 @@ mod lectern_signal_tests {
        items::ItemStack,
    };
    use horizon_core::position::BlockPos;
+    use horizon_world::level::LevelAccess;
    use horizon_world::registry::BlockStateId;

    fn signal(game: &mut super::Game<'_>, book: Option<ItemStack>, page: i32) -> i32 {
@@ -1738,6 +1749,55 @@ mod lectern_signal_tests {
        lectern_signal(&game.world, BlockPos::new(key.0, key.1, key.2)).unwrap()
    }

+    /// `LecternBlock.getAnalogOutputSignal` reads the block entity only while
+    /// the state's `HAS_BOOK` is true.
+    #[test]
+    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+    fn a_lectern_without_the_has_book_state_feeds_no_comparator() {
+        let mut game = server_game();
+        let key = (8, 64, 8);
+        let state = game
+            .pack
+            .assets
+            .registry
+            .default_state("minecraft:lectern")
+            .unwrap();
+        game.world.set(key.0, key.1, key.2, state).unwrap();
+        game.world.block_entities.insert(
+            key,
+            BlockEntity::Lectern(Lectern {
+                book: Some(ItemStack::new("minecraft:writable_book", 1)),
+                page: 0,
+            }),
+        );
+        let signal = |game: &mut super::Game<'_>, state| {
+            game.with_level(|_, level, _| {
+                level.block_entity_analog_signal(
+                    BlockPos::new(key.0, key.1, key.2),
+                    state,
+                    horizon_core::geometry::Direction::North,
+                )
+            })
+        };
+        assert_eq!(
+            signal(&mut game, state),
+            0,
+            "the block state says the lectern holds no book"
+        );
+        let registry = game.pack.assets.registry;
+        let mut with_book = registry.state(state).unwrap().clone();
+        with_book
+            .properties
+            .insert("has_book".into(), "true".into());
+        let with_book = registry.id(&with_book).unwrap();
+        game.world.set(key.0, key.1, key.2, with_book).unwrap();
+        assert_eq!(
+            signal(&mut game, with_book),
+            15,
+            "with HAS_BOOK the book's page signal"
+        );
+    }
+
    /// `LecternBlockEntity.getRedstoneSignal`: `floor(page / (pageCount - 1)
    /// * 14) + (hasBook() ? 1 : 0)`. `hasBook()` asks for a book-content
    /// component, so a stack that only sits in the lectern (a non-book item a
@@ -255,8 +255,8 @@ pub struct UiState {
    /// What this frame's HUD shows that Horizon's overlays keep clear of (`Game::hud_room`),
    /// set by `hud_layers` before anything draws.
    pub room: horizon_client::hud_kit::room::Room,
-    /// Path of an F2 screenshot waiting for its frame.
-    pub screenshot_message: Option<std::path::PathBuf>,
+    /// F2 screenshots not written yet: each reports in chat once its PNG is.
+    pub screenshot_messages: Vec<std::path::PathBuf>,
    /// The options screens.
    pub options: horizon_client::options_ui::OptionsUi,
    /// The prepared resources before resource packs are layered on.
@@ -1982,15 +1982,17 @@ impl Game<'_> {
        if std::fs::create_dir_all(&dir).is_err() {
            return None;
        }
-        let name = screenshot_name(&dir);
+        // A screenshot still being written has no file yet: its name is taken all the same.
+        let name = screenshot_name(&dir, &self.ui.screenshot_messages);
        let renderer = self.renderer.as_mut()?;
        let path = dir.join(name);
        renderer.screenshot = Some(horizon_client::gfx::ScreenshotRequest {
            path: path.clone(),
            size: None,
            scaled: true,
+            background: true,
        });
-        self.ui.screenshot_message = Some(path.clone());
+        self.ui.screenshot_messages.push(path.clone());
        Some(path)
    }
    /// `Minecraft.handleGlobalKeyPress`'s screenshot branch: the
@@ -2014,12 +2016,23 @@ impl Game<'_> {
        self.take_screenshot();
        true
    }
-    /// After a frame: report a finished F2 screenshot in chat.
-    pub(super) fn finish_screenshot(&mut self, result: &std::result::Result<[u32; 2], String>) {
-        let Some(path) = self.ui.screenshot_message.take() else {
+    /// A screenshot written on its thread: F2's reports in chat. Any other was the world
+    /// icon's (`tick_world_icon`): a failure tries again a second later, as
+    /// `tryTakeScreenshotIfNeeded` does.
+    pub(super) fn finish_screenshot(&mut self, saved: horizon_client::gfx::SavedScreenshot) {
+        let Some(at) = self
+            .ui
+            .screenshot_messages
+            .iter()
+            .position(|p| *p == saved.path)
+        else {
+            if let Err(error) = saved.result {
+                log::warn!("Horizon: couldn't save the world icon: {error}");
+            }
            return;
        };
-        let message = match result {
+        let path = self.ui.screenshot_messages.remove(at);
+        let message = match &saved.result {
            Ok(_) => {
                log::info!("Saved screenshot to {}", path.display());
                let name = path.file_name().unwrap_or_default().to_string_lossy();
@@ -2055,7 +2068,7 @@ fn chat_box_text(text: &str) -> String {
        .filter(|&ch| ch >= ' ' && ch != '\u{7f}' && ch != '§')
        .collect()
 }
-pub fn screenshot_name(dir: &std::path::Path) -> String {
+pub fn screenshot_name(dir: &std::path::Path, pending: &[std::path::PathBuf]) -> String {
    // Util.getFilenameFormattedDateTime: the local date and time.
    let base = chrono::Local::now().format("%Y-%m-%d_%H.%M.%S").to_string();
    let mut n = 1;
@@ -2065,7 +2078,8 @@ pub fn screenshot_name(dir: &std::path::Path) -> String {
        } else {
            format!("{base}_{n}.png")
        };
-        if !dir.join(&name).exists() {
+        let path = dir.join(&name);
+        if !path.exists() && !pending.contains(&path) {
            return name;
        }
        n += 1;
@@ -2107,6 +2121,25 @@ mod tests {
        assert!(should_discard_draft(ChatExit::Done, true));
    }

+    /// `Screenshot.getFile` picks the first free name of the second; an F2
+    /// screenshot still being written on its thread has no file yet, so a
+    /// second press in the same second takes the next name, not the same one.
+    #[test]
+    fn a_screenshot_being_written_keeps_its_name() {
+        let dir = std::env::temp_dir().join(format!("horizon-shots-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let first = screenshot_name(&dir, &[]);
+        let second = screenshot_name(&dir, &[dir.join(&first)]);
+        assert_ne!(first, second);
+        // Unless the clock turned to the next second in between.
+        let same_second = second.starts_with(first.trim_end_matches(".png"));
+        assert!(
+            !same_second || second == first.replace(".png", "_2.png"),
+            "{second}"
+        );
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
    #[test]
    fn resource_ids_are_listed_once_per_root() {
        let root = std::env::temp_dir().join(format!("horizon-ids-{}", std::process::id()));
@@ -3831,12 +3831,9 @@ impl Game<'_> {
                    return;
                }
                g.spawn = None;
-                g.respawn_config = Some(super::respawn_anchor::RespawnConfig {
-                    dim: level,
-                    pos,
-                    yaw,
-                    forced: true,
-                });
+                g.respawn_config = Some(super::respawn_anchor::RespawnConfig::forced(
+                    level, pos, yaw, pitch,
+                ));
            });
        }
        let dim = Text::literal(self.dim.id());
@@ -1039,6 +1039,7 @@ impl Game<'_> {
                    path: path.trim().into(),
                    size: None,
                    scaled: false,
+                    background: false,
                });
                self.pending_screenshot = Some(reply.clone());
                Ok(None)
@@ -10,6 +10,7 @@ use horizon_client::mobs::Mob;
 use horizon_client::mobs::anim::BodyPose;
 use horizon_cosmetics::account::OwnedEmote;
 use horizon_cosmetics::{Item, Playing, Slot};
+use horizon_hooks::players::PlayerModels;
 use std::sync::Arc;

 /// How far the player may drift (blocks) before the emote stops: a nudge, not a step.
@@ -37,10 +38,15 @@ pub(in crate::game) struct Emotes {

 impl Emotes {
    /// The emote to tell the service about, while it plays: its id and whether it loops.
-    pub(in crate::game) fn sending(&self) -> Option<(String, bool)> {
+    pub(in crate::game) fn sending(&self) -> Option<(&str, bool)> {
        let p = self.playing.as_ref().filter(|p| p.stop.is_none())?;
        let looping = p.item.emote.as_ref().is_some_and(|e| e.looping);
-        Some((p.item.id.clone(), looping))
+        Some((&p.item.id, looping))
+    }
+
+    /// When the emote that pulled the camera back started (the own model's age), while it plays.
+    pub(in crate::game) fn pull(&self) -> Option<f32> {
+        self.camera_from.and(self.playing.as_ref()).map(|p| p.start)
    }
 }

@@ -59,23 +65,43 @@ impl BodyPose for EmotePose {
    }
 }

-/// The emote `m` plays, if any.
-pub(in crate::game) fn playing(m: &Mob) -> Option<&Playing> {
-    let any: &dyn std::any::Any = &**m.emote.as_ref()?;
+/// The emote a model's pose plays, if it is one.
+pub(in crate::game) fn pose_playing(pose: Option<&Arc<dyn BodyPose>>) -> Option<&Playing> {
+    let any: &dyn std::any::Any = &**pose?;
    any.downcast_ref::<EmotePose>().map(|e| &e.0)
 }

-/// Makes `m` play `next`, unless it plays that already (a new one allocates).
-pub(in crate::game) fn set_playing(m: &mut Mob, next: Option<Playing>) {
-    let same = match (playing(m), &next) {
+/// The pose that plays `next` where `now` is laid, unless it plays that already (None: keep
+/// it; a new one allocates).
+fn replaced(
+    now: Option<&Arc<dyn BodyPose>>,
+    next: Option<Playing>,
+) -> Option<Option<Arc<dyn BodyPose>>> {
+    let same = match (pose_playing(now), &next) {
        (None, None) => true,
        (Some(a), Some(b)) => {
            Arc::ptr_eq(&a.item, &b.item) && a.start == b.start && a.stop == b.stop
        }
        _ => false,
    };
-    if !same {
-        m.emote = next.map(|p| Arc::new(EmotePose(p)) as Arc<dyn BodyPose>);
+    (!same).then(|| next.map(|p| Arc::new(EmotePose(p)) as Arc<dyn BodyPose>))
+}
+
+/// Makes `m` play `next`, unless it plays that already.
+pub(in crate::game) fn set_playing(m: &mut Mob, next: Option<Playing>) {
+    if let Some(pose) = replaced(m.emote.as_ref(), next) {
+        m.emote = pose;
+    }
+}
+
+/// Makes model `id` play `next`, unless it plays that already.
+pub(in crate::game) fn set_model_playing(
+    models: &mut dyn PlayerModels,
+    id: u32,
+    next: Option<Playing>,
+) {
+    if let Some(pose) = replaced(models.body_pose(id), next) {
+        models.set_body_pose(id, pose);
    }
 }

@@ -229,7 +255,7 @@ impl Game<'_> {
        }
    }

-    /// Once a tick: my emote, then the other players'.
+    /// Once a tick: my emote (the others' are `cosmetics::Seat::tick`'s, a hook's).
    pub(in crate::game) fn tick_emotes(&mut self) {
        if let Some(done) = self
            .cosmetics
@@ -250,20 +276,6 @@ impl Game<'_> {
            }
        }
        self.tick_emote();
-        self.tick_others_emotes();
-    }
-
-    /// How far the camera stands back while an emote pulls it (1: the usual distance): it eases
-    /// out over the emote's first quarter second.
-    pub(in crate::game) fn emote_camera_pull(&self, partial: f32) -> f32 {
-        let (Some(p), Some(m)) = (&self.cosmetics.emotes.playing, &self.player_model) else {
-            return 1.0;
-        };
-        if self.cosmetics.emotes.camera_from.is_none() {
-            return 1.0;
-        }
-        let t = ((m.age as f32 + partial - p.start) / 5.0).clamp(0.0, 1.0);
-        0.35 + 0.65 * t * t * (3.0 - 2.0 * t)
    }
 }

@@ -1,47 +1,78 @@
 //! Companions, trails and auras ([docs/cosmetics.md](../../../../../docs/cosmetics.md)): worn
 //! like the other cosmetics but on no bone. A companion floats beside its wearer and follows with
 //! a lag (`horizon_cosmetics::follow`), drawn with the wearer; a trail's particles
-//! (`horizon_cosmetics::trail`) and an aura blend, so they go after every player in one
-//! see-through span (`cosmetics_fx_geometry`). Nothing of them is an entity, collides or is sent
-//! to a server.
+//! (`horizon_cosmetics::trail`) and an aura blend, so they are drawn see-through after every
+//! player (`PlayerDraw::particles`, `Look::see_through`). Nothing of them is an entity, collides
+//! or is sent to a server.

-use super::{FULL_LIGHT, OWN};
-use crate::game::Game;
+use super::Seat;
 use glam::{DVec3, Mat4, Vec3};
-use horizon_client::mesher::Vertex;
-use horizon_client::mobs::anim::Poses;
-use horizon_client::mobs::{Mob, Part};
+use horizon_client::fast_hash::FxHashMap;
 use horizon_cosmetics::follow::{self, Follow};
-use horizon_cosmetics::trail::Emitter;
+use horizon_cosmetics::trail::{Budget, Emitter};
 use horizon_cosmetics::{Item, Slot};
+use horizon_hooks::players::{Kind, Light, Look, Particle, Pass, PlayerDraw, PlayerModel};
 use std::sync::Arc;
+use std::time::Instant;

 /// How far from the camera (blocks) a wearer's companion, trail and aura are drawn.
 const FAR: f32 = 48.0;

-/// Who wears it, as drawn this frame.
-pub(super) struct Wearer<'a> {
-    pub m: &'a Mob,
-    /// The player's own model.
-    pub own: bool,
-    /// `OWN`, or the entity id.
-    pub key: u32,
-    /// The wearer's model matrix (`render::base_transform`), relative to `camera`.
-    pub base: Mat4,
-    pub camera: DVec3,
-    pub alpha: f32,
-    pub light: u32,
+/// The key of the player's own model in `Fx`'s maps (others go by entity id).
+const OWN: u32 = u32::MAX;
+
+/// What companions and trails keep between frames, per wearer (marked with the frame they were
+/// last drawn in; the others are dropped).
+#[derive(Default)]
+pub(super) struct Fx {
+    companions: FxHashMap<u32, (Follow, u32)>,
+    trails: FxHashMap<u32, (Emitter, u32)>,
+    budget: Budget,
+    clock: Option<(Instant, Instant)>,
+    /// Ticks since the first frame, and the last frame's length in seconds.
+    now: f64,
+    dt: f32,
+    frame: u32,
+    /// Kept so a frame of trails allocates none.
+    particles: Vec<Particle>,
 }

-/// `m`'s head yaw this frame (degrees).
-fn head_yaw(m: &Mob, alpha: f32) -> f32 {
-    let turn = horizon_client::mobs::living::wrap(m.head_yaw - m.previous_head_yaw);
-    m.previous_head_yaw + turn * alpha
-}
+impl Fx {
+    /// A new frame: the clock moves on and what no frame drew since the last one goes.
+    pub(super) fn frame(&mut self) {
+        self.frame = self.frame.wrapping_add(1);
+        let frame = self.frame;
+        let now = Instant::now();
+        let (start, last) = self.clock.get_or_insert((now, now));
+        self.dt = now.duration_since(*last).as_secs_f32().min(0.25);
+        self.now = now.duration_since(*start).as_secs_f64() * 20.0;
+        *last = now;
+        let seen = |mark: u32| frame.wrapping_sub(mark) <= 1;
+        self.companions.retain(|_, (_, mark)| seen(*mark));
+        let budget = &mut self.budget;
+        self.trails.retain(|_, (e, mark)| {
+            let keep = seen(*mark);
+            if !keep {
+                e.clear(budget);
+            }
+            keep
+        });
+    }

-/// Whether `m` lies in a bed.
-fn asleep(m: &Mob) -> bool {
-    m.extra.avatar_pose == horizon_client::pose::Pose::Sleeping
+    /// The companion of wearer `key` moved toward `target` (once a frame, however many times it
+    /// is drawn).
+    fn follow(&mut self, key: u32, target: DVec3, yaw: f32, lag: f32) -> Follow {
+        let (frame, dt) = (self.frame, self.dt);
+        let (f, mark) = self
+            .companions
+            .entry(key)
+            .or_insert((Follow::at(target, yaw), frame));
+        if *mark != frame {
+            f.step(target, yaw, lag, dt);
+            *mark = frame;
+        }
+        *f
+    }
 }

 /// Where a companion floats: `at` (relative to the camera) facing `yaw`, at the wearer's scale,
@@ -52,270 +83,144 @@ fn companion_matrix(at: Vec3, yaw: f32, scale: f32) -> Mat4 {
        * Mat4::from_scale(Vec3::new(-scale, -scale, scale))
 }

-impl Game<'_> {
-    /// A companion, trail or aura `at` wears: a companion goes where the wearer's other items go
-    /// (`gpu` and `out`, `bounds` grown), trails and auras to the frame's see-through vertices.
-    /// Other players' trails and auras stay hidden with "Hide other players' trails and auras".
-    pub(super) fn cosmetics_fx(
-        &self,
-        at: &Wearer,
-        item: &Arc<Item>,
-        gpu: bool,
-        bounds: Option<(Vec3, Vec3)>,
-        poses: &mut Poses,
-        out: &mut Vec<Vertex>,
-    ) -> Option<(Vec3, Vec3)> {
-        if !at.own && item.slot.is_effect() && self.settings.extras.cosmetics_hide_fx {
-            return bounds;
+/// Full light for what glows, else `otherwise`.
+fn glowing(glow: bool, otherwise: Light) -> Light {
+    if glow { Light::Full } else { otherwise }
+}
+
+impl Seat {
+    /// A companion, trail or aura `m` wears, around its model as `draw` draws it. Other players'
+    /// trails and auras stay hidden with "Hide other players' trails and auras".
+    pub(super) fn fx(&mut self, m: &PlayerModel, item: &Arc<Item>, draw: &mut dyn PlayerDraw) {
+        let own = m.kind == Kind::Own;
+        if !own && item.slot.is_effect() && self.settings.hide_fx {
+            return;
        }
        // Past `FAR` a companion, trail or aura is a few pixels across for the cost of a model:
        // not drawn, and a trail that isn't drawn doesn't spawn (its particles go back to the
        // budget).
-        if at.base.w_axis.truncate().length_squared() > FAR * FAR {
-            return bounds;
+        let base = Mat4::from_cols_array_2d(&draw.base());
+        if base.w_axis.truncate().length_squared() > FAR * FAR {
+            return;
        }
+        let Some(uv) = self.uv(item, |id| draw.sprite(id)) else {
+            return;
+        };
+        let key = if own { OWN } else { m.id };
        match item.slot {
-            Slot::Companion => {
-                let Some((model, uv, matrix)) = self.companion_at(at, item, None) else {
-                    return bounds;
-                };
-                self.pose_companion(item, at.m, at.alpha, poses, &model);
-                let glow = item.companion.as_ref().is_some_and(|c| c.glow);
-                let light = if glow { FULL_LIGHT } else { at.light };
-                self.cosmetics_model(&model, matrix, poses, uv, light, gpu, bounds, out)
-            }
-            Slot::Trail => {
-                self.trail(at, item);
-                bounds
-            }
-            Slot::Aura => {
-                self.aura(at, item, poses);
-                bounds
-            }
-            _ => bounds,
+            Slot::Companion => self.companion(key, item, uv, base, draw),
+            Slot::Trail => self.trail(key, item, uv, draw),
+            Slot::Aura => self.aura(item, uv, base, draw),
+            _ => {}
        }
    }

-    /// The companion's model, texture and matrix this frame, its follow moved on once a frame.
-    /// `first_person`: the camera's forward and left, for the player's own in first person: the
-    /// companion keeps out of the middle of the view.
-    fn companion_at(
-        &self,
-        at: &Wearer,
+    /// The companion where it floats, its follow moved on once a frame. In first person it keeps
+    /// out of the middle of the view, lit where it floats.
+    fn companion(
+        &mut self,
+        key: u32,
        item: &Arc<Item>,
-        first_person: Option<(Vec3, Vec3)>,
-    ) -> Option<(Arc<Part>, [f32; 4], Mat4)> {
-        let c = item.companion.as_ref()?;
-        let (models, uv) = self.cosmetics_baked(item)?;
-        let model = models.first()?.1.clone();
-        let scale = at.base.x_axis.truncate().length();
-        let target = at.base.transform_point3(Vec3::from(c.anchor) / 16.0);
-        let head = at
-            .base
-            .transform_point3(Vec3::from(horizon_cosmetics::HEAD) / 16.0);
-        let yaw = head_yaw(at.m, at.alpha);
-        let follow = self.companion_follow(at.key, at.camera + target.as_dvec3(), yaw, c.lag);
+        uv: [f32; 4],
+        base: Mat4,
+        draw: &mut dyn PlayerDraw,
+    ) {
+        let Some(c) = item.companion.as_ref() else {
+            return;
+        };
+        let Some((_, mesh)) = self.kept(item).meshes.first().cloned() else {
+            return;
+        };
+        let first_person = draw.pass() == Pass::FirstPerson;
+        let (motion, view) = (draw.motion(), draw.view());
+        let camera = DVec3::from(view.camera);
+        let scale = base.x_axis.truncate().length();
+        let target = base.transform_point3(Vec3::from(c.anchor) / 16.0);
+        let head = base.transform_point3(Vec3::from(horizon_cosmetics::HEAD) / 16.0);
+        let follow = self
+            .fx
+            .follow(key, camera + target.as_dvec3(), motion.head_yaw, c.lag);
        let clearance = (horizon_cosmetics::HEAD_CLEARANCE + c.reach) / 16.0 * scale;
-        let mut rel = (follow.pos - at.camera).as_vec3();
-        if let Some((forward, left)) = first_person {
-            rel = follow::out_of_view(rel, forward, left);
+        let mut rel = (follow.pos - camera).as_vec3();
+        if first_person {
+            rel = follow::out_of_view(rel, Vec3::from(view.forward), Vec3::from(view.left));
        }
        rel = follow::clear_of(rel, head, clearance);
-        Some((model, uv, companion_matrix(rel, follow.yaw, scale)))
-    }
-
-    /// The companion of wearer `key` moved toward `target` (once a frame, however many times it
-    /// is drawn).
-    fn companion_follow(&self, key: u32, target: DVec3, yaw: f32, lag: f32) -> Follow {
-        let frame = self.cosmetics.frame.get();
-        let mut fx = self.cosmetics.fx.borrow_mut();
-        let dt = fx.dt;
-        let (f, mark) = fx
-            .companions
-            .entry(key)
-            .or_insert((Follow::at(target, yaw), frame));
-        if *mark != frame {
-            f.step(target, yaw, lag, dt);
-            *mark = frame;
-        }
-        *f
-    }
-
-    /// The companion's animations, and its `look` part turned with the wearer's pitch.
-    fn pose_companion(&self, item: &Item, m: &Mob, alpha: f32, poses: &mut Poses, model: &Part) {
-        poses.reset(model);
-        item.animate(m.age as f32 + alpha, |name, pose| *poses.get(name) = pose);
-        if let Some(look) = item.companion.as_ref().and_then(|c| c.look.as_deref()) {
-            let pitch = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * alpha;
-            poses.get(look)[3] += (pitch * 0.6).clamp(-30.0, 30.0).to_radians();
-        }
+        let matrix = companion_matrix(rel, follow.yaw, scale).to_cols_array_2d();
+        let near = if first_person {
+            Light::AtPlace
+        } else {
+            Light::Model
+        };
+        let look = Look::new(uv).lit(glowing(c.glow, near));
+        let ticks = draw.ticks();
+        // Its animations, and its `look` part turned with the wearer's pitch.
+        let pitch = (motion.head_pitch * 0.6).clamp(-30.0, 30.0).to_radians();
+        draw.draw(&mesh, matrix, look, &mut |p| {
+            item.animate(ticks, |name, pose| *p.pose(name) = pose);
+            if let Some(part) = c.look.as_deref() {
+                p.pose(part)[3] += pitch;
+            }
+        });
    }

    /// The trail's particles: spawned once a frame by the distance walked (not while sneaking or
    /// asleep), facing the camera.
-    fn trail(&self, at: &Wearer, item: &Arc<Item>) {
+    fn trail(&mut self, key: u32, item: &Arc<Item>, uv: [f32; 4], draw: &mut dyn PlayerDraw) {
        let Some(t) = &item.trail else {
            return;
        };
-        let Some((_, uv)) = self.cosmetics_baked(item) else {
-            return;
-        };
-        let m = at.m;
-        let a = f64::from(at.alpha);
-        let feet = DVec3::new(
-            m.previous.x + (m.position.x - m.previous.x) * a,
-            m.previous.y + (m.position.y - m.previous.y) * a,
-            m.previous.z + (m.position.z - m.previous.z) * a,
-        );
-        let moves = !m.extra.crouching && !asleep(m);
-        let q = self.camera_orientation();
-        let (right, up) = (q * Vec3::X, q * Vec3::Y);
-        let light = if t.glow { FULL_LIGHT } else { at.light };
-        let frame = self.cosmetics.frame.get();
-        let mut fx = self.cosmetics.fx.borrow_mut();
-        let super::Fx {
+        let (motion, view) = (draw.motion(), draw.view());
+        let moves = !motion.crouching && !motion.asleep;
+        let Fx {
            trails,
            budget,
            now,
-            clear,
+            frame,
+            particles,
            ..
-        } = &mut *fx;
+        } = &mut self.fx;
        let (e, mark) = trails
-            .entry(at.key)
+            .entry(key)
            .or_insert_with(|| (Emitter::default(), frame.wrapping_sub(1)));
-        if *mark != frame {
-            e.step(t, feet, moves, *now, budget);
-            *mark = frame;
-        }
-        for quad in e.quads(t, *now, at.camera, right, up) {
-            let color = ((quad.alpha.clamp(0.0, 1.0) * 255.0) as u32) << 24 | 0x00FF_FFFF;
-            for (corner, [u, v]) in quad.corners.iter().zip(quad.uv) {
-                clear.push(Vertex {
-                    pos: corner.to_array(),
-                    uv: [uv[0] + (uv[2] - uv[0]) * u, uv[1] + (uv[3] - uv[1]) * v],
-                    layer: 0,
-                    color,
-                    light,
-                    // Unlit: a particle keeps its colour whichever way it faces.
-                    normal: [0, 0, 0, 0],
-                    glint_uv: [0.0, 0.0],
-                });
-            }
+        if *mark != *frame {
+            e.step(t, DVec3::from(motion.feet), moves, *now, budget);
+            *mark = *frame;
        }
+        let (camera, right, up) = (
+            DVec3::from(view.camera),
+            Vec3::from(view.right),
+            Vec3::from(view.up),
+        );
+        particles.clear();
+        particles.extend(
+            e.quads(t, *now, camera, right, up)
+                .map(|q| Particle::new(q.corners.map(|c| c.to_array()), q.uv, q.alpha)),
+        );
+        draw.particles(uv, particles, glowing(t.glow, Light::Model));
    }

    /// The aura at the wearer's feet, see-through. None while they fly, swim or sleep: it would
    /// tip over with the body.
-    fn aura(&self, at: &Wearer, item: &Arc<Item>, poses: &mut Poses) {
-        let (m, Some(a)) = (at.m, &item.aura) else {
+    fn aura(&mut self, item: &Arc<Item>, uv: [f32; 4], base: Mat4, draw: &mut dyn PlayerDraw) {
+        let Some(a) = &item.aura else {
            return;
        };
-        if m.extra.fall_flying || asleep(m) || m.extra.swim.amount(at.alpha) > 0.0 {
+        let motion = draw.motion();
+        if motion.flying || motion.asleep || motion.swimming {
            return;
        }
-        let Some((models, uv)) = self.cosmetics_baked(item) else {
-            return;
-        };
-        let Some((_, model)) = models.first() else {
+        let Some((_, mesh)) = self.kept(item).meshes.first().cloned() else {
            return;
        };
        // The model's origin is the middle of the feet: 24 pixels under the neck.
-        let matrix = at.base * Mat4::from_translation(Vec3::new(0.0, 24.0 / 16.0, 0.0));
-        poses.reset(model);
-        item.animate(m.age as f32 + at.alpha, |name, pose| {
-            *poses.get(name) = pose
+        let matrix = base * Mat4::from_translation(Vec3::new(0.0, 24.0 / 16.0, 0.0));
+        let look = Look::new(uv)
+            .lit(glowing(a.glow, Light::Model))
+            .see_through(a.alpha);
+        let ticks = draw.ticks();
+        draw.draw(&mesh, matrix.to_cols_array_2d(), look, &mut |p| {
+            item.animate(ticks, |name, pose| *p.pose(name) = pose)
        });
-        let light = if a.glow { FULL_LIGHT } else { at.light };
-        let mut fx = self.cosmetics.fx.borrow_mut();
-        let start = fx.clear.len();
-        horizon_client::mobs::render_model(
-            model,
-            matrix,
-            &|p: &Part| poses.pose(p),
-            uv,
-            light,
-            0,
-            &mut fx.clear,
-        );
-        let color = ((a.alpha * 255.0) as u32) << 24 | 0x00FF_FFFF;
-        for v in &mut fx.clear[start..] {
-            v.color = color;
-            // Seen through, a face turned away would add to the near one (and a card's two
-            // faces would double it): `entity.wgsl` drops back faces, so it is `alpha` at most.
-            v.normal[3] = horizon_client::mesher::SHADED_CULL_W;
-        }
-    }
-
-    /// After every player: the player's own companion in first person (out of the middle of the
-    /// view, after the first-person model went to the shadow pass only), then the frame's trails
-    /// and auras in one see-through span.
-    pub(in crate::game) fn cosmetics_fx_geometry(
-        &self,
-        camera: DVec3,
-        alpha: f64,
-        out: &mut Vec<Vertex>,
-    ) {
-        if !super::enabled() {
-            return;
-        }
-        if !self.own_body_in_view()
-            && let Some(m) = self.player_model.as_ref()
-        {
-            self.mark_entity(out.len(), "minecraft:player");
-            self.own_companion_first_person(m, camera, alpha as f32, out);
-        }
-        let fx = self.cosmetics.fx.borrow();
-        if !fx.clear.is_empty() {
-            self.mark_translucent_entity(out.len(), "minecraft:player");
-            out.extend_from_slice(&fx.clear);
-        }
-    }
-
-    fn own_companion_first_person(
-        &self,
-        m: &Mob,
-        camera: DVec3,
-        alpha: f32,
-        out: &mut Vec<Vertex>,
-    ) {
-        if horizon_client::mobs::trader::is_invisible(m) || self.own_invisible() {
-            return;
-        }
-        let Some(worn) = self.worn(m, true) else {
-            return;
-        };
-        let Some(item) = worn.iter().find(|i| i.slot == Slot::Companion) else {
-            return;
-        };
-        let at = Wearer {
-            m,
-            own: true,
-            key: OWN,
-            base: horizon_client::mobs::render::base_transform(m, alpha, camera),
-            camera,
-            alpha,
-            light: FULL_LIGHT,
-        };
-        let (yaw, pitch) = (self.yaw.to_radians(), self.pitch.to_radians());
-        let forward = Vec3::new(
-            -yaw.sin() * pitch.cos(),
-            -pitch.sin(),
-            yaw.cos() * pitch.cos(),
-        );
-        let left = Vec3::new(yaw.cos(), 0.0, yaw.sin());
-        let Some((model, uv, matrix)) = self.companion_at(&at, item, Some((forward, left))) else {
-            return;
-        };
-        // Lit where it floats.
-        let p = (camera + matrix.w_axis.truncate().as_dvec3()).floor();
-        let light = self.world.light(p.x as i32, p.y as i32, p.z as i32);
-        let mut light = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
-        if item.companion.as_ref().is_some_and(|c| c.glow) {
-            light = FULL_LIGHT;
-        }
-        let mut poses = self.cosmetics.poses.borrow_mut();
-        let poses = &mut poses.1;
-        self.pose_companion(item, m, alpha, poses, &model);
-        self.cosmetics_model(&model, matrix, poses, uv, light, false, None, out);
    }
 }
@@ -0,0 +1,285 @@
+//! The cosmetics' settings (spec #14091 step 5a): their lines of `horizon-extras.txt`, the ones
+//! the launcher's Wardrobe shares (`horizon_cosmetics::prefs`), through the settings store
+//! ([`STORE`]), and their rows in the Extras page's Cosmetics group ([`SECTION`]). Each
+//! splitscreen player has their own, as their own settings file: they live in the player's
+//! [`Seat`].
+
+use super::{Seat, service};
+use horizon_cosmetics::prefs::{self, Others};
+use horizon_hooks::pages::{Act, Label, Page, Place, Row};
+use horizon_hooks::settings::Store;
+
+/// My cosmetics in single player too.
+const SOLO: &str = "cosmeticsSolo";
+
+/// The settings, each with its line in `horizon-extras.txt`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) struct Settings {
+    /// Show my cosmetics (the account's, told to the service; `prefs::MINE`).
+    pub mine: bool,
+    /// How much of other players' cosmetics shows: no line until the player chooses
+    /// (`Seat::others`).
+    pub others: Option<Others>,
+    /// Other players' trails and auras hidden.
+    pub hide_fx: bool,
+    /// My cosmetics in single player too: the window's own server names the player by their
+    /// offline profile, which the service doesn't know, so they show only with this on.
+    pub solo: bool,
+    /// Horizon's mark before Horizon players' names (name tags, player list).
+    pub marks: bool,
+    /// The service may say this player plays Horizon.
+    pub listed: bool,
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            mine: true,
+            others: None,
+            hide_fx: false,
+            solo: false,
+            marks: true,
+            listed: true,
+        }
+    }
+}
+
+const KEYS: [&str; 6] = [
+    prefs::MINE,
+    prefs::OTHERS,
+    prefs::HIDE_FX,
+    SOLO,
+    prefs::MARKS,
+    prefs::LISTED,
+];
+
+impl Settings {
+    /// One line; a value it can't read keeps the setting.
+    fn load(&mut self, key: &str, value: &str) {
+        let flag = |was: bool| match value {
+            "true" => true,
+            "false" => false,
+            _ => was,
+        };
+        match key {
+            prefs::MINE => self.mine = flag(self.mine),
+            // `Others::parse` reads the old two-way switch too.
+            prefs::OTHERS => self.others = Others::parse(value).or(self.others),
+            prefs::HIDE_FX => self.hide_fx = flag(self.hide_fx),
+            SOLO => self.solo = flag(self.solo),
+            prefs::MARKS => self.marks = flag(self.marks),
+            prefs::LISTED => self.listed = flag(self.listed),
+            _ => {}
+        }
+    }
+
+    /// Their lines; others' only once chosen.
+    fn save(&self, line: &mut dyn FnMut(&str, &str)) {
+        let text = |on: bool| if on { "true" } else { "false" };
+        line(prefs::MINE, text(self.mine));
+        if let Some(others) = self.others {
+            line(prefs::OTHERS, others.name());
+        }
+        line(prefs::HIDE_FX, text(self.hide_fx));
+        line(SOLO, text(self.solo));
+        line(prefs::MARKS, text(self.marks));
+        line(prefs::LISTED, text(self.listed));
+    }
+}
+
+/// The settings' lines of `horizon-extras.txt`, the player's own file in splitscreen: the game
+/// loads and saves it on the player's turn, so they are that seat's.
+pub(super) static STORE: Lines = Lines;
+
+pub(super) struct Lines;
+
+impl Store for Lines {
+    fn file(&self) -> &'static str {
+        prefs::FILE
+    }
+    fn owns(&self, key: &str) -> bool {
+        KEYS.contains(&key)
+    }
+    fn load(&self, key: &str, value: &str) {
+        service(|s| s.settings.load(key, value));
+    }
+    fn save(&self, line: &mut dyn FnMut(&str, &str)) {
+        service(|s| s.settings).save(line);
+    }
+    fn is_default(&self) -> bool {
+        service(|s| s.settings) == Settings::default()
+    }
+}
+
+/// The rows, top to bottom.
+const ROWS: [&str; 6] = [
+    "horizon.extras.cosmetics_mine",
+    "horizon.extras.cosmetics_solo",
+    "horizon.extras.cosmetics_others",
+    "horizon.extras.cosmetics_hide_fx",
+    "horizon.extras.horizon_marks",
+    "horizon.extras.horizon_me",
+];
+
+const TOOLTIPS: [&str; 6] = [
+    "horizon.extras.cosmetics_mine.tooltip",
+    "horizon.extras.cosmetics_solo.tooltip",
+    "horizon.extras.cosmetics_others.tooltip",
+    "horizon.extras.cosmetics_hide_fx.tooltip",
+    "horizon.extras.horizon_marks.tooltip",
+    "horizon.extras.horizon_me.tooltip",
+];
+
+/// The rows in the Extras page's Cosmetics group, while cosmetics are offered
+/// ([`super::enabled`]).
+pub(super) static SECTION: Section = Section;
+
+pub(super) struct Section;
+
+impl Section {
+    fn rows_of(seat: &Seat, rows: &mut Vec<Row>) {
+        let s = &seat.settings;
+        let shown = |on: bool| {
+            Label::Key(if on {
+                "horizon.extras.cosmetics.shown"
+            } else {
+                "horizon.extras.cosmetics.hidden"
+            })
+        };
+        let others = Label::Key(match seat.others() {
+            Others::Shown => "horizon.extras.cosmetics.shown",
+            Others::NameTags => "horizon.extras.cosmetics.name_tags",
+            Others::Hidden => "horizon.extras.cosmetics.hidden",
+        });
+        let toggle = |label, on| Row::Toggle { label, on };
+        let cycle = |label, value| Row::Cycle { label, value };
+        rows.extend([
+            cycle(ROWS[0], shown(s.mine)),
+            toggle(ROWS[1], s.solo),
+            cycle(ROWS[2], others),
+            toggle(ROWS[3], s.hide_fx),
+            toggle(ROWS[4], s.marks),
+            toggle(ROWS[5], s.listed),
+        ]);
+    }
+
+    /// A press on row `row`; `back` turns the three-way row the other way.
+    fn act_on(seat: &mut Seat, row: usize, back: bool) {
+        let s = &mut seat.settings;
+        match row {
+            0 => s.mine = !s.mine,
+            1 => s.solo = !s.solo,
+            2 => {
+                // From what the row shows; the result is the player's choice from now on.
+                let o = seat.others();
+                seat.settings.others = Some(if back { o.next().next() } else { o.next() });
+            }
+            3 => s.hide_fx = !s.hide_fx,
+            4 => s.marks = !s.marks,
+            5 => s.listed = !s.listed,
+            _ => {}
+        }
+    }
+}
+
+impl Page for Section {
+    fn id(&self) -> &'static str {
+        "horizon-cosmetics.extras"
+    }
+    fn title(&self) -> &'static str {
+        "horizon.extras.header.cosmetics"
+    }
+    fn place(&self) -> Place {
+        Place::Extras
+    }
+    fn rows(&self, rows: &mut Vec<Row>) {
+        if super::enabled() {
+            service(|seat| Self::rows_of(seat, rows));
+        }
+    }
+    fn act(&self, row: usize, act: Act) {
+        let back = match act {
+            Act::Press => false,
+            Act::PressBack => true,
+            _ => return,
+        };
+        service(|seat| Self::act_on(seat, row, back));
+    }
+    fn tooltip(&self, row: usize) -> Option<Label> {
+        TOOLTIPS.get(row).copied().map(Label::Key)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn loaded(text: &str) -> Settings {
+        let mut s = Settings::default();
+        for (key, value) in text.lines().filter_map(|l| l.split_once(':')) {
+            s.load(key.trim(), value.trim());
+        }
+        s
+    }
+
+    fn saved(s: &Settings) -> String {
+        let mut text = String::new();
+        s.save(&mut |k, v| text.push_str(&format!("{k}:{v}\n")));
+        text
+    }
+
+    #[test]
+    fn the_lines_round_trip_and_the_wardrobe_reads_them() {
+        let s = Settings {
+            mine: false,
+            others: Some(Others::NameTags),
+            hide_fx: true,
+            solo: true,
+            marks: false,
+            listed: false,
+        };
+        let text = saved(&s);
+        assert_eq!(loaded(&text), s);
+        // The launcher's Wardrobe reads the same lines.
+        let wardrobe = prefs::Prefs::parse(&text);
+        assert_eq!(
+            (wardrobe.mine, wardrobe.others, wardrobe.hide_fx),
+            (false, Some(Others::NameTags), true)
+        );
+        // No choice made: no `cosmeticsOthers` line; the old switch still reads.
+        assert!(!saved(&Settings::default()).contains(prefs::OTHERS));
+        assert_eq!(
+            loaded("cosmeticsOthers:false\n").others,
+            Some(Others::Hidden)
+        );
+        // A value it can't read keeps the setting.
+        assert!(loaded("cosmeticsMine:maybe\n").mine);
+    }
+
+    #[test]
+    fn others_cycle_three_ways_from_what_the_row_shows() {
+        let mut seat = Seat::default();
+        // Not chosen, nothing owned: Hidden, and forward wraps to Shown.
+        assert_eq!(seat.others(), Others::Hidden);
+        Section::act_on(&mut seat, 2, false);
+        assert_eq!(seat.settings.others, Some(Others::Shown));
+        Section::act_on(&mut seat, 2, true);
+        assert_eq!(seat.settings.others, Some(Others::Hidden));
+        Section::act_on(&mut seat, 2, true);
+        assert_eq!(seat.settings.others, Some(Others::NameTags));
+        // Owning one shows them by default, until the player chooses.
+        let mut owner = Seat::default();
+        owner.owner.owns = true;
+        assert_eq!(owner.others(), Others::Shown);
+        let mut rows = Vec::new();
+        Section::rows_of(&owner, &mut rows);
+        assert_eq!(
+            rows[2],
+            Row::Cycle {
+                label: ROWS[2],
+                value: Label::Key("horizon.extras.cosmetics.shown")
+            }
+        );
+        assert_eq!(rows.len(), TOOLTIPS.len());
+    }
+}
@@ -280,25 +280,18 @@ impl Game<'_> {
                self.spin_attack_geometry(mob, camera, alpha as f32, packed, out);
                self.stuck_in_body_geometry(mob, mob.id as i32, camera, alpha as f32, packed, out);
            }
-            // Cosmetics (game/cosmetics.rs), posed on the GPU with the mob's own jobs: culled
-            // with it.
+            // What crates draw on players and mannequins (`game/player_hooks.rs`: cosmetics),
+            // posed on the GPU with the mob's own jobs: culled with it.
            if !layers_only
-                && super::super::cosmetics::enabled()
+                && horizon_hooks::engine::any()
                && (is_player || &*mob.kind.id == "minecraft:mannequin")
            {
                let mark = self.skin_frame.borrow().mark();
                let base = horizon_client::mobs::render::base_transform(mob, alpha as f32, camera);
                let gpu = skinning;
-                if let Some((lo, hi)) = self.cosmetics_geometry(
-                    mob,
-                    false,
-                    base,
-                    Some(camera),
-                    alpha as f32,
-                    packed,
-                    gpu,
-                    out,
-                ) {
+                if let Some((lo, hi)) =
+                    self.player_layers_geometry(mob, base, camera, alpha as f32, packed, gpu, out)
+                {
                    skinned = Some(match skinned {
                        Some((first, Some((l, h)))) => (first, Some((l.min(lo), h.max(hi)))),
                        Some((first, None)) => (first, Some((lo, hi))),
@@ -1,49 +0,0 @@
-//! What the player is doing, for Discord Rich Presence (`horizon_client::discord_presence`).
-use super::*;
-use horizon_client::discord_presence::{self as presence, Dimension, Play, Status};
-
-impl Game<'_> {
-    /// Each frame: only a change reaches the presence thread.
-    pub(super) fn update_discord_presence(&self) {
-        // One Discord status per computer: P1's, not a splitscreen player's.
-        if self.options.split_guest {
-            return;
-        }
-        presence::set(self.discord_status());
-    }
-    fn discord_status(&self) -> Status {
-        if !self.settings.extras.discord_presence {
-            return Status::Off;
-        }
-        if self.title.is_some() {
-            return Status::Menus;
-        }
-        let play = if let Some(host) = &self.lan {
-            Play::Hosting {
-                players: 1 + host.hub.guests.len(),
-                max: horizon_client::lan::MAX_PLAYERS,
-            }
-        } else if let Some(server) = &self.integrated {
-            match (server.published(), &self.remote) {
-                (Some(_), Some(remote)) => Play::Hosting {
-                    players: remote.player_count(),
-                    max: horizon_client::lan::MAX_PLAYERS,
-                },
-                _ => Play::Singleplayer,
-            }
-        } else if self.remote.is_some() {
-            Play::Multiplayer
-        } else {
-            Play::Singleplayer
-        };
-        Status::World {
-            play,
-            dimension: match self.dim {
-                Dim::Overworld => Dimension::Overworld,
-                Dim::Nether => Dimension::Nether,
-                Dim::End => Dimension::End,
-            },
-            mode: self.mode,
-        }
-    }
-}
@@ -353,7 +353,7 @@ impl Game<'_> {
            let found =
                self.find_respawn_and_use(config, op["consume"].as_bool().unwrap_or(true))?;
            used.push(match found {
-                Some((p, yaw)) => format!(
+                Some((p, yaw, _pitch)) => format!(
                    "respawn {} {} {} {}",
                    num(p.x),
                    num(p.y),
@@ -579,6 +579,7 @@ impl Game<'_> {
                dim: self.dim,
                pos: [p(0), p(1), p(2)],
                yaw: 0.0,
+                pitch: 0.0,
                forced: false,
            });
        }
@@ -739,7 +739,8 @@ impl Game<'_> {
        // anchor puts the player, facing it; else onto the spawn column.
        let mut target = target;
        if let Some(c) = self.respawn_config.filter(|c| c.dim == self.dim) {
-            if let Some((at, yaw)) = self.find_respawn_and_use(c, false)? {
+            // This existing owner transition adapter carries yaw only; its pitch path remains open.
+            if let Some((at, yaw, _pitch)) = self.find_respawn_and_use(c, false)? {
                return Ok(Some((at, Some(yaw))));
            }
            target = fallback_spawn(self.spawn, self.level.world_spawn);
@@ -70,9 +70,10 @@ fn overworld_spawnpoint_is_validated_at_both_player_blocks() {
            assert_eq!(actual.is_some(), allowed, "{block} at height {height}");
            assert_eq!(game.respawn_config.is_some(), allowed);
            assert_eq!(game.level.world_spawn, Some([0, 80, 0]));
-            if let Some((at, yaw)) = actual {
+            if let Some((at, yaw, pitch)) = actual {
                assert_eq!(at, Vec3::new(5.5, 64.1, 5.5));
                assert_eq!(yaw, 0.0);
+                assert_eq!(pitch.to_bits(), 0.0f32.to_bits());
            }
        }
    }
@@ -135,8 +135,8 @@ impl Game<'_> {
    }
    /// `Camera.calculateFov` with `modifyFovBasedOnDeathOrFluid`.
    pub(super) fn fov_degrees(&self, partial: f32, camera: [f64; 3]) -> f32 {
-        if self.studio_freecam.active {
-            return self.studio_freecam.fov.clamp(1.0, 179.0);
+        if self.studio.flying() {
+            return self.studio.freecam.fov.clamp(1.0, 179.0);
        }
        let fov = self.view.calculate_fov(
            partial,
@@ -193,7 +193,7 @@ impl Game<'_> {
        // replay player's hands remain visible in first person; freecam has
        // no player-view hand.
        if !fov::studio_draws_hand(
-            self.studio_freecam.active,
+            self.studio.flying(),
            self.ui.hands_drawn(
                self.spectator(),
                self.sleeping.is_some(),
@@ -4190,8 +4190,8 @@ impl Game<'_> {
                .map_or([0.5, 80.0, 0.5], |[x, y, z]| {
                    [f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5]
                });
-            let at = found.map_or(world, |(at, yaw)| {
-                host.hub.guests[i].yaw = yaw;
+            let at = found.map_or(world, |(at, yaw, pitch)| {
+                (host.hub.guests[i].yaw, host.hub.guests[i].pitch) = (yaw, pitch);
                [at.x, at.y, at.z]
            });
            if found.is_none() {
@@ -34,8 +34,6 @@ pub(super) fn run_event_loop(mut game: Game<'_>) -> Result<()> {
    narrator::stop();
    leave_fullscreen_after(&result, &mut game.settings);
    result?;
-    #[cfg(feature = "discord")]
-    horizon_client::discord_presence::stop();
    write_report(&game)?;
    if let Some(e) = game.error.take() {
        return Err(e);
@@ -98,9 +96,8 @@ impl Loading {
            .map_or([1280, 720], |o| o.window_size)
            .map(f64::from);
        self.fullscreen = horizon_client::window::FullscreenState::new(fullscreen);
-        let attributes = horizon_client::window::with_horizon_icon(
-            Window::default_attributes().with_title("Horizon"),
-        );
+        let attributes =
+            horizon_client::window::with_icon(Window::default_attributes().with_title("Horizon"));
        // Wayland names the window by its app id, which the horizon.desktop entry matches.
        #[cfg(target_os = "linux")]
        let attributes = winit::platform::wayland::WindowAttributesExtWayland::with_name(
@@ -130,22 +127,25 @@ impl Loading {
        // redraw the same design when they start. GDI is unsafe:
        // horizon-threads holds it (this crate forbids unsafe code).
        #[cfg(target_os = "windows")]
-        let boot_paint_stop = hwnd(&window).map(|hwnd| {
-            let stop = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
-            let repaint_stop = stop.clone();
-            std::thread::spawn(move || {
-                while !repaint_stop.load(std::sync::atomic::Ordering::Relaxed) {
-                    horizon_threads::boot_paint::paint(
-                        hwnd,
-                        horizon_theme::fonts::GEIST_SEMIBOLD,
-                        horizon_theme::fonts::GEIST_MONO,
-                        &horizon_client::logging::recent_lines(),
-                    );
-                    std::thread::sleep(std::time::Duration::from_millis(300));
-                }
+        // In the fonts given to `menu_style`; with none, the window stays as it is.
+        let boot_paint_stop = hwnd(&window)
+            .zip(horizon_client::menu_style::get().fonts)
+            .map(|(hwnd, fonts)| {
+                let stop = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+                let repaint_stop = stop.clone();
+                std::thread::spawn(move || {
+                    while !repaint_stop.load(std::sync::atomic::Ordering::Relaxed) {
+                        horizon_threads::boot_paint::paint(
+                            hwnd,
+                            fonts.semibold,
+                            fonts.mono,
+                            &horizon_client::logging::recent_lines(),
+                        );
+                        std::thread::sleep(std::time::Duration::from_millis(300));
+                    }
+                });
+                stop
            });
-            stop
-        });
        let offscreen = self.options.as_ref().is_some_and(|o| o.offscreen);
        let boot_step = startup::step("renderer.boot");
        match loading_renderer(
@@ -118,35 +118,79 @@ impl View {
        }
        None
    }
-    /// `WorldlyContainer.getSlotsForFace` or every slot.
-    fn slots_for_face(&self, face: Option<Direction>) -> Vec<usize> {
+    /// `WorldlyContainer.getSlotsForFace` or every slot, zero-allocation iterator.
+    pub(super) fn slots_for_face_iter(&self, face: Option<Direction>) -> Slots<'_> {
        match (self.kind, face) {
-            (Kind::Furnace, Some(Direction::Down)) => vec![2, 1],
-            (Kind::Furnace, Some(Direction::Up)) => vec![0],
-            (Kind::Furnace, Some(_)) => vec![1],
-            (Kind::Brewing, Some(Direction::Up)) => vec![3],
-            (Kind::Brewing, Some(Direction::Down)) => vec![0, 1, 2, 3],
-            (Kind::Brewing, Some(_)) => vec![0, 1, 2, 4],
-            (Kind::Composter(8), Some(Direction::Down)) => vec![0],
-            (Kind::Composter(level), Some(Direction::Up)) if level < 7 => vec![0],
-            (Kind::Composter(_), _) => vec![],
+            (Kind::Furnace, Some(Direction::Down)) => Slots::Slice(&[2, 1]),
+            (Kind::Furnace, Some(Direction::Up)) => Slots::Slice(&[0]),
+            (Kind::Furnace, Some(_)) => Slots::Slice(&[1]),
+            (Kind::Brewing, Some(Direction::Up)) => Slots::Slice(&[3]),
+            (Kind::Brewing, Some(Direction::Down)) => Slots::Slice(&[0, 1, 2, 3]),
+            (Kind::Brewing, Some(_)) => Slots::Slice(&[0, 1, 2, 4]),
+            (Kind::Composter(8), Some(Direction::Down)) => Slots::Slice(&[0]),
+            (Kind::Composter(level), Some(Direction::Up)) if level < 7 => Slots::Slice(&[0]),
+            (Kind::Composter(_), _) => Slots::Slice(&[]),
            (Kind::Mod, Some(face)) => self
                .container
                .as_ref()
-                .map_or_else(Vec::new, |c| c.faces[face as usize].clone()),
-            _ => (0..self.len()).collect(),
+                .map_or(Slots::Slice(&[]), |c| Slots::Mod(&c.faces[face as usize])),
+            _ => Slots::Range(0..self.len()),
        }
    }
+    /// The slots `HopperBlockEntity.addItem` tries through `face`, zero-allocation iterator.
+    pub(super) fn slots_to_add_iter(&self, face: Option<Direction>) -> Slots<'_> {
+        if matches!(self.kind, Kind::Furnace | Kind::Brewing | Kind::Mod) && face.is_some() {
+            self.slots_for_face_iter(face)
+        } else {
+            Slots::Range(0..self.len())
+        }
+    }
+    /// `WorldlyContainer.getSlotsForFace` or every slot.
+    fn slots_for_face(&self, face: Option<Direction>) -> Vec<usize> {
+        self.slots_for_face_iter(face).collect()
+    }
    /// The slots `HopperBlockEntity.addItem` tries through `face`.
    fn slots_to_add(&self, face: Option<Direction>) -> Vec<usize> {
-        if matches!(self.kind, Kind::Furnace | Kind::Brewing | Kind::Mod) && face.is_some() {
-            self.slots_for_face(face)
-        } else {
-            (0..self.len()).collect()
-        }
+        self.slots_to_add_iter(face).collect()
    }
 }

+pub(super) enum Slots<'a> {
+    Range(std::ops::Range<usize>),
+    Slice(&'static [usize]),
+    Mod(&'a [usize]),
+}
+
+impl Iterator for Slots<'_> {
+    type Item = usize;
+    #[inline]
+    fn next(&mut self) -> Option<usize> {
+        match self {
+            Slots::Range(r) => r.next(),
+            Slots::Slice(s) => {
+                let (&first, rest) = s.split_first()?;
+                *s = rest;
+                Some(first)
+            }
+            Slots::Mod(s) => {
+                let (&first, rest) = s.split_first()?;
+                *s = rest;
+                Some(first)
+            }
+        }
+    }
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = match self {
+            Slots::Range(r) => r.len(),
+            Slots::Slice(s) => s.len(),
+            Slots::Mod(s) => s.len(),
+        };
+        (len, Some(len))
+    }
+}
+impl ExactSizeIterator for Slots<'_> {}
+
 pub(super) fn dir_from_name(name: &str) -> Option<Direction> {
    Some(match name {
        "down" => Direction::Down,
@@ -180,8 +224,6 @@ struct Containers<'a> {
    registry: &'static horizon_world::registry::BlockRegistry,
    /// Brewing recipes, for what a brewing stand accepts (not needed for signals).
    brewing: Option<&'a horizon_client::brewing::Brewing>,
-    /// The stack of a full composter's `OutputContainer`.
-    bone_meal: ItemStack,
 }
 impl Containers<'_> {
    fn prop(&self, state: BlockStateId, key: &str) -> Option<&str> {
@@ -346,7 +388,7 @@ impl Containers<'_> {
    fn get(&self, view: &View, slot: usize) -> Option<&ItemStack> {
        if let Kind::Composter(level) = view.kind {
            // OutputContainer holds one bone meal; InputContainer composts at once.
-            return (level == 8 && slot == 0).then_some(&self.bone_meal);
+            return (level == 8 && slot == 0).then_some(bone_meal_stack());
        }
        let (pos, i) = view.locate(slot)?;
        self.world
@@ -452,7 +494,7 @@ impl Containers<'_> {
    }
    /// `HopperBlockEntity.isFullContainer`.
    fn is_full(&self, view: &View, face: Direction) -> bool {
-        view.slots_for_face(Some(face)).into_iter().all(|i| {
+        view.slots_for_face_iter(Some(face)).all(|i| {
            self.insertion_item(view, i)
                .is_some_and(|s| s.count >= self.max_stack(&s))
        })
@@ -498,6 +540,9 @@ impl ItemColumns {
        x: i32,
        z: i32,
    ) -> bool {
+        if items.is_empty() {
+            return false;
+        }
        let (len, last) = (items.len(), items.last().map(|i| i.id));
        let stale = self
            .seen
@@ -556,13 +601,14 @@ impl StampedItemColumns {
    }
 }

-fn bone_meal() -> ItemStack {
-    ItemStack {
+fn bone_meal_stack() -> &'static ItemStack {
+    static STACK: std::sync::LazyLock<ItemStack> = std::sync::LazyLock::new(|| ItemStack {
        item: "minecraft:bone_meal".into(),
        count: 1,
        damage: 0,
        extra: None,
-    }
+    });
+    &STACK
 }

 /// Comparator input from a container block entity (0 when there is none).
@@ -579,7 +625,6 @@ pub(super) fn container_signal(
        items,
        registry,
        brewing: None,
-        bone_meal: bone_meal(),
    };
    c.view((pos.x, pos.y, pos.z), true)
        .filter(|v| !matches!(v.kind, Kind::Composter(_)))
@@ -635,7 +680,6 @@ impl Game<'_> {
            items: self.items(),
            registry: self.pack.assets.registry,
            brewing: Some(&self.stations().brewing),
-            bone_meal: bone_meal(),
        }
    }
    pub(super) fn block_can_place(&self, pos: [i32; 3], slot: usize, stack: &ItemStack) -> bool {
@@ -847,7 +891,7 @@ impl Game<'_> {
            return self.composter_container_insert([x, y, z], stack, face == Some(Direction::Up));
        }
        let mut rest = Some(stack);
-        for slot in view.slots_to_add(face) {
+        for slot in view.slots_to_add_iter(face) {
            let Some(stack) = rest.take() else { break };
            rest = self.try_move_in_item(from_hopper, view, stack, slot, face);
        }
@@ -880,32 +924,31 @@ impl Game<'_> {
    /// is still a hopper (`BlockEntityType.isValid`).
    pub(super) fn tick_hopper(&mut self, pos: Pos) {
        let time = self.world.game_time;
-        let waiting = {
-            let state = self.hoppers.entry(pos).or_default();
-            state.cooldown = state.cooldown.wrapping_sub(1);
-            state.ticked = time;
-            state.cooldown > 0
-        };
-        if waiting {
+        // Every hopper keeps its cooldown and the tick it last ticked
+        // (`HopperBlockEntity.tickedGameTime`), idle ones too: a hopper that
+        // receives an item reads it for its cooldown (8, or 7 once it ticked).
+        let state = self.hoppers.entry(pos).or_default();
+        state.cooldown = state.cooldown.wrapping_sub(1);
+        state.ticked = time;
+        if state.cooldown > 0 {
            return;
        }
+        state.cooldown = 0;
        // Most ticks only advance the cooldown: the block is checked when the
        // hopper is about to move, not on every tick it waits.
-        let hopper = self
-            .res
-            .facts()
-            .get(self.world.block(pos.0, pos.1, pos.2))
-            .name
-            .as_ref()
-            == "minecraft:hopper";
-        if !hopper {
+        let state = self.world.block(pos.0, pos.1, pos.2);
+        let Some(info) = self.pack.assets.registry.state(state) else {
+            self.hoppers.remove(&pos);
+            return;
+        };
+        if info.name != "minecraft:hopper" {
            self.hoppers.remove(&pos);
            return;
        }
-        if let Some(state) = self.hoppers.get_mut(&pos) {
-            state.cooldown = 0;
+        if info.properties.get("enabled").is_some_and(|v| v == "false") {
+            return;
        }
-        self.hopper_try_move_items(pos);
+        self.hopper_try_move_items_with_state(pos, state);
    }
    /// Drops the cooldowns of hoppers whose block entity is gone.
    pub(super) fn forget_gone_hoppers(&mut self) {
@@ -917,23 +960,69 @@ impl Game<'_> {
    /// `HopperBlockEntity.tryMoveItems` with `suckInItems`.
    pub(super) fn hopper_try_move_items(&mut self, pos: Pos) {
        let state = self.world.block(pos.0, pos.1, pos.2);
-        let c = self.containers();
-        let enabled = c.prop(state, "enabled") != Some("false");
-        let Some(view) = c.view(pos, false) else {
+        self.hopper_try_move_items_with_state(pos, state);
+    }
+    fn hopper_try_move_items_with_state(&mut self, pos: Pos, state: BlockStateId) {
+        let Some(info) = self.pack.assets.registry.state(state) else {
            return;
        };
-        if self.hoppers.get(&pos).is_some_and(|h| h.cooldown > 0) || !enabled {
+        if info.properties.get("enabled").is_some_and(|v| v == "false") {
            return;
        }
-        self.native_prepare_hopper_transfer([pos.0, pos.1, pos.2]);
-        let mut changed = false;
-        if !c.is_empty(&view) {
-            changed = self.hopper_eject(pos, &view);
+        if self.hoppers.get(&pos).is_some_and(|h| h.cooldown > 0) {
+            return;
        }
-        let c = self.containers();
-        let full =
-            (0..view.len()).all(|i| c.get(&view, i).is_some_and(|s| s.count == c.max_stack(s)));
-        if !full {
+        let Some(BlockEntity::Chest(items)) = self.world.block_entities.get(&pos) else {
+            return;
+        };
+        if items.len() != HOPPER_SLOTS {
+            return;
+        }
+        let is_empty = items
+            .iter()
+            .all(|s| s.as_ref().is_none_or(|s| s.count == 0));
+        let has_empty_slot = items
+            .iter()
+            .any(|s| s.as_ref().is_none_or(|s| s.count == 0));
+
+        let above = (pos.0, pos.1 + 1, pos.2);
+        // Fast path for empty hopper with no source container and no item entities:
+        // if empty, cannot eject; if no container above, cannot suck container;
+        // if no dropped items nearby, cannot suck entities -> nothing can happen!
+        if is_empty
+            && self.world.block_entities.get(&above).is_none()
+            && self.carts.is_empty()
+            && self.boats.is_empty()
+            && (self.dropped.is_empty()
+                || self
+                    .item_columns
+                    .as_mut()
+                    .is_some_and(|c| !c.may_reach(&self.dropped, pos.0, pos.2)))
+            && self
+                .pack
+                .assets
+                .registry
+                .state(self.world.block(above.0, above.1, above.2))
+                .is_none_or(|s| s.name != "minecraft:composter")
+        {
+            return;
+        }
+
+        self.native_prepare_hopper_transfer([pos.0, pos.1, pos.2]);
+        let view = View {
+            parts: vec![(pos, HOPPER_SLOTS)],
+            kind: Kind::Hopper,
+            container: None,
+        };
+        let mut changed = false;
+        if !is_empty {
+            changed = self.hopper_eject_with_state(pos, state, &view);
+        }
+        let is_full = !changed && !has_empty_slot && {
+            let c = self.containers();
+            (0..HOPPER_SLOTS).all(|i| c.get(&view, i).is_some_and(|s| s.count >= c.max_stack(s)))
+        };
+        if !is_full {
            changed |= self.hopper_suck(pos, &view);
        }
        if changed {
@@ -995,19 +1084,20 @@ impl Game<'_> {
    /// `tryMoveItems(…, () -> addItem(hopper, itemEntity))`; true when the
    /// item entity was taken whole.
    fn hopper_take_item(&mut self, pos: Pos, i: usize) -> bool {
+        if self.hoppers.get(&pos).is_some_and(|h| h.cooldown > 0) {
+            return false;
+        }
        let state = self.world.block(pos.0, pos.1, pos.2);
        let c = self.containers();
+        if c.prop(state, "enabled") == Some("false") {
+            return false;
+        }
        let Some(view) = c.view(pos, false) else {
            return false;
        };
-        if c.prop(state, "enabled") == Some("false")
-            || self.hoppers.get(&pos).is_some_and(|h| h.cooldown > 0)
-        {
-            return false;
-        }
        let mut changed = false;
        if !c.is_empty(&view) {
-            changed = self.hopper_eject(pos, &view);
+            changed = self.hopper_eject_with_state(pos, state, &view);
        }
        let c = self.containers();
        let full =
@@ -1043,8 +1133,7 @@ impl Game<'_> {
    }
    /// `HopperBlockEntity.ejectItems`: into the block container in front, else
    /// a container entity there (`getContainerAt`).
-    fn hopper_eject(&mut self, pos: Pos, hopper: &View) -> bool {
-        let state = self.world.block(pos.0, pos.1, pos.2);
+    fn hopper_eject_with_state(&mut self, pos: Pos, state: BlockStateId, hopper: &View) -> bool {
        let c = self.containers();
        let Some(facing) = c.prop(state, "facing").and_then(dir_from_name) else {
            return false;
@@ -1156,6 +1245,9 @@ impl Game<'_> {
        if blocked {
            return false;
        }
+        if self.dropped.is_empty() {
+            return false;
+        }
        // Hopper.SUCK_AABB: the hopper bowl and the block above.
        let (min, max) = (
            [
@@ -1214,7 +1306,7 @@ impl Game<'_> {
            // second setChanged after the move or, when the hopper has no
            // room, the setItem putting the bone meal back into the detached
            // container (whose bone meal is lost with it).
-            let bone_meal = c.bone_meal.clone();
+            let bone_meal = bone_meal_stack().clone();
            if !horizon_client::mod_api::mods().is_empty() {
                let mut cancel = false;
                self.native_inventory_move_item(
@@ -1244,13 +1336,15 @@ impl Game<'_> {
        source: &View,
        hopper: &View,
    ) -> bool {
-        for slot in source.slots_for_face(Some(Direction::Down)) {
-            let c = self.containers();
-            let Some(stack) = c.get(source, slot) else {
-                continue;
-            };
-            if !c.can_take(source, slot, stack, Direction::Down) {
-                continue;
+        for slot in source.slots_for_face_iter(Some(Direction::Down)) {
+            {
+                let c = self.containers();
+                let Some(stack) = c.get(source, slot) else {
+                    continue;
+                };
+                if !c.can_take(source, slot, stack, Direction::Down) {
+                    continue;
+                }
            }
            if self.hopper_move_canceled(source, slot, source, hopper) {
                continue;
@@ -1269,7 +1363,9 @@ impl Game<'_> {
                    }
                    return true;
                }
-                Some(rest) => self.put_back(source, slot, rest),
+                Some(rest) => {
+                    self.put_back(source, slot, rest);
+                }
            }
        }
        false
@@ -1279,6 +1375,9 @@ impl Game<'_> {
    /// minecarts, chest boats) whose box meets the 1x1x1 box around `at`,
    /// picked at random.
    fn entity_container_at(&mut self, at: [f64; 3]) -> Option<u32> {
+        if self.carts.is_empty() && self.boats.is_empty() {
+            return None;
+        }
        let meets = |b: horizon_core::geometry::Aabb| {
            let (lo, hi) = (b.min_position(), b.max_position());
            lo.x < at[0] + 0.5
@@ -300,11 +300,7 @@ impl Game<'_> {
            ) {
                continue;
            }
-            let marks = if player || self.cosmetics_local() {
-                self.cosmetics_marks(m, Some(m.id) == own)
-            } else {
-                Marks::default()
-            };
+            let marks = self.hooks_name_marks(m, Some(m.id) == own);
            let at = match marks.top {
                Some(top) => p + glam::DVec3::Y * cosmetic_lift(top, m.model_scale()),
                None => p,
@@ -770,10 +766,10 @@ impl Game<'_> {
                    if background { BACKGROUND } else { 0 },
                ),
            };
-            if n == last && marks.horizon {
+            if let Some(mark) = marks.mark.filter(|_| n == last) {
                let x = -self.gui.atlas.font.width_text(text) / 2.0 - 10.0;
                // 8 text pixels square, a pixel left of the background.
-                for &(mx, my, w, h, argb) in super::cosmetics::MARK {
+                for &(mx, my, w, h, argb) in mark {
                    let a = text_alpha * (argb >> 24) / 255;
                    batch.fill(
                        &self.gui.atlas,
@@ -937,10 +933,11 @@ struct NameTag {
    marks: Marks,
 }

-/// What Horizon draws by a player's name: its mark (they play Horizon) and their name tag style.
+/// What a hook draws by a player's name (`horizon_hooks::players::NameDecoration`): a mark
+/// before it (Horizon's: they play Horizon) and a name tag style.
 #[derive(Clone, Copy, Default)]
 pub(super) struct Marks {
-    pub horizon: bool,
+    pub mark: Option<horizon_hooks::players::Mark>,
    pub style: Option<TagStyle>,
    /// How high the cosmetics drawn on their body get above the neck, in model pixels: the tag
    /// goes up over a tall one (`cosmetic_lift`).
@@ -471,6 +471,7 @@ pub(crate) mod tests {
            dim: game.dim,
            pos: [1, 2, 3],
            yaw: 0.0,
+            pitch: 0.0,
            forced: false,
        };
        let spawn = Vec3::new(1.0, 2.0, 3.0);
@@ -46,6 +46,8 @@ pub(super) struct SpawnScratch {
    /// dx/dz order, that no earlier player's square holds.
    segments: Vec<Vec<(i32, i32)>>,
    stale: Vec<bool>,
+    /// Reusable buffer for spawn players across ticks to avoid heap allocation.
+    pub(super) spawn_players: Vec<SpawnPlayer>,
 }
 impl SpawnScratch {
    fn chunk(p: &LevelPlayer) -> (i32, i32) {
@@ -128,6 +130,20 @@ impl SpawnScratch {
        self.prepare(players);
        self.candidates.clear();
        let mut count = 0;
+        if players.len() == 1 {
+            let p = &players[0];
+            count = self.segments.first().map_or(0, |s| s.len());
+            if !p.spectator
+                && let Some(segment) = self.segments.first()
+            {
+                for &c in segment {
+                    if close_enough_for_spawning(p, c) && keep(c) {
+                        self.candidates.push(c);
+                    }
+                }
+            }
+            return count as i32;
+        }
        for (i, segment) in self.segments.iter().enumerate() {
            count += segment.len();
            let near = &self.neighbours[i];
@@ -650,8 +666,10 @@ fn spawn_cost_types(biomes: &horizon_client::biome::Biomes) -> Vec<&str> {
    types
 }
 impl<'a> Game<'a> {
-    pub(super) fn natural_level(&self) -> GameLevel<'_, 'a> {
-        let players = self.level_players();
+    pub(super) fn natural_level_with_players(
+        &self,
+        players: Vec<LevelPlayer>,
+    ) -> GameLevel<'_, 'a> {
        let nearest = players
            .iter()
            .filter(|p| !p.spectator)
@@ -670,6 +688,9 @@ impl<'a> Game<'a> {
            costed: spawn_cost_types(world_biomes!(self)),
        }
    }
+    pub(super) fn natural_level(&self) -> GameLevel<'_, 'a> {
+        self.natural_level_with_players(self.level_players())
+    }
    /// Creates a mob the spawner accepted, finalized the game's way; the
    /// caller adds it with [`Game::add_spawned`].
    fn finalize_spawned(&self, r: &SpawnRequest, pending: &mut Vec<Mob>) -> Option<Spawned> {
@@ -773,6 +794,8 @@ impl<'a> Game<'a> {
        scratch: &mut SpawnScratch,
    ) -> i32 {
        let levels = self.tickets.levels();
+        // Recomputed each pass: a chunk's ticket level and entity loading change without the
+        // players moving or the chunk count changing.
        scratch.collect(players, |(cx, cz)| {
            levels.loaded_ticking(cx, cz) && super::ticking_chunk(&self.world, cx, cz)
        })
@@ -819,31 +842,28 @@ impl<'a> Game<'a> {
        {
            let level = self.natural_level();
            laps.lap("sn_level");
-            let counted: Vec<Counted> = self
-                .mobs
-                .iter()
-                .map(|m| Counted {
-                    entity: &m.kind.id,
-                    category: Category::from_name(&m.kind.category),
-                    block: [
-                        m.position.x.floor() as i32,
-                        m.position.y.floor() as i32,
-                        m.position.z.floor() as i32,
-                    ],
-                    is_mob: true,
-                    persistent: m.persistent
-                        || horizon_client::mobs::ai::requires_custom_persistence(m),
-                })
-                .collect();
-            let players = players
-                .iter()
-                .map(|p| SpawnPlayer {
+            let counted = self.mobs.iter().map(|m| Counted {
+                entity: &m.kind.id,
+                category: Category::from_name(&m.kind.category),
+                block: [
+                    m.position.x.floor() as i32,
+                    m.position.y.floor() as i32,
+                    m.position.z.floor() as i32,
+                ],
+                is_mob: true,
+                persistent: m.persistent
+                    || horizon_client::mobs::ai::requires_custom_persistence(m),
+            });
+            scratch.spawn_players.clear();
+            scratch
+                .spawn_players
+                .extend(players.iter().map(|p| SpawnPlayer {
                    position: [p.position.x, p.position.y, p.position.z],
                    spectator: p.spectator,
-                })
-                .collect();
+                }));
+            let spawn_players = std::mem::take(&mut scratch.spawn_players);
            laps.lap("sn_materialize");
-            let mut state = SpawnState::new(&level, spawnable, players, &counted, |cx, cz| {
+            let mut state = SpawnState::new(&level, spawnable, spawn_players, counted, |cx, cz| {
                self.world.chunks.contains_key(&(cx, cz))
            });
            laps.lap("sn_state");
@@ -854,7 +874,8 @@ impl<'a> Game<'a> {
                Vec::new()
            };
            laps.lap("sn_categories");
-            // Util.shuffle.
+            // Util.shuffle, every pass: it draws from the level's random even when no
+            // category may spawn.
            for i in (1..scratch.candidates.len()).rev() {
                let j = random.next_int_bound(i as i32 + 1).unwrap_or(0) as usize;
                scratch.candidates.swap(i, j);
@@ -885,6 +906,7 @@ impl<'a> Game<'a> {
                    );
                }
            }
+            scratch.spawn_players = state.into_players();
        }
        spawn_selection::attempt_counters(true);
        laps.lap("sn_attempts");
@@ -93,10 +93,9 @@ impl ApplicationHandler for Missing {
        if self.window.is_some() {
            return;
        }
-        let attributes = horizon_client::window::with_horizon_icon(
-            Window::default_attributes().with_title("Horizon"),
-        )
-        .with_inner_size(winit::dpi::LogicalSize::new(1040.0, 700.0));
+        let attributes =
+            horizon_client::window::with_icon(Window::default_attributes().with_title("Horizon"))
+                .with_inner_size(winit::dpi::LogicalSize::new(1040.0, 700.0));
        let made = event_loop
            .create_window(attributes)
            .map_err(Into::into)
@@ -185,7 +185,7 @@ impl Game<'_> {
        let output = self
            .renderer
            .as_ref()
-            .map_or(Default::default(), |r| *r.output());
+            .map_or(Default::default(), |r| r.output());
        ui.draw(&self.settings, output, batch, &self.gui.atlas, self.cursor);
        self.ui.options = ui;
        self.show_calibration((batch.width, batch.height));
@@ -280,11 +280,11 @@ impl Game<'_> {
    /// front of) it, pulled in where visual shapes are in the way. Returns the
    /// position, yaw and pitch to render from.
    pub(super) fn camera_view(&mut self, partial: f32) -> Option<(glam::DVec3, f32, f32)> {
-        if self.studio_freecam.active {
+        if self.studio.flying() {
            return Some((
-                self.studio_freecam.position,
-                self.studio_freecam.yaw,
-                self.studio_freecam.pitch,
+                self.studio.freecam.position,
+                self.studio.freecam.yaw,
+                self.studio.freecam.pitch,
            ));
        }
        // Minecraft.cameraEntity: a server's spectator camera on a mob or
@@ -311,8 +311,8 @@ impl Game<'_> {
            }
        };
        let mut view = self.view;
-        // An emote pulls the camera back from the player's face (`game/cosmetics/emotes.rs`).
-        let pull = self.emote_camera_pull(partial);
+        // A hook may pull the camera back (an emote, from the player's face).
+        let pull = self.hooks_camera_distance(partial);
        let kind = match self.camera_type {
            CameraType::FirstPerson => horizon_client::camera::CameraType::FirstPerson,
            CameraType::ThirdPersonBack => horizon_client::camera::CameraType::ThirdPersonBack,
@@ -643,8 +643,9 @@ impl Game<'_> {
    /// The model's old pitch is the player's `xRotO`, which the turn moves
    /// with `xRot` (`turn_rotation`).
    pub(super) fn turn_player(&mut self, xo: f64, yo: f64) {
-        if self.studio_freecam.active {
-            self.studio_freecam
+        if self.studio.flying() {
+            self.studio
+                .freecam
                .turn((xo * 0.15) as f32, (yo * 0.15) as f32);
            return;
        }
@@ -697,7 +698,7 @@ impl Game<'_> {
    /// `LevelExtractor`'s skip of the camera entity: the player's own body
    /// is drawn unless the camera is in first person, or while it sleeps.
    pub(super) fn own_body_in_view(&self) -> bool {
-        !self.camera_type.first_person() || self.sleeping.is_some() || self.studio_freecam.active
+        !self.camera_type.first_person() || self.sleeping.is_some() || self.studio.flying()
    }
    /// Whether the player's own model shows in the world view (its body or,
    /// while invisible, only its armour and held items).
@@ -800,19 +801,8 @@ impl Game<'_> {
                packed,
                out,
            );
-            if super::cosmetics::enabled() {
-                let base = horizon_client::mobs::render::base_transform(m, alpha as f32, camera);
-                self.cosmetics_geometry(
-                    m,
-                    true,
-                    base,
-                    Some(camera),
-                    alpha as f32,
-                    packed,
-                    false,
-                    out,
-                );
-            }
+            let world = horizon_hooks::players::Pass::World;
+            self.own_layers_geometry(m, world, camera, alpha as f32, packed, out);
            self.player_elytra_geometry(m, chest, camera, alpha as f32, packed, out);
            self.spin_attack_geometry(m, camera, alpha as f32, packed, out);
            self.shoulder_parrots_geometry(m, camera, alpha as f32, packed, out);
@@ -926,10 +916,8 @@ impl Game<'_> {
            240 | 240 << 8,
            &mut verts,
        );
-        if super::cosmetics::enabled() {
-            let base = horizon_client::mobs::render::base_transform(&m, 1.0, camera);
-            self.cosmetics_geometry(&m, true, base, None, 1.0, 240 | 240 << 8, false, &mut verts);
-        }
+        let picture = horizon_hooks::players::Pass::Picture;
+        self.own_layers_geometry(&m, picture, camera, 1.0, 240 | 240 << 8, &mut verts);
        // `WingsLayer` draws through `RenderTypes.armorCutoutNoCull`: the
        // wings' faces show from both sides (the elytra texture is empty on
        // the face that looks at the body).
@@ -738,14 +738,11 @@ impl Game<'_> {
        });
        self.set_pushed_on_ground(target, limited, resolved);

-        // Entity.move updates ground before its tiny-collision return. This
-        // native slice covers only unoccupied server NoAI horizontal moves.
-        if let Target::Entity(EntityHandle::Mob(i)) = target {
+        // shortcut: unoccupied server mobs only, expand when controller/passenger authority is bound.
+        let mob = if let Target::Entity(EntityHandle::Mob(i)) = target {
            let m = &self.mobs[i];
-            let eligible = !self.options.execution_role.is_client()
+            (!self.options.execution_role.is_client()
                && self.remote.is_none()
-                && limited.y == 0.0
-                && m.no_ai
                && !m.extra.passenger
                && m.extra.mount.is_none()
                && m.rider.is_none()
@@ -757,16 +754,22 @@ impl Game<'_> {
                        .guests
                        .iter()
                        .any(|g| host.hub.here(g) && g.vehicle == Some(m.id))
-                });
-            if eligible {
-                self.mobs[i].on_ground = limited.y < 0.0 && limited.y != resolved.y;
-            }
+                }))
+            .then_some(i)
+        } else {
+            None
+        };
+        // Entity.move updates ground before its tiny-collision return.
+        if let Some(i) = mob
+            && self.mobs[i].no_ai
+        {
+            self.mobs[i].on_ground = limited.y < 0.0 && limited.y != resolved.y;
+        }
+        let tnt_after_move =
+            tnt.is_some() && !self.options.execution_role.is_client() && self.remote.is_none();
+        if mob.is_none() && !tnt_after_move {
+            self.restitute_piston(target, limited, resolved);
        }
-        // `Entity.move(MoverType.PISTON, …)` restitution, which runs whether or
-        // not the step is applied: so a primed TNT in a chunk that does not tick
-        // entities still loses its velocity into walls and ceilings and
-        // bounces on slime (#12022).
-        self.restitute_piston(target, limited, resolved);
        let moved = resolved.length_squared() > 1.0e-7
            || limited.length_squared() - resolved.length_squared() < 1.0e-7;
        if moved {
@@ -775,6 +778,12 @@ impl Game<'_> {
            // A move the collisions cut to nothing still ends in the check.
            self.release_after_block_move(target);
        }
+        // Restitution reads the new landing block even when the push was blocked.
+        if let Some(i) = mob {
+            self.mobs[i].restitute_movement(&self.world, &self.motion.blocks, limited, resolved);
+        } else if tnt_after_move {
+            self.restitute_piston(target, limited, resolved);
+        }
        if let Some((i, from, ..)) = tnt {
            self.finish_tnt_piston_move(i, from, resolved);
        }
@@ -1053,6 +1062,7 @@ mod tests {
 mod order_tests {
    use crate::game::{Audio, Game, Options, Progress, Settings, load_resources};
    use horizon_client::chunk::Chunk;
+    use horizon_core::geometry::Vec3;
    use horizon_core::{geometry::Direction, position::BlockPos};
    use horizon_world::level::pistons::MovingPiston;
    use std::sync::Arc;
@@ -1151,8 +1161,9 @@ mod order_tests {
        }
        // The near stone's box reaches x 5.5 into a TNT from x 5.01: 0.49 plus
        // PUSH_OFFSET; the far stone's old box stops it at x 6.
+        // Vanilla's TNT width is 0.98F, not the exact decimal 0.98.
        assert!(
-            (moved[0] - 0.5).abs() < 1e-9,
+            (moved[0] - 0.500000009536743).abs() < 1e-9,
            "far stone gone first: {}",
            moved[0]
        );
@@ -1251,7 +1262,7 @@ mod order_tests {
    }

    /// A primed TNT pushed down by a piston onto a slime block bounces up,
-    /// matching vanilla's slime restitution (~+0.64) even in a lazy chunk (#12022).
+    /// matching vanilla's restitution even in a lazy chunk (#12022).
    #[test]
    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
    fn a_pushed_tnt_bounces_on_slime() {
@@ -1312,32 +1323,36 @@ mod order_tests {
            death_ticks: 0,
            id: 1,
        };
-        game.block_ticks.moving_pistons = vec![(BlockPos::new(5, 200, 5), piston)];
-        game.sync_moving_pistons();
-        game.tnts.clear();
-        assert!(game.run_command("summon tnt 5.5 200.5 5.5 {fuse:80,Motion:[0.0d,-0.4d,0.0d]}"));
-        assert!(
-            (game.tnts[0].velocity.y - (-0.4)).abs() < 1.0e-9,
-            "TNT starts with vy -0.4, got {:?}",
-            game.tnts[0].velocity
-        );
-        // Piston advances from progress 0 to 0.5 and pushes the TNT down.
-        let pushes: Vec<_> = game
-            .block_ticks
-            .moving_pistons
-            .iter()
-            .map(|&(pos, old)| (pos, old, old.progress + 0.5))
-            .collect();
-        for (_, piston) in &mut game.block_ticks.moving_pistons {
-            piston.progress += 0.5;
+        // Pinned 26.3 PistonMovingBlockEntity.moveCollidedEntities, without entity ticks.
+        for (floor, y, vy, final_y, final_vy) in [
+            (slime, 200.5, -0.4, 200.0, 0.3510000138133766_f64),
+            (stone, 200.5, -0.4, 200.0, 0.0),
+            (slime, 200.0, -0.4, 200.0, 0.3200000047683716),
+            (slime, 200.00001, -0.4, 200.00001, 0.32000064476813395),
+            (slime, 200.5, 0.3, 200.0, 0.0),
+        ] {
+            game.world.set(5, 199, 5, floor).unwrap();
+            game.block_ticks.moving_pistons = vec![(BlockPos::new(5, 200, 5), piston)];
+            game.sync_moving_pistons();
+            game.tnts.clear();
+            assert!(game.run_command(&format!(
+                "summon tnt 5.5 {y} 5.5 {{fuse:80,Motion:[0.0d,{vy}d,0.0d]}}"
+            )));
+            assert_eq!(game.tnts[0].velocity.y, vy);
+            let pushes: Vec<_> = game
+                .block_ticks
+                .moving_pistons
+                .iter()
+                .map(|&(pos, old)| (pos, old, old.progress + 0.5))
+                .collect();
+            for (_, piston) in &mut game.block_ticks.moving_pistons {
+                piston.progress += 0.5;
+            }
+            game.push_piston_entities(pushes);
+            assert_eq!(game.tnts[0].position, Vec3::new(5.5, final_y, 5.5));
+            assert_eq!(game.tnts[0].velocity.y.to_bits(), final_vy.to_bits());
+            assert!(game.tnts[0].on_ground);
        }
-        game.push_piston_entities(pushes);
-        // The slime block at y=199 bounces the TNT up; vertical velocity must be positive.
-        assert!(
-            game.tnts[0].velocity.y > 0.0,
-            "TNT should bounce up on slime, got vy {:?}",
-            game.tnts[0].velocity
-        );
    }
 }

@@ -1602,6 +1617,54 @@ mod h255_mob_piston_ground_tests {
    }
    #[test]
    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+    fn h255_added_tnt_authority_and_exhausted_budget() {
+        use crate::game::execution_role::ExecutionRole;
+        for role in [
+            ExecutionRole::Client,
+            ExecutionRole::IntegratedServer,
+            ExecutionRole::DedicatedServer,
+        ] {
+            with_role_game(role, |game| {
+                assert!(game.run_command("setblock 5 199 5 slime_block"));
+                assert!(
+                    game.run_command("summon tnt 5.5 200.5 5.5 {fuse:80,Motion:[0d,-0.4d,0d]}")
+                );
+                let mut budget = std::collections::HashMap::new();
+                let push = |game: &mut Game<'_>,
+                            budget: &mut std::collections::HashMap<_, _>,
+                            movement| {
+                    let tnt = &game.tnts[0];
+                    game.move_pushed(
+                        Target::Entity(EntityHandle::Tnt(0)),
+                        tnt.bounds(),
+                        [tnt.position.x, tnt.position.z],
+                        0.0,
+                        tnt.on_ground,
+                        movement,
+                        Direction::Down,
+                        budget,
+                    );
+                };
+                push(game, &mut budget, Vec3::ZERO);
+                assert_eq!(game.tnts[0].position.y, 200.5);
+                assert_eq!(game.tnts[0].velocity.y, -0.4);
+                push(game, &mut budget, Vec3::new(0.0, -0.51, 0.0));
+                let expected = if role.is_client() {
+                    0.0_f64
+                } else {
+                    0.3510000138133766
+                };
+                assert_eq!(game.tnts[0].velocity.y.to_bits(), expected.to_bits());
+                game.tnts[0].position.y = 200.5;
+                game.tnts[0].velocity.y = -0.4;
+                push(game, &mut budget, Vec3::new(0.0, -0.51, 0.0));
+                assert_eq!(game.tnts[0].position.y, 200.5);
+                assert_eq!(game.tnts[0].velocity.y, -0.4);
+            });
+        }
+    }
+    #[test]
+    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
    fn h255_added_no_request_and_exhausted_budget_keep_state() {
        with_game(|game| {
            let i = added_mob(game, 20, "horse", true, 8.5);
@@ -1613,6 +1676,16 @@ mod h255_mob_piston_ground_tests {
            added_push(game, i, Vec3::new(0.51, 0.0, 0.0));
            assert!(game.mobs[i].on_ground, "occupied path remains excluded");
            assert_eq!(game.mobs[i].position, Vec3::new(9.01, 202.0, 4.5));
+            assert!(game.run_command("setblock 9 201 4 slime_block"));
+            game.mobs[i].position.y = 202.25;
+            game.mobs[i].velocity = Vec3::new(0.0, -1.0, 0.0);
+            game.mobs[i].sync_position = false;
+            added_push(game, i, Vec3::new(0.0, -0.5, 0.0));
+            assert_eq!(
+                game.mobs[i].velocity.y, 0.0,
+                "occupied restitution stays outside this slice"
+            );
+            assert!(!game.mobs[i].sync_position);
            assert!(game.run_command("ride @s dismount"));
            assert!(game.riding.is_none());
            assert!(game.mobs[i].rider.is_none());
@@ -1655,23 +1728,46 @@ mod h255_mob_piston_ground_tests {
    }
    #[test]
    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
-    fn h255_added_client_role_ai_and_vertical_paths_keep_native_state() {
+    fn h255_added_client_role_ai_and_vertical_ground_state() {
        use crate::game::execution_role::ExecutionRole as Role;
-        for (role, no_ai, movement) in [
-            (Role::Client, true, Vec3::new(0.25, 0.0, 0.0)),
-            (Role::IntegratedServer, false, Vec3::new(0.25, 0.0, 0.0)),
-            (Role::IntegratedServer, true, Vec3::new(0.0, 0.25, 0.0)),
+        for (role, no_ai, movement, on_ground) in [
+            (Role::Client, true, Vec3::new(0.25, 0.0, 0.0), true),
+            (
+                Role::IntegratedServer,
+                false,
+                Vec3::new(0.25, 0.0, 0.0),
+                true,
+            ),
+            (
+                Role::IntegratedServer,
+                true,
+                Vec3::new(0.0, 0.25, 0.0),
+                false,
+            ),
        ] {
            with_role_game(role, |game| {
                let i = added_mob(game, 22, "husk", no_ai, 8.5);
                let before = game.mobs[i].position;
                added_push(game, i, movement);
                assert_eq!(game.mobs[i].position, before.add_vector(movement));
-                assert!(
-                    game.mobs[i].on_ground,
-                    "excluded native path remains unchanged; not Java parity"
-                );
+                assert_eq!(game.mobs[i].on_ground, on_ground);
            });
        }
    }
+
+    #[test]
+    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+    fn h255_added_partial_push_reads_slime_after_the_position_changes() {
+        with_game(|game| {
+            assert!(game.run_command("setblock 8 201 4 slime_block"));
+            let i = added_mob(game, 23, "iron_golem", true, 8.5);
+            game.mobs[i].position.y = 202.25;
+            game.mobs[i].velocity = Vec3::new(0.0, -1.0, 0.0);
+            game.mobs[i].sync_position = false;
+            added_push(game, i, Vec3::new(0.0, -0.5, 0.0));
+            assert_eq!(game.mobs[i].position, Vec3::new(8.5, 202.0, 4.5));
+            assert!(game.mobs[i].velocity.y > 0.9);
+            assert!(game.mobs[i].sync_position);
+        });
+    }
 }
@@ -180,7 +180,7 @@ impl Game<'_> {
        raw: KeyCode,
        source: Source,
    ) -> Result<()> {
-        if self.screen == Screen::Playing && self.studio_replay.is_some() {
+        if self.screen == Screen::Playing && self.replay.playing() {
            if !pressed {
                self.keys.release(&key, source);
                return Ok(());
@@ -191,7 +191,7 @@ impl Game<'_> {
                }
                return Ok(());
            }
-            if !studio_freecam_movement_key(key) || !self.studio_freecam.active {
+            if !studio_freecam_movement_key(key) || !self.studio.flying() {
                return Ok(());
            }
        }
@@ -10,41 +10,8 @@ impl Game<'_> {
    /// the container's hotbar keys are now (`checkHotbarKeyPressed`).
    pub(super) fn key_pressed(&mut self, key: KeyCode, raw: KeyCode) -> Result<()> {
        self.direct_craft_stop();
-        if self.screen == Screen::Playing && self.studio_replay.is_some() {
-            match key {
-                KeyCode::Escape => {
-                    self.close_studio_replay();
-                    return Ok(());
-                }
-                KeyCode::KeyP => {
-                    self.pause_focus = None;
-                    self.screen = Screen::Paused;
-                    self.pause_menu = true;
-                    self.capture(false);
-                }
-                KeyCode::KeyF => self.handle_studio_timeline_action(
-                    horizon_client::studio::TimelineAction::ToggleFreecam,
-                ),
-                KeyCode::KeyT => self.studio_timeline.visible = !self.studio_timeline.visible,
-                KeyCode::KeyM => self.add_studio_marker(),
-                KeyCode::Home => self.handle_studio_topbar_action(
-                    horizon_client::studio::TopBarAction::ResetCameraToPlayer,
-                ),
-                KeyCode::KeyL => {
-                    self.studio_freecam.locked_to_path = !self.studio_freecam.locked_to_path;
-                }
-                KeyCode::KeyK => self.handle_studio_timeline_action(
-                    horizon_client::studio::TimelineAction::AddCameraKeyframe,
-                ),
-                KeyCode::Delete => {
-                    if let Some(index) = self.studio_timeline.selected_keyframe {
-                        self.handle_studio_timeline_action(
-                            horizon_client::studio::TimelineAction::RemoveCameraKeyframe(index),
-                        );
-                    }
-                }
-                _ => {}
-            }
+        if self.screen == Screen::Playing && self.replay.playing() {
+            self.studio_key(key);
            return Ok(());
        }
        // `CreativeModeInventoryScreen.keyPressed` clears `ignoreTextInput` on
@@ -78,7 +45,7 @@ impl Game<'_> {
            KeyCode::Escape => match self.screen {
                Screen::Options => self.options_key(KeyCode::Escape, None)?,
                Screen::Playing => {
-                    if self.studio_replay.is_some() && self.captured {
+                    if self.replay.playing() && self.captured {
                        self.capture(false);
                        return Ok(());
                    }
@@ -213,7 +180,7 @@ impl Game<'_> {
            // key.toggleGui is a KeyMapping: it clicks only with no screen open.
            KeyCode::F1 if self.screen == Screen::Playing => self.toggle_hide_gui(),
            KeyCode::F11 => self.toggle_fullscreen(),
-            KeyCode::F5 if self.screen == Screen::Playing && self.studio_replay.is_none() => {
+            KeyCode::F5 if self.screen == Screen::Playing && !self.replay.playing() => {
                self.cycle_camera()
            }
            KeyCode::KeyE
@@ -0,0 +1,613 @@
+//! Where the game hands the player models to crates above the engine (`horizon_hooks::Hooks`'s
+//! `frame`, `tick`, `name_decoration`, `player_mark`, `camera`; spec #14091): only a window's
+//! game calls them, never the integrated server's thread or a dedicated server. With no hook
+//! registered nothing is built.
+
+use super::Game;
+use horizon_client::fast_hash::FxHashMap;
+use horizon_client::join_seq::JoinList;
+use horizon_client::mesher::Vertex;
+use horizon_client::mobs::anim::{self, BodyPose, PooledPoses, Poses};
+use horizon_client::mobs::{Mob, Part, Polygon, render};
+use horizon_hooks::engine;
+use horizon_hooks::players::{
+    Bone, CameraView, Frame, Gear, Kind, Light, Look, Mesh, Motion, PartPoses, Particle, Pass,
+    PlayerDraw, PlayerModel, PlayerModels, SpriteStore, Sprites, View,
+};
+use std::sync::Arc;
+
+/// Registers the hooks of the Horizon parts still in this crate (cosmetics: spec #14091 step 5
+/// moves them out). Before the hooks are sealed.
+pub(crate) fn register() {
+    if let Err(e) = super::cosmetics::register() {
+        log::error!("Cosmetics: their hooks came too late: {e}");
+    }
+}
+
+/// The models of the world a window shows: its own first, then the other players and mannequins.
+struct Models<'a> {
+    own: Option<&'a mut Mob>,
+    mobs: &'a mut JoinList<Mob>,
+    remote: &'a super::remote::Remote,
+}
+
+impl Models<'_> {
+    fn find(&mut self, id: u32) -> Option<&mut Mob> {
+        match self.own.as_deref_mut() {
+            Some(m) if m.id == id => Some(m),
+            _ => self
+                .mobs
+                .iter_mut()
+                .find(|m| m.id == id && kind(m).is_some()),
+        }
+    }
+}
+
+/// What kind of player model `m` is, if it is one (the window's own model aside).
+fn kind(m: &Mob) -> Option<Kind> {
+    match &*m.kind.id {
+        "minecraft:player" => Some(Kind::Player),
+        "minecraft:mannequin" => Some(Kind::Mannequin),
+        _ => None,
+    }
+}
+
+/// What `m` wears where a crate may draw: a helmet or head item, a chestplate, a cape or elytra.
+pub(super) fn gear(m: &Mob) -> Gear {
+    let elytra = m.extra.chest.as_deref() == Some("minecraft:elytra");
+    Gear::new(
+        m.extra.head.is_some(),
+        m.extra.chest.is_some() && !elytra,
+        m.cape.is_some() || elytra,
+    )
+}
+
+fn model(m: &Mob, kind: Kind, uuid: Option<u128>) -> PlayerModel {
+    let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
+    PlayerModel::new(m.id, kind, uuid, m.age, dx * dx + dz * dz > 1e-4)
+        .looks(gear(m), horizon_client::mobs::trader::is_invisible(m))
+}
+
+impl PlayerModels for Models<'_> {
+    fn connection(&self) -> u64 {
+        self.remote.session.serial()
+    }
+
+    fn for_each(&self, f: &mut dyn FnMut(PlayerModel)) {
+        if let Some(m) = self.own.as_deref() {
+            f(model(m, Kind::Own, Some(self.remote.profile())));
+        }
+        for m in self.mobs.iter() {
+            if let Some(kind) = kind(m) {
+                let uuid = (kind == Kind::Player)
+                    .then(|| self.remote.player_uuid(m.id))
+                    .flatten();
+                f(model(m, kind, uuid));
+            }
+        }
+    }
+
+    fn body_pose(&self, id: u32) -> Option<&Arc<dyn BodyPose>> {
+        match self.own.as_deref() {
+            Some(m) if m.id == id => m.emote.as_ref(),
+            _ => self
+                .mobs
+                .iter()
+                .find(|m| m.id == id && kind(m).is_some())?
+                .emote
+                .as_ref(),
+        }
+    }
+
+    fn set_body_pose(&mut self, id: u32, pose: Option<Arc<dyn BodyPose>>) {
+        if let Some(m) = self.find(id) {
+            m.emote = pose;
+        }
+    }
+}
+
+/// Sprite `id`'s place in the atlas's names (`hooks/<hex>`), written into `buf`: no allocation.
+fn location(id: u64, buf: &mut [u8; 22]) -> &str {
+    use std::io::Write;
+    let mut out = std::io::Cursor::new(&mut buf[..]);
+    let _ = write!(out, "hooks/{id:x}");
+    let len = out.position() as usize;
+    std::str::from_utf8(&buf[..len]).unwrap_or_default()
+}
+
+/// The crates' sprites in the GUI atlas, in the skin slots: read while drawing.
+struct HookSprites<'a, 'g>(&'a Game<'g>);
+
+impl Sprites for HookSprites<'_, '_> {
+    fn get(&self, id: u64) -> Option<[f32; 4]> {
+        let mut buf = [0; 22];
+        let at = location(id, &mut buf);
+        let r = self.0.gui.atlas.sprites.get(at)?;
+        // Kept this frame (`skin_slots.next_frame`).
+        self.0.skin_downloads.borrow_mut().drawn(at);
+        Some([r.u0, r.v0, r.u1, r.v1])
+    }
+}
+
+/// Where a crate's frame hook puts its sprites.
+struct HookStore<'a, 'g>(&'a mut Game<'g>);
+
+impl SpriteStore for HookStore<'_, '_> {
+    fn has(&self, id: u64) -> bool {
+        self.0
+            .gui
+            .atlas
+            .sprites
+            .contains_key(location(id, &mut [0; 22]))
+    }
+
+    fn put(&mut self, id: u64, rgba: Vec<u8>) {
+        let at = location(id, &mut [0; 22]).to_owned();
+        self.0.store_skin(at, rgba);
+    }
+}
+
+thread_local! {
+    /// The crates' meshes as the renderer takes them, by the mesh's address (each entry holds its
+    /// mesh, so the address isn't reused); render thread only.
+    static MESHES: std::cell::RefCell<FxHashMap<usize, (Arc<Mesh>, Arc<Part>)>> =
+        Default::default();
+}
+
+/// The game's model of `mesh`, made once.
+fn part_of(mesh: &Arc<Mesh>) -> Arc<Part> {
+    fn part(m: &Mesh) -> Part {
+        Part {
+            name: m.name.clone(),
+            pose: m.pose,
+            polygons: m
+                .quads
+                .iter()
+                .map(|q| Polygon {
+                    normal: q.normal,
+                    vertices: q.vertices,
+                    cull_back: false,
+                })
+                .collect(),
+            children: m.children.iter().map(part).collect(),
+        }
+    }
+    MESHES.with_borrow_mut(|meshes| {
+        let (_, part_of) = meshes
+            .entry(Arc::as_ptr(mesh) as usize)
+            .or_insert_with(|| (mesh.clone(), Arc::new(part(mesh))));
+        part_of.clone()
+    })
+}
+
+/// Full light, packed as the vertices carry it.
+const FULL: u32 = 240 | 240 << 8;
+
+thread_local! {
+    /// What crates draw see-through this frame, added after every player.
+    static SEE_THROUGH: std::cell::RefCell<Vec<Vertex>> = const { std::cell::RefCell::new(Vec::new()) };
+}
+
+/// Forgets the meshes no crate holds any more (once a frame).
+fn forget_meshes() {
+    let _ = MESHES.try_with(|m| {
+        m.borrow_mut()
+            .retain(|_, (mesh, _)| Arc::strong_count(mesh) > 1)
+    });
+}
+
+/// `Poses` as a crate poses a mesh's parts.
+struct PosesOf<'a>(&'a mut Poses);
+
+impl PartPoses for PosesOf<'_> {
+    fn pose(&mut self, name: &str) -> &mut [f32; 9] {
+        self.0.get(name)
+    }
+}
+
+/// A player model drawn, as a crate draws on it: posed on the GPU's skin path
+/// when `gpu` (the mob pass's skin frame, begun; the bounds of what went there grow, for
+/// culling), else its vertices go to `out`.
+struct DrawPlayer<'a, 'g> {
+    game: &'a Game<'g>,
+    m: &'a Mob,
+    pass: Pass,
+    /// The model's matrix (`render::base_transform`).
+    base: glam::Mat4,
+    camera: glam::DVec3,
+    alpha: f32,
+    light: u32,
+    gpu: bool,
+    out: &'a mut Vec<Vertex>,
+    bounds: Option<(glam::Vec3, glam::Vec3)>,
+    /// The body as it is drawn, posed on the first `bone`.
+    body: Option<PooledPoses>,
+    poses: PooledPoses,
+}
+
+impl DrawPlayer<'_, '_> {
+    fn body(&self) -> &Part {
+        let (key, _) = render::body(self.m);
+        self.m.kind.layer(&key).unwrap_or(&self.m.kind.model)
+    }
+
+    /// `light` packed; `at`: the place `Light::AtPlace` reads, relative to the camera.
+    fn packed(&self, light: Light, at: glam::Vec3) -> u32 {
+        match light {
+            Light::Full => FULL,
+            Light::AtPlace => {
+                let p = (self.camera + at.as_dvec3()).floor();
+                let l = self.game.world.light(p.x as i32, p.y as i32, p.z as i32);
+                (u32::from(l >> 4) * 16) | ((u32::from(l & 15) * 16) << 8)
+            }
+            _ => self.light,
+        }
+    }
+}
+
+impl PlayerDraw for DrawPlayer<'_, '_> {
+    fn pass(&self) -> Pass {
+        self.pass
+    }
+
+    fn ticks(&self) -> f32 {
+        self.m.age as f32 + self.alpha
+    }
+
+    fn base(&self) -> [[f32; 4]; 4] {
+        self.base.to_cols_array_2d()
+    }
+
+    fn motion(&self) -> Motion {
+        let (m, a) = (self.m, self.alpha);
+        let t = f64::from(a);
+        let (p, n) = (m.previous, m.position);
+        let feet = [
+            p.x + (n.x - p.x) * t,
+            p.y + (n.y - p.y) * t,
+            p.z + (n.z - p.z) * t,
+        ];
+        let turn = horizon_client::mobs::living::wrap(m.head_yaw - m.previous_head_yaw);
+        let yaw = m.previous_head_yaw + turn * a;
+        let pitch = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * a;
+        let asleep = m.extra.avatar_pose == horizon_client::pose::Pose::Sleeping;
+        let swimming = m.extra.swim.amount(a) > 0.0;
+        Motion::new(feet, yaw, pitch).poses(
+            m.extra.crouching,
+            asleep,
+            m.extra.fall_flying,
+            swimming,
+        )
+    }
+
+    fn view(&self) -> View {
+        let q = self.game.camera_orientation();
+        let (right, up) = (
+            (q * glam::Vec3::X).to_array(),
+            (q * glam::Vec3::Y).to_array(),
+        );
+        let (yaw, pitch) = (self.game.yaw.to_radians(), self.game.pitch.to_radians());
+        let forward = [
+            -yaw.sin() * pitch.cos(),
+            -pitch.sin(),
+            yaw.cos() * pitch.cos(),
+        ];
+        let left = [yaw.cos(), 0.0, yaw.sin()];
+        View::new(self.camera.to_array(), right, up).looking(forward, left)
+    }
+
+    fn bone(&mut self, bone: Bone) -> Option<[[f32; 4]; 4]> {
+        if self.pass == Pass::FirstPerson {
+            return None;
+        }
+        if self.body.is_none() {
+            let mut poses = Poses::pooled();
+            poses.reset(self.body());
+            let data = self.game.res.mob_data();
+            let state = anim::state(self.m, self.alpha);
+            anim::setup(self.m, &state, &mut poses, &data.animations);
+            self.body = Some(poses);
+        }
+        let poses = self.body.as_ref()?;
+        let at = render::part_matrix(self.body(), self.base, poses, bone.part(), 0.0)?;
+        Some(at.to_cols_array_2d())
+    }
+
+    fn body_pose(&self) -> Option<&Arc<dyn BodyPose>> {
+        self.m.emote.as_ref()
+    }
+
+    fn sprite(&self, id: u64) -> Option<[f32; 4]> {
+        HookSprites(self.game).get(id)
+    }
+
+    fn draw(
+        &mut self,
+        mesh: &Arc<Mesh>,
+        matrix: [[f32; 4]; 4],
+        look: Look,
+        pose: &mut dyn FnMut(&mut dyn PartPoses),
+    ) {
+        let model = part_of(mesh);
+        let matrix = glam::Mat4::from_cols_array_2d(&matrix);
+        let (uv, light) = (look.uv, self.packed(look.light, matrix.w_axis.truncate()));
+        self.poses.reset(&model);
+        pose(&mut PosesOf(&mut self.poses));
+        let poses = &self.poses;
+        if let Some(alpha) = look.see_through {
+            let color = ((alpha.clamp(0.0, 1.0) * 255.0) as u32) << 24 | 0x00FF_FFFF;
+            let pose_of = |p: &Part| poses.pose(p);
+            SEE_THROUGH.with_borrow_mut(|out| {
+                let start = out.len();
+                horizon_client::mobs::render_model(&model, matrix, &pose_of, uv, light, 0, out);
+                for v in &mut out[start..] {
+                    v.color = color;
+                    // Seen through, a face turned away would add to the near one: `entity.wgsl`
+                    // drops back faces, so it is `alpha` at most.
+                    v.normal[3] = horizon_client::mesher::SHADED_CULL_W;
+                }
+            });
+            return;
+        }
+        if self.gpu {
+            let mut models = self.game.skin_models.borrow_mut();
+            let mut frame = self.game.skin_frame.borrow_mut();
+            let mut skin = horizon_client::mobs::skin::Skin::new(&mut models, &mut frame);
+            skin.bounds = self.bounds;
+            let paint = horizon_client::mobs::skin::Paint {
+                uv,
+                scroll: 0.0,
+                color: 0xFFFF_FFFF,
+                light,
+                overlay: 0,
+            };
+            if skin.draw(&model, matrix, poses, paint) {
+                self.bounds = skin.bounds;
+                return;
+            }
+        }
+        let pose_of = |p: &Part| poses.pose(p);
+        horizon_client::mobs::render_model(&model, matrix, &pose_of, uv, light, 0, self.out);
+    }
+
+    fn particles(&mut self, uv: [f32; 4], particles: &[Particle], light: Light) {
+        let light = self.packed(light, glam::Vec3::ZERO);
+        SEE_THROUGH.with_borrow_mut(|out| {
+            for q in particles {
+                let color = ((q.alpha.clamp(0.0, 1.0) * 255.0) as u32) << 24 | 0x00FF_FFFF;
+                for (corner, [u, v]) in q.corners.iter().zip(q.uv) {
+                    out.push(Vertex {
+                        pos: *corner,
+                        uv: [uv[0] + (uv[2] - uv[0]) * u, uv[1] + (uv[3] - uv[1]) * v],
+                        layer: 0,
+                        color,
+                        light,
+                        // Unlit: a particle keeps its colour whichever way it faces.
+                        normal: [0, 0, 0, 0],
+                        glint_uv: [0.0, 0.0],
+                    });
+                }
+            }
+        });
+    }
+}
+
+impl Game<'_> {
+    /// What crates draw on player model `m` in the world pass (`creatures.rs`): see
+    /// [`DrawPlayer`]. The bounds of what went to the GPU.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn player_layers_geometry(
+        &self,
+        m: &Mob,
+        base: glam::Mat4,
+        camera: glam::DVec3,
+        alpha: f32,
+        light: u32,
+        gpu: bool,
+        out: &mut Vec<Vertex>,
+    ) -> Option<(glam::Vec3, glam::Vec3)> {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let kind = kind(m).filter(|_| engine::any())?;
+        let model = model(m, kind, self.remote_player_uuid(m.id));
+        let mut draw = DrawPlayer {
+            game: self,
+            m,
+            pass: Pass::World,
+            base,
+            camera,
+            alpha,
+            light,
+            gpu,
+            out,
+            bounds: None,
+            body: None,
+            poses: Poses::pooled(),
+        };
+        engine::player_layers(&model, &mut draw);
+        draw.bounds
+    }
+
+    /// What crates draw on the window's own model `m` (its vertices to `out`): in the world in
+    /// third person (`Pass::World`), or in the inventory's picture of it (`Pass::Picture`).
+    /// `camera`: the world view's camera, or the picture's.
+    pub(super) fn own_layers_geometry(
+        &self,
+        m: &Mob,
+        pass: Pass,
+        camera: glam::DVec3,
+        alpha: f32,
+        light: u32,
+        out: &mut Vec<Vertex>,
+    ) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        if !engine::any() {
+            return;
+        }
+        let model = model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile()));
+        let mut draw = DrawPlayer {
+            game: self,
+            m,
+            pass,
+            base: render::base_transform(m, alpha, camera),
+            camera,
+            alpha,
+            light,
+            gpu: false,
+            out,
+            bounds: None,
+            body: None,
+            poses: Poses::pooled(),
+        };
+        engine::player_layers(&model, &mut draw);
+    }
+
+    /// After every player (`game.rs`): what crates draw around the window's own model in first
+    /// person, then what was drawn see-through, in one span.
+    pub(super) fn players_after_geometry(
+        &self,
+        camera: glam::DVec3,
+        alpha: f64,
+        out: &mut Vec<Vertex>,
+    ) {
+        if engine::any()
+            && !self.own_body_in_view()
+            && let Some(m) = self.player_model.as_ref()
+        {
+            let own = model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile()));
+            let own = own.looks(own.gear, own.invisible || self.own_invisible());
+            self.mark_entity(out.len(), "minecraft:player");
+            let mut draw = DrawPlayer {
+                game: self,
+                m,
+                pass: Pass::FirstPerson,
+                base: render::base_transform(m, alpha as f32, camera),
+                camera,
+                alpha: alpha as f32,
+                light: FULL,
+                gpu: false,
+                out: &mut *out,
+                bounds: None,
+                body: None,
+                poses: Poses::pooled(),
+            };
+            engine::first_person(&own, &mut draw);
+        }
+        let _ = SEE_THROUGH.try_with(|v| {
+            let mut v = v.borrow_mut();
+            if !v.is_empty() {
+                self.mark_translucent_entity(out.len(), "minecraft:player");
+                out.extend_from_slice(&v);
+                v.clear();
+            }
+        });
+    }
+
+    /// Once a frame, before drawing.
+    pub(super) fn client_hooks_frame(&mut self) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        if !engine::any() {
+            return;
+        }
+        self.cosmetics_say();
+        let connection = self.remote.as_ref().map_or(0, |r| r.session.serial());
+        let frame = Frame::new(connection, self.integrated.is_some());
+        engine::frame(&frame, &mut HookStore(self));
+        forget_meshes();
+        let _ = SEE_THROUGH.try_with(|v| v.borrow_mut().clear());
+        self.cosmetics_frame();
+    }
+
+    /// Once a client tick in a world: the player's own emote, then the hooks.
+    pub(super) fn client_hooks_tick(&mut self) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        self.tick_emotes();
+        if !engine::any() {
+            return;
+        }
+        self.cosmetics_say();
+        let Some(remote) = self.remote.as_ref() else {
+            return;
+        };
+        engine::tick(&mut Models {
+            own: self.player_model.as_mut(),
+            mobs: &mut self.mobs,
+            remote,
+        });
+    }
+
+    /// What goes by `m`'s name (`own`: the window's own player), from the hooks.
+    pub(super) fn hooks_name_marks(&self, m: &Mob, own: bool) -> super::names::Marks {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let mut marks = super::names::Marks::default();
+        if !engine::any() {
+            return marks;
+        }
+        let model = match (own, kind(m)) {
+            (true, _) => model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile())),
+            (false, Some(kind)) => model(m, kind, self.remote_player_uuid(m.id)),
+            (false, None) => return marks,
+        };
+        if let Some(d) = engine::name_decoration(&model, &HookSprites(self)) {
+            marks.mark = d.mark;
+            marks.top = d.top;
+            marks.style = d.badge.map(|b| {
+                let [u0, v0, u1, v1] = b.uv;
+                super::names::TagStyle {
+                    mark: horizon_client::hud::Rect {
+                        u0,
+                        v0,
+                        u1,
+                        v1,
+                        w: 8,
+                        h: 8,
+                    },
+                    line: b.line,
+                }
+            });
+        }
+        marks
+    }
+
+    /// How far the third-person camera stands back, as a share of the usual distance: a hook's
+    /// (an emote pulls it back), else 1.
+    pub(super) fn hooks_camera_distance(&self, partial: f32) -> f32 {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        match &self.player_model {
+            Some(m) if engine::any() => {
+                engine::camera(&CameraView::new(m.age as f32 + partial)).map_or(1.0, |c| c.distance)
+            }
+            _ => 1.0,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sprite_locations_fit_the_buffer_and_differ_by_id() {
+        let mut a = [0; 22];
+        let mut b = [0; 22];
+        assert_eq!(location(u64::MAX, &mut a), "hooks/ffffffffffffffff");
+        assert_eq!(location(10, &mut b), "hooks/a");
+    }
+}
@@ -26,7 +26,7 @@ impl Game<'_> {
        let pointer = self.captured || self.agent_pointer;
        let grabbed = pointer
            && self.screen == Screen::Playing
-            && (self.player.is_some() || self.studio_freecam.active);
+            && (self.player.is_some() || self.studio.flying());
        let active = self.focused || self.agent_pointer;
        if let Some((xo, yo)) = self
            .mouse
@@ -75,10 +75,7 @@ impl Game<'_> {
            .is_some_and(|t| t.elapsed() > Duration::from_millis(500))
            && self.control.is_none()
            && self.screen == Screen::Playing
-            && !studio_suppresses_focus_pause(
-                self.studio_replay.is_some(),
-                self.studio_freecam.active,
-            )
+            && !studio_suppresses_focus_pause(self.replay.playing(), self.studio.flying())
            && self.player.is_some()
            && !self.options.no_pause
            && self.settings.file.bool("pauseOnLostFocus")
@@ -149,7 +146,7 @@ impl Game<'_> {
        self.reset_inventory_clicks();
        if !capture {
            self.stop_mining();
-            self.studio_rmb_down = false;
+            self.studio.rmb_down = false;
        }
        // The real pointer takes over from an agent's.
        self.agent_pointer = false;
@@ -353,9 +350,9 @@ impl Game<'_> {
    /// click. A screen that is open keeps it free, as releasing the pointer
    /// for that screen did: it is the screen, not the focus, that shows it.
    pub(super) fn regrab_on_refocus(&mut self) {
-        if self.studio_replay.is_some() || self.studio_freecam.active {
+        if self.studio_up() {
            self.regrab_on_refocus = false;
-            self.studio_rmb_down = false;
+            self.studio.rmb_down = false;
            self.capture(false);
            return;
        }
@@ -2433,7 +2433,7 @@ impl Game<'_> {
    /// view centre, `calculateStorageRange` (the server's radius, at least
    /// two, plus three) chunks each way.
    pub(super) fn remote_chunk_in_range(&self, x: i32, z: i32) -> bool {
-        if self.studio_replay.is_some() {
+        if self.replay.playing() {
            return true;
        }
        self.remote
@@ -3110,33 +3110,6 @@ impl Game<'_> {
                index.get(mobs, id as u32).map(mob_tracking_body)
            });
    }
-    fn remove_entity(&mut self, id: i32) {
-        self.detach_remote_tracking_entity(id);
-        self.audio.remove_sound_entity(id as u32);
-        // Entity.setRemoved detaches every passenger, even when no empty
-        // SetPassengers packet preceded the vehicle's removal. Otherwise
-        // mobs and other players keep their passenger pose after it is gone.
-        self.remote_set_passengers(id, &[]);
-        self.mobs.retain(|m| m.id != id as u32);
-        self.orbs.retain(|o| o.id != id as u32);
-        self.dropped.retain(|d| d.id != id as u32);
-        // Before the crystals go: the dragon's beam index follows them.
-        self.remove_remote_dragon(id);
-        self.remove_remote_object(id as u32);
-        self.remove_remote_projectile(id as u32);
-        self.persist.uuids.remove(&(id as u32));
-        if let Some(r) = self.remote.as_mut() {
-            r.glowing.remove(&id);
-            r.entities.remove(&id);
-            r.passenger_vehicles.remove(&(id as u32));
-            r.passenger_vehicles.retain(|_, v| *v != id as u32);
-            r.lerps.remove(&id);
-            r.cart_lerps.remove(&id);
-            r.stepped.remove(&id);
-            r.head_lerps.remove(&id);
-            r.pending_items.remove(&id);
-        }
-    }
    /// Map a menu slot to Horizon's inventory screen slot ids.
    pub(super) fn menu_slot(menu: &str, slot: i32) -> Option<usize> {
        let s = usize::try_from(slot).ok()?;
@@ -3707,7 +3680,7 @@ impl Game<'_> {
                self.move_remote_interaction(p.id, p.position);
            }
            C::RemoveEntities(p) => {
-                for id in p.ids {
+                for &id in &p.ids {
                    if let Some(r) = self.remote.as_mut() {
                        if let Some(uuid) = r.level_players.remove(&id) {
                            r.attachments.remove(&Holder::Player(uuid));
@@ -3716,8 +3689,8 @@ impl Game<'_> {
                        r.level_player_textures.remove(&id);
                        r.attachments.remove(&Holder::Entity(id as u32));
                    }
-                    self.remove_entity(id);
                }
+                self.remove_entities(&p.ids);
            }
            C::MoveEntityPos(play::MoveEntityPos(m))
            | C::MoveEntityPosRot(play::MoveEntityPosRot(m))
@@ -6185,7 +6158,7 @@ impl Game<'_> {
                self.apply_remote_abilities();
            }
        }
-        if self.studio_replay.is_none() {
+        if !self.replay.playing() {
            self.previous_position = position;
        }
        self.yaw = yaw;
@@ -6521,7 +6494,7 @@ impl Game<'_> {
            return Ok(());
        };
        player.fluids.boat = boat;
-        if !riding && self.studio_replay.is_none() {
+        if !riding && !self.replay.playing() {
            self.previous_position = player.position;
        }
        let before = (
@@ -6728,10 +6701,10 @@ impl Game<'_> {
            self.snap_player_model_pitch();
        }
        // The player's own model (third person, the inventory's preview).
-        if self.studio_replay.is_none() {
+        if !self.replay.playing() {
            self.tick_player_model();
        }
-        self.tick_emotes();
+        self.client_hooks_tick();
        if !dead {
            self.remote_tick_using();
        }
@@ -7269,15 +7242,15 @@ impl Game<'_> {
            } else if m.alive() {
                m.body_rotation_tick();
            }
-            // Squid.aiStep follows LivingEntity's interpolation and head turn.
+            // Squid.aiStep; WalkAnimationState.update from the horizontal distance.
            horizon_client::mobs::aquatic::squid_client_step(m, &mut mob_fx);
-            // WalkAnimationState.update from the horizontal distance moved.
-            let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
-            let (target, factor) = if horizon_client::mobs::camel::is_camel(m.species()) {
-                // Camel.updateWalkAnimation.
-                horizon_client::mobs::camel::walk_target(m, (dx * dx + dz * dz).sqrt() as f32)
+            let d = (m.position.x - m.previous.x).hypot(m.position.z - m.previous.z) as f32;
+            let (target, factor) = if m.species() == horizon_client::mobs::Species::Frog {
+                (horizon_client::mobs::frog::walk_target(m, d), 0.4)
+            } else if horizon_client::mobs::camel::is_camel(m.species()) {
+                horizon_client::mobs::camel::walk_target(m, d)
            } else {
-                ((((dx * dx + dz * dz).sqrt() * 4.0) as f32).min(1.0), 0.4)
+                ((d * 4.0).min(1.0), 0.4)
            };
            m.limb_speed += (target - m.limb_speed) * factor;
            m.limb_position += m.limb_speed;
@@ -10528,7 +10501,7 @@ impl Game<'_> {
    /// A connection's screen is over the world: connecting, reconfiguring, or
    /// the level loading screen, a portal's included (`remote_overlay`).
    pub(super) fn remote_screen_up(&self) -> bool {
-        self.studio_replay.is_none()
+        !self.replay.playing()
            && self
                .remote
                .as_ref()
@@ -10612,7 +10585,7 @@ impl Game<'_> {
    /// Connected or connecting with no player yet: `ConnectScreen`, then
    /// `LevelLoadingScreen`, over the panorama with its blur.
    pub(super) fn remote_loading(&self) -> bool {
-        if self.studio_replay.is_some() {
+        if self.replay.playing() {
            return false;
        }
        use horizon_client::level_loading::Reason;
@@ -10714,17 +10687,11 @@ impl Game<'_> {
    /// The profile name of another player the server sent, by entity id.
    /// The UUID of another player's entity in the level.
    pub(super) fn remote_player_uuid(&self, id: u32) -> Option<u128> {
-        let r = self.remote.as_ref()?;
-        let uuid = *r.level_players.get(&(id as i32))?;
-        (uuid != r.profile).then_some(uuid)
+        self.remote.as_ref()?.player_uuid(id)
    }
    pub(super) fn remote_player_name(&self, id: u32) -> Option<&str> {
        let r = self.remote.as_ref()?;
-        let uuid = r.level_players.get(&(id as i32))?;
-        if *uuid == r.profile {
-            return None;
-        }
-        r.level_player_name(id as i32, uuid)
+        r.level_player_name(id as i32, &r.player_uuid(id)?)
    }
    /// Status for `horizon-ctl status`.
    /// The other players' entities in the level and their names (their
@@ -11496,8 +11463,7 @@ impl Remote {
    pub(super) fn listed_player_count(&self) -> usize {
        self.listed.len()
    }
-    /// Players in the server's player list, this one included (for Discord).
-    #[cfg(feature = "discord")]
+    /// Players in the server's player list, this one included (for the activity hooks).
    pub(super) fn player_count(&self) -> usize {
        self.players.len()
    }
@@ -11505,6 +11471,11 @@ impl Remote {
    pub(super) fn profile(&self) -> u128 {
        self.profile
    }
+    /// Another player's profile UUID, by their entity id (None for the local player).
+    pub(super) fn player_uuid(&self, id: u32) -> Option<u128> {
+        let uuid = *self.level_players.get(&(id as i32))?;
+        (uuid != self.profile).then_some(uuid)
+    }
    /// The entity id of a player in the level, by profile UUID.
    pub(super) fn player_entity(&self, uuid: u128) -> Option<u32> {
        self.level_players
@@ -11642,6 +11613,9 @@ fn in_storage_range(view_distance: i32, center: (i32, i32), x: i32, z: i32) -> b
    x.abs_diff(center.0) <= range && z.abs_diff(center.1) <= range
 }

+// A packet's removals (`RemoveEntities`), apart: this file may not grow.
+#[path = "remote_removal.rs"]
+mod removal;
 #[cfg(test)]
 mod tests {
    #[test]
@@ -793,13 +793,17 @@ impl Game<'_> {
    }

    pub(super) fn remove_remote_projectile(&mut self, id: u32) {
-        self.fangs.list.retain(|f| f.id != id);
        self.tnts.retain(|t| t.id != id);
        self.falling.retain(|f| f.id != id);
+        self.crystals.retain(|c| c.id != id);
+        self.remove_remote_small_projectiles(id);
+    }
+
+    pub(super) fn remove_remote_small_projectiles(&mut self, id: u32) {
+        self.fangs.list.retain(|f| f.id != id);
        self.creatures.projectiles.retain(|p| p.id != id);
        self.tridents.retain(|t| t.id != id);
        self.rockets.retain(|r| r.id != id);
-        self.crystals.retain(|c| c.id != id);
        self.potions.remove_remote_thrown(id);
        self.potions.clouds.retain(|c| c.id != id);
        self.end.remove_remote_eye(id);
@@ -0,0 +1,142 @@
+//! Removing entities a server dropped (`RemoveEntities`), out of remote.rs,
+//! which may not grow.
+use super::super::Game;
+
+impl Game<'_> {
+    pub(super) fn remove_entity(&mut self, id: i32) {
+        self.remove_entities(&[id]);
+    }
+
+    /// `ClientboundRemoveEntitiesPacket`: a packet's ids go together, the big
+    /// entity lists filtered once (#13007), each id's own cleanup in order.
+    pub(super) fn remove_entities(&mut self, ids: &[i32]) {
+        for &id in ids {
+            self.detach_remote_tracking_entity(id);
+            self.audio.remove_sound_entity(id as u32);
+            // Entity.setRemoved detaches every passenger, even when no empty
+            // SetPassengers packet preceded the vehicle's removal. Otherwise
+            // mobs and other players keep their passenger pose after it is gone.
+            self.remote_set_passengers(id, &[]);
+            // Before the crystals go: the dragon's beam index follows them.
+            self.remove_remote_dragon(id);
+            self.crystals.retain(|c| c.id != id as u32);
+            self.remove_remote_object(id as u32);
+            self.remove_remote_small_projectiles(id as u32);
+            self.persist.uuids.remove(&(id as u32));
+            if let Some(r) = self.remote.as_mut() {
+                r.glowing.remove(&id);
+                r.entities.remove(&id);
+                r.passenger_vehicles.remove(&(id as u32));
+                r.lerps.remove(&id);
+                r.cart_lerps.remove(&id);
+                r.stepped.remove(&id);
+                r.head_lerps.remove(&id);
+                r.pending_items.remove(&id);
+            }
+        }
+        let removed: horizon_client::fast_hash::FxHashSet<u32> = if ids.len() > 1 {
+            ids.iter().map(|&id| id as u32).collect()
+        } else {
+            Default::default()
+        };
+        let keep = |id: u32| {
+            if ids.len() > 1 {
+                !removed.contains(&id)
+            } else {
+                ids.first().is_none_or(|&removed| id != removed as u32)
+            }
+        };
+        self.mobs.retain(|m| keep(m.id));
+        self.orbs.retain(|o| keep(o.id));
+        self.dropped.retain(|d| keep(d.id));
+        self.falling.retain(|f| keep(f.id));
+        self.tnts.retain(|t| keep(t.id));
+        if let Some(r) = self.remote.as_mut() {
+            r.passenger_vehicles.retain(|_, v| keep(*v));
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES and scratch homes/cwd"]
+    fn remove_entities_filters_mixed_entity_lists() {
+        use crate::game::{
+            Audio, Game, Options, Progress, Settings, execution_role::ExecutionRole, load_resources,
+        };
+        use horizon_protocol::packets::play::{self, Clientbound as C};
+
+        let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
+        let settings = Settings::default();
+        let loaded = load_resources(
+            root.clone(),
+            None,
+            &root,
+            &settings,
+            std::time::Instant::now(),
+            false,
+            true,
+            &Progress::new(),
+            &mut |_, _| unreachable!(),
+        )
+        .unwrap();
+        let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
+        options.resources = root.clone();
+        options.execution_role = ExecutionRole::Client;
+        let mut game = Game::new(
+            &loaded.resources,
+            loaded.pack,
+            loaded.gui.unwrap(),
+            options,
+            settings,
+            Audio::silent(&root),
+            None,
+        )
+        .unwrap();
+        let (client, _server) = horizon_protocol::connection::Pipe::pair();
+        game.connect_local(client, "RemovalTest").unwrap();
+        for (id, kind) in [
+            (40, "minecraft:falling_block"),
+            (41, "minecraft:falling_block"),
+            (42, "minecraft:falling_block"),
+            (43, "minecraft:tnt"),
+            (44, "minecraft:tnt"),
+            (45, "minecraft:experience_orb"),
+            (46, "minecraft:experience_orb"),
+            (47, "minecraft:zombie"),
+            (48, "minecraft:zombie"),
+        ] {
+            if matches!(kind, "minecraft:falling_block" | "minecraft:tnt") {
+                assert!(game.spawn_remote_projectile(
+                    id,
+                    kind,
+                    [0.0, 64.0, 0.0],
+                    (0.0, 0.0),
+                    [0.0; 3],
+                    0
+                ));
+            } else {
+                game.spawn_entity(id, kind, [0.0, 64.0, 0.0], [0.0; 3]);
+            }
+        }
+        for id in [49, 50] {
+            game.dropped.push(horizon_client::entities::ItemEntity::new(
+                id,
+                horizon_client::items::ItemStack::new("minecraft:sand", 1),
+                horizon_core::geometry::Vec3::new(0.0, 64.0, 0.0),
+                horizon_core::geometry::Vec3::ZERO,
+                0.0,
+            ));
+        }
+        game.handle_packet(C::RemoveEntities(play::RemoveEntities {
+            ids: vec![40, 42, 43, 45, 47, 49],
+        }))
+        .unwrap();
+        assert_eq!(game.falling.iter().map(|e| e.id).collect::<Vec<_>>(), [41]);
+        assert_eq!(game.tnts.iter().map(|e| e.id).collect::<Vec<_>>(), [44]);
+        assert_eq!(game.orbs.iter().map(|e| e.id).collect::<Vec<_>>(), [46]);
+        assert_eq!(game.mobs.iter().map(|e| e.id).collect::<Vec<_>>(), [48]);
+        assert_eq!(game.dropped.iter().map(|e| e.id).collect::<Vec<_>>(), [50]);
+    }
+}
@@ -168,6 +168,7 @@ impl Game<'_> {
            full_water_vision: self.settings.extras.pvp.tweaks.clear_water,
            night_vision: self.fog_night_vision(),
            environment: self.pack.polytone_colors.env,
+            fluid_fog: self.pack.polytone_colors.fluid_fog,
        };
        let mut fog = horizon_client::fog::setup_fog(tables, &self.fog, &input);
        if !self.settings.horizon.fog {
@@ -0,0 +1,855 @@
+//! Recording a session's packets as `.mcpr` and playing them back in a `Game`: the `/studio record`
+//! and `/studio replay` commands (chat and `horizon-ctl`), the replay's clock and its world. This is
+//! platform (docs/layers.md, "Replays"); Studio's editor (`studio.rs`) builds on it.
+
+use super::{Game, PendingWorldEntry, Screen};
+use horizon_client::{
+    Result,
+    studio::{Metadata, ReplayDriver},
+    text::Text,
+};
+use serde_json::{Value, json};
+use std::{
+    path::{Path, PathBuf},
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+
+/// The packet replay a `Game` plays, if any, and its playback clock.
+#[derive(Default)]
+pub(super) struct Replay {
+    /// The packet replay playing, if any.
+    pub(super) driver: Option<ReplayDriver>,
+    /// Camera perspective to restore after leaving replay playback.
+    pub(super) previous_camera_type: Option<super::perspective::CameraType>,
+    /// Replay opened from the title screen owns the synthetic remote session.
+    pub(super) standalone: bool,
+    pub(super) last_tick: Option<std::time::Instant>,
+    pub(super) virtual_tick_ms: f32,
+}
+
+impl Replay {
+    /// A replay plays: the world shown is the recording's.
+    pub(super) fn playing(&self) -> bool {
+        self.driver.is_some()
+    }
+    /// How far the replay's player is between its last two ticks, while a replay plays: it
+    /// moves on the replay's clock, not the game's.
+    pub(super) fn player_alpha(&self) -> Option<f64> {
+        self.playing()
+            .then(|| (f64::from(self.virtual_tick_ms) / 50.0).clamp(0.0, 1.0))
+    }
+}
+
+impl Game<'_> {
+    /// How far the window's own player model is between two ticks: on the replay's clock while a
+    /// replay plays, else the game's.
+    pub(super) fn own_player_alpha(&self) -> f64 {
+        self.replay
+            .player_alpha()
+            .unwrap_or_else(|| self.clock.camera_fraction())
+    }
+
+    /// In-game chat command handler: `/studio <record|replay> ...`.
+    /// Returns true if the command was recognized and handled.
+    pub(super) fn studio_command(&mut self, command: &str) -> bool {
+        let Some(rest) = command.strip_prefix("studio") else {
+            return false;
+        };
+        if !rest.is_empty() && !rest.starts_with(char::is_whitespace) {
+            return false;
+        }
+        let words: Vec<&str> = rest.split_whitespace().collect();
+        if words.is_empty() {
+            self.system_message(Text::translate("horizon.studio.replay.usage", &[]));
+            return true;
+        }
+
+        match words[0] {
+            "freecam" | "keyframe" | "path" if super::studio::EDITOR => {
+                return self.studio_editor_command(&words);
+            }
+            "record" => match words.get(1).copied() {
+                Some("start") => match self.start_studio_recording(words.get(2).copied()) {
+                    Ok(v) if v["ok"].as_bool() == Some(true) => {
+                        let path = v["path"].as_str().unwrap_or_default();
+                        self.system_message(Text::tr("horizon.studio.record.started", &[&path]));
+                    }
+                    Ok(v) => {
+                        let error = v["error"].as_str().unwrap_or_default();
+                        self.system_message(Text::tr("horizon.studio.record.error", &[&error]));
+                    }
+                    Err(error) => {
+                        self.system_message(Text::tr("horizon.studio.record.error", &[&error]));
+                    }
+                },
+                Some("stop") => match self.stop_studio_recording() {
+                    Ok(v) if v["ok"].as_bool() == Some(true) => {
+                        let path = v["path"].as_str().unwrap_or_default();
+                        self.system_message(Text::tr("horizon.studio.record.saved", &[&path]));
+                    }
+                    Ok(v) => {
+                        let error = v["error"].as_str().unwrap_or_default();
+                        self.system_message(Text::tr("horizon.studio.record.error", &[&error]));
+                    }
+                    Err(error) => {
+                        self.system_message(Text::tr("horizon.studio.record.error", &[&error]));
+                    }
+                },
+                Some("status") => {
+                    let status = self.studio_recording_status();
+                    if status["active"].as_bool() == Some(true) {
+                        let elapsed =
+                            (status["elapsed_ms"].as_u64().unwrap_or(0) / 1000).to_string();
+                        let packets = status["packet_count"].as_u64().unwrap_or(0).to_string();
+                        let size =
+                            (status["bytes_written"].as_u64().unwrap_or(0) / 1024).to_string();
+                        let path = status["path"].as_str().unwrap_or_default();
+                        self.system_message(Text::tr(
+                            "horizon.studio.record.status.active",
+                            &[&elapsed, &packets, &size, &path],
+                        ));
+                    } else if let Some(error) = status["error"].as_str() {
+                        self.system_message(Text::tr("horizon.studio.record.error", &[&error]));
+                    } else {
+                        self.system_message(Text::translate(
+                            "horizon.studio.record.status.inactive",
+                            &[],
+                        ));
+                    }
+                }
+                _ => self.system_message(Text::translate("horizon.studio.record.usage", &[])),
+            },
+            "replay" => match words.get(1).copied() {
+                Some("open") => {
+                    let Some(path) = words.get(2) else {
+                        self.system_message(Text::translate(
+                            "horizon.studio.replay.open.usage",
+                            &[],
+                        ));
+                        return true;
+                    };
+                    match self.open_studio_replay(path) {
+                        Ok(v) if v["ok"].as_bool() == Some(true) => {
+                            let duration_s = v["duration_ms"].as_f64().unwrap_or(0.0) / 1000.0;
+                            let packets = v["packet_count"].as_u64().unwrap_or(0);
+                            let duration = format!("{duration_s:.1}");
+                            let packets = packets.to_string();
+                            self.system_message(Text::tr(
+                                "horizon.studio.replay.opened",
+                                &[path, &duration, &packets],
+                            ));
+                        }
+                        Ok(v) => {
+                            let err = v["error"].as_str().unwrap_or_default();
+                            self.system_message(Text::tr(
+                                "horizon.studio.replay.open_error",
+                                &[&err],
+                            ));
+                        }
+                        Err(e) => {
+                            let error = e.to_string();
+                            self.system_message(Text::tr(
+                                "horizon.studio.replay.open_error",
+                                &[&error],
+                            ));
+                        }
+                    }
+                }
+                Some("pause") => {
+                    if let Some(r) = self.replay.driver.as_mut() {
+                        r.set_paused(true);
+                        self.system_message(Text::translate("horizon.studio.replay.paused", &[]));
+                    } else {
+                        self.system_message(Text::translate("horizon.studio.replay.inactive", &[]));
+                    }
+                }
+                Some("resume") => {
+                    if let Some(r) = self.replay.driver.as_mut() {
+                        r.set_paused(false);
+                        self.system_message(Text::translate("horizon.studio.replay.resumed", &[]));
+                    } else {
+                        self.system_message(Text::translate("horizon.studio.replay.inactive", &[]));
+                    }
+                }
+                Some("speed") => {
+                    let Some(spd_str) = words.get(2) else {
+                        self.system_message(Text::translate(
+                            "horizon.studio.replay.speed.usage",
+                            &[],
+                        ));
+                        return true;
+                    };
+                    if let Ok(spd) = spd_str.parse::<f64>() {
+                        let new_speed = if let Some(r) = self.replay.driver.as_mut() {
+                            r.set_speed(spd);
+                            Some(r.speed())
+                        } else {
+                            None
+                        };
+                        if let Some(speed) = new_speed {
+                            let speed = format!("{speed:.2}");
+                            self.system_message(Text::tr(
+                                "horizon.studio.replay.speed.set",
+                                &[&speed],
+                            ));
+                        } else {
+                            self.system_message(Text::translate(
+                                "horizon.studio.replay.inactive",
+                                &[],
+                            ));
+                        }
+                    } else {
+                        self.system_message(Text::translate(
+                            "horizon.studio.replay.speed.invalid",
+                            &[],
+                        ));
+                    }
+                }
+                Some("seek") => {
+                    let Some(ms_str) = words.get(2) else {
+                        self.system_message(Text::translate(
+                            "horizon.studio.replay.seek.usage",
+                            &[],
+                        ));
+                        return true;
+                    };
+                    if let Ok(ms) = ms_str.parse::<u32>() {
+                        if self.replay.driver.is_some() {
+                            match self.seek_studio_replay(ms) {
+                                Ok(()) => {
+                                    let actual_ms = self
+                                        .replay
+                                        .driver
+                                        .as_ref()
+                                        .map_or(ms, |replay| ms.min(replay.duration_ms()));
+                                    let ms_text = actual_ms.to_string();
+                                    let seconds = format!("{:.1}", actual_ms as f32 / 1000.0);
+                                    self.system_message(Text::tr(
+                                        "horizon.studio.replay.seeked",
+                                        &[&ms_text, &seconds],
+                                    ));
+                                }
+                                Err(e) => {
+                                    if e.kind() == std::io::ErrorKind::Unsupported {
+                                        self.system_message(Text::translate(
+                                            "horizon.studio.replay.seek.backward_requires_standalone",
+                                            &[],
+                                        ));
+                                    } else {
+                                        let error = e.to_string();
+                                        self.system_message(Text::tr(
+                                            "horizon.studio.replay.seek.error",
+                                            &[&error],
+                                        ));
+                                    }
+                                }
+                            }
+                        } else {
+                            self.system_message(Text::translate(
+                                "horizon.studio.replay.inactive",
+                                &[],
+                            ));
+                        }
+                    } else {
+                        self.system_message(Text::translate(
+                            "horizon.studio.replay.seek.invalid",
+                            &[],
+                        ));
+                    }
+                }
+                Some("status") => {
+                    if let Some(r) = self.replay.driver.as_ref() {
+                        let position = r.position_ms().to_string();
+                        let duration = r.duration_ms().to_string();
+                        let progress = format!("{:.1}", r.progress() * 100.0);
+                        let speed = format!("{:.2}", r.speed());
+                        let paused = r.is_paused().to_string();
+                        let finished = r.is_finished().to_string();
+                        self.system_message(Text::tr(
+                            "horizon.studio.replay.status",
+                            &[&position, &duration, &progress, &speed, &paused, &finished],
+                        ));
+                    } else {
+                        self.system_message(Text::translate("horizon.studio.replay.inactive", &[]));
+                    }
+                }
+                Some("close") => {
+                    if self.close_studio_replay() {
+                        self.system_message(Text::translate("horizon.studio.replay.closed", &[]));
+                    } else {
+                        self.system_message(Text::translate("horizon.studio.replay.inactive", &[]));
+                    }
+                }
+                _ => {
+                    self.system_message(Text::translate("horizon.studio.replay.usage", &[]));
+                }
+            },
+            _ => {
+                self.system_message(Text::translate("horizon.studio.replay.usage", &[]));
+            }
+        }
+        true
+    }
+
+    /// Reset playback tick accumulator and align positions on seek.
+    pub(super) fn reset_studio_playback_ticks(&mut self) {
+        self.replay.virtual_tick_ms = 0.0;
+        if let Some(player) = &self.player {
+            self.previous_position = player.position;
+            if let Some(m) = self.player_model.as_mut() {
+                m.previous = player.position;
+                m.position = player.position;
+                m.limb_speed = 0.0;
+                m.previous_limb_speed = 0.0;
+            }
+        }
+    }
+
+    /// Reconstruct replay state at a target timestamp. Standalone replays can
+    /// safely reset their synthetic remote; an in-world replay can only seek
+    /// forward because its pre-replay world must remain intact.
+    pub(super) fn seek_studio_replay(&mut self, target_ms: u32) -> std::io::Result<()> {
+        let current_ms = self
+            .replay
+            .driver
+            .as_ref()
+            .map_or(0, ReplayDriver::position_ms);
+        let packets = if self.replay.standalone {
+            let packets = self
+                .replay
+                .driver
+                .as_mut()
+                .expect("replay checked by caller")
+                .seek_and_collect(target_ms)?;
+            self.init_remote_for_replay()
+                .map_err(|error| std::io::Error::other(error.to_string()))?;
+            packets
+        } else {
+            if target_ms < current_ms {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Unsupported,
+                    "backward seek requires a standalone replay",
+                ));
+            }
+            self.replay
+                .driver
+                .as_mut()
+                .expect("replay checked by caller")
+                .seek_forward(target_ms)?
+        };
+
+        self.dispatch_studio_replay_packets(packets);
+        self.reset_studio_playback_ticks();
+        self.replay.last_tick = Some(std::time::Instant::now());
+        Ok(())
+    }
+
+    fn dispatch_studio_replay_packets(
+        &mut self,
+        packets: Vec<horizon_client::studio::mcpr::TimestampedPacket>,
+    ) {
+        for pkt in packets {
+            match horizon_protocol::packets::play::Clientbound::decode(pkt.id, &pkt.payload) {
+                Ok(packet) => {
+                    let _ = self.handle_packet(packet);
+                }
+                Err(e) => {
+                    let name = horizon_protocol::ids::name(
+                        horizon_protocol::State::Play,
+                        horizon_protocol::Direction::Clientbound,
+                        pkt.id,
+                    )
+                    .unwrap_or("?");
+                    log::debug!(
+                        "Studio replay skipped packet {name} (id {:#x}): {e}",
+                        pkt.id
+                    );
+                }
+            }
+        }
+    }
+
+    /// Advance active replay playback by elapsed frame time and dispatch ready packets.
+    pub(super) fn advance_studio_replay(&mut self) -> Result<()> {
+        let Some(driver) = self.replay.driver.as_mut() else {
+            self.replay.last_tick = None;
+            return Ok(());
+        };
+
+        let now = std::time::Instant::now();
+        let delta = match self.replay.last_tick {
+            Some(last) => now
+                .saturating_duration_since(last)
+                .min(Duration::from_millis(250)),
+            None => Duration::from_millis(16),
+        };
+        self.replay.last_tick = Some(now);
+
+        let ready_packets = match driver.advance(delta) {
+            Ok(pkts) => pkts,
+            Err(e) => {
+                log::warn!("Studio replay advance error: {e}");
+                return Ok(());
+            }
+        };
+
+        self.dispatch_studio_replay_packets(ready_packets);
+        let paused = self
+            .replay
+            .driver
+            .as_ref()
+            .is_some_and(|replay| replay.is_paused());
+        if self.player_model.is_none() {
+            self.tick_player_model();
+        }
+        if !paused {
+            let speed = self
+                .replay
+                .driver
+                .as_ref()
+                .map_or(1.0, |r| r.speed() as f32)
+                .max(0.1);
+            self.replay.virtual_tick_ms += delta.as_secs_f32() * 1000.0 * speed;
+            while self.replay.virtual_tick_ms >= 50.0 {
+                self.replay.virtual_tick_ms -= 50.0;
+                if let Some(player) = &self.player {
+                    let current_pos = player.position;
+                    let (dx, dz) = (
+                        current_pos.x - self.previous_position.x,
+                        current_pos.z - self.previous_position.z,
+                    );
+                    let walked = (dx * dx + dz * dz).sqrt() as f32;
+                    if let Some(m) = self.player_model.as_mut() {
+                        m.previous = self.previous_position;
+                        m.position = current_pos;
+                        m.previous_limb_speed = m.limb_speed;
+                        let target_speed = (walked * 4.0).min(1.0);
+                        m.limb_speed += (target_speed - m.limb_speed) * 0.4;
+                        if m.limb_speed < 0.001 {
+                            m.limb_speed = 0.0;
+                        }
+                        m.limb_position += m.limb_speed;
+                        m.previous_yaw = m.yaw;
+                        m.previous_head_yaw = m.head_yaw;
+                        m.previous_head_pitch = m.head_pitch;
+                        m.previous_body_yaw = m.body_yaw;
+                        m.yaw = self.yaw;
+                        m.head_yaw = self.yaw;
+                        m.head_pitch = self.pitch;
+                        let mut target = m.body_yaw;
+                        if dx * dx + dz * dz > 0.0025 {
+                            let walk = (dz.atan2(dx) as f32).to_degrees() - 90.0;
+                            let facing =
+                                ((self.yaw - walk + 180.0).rem_euclid(360.0) - 180.0).abs();
+                            target = if 95.0 < facing && facing < 265.0 {
+                                walk - 180.0
+                            } else {
+                                walk
+                            };
+                        }
+                        let diff = (target - m.body_yaw + 180.0).rem_euclid(360.0) - 180.0;
+                        m.body_yaw += diff * 0.3;
+                        let body_diff = (self.yaw - m.body_yaw + 180.0).rem_euclid(360.0) - 180.0;
+                        if body_diff.abs() > 50.0 {
+                            m.body_yaw += body_diff - body_diff.signum() * 50.0;
+                        }
+                        m.age = m.age.wrapping_add(1);
+                    }
+                    self.previous_position = current_pos;
+                }
+            }
+        } else if let Some(m) = self.player_model.as_mut() {
+            m.previous_limb_speed = m.limb_speed;
+        }
+        self.studio_replay_advanced();
+        Ok(())
+    }
+
+    /// Control socket command handler for `studio`.
+    pub(super) fn studio_control(&mut self, words: &[&str]) -> Result<Option<Value>> {
+        if words.first().copied() != Some("studio") {
+            return Ok(None);
+        }
+        match words.get(1).copied() {
+            Some("record") => match words.get(2).copied() {
+                Some("start") => {
+                    let name = words.get(3).copied();
+                    let res = self.start_studio_recording(name)?;
+                    Ok(Some(res))
+                }
+                Some("stop") => {
+                    let res = self.stop_studio_recording()?;
+                    Ok(Some(res))
+                }
+                Some("status") => {
+                    let res = self.studio_recording_status();
+                    Ok(Some(res))
+                }
+                _ => Ok(Some(json!({ "error": "unknown studio record subcommand" }))),
+            },
+            Some("replay") => match words.get(2).copied() {
+                Some("open") => {
+                    let path = words.get(3).ok_or("missing path for studio replay open")?;
+                    let res = self.open_studio_replay(path)?;
+                    Ok(Some(res))
+                }
+                Some("pause") => {
+                    if let Some(r) = self.replay.driver.as_mut() {
+                        r.set_paused(true);
+                        Ok(Some(json!({ "ok": true, "paused": true })))
+                    } else {
+                        Ok(Some(json!({ "error": "no active replay" })))
+                    }
+                }
+                Some("resume") => {
+                    if let Some(r) = self.replay.driver.as_mut() {
+                        r.set_paused(false);
+                        Ok(Some(json!({ "ok": true, "paused": false })))
+                    } else {
+                        Ok(Some(json!({ "error": "no active replay" })))
+                    }
+                }
+                Some("speed") => {
+                    let spd_str = words.get(3).ok_or("missing speed value")?;
+                    let spd: f64 = spd_str.parse().map_err(|_| "invalid speed")?;
+                    if let Some(r) = self.replay.driver.as_mut() {
+                        r.set_speed(spd);
+                        Ok(Some(json!({ "ok": true, "speed": r.speed() })))
+                    } else {
+                        Ok(Some(json!({ "error": "no active replay" })))
+                    }
+                }
+                Some("seek") => {
+                    let ms_str = words.get(3).ok_or("missing seek timestamp")?;
+                    let ms: u32 = ms_str.parse().map_err(|_| "invalid timestamp")?;
+                    let pos = if let Some(r) = self.replay.driver.as_mut() {
+                        r.seek(ms).map_err(|e| format!("{e}"))?;
+                        Some(r.position_ms())
+                    } else {
+                        None
+                    };
+                    if let Some(pos) = pos {
+                        self.reset_studio_playback_ticks();
+                        Ok(Some(json!({ "ok": true, "position_ms": pos })))
+                    } else {
+                        Ok(Some(json!({ "error": "no active replay" })))
+                    }
+                }
+                Some("status") => {
+                    if let Some(r) = self.replay.driver.as_ref() {
+                        Ok(Some(json!({
+                            "ok": true,
+                            "active": true,
+                            "position_ms": r.position_ms(),
+                            "duration_ms": r.duration_ms(),
+                            "progress": r.progress(),
+                            "speed": r.speed(),
+                            "paused": r.is_paused(),
+                            "finished": r.is_finished(),
+                        })))
+                    } else {
+                        Ok(Some(json!({ "ok": true, "active": false })))
+                    }
+                }
+                Some("close") => {
+                    let closed = self.close_studio_replay();
+                    Ok(Some(json!({ "ok": true, "closed": closed })))
+                }
+                _ => Ok(Some(json!({ "error": "unknown studio replay subcommand" }))),
+            },
+            Some("screen") if super::studio::EDITOR => self.studio_screen_control(words),
+            _ => Ok(Some(json!({ "error": "unknown studio command" }))),
+        }
+    }
+
+    pub(super) fn start_studio_recording(&mut self, name: Option<&str>) -> Result<Value> {
+        let Some(r) = self.remote.as_ref() else {
+            return Ok(json!({ "ok": false, "error": "no active world session" }));
+        };
+        if r.session.is_recording() {
+            return Ok(json!({ "ok": false, "error": "recording already active" }));
+        }
+        let _ = std::fs::create_dir_all("recordings");
+        let ts = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+        let filename = match name {
+            Some(n) if !n.is_empty() => format!("{}_{}.mcpr", n, ts),
+            _ => format!("recording_{}.mcpr", ts),
+        };
+        let path = PathBuf::from("recordings").join(filename);
+        let server_address = if r.session.address.is_empty() {
+            "local".to_owned()
+        } else {
+            r.session.address.clone()
+        };
+        let is_singleplayer = server_address == "local";
+        let meta = Metadata::new(
+            server_address,
+            is_singleplayer,
+            horizon_core::release::VERSION.into(),
+        );
+        match horizon_client::studio::StudioRecorder::start(path.clone(), meta) {
+            Ok(recorder) => {
+                r.session.start_recording(recorder, |recorder| {
+                    self.dump_world_snapshot_to_recorder(recorder);
+                });
+                Ok(json!({ "ok": true, "path": path.display().to_string() }))
+            }
+            Err(e) => Ok(json!({ "ok": false, "error": e.to_string() })),
+        }
+    }
+
+    pub(super) fn stop_studio_recording(&mut self) -> Result<Value> {
+        let Some(r) = self.remote.as_ref() else {
+            return Ok(json!({ "ok": false, "error": "no active world session" }));
+        };
+        match r.session.stop_recording() {
+            Some(Ok(path)) => Ok(json!({ "ok": true, "path": path.display().to_string() })),
+            Some(Err(e)) => Ok(json!({ "ok": false, "error": e.to_string() })),
+            None => Ok(json!({ "ok": false, "error": "no active recording" })),
+        }
+    }
+
+    pub(super) fn studio_recording_status(&self) -> Value {
+        if let Some(r) = self.remote.as_ref()
+            && let Some(status) = r.session.recorder_status()
+        {
+            json!({
+                "ok": true,
+                "active": status.active,
+                "path": status.path.display().to_string(),
+                "elapsed_ms": status.elapsed.as_millis(),
+                "packet_count": status.packet_count,
+                "bytes_written": status.bytes_written,
+            })
+        } else {
+            json!({ "ok": true, "active": false })
+        }
+    }
+
+    pub(super) fn open_studio_replay(&mut self, path: &str) -> Result<Value> {
+        if let Err(error) = self.save_studio_camera_track() {
+            return Ok(json!({ "ok": false, "error": error.to_string() }));
+        }
+        // The recordings browser can be opened while the title screen is
+        // available but the slower world tables are still loading. Replay
+        // setup builds the normal client registries, which require `rest`.
+        if self.remote.is_none() && self.res.rest.get().is_none() {
+            let pending = PendingWorldEntry::StudioReplay(PathBuf::from(path));
+            if self.defer_world_entry(pending)? {
+                return Ok(json!({ "ok": true, "pending": true }));
+            }
+            self.join_world_rest()?;
+        }
+
+        // Validate and index the archive before replacing the title menu or active world. A
+        // temp-file, metadata, or protocol error must leave the current screen usable.
+        let driver = match ReplayDriver::open(Path::new(path)) {
+            Ok(driver) => driver,
+            Err(error) => {
+                log::error!("Failed to open studio replay '{path}': {error}");
+                return Ok(json!({ "ok": false, "error": error.to_string() }));
+            }
+        };
+
+        let standalone = self.replay.driver.is_none() && self.remote.is_none();
+        if self.remote.is_none()
+            && let Err(error) = self.init_remote_for_replay()
+        {
+            log::error!("Failed to initialize studio replay session: {error}");
+            return Ok(json!({ "ok": false, "error": error.to_string() }));
+        }
+
+        let duration_ms = driver.duration_ms();
+        let packets = driver.packet_count();
+        self.studio_replay_opened(&driver);
+        if self.replay.driver.is_none() {
+            self.replay.previous_camera_type = Some(self.camera_type);
+            self.replay.standalone = standalone;
+        }
+        self.replay.driver = Some(driver);
+        self.camera_type = super::perspective::CameraType::FirstPerson;
+        self.title = None;
+        self.screen = Screen::Playing;
+        self.capture(false);
+        self.dragging = false;
+        // Apply timestamp-zero login, player pose, and chunk packets before the first rendered
+        // frame so playback opens at the recorded player's viewpoint.
+        let _ = self.advance_studio_replay();
+        self.reset_studio_playback_ticks();
+        log::info!("Studio: Opened replay '{path}' ({duration_ms} ms, {packets} packets)");
+        Ok(json!({
+            "ok": true,
+            "duration_ms": duration_ms,
+            "packet_count": packets,
+        }))
+    }
+    pub(super) fn close_studio_replay(&mut self) -> bool {
+        self.studio_replay_closing();
+        let closed = self.replay.driver.take().is_some();
+        if !closed {
+            return false;
+        }
+
+        // A standalone replay owns a synthetic Remote connection. Treat that
+        // connection as replay state even if the saved origin flag was lost;
+        // sending it through leave_server() opens the Multiplayer screen.
+        let standalone = self.replay.standalone
+            || self
+                .remote
+                .as_ref()
+                .is_some_and(|remote| remote.brand == "horizon-studio");
+        self.replay.standalone = false;
+        if let Some(camera_type) = self.replay.previous_camera_type.take() {
+            self.camera_type = camera_type;
+        }
+        self.replay.last_tick = None;
+        self.studio_replay_closed();
+        self.replay.virtual_tick_ms = 0.0;
+        self.capture(false);
+        if standalone {
+            if let Some(mut remote) = self.remote.take() {
+                remote.session.disconnect();
+            }
+            self.using = None;
+            self.end_mod_use();
+            if let Err(error) = self.finish_close_world() {
+                log::error!("Failed to close standalone Studio replay cleanly: {error}");
+            }
+            self.reset_studio_hand_state();
+            // A title-screen replay has no previous world perspective to
+            // restore. Start the next world in first person with visible hands.
+            self.camera_type = super::perspective::CameraType::FirstPerson;
+            if let Some(title) = self.title.as_mut() {
+                title.mode = horizon_client::title::Mode::Main;
+            }
+        } else if self.integrated.is_none() && self.lan.is_none() {
+            let _ = self.close_world();
+            if let Some(title) = self.title.as_mut() {
+                title.mode = horizon_client::title::Mode::Main;
+            }
+        }
+        closed
+    }
+    /// Dump current player pose, dimension login, center chunk, and resident loaded chunks
+    /// into the recording stream at timestamp 0ms so replays accurately reconstruct the world.
+    pub(super) fn dump_world_snapshot_to_recorder(
+        &self,
+        recorder: &horizon_client::studio::StudioRecorder,
+    ) {
+        let Some(r) = self.remote.as_ref() else {
+            return;
+        };
+        let record_cb = |pkt: horizon_protocol::packets::play::Clientbound| {
+            let encoded = pkt.encode();
+            let mut reader = horizon_protocol::buf::Reader::new(&encoded);
+            if let Ok(id) = reader.varint() {
+                let payload = reader.rest();
+                recorder.record_packet_at(0, id, payload);
+            }
+        };
+
+        // 1. C::Login packet baseline
+        let login = horizon_protocol::packets::play::Clientbound::Login(
+            horizon_protocol::packets::play::Login {
+                player_id: r.entity_id,
+                hardcore: self.level.hardcore,
+                levels: vec!["minecraft:overworld".into()],
+                max_players: 20,
+                chunk_radius: self.settings.render_distance,
+                simulation_distance: self.settings.simulation_distance,
+                reduced_debug_info: false,
+                show_death_screen: true,
+                limited_crafting: false,
+                spawn: horizon_protocol::packets::play::SpawnInfo {
+                    dimension_type: 0,
+                    dimension: "minecraft:overworld".into(),
+                    seed: 0,
+                    game_type: 0,
+                    previous_game_type: None,
+                    debug: false,
+                    flat: false,
+                    last_death: None,
+                    portal_cooldown: 0,
+                    sea_level: 63,
+                },
+                online_mode: false,
+                enforces_secure_chat: false,
+            },
+        );
+        record_cb(login);
+
+        // 2. Center chunk and player position
+        let (pos, yaw, pitch) = if let Some(p) = &self.player {
+            (
+                glam::DVec3::new(p.position.x, p.position.y, p.position.z),
+                self.yaw,
+                self.pitch,
+            )
+        } else {
+            (glam::DVec3::ZERO, self.yaw, self.pitch)
+        };
+        let chunk_x = (pos.x.floor() as i32) >> 4;
+        let chunk_z = (pos.z.floor() as i32) >> 4;
+
+        let center_chunk = horizon_protocol::packets::play::Clientbound::SetChunkCacheCenter(
+            horizon_protocol::packets::play::SetChunkCacheCenter {
+                x: chunk_x,
+                z: chunk_z,
+            },
+        );
+        record_cb(center_chunk);
+
+        let player_pos = horizon_protocol::packets::play::Clientbound::PlayerPosition(
+            horizon_protocol::packets::play::PlayerPosition {
+                teleport: 0,
+                position: [pos.x, pos.y, pos.z],
+                delta: [0.0, 0.0, 0.0],
+                yaw,
+                pitch,
+                relatives: 0,
+            },
+        );
+        record_cb(player_pos);
+
+        // 3. Encode resident loaded chunks into LevelChunkWithLight packets
+        let biome_names: Vec<String> = world_biomes!(self)
+            .list
+            .iter()
+            .map(|b| b.name.clone())
+            .collect();
+        let registry: Vec<String> = r
+            .registries
+            .registries
+            .get("minecraft:worldgen/biome")
+            .map(|v| v.iter().map(|(n, _)| n.clone()).collect())
+            .unwrap_or_else(|| biome_names.clone());
+
+        let encoder = crate::lan::chunks::ChunkEncoder::with_signs(
+            self.res.facts().states.iter().map(|s| {
+                (
+                    s.name.clone(),
+                    s.fluid_level > 0 || s.waterlogged,
+                    s.sign_form(),
+                )
+            }),
+            &r.builtin,
+            &biome_names,
+            &registry,
+        );
+
+        let mut count = 0;
+        for chunk in self.world.chunks.values() {
+            let level_chunk = encoder.encode(chunk, &self.world.block_entities);
+            record_cb(
+                horizon_protocol::packets::play::Clientbound::LevelChunkWithLight(level_chunk),
+            );
+            count += 1;
+        }
+        log::info!(
+            "Studio Recorder: Dumped initial world snapshot ({count} chunks) at timestamp 0ms"
+        );
+    }
+}
@@ -306,8 +306,6 @@ pub(super) fn run_loading(
        App::Loading(loading) => leave_fullscreen_after(&result, &mut loading.settings),
    }
    result?;
-    #[cfg(feature = "discord")]
-    horizon_client::discord_presence::stop();
    match app {
        App::Ready(mut split) => {
            write_report(&split.host)?;
@@ -29,12 +29,13 @@ pub(super) struct RespawnConfig {
    pub dim: Dim,
    pub pos: [i32; 3],
    pub yaw: f32,
+    pub pitch: f32,
    pub forced: bool,
 }

 /// A respawn point as a player's save keeps it (`respawn`): dimension,
-/// block, yaw and whether it is forced.
-pub(super) type SavedRespawn = (String, [i32; 3], f32, bool);
+/// block, yaw, pitch and whether it is forced.
+pub(super) type SavedRespawn = (String, [i32; 3], f32, f32, bool);

 impl RespawnConfig {
    /// `RespawnData.of`: the yaw wrapped to [-180, 180).
@@ -43,19 +44,37 @@ impl RespawnConfig {
            dim,
            pos,
            yaw: wrap_degrees(f64::from(yaw)) as f32,
+            pitch: 0.0,
            forced,
        }
    }
-    pub(super) fn from_saved((dim, pos, yaw, forced): &SavedRespawn) -> Self {
+    /// `SetSpawnCommand`: the forced literal, with its already parsed angles.
+    pub(super) fn forced(dim: Dim, pos: [i32; 3], yaw: f32, pitch: f32) -> Self {
+        Self {
+            dim,
+            pos,
+            yaw,
+            pitch,
+            forced: true,
+        }
+    }
+    pub(super) fn from_saved((dim, pos, yaw, pitch, forced): &SavedRespawn) -> Self {
        Self {
            dim: Dim::from_id(dim),
            pos: *pos,
            yaw: *yaw,
+            pitch: *pitch,
            forced: *forced,
        }
    }
    pub(super) fn saved(&self) -> SavedRespawn {
-        (self.dim.id().to_owned(), self.pos, self.yaw, self.forced)
+        (
+            self.dim.id().to_owned(),
+            self.pos,
+            self.yaw,
+            self.pitch,
+            self.forced,
+        )
    }
 }

@@ -180,6 +199,7 @@ impl Game<'_> {
            dim: self.dim,
            pos,
            yaw: 0.0,
+            pitch: 0.0,
            forced: false,
        };
        // RespawnConfig.isSamePosition: dimension and block.
@@ -478,14 +498,14 @@ impl Game<'_> {
        rule.can_set_spawn.test(self.dark_outside())
    }
    /// `ServerPlayer.findRespawnAndUseSpawnBlock` for a config in the loaded
-    /// dimension: the position and yaw, using an anchor's charge; a bed's
+    /// dimension: position and angles, using an anchor's charge; a bed's
    /// stand-up spot. A forced point (`spawnpoint`) that is no anchor or bed
    /// holds if a player fits in it; anything else is gone.
    pub(super) fn find_respawn_and_use(
        &mut self,
        c: RespawnConfig,
        consume: bool,
-    ) -> Result<Option<(Vec3, f32)>> {
+    ) -> Result<Option<(Vec3, f32, f32)>> {
        let state = self.world.block(c.pos[0], c.pos[1], c.pos[2]);
        if !(self.is_anchor(state)
            && (c.forced || self.anchor_charges(state) > 0)
@@ -495,7 +515,7 @@ impl Game<'_> {
            if self.is_bed(state) && self.bed_sets_spawn(state) {
                let facing = self.bed_forward(state);
                let stand = self.bed_stand_up(c.pos, facing, c.yaw);
-                return Ok(stand.map(|p| (p, look_at_yaw(p, c.pos))));
+                return Ok(stand.map(|p| (p, look_at_yaw(p, c.pos), 0.0)));
            }
            let [x, y, z] = c.pos;
            let free = c.forced
@@ -503,7 +523,7 @@ impl Game<'_> {
                && self.possible_to_respawn_in(state)
                && self.possible_to_respawn_in(self.world.block(x, y + 1, z));
            let at = Vec3::new(f64::from(x) + 0.5, f64::from(y) + 0.1, f64::from(z) + 0.5);
-            return Ok(free.then_some((at, c.yaw)));
+            return Ok(free.then_some((at, c.yaw, c.pitch)));
        }
        let stand = self.anchor_stand_up(c.pos);
        if !c.forced
@@ -513,7 +533,7 @@ impl Game<'_> {
        {
            self.level_set(c.pos, next)?;
        }
-        Ok(stand.map(|p| (p, look_at_yaw(p, c.pos))))
+        Ok(stand.map(|p| (p, look_at_yaw(p, c.pos), 0.0)))
    }
 }

@@ -560,3 +580,354 @@ mod tests {
        assert!((look_at_yaw(east, head) - 90.0).abs() < 1.0e-4);
    }
 }
+
+#[cfg(test)]
+mod connected_spawnpoint_rotation_tests {
+    use crate::game::{Game, lan::LanSettings};
+    use horizon_client::{
+        chunk::Chunk,
+        lan::{Joined, NetConfig, Out, PlayerSender, guest::Guest, hub::HubConfig, playerdata},
+    };
+    use horizon_protocol::packets::{
+        configuration::ClientInformation,
+        play::{self, Clientbound as C, Serverbound as S},
+    };
+    use std::sync::{Arc, atomic::AtomicI32, mpsc};
+
+    fn command(game: &mut Game<'_>, text: &str) {
+        game.chat_capture = Some(Vec::new());
+        game.ui.registries.permission = 4;
+        let dispatcher = horizon_client::command::vanilla::build_for(false, true);
+        let parsed = dispatcher.parse(text, &game.ui.registries);
+        let (ctx, _) = parsed
+            .executable()
+            .expect("actual registered dedicated command");
+        let (root, ctx) = (parsed.context.clone(), ctx.clone());
+        assert_eq!(game.run_chain(&root, &ctx).unwrap(), 1, "{text}");
+        assert!(
+            !game.chat_capture.take().unwrap().is_empty(),
+            "actual command feedback {text}"
+        );
+    }
+
+    #[test]
+    #[ignore = "prepared resources and isolated scratch homes/cwd"]
+    fn command_forced_free_point_survives_real_guest_death_and_respawn_packet() {
+        let mut game = crate::game::native_machines::tests::server_game();
+        game.set_allow_commands(true);
+        let scratch = std::env::temp_dir().join(format!(
+            "horizon-forced-spawn-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&scratch).unwrap();
+        game.world_root = scratch.clone();
+        // Fixture setup through the existing column insertion API; admit every lit column below.
+        for x in -2..=2 {
+            for z in -2..=2 {
+                game.streaming
+                    .insert_remote(&mut game.world, Chunk::empty(x, z));
+                assert!(game.streaming.is_lit(x, z));
+            }
+        }
+        let stone = game
+            .pack
+            .assets
+            .registry
+            .default_state("minecraft:stone")
+            .unwrap();
+        let air = game
+            .pack
+            .assets
+            .registry
+            .default_state("minecraft:air")
+            .unwrap();
+        game.world.set(12, 99, 12, stone).unwrap();
+        for y in [100, 101] {
+            game.world.set(12, y, 12, air).unwrap();
+        }
+        assert_eq!(game.world.block(12, 99, 12), stone);
+        assert!(game.world.loaded(12, 12));
+        game.level.world_spawn = Some([4, 100, 4]);
+        game.level.world_spawn_angle = [-30.0, -5.0];
+        game.lan_host(
+            LanSettings {
+                port: 0,
+                guest_commands: true,
+                force_game_mode: false,
+            },
+            NetConfig {
+                listen: false,
+                announce: false,
+                ..NetConfig::loopback(0, String::new(), 2)
+            },
+            HubConfig {
+                default_game_mode: 0,
+                guest_commands: true,
+                force_game_mode: false,
+                hardcore: false,
+                view_distance: 2,
+                simulation_distance: 2,
+                dimension: "minecraft:overworld".into(),
+                allow_flight: false,
+                seed: 0,
+                max_players: 2,
+                integrated: false,
+                levels: Default::default(),
+            },
+        )
+        .unwrap();
+        let (tx, rx) = mpsc::channel();
+        let mut guest = Guest::new(
+            Joined {
+                conn: 7,
+                uuid: 77,
+                name: "Alice".into(),
+                properties: Vec::new(),
+                info: ClientInformation::new(2),
+                brand: "test".into(),
+                sender: PlayerSender::new(tx, Arc::default()),
+                latency: Arc::new(AtomicI32::new(0)),
+                address: "127.0.0.1:7".parse().unwrap(),
+                expected: false,
+                configured: Default::default(),
+            },
+            7,
+            [4.5, 100.0, 4.5],
+            2,
+        );
+        guest.dimension = "minecraft:overworld".into();
+        guest.placed = true;
+        guest.loaded = true;
+        guest.health = 20.0;
+        guest.game_mode = 0;
+        guest.yaw = 0.0;
+        guest.pitch = 0.0;
+        game.lan.as_mut().unwrap().hub.guests.push(guest);
+        let clock = game.world.game_time;
+        command(&mut game, "spawnpoint Alice 12 100 12 45 10");
+        let host = game.lan.as_ref().unwrap();
+        assert!(host.owner.is_none());
+        let guest = &host.hub.guests[0];
+        assert_eq!(
+            (guest.uuid, guest.health, guest.game_mode, guest.position),
+            (77, 20.0, 0, [4.5, 100.0, 4.5])
+        );
+        let tag = playerdata::player_tag(guest);
+        let respawn = tag
+            .get("respawn")
+            .expect("actual serialized personal configuration")
+            .clone();
+        assert_eq!(
+            respawn.get("yaw"),
+            Some(&horizon_world::nbt::Tag::Float(45f32.to_bits()))
+        );
+        assert_eq!(
+            respawn.get("pos"),
+            Some(&horizon_world::nbt::Tag::IntArray(vec![12, 100, 12]))
+        );
+        command(&mut game, "kill Alice");
+        game.tick_lan(false);
+        let mut host = game.lan.take().unwrap();
+        assert_eq!(host.hub.guests[0].uuid, 77);
+        assert_eq!(host.hub.guests[0].health, 0.0);
+        assert!(
+            host.hub.guests[0].dead,
+            "actual command death before request"
+        );
+        for _ in rx.try_iter() {}
+        game.lan_guest_packet(
+            &mut host,
+            7,
+            S::ClientCommand(play::ClientCommand { action: 0 }),
+        );
+        game.tick_server_travel(&mut host);
+        assert!(
+            !game.on_server_trip(7),
+            "admitted lit columns permit actual arrival"
+        );
+        let guest = &host.hub.guests[0];
+        assert_eq!(guest.uuid, 77);
+        assert_eq!(guest.health, 20.0);
+        assert!(!guest.dead);
+        assert_eq!(guest.position, [12.5, 100.1, 12.5]);
+        assert_eq!(game.level.world_spawn, Some([4, 100, 4]));
+        assert_eq!(game.level.world_spawn_angle, [-30.0, -5.0]);
+        assert_eq!(game.world.game_time, clock);
+        let physical = [guest.yaw.to_bits(), guest.pitch.to_bits()];
+        let awaiting_id = guest
+            .awaiting_teleport
+            .expect("actual final arrival awaits its acknowledgement")
+            .0;
+        let mut packets = Vec::new();
+        for out in rx.try_iter() {
+            match out {
+                Out::Packet(p) => packets.push(p),
+                Out::Packets(p) => packets.extend(p),
+                Out::Disconnect(_) => panic!("unexpected disconnect"),
+            }
+        }
+        let mut positions = Vec::new();
+        let mut respawns = 0;
+        for p in packets {
+            println!("complete actual Hub frame {p:?}");
+            let mut r = horizon_protocol::buf::Reader::new(&p);
+            let id = r.varint().unwrap();
+            match C::decode(id, r.rest()).unwrap() {
+                C::PlayerPosition(p) => positions.push(p),
+                C::Respawn(_) => respawns += 1,
+                _ => {}
+            }
+        }
+        assert_eq!(respawns, 1);
+        assert!(!positions.is_empty());
+        println!("all actual arrival positions {positions:?}");
+        let selected: Vec<_> = positions
+            .iter()
+            .filter(|p| p.teleport == awaiting_id)
+            .collect();
+        assert_eq!(
+            selected.len(),
+            1,
+            "select by actual authoritative pending id, never expected position/pitch"
+        );
+        let p = selected[0];
+        assert_eq!(p.position, [12.5, 100.1, 12.5]);
+        // All successful command/death/arrival/identity/world controls precede the intended regression.
+        assert_eq!(
+            (
+                respawn.get("pitch"),
+                physical,
+                [p.yaw.to_bits(), p.pitch.to_bits()]
+            ),
+            (
+                Some(&horizon_world::nbt::Tag::Float(10f32.to_bits())),
+                [45f32.to_bits(), 10f32.to_bits()],
+                [45f32.to_bits(), 10f32.to_bits()]
+            )
+        );
+        drop(host);
+        drop(game);
+        std::fs::remove_dir_all(scratch).unwrap();
+    }
+}
+
+#[cfg(test)]
+mod pitch_preservation_controls {
+    use super::*;
+
+    #[test]
+    fn wrapped_existing_callers_default_to_positive_zero_pitch() {
+        let c = RespawnConfig::wrapped(Dim::Overworld, [5, 100, 5], 45.0, false);
+        assert_eq!(c.yaw.to_bits(), 45f32.to_bits());
+        assert_eq!(c.pitch.to_bits(), 0.0f32.to_bits());
+        assert!(!c.forced);
+    }
+
+    /// Added source/model controls; these do not add a connected bed/anchor runtime claim.
+    #[test]
+    #[ignore = "prepared resources and isolated scratch homes/cwd"]
+    fn bed_anchor_facing_and_invalid_personal_fallback_ignore_stored_pitch() {
+        let mut game = crate::game::native_machines::tests::server_game();
+        let stone = game
+            .pack
+            .assets
+            .registry
+            .default_state("minecraft:stone")
+            .unwrap();
+        for x in 0..16 {
+            for z in 0..16 {
+                game.world.set(x, 99, z, stone).unwrap();
+            }
+        }
+        let state = |game: &Game<'_>, name: &str, properties: &[(&str, &str)]| {
+            let registry = game.pack.assets.registry;
+            let id = registry.default_state(name).unwrap();
+            let mut value = registry.state(id).unwrap().clone();
+            for (key, value_) in properties {
+                value.properties.insert((*key).into(), (*value_).into());
+            }
+            registry.resolve(&value).unwrap()
+        };
+        let head = state(
+            &game,
+            "minecraft:red_bed",
+            &[("facing", "north"), ("part", "head")],
+        );
+        let foot = state(
+            &game,
+            "minecraft:red_bed",
+            &[("facing", "north"), ("part", "foot")],
+        );
+        game.world.set(5, 100, 5, head).unwrap();
+        game.world.set(5, 100, 6, foot).unwrap();
+        assert!(game.is_bed(head) && game.bed_sets_spawn(head));
+        let bed = RespawnConfig {
+            dim: Dim::Overworld,
+            pos: [5, 100, 5],
+            yaw: 45.0,
+            pitch: 0.0,
+            forced: true,
+        };
+        let zero = game
+            .find_respawn_and_use(bed, false)
+            .unwrap()
+            .expect("valid bed geometry");
+        let stored = game
+            .find_respawn_and_use(RespawnConfig { pitch: 75.0, ..bed }, false)
+            .unwrap()
+            .unwrap();
+        assert_eq!(stored, zero);
+        assert_eq!(stored.2.to_bits(), 0.0f32.to_bits());
+        assert_eq!(stored.1.to_bits(), look_at_yaw(stored.0, bed.pos).to_bits());
+
+        // Existing built-in dimension facts select the anchor rule; no new world or actor API.
+        game.dim = Dim::Nether;
+        let anchor = state(&game, "minecraft:respawn_anchor", &[("charges", "2")]);
+        game.world.set(10, 100, 10, anchor).unwrap();
+        assert!(game.anchor_works() && game.is_anchor(anchor));
+        let c = RespawnConfig {
+            dim: Dim::Nether,
+            pos: [10, 100, 10],
+            yaw: 45.0,
+            pitch: 0.0,
+            forced: true,
+        };
+        let zero = game
+            .find_respawn_and_use(c, false)
+            .unwrap()
+            .expect("valid anchor geometry");
+        let stored = game
+            .find_respawn_and_use(RespawnConfig { pitch: 75.0, ..c }, true)
+            .unwrap()
+            .unwrap();
+        assert_eq!(stored, zero);
+        assert_eq!(stored.2.to_bits(), 0.0f32.to_bits());
+        assert_eq!(stored.1.to_bits(), look_at_yaw(stored.0, c.pos).to_bits());
+        assert_eq!(
+            game.world.block(10, 100, 10),
+            anchor,
+            "existing forced-charge behavior"
+        );
+
+        game.dim = Dim::Overworld;
+        game.level.world_spawn = Some([4, 100, 4]);
+        game.level.world_spawn_angle = [-30.0, -5.0];
+        game.world.set(12, 100, 12, stone).unwrap();
+        let invalid = RespawnConfig {
+            dim: Dim::Overworld,
+            pos: [12, 100, 12],
+            yaw: 45.0,
+            pitch: 10.0,
+            forced: true,
+        };
+        game.respawn_config = Some(invalid);
+        assert!(game.resolve_server_respawn(invalid).is_none());
+        assert!(game.respawn_config.is_none());
+        assert_eq!(game.level.world_spawn, Some([4, 100, 4]));
+        assert_eq!(game.level.world_spawn_angle, [-30.0, -5.0]);
+    }
+}
@@ -362,6 +362,7 @@ impl Game<'_> {
            path,
            size: Some([64, 64]),
            scaled: false,
+            background: true,
        });
    }
 }
@@ -823,7 +823,7 @@ impl Game<'_> {
        for (location, rgba) in ready {
            self.store_skin(location, rgba);
        }
-        self.cosmetics_frame();
+        self.client_hooks_frame();
    }
    /// `Hud.extractTabList`: the player list while the player-list key is
    /// held. A local world shows it with a joined LAN guest or a `list`
@@ -900,10 +900,12 @@ impl Game<'_> {
        let board = &self.score.board;
        let objective = board.display_objective(sb::SLOT_LIST);
        let up = |id: u128| upside_down.contains(&id);
-        // Horizon's mark before the names of Horizon players (the cosmetics service's cache).
-        let horizon = self.horizon_players(players.iter().map(|p| p.uuid));
-        let horizon_mark = super::cosmetics::MARK;
-        let marked = |id: u128| horizon.contains(&id).then_some(horizon_mark);
+        // A hook's mark before a name (Horizon's: they play Horizon).
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let marked = horizon_hooks::engine::player_mark;
        let inputs = TabInputs {
            players: &players,
            board,
@@ -138,10 +138,7 @@ impl Game<'_> {
            return Err("a screenshot sequence is already running".into());
        }
        let renderer = self.renderer.as_ref().ok_or("no renderer yet")?;
-        if self.pending_screenshot.is_some()
-            || self.ui.screenshot_message.is_some()
-            || renderer.screenshot.is_some()
-        {
+        if self.pending_screenshot.is_some() || renderer.screenshot.is_some() {
            return Err("a screenshot is already pending".into());
        }
        if let Some(refusal) = self.sequence_refusal() {
@@ -233,6 +230,7 @@ impl Game<'_> {
                path,
                size: None,
                scaled: false,
+                background: false,
            });
            renderer.screenshot_result = None;
        }
@@ -644,11 +644,14 @@ impl Game<'_> {
    /// in the level in place: where it stands up, facing the anchor (with
    /// the deplete sound) or the bed; else the point is forgotten, and the
    /// caller tells the player (`Hub::missing_respawn_block`).
-    pub(super) fn resolve_server_respawn(&mut self, config: RespawnConfig) -> Option<(Vec3, f32)> {
+    pub(super) fn resolve_server_respawn(
+        &mut self,
+        config: RespawnConfig,
+    ) -> Option<(Vec3, f32, f32)> {
        let [x, y, z] = config.pos;
        let anchor = self.is_anchor(self.world.block(x, y, z));
        match self.find_respawn_and_use(config, true) {
-            Ok(Some((at, yaw))) => {
+            Ok(Some((at, yaw, pitch))) => {
                if !config.forced && anchor {
                    let [x, y, z] = config.pos.map(f64::from);
                    self.audio.play(
@@ -658,7 +661,7 @@ impl Game<'_> {
                        1.0,
                    );
                }
-                Some((at, yaw))
+                Some((at, yaw, pitch))
            }
            Ok(None) | Err(_) => {
                let mut cancel = false;
@@ -796,7 +799,10 @@ impl Game<'_> {
            let yaw = host.hub.guests[i].yaw;
            let (position, yaw) = if let Some(config) = trip.respawn {
                match self.as_guest(host, trip.conn, |g| g.resolve_server_respawn(config)) {
-                    Some(Some(found)) => found,
+                    Some(Some((at, yaw, pitch))) => {
+                        host.hub.guests[i].pitch = pitch;
+                        (at, yaw)
+                    }
                    _ => {
                        host.hub.missing_respawn_block(trip.conn);
                        self.respawn_at_world_spawn(host, trip.conn);
@@ -261,6 +261,8 @@ impl<'a> Split<'a> {
                .get(i.wrapping_sub(1))
                .map(|g| g.options.clone()),
        );
+        let seat = self.guests.get(i.wrapping_sub(1)).map_or(1, |g| g.seat);
+        horizon_hooks::engine::set_seat(seat - 1);
        self.turn = i;
    }

@@ -126,6 +126,7 @@ impl Split<'_> {
        // Until it has a profile, a scratch options file: never P1's.
        let options = Self::folder()?.join(".joining/options.txt");
        OPTIONS.set(Some(options.clone()));
+        horizon_hooks::engine::set_seat(seat - 1);
        let mut settings = self.host.settings.clone();
        if pad.is_some() {
            // The Controller setting is P1's own: a player who pressed a pad to join plays
@@ -135,6 +136,7 @@ impl Split<'_> {
        }
        let game = self.start_guest(seat, &options, settings);
        OPTIONS.set(None);
+        horizon_hooks::engine::set_seat(0);
        let mut game = game?;
        if let Some(pad) = pad {
            // The press that joined it doesn't act in its game.
@@ -299,16 +301,31 @@ impl Split<'_> {
        }
        let profile = profiles.join(&name);
        let options = profile.join("options.txt");
-        let mut settings = if options.exists() {
-            horizon_client::settings::Settings::load(&options)
+        let made = if options.exists() {
+            None
        } else {
            std::fs::create_dir_all(&profile)?;
            let mut new = self.host.settings.clone();
            // The Controller setting is P1's, as on the profile page (`join`).
            new.controller.enabled |= self.guests[i].pad.is_some();
+            // On P1's seat, so the crates' settings stores write P1's values too.
+            let turn = horizon_hooks::seat();
+            horizon_hooks::engine::set_seat(0);
            new.save(&options);
-            new
+            horizon_hooks::engine::set_seat(turn);
+            Some(new)
        };
+        // The crates' stores load into the guest's seat, before its turn starts below.
+        let turn = horizon_hooks::seat();
+        horizon_hooks::engine::set_seat(self.guests[i].seat - 1);
+        let mut settings = match made {
+            Some(new) => {
+                horizon_client::settings::Settings::load_stores(&options);
+                new
+            }
+            None => horizon_client::settings::Settings::load(&options),
+        };
+        horizon_hooks::engine::set_seat(turn);
        // A profile an earlier join saved with P1's off, or the player's pad would be dead.
        settings.controller.enabled |= self.guests[i].pad.is_some();
        // P1's own world through memory (`Ok`), else P1's server over the network (`Err`).
@@ -516,10 +516,9 @@ impl<'a> Split<'a> {
                continue;
            }
            // Opened without the focus: whoever types in the game's window keeps the keyboard.
-            let attributes =
-                horizon_client::window::with_horizon_icon(Window::default_attributes())
-                    .with_active(false)
-                    .with_visible(window_shown(true, self.offscreen));
+            let attributes = horizon_client::window::with_icon(Window::default_attributes())
+                .with_active(false)
+                .with_visible(window_shown(true, self.offscreen));
            // A monitor's window covers it, borderless. On macOS not the system's fullscreen, a
            // Space of its own that hides the other windows as it slides in.
            let placement = self.placement(*key).cloned();
@@ -113,6 +113,117 @@ fn fire_from_damage_lights_or_burns_the_stand_though_the_command_fails() {
    assert!(health.ends_with(": 16.0f"), "{health}");
 }

+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn igniting_a_frozen_stand_clears_its_freeze_while_burning_keeps_it() {
+    let mut game = game();
+    summon(&mut game, ",TicksFrozen:140");
+    let (_, frozen) = say(&mut game, &format!("data get entity {STAND} TicksFrozen"));
+    assert!(frozen.ends_with(": 140"), "{frozen}");
+    assert!(!game.run_command(&format!("damage {STAND} 1 minecraft:in_fire")));
+    let (_, fire) = say(&mut game, &format!("data get entity {STAND} Fire"));
+    assert!(fire.ends_with(": 100s"), "{fire}");
+    let (ok, frozen_after) = say(&mut game, &format!("data get entity {STAND} TicksFrozen"));
+    assert!(!ok, "{frozen_after}");
+
+    // When already burning, in_fire calls causeDamage(0.15) instead of igniteForSeconds.
+    assert!(game.run_command(&format!("data merge entity {STAND} {{TicksFrozen:140}}")));
+    assert!(!game.run_command(&format!("damage {STAND} 1 minecraft:in_fire")));
+    let (ok, still_frozen) = say(&mut game, &format!("data get entity {STAND} TicksFrozen"));
+    assert!(ok && still_frozen.ends_with(": 140"), "{still_frozen}");
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn damage_immunity_on_worn_boots_refuses_campfire_but_not_in_fire_or_wrong_slot() {
+    let mut game = game();
+    summon(
+        &mut game,
+        r#",equipment:{feet:{id:"minecraft:diamond_boots",count:1,components:{"minecraft:enchantments":{"minecraft:frost_walker":1}}}}"#,
+    );
+    // campfire is in both #ignites_armor_stands and #burn_from_stepping.
+    assert!(!game.run_command(&format!("damage {STAND} 1 minecraft:campfire")));
+    let (_, fire) = say(&mut game, &format!("data get entity {STAND} Fire"));
+    assert!(fire.ends_with(": 0s"), "{fire}");
+    // in_fire is not in #burn_from_stepping, so it still ignites the stand.
+    assert!(!game.run_command(&format!("damage {STAND} 1 minecraft:in_fire")));
+    let (_, fire) = say(&mut game, &format!("data get entity {STAND} Fire"));
+    assert!(fire.ends_with(": 100s"), "{fire}");
+
+    // Frost Walker on a helmet (head) is not in an active slot for the enchantment.
+    let mut helmeted = self::game();
+    summon(
+        &mut helmeted,
+        r#",equipment:{head:{id:"minecraft:diamond_helmet",count:1,components:{"minecraft:enchantments":{"minecraft:frost_walker":1}}}}"#,
+    );
+    assert!(!helmeted.run_command(&format!("damage {STAND} 1 minecraft:campfire")));
+    let (_, fire) = say(&mut helmeted, &format!("data get entity {STAND} Fire"));
+    assert!(fire.ends_with(": 100s"), "{fire}");
+}
+
+fn capture() {
+    super::sculk::TEST_POSTED_EVENTS.with(|events| *events.borrow_mut() = Some(Vec::new()));
+}
+
+fn take_events() -> Vec<(&'static str, [f64; 3], Option<horizon_client::mobs::Who>)> {
+    super::sculk::TEST_POSTED_EVENTS.with(|events| events.borrow_mut().take().unwrap_or_default())
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn cause_damage_and_explosion_post_attributed_game_events() {
+    use horizon_client::mobs::Who;
+    let mut game = game();
+    summon(&mut game, ",Fire:200s");
+    assert!(game.run_command("summon pig 14.5 100 2.5 {NoAI:1b}"));
+    let pig_id = game.mobs[0].id;
+    let at = [2.5, 100.0, 8.5];
+
+    // Burning stand hurt by in_fire (0.15) posts entity_damage attributed to the pig.
+    capture();
+    assert!(!game.run_command(&format!(
+        "damage {STAND} 1 minecraft:in_fire by @e[type=pig,limit=1]"
+    )));
+    assert_eq!(
+        take_events(),
+        vec![("minecraft:entity_damage", at, Some(Who::Mob(pig_id)))]
+    );
+
+    // Burning stand hurt by on_fire (4.0) while surviving posts entity_damage.
+    capture();
+    assert!(!game.run_command(&format!(
+        "damage {STAND} 1 minecraft:on_fire by @e[type=pig,limit=1]"
+    )));
+    assert_eq!(
+        take_events(),
+        vec![("minecraft:entity_damage", at, Some(Who::Mob(pig_id)))]
+    );
+
+    // Burning stand broken by on_fire (health <= 0.5) posts entity_die attributed to the pig.
+    assert!(game.run_command(&format!("data merge entity {STAND} {{Health:4f}}")));
+    capture();
+    assert!(!game.run_command(&format!(
+        "damage {STAND} 1 minecraft:on_fire by @e[type=pig,limit=1]"
+    )));
+    assert!(!game.run_command(&format!("execute if entity {STAND}")));
+    assert_eq!(
+        take_events(),
+        vec![("minecraft:entity_die", at, Some(Who::Mob(pig_id)))]
+    );
+
+    // Stand broken by explosion posts entity_die attributed to the pig.
+    summon(&mut game, "");
+    capture();
+    assert!(!game.run_command(&format!(
+        "damage {STAND} 1 minecraft:explosion by @e[type=pig,limit=1]"
+    )));
+    assert!(!game.run_command(&format!("execute if entity {STAND}")));
+    assert_eq!(
+        take_events(),
+        vec![("minecraft:entity_die", at, Some(Who::Mob(pig_id)))]
+    );
+}
+
 // Controls added after the baseline: the guards before the acting sources,
 // and a stand broken once however often it is hurt.

@@ -1268,7 +1268,7 @@ impl Loading {
            let output = self
                .renderer
                .as_ref()
-                .map_or(Default::default(), |r| *r.output());
+                .map_or(Default::default(), |r| r.output());
            self.menu
                .options
                .draw(&self.settings, output, batch, &gui.atlas, self.menu.cursor);
@@ -273,9 +273,8 @@ impl ApplicationHandler for Game<'_> {
        let fullscreen = self.settings.fullscreen || self.options.fullscreen;
        let size = self.options.window_size.map(f64::from);
        self.fullscreen = horizon_client::window::FullscreenState::new(fullscreen);
-        let attributes = horizon_client::window::with_horizon_icon(
-            Window::default_attributes().with_title("Horizon"),
-        );
+        let attributes =
+            horizon_client::window::with_icon(Window::default_attributes().with_title("Horizon"));
        // Wayland names the window by its app id, which the horizon.desktop entry matches.
        #[cfg(target_os = "linux")]
        let attributes = winit::platform::wayland::WindowAttributesExtWayland::with_name(
@@ -245,7 +245,7 @@ impl Game<'_> {
        // Pause-menu and death-screen exits use the normal world-close action.
        // A standalone replay owns a synthetic remote session, so it must go
        // through replay cleanup instead of being treated like a server.
-        if self.studio_replay.is_some() {
+        if self.replay.playing() {
            self.close_studio_replay();
            return Ok(());
        }
@@ -0,0 +1,56 @@
+//! Horizon's look, given to the engine's extension points at startup (docs/layers.md): the
+//! windows' icon and the colours, sizes and fonts of the menus vanilla doesn't have
+//! (`docs/design-system.md`).
+//! Its own module so it can leave the engine crate as a pure file move, for the official
+//! executable to call.
+use horizon_client::menu_style::{Fonts, MenuStyle, OverlayColours, SettingsColours, Sizes};
+use horizon_theme as theme;
+
+/// Give the engine Horizon's look; call it once, before the first window opens.
+pub(crate) fn give() {
+    horizon_client::window::set_icon_png(theme::ICON_PNG);
+    let (blocks, dark) = (theme::BLOCKS_DARK, theme::DARK);
+    horizon_client::menu_style::install(MenuStyle {
+        settings: SettingsColours {
+            page: blocks.page,
+            ink: blocks.ink,
+            ink_soft: blocks.ink_soft,
+            muted: blocks.muted,
+            outline: blocks.outline,
+            accent: blocks.accent,
+            face: blocks.face,
+            // The face's hover, lighter than `face`: the settings screen's own shade.
+            face_hover: 0x6a50e6,
+            success: blocks.success,
+            warn: blocks.warn,
+            danger: blocks.danger,
+        },
+        overlay: OverlayColours {
+            page: dark.page,
+            backdrop_muted: theme::BACKDROP_MUTED,
+            ink: dark.ink,
+            ink_soft: dark.ink_soft,
+            rule: dark.rule,
+            accent: dark.accent,
+            on_accent: dark.on_accent,
+        },
+        sizes: Sizes {
+            caption: theme::CAPTION.px,
+            label: theme::LABEL.px,
+            ui: theme::UI.px,
+            body: theme::BODY.px,
+            title: theme::TITLE.px,
+            display: theme::DISPLAY.px,
+            micro: theme::MICRO.px,
+            radius: theme::RADIUS,
+            radius_plate: theme::RADIUS_PLATE,
+            control_large: theme::CONTROL_LARGE,
+        },
+        fonts: Some(Fonts {
+            regular: theme::fonts::GEIST_REGULAR,
+            medium: theme::fonts::GEIST_MEDIUM,
+            semibold: theme::fonts::GEIST_SEMIBOLD,
+            mono: theme::fonts::GEIST_MONO,
+        }),
+    });
+}
@@ -173,10 +173,10 @@ pub struct Guest {
    /// Where the player respawns (a bed's spot; `ServerPlayer.respawnConfig`),
    /// None for the world spawn.
    pub spawn: Option<[f64; 3]>,
-    /// A respawn point outside the Overworld (a respawn anchor, or one
-    /// `spawnpoint` set there): its dimension, block, yaw and whether it is
-    /// forced, as the player's save keeps it (`respawn`).
-    pub respawn_elsewhere: Option<(String, [i32; 3], f32, bool)>,
+    /// A block-resolved personal respawn point: its dimension, block, yaw,
+    /// pitch and whether it is forced, as the player's save keeps it
+    /// (`respawn`).
+    pub respawn_elsewhere: Option<(String, [i32; 3], f32, f32, bool)>,
    /// Pending ClientboundPlayerPositionPacket id; movement is ignored until
    /// the client accepts it (ServerGamePacketListenerImpl.awaitingPositionFromClient).
    pub awaiting_teleport: Option<(i32, [f64; 3])>,
@@ -343,7 +343,7 @@ struct Kept {
    effects: Option<crate::effects::PlayerEffects>,
    game_mode: Option<(i32, bool, f32)>,
    position: Option<([f64; 3], [f64; 3], f32, f32, f32, bool, Option<[i32; 4]>)>,
-    spawn: Option<(Option<[f64; 3]>, Option<(String, [i32; 3], f32, bool)>)>,
+    spawn: Option<(Option<[f64; 3]>, Option<(String, [i32; 3], f32, f32, bool)>)>,
    recipes: Option<crate::recipe_book::Settings>,
    /// The body's values: its fall goes with the position, its air and fire with the
    /// health.
@@ -6,6 +6,7 @@ extern crate self as horizon_client;
 pub use horizon_client_lib::*;
 pub mod entry;
 pub mod game;
+mod horizon_look;
 pub mod mod_api;

 #[cfg(test)]
@@ -771,26 +771,9 @@ fn swim(p: &mut Poses, pos: f32, h: &Hum) {
        lerp(amount, x, 0.3 * (pos * 0.333_333_34).mcos()),
    );
 }
-/// The player model's parts a [`BodyPose`] poses, in its order.
-pub const BODY_PARTS: [&str; 6] = [
-    "head",
-    "body",
-    "right_arm",
-    "left_arm",
-    "right_leg",
-    "left_leg",
-];
-
-/// A pose a higher layer lays over the player model's body after its vanilla animation (Horizon's
-/// emotes, docs/cosmetics.md), handed to the model through [`Mob::emote`]. The engine names no
-/// type of that layer (docs/layers.md); it downcasts its own back through [`std::any::Any`].
-pub trait BodyPose: std::any::Any + std::fmt::Debug + Send + Sync {
-    /// Poses the [`BODY_PARTS`] at `age` (the mob's ticks): `at_rest` holds each part before the
-    /// animation, `poses` as the animation left it; a part the model lacks holds the identity in
-    /// both and is not written back. False when it poses nothing at `age` (`poses` is then
-    /// ignored).
-    fn pose(&self, age: f32, at_rest: &[[f32; 9]; 6], poses: &mut [[f32; 9]; 6]) -> bool;
-}
+/// A pose laid over the player model's body after its vanilla animation, and the parts it poses:
+/// the hook's own types (`horizon_hooks::players`), kept here under their old path.
+pub use horizon_hooks::players::{BODY_PARTS, BodyPose};

 /// Apply the mob's model animation to `p` (at rest), then the pose laid over it, if any.
 pub fn setup(
@@ -73,7 +73,7 @@ impl Animation {
    /// KeyframeAnimation.apply(millis, scale): offsets added to each bone's pose.
    pub fn apply(&self, millis: i64, scale: f32, poses: &mut super::anim::Poses) {
        let mut seconds = millis as f32 / 1000.0;
-        if self.looping {
+        if self.looping && self.length > 0.0 {
            seconds %= self.length;
        }
        for (bone, channels) in &self.bones {
@@ -231,4 +231,34 @@ mod tests {
        ];
        assert!((sample(&k, 1.0, 1.0)[0] - 1.0).abs() < 1e-6);
    }
+    #[test]
+    fn looping_animation_applies_walk_without_overflow() {
+        let anim = Animation {
+            length: 1.25,
+            looping: true,
+            bones: vec![(
+                "body".to_string(),
+                vec![Channel {
+                    target: Target::Position,
+                    keyframes: vec![
+                        Keyframe {
+                            time: 0.0,
+                            pre: [0.0; 3],
+                            post: [0.0, 1.0, 0.0],
+                            catmull: false,
+                        },
+                        Keyframe {
+                            time: 1.25,
+                            pre: [0.0, 1.0, 0.0],
+                            post: [0.0, 1.0, 0.0],
+                            catmull: false,
+                        },
+                    ],
+                }],
+            )],
+        };
+        let mut poses = super::super::anim::Poses::default();
+        anim.apply_walk(50.0, 1.0, 1.0, 2.5, &mut poses);
+        assert!((poses.get("body")[1] - 1.0).abs() < 1e-6);
+    }
 }
@@ -849,7 +849,6 @@ impl Mob {
        self.horizontal_collision = x_hit || z_hit;
        // A server's mobs are authoritative (`isLocalInstanceAuthoritative`):
        // the vertical flags update even without vertical movement.
-        let moved_vertically = wanted.y.abs() > 0.0;
        let vertical = wanted.y != moved.y;
        self.vertical_collision_below = vertical && wanted.y < 0.0;
        self.on_ground = self.vertical_collision_below;
@@ -857,42 +856,51 @@ impl Mob {
        // checkFallDamage reads the landing block (getOnPosLegacy).
        self.supporting = self.supporting_block(w, moved);
        self.species_check_fall_damage(w, moved, events);
-        // Entity.restituteMovementAfterCollisions: the colliding components
-        // bounce back by the entity's bounciness or the block's (a slime
-        // block, a bed), whichever is larger. A mob never sneaks, so nothing
-        // suppresses its bounce there.
-        if moved_vertically && vertical || self.horizontal_collision {
-            // Entity.getOnPos(0.2F): the block whose bounce this move sees.
+        self.restitute_movement(w.world, w.movement, wanted, moved);
+        self.movement_emission(w, moved, events);
+        // Entity.move's last step: soul sand, honey and the like slow the
+        // horizontal speed of whatever the mob stands in or on.
+        let factor = self.block_speed_factor(w);
+        self.velocity = horizon_world::entity_move::scale_by_block_speed(self.velocity, factor);
+    }
+    /// `Entity.restituteMovementAfterCollisions`, shared by travel and piston pushes.
+    pub fn restitute_movement(
+        &mut self,
+        world: &crate::world::World,
+        movement: &horizon_world::movement_properties::BoundMovementProperties,
+        wanted: Vec3,
+        moved: Vec3,
+    ) {
+        let differs = |a: f64, b: f64| (b - a).abs() >= f64::from(1.0e-5_f32);
+        let x_hit = differs(wanted.x, moved.x);
+        let z_hit = differs(wanted.z, moved.z);
+        let vertical = wanted.y != moved.y;
+        if wanted.y.abs() > 0.0 && vertical || x_hit || z_hit {
            let on = (
                self.position.x.floor() as i32,
                (self.position.y - f64::from(0.2_f32)).floor() as i32,
                self.position.z.floor() as i32,
            );
            let input = RestitutionInput {
-                block: w.world.block(on.0, on.1, on.2),
+                block: world.block(on.0, on.1, on.2),
                collided_x: x_hit,
                collided_z: z_hit,
                vertical_collision: vertical,
-                collision_below: self.vertical_collision_below,
+                collision_below: vertical && wanted.y < 0.0,
                living: true,
                resolved_movement: moved,
                fall_distance: self.fall_distance,
            };
-            // The port's phases cannot fail for a mob: a block outside the
-            // registry reads as one with no bounce, never as an error.
+            // Unknown block states have no bounce; the provider cannot fail.
            let _ = restitute_movement(
                &mut MobRestitution {
                    mob: self,
-                    world: w,
+                    world,
+                    movement,
                },
                input,
            );
        }
-        self.movement_emission(w, moved, events);
-        // Entity.move's last step: soul sand, honey and the like slow the
-        // horizontal speed of whatever the mob stands in or on.
-        let factor = self.block_speed_factor(w);
-        self.velocity = horizon_world::entity_move::scale_by_block_speed(self.velocity, factor);
    }
    /// `Entity.getBlockSpeedFactor` at the mob's feet.
    fn block_speed_factor(&self, w: &MobWorld) -> f32 {
@@ -2103,20 +2111,21 @@ pub fn client_water_splash(mob: &mut Mob, out: &mut Vec<MobEvent>) {
 /// mob that never sneaks. The phases themselves are
 /// `movement_restitution::restitute_movement`, the same port the player and
 /// dropped items use.
-struct MobRestitution<'a, 'w> {
+struct MobRestitution<'a> {
    mob: &'a mut Mob,
-    world: &'a MobWorld<'w>,
+    world: &'a crate::world::World,
+    movement: &'a horizon_world::movement_properties::BoundMovementProperties,
 }
-impl<'a, 'w> MobRestitution<'a, 'w> {
+impl<'a> MobRestitution<'a> {
    /// The block's movement data: its coefficients and its bounce tag.
    fn movement(
        &self,
        state: BlockStateId,
    ) -> Result<horizon_world::movement_properties::MovementBlock, ()> {
-        self.world.movement.get(state).map_err(|_| ())
+        self.movement.get(state).map_err(|_| ())
    }
 }
-impl RestitutionWorld for MobRestitution<'_, '_> {
+impl RestitutionWorld for MobRestitution<'_> {
    // The block data cannot fail here: a state the registry does not know
    // reads as a block with no bounce, never as an error.
    type Error = ();
@@ -2162,7 +2171,7 @@ impl RestitutionWorld for MobRestitution<'_, '_> {
                position.z.floor() as i32,
            ));
        };
-        let state = self.world.world.block(support[0], support[1], support[2]);
+        let state = self.world.block(support[0], support[1], support[2]);
        let keeps_column = self
            .movement(state)
            .is_ok_and(|b| b.wall || b.coefficients.fence_gate);
@@ -21,7 +21,12 @@ use horizon_core::{
    random::RandomSource,
 };
 use serde_json::Value;
-use std::{borrow::Cow, collections::HashMap, fs, path::Path};
+use std::{
+    borrow::{Borrow, Cow},
+    collections::HashMap,
+    fs,
+    path::Path,
+};

 pub use crate::biome::{SpawnCost, parse_costs, parse_entries};

@@ -879,13 +884,17 @@ impl SpawnState {
    /// `NaturalSpawner.createState`: every non-persistent entity of a
    /// spawning category in a loaded chunk adds its biome's spawn charge, its
    /// category count and (for mobs) the local caps of the players near it.
-    pub fn new<L: NaturalLevel>(
+    pub fn new<'a, L: NaturalLevel, I>(
        l: &L,
        spawnable_chunks: i32,
        players: Vec<SpawnPlayer>,
-        entities: &[Counted],
+        entities: I,
        chunk_loaded: impl Fn(i32, i32) -> bool,
-    ) -> Self {
+    ) -> Self
+    where
+        I: IntoIterator,
+        I::Item: std::borrow::Borrow<Counted<'a>>,
+    {
        let mut state = Self {
            spawnable_chunks,
            counts: [0; 8],
@@ -898,6 +907,7 @@ impl SpawnState {
            last_checked: None,
        };
        for e in entities {
+            let e = e.borrow();
            if e.is_mob && e.persistent || e.category == Category::Misc {
                continue;
            }
@@ -915,6 +925,10 @@ impl SpawnState {
        }
        state
    }
+    /// Reclaims the player buffer for reuse across passes.
+    pub fn into_players(self) -> Vec<SpawnPlayer> {
+        self.players
+    }
    fn add_charge(&mut self, pos: [i32; 3], charge: f64) {
        if charge != 0.0 {
            self.charges.push((pos, charge));
@@ -928,12 +928,12 @@ fn chunk_pois(
        return;
    };
    let kind = |state: u32| poi_of_state(w, horizon_world::registry::BlockStateId(state));
-    let min = w.world.bottom_y();
-    for s in (y0 - min) >> 4..=(y1 - min) >> 4 {
-        let section = &chunk.sections[s as usize];
-        for &(i, poi) in w.world.pois.get((qx, s, qz), section, kind).iter() {
+    let (min, mut lists) = (w.world.bottom_y(), Vec::new());
+    w.world.pois.column(chunk, min, (y0, y1), kind, &mut lists);
+    for (base, pois) in &lists {
+        for &(i, poi) in pois.iter() {
            let i = i32::from(i);
-            let y = min + s * 16 + (i >> 8);
+            let y = base + (i >> 8);
            if (y0..=y1).contains(&y) {
                visit(poi, [qx * 16 + (i & 15), y, qz * 16 + (i >> 4 & 15)]);
            }