diff --git a/clippy.toml b/clippy.toml
new file mode 100644
index 0000000000..8bab3b0afd
--- /dev/null
+++ b/clippy.toml
@@ -0,0 +1,5 @@
+# `keys.contains(&KeyCode::ShiftLeft)` reads a mapping by its default key: ask by `Action`, so the
+# mapping is named and every device that can hold it counts.
+disallowed-methods = [
+    { path = "horizon_client_input::held::HeldKeys::contains", reason = "use `held(Action::..)`, or `raw` for a key that is no mapping's default", allow-invalid = true },
+]
diff --git a/crates/horizon-client-input/src/actions.rs b/crates/horizon-client-input/src/actions.rs
new file mode 100644
index 0000000000..356ab1b02c
--- /dev/null
+++ b/crates/horizon-client-input/src/actions.rs
@@ -0,0 +1,143 @@
+//! Every input the game names: vanilla's key mappings (`Options.keyMappings`) and Horizon's
+//! pad-only actions. Held state is asked by [`Action`] ([`crate::held::HeldKeys::held`]), not by a
+//! key: code that wants a mapping says which one, and every device that can hold it counts.
+use winit::keyboard::KeyCode;
+
+macro_rules! actions {
+    ($($variant:ident, $name:literal, $key:expr;)*) => {
+        /// A key mapping, or a pad-only action.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+        pub enum Action {
+            $($variant,)*
+        }
+        impl Action {
+            /// In `Options.keyMappings` order, the pad-only actions last.
+            pub const ALL: &[Action] = &[$(Action::$variant,)*];
+            /// The saved name: vanilla's for a mapping, `pad.*` for Horizon's own.
+            pub fn name(self) -> &'static str {
+                match self {
+                    $(Action::$variant => $name,)*
+                }
+            }
+            /// The default key the game's held state keeps this action under. `None` for what
+            /// isn't held as a key there: a mouse mapping, one with no default, a pad-only action,
+            /// and the debug keys, which act on the physical key (`debug_keys.rs`) and whose
+            /// defaults are other mappings' keys.
+            pub fn key(self) -> Option<KeyCode> {
+                match self {
+                    $(Action::$variant => $key,)*
+                }
+            }
+        }
+    };
+}
+
+actions! {
+    Attack, "key.attack", None;
+    Use, "key.use", None;
+    Forward, "key.forward", Some(KeyCode::KeyW);
+    Left, "key.left", Some(KeyCode::KeyA);
+    Back, "key.back", Some(KeyCode::KeyS);
+    Right, "key.right", Some(KeyCode::KeyD);
+    Jump, "key.jump", Some(KeyCode::Space);
+    Sneak, "key.sneak", Some(KeyCode::ShiftLeft);
+    Sprint, "key.sprint", Some(KeyCode::ControlLeft);
+    Drop, "key.drop", Some(KeyCode::KeyQ);
+    Inventory, "key.inventory", Some(KeyCode::KeyE);
+    Chat, "key.chat", Some(KeyCode::KeyT);
+    Playerlist, "key.playerlist", Some(KeyCode::Tab);
+    PickItem, "key.pickItem", None;
+    Command, "key.command", Some(KeyCode::Slash);
+    Friends, "key.friends", Some(KeyCode::KeyO);
+    Emote, "key.emote", Some(KeyCode::KeyB);
+    SocialInteractions, "key.socialInteractions", Some(KeyCode::KeyP);
+    ToggleGui, "key.toggleGui", Some(KeyCode::F1);
+    ToggleSpectatorShaderEffects, "key.toggleSpectatorShaderEffects", Some(KeyCode::F4);
+    Screenshot, "key.screenshot", Some(KeyCode::F2);
+    TogglePerspective, "key.togglePerspective", Some(KeyCode::F5);
+    SmoothCamera, "key.smoothCamera", None;
+    Fullscreen, "key.fullscreen", Some(KeyCode::F11);
+    SpectatorOutlines, "key.spectatorOutlines", None;
+    SpectatorHotbar, "key.spectatorHotbar", None;
+    SwapOffhand, "key.swapOffhand", Some(KeyCode::KeyF);
+    SaveToolbarActivator, "key.saveToolbarActivator", Some(KeyCode::KeyC);
+    LoadToolbarActivator, "key.loadToolbarActivator", Some(KeyCode::KeyX);
+    Advancements, "key.advancements", Some(KeyCode::KeyL);
+    QuickActions, "key.quickActions", Some(KeyCode::KeyG);
+    DebugOverlay, "key.debug.overlay", None;
+    DebugModifier, "key.debug.modifier", None;
+    Hotbar1, "key.hotbar.1", Some(KeyCode::Digit1);
+    Hotbar2, "key.hotbar.2", Some(KeyCode::Digit2);
+    Hotbar3, "key.hotbar.3", Some(KeyCode::Digit3);
+    Hotbar4, "key.hotbar.4", Some(KeyCode::Digit4);
+    Hotbar5, "key.hotbar.5", Some(KeyCode::Digit5);
+    Hotbar6, "key.hotbar.6", Some(KeyCode::Digit6);
+    Hotbar7, "key.hotbar.7", Some(KeyCode::Digit7);
+    Hotbar8, "key.hotbar.8", Some(KeyCode::Digit8);
+    Hotbar9, "key.hotbar.9", Some(KeyCode::Digit9);
+    DebugReloadChunk, "key.debug.reloadChunk", None;
+    DebugShowHitboxes, "key.debug.showHitboxes", None;
+    DebugClearChat, "key.debug.clearChat", None;
+    DebugCrash, "key.debug.crash", None;
+    DebugShowChunkBorders, "key.debug.showChunkBorders", None;
+    DebugShowAdvancedTooltips, "key.debug.showAdvancedTooltips", None;
+    DebugCopyRecreateCommand, "key.debug.copyRecreateCommand", None;
+    DebugSpectate, "key.debug.spectate", None;
+    DebugSwitchGameMode, "key.debug.switchGameMode", None;
+    DebugDebugOptions, "key.debug.debugOptions", None;
+    DebugFocusPause, "key.debug.focusPause", None;
+    DebugDumpDynamicTextures, "key.debug.dumpDynamicTextures", None;
+    DebugReloadResourcePacks, "key.debug.reloadResourcePacks", None;
+    DebugProfiling, "key.debug.profiling", None;
+    DebugCopyLocation, "key.debug.copyLocation", None;
+    DebugDumpVersion, "key.debug.dumpVersion", None;
+    DebugProfilingChart, "key.debug.profilingChart", None;
+    DebugFpsCharts, "key.debug.fpsCharts", None;
+    DebugNetworkCharts, "key.debug.networkCharts", None;
+    DebugLightmapTexture, "key.debug.lightmapTexture", None;
+    DebugImprovedTransparency, "key.debug.improvedTransparency", None;
+    HotbarPrevious, "pad.hotbarPrevious", None;
+    HotbarNext, "pad.hotbarNext", None;
+}
+
+impl Action {
+    pub fn parse(name: &str) -> Option<Self> {
+        Self::ALL.iter().copied().find(|a| a.name() == name)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::keybinds::{self, KeyBinds, MAPPINGS};
+
+    #[test]
+    fn every_mapping_is_an_action_in_order() {
+        let names: Vec<&str> = Action::ALL.iter().map(|a| a.name()).collect();
+        let mappings: Vec<&str> = MAPPINGS.iter().map(|m| m.0).collect();
+        assert_eq!(names[..mappings.len()], mappings[..]);
+        for action in &names[mappings.len()..] {
+            assert!(action.starts_with("pad."), "{action}");
+        }
+    }
+
+    #[test]
+    fn an_actions_key_is_its_mappings_default_key() {
+        for (name, _, category) in MAPPINGS {
+            let action = Action::parse(name).unwrap();
+            let want = if *category == "debug" {
+                None
+            } else {
+                keybinds::key_code(KeyBinds::default_of(name))
+            };
+            assert_eq!(action.key(), want, "{name}");
+        }
+    }
+
+    #[test]
+    fn every_bindable_action_is_an_action() {
+        for (name, _) in crate::gamepad::ACTIONS {
+            assert!(Action::parse(name).is_some(), "{name}");
+        }
+    }
+}
diff --git a/crates/horizon-client-input/src/gamepad.rs b/crates/horizon-client-input/src/gamepad.rs
index c8fcdf7ecf..3148922de9 100644
--- a/crates/horizon-client-input/src/gamepad.rs
+++ b/crates/horizon-client-input/src/gamepad.rs
@@ -1,11 +1,17 @@
 //! Controllers: Horizon's own feature (vanilla 26.3 has no gamepad input).
-//! The default layout is Bedrock Edition's; see docs/controllers.md.
+//! Its default buttons are Horizon's own; analog walking and toggle sneak follow Bedrock Edition on
+//! consoles. See docs/controllers.md.
 //!
 //! This module is the backend-free part: positional buttons, the action
 //! bindings, deadzones and the look curve, button edges from successive pad
 //! states, and `horizon-controller.txt`, kept next to `options.txt` so that
 //! file stays exactly vanilla's. The game reads the pads with gilrs.
-use std::{collections::BTreeMap, fs, path::Path};
+use std::{
+    collections::BTreeMap,
+    fs,
+    path::Path,
+    time::{Duration, Instant},
+};
 
 pub const FILE: &str = "horizon-controller.txt";
 
@@ -316,6 +322,20 @@ pub const ACTIONS: &[(&str, Option<Button>)] = &[
     ("key.smoothCamera", None),
     // Horizon's emote wheel: no button is free by default; the stick's cursor picks.
     ("key.emote", None),
+    ("key.fullscreen", None),
+    ("key.socialInteractions", None),
+    ("key.quickActions", None),
+    ("key.saveToolbarActivator", None),
+    ("key.loadToolbarActivator", None),
+    ("key.hotbar.1", None),
+    ("key.hotbar.2", None),
+    ("key.hotbar.3", None),
+    ("key.hotbar.4", None),
+    ("key.hotbar.5", None),
+    ("key.hotbar.6", None),
+    ("key.hotbar.7", None),
+    ("key.hotbar.8", None),
+    ("key.hotbar.9", None),
 ];
 
 /// How a bindable action reaches the game: one of its own handlers, shared
@@ -330,6 +350,10 @@ pub enum Route {
     Sneak,
     Screenshot,
     SmoothCamera,
+    Fullscreen,
+    /// Does nothing by itself: what reads it asks whether the button is held
+    /// (`Minecraft.handleKeybinds`' toolbar keys, held with a hotbar key).
+    Held,
     Key(winit::keyboard::KeyCode),
     Mouse(winit::event::MouseButton),
 }
@@ -342,6 +366,8 @@ pub fn route(action: &str) -> Option<Route> {
         "key.sneak" => Some(Route::Sneak),
         "key.screenshot" => Some(Route::Screenshot),
         "key.smoothCamera" => Some(Route::SmoothCamera),
+        "key.fullscreen" => Some(Route::Fullscreen),
+        "key.saveToolbarActivator" | "key.loadToolbarActivator" => Some(Route::Held),
         _ => {
             let default = crate::keybinds::KeyBinds::default_of(action);
             crate::keybinds::mouse_button(default)
@@ -361,6 +387,46 @@ pub fn action_caption(action: &str) -> &str {
     }
 }
 
+/// How long a held drop button throws single items before it throws the rest of the stack.
+pub const DROP_STACK_HOLD: Duration = Duration::from_secs(1);
+
+/// What a held drop button does now, past its press.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DropStep {
+    /// Held key.drop (a repeat reaches `KeyMapping.click` as a press).
+    One,
+    /// Control + key.drop: a pad has no Control to hold, so holding on is how it asks.
+    Stack,
+}
+
+/// A held drop button's repeats: a tap throws one item, as Q does; held, it repeats at the pad's
+/// repeat delay and interval; and held for [`DROP_STACK_HOLD`] it throws what's left.
+#[derive(Clone, Copy, Debug)]
+pub struct HeldDrop {
+    since: Instant,
+    next: Instant,
+}
+impl HeldDrop {
+    pub fn new(now: Instant, delay: Duration) -> Self {
+        Self {
+            since: now,
+            next: now + delay,
+        }
+    }
+    /// The step due at `now`, if any; at most one per call.
+    pub fn due(&mut self, now: Instant, interval: Duration) -> Option<DropStep> {
+        if now < self.next {
+            return None;
+        }
+        self.next = now + interval;
+        Some(if now.duration_since(self.since) >= DROP_STACK_HOLD {
+            DropStep::Stack
+        } else {
+            DropStep::One
+        })
+    }
+}
+
 /// Which button pictures prompts use.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum GlyphStyle {
@@ -404,13 +470,21 @@ impl GlyphStyle {
         GlyphStyle::PlayStation,
         GlyphStyle::Nintendo,
     ];
-    /// The style for a pad by its USB vendor (Sony, Nintendo; Microsoft,
-    /// Valve's Steam Deck and Steam Input's virtual pad, and everything else
-    /// look like Xbox).
-    pub fn of_vendor(vendor: Option<u16>) -> Self {
-        match vendor {
-            Some(0x054c) => GlyphStyle::PlayStation,
-            Some(0x057e) => GlyphStyle::Nintendo,
+    /// The style for a pad by its USB ids: Sony's and Nintendo's own, and a few officially licensed
+    /// third-party pads made for their consoles. Microsoft, Valve's Steam Deck and Steam Input's
+    /// virtual pad, and everything else look like Xbox.
+    pub fn of_device(vendor: Option<u16>, product: Option<u16>) -> Self {
+        match (vendor, product) {
+            (Some(0x054c), _) => GlyphStyle::PlayStation,
+            (Some(0x057e), _) => GlyphStyle::Nintendo,
+            // HORIPAD 4 FPS and FPS Plus; Razer Raiju; Nacon Revolution Pro.
+            (Some(0x0f0d), Some(0x0055 | 0x0066))
+            | (Some(0x1532), Some(0x1000))
+            | (Some(0x146b), Some(0x0d01)) => GlyphStyle::PlayStation,
+            // HORIPAD for Nintendo Switch; PowerA Wired Plus; PDP Faceoff Wired Pro.
+            (Some(0x0f0d), Some(0x00c1))
+            | (Some(0x20d6), Some(0xa711))
+            | (Some(0x0e6f), Some(0x0180)) => GlyphStyle::Nintendo,
             _ => GlyphStyle::Xbox,
         }
     }
@@ -718,6 +792,29 @@ pub fn stick_axes(
     }
 }
 
+/// The tilt from which a stick holds a key in [`eight_direction_keys`]: holding one is full speed,
+/// so the small tilts past the deadzone stay still.
+const KEY_TILT: f32 = 0.3;
+/// tan(22.5 degrees): where one of the 8 sectors meets the next.
+const SECTOR_EDGE: f32 = 0.414_213_57;
+
+/// The movement keys (forward, backward, left, right) a move vector (`[left, forward]`) holds: the
+/// one of the 8 headings it is nearest, so it is at most 22.5 degrees off. An edge goes to the
+/// straight heading.
+pub fn eight_direction_keys([left, forward]: [f32; 2]) -> [bool; 4] {
+    if length([left, forward]) < KEY_TILT {
+        return [false; 4];
+    }
+    let along = forward.abs() > SECTOR_EDGE * left.abs();
+    let across = left.abs() > SECTOR_EDGE * forward.abs();
+    [
+        along && forward > 0.0,
+        along && forward < 0.0,
+        across && left > 0.0,
+        across && left < 0.0,
+    ]
+}
+
 /// A radial deadzone: inside it the stick is centred; beyond it the rest of
 /// the travel is rescaled to 0..1 in the same direction, so diagonals aren't
 /// clipped and the first movement past the deadzone is small.
@@ -766,15 +863,6 @@ pub fn look_delta(
     )
 }
 
-/// The hotbar slot after a bumper: one step with wrap-around.
-pub fn hotbar_step(selected: usize, forward: bool) -> usize {
-    if forward {
-        (selected + 1) % 9
-    } else {
-        (selected + 8) % 9
-    }
-}
-
 /// Menu cursor speed in GUI pixels per second at full tilt.
 pub const CURSOR_SPEED: f32 = 300.0;
 
@@ -1481,6 +1569,52 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_held_drop_repeats_then_throws_the_stack() {
+        let t = Instant::now();
+        let at = |ms: u64| t + Duration::from_millis(ms);
+        let (delay, interval) = (Duration::from_millis(350), Duration::from_millis(90));
+        let mut held = HeldDrop::new(t, delay);
+        assert_eq!(held.due(at(100), interval), None, "a tap is one item");
+        assert_eq!(held.due(at(349), interval), None);
+        assert_eq!(held.due(at(350), interval), Some(DropStep::One));
+        assert_eq!(held.due(at(400), interval), None, "not before the interval");
+        assert_eq!(held.due(at(440), interval), Some(DropStep::One));
+        assert_eq!(held.due(at(999), interval), Some(DropStep::One));
+        assert_eq!(held.due(at(1000), interval), None);
+        assert_eq!(held.due(at(1100), interval), Some(DropStep::Stack));
+        assert_eq!(held.due(at(1200), interval), Some(DropStep::Stack));
+        assert_eq!(held.due(at(1201), interval), None);
+    }
+
+    #[test]
+    fn the_later_actions_have_no_default_button_and_leave_saved_bindings() {
+        let defaults = PadSettings::default();
+        for action in [
+            "key.fullscreen",
+            "key.socialInteractions",
+            "key.quickActions",
+            "key.saveToolbarActivator",
+            "key.loadToolbarActivator",
+            "key.hotbar.1",
+            "key.hotbar.9",
+        ] {
+            assert_eq!(defaults.binding(action), None, "{action}");
+        }
+        let read = PadSettings::parse(
+            "bindLayout:1
+bind_key.jump:east
+bind_key.hotbar.2:north
+",
+        );
+        assert_eq!(read.binding("key.jump"), Some(Button::East));
+        assert_eq!(read.binding("key.inventory"), Some(Button::North));
+        assert_eq!(
+            read.actions_of(Button::North),
+            ["key.inventory", "key.hotbar.2"]
+        );
+    }
+
     #[test]
     fn navigation_preferences_migrate_and_stay_with_each_player() {
         let dir = std::env::temp_dir().join(format!(
@@ -1600,7 +1734,7 @@ mod tests {
     }
 
     #[test]
-    fn defaults_follow_bedrock() {
+    fn every_action_has_its_default() {
         let s = PadSettings::default();
         assert_eq!(s.actions_of(Button::South), ["key.jump"]);
         assert_eq!(s.actions_of(Button::RightTrigger), ["key.attack"]);
@@ -1728,6 +1862,63 @@ mod tests {
         assert_eq!(Button::North.by_letter().label(GlyphStyle::Nintendo), "Y");
     }
 
+    #[test]
+    fn a_stick_holds_the_keys_of_its_nearest_heading() {
+        // Forward, backward, left, right, by the heading counted from forward toward left.
+        let headings = [
+            [true, false, false, false],
+            [true, false, true, false],
+            [false, false, true, false],
+            [false, true, true, false],
+            [false, true, false, false],
+            [false, true, false, true],
+            [false, false, false, true],
+            [true, false, false, true],
+        ];
+        for tenth in 0..3600 {
+            let degrees = tenth as f32 / 10.0;
+            if degrees % 45.0 == 22.5 {
+                continue;
+            }
+            for tilt in [0.31, 0.5, 1.0] {
+                let (s, c) = degrees.to_radians().sin_cos();
+                let keys = eight_direction_keys([tilt * s, tilt * c]);
+                let sector = ((degrees / 45.0).round() as usize) % 8;
+                assert_eq!(keys, headings[sector], "{degrees} at {tilt}");
+                let [left, forward] =
+                    crate::input::keyboard_direction(keys[0], keys[1], keys[2], keys[3]);
+                let off = (left.atan2(forward).to_degrees() - degrees).rem_euclid(360.0);
+                assert!(off.min(360.0 - off) <= 22.5 + 1e-3, "{degrees}: {off}");
+            }
+        }
+    }
+
+    #[test]
+    fn a_sector_edge_goes_to_the_straight_heading() {
+        assert_eq!(
+            eight_direction_keys([0.414_213_57, 1.0]),
+            [true, false, false, false]
+        );
+        assert_eq!(
+            eight_direction_keys([0.4143, 1.0]),
+            [true, false, true, false]
+        );
+        assert_eq!(
+            eight_direction_keys([1.0, 0.414_213_57]),
+            [false, false, true, false]
+        );
+    }
+
+    #[test]
+    fn a_small_tilt_holds_no_key() {
+        assert_eq!(eight_direction_keys([0.0, 0.0]), [false; 4]);
+        assert_eq!(eight_direction_keys([0.2, 0.2]), [false; 4]);
+        assert_eq!(
+            eight_direction_keys([0.0, 0.31]),
+            [true, false, false, false]
+        );
+    }
+
     #[test]
     fn radial_deadzone_rescales() {
         assert_eq!(radial([0.1, 0.05], 0.15), [0.0, 0.0]);
@@ -2258,12 +2449,27 @@ mod tests {
     }
 
     #[test]
-    fn hotbar_wraps_and_glyphs_follow_the_vendor() {
-        assert_eq!(hotbar_step(8, true), 0);
-        assert_eq!(hotbar_step(0, false), 8);
-        assert_eq!(hotbar_step(3, true), 4);
-        assert_eq!(GlyphStyle::of_vendor(Some(0x054c)), GlyphStyle::PlayStation);
-        assert_eq!(GlyphStyle::of_vendor(Some(0x28de)), GlyphStyle::Xbox);
-        assert_eq!(GlyphStyle::of_vendor(None), GlyphStyle::Xbox);
+    fn glyphs_follow_the_vendor() {
+        let of = |vendor, product| GlyphStyle::of_device(Some(vendor), Some(product));
+        // Any product of the consoles' makers.
+        assert_eq!(of(0x054c, 0x0ce6), GlyphStyle::PlayStation);
+        assert_eq!(of(0x054c, 0x0001), GlyphStyle::PlayStation);
+        assert_eq!(of(0x057e, 0x2009), GlyphStyle::Nintendo);
+        // A pad made for a console by another maker, and that maker's others.
+        assert_eq!(of(0x0f0d, 0x0066), GlyphStyle::PlayStation);
+        assert_eq!(of(0x0f0d, 0x00c1), GlyphStyle::Nintendo);
+        assert_eq!(of(0x0f0d, 0x0067), GlyphStyle::Xbox);
+        assert_eq!(of(0x20d6, 0xa711), GlyphStyle::Nintendo);
+        // Valve's virtual pad, Microsoft's, nothing known, nothing reported.
+        assert_eq!(of(0x28de, 0x11ff), GlyphStyle::Xbox);
+        assert_eq!(of(0x045e, 0x0b12), GlyphStyle::Xbox);
+        assert_eq!(of(0x1234, 0x5678), GlyphStyle::Xbox);
+        assert_eq!(GlyphStyle::of_device(None, None), GlyphStyle::Xbox);
+        // A vendor alone is enough only for the consoles' makers.
+        assert_eq!(
+            GlyphStyle::of_device(Some(0x054c), None),
+            GlyphStyle::PlayStation
+        );
+        assert_eq!(GlyphStyle::of_device(Some(0x0f0d), None), GlyphStyle::Xbox);
     }
 }
diff --git a/crates/horizon-client-input/src/held.rs b/crates/horizon-client-input/src/held.rs
index c36141a618..532ec8f2f4 100644
--- a/crates/horizon-client-input/src/held.rs
+++ b/crates/horizon-client-input/src/held.rs
@@ -3,15 +3,18 @@
 //! device letting go (splitscreen moving the keyboard to another player, say)
 //! can't release what another still presses.
 
+use crate::actions::Action;
 use std::collections::HashMap;
 use winit::keyboard::KeyCode;
 
 /// Where a press came from.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Source {
-    /// The keyboard and mouse, and the scripting socket acting as them.
+    /// The keyboard and mouse.
     Keyboard,
     Pad,
+    /// `horizon-ctl`'s `key` and `mouse` and the agent commands that walk and click.
+    Agent,
 }
 
 impl Source {
@@ -19,6 +22,7 @@ impl Source {
         match self {
             Source::Keyboard => 1,
             Source::Pad => 2,
+            Source::Agent => 4,
         }
     }
 }
@@ -29,9 +33,20 @@ pub struct HeldKeys {
 }
 
 impl HeldKeys {
-    pub fn contains(&self, key: &KeyCode) -> bool {
+    /// Whether anything holds this mapping: every device, whatever the mapping is bound to.
+    pub fn held(&self, action: Action) -> bool {
+        action.key().is_some_and(|key| self.raw(&key))
+    }
+    /// Whether a key that is no mapping's default is held (Right Shift, the arrows, Alt, the system
+    /// key), or the key a caller already holds as a key: most code wants [`HeldKeys::held`].
+    pub fn raw(&self, key: &KeyCode) -> bool {
         self.held.contains_key(key)
     }
+    /// The old way of asking, by a mapping's default key; clippy refuses it (`clippy.toml`). It
+    /// stays so that a change written against it says what to use instead.
+    pub fn contains(&self, key: &KeyCode) -> bool {
+        self.raw(key)
+    }
     /// `source` holds `key`. True when nothing held it before.
     pub fn press(&mut self, key: KeyCode, source: Source) -> bool {
         let sources = self.held.entry(key).or_insert(0);
@@ -72,7 +87,7 @@ impl HeldKeys {
     /// Held, by the keyboard unless a device already holds it: for callers
     /// that don't say where the press came from.
     pub fn insert(&mut self, key: KeyCode) -> bool {
-        if self.contains(&key) {
+        if self.raw(&key) {
             return false;
         }
         self.press(key, Source::Keyboard)
@@ -132,13 +147,25 @@ mod tests {
         assert!(!keys.press(KeyCode::Space, Source::Keyboard));
         assert!(keys.press(KeyCode::KeyW, Source::Keyboard));
         assert_eq!(keys.release_source(Source::Keyboard), vec![KeyCode::KeyW]);
-        assert!(keys.contains(&KeyCode::Space) && !keys.contains(&KeyCode::KeyW));
+        assert!(keys.held(Action::Jump) && !keys.held(Action::Forward));
         assert!(keys.held_by(&KeyCode::Space, Source::Pad));
         assert!(!keys.held_by(&KeyCode::Space, Source::Keyboard));
         assert!(keys.release(&KeyCode::Space, Source::Pad));
         assert!(keys.is_empty());
     }
 
+    #[test]
+    fn a_script_holds_a_key_by_itself() {
+        let mut keys = HeldKeys::default();
+        keys.press(KeyCode::KeyW, Source::Agent);
+        keys.press(KeyCode::KeyW, Source::Keyboard);
+        assert!(!keys.release(&KeyCode::KeyW, Source::Keyboard));
+        assert!(keys.held(Action::Forward));
+        assert!(keys.release_source(Source::Pad).is_empty());
+        assert_eq!(keys.release_source(Source::Agent), vec![KeyCode::KeyW]);
+        assert!(!keys.held(Action::Forward));
+    }
+
     #[test]
     fn untagged_inserts_and_removes_act_as_before() {
         let mut keys = HeldKeys::default();
@@ -149,7 +176,7 @@ mod tests {
             keys.remove(&KeyCode::ShiftLeft),
             "remove lets go for everyone"
         );
-        assert!(!keys.contains(&KeyCode::ShiftLeft));
+        assert!(!keys.held(Action::Sneak));
         assert!(keys.release(&KeyCode::KeyA, Source::Keyboard), "never held");
     }
 }
diff --git a/crates/horizon-client-input/src/keybinds.rs b/crates/horizon-client-input/src/keybinds.rs
index 7f6a13f423..3b9f50bd0e 100644
--- a/crates/horizon-client-input/src/keybinds.rs
+++ b/crates/horizon-client-input/src/keybinds.rs
@@ -442,6 +442,18 @@ impl KeyBinds {
         }
         vec![Ok(key)]
     }
+    /// `Minecraft.handleKeybinds`: key.pickItem and key.spectatorHotbar share the middle button by
+    /// default and are separate mappings, so a press of what `input` is bound to acts only as the
+    /// one this player can use: the spectator hotbar for a spectator, pick block otherwise. (Pick
+    /// block does nothing a spectator would see.)
+    pub fn middle_acts(&self, input: &str, spectator: bool) -> bool {
+        let mapping = if spectator {
+            "key.spectatorHotbar"
+        } else {
+            "key.pickItem"
+        };
+        self.get(mapping) == input
+    }
     /// Translate a mouse button the same way (keys bound to mouse buttons).
     pub fn translate_mouse(&self, button: MouseButton) -> Option<Result<KeyCode, MouseButton>> {
         self.translate_mouse_all(button).into_iter().next()
@@ -505,6 +517,27 @@ impl KeyBinds {
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    #[test]
+    fn mappings_sharing_the_middle_button_act_as_themselves() {
+        let middle = "key.mouse.middle";
+        let z = "key.keyboard.z";
+        let mut keys = KeyBinds::default();
+        assert!(keys.middle_acts(middle, false) && keys.middle_acts(middle, true));
+        // The spectator hotbar on Z: the middle button only picks, and Z never picks.
+        keys.set("key.spectatorHotbar", z);
+        assert!(keys.middle_acts(middle, false));
+        assert!(!keys.middle_acts(middle, true));
+        assert!(keys.middle_acts(z, true));
+        assert!(!keys.middle_acts(z, false));
+        // Pick block on Z instead: the other way round.
+        keys.reset_all();
+        keys.set("key.pickItem", z);
+        assert!(keys.middle_acts(z, false));
+        assert!(!keys.middle_acts(z, true));
+        assert!(keys.middle_acts(middle, true));
+        assert!(!keys.middle_acts(middle, false));
+    }
     #[test]
     fn container_mouse_hotkeys_follow_slot_bindings_and_pick_item_priority() {
         for button in [MouseButton::Back, MouseButton::Forward, MouseButton::Middle] {
diff --git a/crates/horizon-client-input/src/lib.rs b/crates/horizon-client-input/src/lib.rs
index 4131625fb7..fadf7a6749 100644
--- a/crates/horizon-client-input/src/lib.rs
+++ b/crates/horizon-client-input/src/lib.rs
@@ -3,6 +3,7 @@
 //! options. horizon-client re-exports each module under its old path
 //! (`horizon_client::keybinds`, ...).
 #![forbid(unsafe_code)]
+pub mod actions;
 pub mod clipboard;
 pub mod gamepad;
 pub mod held;
diff --git a/crates/horizon-client-render/src/controller_ui.rs b/crates/horizon-client-render/src/controller_ui.rs
index 5651ffb3ca..5b73c33ab2 100644
--- a/crates/horizon-client-render/src/controller_ui.rs
+++ b/crates/horizon-client-render/src/controller_ui.rs
@@ -133,6 +133,13 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                         ),
                     ],
                 ),
+                (
+                    "Play",
+                    vec![option(
+                        Opt::PadTriggerThreshold,
+                        "How far a trigger is pulled before it counts as pressed.",
+                    )],
+                ),
                 (
                     "Menus",
                     vec![
@@ -1266,6 +1273,7 @@ mod tests {
             Opt::PadInvertY,
             Opt::PadMoveDeadzone,
             Opt::PadLookDeadzone,
+            Opt::PadTriggerThreshold,
             Opt::PadGlyphs,
             Opt::PadKeyboard,
             Opt::PadPointerSpeed,
diff --git a/crates/horizon-client-render/src/hud.rs b/crates/horizon-client-render/src/hud.rs
index a29d5a6176..5f0d10043a 100644
--- a/crates/horizon-client-render/src/hud.rs
+++ b/crates/horizon-client-render/src/hud.rs
@@ -1313,12 +1313,13 @@ impl HudAtlas {
             edition.3 = pixels;
         }
         images.push(("horizon/white".into(), 4, 4, vec![255; 64]));
-        images.push((
-            crate::pad_cursor::SPRITE.into(),
-            crate::pad_cursor::SIZE,
-            crate::pad_cursor::SIZE,
-            crate::pad_cursor::pixels(),
-        ));
+        // The controller's art, unless a pack brought its own (walked above, as a mod's GUI
+        // textures are).
+        for image in crate::pad_glyph::images() {
+            if !images.iter().any(|i| i.0 == image.0) {
+                images.push(image);
+            }
+        }
         if full {
             Self::slots(&mut images, crate::trims::slot_size(root), mod_image);
             // MissingTextureAtlasSprite.generateMissingImage: 16x16, magenta
diff --git a/crates/horizon-client-render/src/lib.rs b/crates/horizon-client-render/src/lib.rs
index a14fd35337..359de0dce6 100644
--- a/crates/horizon-client-render/src/lib.rs
+++ b/crates/horizon-client-render/src/lib.rs
@@ -76,6 +76,7 @@ pub mod pack_browser;
 pub mod pack_screen;
 pub mod packs;
 pub mod pad_cursor;
+pub mod pad_glyph;
 pub mod par;
 pub mod particles;
 pub mod poi_sections;
diff --git a/crates/horizon-client-render/src/options_ui.rs b/crates/horizon-client-render/src/options_ui.rs
index fe58e6fbc7..409ac6418f 100644
--- a/crates/horizon-client-render/src/options_ui.rs
+++ b/crates/horizon-client-render/src/options_ui.rs
@@ -281,6 +281,7 @@ impl Opt {
             Opt::PadToggleSneak => "horizon.options.sneak_button",
             Opt::PadMoveDeadzone => "horizon.options.move_deadzone",
             Opt::PadLookDeadzone => "horizon.options.look_deadzone",
+            Opt::PadTriggerThreshold => "horizon.options.trigger_threshold",
             Opt::PadGlyphs => "horizon.options.button_glyphs",
             Opt::PadKeyboard => "horizon.options.on_screen_keyboard",
             Opt::ModelPart(i) => [
@@ -361,6 +362,7 @@ impl Opt {
             Opt::PadRepeatInterval => unit(s.controller.repeat_interval, 0.03, 0.3),
             Opt::PadMoveDeadzone => unit(s.controller.move_deadzone, 0.0, 0.5),
             Opt::PadLookDeadzone => unit(s.controller.look_deadzone, 0.0, 0.5),
+            Opt::PadTriggerThreshold => unit(s.controller.trigger_threshold, 0.1, 0.9),
             Opt::SprintWindow => unit(s.sprint_window as f32, 0.0, 10.0),
             _ => Kind::Cycle,
         }
@@ -425,6 +427,7 @@ impl Opt {
             Opt::MenuBlur => Some(10),
             Opt::NotificationDisplayTime => Some(95),
             Opt::PadMoveDeadzone | Opt::PadLookDeadzone => Some(50),
+            Opt::PadTriggerThreshold => Some(80),
             Opt::SprintWindow => Some(10),
             _ => None,
         }
@@ -634,11 +637,11 @@ impl Opt {
                     )],
                 ),
             ),
-            Opt::PadMoveDeadzone | Opt::PadLookDeadzone => {
-                let v = if self == Opt::PadMoveDeadzone {
-                    s.controller.move_deadzone
-                } else {
-                    s.controller.look_deadzone
+            Opt::PadMoveDeadzone | Opt::PadLookDeadzone | Opt::PadTriggerThreshold => {
+                let v = match self {
+                    Opt::PadMoveDeadzone => s.controller.move_deadzone,
+                    Opt::PadLookDeadzone => s.controller.look_deadzone,
+                    _ => s.controller.trigger_threshold,
                 };
                 Text::translate(
                     "options.percent_value",
@@ -897,6 +900,7 @@ impl Opt {
             Opt::PadRepeatInterval => s.controller.repeat_interval = step(30.0, 300.0) / 1000.0,
             Opt::PadMoveDeadzone => s.controller.move_deadzone = step(0.0, 50.0) / 100.0,
             Opt::PadLookDeadzone => s.controller.look_deadzone = step(0.0, 50.0) / 100.0,
+            Opt::PadTriggerThreshold => s.controller.trigger_threshold = step(10.0, 90.0) / 100.0,
             Opt::SprintWindow => s.sprint_window = step(0.0, 10.0) as i32,
             _ => {}
         }
@@ -1564,7 +1568,7 @@ pub struct OptionsUi {
     pub selected_key: Option<&'static str>,
     /// The native mod's key waiting: (mod, key) in `mods.installed`.
     selected_native_key: Option<(usize, usize)>,
-    /// Controller Binds: the action waiting for a pad button.
+    /// Bindings: the action waiting for a pad button.
     pub selected_pad_action: Option<&'static str>,
     /// The glyphs the binds list shows (the setting, else the pad's family).
     pub pad_style: GlyphStyle,
@@ -8249,6 +8253,7 @@ mod tests {
             Opt::NotificationDisplayTime,
             Opt::PadMoveDeadzone,
             Opt::PadLookDeadzone,
+            Opt::PadTriggerThreshold,
             Opt::SprintWindow,
         ];
         for opt in stepped_opts {
diff --git a/crates/horizon-client-render/src/pad_cursor.rs b/crates/horizon-client-render/src/pad_cursor.rs
index 43d8d36b00..25a7e25865 100644
--- a/crates/horizon-client-render/src/pad_cursor.rs
+++ b/crates/horizon-client-render/src/pad_cursor.rs
@@ -1,43 +1,13 @@
 //! The controller's menu cursor in inventories: a crosshair whose centre is
-//! the point it clicks. Horizon's own art (pad_cursor.png).
+//! the point it clicks. Horizon's own art, packed with the button glyphs (`pad_glyph`).
 
 /// The atlas sprite.
-pub const SPRITE: &str = "horizon/pad_cursor";
-/// The texture's size in texels, and the size it's drawn at in GUI pixels
-/// (an item's).
-pub const SIZE: u32 = 32;
+pub const SPRITE: &str = "horizon:gui/controller/crosshair_inv";
+/// The size it's drawn at in GUI pixels (an item's); its texture is twice that.
 pub const DRAWN: f32 = 16.0;
 
-const PNG: &[u8] = include_bytes!("pad_cursor.png");
-
-/// The texture as `SIZE` square RGBA texels.
-pub fn pixels() -> Vec<u8> {
-    decode(PNG).expect("pad_cursor.png is a 32x32 PNG")
-}
-
-fn decode(bytes: &[u8]) -> Option<Vec<u8>> {
-    let mut decoder = png::Decoder::new(std::io::Cursor::new(bytes));
-    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
-    let mut reader = decoder.read_info().ok()?;
-    let info = reader.info();
-    if (info.width, info.height) != (SIZE, SIZE) {
-        return None;
-    }
-    let mut buf = vec![0; reader.output_buffer_size()?];
-    let frame = reader.next_frame(&mut buf).ok()?;
-    let channels = frame.color_type.samples();
-    Some(
-        buf.chunks(channels)
-            .take((SIZE * SIZE) as usize)
-            .flat_map(|p| match channels {
-                4 => [p[0], p[1], p[2], p[3]],
-                3 => [p[0], p[1], p[2], 255],
-                2 => [p[0], p[0], p[0], p[1]],
-                _ => [p[0], p[0], p[0], 255],
-            })
-            .collect(),
-    )
-}
+pub(crate) const PNG: &[u8] =
+    include_bytes!("../../horizon-client/assets/horizon/textures/gui/controller/crosshair_inv.png");
 
 /// Where to draw the cursor (top-left, GUI pixels) so its centre lands on
 /// the GUI point `at`.
@@ -51,10 +21,12 @@ mod tests {
 
     #[test]
     fn the_cursor_is_a_crosshair_centred_on_its_point() {
-        let px = pixels();
-        assert_eq!(px.len(), (SIZE * SIZE * 4) as usize);
-        let alpha = |x: u32, y: u32| px[((y * SIZE + x) * 4 + 3) as usize];
-        let middle = (SIZE / 2 - 1)..=(SIZE / 2);
+        let (_, w, h, px) = crate::pad_glyph::images()
+            .find(|i| i.0 == SPRITE)
+            .expect("the cursor is packed");
+        assert_eq!((w as f32, h as f32), (DRAWN * 2.0, DRAWN * 2.0));
+        let alpha = |x: u32, y: u32| px[((y * w + x) * 4 + 3) as usize];
+        let middle = (w / 2 - 1)..=(w / 2);
         assert!(
             middle
                 .clone()
diff --git a/crates/horizon-client-render/src/pad_glyph.rs b/crates/horizon-client-render/src/pad_glyph.rs
new file mode 100644
index 0000000000..4b2d11b1bf
--- /dev/null
+++ b/crates/horizon-client-render/src/pad_glyph.rs
@@ -0,0 +1,386 @@
+//! A controller button as the player sees it: Horizon's own art where the pad's family has one
+//! (`assets/horizon/textures/gui/controller/`, which a resource pack can replace), else the label
+//! printed on the pad, in its colour, on a dark key. Whatever shows a button draws and measures it
+//! here; `Button::label` stays for plain text and narration.
+use crate::gamepad::{Button, GlyphStyle};
+use crate::hud::{HudAtlas, HudBatch, rgba};
+use crate::pad_cursor;
+
+/// The art's height as drawn, in GUI pixels. Its texture is twice that, so it maps pixel for pixel
+/// at GUI scale 2 and to whole pixels at 4.
+const DRAWN_HEIGHT: f32 = 16.0;
+/// The clear edge the art has all round.
+const MARGIN: f32 = 2.0;
+/// How tall a glyph shows, art or key: the text line and 2 above and below it.
+pub const HEIGHT: f32 = DRAWN_HEIGHT - 2.0 * MARGIN;
+/// How wide a face button's art shows; a declared button's label leaves it room.
+pub const FACE_WIDTH: f32 = 12.0;
+
+/// A picture of a button in a family (Auto reads as Xbox, as `Button::label` has it). Every family
+/// has its own file for every button, some of them a copy of another's until theirs is drawn.
+struct Art {
+    family: GlyphStyle,
+    button: Button,
+    /// The atlas sprite: where a pack's own file lands.
+    sprite: &'static str,
+    png: &'static [u8],
+}
+
+macro_rules! art {
+    ($($family:ident $button:ident $file:literal,)*) => {
+        &[$(Art {
+            family: GlyphStyle::$family,
+            button: Button::$button,
+            sprite: concat!("horizon:gui/controller/", $file),
+            png: include_bytes!(concat!(
+                "../../horizon-client/assets/horizon/textures/gui/controller/",
+                $file,
+                ".png"
+            )),
+        },)*]
+    };
+}
+
+/// All the art. A new picture is one line here and its file: a button not listed is text, and a
+/// picture is measured from its texture, so it can be as wide as it needs.
+static ART: &[Art] = art![
+    Xbox South "xb_a",
+    Xbox East "xb_b",
+    Xbox West "xb_x",
+    Xbox North "xb_y",
+    Xbox LeftBumper "xb_lb",
+    Xbox RightBumper "xb_rb",
+    Xbox LeftTrigger "xb_lt",
+    Xbox RightTrigger "xb_rt",
+    Xbox Select "xb_view",
+    Xbox Start "xb_menu",
+    Xbox LeftStick "xb_l3",
+    Xbox RightStick "xb_r3",
+    Xbox DPadUp "xb_up",
+    Xbox DPadDown "xb_down",
+    Xbox DPadLeft "xb_left",
+    Xbox DPadRight "xb_right",
+    PlayStation South "psx_cross",
+    PlayStation East "psx_circle",
+    PlayStation West "psx_square",
+    PlayStation North "psx_triangle",
+    PlayStation LeftBumper "psx_l1",
+    PlayStation RightBumper "psx_r1",
+    PlayStation LeftTrigger "psx_l2",
+    PlayStation RightTrigger "psx_r2",
+    PlayStation Select "psx_create",
+    PlayStation Start "psx_options",
+    PlayStation LeftStick "psx_l3",
+    PlayStation RightStick "psx_r3",
+    PlayStation DPadUp "psx_up",
+    PlayStation DPadDown "psx_down",
+    PlayStation DPadLeft "psx_left",
+    PlayStation DPadRight "psx_right",
+    Nintendo South "nx_b",
+    Nintendo East "nx_a",
+    Nintendo West "nx_y",
+    Nintendo North "nx_x",
+    Nintendo LeftBumper "nx_l",
+    Nintendo RightBumper "nx_r",
+    Nintendo LeftTrigger "nx_zl",
+    Nintendo RightTrigger "nx_zr",
+    Nintendo Select "nx_minus",
+    Nintendo Start "nx_plus",
+    Nintendo LeftStick "nx_l3",
+    Nintendo RightStick "nx_r3",
+    Nintendo DPadUp "nx_up",
+    Nintendo DPadDown "nx_down",
+    Nintendo DPadLeft "nx_left",
+    Nintendo DPadRight "nx_right",
+];
+
+fn find(button: Button, style: GlyphStyle) -> Option<&'static Art> {
+    let family = match style {
+        GlyphStyle::Auto => GlyphStyle::Xbox,
+        style => style,
+    };
+    ART.iter()
+        .find(|art| art.family == family && art.button == button)
+}
+
+/// The sprite of a button in a family, if it has one.
+pub fn sprite(button: Button, style: GlyphStyle) -> Option<&'static str> {
+    find(button, style).map(|art| art.sprite)
+}
+
+/// The sprite this atlas can draw for the button; none (the boot screen's atlas) means text.
+pub fn art(atlas: &HudAtlas, button: Button, style: GlyphStyle) -> Option<&'static str> {
+    sprite(button, style).filter(|name| atlas.sprites.contains_key(*name))
+}
+
+/// How wide the art shows: half its texture (IHDR's width, in a PNG's first bytes) less its edge.
+/// A pack's own texture of another size is drawn in the same place.
+fn art_width(art: &Art) -> f32 {
+    let texels = u32::from_be_bytes([art.png[16], art.png[17], art.png[18], art.png[19]]);
+    texels as f32 / 2.0 - 2.0 * MARGIN
+}
+
+/// How wide the glyph shows.
+pub fn width(atlas: &HudAtlas, button: Button, style: GlyphStyle) -> f32 {
+    match find(button, style).filter(|a| atlas.sprites.contains_key(a.sprite)) {
+        Some(art) => art_width(art),
+        None => HudBatch::text_width(atlas, button.label(style)).ceil() + 4.0,
+    }
+}
+
+/// What the glyph covers with its label's text at `(x, y)`: `[x, y, w, h]`.
+pub fn rect(atlas: &HudAtlas, button: Button, style: GlyphStyle, x: f32, y: f32) -> [f32; 4] {
+    [x - 1.0, y - 2.0, width(atlas, button, style), HEIGHT]
+}
+
+/// Draw the glyph over the 8 pixel text line at `(x, y)`, filling [`rect`]. A dark key backs text
+/// only: the art brings its own.
+pub fn draw(
+    batch: &mut HudBatch,
+    atlas: &HudAtlas,
+    button: Button,
+    style: GlyphStyle,
+    x: f32,
+    y: f32,
+) {
+    let [left, top, wide, tall] = rect(atlas, button, style, x, y);
+    if let Some(name) = art(atlas, button, style) {
+        batch.sprite_scaled(
+            atlas,
+            name,
+            left - MARGIN,
+            top - MARGIN,
+            wide + 2.0 * MARGIN,
+            tall + 2.0 * MARGIN,
+            u32::MAX,
+        );
+    } else {
+        let [r, g, b] = button.color(style);
+        batch.fill(atlas, left, top, wide, tall, rgba(40, 40, 40, 255));
+        batch.text(
+            atlas,
+            button.label(style),
+            x + 1.0,
+            y,
+            rgba(r, g, b, 255),
+            false,
+        );
+    }
+}
+
+/// Horizon's art for the atlas: each `(sprite, width, height, RGBA texels)`.
+pub fn images() -> impl Iterator<Item = (String, u32, u32, Vec<u8>)> {
+    ART.iter()
+        .map(|art| (art.sprite, art.png))
+        .chain([(pad_cursor::SPRITE, pad_cursor::PNG)])
+        .map(|(name, png)| {
+            let (w, h, pixels) = decode(png).expect("Horizon's controller art is PNG");
+            (name.to_owned(), w, h, pixels)
+        })
+}
+
+fn decode(bytes: &[u8]) -> Option<(u32, u32, Vec<u8>)> {
+    let mut decoder = png::Decoder::new(std::io::Cursor::new(bytes));
+    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
+    let mut reader = decoder.read_info().ok()?;
+    let (w, h) = (reader.info().width, reader.info().height);
+    let mut buf = vec![0; reader.output_buffer_size()?];
+    let frame = reader.next_frame(&mut buf).ok()?;
+    let channels = frame.color_type.samples();
+    let pixels = buf
+        .chunks(channels)
+        .take((w * h) as usize)
+        .flat_map(|p| match channels {
+            4 => [p[0], p[1], p[2], p[3]],
+            3 => [p[0], p[1], p[2], 255],
+            2 => [p[0], p[0], p[0], p[1]],
+            _ => [p[0], p[0], p[0], 255],
+        })
+        .collect();
+    Some((w, h, pixels))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn atlas() -> HudAtlas {
+        HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
+    }
+
+    fn file(button: Button, style: GlyphStyle) -> Option<&'static str> {
+        sprite(button, style).and_then(|name| name.strip_prefix("horizon:gui/controller/"))
+    }
+
+    /// The batch's quads as `[left, top, right, bottom]`.
+    fn quads(batch: &HudBatch) -> Vec<[f32; 4]> {
+        batch
+            .vertices
+            .as_chunks::<6>()
+            .0
+            .iter()
+            .map(|quad| {
+                let xs = quad.iter().map(|v| v.pos[0]);
+                let ys = quad.iter().map(|v| v.pos[1]);
+                [
+                    xs.clone().fold(f32::MAX, f32::min),
+                    ys.clone().fold(f32::MAX, f32::min),
+                    xs.fold(f32::MIN, f32::max),
+                    ys.fold(f32::MIN, f32::max),
+                ]
+            })
+            .collect()
+    }
+
+    #[test]
+    fn xbox_and_auto_show_the_letters_and_shoulders() {
+        for style in [GlyphStyle::Xbox, GlyphStyle::Auto] {
+            for (button, expected) in [
+                (Button::South, "xb_a"),
+                (Button::East, "xb_b"),
+                (Button::West, "xb_x"),
+                (Button::North, "xb_y"),
+                (Button::LeftBumper, "xb_lb"),
+                (Button::RightBumper, "xb_rb"),
+                (Button::LeftTrigger, "xb_lt"),
+                (Button::RightTrigger, "xb_rt"),
+                (Button::Select, "xb_view"),
+                (Button::Start, "xb_menu"),
+            ] {
+                assert_eq!(file(button, style), Some(expected));
+            }
+        }
+    }
+
+    #[test]
+    fn playstation_shows_its_symbols_by_position_and_its_own_shoulders() {
+        let style = GlyphStyle::PlayStation;
+        assert_eq!(file(Button::South, style), Some("psx_cross"));
+        assert_eq!(file(Button::East, style), Some("psx_circle"));
+        assert_eq!(file(Button::West, style), Some("psx_square"));
+        assert_eq!(file(Button::North, style), Some("psx_triangle"));
+        assert_eq!(file(Button::LeftBumper, style), Some("psx_l1"));
+        assert_eq!(file(Button::RightTrigger, style), Some("psx_r2"));
+        assert_eq!(file(Button::Select, style), Some("psx_create"));
+    }
+
+    #[test]
+    fn nintendo_shows_what_its_pad_prints_at_each_position() {
+        let style = GlyphStyle::Nintendo;
+        assert_eq!(file(Button::South, style), Some("nx_b"));
+        assert_eq!(file(Button::East, style), Some("nx_a"));
+        assert_eq!(file(Button::West, style), Some("nx_y"));
+        assert_eq!(file(Button::North, style), Some("nx_x"));
+        assert_eq!(file(Button::LeftTrigger, style), Some("nx_zl"));
+        assert_eq!(file(Button::Start, style), Some("nx_plus"));
+    }
+
+    #[test]
+    fn every_family_has_its_own_file_for_every_button() {
+        for (style, prefix) in [
+            (GlyphStyle::Xbox, "xb_"),
+            (GlyphStyle::PlayStation, "psx_"),
+            (GlyphStyle::Nintendo, "nx_"),
+        ] {
+            for button in Button::ALL {
+                let name = file(button, style).unwrap();
+                assert!(name.starts_with(prefix), "{button:?} {name}");
+            }
+        }
+    }
+
+    #[test]
+    fn every_sprite_has_its_texture_at_twice_gui_size() {
+        let images: Vec<_> = images().collect();
+        assert_eq!(images.len(), ART.len() + 1, "the art and the cursor");
+        for (name, w, h, pixels) in &images {
+            assert_eq!(pixels.len(), (w * h * 4) as usize, "{name}");
+            assert_eq!(*h as f32, DRAWN_HEIGHT * 2.0, "{name}");
+        }
+        for art in ART {
+            let (_, w, ..) = images.iter().find(|i| i.0 == art.sprite).unwrap();
+            assert_eq!(art_width(art), *w as f32 / 2.0 - 4.0, "{}", art.sprite);
+        }
+    }
+
+    #[test]
+    fn no_button_has_two_pictures_in_a_family() {
+        for (i, art) in ART.iter().enumerate() {
+            assert!(
+                !ART[..i]
+                    .iter()
+                    .any(|a| a.family == art.family && a.button == art.button),
+                "{}",
+                art.sprite
+            );
+        }
+    }
+
+    #[test]
+    fn art_measures_from_its_shape_and_text_from_its_label() {
+        let atlas = atlas();
+        assert_eq!(width(&atlas, Button::South, GlyphStyle::Xbox), 12.0);
+        assert_eq!(width(&atlas, Button::LeftBumper, GlyphStyle::Xbox), 20.0);
+        assert_eq!(
+            width(&atlas, Button::LeftBumper, GlyphStyle::PlayStation),
+            20.0
+        );
+        assert_eq!(width(&atlas, Button::DPadUp, GlyphStyle::Nintendo), 12.0);
+        let mut no_art = atlas;
+        no_art
+            .sprites
+            .remove(sprite(Button::LeftTrigger, GlyphStyle::Nintendo).unwrap());
+        let label = HudBatch::text_width(&no_art, "ZL").ceil() + 4.0;
+        assert_eq!(
+            width(&no_art, Button::LeftTrigger, GlyphStyle::Nintendo),
+            label
+        );
+    }
+
+    #[test]
+    fn an_atlas_without_the_art_falls_back_to_text() {
+        let mut atlas = atlas();
+        atlas
+            .sprites
+            .remove(sprite(Button::South, GlyphStyle::Xbox).unwrap());
+        assert_eq!(art(&atlas, Button::South, GlyphStyle::Xbox), None);
+        let label = HudBatch::text_width(&atlas, "A").ceil() + 4.0;
+        assert_eq!(width(&atlas, Button::South, GlyphStyle::Xbox), label);
+    }
+
+    #[test]
+    fn art_is_one_quad_centred_on_the_text_line_with_no_key_behind_it() {
+        let atlas = atlas();
+        let mut batch = HudBatch::new([640, 480]);
+        draw(
+            &mut batch,
+            &atlas,
+            Button::South,
+            GlyphStyle::Xbox,
+            10.0,
+            20.0,
+        );
+        assert_eq!(quads(&batch), vec![[7.0, 16.0, 23.0, 32.0]]);
+        let mut batch = HudBatch::new([640, 480]);
+        draw(
+            &mut batch,
+            &atlas,
+            Button::LeftBumper,
+            GlyphStyle::Xbox,
+            10.0,
+            20.0,
+        );
+        assert_eq!(quads(&batch), vec![[7.0, 16.0, 31.0, 32.0]]);
+    }
+
+    #[test]
+    fn text_sits_on_a_key_covering_what_rect_says() {
+        let mut atlas = atlas();
+        let style = GlyphStyle::Nintendo;
+        atlas.sprites.remove(sprite(Button::South, style).unwrap());
+        let mut batch = HudBatch::new([640, 480]);
+        draw(&mut batch, &atlas, Button::South, style, 10.0, 20.0);
+        let [x, y, w, h] = rect(&atlas, Button::South, style, 10.0, 20.0);
+        assert_eq!(quads(&batch)[0], [x, y, x + w, y + h]);
+    }
+}
diff --git a/crates/horizon-client-render/src/settings.rs b/crates/horizon-client-render/src/settings.rs
index cbb3f067a6..5fdb01d323 100644
--- a/crates/horizon-client-render/src/settings.rs
+++ b/crates/horizon-client-render/src/settings.rs
@@ -814,6 +814,7 @@ pub enum Opt {
     PadToggleSneak,
     PadMoveDeadzone,
     PadLookDeadzone,
+    PadTriggerThreshold,
     PadGlyphs,
     PadKeyboard,
     /// `options.modelPart.*`: one skin layer (index into `options_file::MODEL_PARTS`).
diff --git a/crates/horizon-client-render/src/split_profiles.rs b/crates/horizon-client-render/src/split_profiles.rs
index 035a0e1e13..d2446f6704 100644
--- a/crates/horizon-client-render/src/split_profiles.rs
+++ b/crates/horizon-client-render/src/split_profiles.rs
@@ -8,7 +8,7 @@ use crate::{
     gamepad::{Button as PadButton, GlyphStyle},
     graphics_style,
     hud::{HudAtlas, HudBatch, rgba},
-    lang,
+    lang, pad_glyph,
     text::Text,
     ui,
 };
@@ -411,30 +411,23 @@ impl SplitProfiles {
             None => tr("horizon.splitscreen.profiles.move", "Move where you play"),
         };
         let keys = [PadButton::LeftBumper, PadButton::RightBumper];
-        let key_width = |b: PadButton| width(b.label(style)) + 4.0;
+        let key_width = |b: PadButton| pad_glyph::width(atlas, b, style);
         let total = keys.iter().map(|&b| key_width(b) + 4.0).sum::<f32>() + 2.0 + width(&words);
         let (mut x, y) = (((batch.width - total) / 2.0).floor(), 30.0);
         for b in keys {
-            let [r, g, bl] = b.color(style);
             let kw = key_width(b);
-            // A light edge around the dark key: it stands out on the menu's dark background.
-            batch.fill(
-                atlas,
-                x - 2.0,
-                y - 3.0,
-                kw + 2.0,
-                13.0,
-                rgba(170, 170, 170, 255),
-            );
-            batch.fill(atlas, x - 1.0, y - 2.0, kw, 11.0, rgba(40, 40, 40, 255));
-            batch.text(
-                atlas,
-                b.label(style),
-                x + 1.0,
-                y,
-                rgba(r, g, bl, 255),
-                false,
-            );
+            // A light edge around a dark key: it stands out on the menu's dark background.
+            if pad_glyph::art(atlas, b, style).is_none() {
+                batch.fill(
+                    atlas,
+                    x - 2.0,
+                    y - 3.0,
+                    kw + 2.0,
+                    pad_glyph::HEIGHT + 2.0,
+                    rgba(170, 170, 170, 255),
+                );
+            }
+            pad_glyph::draw(batch, atlas, b, style, x, y);
             x += kw + 4.0;
         }
         batch.text(atlas, &words, x + 2.0, y, rgba(240, 240, 240, 255), true);
diff --git a/crates/horizon-client-render/src/widgets.rs b/crates/horizon-client-render/src/widgets.rs
index 8b94f9dbc4..9b47c70699 100644
--- a/crates/horizon-client-render/src/widgets.rs
+++ b/crates/horizon-client-render/src/widgets.rs
@@ -201,9 +201,14 @@ pub fn set_action_glyphs(on: bool) {
     ACTION_GLYPHS.set(on);
 }
 
-/// How much of a declared button's left the glyph takes from its label.
+/// How much of a declared button's left the glyph takes from its label: a face button's, the only
+/// kind declared buttons show, and no family's is wider than its art.
 pub fn action_glyph_room() -> f32 {
-    if ACTION_GLYPHS.get() { 14.0 } else { 0.0 }
+    if ACTION_GLYPHS.get() {
+        crate::pad_glyph::FACE_WIDTH + 3.0
+    } else {
+        0.0
+    }
 }
 
 /// An interactive rectangle (GUI pixels) a controller can focus and click.
@@ -244,6 +249,41 @@ pub fn clip_targets(mark: usize, y0: f32, y1: f32) {
     });
 }
 
+/// How many labelled widgets and targets the frame has so far, for [`clip_frame`].
+pub fn frame_mark() -> (usize, usize) {
+    let labelled = WIDGETS.with_borrow(|(current, _, _)| current.len());
+    (labelled, targets_mark())
+}
+
+/// Drop the labelled widgets and targets since `mark` whose middle isn't in `y0..y1` (GUI pixels):
+/// what a scrolling body clipped away, where a press wouldn't land.
+pub fn clip_frame((labelled, targets): (usize, usize), y0: f32, y1: f32) {
+    let shown = |y: f32, h: f32| (y0..y1).contains(&(y + h / 2.0));
+    WIDGETS.with_borrow_mut(|(current, _, _)| {
+        let mut at = 0;
+        current.retain(|w| {
+            at += 1;
+            at <= labelled || shown(w.y, w.h)
+        });
+    });
+    TARGETS.with_borrow_mut(|(current, _, _)| {
+        let mut at = 0;
+        current.retain(|t| {
+            at += 1;
+            at <= targets || shown(t.rect[1], t.rect[3])
+        });
+    });
+}
+
+/// A prompt comes up over what the frame drew so far: what it covers can't be reached, by the
+/// pointer or a controller, so its widgets, targets, declared buttons and lists go.
+pub fn cover_frame() {
+    WIDGETS.with_borrow_mut(|(current, _, _)| current.clear());
+    TARGETS.with_borrow_mut(|(current, _, _)| current.clear());
+    ACTIONS.with_borrow_mut(|(current, _)| current.clear());
+    SCROLL_AREAS.with_borrow_mut(|(current, _)| current.clear());
+}
+
 /// This frame drew a list with something to scroll, in `rect`, scrolled `amount`
 /// of `max`: a focus step goes through its hidden rows before it leaves
 /// (`gamepad::list_step`).
@@ -1349,4 +1389,42 @@ mod tests {
             "the clipped row is gone, earlier ones stay"
         );
     }
+
+    #[test]
+    fn a_scrolled_body_loses_what_it_clips_and_nothing_before_it() {
+        let _ = take();
+        target([0.0, 0.0, 5.0, 5.0]);
+        record("warning", [0.0, 0.0, 5.0, 5.0], true);
+        let mark = frame_mark();
+        record("shown", [0.0, 10.0, 5.0, 10.0], true);
+        target([0.0, 10.0, 5.0, 10.0]);
+        // Half in view is still pressed at its middle, which a mouse could reach.
+        record("half", [0.0, 25.0, 5.0, 10.0], true);
+        target([0.0, 25.0, 5.0, 10.0]);
+        record("gone", [0.0, 40.0, 5.0, 10.0], true);
+        target([0.0, 40.0, 5.0, 10.0]);
+        clip_frame(mark, 8.0, 32.0);
+        end_frame(101);
+        let names: Vec<String> = last_labelled().into_iter().map(|w| w.label).collect();
+        assert_eq!(names, ["warning", "shown", "half"]);
+        assert_eq!(last_targets().len(), 3);
+    }
+
+    #[test]
+    fn a_prompt_covers_what_was_drawn_before_it() {
+        let _ = take();
+        record("under", [0.0, 0.0, 5.0, 5.0], true);
+        target([0.0, 10.0, 5.0, 5.0]);
+        declare_action(Action::Done, [0.0, 0.0, 5.0, 5.0], true);
+        scroll_area([0.0, 0.0, 5.0, 5.0], 0.0, 5.0);
+        cover_frame();
+        record("over", [0.0, 20.0, 5.0, 5.0], true);
+        set_action_screen(7);
+        end_frame(102);
+        let names: Vec<String> = last_labelled().into_iter().map(|w| w.label).collect();
+        assert_eq!(names, ["over"]);
+        assert!(last_targets().is_empty());
+        assert!(last_actions(7).is_empty());
+        assert!(last_scroll_areas().is_empty());
+    }
 }
diff --git a/crates/horizon-client/assets/horizon/lang/en_us.json b/crates/horizon-client/assets/horizon/lang/en_us.json
index 401d8a0aff..c3231dbf90 100644
--- a/crates/horizon-client/assets/horizon/lang/en_us.json
+++ b/crates/horizon-client/assets/horizon/lang/en_us.json
@@ -13,6 +13,7 @@
   "horizon.options.sneak_button": "Sneak Button",
   "horizon.options.move_deadzone": "Move Deadzone",
   "horizon.options.look_deadzone": "Look Deadzone",
+  "horizon.options.trigger_threshold": "Trigger Threshold",
   "horizon.options.button_glyphs": "Button Glyphs",
   "horizon.options.on_screen_keyboard": "On-Screen Keyboard",
   "horizon.options.chat_delay": "Chat Delay",
@@ -80,7 +81,7 @@
   "horizon.pages.open.mods": "Mods...",
   "horizon.pages.open.agent": "AI Agent...",
   "horizon.pages.open.horizon_graphics": "Horizon Graphics...",
-  "horizon.pages.open.controller_binds": "Controller Binds...",
+  "horizon.pages.open.controller_binds": "Bindings...",
   "horizon.pages.open.horizon_settings": "Horizon Settings...",
   "horizon.pages.open.studio": "Replay Studio...",
   "horizon.studio.saved_recordings": "Saved Recordings",
@@ -791,6 +792,7 @@
   "horizon.pvp.preset": "PvP preset",
   "horizon.pvp.preset.tooltip": "Turns on the custom crosshair, the armour and effects widgets, toggle sprint and sneak, lower fire, and the FPS counter and keystrokes mods if installed. Your settings for each stay.",
   "Bindings": "Bindings",
+  "Play": "Play",
   "Device": "Device",
   "Look": "Look",
   "Movement": "Movement",
@@ -812,6 +814,7 @@
   "How far the right stick moves before the view turns. Raise it if the view drifts.": "How far the right stick moves before the view turns. Raise it if the view drifts.",
   "Hold the button to sneak, or press it once to start and again to stop.": "Hold the button to sneak, or press it once to start and again to stop.",
   "How far the left stick moves before you walk. Raise it if you drift.": "How far the left stick moves before you walk. Raise it if you drift.",
+  "How far a trigger is pulled before it counts as pressed.": "How far a trigger is pulled before it counts as pressed.",
   "How fast the stick moves the crosshair in inventories.": "How fast the stick moves the crosshair in inventories.",
   "How fast the right stick scrolls a list.": "How fast the right stick scrolls a list.",
   "How long a held direction waits before it repeats.": "How long a held direction waits before it repeats.",
diff --git a/crates/horizon-client-render/src/pad_cursor.png b/crates/horizon-client/assets/horizon/textures/gui/controller/crosshair_inv.png
similarity index 100%
rename from crates/horizon-client-render/src/pad_cursor.png
rename to crates/horizon-client/assets/horizon/textures/gui/controller/crosshair_inv.png
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_a.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_a.png
new file mode 100644
index 0000000000..ab4ca1f0d5
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_a.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_b.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_b.png
new file mode 100644
index 0000000000..ffbe94f4ad
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_b.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_down.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_down.png
new file mode 100644
index 0000000000..e97ad31441
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_down.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_l.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_l.png
new file mode 100644
index 0000000000..544d5babf2
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_l.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_l3.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_l3.png
new file mode 100644
index 0000000000..47f50092e7
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_l3.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_left.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_left.png
new file mode 100644
index 0000000000..d98c875a10
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_left.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_minus.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_minus.png
new file mode 100644
index 0000000000..d01814f80f
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_minus.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_plus.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_plus.png
new file mode 100644
index 0000000000..5d17c66198
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_plus.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_r.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_r.png
new file mode 100644
index 0000000000..48976a5ae3
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_r.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_r3.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_r3.png
new file mode 100644
index 0000000000..535523ec2e
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_r3.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_right.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_right.png
new file mode 100644
index 0000000000..1bfe40e3a6
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_right.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_up.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_up.png
new file mode 100644
index 0000000000..9255a9af5f
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_up.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_x.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_x.png
new file mode 100644
index 0000000000..8f6426ef74
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_x.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_y.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_y.png
new file mode 100644
index 0000000000..0b164ac75d
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_y.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_zl.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_zl.png
new file mode 100644
index 0000000000..dd2740c223
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_zl.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/nx_zr.png b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_zr.png
new file mode 100644
index 0000000000..24f8a1cc1b
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/nx_zr.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_circle.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_circle.png
new file mode 100644
index 0000000000..536d49e05f
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_circle.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_create.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_create.png
new file mode 100644
index 0000000000..d01814f80f
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_create.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_cross.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_cross.png
new file mode 100644
index 0000000000..4c04d0d833
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_cross.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_down.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_down.png
new file mode 100644
index 0000000000..e97ad31441
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_down.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l1.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l1.png
new file mode 100644
index 0000000000..297ea570be
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l1.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l2.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l2.png
new file mode 100644
index 0000000000..a6d6c0d502
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l2.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l3.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l3.png
new file mode 100644
index 0000000000..47f50092e7
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_l3.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_left.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_left.png
new file mode 100644
index 0000000000..d98c875a10
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_left.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_options.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_options.png
new file mode 100644
index 0000000000..5d17c66198
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_options.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r1.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r1.png
new file mode 100644
index 0000000000..2e4091d615
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r1.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r2.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r2.png
new file mode 100644
index 0000000000..1d2c1a8595
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r2.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r3.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r3.png
new file mode 100644
index 0000000000..535523ec2e
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_r3.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_right.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_right.png
new file mode 100644
index 0000000000..1bfe40e3a6
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_right.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_square.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_square.png
new file mode 100644
index 0000000000..5705196946
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_square.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_triangle.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_triangle.png
new file mode 100644
index 0000000000..c74066088a
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_triangle.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/psx_up.png b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_up.png
new file mode 100644
index 0000000000..9255a9af5f
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/psx_up.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_a.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_a.png
new file mode 100644
index 0000000000..ab4ca1f0d5
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_a.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_b.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_b.png
new file mode 100644
index 0000000000..ffbe94f4ad
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_b.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_down.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_down.png
new file mode 100644
index 0000000000..e97ad31441
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_down.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_l3.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_l3.png
new file mode 100644
index 0000000000..47f50092e7
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_l3.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_lb.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_lb.png
new file mode 100644
index 0000000000..544d5babf2
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_lb.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_left.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_left.png
new file mode 100644
index 0000000000..d98c875a10
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_left.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_lt.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_lt.png
new file mode 100644
index 0000000000..dd2740c223
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_lt.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_menu.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_menu.png
new file mode 100644
index 0000000000..5d17c66198
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_menu.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_r3.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_r3.png
new file mode 100644
index 0000000000..535523ec2e
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_r3.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_rb.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_rb.png
new file mode 100644
index 0000000000..48976a5ae3
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_rb.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_right.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_right.png
new file mode 100644
index 0000000000..1bfe40e3a6
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_right.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_rt.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_rt.png
new file mode 100644
index 0000000000..24f8a1cc1b
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_rt.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_up.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_up.png
new file mode 100644
index 0000000000..9255a9af5f
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_up.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_view.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_view.png
new file mode 100644
index 0000000000..d01814f80f
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_view.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_x.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_x.png
new file mode 100644
index 0000000000..8f6426ef74
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_x.png differ
diff --git a/crates/horizon-client/assets/horizon/textures/gui/controller/xb_y.png b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_y.png
new file mode 100644
index 0000000000..0b164ac75d
Binary files /dev/null and b/crates/horizon-client/assets/horizon/textures/gui/controller/xb_y.png differ
diff --git a/crates/horizon-client/src/client_lib.rs b/crates/horizon-client/src/client_lib.rs
index 4e06fc618f..caa83ea334 100644
--- a/crates/horizon-client/src/client_lib.rs
+++ b/crates/horizon-client/src/client_lib.rs
@@ -17,7 +17,7 @@ pub use horizon_client_render::{
     hdr_calibration, hud, hud_layout, hud_overlays, inventory_effects, java_text, jigsaw_block,
     json_folder, level_loading, light, lod, logging, menu_blur, mesher, minimap, mipmap, mod_list,
     model_library, models, multiline_edit, native_emissive, options_file, options_fixes,
-    options_ui, overlay, pack_browser, pack_screen, packs, pad_cursor, par, particles,
+    options_ui, overlay, pack_browser, pack_screen, packs, pad_cursor, pad_glyph, par, particles,
     poi_sections, post_chain, potent_sulfur, preedit, providers, pvp, pvp_hud, screen_draw,
     screen_effects, sculk, section_mask, server_terrain, settings, shader_options,
     shader_pack_list, signs, skins, sound_engine, sound_events, sound_preview, spans, split_layout,
@@ -157,6 +157,7 @@ pub use horizon_client_core::nbt_path;
 pub use horizon_client_core::scoreboard;
 pub use horizon_client_core::snbt;
 pub use horizon_client_core::text;
+pub use horizon_client_input::actions;
 pub use horizon_client_input::clipboard;
 pub use horizon_client_input::gamepad;
 pub use horizon_client_input::held;
diff --git a/crates/horizon-client/src/confirm_screen.rs b/crates/horizon-client/src/confirm_screen.rs
index b232bd4ec8..2640db07af 100644
--- a/crates/horizon-client/src/confirm_screen.rs
+++ b/crates/horizon-client/src/confirm_screen.rs
@@ -14,6 +14,8 @@ pub struct Confirm {
     /// The yes and no buttons' corners.
     pub buttons: [(f32, f32); 2],
     pub focus: Option<usize>,
+    /// `declare_no` was called.
+    declares_no: bool,
 }
 impl Confirm {
     pub fn new(font: &Font, size: (f32, f32), title: &Text, message: &Text) -> Self {
@@ -22,6 +24,7 @@ impl Confirm {
             lines,
             buttons: [buttons[0], buttons[1]],
             focus: None,
+            declares_no: false,
         }
     }
     /// Tab cycles focus between yes (0) and no (1).
@@ -67,10 +70,9 @@ impl Confirm {
     ) {
         self.draw_active(batch, atlas, cursor, labels, true);
     }
-    /// The second button answers no, as Escape does (`widgets::Action`).
-    pub fn declare_no(&self) {
-        let (x, y) = self.buttons[1];
-        crate::widgets::declare_action(crate::widgets::Action::Cancel, [x, y, 150.0, 20.0], true);
+    /// The second button answers no, as Escape does (`widgets::Action`), once drawn.
+    pub fn declare_no(&mut self) {
+        self.declares_no = true;
     }
     /// `draw` with the buttons greyed out while `setDelay` runs (`active` false).
     pub fn draw_active(
@@ -87,7 +89,14 @@ impl Confirm {
         for (i, ((bx, by), label)) in self.buttons.into_iter().zip(labels).enumerate() {
             let is_focused = self.focus == Some(i);
             let hover = active && (ui::hovered(cursor, bx, by, 150.0, 20.0) || is_focused);
-            ui::button(batch, atlas, bx, by, 150.0, 20.0, label, active, hover);
+            if self.declares_no && i == 1 {
+                let action = crate::widgets::Action::Cancel;
+                ui::action_button(
+                    batch, atlas, action, bx, by, 150.0, 20.0, label, active, hover,
+                );
+            } else {
+                ui::button(batch, atlas, bx, by, 150.0, 20.0, label, active, hover);
+            }
         }
     }
 }
@@ -101,6 +110,8 @@ pub struct Choice {
     pub buttons: Vec<(f32, f32)>,
     pub width: f32,
     pub focus: Option<usize>,
+    /// The button `declare_no` named.
+    no_button: Option<usize>,
 }
 impl Choice {
     pub fn new(
@@ -142,6 +153,7 @@ impl Choice {
                 .collect(),
             width,
             focus: None,
+            no_button: None,
         }
     }
     /// Tab cycles focus across the buttons.
@@ -188,15 +200,9 @@ impl Choice {
             .iter()
             .position(|&(x, y)| ui::hovered(cursor, x, y, self.width, 20.0))
     }
-    /// Button `i` answers no, as Escape does (`widgets::Action`).
-    pub fn declare_no(&self, i: usize) {
-        if let Some(&(x, y)) = self.buttons.get(i) {
-            crate::widgets::declare_action(
-                crate::widgets::Action::Cancel,
-                [x, y, self.width, 20.0],
-                true,
-            );
-        }
+    /// Button `i` answers no, as Escape does (`widgets::Action`), once drawn.
+    pub fn declare_no(&mut self, i: usize) {
+        self.no_button = Some(i);
     }
     /// The lines and the buttons, over whatever is behind.
     pub fn draw(
@@ -212,7 +218,14 @@ impl Choice {
         for (i, (&(bx, by), label)) in self.buttons.iter().zip(labels).enumerate() {
             let is_focused = self.focus == Some(i);
             let hover = ui::hovered(cursor, bx, by, self.width, 20.0) || is_focused;
-            ui::button(batch, atlas, bx, by, self.width, 20.0, label, true, hover);
+            if self.no_button == Some(i) {
+                let action = crate::widgets::Action::Cancel;
+                ui::action_button(
+                    batch, atlas, action, bx, by, self.width, 20.0, label, true, hover,
+                );
+            } else {
+                ui::button(batch, atlas, bx, by, self.width, 20.0, label, true, hover);
+            }
         }
     }
 }
@@ -258,6 +271,55 @@ mod tests {
         assert_eq!(two.buttons[1].0, 242.0);
     }
 
+    #[test]
+    fn only_the_button_declared_no_gets_its_job() {
+        use crate::widgets::{self, Action, DeclaredAction};
+        let atlas = HudAtlas::build(Path::new("/nonexistent/horizon-test-assets")).unwrap();
+        let (title, message) = (Text::literal("Title"), Text::literal("Message"));
+        let labels = [
+            Text::literal("Yes"),
+            Text::literal("Copy"),
+            Text::literal("No"),
+        ];
+        let drawn = |frame: u64, draw: &dyn Fn(&mut HudBatch)| {
+            widgets::set_action_screen(7);
+            draw(&mut HudBatch::new([480, 270]));
+            widgets::end_frame(frame);
+            widgets::last_actions(7)
+        };
+        let no = |rect| {
+            vec![DeclaredAction {
+                action: Action::Cancel,
+                rect,
+                enabled: true,
+            }]
+        };
+
+        let mut confirm = Confirm::new(&font(), (480.0, 270.0), &title, &message);
+        let draw_confirm = |confirm: &Confirm, batch: &mut HudBatch| {
+            confirm.draw(batch, &atlas, (0.0, 0.0), [&labels[0], &labels[2]]);
+        };
+        assert!(drawn(1, &|b| draw_confirm(&confirm, b)).is_empty());
+        confirm.declare_no();
+        let (x, y) = confirm.buttons[1];
+        assert_eq!(
+            drawn(2, &|b| draw_confirm(&confirm, b)),
+            no([x, y, 150.0, 20.0])
+        );
+
+        let mut choice = Choice::new(&font(), (480.0, 270.0), &title, &message, 3, 100.0);
+        let draw_choice = |choice: &Choice, batch: &mut HudBatch| {
+            choice.draw(batch, &atlas, (0.0, 0.0), &labels);
+        };
+        assert!(drawn(3, &|b| draw_choice(&choice, b)).is_empty());
+        choice.declare_no(2);
+        let (x, y) = choice.buttons[2];
+        assert_eq!(
+            drawn(4, &|b| draw_choice(&choice, b)),
+            no([x, y, 100.0, 20.0])
+        );
+    }
+
     #[test]
     fn confirm_and_choice_keyboard_navigation() {
         let (title, message) = (Text::literal("Title"), Text::literal("Message"));
diff --git a/crates/horizon-client/src/controller_notice.rs b/crates/horizon-client/src/controller_notice.rs
index 80c94a2e82..32ca3fc75a 100644
--- a/crates/horizon-client/src/controller_notice.rs
+++ b/crates/horizon-client/src/controller_notice.rs
@@ -4,6 +4,7 @@
 //! reconnects, a solo game's controller coming and going) decides that for itself.
 use crate::gamepad::{Button, GlyphStyle};
 use crate::hud::{HudAtlas, HudBatch, rgba};
+use crate::pad_glyph;
 use crate::toasts::Slide;
 use std::time::{Duration, Instant};
 
@@ -129,12 +130,9 @@ impl NoticeSlot {
         let w = batch.width;
         let width = |text: &str| HudBatch::text_width(atlas, text).ceil();
         let max = (w - 24.0).min(260.0);
-        let glyph = notice.glyph.map(|g| {
-            (
-                g.button.label(g.style),
-                width(g.button.label(g.style)) + 4.0,
-            )
-        });
+        let glyph = notice
+            .glyph
+            .map(|g| (g, pad_glyph::width(atlas, g.button, g.style) + 4.0));
         let indent = glyph.map_or(0.0, |g| g.1);
         let lines = crate::split_profiles::wrap(&notice.body, max - indent, width);
         let inner = lines
@@ -151,8 +149,8 @@ impl NoticeSlot {
         for (k, line) in lines.iter().enumerate() {
             let lx = (px + (pw - width(line) - indent) / 2.0).floor();
             let y = py + 18.0 + 10.0 * k as f32;
-            if let (0, Some((label, _))) = (k, glyph) {
-                batch.text(atlas, label, lx, y, rgba(255, 255, 255, 255), false);
+            if let (0, Some((g, _))) = (k, glyph) {
+                pad_glyph::draw(batch, atlas, g.button, g.style, lx, y);
             }
             batch.text(atlas, line, lx + indent, y, rgba(200, 200, 200, 255), false);
         }
@@ -173,20 +171,6 @@ pub fn panel(batch: &mut HudBatch, atlas: &HudAtlas, [px, py, pw, ph]: [f32; 4])
     }
 }
 
-/// A button as printed on the pad, in its colour, on a dark key `gw` wide.
-pub fn key(
-    batch: &mut HudBatch,
-    atlas: &HudAtlas,
-    label: &str,
-    color: u32,
-    x: f32,
-    y: f32,
-    gw: f32,
-) {
-    batch.fill(atlas, x - 1.0, y - 2.0, gw, 11.0, rgba(40, 40, 40, 255));
-    batch.text(atlas, label, x + 1.0, y, color, false);
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 42ba6636b9..f4248c065e 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -375,6 +375,8 @@ mod world_primitives;
 mod zombie_reinforcements;
 mod zombie_villagers;
 use event_loop::EventLoopCtl;
+// `Action` here is the title screen's buttons (`title::Action`).
+use horizon_client::actions::Action as Mapping;
 use horizon_client::held::Source;
 use horizon_client::spans::startup;
 use horizon_client::{
@@ -6633,7 +6635,7 @@ impl Game<'_> {
         self.use_failed = false;
         // isSecondaryUseActive with something in either hand keeps blocks
         // from reacting.
-        let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Mapping::Sneak);
         let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some();
         let mut anchor_passed = false;
         // Native mods, where ServerPlayerGameMode.useItemOn starts: a
@@ -7065,7 +7067,7 @@ impl Game<'_> {
             inside: false,
             yaw: self.yaw,
             pitch: self.pitch,
-            sneaking: self.keys.contains(&KeyCode::ShiftLeft),
+            sneaking: self.keys.held(Mapping::Sneak),
             item: stack.item.to_string(),
             can_use_game_master_blocks: self.can_use_game_master_blocks(),
         };
@@ -8180,7 +8182,10 @@ impl Game<'_> {
                         ),
                         action,
                     ) {
-                        self.play_mouse(button, pressed)?;
+                        if self.shared_default_acts(button, horizon_client::keybinds::key_name(key))
+                        {
+                            self.mouse_mapping(button, pressed, Source::Keyboard)?;
+                        }
                     } else if container_key_clones(button, action) {
                         self.inventory_pick_key();
                     }
@@ -8225,7 +8230,7 @@ impl Game<'_> {
             if !pressed {
                 return Ok(());
             }
-            if self.keys.contains(&key) {
+            if self.keys.raw(&key) {
                 self.keys.press(key, source);
             }
         } else if !pressed {
@@ -8329,9 +8334,12 @@ impl Game<'_> {
     /// lectern, a sign, a server dialog, the code of conduct, a link or
     /// server pack prompt (vanilla's `Minecraft.screen` is set for each).
     fn screen_over_playing(&self) -> bool {
-        self.book.is_some()
-            || self.sign_edit.is_some()
-            || self.dialog_open()
+        self.book.is_some() || self.sign_edit.is_some() || self.prompt_open()
+    }
+    /// A prompt is up: over the world or over another open screen, it takes the input and is
+    /// answered first, in the order of `handle_window_event`'s arms and of what draws on top.
+    fn prompt_open(&self) -> bool {
+        self.dialog_open()
             || self.code_of_conduct.is_some()
             || self.link_prompt.is_some()
             || self.command_prompt.is_some()
@@ -13370,7 +13378,7 @@ impl Game<'_> {
         let Some(held) = held else {
             return Outcome::Pass;
         };
-        if self.keys.contains(&KeyCode::ShiftLeft) {
+        if self.keys.held(Mapping::Sneak) {
             return Outcome::Pass;
         }
         let Some((state, under_water)) = self.cauldron_at(pos) else {
@@ -13420,7 +13428,7 @@ impl Game<'_> {
             return Ok(false);
         };
         // Player.isSecondaryUseActive with an item in hand skips useItemOn.
-        if self.keys.contains(&KeyCode::ShiftLeft) {
+        if self.keys.held(Mapping::Sneak) {
             return Ok(false);
         }
         let removes_dye = cauldron::removes_dye(self.items(), &held.item);
@@ -13489,7 +13497,7 @@ impl Game<'_> {
             .offhand
             .as_ref()
             .is_some_and(|s| self.blocks_attacks(s).is_some());
-        if shield && !self.keys.contains(&KeyCode::ShiftLeft) {
+        if shield && !self.keys.held(Mapping::Sneak) {
             return None;
         }
         let face_name = match face {
@@ -13807,7 +13815,7 @@ impl Game<'_> {
             // `Player.isShiftKeyDown`: a block that refuses the fluid (any
             // non-air block under Shift) passes it to the block beside, where
             // Shift no longer counts.
-            let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
+            let sneaking = self.keys.held(Mapping::Sneak);
             let creative = self.creative;
             let emptied = self.with_level(|b, level, ticks| {
                 b.bucket_empty(
@@ -15222,7 +15230,7 @@ impl Game<'_> {
             let bed_gone = !self.res.facts().get(bed).name.ends_with("_bed");
             // Vanilla has no Shift wake-up: the chat screen's capitals must
             // not get the sleeper up.
-            if (self.screen != Screen::Chat && self.keys.contains(&KeyCode::ShiftLeft))
+            if (self.screen != Screen::Chat && self.keys.held(Mapping::Sneak))
                 || bed_gone
                 || self
                     .player
@@ -17030,7 +17038,8 @@ impl Game<'_> {
             KeyCode::KeyQ if self.screen == Screen::Playing => {
                 // handleKeybinds: the number keys select before key.drop.
                 self.select_queued_hotbar();
-                let all = drop_whole_stack(self.modifiers);
+                let all =
+                    drop_whole_stack(self.modifiers) || std::mem::take(&mut self.pad.drop_stack);
                 self.drop_held(all);
             }
             KeyCode::Digit1
@@ -17080,6 +17089,104 @@ impl Game<'_> {
         }
         Ok(())
     }
+    /// `MouseHandler.onScroll`: the hotbar (or the spectator menu) takes the wheel only when no
+    /// screen is open; a book, lectern, sign or prompt drawn over gameplay is one.
+    fn hotbar_takes_wheel(&self) -> bool {
+        self.screen == Screen::Playing
+            && !self.screen_over_playing()
+            && self.sleeping.is_none()
+            && self.player.is_some()
+    }
+    /// A mod's `MouseScrolling` cancels the step about to turn the hotbar.
+    fn hotbar_scroll_canceled(&mut self, scroll: [f64; 2], steps: [i32; 2]) -> bool {
+        let mut canceled = false;
+        self.native_mouse_scrolling(
+            scroll,
+            steps,
+            [
+                self.physical_buttons.contains(&MouseButton::Left),
+                self.physical_buttons.contains(&MouseButton::Middle),
+                self.physical_buttons.contains(&MouseButton::Right),
+            ],
+            [self.cursor.0, self.cursor.1],
+            glfw_modifiers(self.modifiers),
+            &mut canceled,
+        );
+        canceled
+    }
+    /// What one whole wheel step does in play (`MouseHandler.onScroll`): a spectator's menu or
+    /// flying speed, else the selected hotbar slot.
+    fn hotbar_wheel_step(&mut self, wheel: i32, vertical_steps: i32) {
+        if self.spectator() && self.spectator_gui.is_menu_active() {
+            self.spectator_scroll(-wheel);
+        } else if self.spectator() {
+            if let Some(player) = &mut self.player {
+                player.flying_speed = horizon_client::mouse::spectator_flying_speed(
+                    player.flying_speed,
+                    vertical_steps,
+                );
+            }
+        } else {
+            self.selected = horizon_client::mouse::ScrollWheelHandler::next_selection(
+                f64::from(wheel),
+                self.selected as i32,
+                9,
+            ) as usize;
+        }
+    }
+    /// A step of the hotbar from a controller's bumper: one wheel notch, down for the next slot,
+    /// through everything the wheel goes through.
+    fn hotbar_step(&mut self, next: bool) {
+        let wheel = if next { -1 } else { 1 };
+        if self.hotbar_takes_wheel()
+            && !self.native_wheel_event(wheel as f32)
+            && !self.hotbar_scroll_canceled([0.0, f64::from(wheel)], [0, wheel])
+        {
+            self.hotbar_wheel_step(wheel, wheel);
+        }
+    }
+    /// A mouse mapping pressed or let go by `source`. A release waits while another device holds
+    /// the mapping, so letting go of one can't end what the other still presses, as for keys
+    /// (`HeldKeys`).
+    fn mouse_mapping(&mut self, button: MouseButton, pressed: bool, source: Source) -> Result<()> {
+        if !pressed && self.mouse_mapping_held_elsewhere(button, source) {
+            return Ok(());
+        }
+        self.play_mouse(button, pressed)
+    }
+    /// Whether a device other than `source` holds what `button` stands for. Asks each device's own
+    /// live state rather than keeping a count: a screen takes a mouse release without telling the
+    /// mappings, and a count would then hold the attack for good. A script keeps no such state, so
+    /// nothing waits for a script's mouse hold.
+    fn mouse_mapping_held_elsewhere(&self, button: MouseButton, source: Source) -> bool {
+        let mapping = match button {
+            MouseButton::Left => "key.attack",
+            MouseButton::Right => "key.use",
+            _ => return false,
+        };
+        match source {
+            Source::Keyboard | Source::Agent => {
+                self.pad.holds_action(&self.settings.controller, mapping)
+            }
+            Source::Pad => {
+                let keys = &self.settings.keys;
+                self.physical_buttons
+                    .iter()
+                    .any(|held| keys.translate_mouse_all(*held).contains(&Err(button)))
+                    || self
+                        .physical_keys
+                        .iter()
+                        .any(|held| keys.translate_all(*held).contains(&Err(button)))
+            }
+        }
+    }
+    /// Two mappings with one default button are separate mappings all the same
+    /// (`Minecraft.handleKeybinds`): whether the middle-button action a physical `input` translated
+    /// to is one of those it is bound to, for this player now.
+    fn shared_default_acts(&self, button: MouseButton, input: Option<&str>) -> bool {
+        button != MouseButton::Middle
+            || input.is_none_or(|input| self.settings.keys.middle_acts(input, self.spectator()))
+    }
     /// A mouse button while playing (window or control socket).
     fn play_mouse(&mut self, button: MouseButton, pressed: bool) -> Result<()> {
         if pressed {
@@ -17765,6 +17872,13 @@ impl Game<'_> {
             self.native_mouse_button_post(button, pressed, modifiers);
         }
     }
+    /// One window event, in the order vanilla's `KeyboardHandler` and `MouseHandler` see it.
+    ///
+    /// A controller doesn't come through here in play: `pad_action` goes straight to the mappings
+    /// (`mapped_key`, `mouse_mapping`). So a key handled below before `mapped_key_event` (a window
+    /// shortcut, a special case) never reaches a controller. If a player could want it on one, give
+    /// it a handler both can call and a `gamepad::Route` (screenshot and fullscreen do this). A
+    /// screen's own raw keys, text and mods' key hooks stay raw on purpose.
     fn handle_window_event_inner(&mut self, event_loop: &dyn EventLoopCtl, mut event: WindowEvent) {
         if let WindowEvent::Focused(false) = &event {
             self.physical_keys.clear();
@@ -18258,13 +18372,21 @@ impl Game<'_> {
                             return Ok(());
                         }
                     }
+                    // A prompt is vanilla's `Minecraft.screen`, the only one MouseHandler.onScroll
+                    // tells: the top one hears the wheel, as the click arms below pick it, and
+                    // nothing behind it does.
+                    if self.prompt_open() {
+                        if self.command_prompt.is_some() || self.link_prompt.is_some() {
+                        } else if self.code_of_conduct.is_some() {
+                            self.code_of_conduct_scroll(d);
+                        } else if self.server_packs.prompt.is_none() {
+                            self.dialog_scroll(d);
+                        }
+                        return Ok(());
+                    }
                     let stick_scroll = self.pad_stick_scroll();
                     let step_scroll = self.pad_step_scroll();
-                    if self.dialog_open() {
-                        self.dialog_scroll(d);
-                    } else if self.code_of_conduct.is_some() {
-                        self.code_of_conduct_scroll(d);
-                    } else if let Some(title) = &mut self.title
+                    if let Some(title) = &mut self.title
                         && self.screen != Screen::Win
                     {
                         let size = self
@@ -18285,50 +18407,21 @@ impl Game<'_> {
                     // MouseHandler.onScroll: the hotbar (or the spectator
                     // menu) takes the wheel only when no screen is open; a
                     // book, lectern, sign or prompt drawn over gameplay is one.
-                    if self.screen == Screen::Playing
-                        && !self.screen_over_playing()
-                        && self.sleeping.is_none()
-                        && self.player.is_some()
+                    if self.hotbar_takes_wheel()
                         && !self.native_wheel_event(d)
                         && let Some((wheel, (horizontal_steps, vertical_steps))) = self
                             .mouse
                             .on_scroll(raw_x, raw_y, discrete, wheel_sensitivity)
                     {
-                        if !self.pad_synthetic_input() {
-                            let mut canceled = false;
-                            self.native_mouse_scrolling(
+                        if !self.pad_synthetic_input()
+                            && self.hotbar_scroll_canceled(
                                 [scaled(raw_x), scaled(raw_y)],
                                 [horizontal_steps, vertical_steps],
-                                [
-                                    self.physical_buttons.contains(&MouseButton::Left),
-                                    self.physical_buttons.contains(&MouseButton::Middle),
-                                    self.physical_buttons.contains(&MouseButton::Right),
-                                ],
-                                [self.cursor.0, self.cursor.1],
-                                glfw_modifiers(self.modifiers),
-                                &mut canceled,
-                            );
-                            if canceled {
-                                return Ok(());
-                            }
-                        }
-                        if self.spectator() && self.spectator_gui.is_menu_active() {
-                            self.spectator_scroll(-wheel);
-                        } else if self.spectator() {
-                            if let Some(player) = &mut self.player {
-                                player.flying_speed = horizon_client::mouse::spectator_flying_speed(
-                                    player.flying_speed,
-                                    vertical_steps,
-                                );
-                            }
-                        } else {
-                            self.selected =
-                                horizon_client::mouse::ScrollWheelHandler::next_selection(
-                                    f64::from(wheel),
-                                    self.selected as i32,
-                                    9,
-                                ) as usize;
+                            )
+                        {
+                            return Ok(());
                         }
+                        self.hotbar_wheel_step(wheel, vertical_steps);
                     }
                     if self.screen == Screen::Chat && d != 0.0 {
                         self.chat_scroll(d);
@@ -18527,9 +18620,12 @@ impl Game<'_> {
                             {
                                 self.smooth_camera_action();
                             }
+                            let input = horizon_client::keybinds::mouse_name(button);
                             for mapped in self.settings.keys.translate_mouse_all(button) {
                                 match mapped {
-                                    Err(b) => self.play_mouse(b, pressed)?,
+                                    Err(b)
+                                        if !self.shared_default_acts(b, Some(input.as_str())) => {}
+                                    Err(b) => self.mouse_mapping(b, pressed, Source::Keyboard)?,
                                     Ok(k) if pressed => {
                                         self.keys.insert(k);
                                         self.key_pressed(k, k)?;
@@ -18959,7 +19055,7 @@ impl Game<'_> {
                         && self.book.is_none()
                         && !self.dialog_open()
                     {
-                        let turn = |k| f32::from(u8::from(self.keys.contains(&k)));
+                        let turn = |k| f32::from(u8::from(self.keys.raw(&k)));
                         let secs = elapsed.as_secs_f32().min(0.1);
                         let yaw = (turn(KeyCode::ArrowRight) - turn(KeyCode::ArrowLeft)) * 90.0;
                         let pitch = (turn(KeyCode::ArrowDown) - turn(KeyCode::ArrowUp)) * 90.0;
@@ -23107,7 +23203,7 @@ mod tests {
         let mut left = true;
         let mut right = true;
         drop_held_behind_dialog(false, &mut keys, &mut left, &mut right);
-        assert!(keys.contains(&KeyCode::KeyW) && left && right);
+        assert!(keys.raw(&KeyCode::KeyW) && left && right);
         drop_held_behind_dialog(true, &mut keys, &mut left, &mut right);
         assert!(keys.is_empty() && !left && !right);
 
diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index e289eaa8a5..525299b366 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -2,6 +2,7 @@
 //! events (`CriteriaTriggers`), awarding with rewards, the toast and the
 //! chat announcement, and `players/advancements/<uuid>.json`.
 use super::{Dim, Game};
+use horizon_client::actions::Action;
 use horizon_client::{
     advancements::{self as adv, EntityView, Frame, ItemView, Progress, Tree},
     hud::{HudBatch, rgba},
@@ -596,7 +597,7 @@ impl Game<'_> {
             on_fire: p.fire_ticks > 0,
             sneaking: p.pose == horizon_client::pose::Pose::Crouching,
             // Input.shift: the held key, as `BlockItem.place`'s sneaking reads it.
-            input_sneak: self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft),
+            input_sneak: self.keys.held(Action::Sneak),
             sprinting: p.sprinting,
             swimming: p.pose == horizon_client::pose::Pose::Swimming,
             flying: p.flying,
diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs
index 436b2ba09b..6b4879f4fa 100644
--- a/crates/horizon-client/src/game/agent.rs
+++ b/crates/horizon-client/src/game/agent.rs
@@ -8,6 +8,8 @@ mod navigation;
 
 use super::event_loop::EventLoopCtl;
 use super::{Game, Screen};
+use horizon_client::actions::Action;
+use horizon_client::held::Source;
 use horizon_client::{
     Result,
     block_entity_anim::Ticker,
@@ -487,7 +489,7 @@ impl Game<'_> {
                 "on_ground": p.ground.on_ground,
                 "flying": p.flying,
                 "fall_flying": p.fall_flying,
-                "sneaking": self.keys.contains(&KeyCode::ShiftLeft),
+                "sneaking": self.keys.held(Action::Sneak),
                 "sprinting": p.sprinting,
                 "fov_modifier": self.view.fov_modifier,
                 "health": p.health.health(),
@@ -896,11 +898,11 @@ impl Game<'_> {
 
     /// A left or right click, as the mouse would.
     fn agent_mouse(&mut self, button: MouseButton, pressed: bool) -> Result<()> {
-        self.play_mouse(button, pressed)
+        self.mouse_mapping(button, pressed, Source::Agent)
     }
     fn release_agent_keys(&mut self) {
         for k in MOVE_KEYS {
-            self.keys.remove(&k);
+            self.keys.release(&k, Source::Agent);
         }
         if self.left {
             let _ = self.agent_mouse(MouseButton::Left, false);
@@ -1155,7 +1157,7 @@ impl Game<'_> {
                     keys.push(KeyCode::Space);
                 }
                 for &k in &keys {
-                    self.keys.insert(k);
+                    self.keys.press(k, Source::Agent);
                 }
                 let from = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position);
                 let until = Instant::now() + Duration::from_secs_f64(seconds);
@@ -1168,7 +1170,7 @@ impl Game<'_> {
             }
             "jump" => {
                 self.playing()?;
-                self.keys.insert(KeyCode::Space);
+                self.keys.press(KeyCode::Space, Source::Agent);
                 let from_y = self.player.as_ref().map_or(0.0, |p| p.position.y);
                 let release_tick = self.ticks + 3;
                 self.start_task(
@@ -1894,7 +1896,7 @@ impl Game<'_> {
                     return Some(json!({ "error": why, "position": self.position() }));
                 }
                 for &k in keys.iter() {
-                    self.keys.insert(k);
+                    self.keys.press(k, Source::Agent);
                 }
                 if Instant::now() < *until && !timed_out {
                     return None;
@@ -1921,7 +1923,7 @@ impl Game<'_> {
                 from_y,
             } => {
                 if self.ticks >= *release_tick || timed_out {
-                    self.keys.remove(&KeyCode::Space);
+                    self.keys.release(&KeyCode::Space, Source::Agent);
                     let on_ground = self.player.as_ref().is_some_and(|p| p.ground.on_ground);
                     if on_ground || timed_out {
                         return Some(
@@ -2089,9 +2091,9 @@ impl Game<'_> {
         if d[0].abs() + d[1].abs() > 1e-3 {
             self.yaw = (-d[0]).atan2(d[1]).to_degrees() as f32;
         }
-        self.keys.insert(KeyCode::KeyW);
+        self.keys.press(KeyCode::KeyW, Source::Agent);
         if g.sprint {
-            self.keys.insert(KeyCode::ControlLeft);
+            self.keys.press(KeyCode::ControlLeft, Source::Agent);
         }
         // Step up onto the next block, or out of water.
         let in_water = {
@@ -2106,9 +2108,9 @@ impl Game<'_> {
             g.jump_until = self.ticks + 4;
         }
         if self.ticks < g.jump_until || in_water {
-            self.keys.insert(KeyCode::Space);
+            self.keys.press(KeyCode::Space, Source::Agent);
         } else {
-            self.keys.remove(&KeyCode::Space);
+            self.keys.release(&KeyCode::Space, Source::Agent);
         }
         None
     }
diff --git a/crates/horizon-client/src/game/block_editor.rs b/crates/horizon-client/src/game/block_editor.rs
index dc75e813d9..d8379c3610 100644
--- a/crates/horizon-client/src/game/block_editor.rs
+++ b/crates/horizon-client/src/game/block_editor.rs
@@ -365,7 +365,7 @@ impl Game<'_> {
         let b = HudBatch::new(size);
         let cursor = self.cursor;
         let shift = self.has_shift_down();
-        let alt = self.keys.contains(&KeyCode::AltLeft);
+        let alt = self.keys.raw(&KeyCode::AltLeft);
         let atlas_click = |game: &Game<'_>, edit: &mut EditBox| {
             edit.click(&game.gui.atlas, cursor.0, false, false);
         };
diff --git a/crates/horizon-client/src/game/boat_leads.rs b/crates/horizon-client/src/game/boat_leads.rs
index d8dd572cfa..b8035083f5 100644
--- a/crates/horizon-client/src/game/boat_leads.rs
+++ b/crates/horizon-client/src/game/boat_leads.rs
@@ -12,6 +12,7 @@
 //! it by the rope either. Here the pull lands on the server's copy and the
 //! rider's client overwrites it the same way (`tick_boats`).
 use super::{Game, boats::Boat};
+use horizon_client::actions::Action;
 use horizon_client::mobs::leash::{self, Holder, HolderState, Pending};
 use horizon_core::geometry::Vec3;
 use horizon_world::nbt::Tag;
@@ -418,7 +419,7 @@ impl Game<'_> {
         let id = self.boats[i].id;
         // The sneak branch: the player's mobs and boats on leads are re-tied
         // to this boat.
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         if sneaking
             && self.tie_player_leads(glam::DVec3::new(c.x, c.y, c.z), Holder::Boat(id), None)
         {
diff --git a/crates/horizon-client/src/game/boats.rs b/crates/horizon-client/src/game/boats.rs
index 0e6b1358b1..a390e60204 100644
--- a/crates/horizon-client/src/game/boats.rs
+++ b/crates/horizon-client/src/game/boats.rs
@@ -5,6 +5,7 @@
 mod placement;
 
 use super::{Game, InteractTarget, entity::Entity, entity_culling::at, view_vector};
+use horizon_client::actions::Action;
 use horizon_client::entity_rules::EntityRules;
 use horizon_client::{
     blocks::Fluid,
@@ -1330,7 +1331,7 @@ impl Game<'_> {
         }) else {
             return false;
         };
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         // Only a client's own pick is stopped by a block: the range check passed.
         if target.is_none() && !self.before_block(d) {
             return false;
diff --git a/crates/horizon-client/src/game/campfire_douse.rs b/crates/horizon-client/src/game/campfire_douse.rs
index e3a990b275..1ded9a028a 100644
--- a/crates/horizon-client/src/game/campfire_douse.rs
+++ b/crates/horizon-client/src/game/campfire_douse.rs
@@ -1,10 +1,10 @@
 //! `CampfireBlock.useItemOn`: an item in `#minecraft:douses_campfires` (the
 //! shovels) put on a lit campfire puts it out.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{Result, animate_tick::make_campfire_smoke, items::ItemStack};
 use horizon_core::position::BlockPos;
 use horizon_world::chunk::BlockState;
-use winit::keyboard::KeyCode;
 
 impl Game<'_> {
     /// The lit campfire at `pos` that `held` puts out, when the item is in
@@ -38,7 +38,7 @@ impl Game<'_> {
         seq: i32,
     ) -> bool {
         // Player.isSecondaryUseActive: a held item means both hands count.
-        if self.keys.contains(&KeyCode::ShiftLeft) {
+        if self.keys.held(Action::Sneak) {
             return false;
         }
         let Some(mut state) = self.campfire_to_douse(pos, held) else {
diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs
index a15a209479..7ee6d828d1 100644
--- a/crates/horizon-client/src/game/chat.rs
+++ b/crates/horizon-client/src/game/chat.rs
@@ -1223,6 +1223,7 @@ impl Game<'_> {
         let Some(url) = &self.link_prompt else {
             return;
         };
+        horizon_client::widgets::cover_frame();
         // ConfirmLinkScreen: the question and the link (its warning is a
         // widget of its own, not narrated).
         horizon_client::widgets::begin_screen(|| {
@@ -1240,7 +1241,7 @@ impl Game<'_> {
             Text::translate("chat.copy", &[]),
             Text::translate("gui.no", &[]),
         ];
-        let layout = self.link_prompt_layout(url, (w, h));
+        let mut layout = self.link_prompt_layout(url, (w, h));
         layout.declare_no(2);
         layout.draw(batch, atlas, self.cursor, &labels);
     }
diff --git a/crates/horizon-client/src/game/clipboard.rs b/crates/horizon-client/src/game/clipboard.rs
index 12d636a0cd..c6a69dac76 100644
--- a/crates/horizon-client/src/game/clipboard.rs
+++ b/crates/horizon-client/src/game/clipboard.rs
@@ -13,7 +13,7 @@ impl Game<'_> {
             return None;
         }
         let m = self.modifiers;
-        let held = |keys: [KeyCode; 2]| keys.iter().any(|k| self.keys.contains(k));
+        let held = |keys: [KeyCode; 2]| keys.iter().any(|k| self.keys.raw(k));
         clipboard::edit_shortcut(
             clipboard::shortcut_letter(&event.logical_key, event.physical_key),
             self.has_control_down_with_quirk(),
@@ -25,7 +25,7 @@ impl Game<'_> {
     /// modifier (`InputQuirks.EDIT_SHORTCUT_KEY_MODIFIER`: Cmd on macOS, Ctrl
     /// elsewhere), held on the keyboard or by an agent.
     pub(super) fn has_control_down_with_quirk(&self) -> bool {
-        let held = |keys: [KeyCode; 2]| keys.iter().any(|k| self.keys.contains(k));
+        let held = |keys: [KeyCode; 2]| keys.iter().any(|k| self.keys.raw(k));
         if cfg!(target_os = "macos") {
             self.modifiers.super_key() || held([KeyCode::SuperLeft, KeyCode::SuperRight])
         } else {
diff --git a/crates/horizon-client/src/game/code_of_conduct.rs b/crates/horizon-client/src/game/code_of_conduct.rs
index 6340bf5930..c6789f7b2c 100644
--- a/crates/horizon-client/src/game/code_of_conduct.rs
+++ b/crates/horizon-client/src/game/code_of_conduct.rs
@@ -169,6 +169,7 @@ impl Game<'_> {
         let Some(prompt) = &self.code_of_conduct else {
             return;
         };
+        horizon_client::widgets::cover_frame();
         // CodeOfConductScreen: WarningScreen's narration, the title and the
         // text on the next line.
         horizon_client::widgets::begin_screen(|| {
@@ -218,6 +219,7 @@ impl Game<'_> {
 
         let [x, y, cw, ch] = layout.check;
         let hover = ui::hovered(cursor, x, y, cw, ch);
+        horizon_client::widgets::record(&layout.label.plain(), layout.check, true);
         horizon_client::widgets::narratable(|| {
             horizon_client::widgets::Narratable::new(
                 horizon_client::widgets::What::Checkbox {
diff --git a/crates/horizon-client/src/game/commands/extra.rs b/crates/horizon-client/src/game/commands/extra.rs
index 44d3ad87b6..10fd94833e 100644
--- a/crates/horizon-client/src/game/commands/extra.rs
+++ b/crates/horizon-client/src/game/commands/extra.rs
@@ -4,6 +4,7 @@
 //! `/fetchprofile`, `/publish`, `/unpublish`, `/debug`, `/jfr` and
 //! `/version`, with vanilla's feedback and failures.
 use super::{Arg, Context, Game, R, Target, err};
+use horizon_client::actions::Action;
 use horizon_client::{
     command::CommandError,
     skins::{NameOrId, Resolve, ResolvedProfile},
@@ -292,8 +293,7 @@ impl Game<'_> {
             self.set_camera(None);
             return;
         }
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft)
-            && self.screen == super::Screen::Playing;
+        let sneaking = self.keys.held(Action::Sneak) && self.screen == super::Screen::Playing;
         match self.target_position(t) {
             Some(p) if !sneaking => {
                 let rot = self.target_rotation(t);
diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs
index 4e092841b4..51939cdf6f 100644
--- a/crates/horizon-client/src/game/control.rs
+++ b/crates/horizon-client/src/game/control.rs
@@ -1,6 +1,7 @@
 //! Commands from the control socket (`horizon-ctl`), run on the game thread.
 use super::event_loop::EventLoopCtl;
 use super::{Game, Screen};
+use horizon_client::held::Source;
 use horizon_client::{Result, items::ItemStack};
 use horizon_core::geometry::Vec3;
 use serde_json::{Value, json};
@@ -588,7 +589,7 @@ impl Game<'_> {
                 // A held edit modifier (`key super down`) and A/C/V/X: the
                 // open book's Select All, Copy, Paste or Cut.
                 if self.book.is_some() && arg(2)? != "up" {
-                    let held = |k: [KeyCode; 2]| k.iter().any(|k| self.keys.contains(k));
+                    let held = |k: [KeyCode; 2]| k.iter().any(|k| self.keys.raw(k));
                     let edit = if cfg!(target_os = "macos") {
                         held([KeyCode::SuperLeft, KeyCode::SuperRight])
                     } else {
@@ -662,15 +663,23 @@ impl Game<'_> {
                         Some(Ok(k)) => k,
                         Some(Err(button)) => {
                             let action = arg(2)?;
-                            if self.screen == Screen::Playing {
+                            if self.screen == Screen::Playing
+                                && self.shared_default_acts(
+                                    button,
+                                    horizon_client::keybinds::key_name(physical),
+                                )
+                            {
                                 if action != "up" {
-                                    self.play_mouse(button, true)?;
+                                    self.mouse_mapping(button, true, Source::Agent)?;
                                 }
                                 // A repeat keeps the key held, as the window's.
                                 if action == "up" || action == "tap" {
-                                    self.play_mouse(button, false)?;
+                                    self.mouse_mapping(button, false, Source::Agent)?;
                                 }
                             }
+                            if action == "tap" {
+                                self.physical_keys.remove(&physical);
+                            }
                             return ok();
                         }
                         None => return ok(),
@@ -679,23 +688,17 @@ impl Game<'_> {
                 match arg(2)? {
                     "down" => self.control_key_down(key, physical)?,
                     "up" => {
-                        self.keys.remove(&key);
+                        self.control_key_up(key);
                         self.physical_keys.remove(&key);
                     }
                     // The system's auto-repeat while the key is held.
                     "repeat" => {
                         self.physical_keys.insert(physical);
-                        self.mapped_key(
-                            key,
-                            true,
-                            true,
-                            key,
-                            horizon_client::held::Source::Keyboard,
-                        )?;
+                        self.mapped_key(key, true, true, key, Source::Agent)?;
                     }
                     "tap" => {
                         self.control_key_down(key, physical)?;
-                        self.keys.remove(&key);
+                        self.control_key_up(key);
                         self.physical_keys.remove(&physical);
                         self.debug_key(physical, horizon_client::debug_keys::KeyAction::Release);
                     }
@@ -745,17 +748,17 @@ impl Game<'_> {
                 match arg(2)? {
                     "down" => {
                         self.extras_mouse(button, true);
-                        self.play_mouse(button, true)?
+                        self.mouse_mapping(button, true, Source::Agent)?
                     }
                     "up" => {
                         self.extras_mouse(button, false);
-                        self.play_mouse(button, false)?
+                        self.mouse_mapping(button, false, Source::Agent)?
                     }
                     "click" => {
                         self.extras_mouse(button, true);
                         self.extras_mouse(button, false);
-                        self.play_mouse(button, true)?;
-                        self.play_mouse(button, false)?;
+                        self.mouse_mapping(button, true, Source::Agent)?;
+                        self.mouse_mapping(button, false, Source::Agent)?;
                     }
                     other => {
                         return Err(
@@ -1239,12 +1242,19 @@ impl Game<'_> {
             self.block_editor_key_code(key, None, None);
             return Ok(());
         }
-        if self.keys.insert(key) {
+        if self.keys.press(key, Source::Agent) {
             self.key_pressed(key, raw)?;
         }
         Ok(())
     }
 
+    /// `key ... up`: the script lets go. What it pressed as the keyboard's stand-in goes with it
+    /// (a fixture's untagged press), and a controller's hold stays.
+    fn control_key_up(&mut self, key: KeyCode) {
+        self.keys.release(&key, Source::Agent);
+        self.keys.release(&key, Source::Keyboard);
+    }
+
     fn screen_name(&self) -> &'static str {
         if self.screen == Screen::Win {
             return "win";
diff --git a/crates/horizon-client/src/game/creative_hotbar.rs b/crates/horizon-client/src/game/creative_hotbar.rs
index 9ada3ceb3a..ee63ff0eda 100644
--- a/crates/horizon-client/src/game/creative_hotbar.rs
+++ b/crates/horizon-client/src/game/creative_hotbar.rs
@@ -5,10 +5,11 @@ use horizon_client::{hotbar, items::ItemStack, keybinds, text::Text};
 use horizon_world::nbt::Tag;
 
 impl Game<'_> {
-    /// Whether the key bound to `mapping` is held.
+    /// Whether the key bound to `mapping` is held, or the controller button bound to it.
     pub(super) fn mapped_key_down(&self, mapping: &str) -> bool {
         keybinds::key_code(self.settings.keys.get(mapping))
             .is_some_and(|k| self.physical_keys.contains(&k))
+            || self.pad.holds_action(&self.settings.controller, mapping)
     }
 
     /// `CreativeModeInventoryScreen.selectTab` on the HOTBAR tab: each saved
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3c978901e3..761fa9df86 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -9,6 +9,7 @@ use super::{
     native_mob_draw::NativePlayerRender, native_projectiles::Impact, view_vector,
 };
 use horizon_assets::item_model::DisplayContext;
+use horizon_client::actions::Action;
 use horizon_client::{
     Result,
     arrows::EntityHit,
@@ -322,7 +323,7 @@ impl Game<'_> {
             alive: !p.health.dead_or_dying(),
             // EntitySelector.NO_CREATIVE_OR_SPECTATOR.
             creative: self.creative || self.spectator(),
-            sneaking: self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft),
+            sneaking: self.keys.held(Action::Sneak),
             swimming: p.swimming,
             look: view_vector(self.yaw, self.pitch),
             main_hand: self.held().map(|s| s.item.clone()),
@@ -5784,8 +5785,8 @@ impl Game<'_> {
             .as_ref()
             .map(|p| [p.position.x, p.position.y, p.position.z]);
         let acting = self.acting_player_uuid();
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft)
-            || self.keys.contains(&winit::keyboard::KeyCode::ShiftRight);
+        let sneaking =
+            self.keys.held(Action::Sneak) || self.keys.raw(&winit::keyboard::KeyCode::ShiftRight);
         let held_damage = held.as_ref().map_or(0, |h| h.damage as i32);
         let held_extra = held.as_ref().and_then(|h| h.extra.clone());
         let m = &mut self.mobs[index];
diff --git a/crates/horizon-client/src/game/cushions.rs b/crates/horizon-client/src/game/cushions.rs
index 9046305d5a..ed79df986a 100644
--- a/crates/horizon-client/src/game/cushions.rs
+++ b/crates/horizon-client/src/game/cushions.rs
@@ -7,11 +7,11 @@
 //! only an entity whose `Pos` is the click point's height. Placement uses
 //! outline bounds, collision shapes and suffocation predicates.
 use super::{Game, Hit, InteractTarget, Keys, entity_culling::default_range, ray_box};
+use horizon_client::actions::Action;
 use horizon_client::entities::{Cushion, dye_index};
 use horizon_client::items::ItemStack;
 use horizon_client::mobs::anim::Poses;
 use horizon_core::geometry::{Aabb, Vec3};
-use winit::keyboard::KeyCode;
 
 /// `Direction.fromYRot(yaw).toYRot()`: the nearest 90 degree step.
 pub(crate) fn snap_yaw(yaw: f32) -> f32 {
@@ -324,7 +324,7 @@ impl Game<'_> {
             return false;
         }
         // isSecondaryUseActive.
-        if self.keys.contains(&KeyCode::ShiftLeft) {
+        if self.keys.held(Action::Sneak) {
             return false;
         }
         let id = self.cushions[i].id;
diff --git a/crates/horizon-client/src/game/debug_options.rs b/crates/horizon-client/src/game/debug_options.rs
index 698ff61024..265119d95e 100644
--- a/crates/horizon-client/src/game/debug_options.rs
+++ b/crates/horizon-client/src/game/debug_options.rs
@@ -481,6 +481,14 @@ impl Game<'_> {
             self.debug_options_type(text);
         }
     }
+    /// One character off the search box, for the controller's on-screen keyboard.
+    pub(super) fn debug_options_backspace(&mut self) {
+        if let Some(s) = &mut self.debug_options
+            && s.search.focused
+        {
+            s.search.key(KeyCode::Backspace, false, false);
+        }
+    }
     /// Characters typed into the search box (`EditBox.charTyped`).
     pub(super) fn debug_options_type(&mut self, typed: &str) {
         let allowed: String = typed
diff --git a/crates/horizon-client/src/game/debug_stick.rs b/crates/horizon-client/src/game/debug_stick.rs
index 2a95ceb924..6d755ed317 100644
--- a/crates/horizon-client/src/game/debug_stick.rs
+++ b/crates/horizon-client/src/game/debug_stick.rs
@@ -5,10 +5,10 @@
 //! compound of block id to property name. Horizon keeps unmodelled components
 //! in `StackData::other`, so the component travels through NBT unchanged.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{Result, items::ItemStack, text::Text};
 use horizon_core::position::BlockPos;
 use horizon_world::level::flags;
-use winit::keyboard::KeyCode;
 
 const DEBUG_STICK: &str = "minecraft:debug_stick";
 
@@ -81,7 +81,7 @@ impl Game<'_> {
         // `Player.isSecondaryUseActive` / `isShiftKeyDown`: the acting
         // player's sneak input. `keys` holds the host's, toggled sneak
         // included; `enter_guest` fills it from the guest's sneak state.
-        let backward = self.keys.contains(&KeyCode::ShiftLeft);
+        let backward = self.keys.held(Action::Sneak);
 
         if cycle {
             // `cycleState`: a property selected on another block falls back to
diff --git a/crates/horizon-client/src/game/dialogs.rs b/crates/horizon-client/src/game/dialogs.rs
index c31aa95f9e..bd217a4ae0 100644
--- a/crates/horizon-client/src/game/dialogs.rs
+++ b/crates/horizon-client/src/game/dialogs.rs
@@ -116,6 +116,35 @@ impl Game<'_> {
         let d = &self.dialogs;
         d.open.is_some() || d.waiting.is_some() || d.warning
     }
+    /// What tells one dialog screen from another for a controller's focus: a new dialog is a
+    /// new screen, and so are the warning and waiting screens.
+    pub(super) fn dialog_screen_key(&self) -> (bool, bool, Option<String>) {
+        let d = &self.dialogs;
+        (
+            d.warning,
+            d.waiting.is_some(),
+            d.open.as_ref().map(|o| o.dialog.title.plain()),
+        )
+    }
+    /// The warning icon in the dialog's corner, while the dialog itself shows.
+    pub(super) fn dialog_warning_icon(&self) -> Option<[f32; 4]> {
+        let d = &self.dialogs;
+        if d.warning || d.waiting.is_some() {
+            return None;
+        }
+        self.dialog_layout().map(|layout| layout.warning)
+    }
+    /// The dialog itself shows, with a text input to start on.
+    pub(super) fn dialog_starts_typing(&self) -> bool {
+        !self.dialogs.warning && self.dialogs.waiting.is_none() && self.dialog_has_text_field()
+    }
+    /// The dialog's focus is a text input of many lines, where Enter is a new line.
+    pub(super) fn dialog_typing_lines(&self) -> bool {
+        self.dialogs.open.as_ref().is_some_and(|o| {
+            let field = o.focus.and_then(|f| o.fields.get(f));
+            matches!(field, Some(Some(Field::Multi(_))))
+        })
+    }
     /// Whether the dialog's focus is one of its text inputs, which takes the
     /// keys.
     pub(super) fn dialog_typing(&self) -> bool {
@@ -400,6 +429,7 @@ impl Game<'_> {
         if !self.dialog_open() {
             return;
         }
+        widgets::cover_frame();
         let (w, h) = (batch.width, batch.height);
         let cursor = self.cursor;
         let atlas = &self.gui.atlas;
@@ -418,7 +448,7 @@ impl Game<'_> {
                     widgets::join_for_narration(&[&title.plain(), &message.plain()]),
                 )
             });
-            let confirm = Confirm::new(&atlas.font, (w, h), &title, &message);
+            let mut confirm = Confirm::new(&atlas.font, (w, h), &title, &message);
             confirm.declare_no();
             confirm.draw(batch, atlas, cursor, [&disconnect, &back]);
             return;
@@ -515,11 +545,16 @@ impl Game<'_> {
         let mut tooltip = None;
         let mut item_tip = None;
         let mut start = None;
+        let mut mark = None;
         for (part, clipped) in layout.placed(open.scroll.amount) {
             if clipped && start.is_none() {
                 start = Some(batch.vertices.len());
+                mark = Some(widgets::frame_mark());
             } else if !clipped && let Some(s) = start.take() {
                 batch.clip_since(s, ax, ay, ax + aw, ay + ah);
+                if let Some(mark) = mark.take() {
+                    widgets::clip_frame(mark, ay, ay + ah);
+                }
             }
             match part {
                 Part::Line(text, x, y) => {
@@ -681,9 +716,13 @@ impl Game<'_> {
                         (!clipped || in_area(cursor.1)) && ui::hovered(cursor, x, y, bw, bh);
                     let b = buttons[index];
                     if open.dialog.escape_button() == Some(index) {
-                        widgets::declare_action(widgets::Action::Cancel, rect, true);
+                        let action = widgets::Action::Cancel;
+                        ui::action_button(
+                            batch, atlas, action, x, y, bw, bh, &b.label, true, hover,
+                        );
+                    } else {
+                        ui::button(batch, atlas, x, y, bw, bh, &b.label, true, hover);
                     }
-                    ui::button(batch, atlas, x, y, bw, bh, &b.label, true, hover);
                     if let Some(t) = &b.tooltip {
                         widgets::last_narratable(|n| n.hint = Some(t.plain()));
                     }
@@ -696,7 +735,12 @@ impl Game<'_> {
         if let Some(s) = start {
             batch.clip_since(s, ax, ay, ax + aw, ay + ah);
         }
+        if let Some(mark) = mark {
+            widgets::clip_frame(mark, ay, ay + ah);
+        }
         if layout.content > ah {
+            // A controller's focus step goes through the body's hidden parts before it leaves.
+            widgets::scroll_area(layout.area, open.scroll.amount, layout.content - ah);
             ui::scrollbar(
                 batch,
                 atlas,
diff --git a/crates/horizon-client/src/game/ghasts.rs b/crates/horizon-client/src/game/ghasts.rs
index d6fd95c02c..01474059c3 100644
--- a/crates/horizon-client/src/game/ghasts.rs
+++ b/crates/horizon-client/src/game/ghasts.rs
@@ -2,6 +2,7 @@
 //! off), riding, getting off on top, and the ghastling a dried ghast block
 //! hatches.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{
     items::ItemStack,
     mobs::{MobEvent, happy_ghast},
@@ -65,7 +66,7 @@ impl Game<'_> {
             return false;
         }
         let at = m.center();
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         let harnessed = m.extra.body.is_some();
         // Equippable.equipOnInteract: a harness goes on a bare adult.
         if item.ends_with("_harness") && item.starts_with("minecraft:") && !harnessed {
diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs
index a7a67073da..d9a5835dee 100644
--- a/crates/horizon-client/src/game/hand.rs
+++ b/crates/horizon-client/src/game/hand.rs
@@ -447,7 +447,7 @@ impl Game<'_> {
                 winit::keyboard::KeyCode::KeyD,
             ]
             .iter()
-            .any(|k| self.keys.contains(k))
+            .any(|k| self.movement_key_held(*k))
     }
     /// `MultiPlayerGameMode.startUseItem`'s bookkeeping around the game's
     /// use: nothing starts while a block is being broken or the hands are
diff --git a/crates/horizon-client/src/game/leads.rs b/crates/horizon-client/src/game/leads.rs
index 99a44a75c7..44276eace3 100644
--- a/crates/horizon-client/src/game/leads.rs
+++ b/crates/horizon-client/src/game/leads.rs
@@ -3,6 +3,7 @@
 //! `LeashFenceKnotEntity.interact`), loading and saving who holds what,
 //! breaking, and drawing the rope (`LeashFeatureRenderer`) and the knot.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{
     items::ItemStack,
     mesher::Vertex,
@@ -357,7 +358,7 @@ impl Game<'_> {
     }
     /// `Entity.interact`'s leash part for a mob. Returns whether it was used.
     pub(super) fn interact_leash(&mut self, index: usize, item: &str) -> bool {
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         let id = self.mobs[index].id;
         let at = self.mobs[index].center();
         if !self.mobs[index].alive() {
@@ -476,7 +477,7 @@ impl Game<'_> {
             .collect();
         let existing_boats = self.boats_on(Holder::Knot(knot_pos));
         let held_item = self.held().map(|s| s.item.to_string());
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         // Shears snip every lead on the knot.
         if knot_hit && held_item.as_deref() == Some("minecraft:shears") {
             for i in existing {
@@ -758,7 +759,7 @@ impl Game<'_> {
             return rot_y(v, -yaw) + eye;
         }
         let yaw = f64::from(self.yaw.to_radians());
-        let crouching = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let crouching = self.keys.held(Action::Sneak);
         let v = glam::DVec3::new(
             0.22 * hand_dir,
             f64::from(p.dimensions.height) - 1.0,
diff --git a/crates/horizon-client/src/game/llamas.rs b/crates/horizon-client/src/game/llamas.rs
index 682968ed73..527f2d296c 100644
--- a/crates/horizon-client/src/game/llamas.rs
+++ b/crates/horizon-client/src/game/llamas.rs
@@ -2,6 +2,7 @@
 //! `Llama.handleEating` (wheat and hay), chests, carpets, shearing a carpet
 //! off and riding.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{
     items::ItemStack,
     mobs::{equine, llama},
@@ -78,7 +79,7 @@ impl Game<'_> {
         if !m.alive() || Some(m.id) == self.riding {
             return false;
         }
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         let (baby, tamed, vehicle) = (m.is_baby(), m.extra.tame, m.rider.is_some());
         let open_inventory = !baby && tamed && sneaking;
         if !vehicle && !open_inventory && !item.is_empty() {
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index d3f8afe1a6..08e441cff8 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -5,6 +5,7 @@
 //! furnace and TNT variants, saving, and `AbstractMinecartRenderer`'s old
 //! rail-following render with the display block.
 use super::{Game, Hit, InteractTarget, Keys, entity::Entity};
+use horizon_client::actions::Action;
 use horizon_client::entity_rules::EntityRules;
 use horizon_client::{
     blocks::Fluid,
@@ -2150,7 +2151,7 @@ impl Game<'_> {
         if target.is_none() && !self.before_block(d) {
             return false;
         }
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         let held = self.held().cloned();
         match self.carts[i].kind {
             CartKind::Rideable => {
diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs
index 0e84ec50e6..85c8c9de24 100644
--- a/crates/horizon-client/src/game/mounts.rs
+++ b/crates/horizon-client/src/game/mounts.rs
@@ -3,6 +3,7 @@
 //! (`LocalPlayer.aiStep`'s riding jump), positioning, dismounting, and the
 //! mount's health and jump bar on the HUD.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{
     blocks::Fluid,
     hud::HudBatch,
@@ -156,7 +157,7 @@ impl Game<'_> {
         {
             return Some(false);
         }
-        if self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft) {
+        if self.keys.held(Action::Sneak) {
             return None;
         }
         let saddle = m.saddle_item()?;
@@ -198,7 +199,7 @@ impl Game<'_> {
         }
         // Pig.mobInteract: held food goes to Animal.mobInteract, not a ride.
         let food = m.kind.food.iter().any(|f| f.as_str() == item);
-        if !m.extra.saddled || food || self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft) {
+        if !m.extra.saddled || food || self.keys.held(Action::Sneak) {
             return false;
         }
         let id = m.id;
@@ -294,8 +295,8 @@ impl Game<'_> {
         if species == Species::SkeletonHorse && !m.extra.tame {
             return false;
         }
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft)
-            || self.keys.contains(&winit::keyboard::KeyCode::ShiftRight);
+        let sneaking =
+            self.keys.held(Action::Sneak) || self.keys.raw(&winit::keyboard::KeyCode::ShiftRight);
         // Horse / ZombieHorse.mobInteract: food is fed, and anything else in
         // hand makes an untamed one mad instead of seating the player.
         let dandelion = [self.held(), self.offhand.as_ref()]
@@ -531,7 +532,7 @@ impl Game<'_> {
             pitch: self.pitch,
             jump: if jump > 0.0 { jump } else { pending },
             steer,
-            sprint: keys.sprint || self.keys.contains(&winit::keyboard::KeyCode::ControlLeft),
+            sprint: keys.sprint || self.keys.held(Action::Sprint),
             jumping: keys.jump,
             // A server's player (a LAN guest, single player's window) drives
             // a horse from its own client (`handleMoveVehicle`).
diff --git a/crates/horizon-client/src/game/native_hooks.rs b/crates/horizon-client/src/game/native_hooks.rs
index 41ca715236..e401178d54 100644
--- a/crates/horizon-client/src/game/native_hooks.rs
+++ b/crates/horizon-client/src/game/native_hooks.rs
@@ -9297,7 +9297,7 @@ impl Game<'_> {
         let &(_, key) = MAPPINGS.iter().find(|m| m.0 == name)?;
         let label = keybinds::display_name(self.settings.keys.get(name)).plain();
         let down = match key {
-            Some(k) => self.keys.contains(&k),
+            Some(k) => self.movement_key_held(k),
             None => self.mouse_reading().1[usize::from(name == "key.use")],
         };
         Some((down, label))
diff --git a/crates/horizon-client/src/game/native_host_bridge.rs b/crates/horizon-client/src/game/native_host_bridge.rs
index db34b91c83..85b5e058bb 100644
--- a/crates/horizon-client/src/game/native_host_bridge.rs
+++ b/crates/horizon-client/src/game/native_host_bridge.rs
@@ -5,13 +5,13 @@
 //! (docs/native-mods.md, "Trait mods"). Each goes through the helper or the
 //! state the game's own code uses, so both answer alike.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{
     containers::{BlockEntity, ModBlockEntity},
     items::ItemStack,
     particles::ParticleOptions,
 };
 use horizon_world::{player_inventory::EquipmentSlot, registry::BlockStateId};
-use winit::keyboard::KeyCode;
 
 // Native mods use these; nothing in Horizon does.
 #[allow(dead_code)]
@@ -117,7 +117,7 @@ impl Game<'_> {
     /// (`as_guest` holds sneak for them); on a client the player's own key.
     /// API @API:host_bridge@.
     pub(super) fn native_sneaking(&self) -> bool {
-        self.keys.contains(&KeyCode::ShiftLeft)
+        self.keys.held(Action::Sneak)
     }
 }
 
diff --git a/crates/horizon-client/src/game/nautili.rs b/crates/horizon-client/src/game/nautili.rs
index 51e965c359..18b959be5a 100644
--- a/crates/horizon-client/src/game/nautili.rs
+++ b/crates/horizon-client/src/game/nautili.rs
@@ -2,6 +2,7 @@
 //! pufferfish, feeding, the saddle and armour, riding, and the zombie
 //! nautilus a drowned with a trident sometimes rides.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{
     items::ItemStack,
     mobs::{Species, nautilus},
@@ -49,8 +50,8 @@ impl Game<'_> {
             .map(|t| t.iter().cloned().collect())
             .unwrap_or_default();
         let food = nautilus::is_food(m, item, &taming);
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft)
-            || self.keys.contains(&winit::keyboard::KeyCode::ShiftRight);
+        let sneaking =
+            self.keys.held(Action::Sneak) || self.keys.raw(&winit::keyboard::KeyCode::ShiftRight);
         let tame = m.extra.tame;
         if m.is_baby() {
             // Animal.mobInteract: food grows a baby up by a tenth.
diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs
index d77fba62d5..195b2ad995 100644
--- a/crates/horizon-client/src/game/options.rs
+++ b/crates/horizon-client/src/game/options.rs
@@ -686,7 +686,7 @@ fn detected_controller_style(
     fallback: horizon_client::gamepad::GlyphStyle,
 ) -> horizon_client::gamepad::GlyphStyle {
     device.map_or(fallback, |d| {
-        horizon_client::gamepad::GlyphStyle::of_vendor(d.vendor)
+        horizon_client::gamepad::GlyphStyle::of_device(d.vendor, d.product)
     })
 }
 
diff --git a/crates/horizon-client/src/game/pad.rs b/crates/horizon-client/src/game/pad.rs
index ab7b12e88e..d354865926 100644
--- a/crates/horizon-client/src/game/pad.rs
+++ b/crates/horizon-client/src/game/pad.rs
@@ -5,6 +5,7 @@
 //! injects a virtual pad on top of the real one.
 use super::event_loop::EventLoopCtl;
 use super::{Game, Screen};
+use horizon_client::actions::Action;
 use horizon_client::held::Source;
 use horizon_client::{
     Result,
@@ -14,7 +15,8 @@ use horizon_client::{
     keymapping::SNEAK,
 };
 use serde_json::{Value, json};
-use std::time::Instant;
+use std::time::{Duration, Instant};
+use winit::event::MouseButton;
 use winit::keyboard::KeyCode;
 
 pub(super) const HELP: &[&str] = &[
@@ -69,6 +71,11 @@ pub(super) struct Pads {
     pub(super) menu: super::pad_menu::MenuCursor,
     /// The last vibration asked for, for `pad status`.
     last_rumble: Option<(&'static str, gamepad::Pulse)>,
+    /// The drop button, while it is held in play.
+    held_drop: Option<gamepad::HeldDrop>,
+    /// The drop about to happen is the pad's stack form: it has no Control for `drop_whole_stack`.
+    /// On a server the drop waits for the tick.
+    pub(super) drop_stack: bool,
     /// The player's health between polls (a drop is damage taken).
     health: HealthWatch,
 }
@@ -323,6 +330,7 @@ impl Game<'_> {
             self.pad.in_use = true;
         }
         self.pad.state = state;
+        self.pad_drop_frame();
         self.pad_output_frame();
         // Damage from any source, here or on a server; nothing counts on
         // the title screen.
@@ -468,8 +476,8 @@ impl Game<'_> {
         };
         match route {
             Route::HotbarStep { next } => {
-                if down && self.screen == Screen::Playing {
-                    self.selected = gamepad::hotbar_step(self.selected, next);
+                if down {
+                    self.hotbar_step(next);
                 }
                 Ok(())
             }
@@ -483,10 +491,10 @@ impl Game<'_> {
                     return Ok(());
                 }
                 let screen_open = self.screen != Screen::Playing || self.title.is_some();
-                let was = self.keys.contains(&KeyCode::ShiftLeft);
+                let was = self.keys.held(Action::Sneak);
                 self.toggles.pad_toggle(SNEAK, screen_open);
                 self.sync_toggle(SNEAK);
-                if !was && self.keys.contains(&KeyCode::ShiftLeft) {
+                if !was && self.keys.held(Action::Sneak) {
                     // The pad's latch: a keyboard handoff leaves it.
                     self.keys.press(KeyCode::ShiftLeft, Source::Pad);
                     self.keys.release(&KeyCode::ShiftLeft, Source::Keyboard);
@@ -512,18 +520,65 @@ impl Game<'_> {
                 }
                 Ok(())
             }
-            Route::Mouse(button) => {
-                if !down || (self.title.is_none() && self.screen == Screen::Playing) {
-                    self.play_mouse(button, down)?;
+            Route::Fullscreen => {
+                if down {
+                    self.toggle_fullscreen();
                 }
                 Ok(())
             }
+            Route::Held => Ok(()),
+            Route::Mouse(button) => {
+                let playing = self.title.is_none() && self.screen == Screen::Playing;
+                // What the window path tells mods and the click counters. Pick block isn't one
+                // they count.
+                if playing
+                    && matches!(button, MouseButton::Left | MouseButton::Right)
+                    && (down || !self.mouse_mapping_held_elsewhere(button, Source::Pad))
+                {
+                    self.extras_mouse(button, down);
+                }
+                if !down || playing {
+                    self.mouse_mapping(button, down, Source::Pad)?;
+                }
+                Ok(())
+            }
+            Route::Key(KeyCode::KeyQ) => {
+                self.pad.drop_stack = false;
+                self.pad.held_drop = down.then(|| {
+                    let delay = self.settings.controller.repeat_delay;
+                    gamepad::HeldDrop::new(Instant::now(), Duration::from_secs_f32(delay))
+                });
+                self.mapped_key(KeyCode::KeyQ, down, false, KeyCode::KeyQ, Source::Pad)
+            }
             Route::Key(key) => self.mapped_key(key, down, false, key, Source::Pad),
         }
     }
 
+    /// Each poll: a held drop button, as a held Q's key repeats reach the mapping.
+    fn pad_drop_frame(&mut self) {
+        if self.pad_in_menu() || self.screen_over_playing() {
+            return;
+        }
+        let interval = Duration::from_secs_f32(self.settings.controller.repeat_interval);
+        let step = self
+            .pad
+            .held_drop
+            .as_mut()
+            .and_then(|held| held.due(Instant::now(), interval));
+        let Some(step) = step else {
+            return;
+        };
+        self.pad.drop_stack = step == gamepad::DropStep::Stack;
+        if let Err(e) = self.mapped_key(KeyCode::KeyQ, true, true, KeyCode::KeyQ, Source::Pad) {
+            log::warn!("Horizon: controller drop: {e}");
+        }
+    }
+
     /// B and Start: what Escape does where the pad is.
     pub(super) fn pad_back(&mut self) -> Result<()> {
+        if self.prompt_open() {
+            return self.pad_prompt_back();
+        }
         // The options open over the title screen too: they come first, as
         // for the keyboard's Escape.
         if self.screen == Screen::Options {
@@ -554,6 +609,26 @@ impl Game<'_> {
         gamepad::move_vector(self.pad.state.left, settings.move_deadzone)
     }
 
+    /// Whether `key` is held, a movement key by the left stick too: as the keys the stick holds
+    /// (`eight_direction_keys`), whatever moves the player. For readers of the keys that aren't
+    /// the movement itself.
+    pub(super) fn movement_key_held(&self, key: KeyCode) -> bool {
+        if self.keys.raw(&key) {
+            return true;
+        }
+        let Some(stick) = self.pad_move() else {
+            return false;
+        };
+        let [forward, backward, left, right] = gamepad::eight_direction_keys(stick);
+        match key {
+            KeyCode::KeyW => forward,
+            KeyCode::KeyS => backward,
+            KeyCode::KeyA => left,
+            KeyCode::KeyD => right,
+            _ => false,
+        }
+    }
+
     /// The right stick turns the view, once per frame (`Entity.turn`).
     pub(super) fn pad_look(&mut self, seconds: f32) {
         let settings = &self.settings.controller;
diff --git a/crates/horizon-client/src/game/pad/hardware.rs b/crates/horizon-client/src/game/pad/hardware.rs
index 6984216905..e07f346092 100644
--- a/crates/horizon-client/src/game/pad/hardware.rs
+++ b/crates/horizon-client/src/game/pad/hardware.rs
@@ -134,9 +134,9 @@ impl Pads {
                     // Some backends report the controllers already there as they open.
                     if !self.devices.known.contains(&id) {
                         self.devices.known.push(id);
-                        let vendor = gilrs.gamepad(id).vendor_id();
-                        self.connections
-                            .push(Connection::Connected(GlyphStyle::of_vendor(vendor)));
+                        let pad = gilrs.gamepad(id);
+                        let style = GlyphStyle::of_device(pad.vendor_id(), pad.product_id());
+                        self.connections.push(Connection::Connected(style));
                     }
                     if let Some(output) = &self.devices.output {
                         output.scan();
@@ -179,7 +179,7 @@ impl Pads {
             return PadState::default();
         };
         self.device = Some(device_of(&pad));
-        self.style = GlyphStyle::of_vendor(pad.vendor_id());
+        self.style = GlyphStyle::of_device(pad.vendor_id(), pad.product_id());
         self.devices.dualsense = is_dualsense(&pad);
         state_of(&pad)
     }
@@ -340,7 +340,7 @@ impl PadRouter {
             .as_ref()
             .and_then(|g| g.connected_gamepad(id))
             .map_or(GlyphStyle::Auto, |pad| {
-                GlyphStyle::of_vendor(pad.vendor_id())
+                GlyphStyle::of_device(pad.vendor_id(), pad.product_id())
             })
     }
 
diff --git a/crates/horizon-client/src/game/pad/hardware/face_buttons.rs b/crates/horizon-client/src/game/pad/hardware/face_buttons.rs
index 15c867e5fc..205ea02e8e 100644
--- a/crates/horizon-client/src/game/pad/hardware/face_buttons.rs
+++ b/crates/horizon-client/src/game/pad/hardware/face_buttons.rs
@@ -18,7 +18,7 @@ pub(super) fn crossed(pad: &Gamepad) -> bool {
                 Button::Z,
             ]
             .map(|button| pad.button_code(button).is_some()),
-            GlyphStyle::of_vendor(pad.vendor_id()),
+            GlyphStyle::of_device(pad.vendor_id(), pad.product_id()),
         )
 }
 
@@ -48,7 +48,7 @@ mod tests {
     #[test]
     fn an_unmapped_xbox_style_pad_is_crossed() {
         // The GameSir Nova Lite 2 of #7323: `3537:1098`, no SDL row, X sends BTN_NORTH.
-        let style = GlyphStyle::of_vendor(Some(0x3537));
+        let style = GlyphStyle::of_device(Some(0x3537), Some(0x1098));
         assert!(crossed_layout(MappingSource::Driver, XBOX_BUTTONS, style));
     }
 
@@ -64,7 +64,7 @@ mod tests {
     #[test]
     fn a_sony_or_nintendo_pad_means_what_its_codes_say() {
         for vendor in [0x054c, 0x057e] {
-            let style = GlyphStyle::of_vendor(Some(vendor));
+            let style = GlyphStyle::of_device(Some(vendor), None);
             assert!(!crossed_layout(MappingSource::Driver, XBOX_BUTTONS, style));
         }
     }
diff --git a/crates/horizon-client/src/game/pad/parity_tests.rs b/crates/horizon-client/src/game/pad/parity_tests.rs
index 2b222ca6e1..5bd56dd120 100644
--- a/crates/horizon-client/src/game/pad/parity_tests.rs
+++ b/crates/horizon-client/src/game/pad/parity_tests.rs
@@ -2,8 +2,13 @@
 //! What needs a renderer (inventory slots, screenshots) is covered by tools/pad_parity_e2e.py.
 
 use super::super::{Audio, Game, Options, Progress, Screen, Settings, load_resources};
+use horizon_client::actions::Action;
+use horizon_client::command::args::GameMode;
 use horizon_client::gamepad::{Button, PadState};
 use horizon_client::held::Source;
+use horizon_client::motion::PlayerMotion;
+use horizon_core::geometry::Vec3;
+use winit::event::MouseButton;
 use winit::keyboard::KeyCode;
 
 /// A game at play with no world: input reaches the mappings, as in `Screen::Playing`.
@@ -43,7 +48,12 @@ fn playing(test: impl FnOnce(&mut Game)) {
 /// Hold `button` on the pad, as a poll that saw it go down would.
 fn pad_press(game: &mut Game, button: Button, action: &str) {
     let mut state = PadState::default();
-    state.set(button, true);
+    // A trigger is held by how far it's pulled, not by a button bit.
+    match button {
+        Button::LeftTrigger => state.triggers[0] = 1.0,
+        Button::RightTrigger => state.triggers[1] = 1.0,
+        _ => state.set(button, true),
+    }
     game.pad.edges.update(&state, 0.4);
     game.pad_action(action, true).unwrap();
 }
@@ -55,15 +65,12 @@ fn keyboard_handoff_keeps_what_the_pad_holds() {
         game.mapped_key(KeyCode::KeyW, true, false, KeyCode::KeyW, Source::Keyboard)
             .unwrap();
         pad_press(game, Button::South, "key.jump");
-        assert!(game.keys.contains(&KeyCode::Space) && game.keys.contains(&KeyCode::KeyW));
+        assert!(game.keys.held(Action::Jump) && game.keys.held(Action::Forward));
         // Splitscreen: keyboard and mouse move to another player.
         game.release_keyboard_mouse();
+        assert!(!game.keys.held(Action::Forward), "the keyboard's walk ends");
         assert!(
-            !game.keys.contains(&KeyCode::KeyW),
-            "the keyboard's walk ends"
-        );
-        assert!(
-            game.keys.contains(&KeyCode::Space),
+            game.keys.held(Action::Jump),
             "the pad still holds jump; only the keyboard and mouse left"
         );
     });
@@ -81,3 +88,165 @@ fn pad_smooth_camera_binding_toggles_the_cinematic_camera() {
         assert!(game.smooth_camera, "as its key does in play");
     });
 }
+
+/// A player at the origin: the wheel's gates ask for one.
+fn with_player(game: &mut Game) {
+    game.player = Some(PlayerMotion::new(game.motion, Vec3::ZERO).unwrap());
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn bumpers_step_the_hotbar_where_the_wheel_does() {
+    playing(|game| {
+        game.selected = 8;
+        game.pad_action("pad.hotbarNext", true).unwrap();
+        assert_eq!(game.selected, 8, "no player, no hotbar");
+        with_player(game);
+        game.pad_action("pad.hotbarNext", true).unwrap();
+        assert_eq!(game.selected, 0, "wraps past the last slot");
+        game.pad_action("pad.hotbarPrevious", true).unwrap();
+        assert_eq!(game.selected, 8, "and back");
+        game.pad_action("pad.hotbarNext", false).unwrap();
+        assert_eq!(game.selected, 8, "a release does nothing");
+        game.screen = Screen::Paused;
+        game.pad_action("pad.hotbarNext", true).unwrap();
+        assert_eq!(game.selected, 8, "a screen keeps the wheel from the hotbar");
+    });
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn a_spectators_bumpers_set_the_flying_speed_as_the_wheel_does() {
+    playing(|game| {
+        with_player(game);
+        game.mode = GameMode::Spectator;
+        game.selected = 3;
+        let speed = game.player.as_ref().unwrap().flying_speed;
+        game.pad_action("pad.hotbarPrevious", true).unwrap();
+        // One wheel notch up: `MouseHandler.onScroll` adds 0.005.
+        let after = game.player.as_ref().unwrap().flying_speed;
+        assert!((after - speed - 0.005).abs() < 1e-6, "{speed} -> {after}");
+        assert_eq!(game.selected, 3, "a spectator's hotbar doesn't step");
+    });
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn readers_of_the_movement_keys_see_the_stick() {
+    playing(|game| {
+        game.focused = true;
+        assert!(!game.native_mapping("key.forward").unwrap().0);
+        // Up and to the left, on a diagonal: two keys, as a keyboard would hold.
+        game.pad.state.left = [-0.7, 0.7];
+        assert!(game.native_mapping("key.forward").unwrap().0);
+        assert!(game.native_mapping("key.left").unwrap().0);
+        assert!(!game.native_mapping("key.back").unwrap().0);
+        assert!(!game.native_mapping("key.right").unwrap().0);
+        assert!(
+            !game.native_mapping("key.jump").unwrap().0,
+            "the stick holds only the movement keys"
+        );
+        // A screen takes the stick away.
+        game.screen = Screen::Paused;
+        assert!(!game.native_mapping("key.forward").unwrap().0);
+    });
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn pad_number_actions_select_the_hotbar_as_their_keys_do() {
+    playing(|game| {
+        with_player(game);
+        game.settings
+            .controller
+            .bind("key.hotbar.3", Some(Button::DPadUp));
+        pad_press(game, Button::DPadUp, "key.hotbar.3");
+        assert_eq!(game.hotbar_presses, [2]);
+    });
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn a_held_pad_toolbar_action_counts_as_the_toolbar_key() {
+    playing(|game| {
+        game.settings
+            .controller
+            .bind("key.saveToolbarActivator", Some(Button::DPadUp));
+        assert!(!game.mapped_key_down("key.saveToolbarActivator"));
+        pad_press(game, Button::DPadUp, "key.saveToolbarActivator");
+        assert!(game.mapped_key_down("key.saveToolbarActivator"));
+        assert!(!game.mapped_key_down("key.loadToolbarActivator"));
+    });
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn the_pads_attack_and_use_reach_what_the_mouse_tells_mods() {
+    playing(|game| {
+        assert_eq!(game.native_clicks(), (0, 0));
+        pad_press(game, Button::RightTrigger, "key.attack");
+        assert!(game.native_mapping("key.attack").unwrap().0);
+        assert_eq!(game.native_clicks(), (1, 0));
+        game.pad_action("key.attack", false).unwrap();
+        assert!(!game.native_mapping("key.attack").unwrap().0);
+        pad_press(game, Button::LeftTrigger, "key.use");
+        assert!(game.native_mapping("key.use").unwrap().0);
+        assert_eq!(game.native_clicks(), (1, 1));
+    });
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn the_mouse_letting_go_leaves_what_the_pad_holds_and_back() {
+    playing(|game| {
+        game.mouse_mapping(MouseButton::Left, true, Source::Keyboard)
+            .unwrap();
+        pad_press(game, Button::RightTrigger, "key.attack");
+        game.mouse_mapping(MouseButton::Left, false, Source::Keyboard)
+            .unwrap();
+        assert!(game.left, "the pad still holds the attack");
+        // The pad let go, so its edges are no longer held either.
+        game.pad.edges.update(&PadState::default(), 0.4);
+        game.pad_action("key.attack", false).unwrap();
+        assert!(!game.left);
+
+        // The other way round: the mouse button is physically down.
+        game.physical_buttons.insert(MouseButton::Right);
+        game.mouse_mapping(MouseButton::Right, true, Source::Keyboard)
+            .unwrap();
+        pad_press(game, Button::LeftTrigger, "key.use");
+        game.pad.edges.update(&PadState::default(), 0.4);
+        game.pad_action("key.use", false).unwrap();
+        assert!(game.right, "the mouse still holds the use");
+        game.physical_buttons.remove(&MouseButton::Right);
+        game.mouse_mapping(MouseButton::Right, false, Source::Keyboard)
+            .unwrap();
+        assert!(!game.right);
+    });
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn a_release_from_a_screen_can_not_strand_the_pads_attack() {
+    playing(|game| {
+        // The mouse went down in play, and came up where the mappings didn't hear it.
+        game.mouse_mapping(MouseButton::Left, true, Source::Keyboard)
+            .unwrap();
+        game.left = false;
+        pad_press(game, Button::RightTrigger, "key.attack");
+        assert!(game.left);
+        game.pad.edges.update(&PadState::default(), 0.4);
+        game.pad_action("key.attack", false).unwrap();
+        assert!(!game.left, "nothing is physically held");
+    });
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn keyboard_handoff_keeps_the_attack_the_pad_holds() {
+    playing(|game| {
+        pad_press(game, Button::RightTrigger, "key.attack");
+        game.release_keyboard_mouse();
+        assert!(game.left);
+    });
+}
diff --git a/crates/horizon-client/src/game/pad_actions.rs b/crates/horizon-client/src/game/pad_actions.rs
index 0ab89cfb37..1684734c0c 100644
--- a/crates/horizon-client/src/game/pad_actions.rs
+++ b/crates/horizon-client/src/game/pad_actions.rs
@@ -3,9 +3,9 @@
 //! here names one (docs/controllers.md, "Adding a screen").
 use super::{Game, Screen};
 use horizon_client::{
-    gamepad::{Button, GlyphStyle},
-    hud::{HudAtlas, HudBatch, rgba},
-    lang,
+    gamepad::Button,
+    hud::HudBatch,
+    lang, pad_glyph,
     widgets::{self, Action, DeclaredAction, Kind, Target},
 };
 
@@ -43,7 +43,7 @@ fn glyph_at(
     right: bool,
 ) -> Option<(f32, f32)> {
     const INSET: f32 = 4.0;
-    let fits = w >= wide + 2.0 * INSET && h >= 11.0;
+    let fits = w >= wide + 2.0 * INSET && h >= pad_glyph::HEIGHT;
     let shown = x >= 0.0 && y >= 0.0 && x + w <= view_w && y + h <= view_h;
     (fits && shown).then(|| {
         let at = if right {
@@ -55,25 +55,12 @@ fn glyph_at(
     })
 }
 
-/// The button as printed on the pad, in its colour, on a dark key.
-fn draw_glyph(
-    batch: &mut HudBatch,
-    atlas: &HudAtlas,
-    button: Button,
-    style: GlyphStyle,
-    x: f32,
-    y: f32,
-) {
-    let (label, [r, g, b]) = (button.label(style), button.color(style));
-    let width = HudBatch::text_width(atlas, label).ceil() + 4.0;
-    let color = rgba(r, g, b, 255);
-    horizon_client::controller_notice::key(batch, atlas, label, color, x, y, width);
-}
-
 impl Game<'_> {
-    /// A key row waits for its key: B is Escape, which unbinds; its buttons aren't pressed.
-    fn pad_binding(&self) -> bool {
-        self.screen == Screen::Options
+    /// A key row waits for its key: B is Escape, which unbinds; its buttons aren't pressed. A
+    /// prompt over the row has the buttons first.
+    pub(super) fn pad_binding(&self) -> bool {
+        !self.prompt_open()
+            && self.screen == Screen::Options
             && (self.options_waiting_for_key() || self.ui.options.selected_pad_action.is_some())
     }
 
@@ -128,7 +115,7 @@ impl Game<'_> {
         }
         let focus = self.pad.menu.focus.filter(|_| self.pad_focus_mode());
         let (atlas, style) = (&self.gui.atlas, self.ui.options.pad_style);
-        let width = |button: Button| HudBatch::text_width(atlas, button.label(style)).ceil() + 4.0;
+        let width = |button: Button| pad_glyph::width(atlas, button, style);
         let mut glyphs = Vec::new();
         // A on a text field opens the keyboard: at its right end, its text stays in view.
         if let Some(focus) = focus.filter(|f| f.kind == Kind::Field)
@@ -156,16 +143,25 @@ impl Game<'_> {
     pub(super) fn draw_pad_action_glyphs(&self, batch: &mut HudBatch) {
         let (atlas, style) = (&self.gui.atlas, self.ui.options.pad_style);
         for (button, x, y) in self.pad_glyphs((batch.width, batch.height)) {
-            draw_glyph(batch, atlas, button, style, x, y);
+            pad_glyph::draw(batch, atlas, button, style, x, y);
         }
     }
 
-    /// `pad status`: the glyphs drawn now and where.
+    /// `pad status`: the glyphs drawn now and where: its text's place, what it covers, and its
+    /// sprite (none: the label on a key).
     pub(super) fn pad_glyphs_status(&self) -> Vec<serde_json::Value> {
         let view = self.gui_scale().map_or((0.0, 0.0), |b| (b.width, b.height));
+        let (atlas, style) = (&self.gui.atlas, self.ui.options.pad_style);
         self.pad_glyphs(view)
             .iter()
-            .map(|(button, x, y)| serde_json::json!({ "button": format!("{button:?}"), "at": [x, y] }))
+            .map(|&(button, x, y)| {
+                serde_json::json!({
+                    "button": format!("{button:?}"),
+                    "at": [x, y],
+                    "rect": pad_glyph::rect(atlas, button, style, x, y),
+                    "sprite": pad_glyph::art(atlas, button, style),
+                })
+            })
             .collect()
     }
 
@@ -259,6 +255,23 @@ mod tests {
         assert_eq!(does(Button::North, &pause), Some(Action::Exit));
     }
 
+    #[test]
+    fn a_face_glyph_on_a_button_stays_clear_of_its_label() {
+        let (x, y) = glyph_at(
+            [10.0, 20.0, 150.0, 20.0],
+            pad_glyph::FACE_WIDTH,
+            (640.0, 480.0),
+            false,
+        )
+        .unwrap();
+        // Vertically inside the button, ending before the label's left (its x + 2 + room).
+        assert_eq!((y - 2.0, y - 2.0 + pad_glyph::HEIGHT), (24.0, 36.0));
+        widgets::set_action_glyphs(true);
+        let label_left = 10.0 + 2.0 + widgets::action_glyph_room();
+        widgets::set_action_glyphs(false);
+        assert!(x - 1.0 + pad_glyph::FACE_WIDTH < label_left);
+    }
+
     #[test]
     fn a_glyph_goes_on_a_button_it_fits_in_the_view() {
         let view = (320.0, 240.0);
@@ -269,6 +282,12 @@ mod tests {
         // Too narrow, too short, running off a small split view.
         assert_eq!(glyph_at([10.0, 20.0, 15.0, 20.0], 10.0, view, false), None);
         assert_eq!(glyph_at([10.0, 20.0, 150.0, 8.0], 10.0, view, false), None);
+        // Art as tall as the row fits; a row any shorter would clip it.
+        assert_eq!(
+            glyph_at([10.0, 20.0, 150.0, 12.0], 12.0, view, false),
+            Some((14.0, 22.0))
+        );
+        assert_eq!(glyph_at([10.0, 20.0, 150.0, 11.0], 12.0, view, false), None);
         assert_eq!(glyph_at(button, 10.0, (120.0, 240.0), false), None);
     }
 
diff --git a/crates/horizon-client/src/game/pad_menu.rs b/crates/horizon-client/src/game/pad_menu.rs
index 380cc00ef6..9de47233ea 100644
--- a/crates/horizon-client/src/game/pad_menu.rs
+++ b/crates/horizon-client/src/game/pad_menu.rs
@@ -20,6 +20,7 @@ use super::{
     Game, Screen,
     key_focus::{self, Act},
 };
+use horizon_client::actions::Action;
 use horizon_client::{
     Result,
     creative::Creative,
@@ -59,6 +60,22 @@ struct Pending {
     amount: Option<f32>,
 }
 
+/// What the focused widget is called (`widgets::slug`), found again by that when it moves: a list
+/// scrolled another row into its place, a filter or a new layout moved it.
+#[derive(Clone)]
+struct FocusName {
+    screen: u64,
+    /// The focus it was read from: once the focus is elsewhere, it isn't this one's name.
+    rect: Rect,
+    name: String,
+}
+
+/// The focus the pad left a screen on (`MenuCursor::remembered`).
+struct Remembered {
+    rect: Rect,
+    name: Option<String>,
+}
+
 /// The targets at the screen size they were drawn for, to carry the focus or the
 /// crosshair over when that changes (a window resize, the GUI scale).
 struct Layout {
@@ -152,9 +169,17 @@ pub(super) struct MenuCursor {
     key_restart: Option<u64>,
     /// The pad's focus on each screen it left (`Game::key_screen`), so coming
     /// back lands where it was, as vanilla keeps a screen's focused widget.
-    remembered: std::collections::HashMap<u64, Rect>,
+    remembered: std::collections::HashMap<u64, Remembered>,
     /// The frame drawn when the pad last left a screen.
     left_screen: u64,
+    /// The focused widget's name, while it has one of its own.
+    focus_name: Option<FocusName>,
+    /// Which prompt is up (`Game::pad_prompt_key`).
+    prompt: Option<u64>,
+    /// The frame drawn when one came or went: the focus starts again once it shows.
+    prompt_restart: Option<u64>,
+    /// The screen and the place the crosshair goes back to when the prompt over it closes.
+    prompt_crosshair: Option<(Screen, (f32, f32))>,
 }
 
 impl MenuCursor {
@@ -169,6 +194,17 @@ impl MenuCursor {
     }
 }
 
+/// The target of the one widget called `name` (`widgets::slug`). None when several are: the
+/// rectangles have to tell them apart.
+fn named_target(name: &str, labelled: &[widgets::Widget], rects: &[Rect]) -> Option<usize> {
+    let mut same = labelled.iter().filter(|w| widgets::slug(&w.label) == name);
+    let w = same.next().filter(|_| same.next().is_none())?;
+    let rect = [w.x, w.y, w.w, w.h];
+    rects
+        .iter()
+        .position(|r| r.iter().zip(&rect).all(|(a, b)| (a - b).abs() < 0.5))
+}
+
 /// How far the list holding `rect` is scrolled.
 fn list_amount(areas: &[gamepad::ScrollArea], rect: &Rect) -> Option<f32> {
     areas.iter().find(|a| a.holds(rect)).map(|a| a.amount)
@@ -209,12 +245,76 @@ impl Game<'_> {
     /// A menu, a screen, the title, a sign or a book is open: the pad drives
     /// it instead of the player.
     pub(super) fn pad_in_menu(&self) -> bool {
+        self.key_focus_screen() || self.prompt_open()
+    }
+
+    /// A screen the keyboard's focus can drive is open. A prompt over the world isn't one: its
+    /// keys are its own.
+    fn key_focus_screen(&self) -> bool {
         self.title.is_some()
             || self.screen != Screen::Playing
             || self.sign_edit.is_some()
             || self.book.is_some()
     }
 
+    /// Which prompt is up: another one starts the controller's focus again.
+    fn pad_prompt_key(&self) -> Option<u64> {
+        use std::hash::{Hash, Hasher};
+        if !self.prompt_open() {
+            return None;
+        }
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        (
+            self.command_prompt.is_some(),
+            self.link_prompt.is_some(),
+            self.code_of_conduct.is_some(),
+            self.server_packs.prompt.is_some(),
+        )
+            .hash(&mut hasher);
+        self.dialog_screen_key().hash(&mut hasher);
+        Some(hasher.finish())
+    }
+
+    /// B or Start on a prompt: as Escape, the top one first. The code of conduct has no answer
+    /// by Escape (`shouldCloseOnEsc`), and a dialog only when it allows it.
+    pub(super) fn pad_prompt_back(&mut self) -> Result<()> {
+        if self.command_prompt.is_some() {
+            self.answer_command_prompt(false);
+        } else if self.link_prompt.is_some() {
+            self.answer_link_prompt(false);
+        } else if self.code_of_conduct.is_some() {
+        } else if self.server_packs.prompt.is_some() {
+            self.answer_pack_prompt(false)?;
+        } else {
+            self.dialog_key(KeyCode::Escape, None, None)?;
+        }
+        Ok(())
+    }
+
+    /// Where the focus starts on a prompt: on what answers no, when it has that, so a press meant
+    /// for the game can't accept anything. A dialog with text to fill in starts on its first
+    /// input; its warning icon comes last.
+    fn pad_prompt_first(&self, targets: &[Target]) -> Option<Target> {
+        use widgets::Action;
+        if !self.dialog_starts_typing() {
+            let declared = widgets::last_actions(self.key_screen());
+            let no = declared
+                .iter()
+                .filter(|d| d.enabled && matches!(d.action, Action::Cancel | Action::Back))
+                .find_map(|d| targets.iter().find(|t| t.rect == d.rect));
+            if let Some(no) = no {
+                return Some(*no);
+            }
+        }
+        let warning = self.dialog_warning_icon();
+        let rest: Vec<Target> = targets
+            .iter()
+            .filter(|t| Some(t.rect) != warning)
+            .copied()
+            .collect();
+        key_focus::tab_step(&rest, None, true).map(|i| rest[i])
+    }
+
     pub(super) fn gui_scale(&self) -> Option<HudBatch> {
         self.renderer
             .as_ref()
@@ -226,12 +326,16 @@ impl Game<'_> {
     /// target (the advancements map, the statistics lists, the pack rows, a
     /// book's page text), where the pointer does (the keyboard always focuses).
     pub(super) fn pad_navigation_mode(&self) -> bool {
-        let pointer = matches!(
+        self.prompt_open() || !self.pad_pointer_screen()
+    }
+
+    /// The open screen is one the crosshair drives, whatever is over it.
+    fn pad_pointer_screen(&self) -> bool {
+        matches!(
             self.screen,
             Screen::Inventory | Screen::Creative | Screen::Stats | Screen::Advancements
         ) || self.book.is_some()
-            || (self.screen == Screen::Options && self.ui.options.page() == Page::Packs);
-        !pointer
+            || (self.screen == Screen::Options && self.ui.options.page() == Page::Packs)
     }
 
     pub(super) fn pad_focus_mode(&self) -> bool {
@@ -272,7 +376,11 @@ impl Game<'_> {
 
     fn pad_all_targets(&self) -> Vec<Target> {
         let mut targets = key_focus::drawn_targets();
-        if self.title.is_some() || self.sign_edit.is_some() || self.book.is_some() {
+        if self.title.is_some()
+            || self.sign_edit.is_some()
+            || self.book.is_some()
+            || self.prompt_open()
+        {
             return targets;
         }
         let Some(batch) = self.gui_scale() else {
@@ -344,15 +452,24 @@ impl Game<'_> {
             // Screen.setInitialFocus: a forward Tab from nothing.
             return key_focus::tab_step(targets, None, true).map(|i| targets[i]);
         }
+        if self.prompt_open() {
+            return self.pad_prompt_first(targets).or(targets.first().copied());
+        }
         // Back on a screen the pad left: where it was, as vanilla keeps a
-        // screen's focused widget (Options, after its Done).
+        // screen's focused widget (Options, after its Done). The same widget
+        // first: the rows under it can have moved.
         let rects: Vec<Rect> = targets.iter().map(|t| t.rect).collect();
         if let Some(i) = self
             .pad
             .menu
             .remembered
             .get(&self.key_screen())
-            .and_then(|r| gamepad::refind(*r, &rects, 2.0))
+            .and_then(|r| {
+                r.name
+                    .as_ref()
+                    .and_then(|n| named_target(n, &widgets::last_labelled(), &rects))
+                    .or_else(|| gamepad::refind(r.rect, &rects, 2.0))
+            })
         {
             return Some(targets[i]);
         }
@@ -619,8 +736,11 @@ impl Game<'_> {
         }
         // The pad takes the focus back from the keyboard.
         self.pad.menu.keyboard = false;
-        // Controller Binds waiting for a button: this one (Start cancels).
-        if self.screen == Screen::Options
+        // A prompt over the screen answers first; no press reaches both.
+        let prompt = self.prompt_open();
+        // Bindings waiting for a button: this one (Start cancels).
+        if !prompt
+            && self.screen == Screen::Options
             && self.ui.options.controller_open()
             && let Some(action) = self.ui.options.selected_pad_action.take()
         {
@@ -629,9 +749,14 @@ impl Game<'_> {
             }
             return self.handle_option_events(vec![Event::Changed]);
         }
+        // A key row waiting for its key takes a mouse button: anything that clicks would bind it.
+        // B or Start is Escape, which unbinds (`pad_back`).
+        if self.pad_binding() && !matches!(button, Button::East | Button::Start) {
+            return Ok(());
+        }
         // Splitscreen Setup: A picks up the focused player's tile, then left/right (or LB/RB)
         // cycle where it goes, A drops it, B puts it back (`split_ui`).
-        if self.screen == Screen::Options && self.ui.options.page() == Page::SplitSetup {
+        if !prompt && self.screen == Screen::Options && self.ui.options.page() == Page::SplitSetup {
             let setup = &mut self.ui.options.split_setup;
             if setup.pad_button(button) {
                 // Dropped or put back: the focus follows the player to its tile.
@@ -671,6 +796,21 @@ impl Game<'_> {
             }
             return Ok(());
         }
+        // A prompt has its focus and B: the screen behind it has none of its buttons now.
+        if prompt
+            && !matches!(
+                button,
+                Button::South
+                    | Button::East
+                    | Button::Start
+                    | Button::DPadUp
+                    | Button::DPadDown
+                    | Button::DPadLeft
+                    | Button::DPadRight
+            )
+        {
+            return Ok(());
+        }
         // A with nothing focused lands the focus, as the D-pad does: nothing
         // fires on a widget the player hasn't seen highlighted.
         if button == Button::South && self.pad_focus_mode() && self.pad.menu.focus.is_none() {
@@ -716,7 +856,7 @@ impl Game<'_> {
             // Y in an inventory: a shift-click (quick move).
             Button::North if matches!(self.screen, Screen::Inventory | Screen::Creative) => {
                 self.pad_take_pointer(event_loop);
-                let in_keys = self.keys.contains(&KeyCode::ShiftLeft);
+                let in_keys = self.keys.held(Action::Sneak);
                 self.keys.insert(KeyCode::ShiftLeft);
                 self.pad_with_modifier(KeyCode::ShiftLeft, |game| {
                     game.pad_pointer_button(event_loop, false, true);
@@ -768,8 +908,13 @@ impl Game<'_> {
             keyboard.step(button);
             return;
         }
+        // A slider's step is a click, which a waiting key row would bind.
+        if self.pad_binding() {
+            return;
+        }
         // Splitscreen Setup with a player held: the stick cycles it as the D-pad does.
-        if self.screen == Screen::Options
+        if !self.prompt_open()
+            && self.screen == Screen::Options
             && self.ui.options.page() == Page::SplitSetup
             && self.ui.options.split_setup.holding()
         {
@@ -986,11 +1131,13 @@ impl Game<'_> {
         if self.pad.menu.shortcut_focus.take() == Some(focus.rect) {
             return;
         }
+        let name = self.pad_focus_name();
         let remembered = &mut self.pad.menu.remembered;
         if remembered.len() > 32 && !remembered.contains_key(&screen) {
             remembered.clear();
         }
-        remembered.insert(screen, focus.rect);
+        let rect = focus.rect;
+        remembered.insert(screen, Remembered { rect, name });
     }
 
     /// Vanilla's arrow navigation moves a screen's focus off the widget a
@@ -1124,6 +1271,10 @@ impl Game<'_> {
             menu.nudge = None;
             menu.osk = None;
             menu.osk_dismissed = false;
+            menu.focus_name = None;
+            menu.prompt = None;
+            menu.prompt_restart = None;
+            menu.prompt_crosshair = None;
             self.pad_show_os_pointer(true);
             return;
         }
@@ -1156,7 +1307,8 @@ impl Game<'_> {
         };
         let focusing = focus_mode && !targets.is_empty();
         let resizing = self.pad_follow_resize(event_loop);
-        if focusing && !resizing && !self.key_focus_restart(event_loop, &targets) {
+        let restarting = self.pad_prompt_frame(&targets);
+        if focusing && !resizing && !restarting && !self.key_focus_restart(event_loop, &targets) {
             self.pad_follow_focus(event_loop, &targets);
         }
         let (move_deadzone, look_deadzone) = (
@@ -1259,6 +1411,60 @@ impl Game<'_> {
         self.pad_show_os_pointer(self.pad.menu.pos.is_none() || self.pad.menu.keyboard);
     }
 
+    /// Each poll: a prompt came up or went away. The keyboard was typing into what was open, and
+    /// the focus starts again once the new frame shows: nothing pressed on one screen lands on
+    /// the other. A keyboard a prompt took from chat or a sign opens again after it
+    /// (`pad_auto_keyboard`), and the crosshair goes back to where it was. Whether the focus is
+    /// waiting for that frame.
+    fn pad_prompt_frame(&mut self, targets: &[Target]) -> bool {
+        let prompt = self.pad_prompt_key();
+        if prompt != self.pad.menu.prompt {
+            let pointer_screen = self.pad_pointer_screen();
+            let (screen, cursor) = (self.screen, self.cursor);
+            let menu = &mut self.pad.menu;
+            let opened = menu.prompt.is_none();
+            menu.prompt = prompt;
+            if menu.osk.take().is_some() && opened {
+                menu.osk_dismissed = false;
+            }
+            if menu.keyboard {
+                menu.prompt_crosshair = None;
+            } else {
+                if opened && pointer_screen && menu.pos.is_some() && menu.prompt_crosshair.is_none()
+                {
+                    let at = menu.glide.map_or(cursor, |(_, to, _)| to);
+                    menu.prompt_crosshair = Some((screen, at));
+                }
+                menu.focus = None;
+                menu.armed = None;
+                menu.pending = None;
+                menu.nudge = None;
+                menu.stick_scrolled = None;
+                menu.prompt_restart = Some(widgets::generation());
+            }
+        }
+        let Some(changed_at) = self.pad.menu.prompt_restart else {
+            return false;
+        };
+        // Two frames on: the first may have been drawn before it changed.
+        if widgets::generation() <= changed_at + 1 {
+            return true;
+        }
+        self.pad.menu.prompt_restart = None;
+        if self.pad.menu.pos.is_some() && !targets.is_empty() {
+            self.pad.menu.focus = self.pad_first_target(targets);
+        }
+        if self.pad.menu.prompt.is_none()
+            && let Some((screen, at)) = self.pad.menu.prompt_crosshair.take()
+            && screen == self.screen
+            && self.pad.menu.pos.is_some()
+            && !self.pad_focus_mode()
+        {
+            self.pad_glide_to(at);
+        }
+        false
+    }
+
     /// Each poll: the screen's size changed (a window resize, the GUI scale), so
     /// once its new layout is drawn, the focus and the crosshair go on from the
     /// same widget. Too far for `pad_follow_focus` and `snap::follow`, which it
@@ -1302,15 +1508,10 @@ impl Game<'_> {
         self.pad.menu.nudge = None;
         self.pad.menu.anchors = None;
         if self.pad_focus_mode() {
-            let named = layout.focus_name.take().and_then(|name| {
-                let labelled = widgets::last_labelled();
-                let mut same = labelled.iter().filter(|w| widgets::slug(&w.label) == name);
-                let w = same.next().filter(|_| same.next().is_none())?;
-                let rect = [w.x, w.y, w.w, w.h];
-                rects
-                    .iter()
-                    .position(|r| r.iter().zip(&rect).all(|(a, b)| (a - b).abs() < 0.5))
-            });
+            let named = layout
+                .focus_name
+                .take()
+                .and_then(|name| named_target(&name, &widgets::last_labelled(), &rects));
             self.pad.menu.focus = named
                 .or_else(|| self.pad.menu.focus.and_then(|focus| found(focus.rect)))
                 .map(|i| targets[i]);
@@ -1349,6 +1550,16 @@ impl Game<'_> {
                     && (l.h - h).abs() < 0.5
             })
             .map(|l| widgets::slug(&l.label))
+            .filter(|name| !name.is_empty())
+    }
+
+    /// The focused widget where its name says it is now, on the screen and from the focus the
+    /// name was read from. The keyboard's focus keeps to the rectangles it always followed.
+    fn pad_named_focus(&self, focus: Target, rects: &[Rect]) -> Option<usize> {
+        let named = self.pad.menu.focus_name.as_ref().filter(|n| {
+            !self.pad.menu.keyboard && n.rect == focus.rect && n.screen == self.key_screen()
+        })?;
+        named_target(&named.name, &widgets::last_labelled(), rects)
     }
 
     /// Pointer mode, each poll: the targets moved out from under a resting
@@ -1432,6 +1643,7 @@ impl Game<'_> {
         } else if ready.is_none() {
             if let Some(focus) = self.pad.menu.focus {
                 let kind = std::mem::discriminant(&focus.kind);
+                let named = self.pad_named_focus(focus, &rects);
                 let followed = stick_scrolled.and_then(|s| {
                     // Its scrollbar knows how far, when the rows land on each other's places.
                     let areas = widgets::last_scroll_areas();
@@ -1448,7 +1660,9 @@ impl Game<'_> {
                         .collect();
                     gamepad::follow_scroll(focus.rect, s.down, &s.before, &after)
                 });
-                self.pad.menu.focus = followed
+                // The widget itself, wherever it went; else where its rectangle says.
+                self.pad.menu.focus = named
+                    .or(followed)
                     .or_else(|| gamepad::refind(focus.rect, &rects, 12.0))
                     .map(|i| targets[i]);
                 if self.pad.menu.focus.is_none() && self.pad.menu.pos.is_some() {
@@ -1476,10 +1690,18 @@ impl Game<'_> {
             } else if self.pad.menu.pos.is_some() {
                 // The pad drives but nothing is focused (switched from the pointer).
                 let centres: Vec<(f32, f32)> = targets.iter().map(Target::center).collect();
-                self.pad.menu.focus =
-                    gamepad::nearest(self.cursor, &centres, f32::INFINITY).map(|i| targets[i]);
+                self.pad.menu.focus = if self.prompt_open() {
+                    self.pad_first_target(targets)
+                } else {
+                    gamepad::nearest(self.cursor, &centres, f32::INFINITY).map(|i| targets[i])
+                };
             }
         }
+        self.pad.menu.focus_name = self.pad.menu.focus.and_then(|focus| {
+            let name = self.pad_focus_name()?;
+            let (screen, rect) = (self.key_screen(), focus.rect);
+            Some(FocusName { screen, rect, name })
+        });
         let Some(focus) = self.pad.menu.focus else {
             return;
         };
@@ -1543,7 +1765,7 @@ impl Game<'_> {
                 .menu
                 .remembered
                 .iter()
-                .map(|(k, r)| (format!("{k:016x}"), serde_json::json!(r)))
+                .map(|(k, r)| (format!("{k:016x}"), serde_json::json!(r.rect)))
                 .collect::<serde_json::Map<_, _>>(),
         })
     }
@@ -1568,7 +1790,7 @@ impl Game<'_> {
 
     /// The keyboard drives the open menu's focus.
     pub(super) fn key_focus_driving(&self) -> bool {
-        self.pad.menu.keyboard && self.pad_in_menu()
+        self.pad.menu.keyboard && self.key_focus_screen()
     }
 
     /// A pointer event the keyboard sends (a press, the hidden pointer on
@@ -1619,7 +1841,7 @@ impl Game<'_> {
         let Some(nav) = key_focus::nav_of(key, self.has_shift_down()) else {
             return false;
         };
-        if !self.pad_in_menu() || self.key_focus_blocked() {
+        if !self.key_focus_screen() || self.key_focus_blocked() {
             return false;
         }
         let targets = self.key_targets();
@@ -1718,11 +1940,7 @@ impl Game<'_> {
             .map(|t| t.screen_key())
             .hash(&mut hasher);
         (self.sign_edit.is_some(), self.book.is_some()).hash(&mut hasher);
-        (
-            self.link_prompt.is_some() || self.command_prompt.is_some(),
-            self.server_packs.prompt.is_some(),
-        )
-            .hash(&mut hasher);
+        self.pad_prompt_key().hash(&mut hasher);
         hasher.finish()
     }
 
@@ -1824,7 +2042,7 @@ impl Game<'_> {
     /// Only a press accepted by ScreenEvent.Pre may focus the widget under it.
     pub(super) fn key_focus_mouse_press(&mut self, event: &WindowEvent) {
         if !self.pad.menu.synthetic
-            && self.pad_in_menu()
+            && self.key_focus_screen()
             && matches!(
                 event,
                 WindowEvent::MouseInput {
@@ -1875,7 +2093,7 @@ impl Game<'_> {
         let Some(origin) = self.pad.menu.origin else {
             return;
         };
-        let there = self.pad_in_menu()
+        let there = self.key_focus_screen()
             && self
                 .key_targets()
                 .iter()
@@ -1902,7 +2120,8 @@ impl Game<'_> {
 
     /// A text field has keyboard focus: chat, a sign, a book being written,
     /// a search box, the anvil's name, the title screens' and the options'
-    /// fields, the LAN port.
+    /// fields, the LAN port, a dialog's input, the command box and the edit
+    /// screens of the jigsaw, structure and test blocks.
     fn pad_typing(&self) -> bool {
         (self.screen == Screen::Chat && self.title.is_none())
             || self.sign_edit.is_some()
@@ -1910,6 +2129,12 @@ impl Game<'_> {
             || (self.screen == Screen::Creative && self.creative_screen.tab().search)
             || self.recipe_search_focused()
             || self.station_typing()
+            || self.dialog_typing()
+            || self.mod_browser_typing()
+            || matches!(
+                self.screen,
+                Screen::CommandBlock | Screen::BlockEditor | Screen::Social | Screen::DebugOptions
+            )
     }
 
     /// Open the on-screen keyboard over the focused field: Horizon's, or
@@ -1942,7 +2167,9 @@ impl Game<'_> {
             menu.osk_dismissed,
             self.pad.in_use,
             menu.open_polls,
-            (self.screen == Screen::Chat && !self.ui.in_bed_chat) || self.sign_edit.is_some(),
+            !self.prompt_open()
+                && ((self.screen == Screen::Chat && !self.ui.in_bed_chat)
+                    || self.sign_edit.is_some()),
         ) {
             self.pad.menu.osk_dismissed = true;
             self.pad_open_keyboard();
@@ -1964,7 +2191,22 @@ impl Game<'_> {
             }
         };
         let backspace = key == Some(KeyCode::Backspace);
-        if self.screen == Screen::Chat && self.title.is_none() {
+        if self.dialog_open() {
+            // Over whatever else is open. Enter only ends the typing, but for a new line.
+            let result = match text {
+                Some(t) => {
+                    self.dialog_type(t);
+                    Ok(())
+                }
+                None if backspace || self.dialog_typing_lines() => {
+                    self.dialog_key(key.expect("a key"), None, None)
+                }
+                None => Ok(()),
+            };
+            if let Err(e) = result {
+                log::warn!("Horizon: on-screen keyboard: {e}");
+            }
+        } else if self.screen == Screen::Chat && self.title.is_none() {
             match text {
                 Some(t) => self.chat_type(t),
                 None => self.chat_key_code(key.expect("a key"), None),
@@ -1979,6 +2221,10 @@ impl Game<'_> {
             } else if key != Some(KeyCode::Enter) {
                 self.creative_search_edit(text);
             }
+        } else if self.mod_browser_typing() {
+            if key != Some(KeyCode::Enter) {
+                self.mod_browser_text(text, backspace);
+            }
         } else if self.recipe_search_focused() {
             if key != Some(KeyCode::Enter) {
                 self.recipe_text(text, backspace);
@@ -1991,6 +2237,29 @@ impl Game<'_> {
             if key != Some(KeyCode::Enter) {
                 self.world_options_text(text);
             }
+        } else if self.screen == Screen::CommandBlock {
+            // Enter is its Done, as on the keyboard.
+            match text {
+                Some(t) => self.command_block_type(t),
+                None => self.command_block_key_code(key.expect("a key"), None, None),
+            }
+        } else if self.screen == Screen::BlockEditor {
+            match text {
+                Some(t) => self.block_editor_type(t),
+                None => self.block_editor_key_code(key.expect("a key"), None, None),
+            }
+        } else if self.screen == Screen::Social {
+            match text {
+                Some(t) => self.social_type(t),
+                None if backspace => self.social_backspace(),
+                None => {}
+            }
+        } else if self.screen == Screen::DebugOptions {
+            match text {
+                Some(t) => self.debug_options_type(t),
+                None if backspace => self.debug_options_backspace(),
+                None => {}
+            }
         } else if self.screen == Screen::Options {
             let result = match text {
                 Some(t) => {
@@ -2013,8 +2282,9 @@ impl Game<'_> {
                 _ => self.title_edit(text, false),
             }
         }
-        // Enter ends the typing; a field that closed with it closes the keyboard.
-        if key == Some(KeyCode::Enter)
+        // Enter ends the typing, but for a dialog's new line; a field that
+        // closed with it closes the keyboard.
+        if (key == Some(KeyCode::Enter) && !self.dialog_typing_lines())
             || (!self.pad_typing()
                 && self.title.is_none()
                 && !matches!(self.screen, Screen::Options | Screen::WorldOptions))
@@ -2133,6 +2403,37 @@ mod tests {
         assert!(!osk_auto_opens(false, false, true, 5, false));
     }
 
+    fn labelled(label: &str, rect: Rect) -> widgets::Widget {
+        let [x, y, w, h] = rect;
+        widgets::Widget {
+            label: label.to_owned(),
+            x,
+            y,
+            w,
+            h,
+            enabled: true,
+            kind: Kind::Button,
+        }
+    }
+
+    #[test]
+    fn a_named_widget_is_found_wherever_it_moved() {
+        let (first, second) = ([10.0, 40.0, 100.0, 20.0], [10.0, 64.0, 100.0, 20.0]);
+        let labels = [labelled("FOV: 80", second), labelled("Done", first)];
+        // Its value changed its label and another row took its place: the name still finds it.
+        assert_eq!(named_target("fov", &labels, &[first, second]), Some(1));
+        // Clipped away: no target where the label says, so the rectangles decide.
+        assert_eq!(named_target("fov", &labels, &[first]), None);
+        assert_eq!(named_target("music", &labels, &[first, second]), None);
+    }
+
+    #[test]
+    fn two_widgets_of_one_name_leave_it_to_the_rectangles() {
+        let (first, second) = ([10.0, 40.0, 40.0, 20.0], [10.0, 64.0, 40.0, 20.0]);
+        let labels = [labelled("Reset", first), labelled("Reset", second)];
+        assert_eq!(named_target("reset", &labels, &[first, second]), None);
+    }
+
     #[test]
     fn a_scrollbar_tells_how_far_rows_moved_when_rectangles_cannot() {
         // A whole row a notch: the same rectangles, so only the amount shows it.
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index e7165722ff..a2129a0db2 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -8,6 +8,7 @@
 //! everything else.
 use super::remote_chunks::{ChunkDecoder, ChunkFormat, Next};
 use super::{Dim, Game, Mining, Screen};
+use horizon_client::actions::Action;
 use horizon_client::first_person::{Hand, SwingAnimation};
 use horizon_client::{
     Result,
@@ -6127,15 +6128,15 @@ impl Game<'_> {
             .as_ref()
             .is_some_and(|r| r.level_load.is_active());
         let playing = self.screen == Screen::Playing && !loading && !self.dialog_open();
-        let held = |k| playing && self.keys.contains(&k);
+        let held = |action| playing && self.keys.held(action);
         let mut keys = Keys {
-            forward: held(KeyCode::KeyW),
-            backward: held(KeyCode::KeyS),
-            left: held(KeyCode::KeyA),
-            right: held(KeyCode::KeyD),
-            jump: held(KeyCode::Space),
-            shift: held(KeyCode::ShiftLeft),
-            sprint: held(KeyCode::ControlLeft),
+            forward: held(Action::Forward),
+            backward: held(Action::Back),
+            left: held(Action::Left),
+            right: held(Action::Right),
+            jump: held(Action::Jump),
+            shift: held(Action::Sneak),
+            sprint: held(Action::Sprint),
             analog: None,
         }
         .with_stick(stick.filter(|_| playing));
@@ -7626,7 +7627,7 @@ impl Game<'_> {
         if let Some(r) = self.remote.as_mut() {
             r.use_target = None;
         }
-        let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         // A boat, minecart, item frame, armor stand or painting nearer than
         // any mob: the server uses it (AbstractBoat.interact boards it).
         if let Some(hit) = self.remote_object_hit(false)
@@ -7776,7 +7777,7 @@ impl Game<'_> {
             // without predicting the inventory swap or swinging.
             let shelf_reacts = hand == Hand::Main
                 && held.is_some()
-                && !(self.keys.contains(&KeyCode::ShiftLeft)
+                && !(self.keys.held(Action::Sneak)
                     && (self.stack_in(self.selected).is_some() || self.offhand.is_some()))
                 && self.shelf_hit(&hit).is_some();
             let spectator = self.spectator();
@@ -7786,7 +7787,7 @@ impl Game<'_> {
                 // useItemOn runs for the off hand too (useWithoutItem doesn't):
                 // RespawnAnchorBlock.useItemOn charges an anchor with its
                 // glowstone, SUCCESS.
-                let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
+                let sneaking = self.keys.held(Action::Sneak);
                 let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some();
                 let charges =
                     !(sneaking && hands_full) && self.anchor_takes(hit.pos, held.as_ref());
@@ -7822,7 +7823,7 @@ impl Game<'_> {
             // candle an empty hand snuffs (CandleBlock.useItemOn) or a lit
             // candle cake (CandleCakeBlock.useItemOn).
             if hand == Hand::Main && !spectator {
-                let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
+                let sneaking = self.keys.held(Action::Sneak);
                 let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some();
                 if !(sneaking && hands_full) {
                     self.redstone_ore_particles(hit.pos);
@@ -8136,7 +8137,7 @@ impl Game<'_> {
     ) -> (InteractionResult, DryUse) {
         // Player.isSecondaryUseActive with something in either hand.
         let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some();
-        if self.keys.contains(&KeyCode::ShiftLeft) && hands_full {
+        if self.keys.held(Action::Sneak) && hands_full {
             return (InteractionResult::Pass, DryUse::default());
         }
         // AbstractCauldronBlock.useItemOn (CauldronInteractions): a bucket,
@@ -8313,7 +8314,7 @@ impl Game<'_> {
             inside: hit.face == [0; 3],
             yaw: self.yaw,
             pitch: self.pitch,
-            sneaking: self.keys.contains(&KeyCode::ShiftLeft),
+            sneaking: self.keys.held(Action::Sneak),
             item: stack.item.to_string(),
             can_use_game_master_blocks: self.can_use_game_master_blocks(),
         };
@@ -8373,7 +8374,7 @@ impl Game<'_> {
         let pos = horizon_core::position::BlockPos::new(target[0], target[1], target[2]);
         let [x, y, z] = hit.beside();
         let beside = Some(horizon_core::position::BlockPos::new(x, y, z));
-        let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         let creative = self.creative;
         self.with_level(|b, level, ticks| {
             let mut level = DryLevel::new(level);
@@ -8953,7 +8954,7 @@ impl Game<'_> {
                 KeyCode::KeyQ if !self.spectator() => {
                     // Minecraft.hasControlDown: the physical keys, so a toggled
                     // sprint on Left Control does not make Q drop the stack.
-                    let all = self.has_control_down();
+                    let all = self.has_control_down() || std::mem::take(&mut self.pad.drop_stack);
                     self.remote_drop(all);
                 }
                 KeyCode::KeyE if self.riding_mount_with_menu() || self.riding_chest_boat() => {
diff --git a/crates/horizon-client/src/game/remote_chat.rs b/crates/horizon-client/src/game/remote_chat.rs
index fbbb9c656f..c21b1f19b0 100644
--- a/crates/horizon-client/src/game/remote_chat.rs
+++ b/crates/horizon-client/src/game/remote_chat.rs
@@ -384,6 +384,7 @@ impl Game<'_> {
         let Some(prompt) = &self.command_prompt else {
             return;
         };
+        horizon_client::widgets::cover_frame();
         horizon_client::widgets::begin_screen(|| {
             super::screen_info::confirm(
                 "multiplayer/confirm_command",
@@ -412,7 +413,7 @@ impl Game<'_> {
                 &[],
             ),
         ];
-        let layout = self.command_prompt_layout(prompt, (w, h));
+        let mut layout = self.command_prompt_layout(prompt, (w, h));
         layout.declare_no(1);
         layout.draw(batch, atlas, self.cursor, &labels);
     }
diff --git a/crates/horizon-client/src/game/remote_mob_use.rs b/crates/horizon-client/src/game/remote_mob_use.rs
index dee804d01c..4fada19343 100644
--- a/crates/horizon-client/src/game/remote_mob_use.rs
+++ b/crates/horizon-client/src/game/remote_mob_use.rs
@@ -4,6 +4,7 @@
 //! (`Minecraft.startUseItem` then sends UseItem). The server does the real
 //! interaction; this is what the client's copy of the mob answers.
 use super::Game;
+use horizon_client::actions::Action;
 use horizon_client::{
     first_person::Hand,
     mobs::{Mob, Species, armadillo, equine, llama, nautilus},
@@ -50,7 +51,7 @@ impl Game<'_> {
         {
             return true;
         }
-        let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft);
+        let sneaking = self.keys.held(Action::Sneak);
         match m.species() {
             // Villager / WanderingTrader.mobInteract: trading, or a baby's head shake.
             Species::Villager | Species::WanderingTrader => item != "minecraft:villager_spawn_egg",
diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs
index 8e27feca84..f1f1948731 100644
--- a/crates/horizon-client/src/game/scoreboard.rs
+++ b/crates/horizon-client/src/game/scoreboard.rs
@@ -3,6 +3,7 @@
 //! entities, the selector options `scores=`, `team=` and `tag=`, the
 //! commands' [`Env`] and the sidebar.
 use super::{Game, chat::PLAYER_NAME, commands::Target};
+use horizon_client::actions::Action;
 use horizon_client::{
     command::{
         Context,
@@ -810,8 +811,7 @@ impl Game<'_> {
         // Player heads and the player list both draw from the same skin
         // slots: a new frame, with what the last one drew.
         self.flush_skin_slots();
-        let key = self.screen == super::Screen::Playing
-            && self.keys.contains(&winit::keyboard::KeyCode::Tab);
+        let key = self.screen == super::Screen::Playing && self.keys.held(Action::Playerlist);
         let (mut players, online_mode, upside_down) = match self.remote_tab_players() {
             Some(remote) => remote,
             None => {
diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs
index 54c62cae24..4e9f234132 100644
--- a/crates/horizon-client/src/game/screens.rs
+++ b/crates/horizon-client/src/game/screens.rs
@@ -271,6 +271,7 @@ impl Game<'_> {
             };
             let action = match id {
                 0 => Some(horizon_client::widgets::Action::Back),
+                1 => Some(horizon_client::widgets::Action::Options),
                 2 => Some(horizon_client::widgets::Action::Exit),
                 _ => None,
             };
diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs
index 94dd98446c..f968d3d714 100644
--- a/crates/horizon-client/src/game/sculk.rs
+++ b/crates/horizon-client/src/game/sculk.rs
@@ -4,6 +4,7 @@
 //! (`SculkShriekerBlockEntity`, `SpawnUtil`), catalysts feeding the sculk
 //! spreader from deaths, and the darkness wardens and shriekers cast.
 use super::{Game, Result};
+use horizon_client::actions::Action;
 use horizon_client::{
     containers::BlockEntity,
     effects::{EffectInstance, PlayerEffects},
@@ -20,7 +21,6 @@ use horizon_core::{
 use horizon_protocol::entity_data::PositionSource;
 use horizon_world::registry::BlockStateId;
 use std::collections::HashSet;
-use winit::keyboard::KeyCode;
 
 pub const HELP: &[&str] = &[
     "sculk                          sculk listeners, the warning level and the darkness blend",
@@ -542,7 +542,7 @@ impl Game<'_> {
             owner: None,
             dampening_state: self.state_dampens(state),
             spectator: self.spectator(),
-            stepping_carefully: self.keys.contains(&KeyCode::ShiftLeft),
+            stepping_carefully: self.keys.held(Action::Sneak),
             dampens: false,
             targetable: !dead && !creative && !self.spectator(),
             living: true,
@@ -1738,7 +1738,7 @@ impl Game<'_> {
             )
         });
         if let Some((at, on_ground, health, flying)) = player {
-            let crouch = self.keys.contains(&KeyCode::ShiftLeft);
+            let crouch = self.keys.held(Action::Sneak);
             if on_ground && !self.spectator() {
                 self.step_on_redstone_ore(at, crouch, true);
             }
diff --git a/crates/horizon-client/src/game/server_packs.rs b/crates/horizon-client/src/game/server_packs.rs
index f79725d4ee..e81376d4cf 100644
--- a/crates/horizon-client/src/game/server_packs.rs
+++ b/crates/horizon-client/src/game/server_packs.rs
@@ -479,6 +479,7 @@ impl Game<'_> {
         let Some(prompt) = &self.server_packs.prompt else {
             return;
         };
+        horizon_client::widgets::cover_frame();
         let atlas = &self.gui.atlas;
         let (w, h) = (batch.width, batch.height);
         if self.player.is_none() {
@@ -498,9 +499,9 @@ impl Game<'_> {
         horizon_client::widgets::begin_screen(|| {
             super::screen_info::confirm("pack_prompt", &title.plain(), &message.plain())
         });
-        prompt
-            .layout(atlas, (w, h))
-            .draw(batch, atlas, self.cursor, [&yes, &no]);
+        let mut layout = prompt.layout(atlas, (w, h));
+        layout.declare_no();
+        layout.draw(batch, atlas, self.cursor, [&yes, &no]);
     }
     /// `IntegratedServer.reportChunkLoadFailure` and the like: what the server
     /// thread reported since the last frame, each in `SystemToast.addOrUpdate`
diff --git a/crates/horizon-client/src/game/split.rs b/crates/horizon-client/src/game/split.rs
index 7e600f27e6..990017675d 100644
--- a/crates/horizon-client/src/game/split.rs
+++ b/crates/horizon-client/src/game/split.rs
@@ -874,11 +874,16 @@ impl Game<'_> {
         for key in std::mem::take(&mut self.physical_keys) {
             self.native_key_event(key, false, false);
         }
-        // Only what the keyboard held: this player's pad keeps its presses.
-        for key in self
+        // Only what the keyboard held, and a script acting as it: this player's pad keeps its
+        // presses.
+        let mut released = self
             .keys
-            .release_source(horizon_client::held::Source::Keyboard)
-        {
+            .release_source(horizon_client::held::Source::Keyboard);
+        released.extend(
+            self.keys
+                .release_source(horizon_client::held::Source::Agent),
+        );
+        for key in released {
             if let Err(e) = self.mapped_key(
                 key,
                 false,
@@ -894,8 +899,11 @@ impl Game<'_> {
         }
         self.drag_button = None;
         self.modifiers = Default::default();
-        self.left = false;
-        self.right = false;
+        // A press this player's pad holds goes on, as for its keys.
+        self.left = self
+            .pad
+            .holds_action(&self.settings.controller, "key.attack");
+        self.right = self.pad.holds_action(&self.settings.controller, "key.use");
         self.inventory_mouse_release(false);
         self.inventory_mouse_release(true);
         self.inventory_pick_release();
diff --git a/crates/horizon-client/src/game/split/hud.rs b/crates/horizon-client/src/game/split/hud.rs
index 9aff8276d7..2af46dfc7c 100644
--- a/crates/horizon-client/src/game/split/hud.rs
+++ b/crates/horizon-client/src/game/split/hud.rs
@@ -1,9 +1,10 @@
 //! What splitscreen draws over a player's view: its badge, questions answered with the pad and
 //! notices.
 use super::*;
-use horizon_client::controller_notice::{NoticeSlot, key, panel};
+use horizon_client::controller_notice::{NoticeSlot, panel};
 use horizon_client::gamepad::Button;
 use horizon_client::hud::{HudBatch, rgba};
+use horizon_client::pad_glyph;
 use std::time::Duration;
 
 /// What splitscreen draws over a player's view (`Game::split_hud`): its corner badge (who, for a
@@ -93,11 +94,11 @@ impl Game<'_> {
             let glyphs: Vec<_> = prompt
                 .choices
                 .iter()
-                .map(|(b, what)| (b.label(style), b.color(style), what.as_str()))
+                .map(|(b, what)| (*b, pad_glyph::width(atlas, *b, style), what.as_str()))
                 .collect();
             let line: f32 = glyphs
                 .iter()
-                .map(|(g, _, what)| width(g) + 8.0 + width(what) + gap(what))
+                .map(|(_, gw, what)| gw + 4.0 + width(what) + gap(what))
                 .sum::<f32>()
                 - 12.0;
             let pw = width(&prompt.title).max(line) + 16.0;
@@ -118,9 +119,8 @@ impl Game<'_> {
             );
             let mut x = (px + (pw - line) / 2.0).floor();
             let y = py + 20.0;
-            for (glyph, [r, g, b], what) in glyphs {
-                let gw = width(glyph) + 4.0;
-                key(batch, atlas, glyph, rgba(r, g, b, 255), x, y, gw);
+            for (button, gw, what) in glyphs {
+                pad_glyph::draw(batch, atlas, button, style, x, y);
                 x += gw + 4.0;
                 batch.text(atlas, what, x, y, rgba(220, 220, 220, 255), false);
                 x += width(what) + gap(what);
diff --git a/crates/horizon-client/src/game/tutorial.rs b/crates/horizon-client/src/game/tutorial.rs
index 412a9b6937..62cf6c97de 100644
--- a/crates/horizon-client/src/game/tutorial.rs
+++ b/crates/horizon-client/src/game/tutorial.rs
@@ -262,7 +262,7 @@ impl super::Game<'_> {
     }
 
     pub(super) fn tick_tutorial(&mut self) {
-        use winit::keyboard::KeyCode;
+        use horizon_client::actions::Action;
         if self.title.is_some()
             || self.player.is_none()
             || self.options.dedicated.is_some()
@@ -289,14 +289,14 @@ impl super::Game<'_> {
         }
         if self.screen == super::Screen::Playing
             && ([
-                KeyCode::KeyW,
-                KeyCode::KeyA,
-                KeyCode::KeyS,
-                KeyCode::KeyD,
-                KeyCode::Space,
+                Action::Forward,
+                Action::Left,
+                Action::Back,
+                Action::Right,
+                Action::Jump,
             ]
-            .iter()
-            .any(|key| self.keys.contains(key))
+            .into_iter()
+            .any(|action| self.keys.held(action))
                 || self
                     .pad_move()
                     .is_some_and(|[left, forward]| left.abs() > 0.3 || forward.abs() > 0.3))
diff --git a/docs/controllers.md b/docs/controllers.md
index 4d5e2b9b4c..175391f5b1 100644
--- a/docs/controllers.md
+++ b/docs/controllers.md
@@ -11,9 +11,8 @@ Nothing. Minecraft Java 26.3 never calls GLFW's gamepad or joystick API, has
 no controller options and ships no button glyphs. Its only non-mouse UI input
 is keyboard focus navigation (`InputType.KEYBOARD_ARROW` / `KEYBOARD_TAB`:
 arrows and Tab move a focus ring between widgets). So controller support is
-Horizon's own feature. It follows what players already know from Minecraft on
-consoles (Bedrock Edition's default controller layout) and Horizon's menu
-design for any new screen.
+Horizon's own feature. Its default buttons are Horizon's own; analog walking and toggle sneak follow
+Bedrock Edition on consoles.
 
 ## Input layer
 
@@ -71,6 +70,20 @@ Advancements and the player list have no button of their own, and are
 bindable. A settings file from before these defaults keeps its buttons where
 they were.
 
+Also bindable, with no default button: fullscreen, player social, quick actions, the save and load
+toolbar activators and hotbar slots 1 to 9. They act in play only: in a menu or a prompt the button
+does what that screen says. A toolbar activator does nothing by itself: a creative player holds it and
+presses a hotbar slot's button, as with the keys, and a spectator's hotbar buttons drive the spectator
+menu.
+
+The bumpers go through what the wheel goes through (`Game::hotbar_step`), one notch a press, RB down:
+with no screen, prompt or bed in the way, a native mod can take it (`native_wheel`, then
+`native_mouse_scrolling`), then a spectator's menu or flying speed takes it, else the hotbar turns.
+
+Drop follows Q: a tap throws one item. Held, it repeats at the repeat delay and interval of Controller
+Settings > General, and from 1 second on (`DROP_STACK_HOLD`) each repeat throws what's left of the
+stack, as a pad has no Control to hold. Nothing repeats while a menu is open.
+
 The Guide / PS / Steam button is left to the system. Sneak on a stick click
 toggles by default (holding a stick in while steering the camera is
 awkward, which is why Bedrock does the same) and acts like vanilla's toggle
@@ -115,8 +128,9 @@ The hint is the glyph on the declared button, in that player's pad's style and v
 in a corner. It shows while the pad drives; the mouse or a focus key hides it, and a button too small
 for it, or running off a split view, goes without it and keeps its pad button. What a screen declared
 stops counting as soon as another screen is drawn over it (`widgets::begin_screen`: a popup's buried
-buttons can't be pressed) or takes its place. While a key row waits for its key nothing is declared:
-B is Escape, which unbinds.
+buttons can't be pressed) or takes its place. While a key row waits for its key nothing is declared and only B and Start act:
+they are Escape, which unbinds. A row on Controller Settings > Bindings takes the next button pressed
+as its binding, and Start cancels.
 
 Don't declare a button Escape deliberately ignores: Optimize World's and a connection's Cancel have
 no pad button, only A on them, and show in `undeclared` for that reason.
@@ -124,7 +138,8 @@ no pad button, only A on them, and show in `undeclared` for that reason.
 A focused text field shows A at its right end. `game/pad_actions.rs` holds this table. A screen that declares nothing keeps
 B as Escape. `horizon-ctl pad status` lists `undeclared`: a button labelled
 Done, Back or Cancel on the current screen that didn't declare its job.
-`tools/pad_menu_e2e.py` fails on one in the settings screens. `glyphs` lists what is drawn.
+`tools/pad_menu_e2e.py` fails on one in the settings screens. `glyphs` lists what is drawn: each
+button, its `sprite` (null when it is the label on a key) and the `rect` it covers.
 
 A label wider than its button slides inside it, as vanilla's do
 (`AbstractWidget.extractScrollingStringOverContents`); one under a glyph slides beside it.
@@ -177,7 +192,7 @@ the crafting result, armour to the player's grid.
 | D-pad, left stick | move focus (held: repeats after 0.35 s, every 0.09 s; the stick steps past 0.55 and lets go under 0.35) |
 | A | press the focused widget: a button when A is let go, if the focus is still on it; anything else when A goes down (held: drag); on a text field, type with the on-screen keyboard. With nothing focused yet, A only lands the focus, as the D-pad does |
 | B, Menu | back (Escape); on the title's main menu, B moves the focus to Quit Game, for A to confirm |
-| X | right click (inventories: take half, place one); on the title's main menu, Options |
+| X | right click (inventories: take half, place one); on the title's main menu and the pause menu, Options |
 | Y | quick move (shift-click) in inventories; on the pause menu, moves the focus to the exit button, for A to confirm |
 | View | throw one item from the focused slot (Q) |
 | Left stick click | throw the focused stack (Ctrl+Q) |
@@ -198,7 +213,7 @@ the crafting result, armour to the player's grid.
   draws it under the pointer). A takes or places, X splits or places one, Y
   quick-moves, View and the left stick click throw.
 - **Where focus lands** when a screen opens: the held hotbar slot in an
-  inventory, else the first button.
+  inventory, else the first button; on a prompt, see "Prompts".
 
 It looks as vanilla's own keyboard focus does: buttons, sliders and slots
 show their highlighted sprite (`isHoveredOrFocused`, drawn because the hidden
@@ -296,6 +311,29 @@ on return (Options, after its Done), as vanilla keeps a screen's focused
 widget. Moving the pad's focus drops the highlight a click gave a button, so
 only one widget ever shows as focused.
 
+The focus means the widget, not the place: the rows under it can have moved, or a resize or a new
+GUI scale moved everything. So it is found again by its label (`widgets::slug`) when exactly one
+widget has that label, and otherwise by its rectangle.
+
+### Prompts
+
+A prompt is a server dialog, the code of conduct, a link or command confirmation or a server pack
+prompt (`Game::prompt_open`), over gameplay or over another screen. The pad drives it by focus, as a
+menu, and nothing it presses reaches the game or the screen behind:
+
+- Of the buttons only A, B, Start and the D-pad do anything.
+- The focus starts on what answers no (its enabled Cancel or Back), so a press meant for the game
+  can't accept anything. A dialog with text to fill in starts on its first input instead, and a prompt
+  with neither starts on its first widget in tab order, a dialog's warning icon last.
+- B and Start answer as Escape, the top prompt first: a command or link confirmation or a pack prompt
+  says no, a dialog closes only if it allows that, and the code of conduct stays, since it has no
+  answer by Escape.
+- The right stick and a step past a list's edge scroll only the prompt, as the mouse wheel does.
+- A prompt coming or going closes the on-screen keyboard and starts the focus again on the new frame.
+  What a prompt covers stops counting (`widgets::cover_frame`): a buried button has no pad button.
+- Once a prompt closes, a keyboard it took from chat or a sign opens again, and on a crosshair screen
+  the crosshair glides back to where it was.
+
 ### Text fields
 
 A on a focused text field (A in pointer mode clicks into it) opens the
@@ -305,10 +343,21 @@ lower half, as chat is). D-pad or stick to move, A types, X deletes, Y is a
 space, LT is Shift (twice: caps lock), RB switches to symbols and accents,
 Menu is Enter, B closes it. It opens by itself when the pad opens chat or a
 sign, but not over the chat a sleeper gets (the game opens that one): there
-it waits for A on the chat box. It types into every field the keyboard
-reaches: chat (local and server), signs, books, the title screens' fields,
-the options' searches, the creative and recipe-book searches, the anvil, the
-LAN port.
+it waits for A on the chat box. It types into chat (local and server), signs, books being written, the title screens' fields,
+every options page's fields (searches, the packs', the language list's,
+splitscreen profiles), the creative and recipe-book searches, the mod browser's search, the anvil, the
+LAN screen's port and its game rules, a server dialog's inputs, command blocks, the game master blocks'
+edit screens, Player Social's search and Debug Options' search. The one exception is a native mod's
+own screen (`Screen::Mod`), which takes its input through the screen hooks: the keyboard types nothing
+there.
+
+Enter (Menu, or the keyboard's Done key) closes the keyboard, and on the way:
+
+- reaches the field as the key would in chat (it sends), on signs and books, on command blocks (their
+  Done) and game master blocks, on the options pages and on the title's fields;
+- does nothing more on the searches, the anvil, the LAN screen and a dialog's one-line input;
+- on a dialog's input of many lines is a new line, and the keyboard stays.
+
 
 On a Steam Deck under Steam (`SteamDeck=1`), A asks Steam for its own
 keyboard instead (`steam://open/keyboard`), which types like a real keyboard;
@@ -332,25 +381,54 @@ book's page text), the pad drives the pointer instead, as it does on Replay Stud
 
 ## Glyphs
 
-Horizon draws its own button glyphs in the HUD and screens (no Mojang
-assets, nothing new from the player's jar): a small round or pill shape with
-the label in the game font, sized to the GUI scale, with two styles:
+A button is drawn as Horizon's own art where its family has a picture, and otherwise as the label
+printed on the pad, in its colour, on a dark key (`pad_glyph.rs`; no Mojang assets, nothing from the
+player's jar). Whatever draws or measures a glyph goes through that module.
 
-- **Xbox / Steam Deck / generic**: A B X Y in their usual colours, LB RB LT
-  RT, View, Menu, stick icons.
-- **PlayStation**: × ○ □ △ in their colours (× rather than ✕, which the game fonts lack), L1 R1 L2 R2,
-  Create/Share, Options.
-- **Nintendo**: B A Y X by position.
+| Family | Art | Text |
+|---|---|---|
+| Xbox, also Auto, Steam Deck and anything unknown | `xb_*`: a b x y, lb rb lt rt, view menu, l3 r3, up down left right | none |
+| PlayStation | `psx_*`: cross circle square triangle, l1 r1 l2 r2, create options, l3 r3, up down left right | none |
+| Nintendo | `nx_*`, by what the pad prints: b a y x at south, east, west and north, l r zl zr, minus plus, l3 r3, up down left right | none |
 
-The style comes from the pad's USB vendor (Sony 054c, Microsoft 045e,
-Nintendo 057e, Valve 28de) unless the controls options force one. Glyphs
-replace key names where a prompt names a key (the controls list, tutorial
-hints, "Press X to dismount") only while the pad is the last-used input.
+Every family has its own file for every button, so a family's art can change without touching another's.
+Some are copies until theirs is drawn: Nintendo's letters and shoulders are Xbox's, and all three share the
+same sticks, D-pad and menu pictures. Text remains for what runs inside a line of text, and for an atlas
+without the sprite.
+
+The art is in `crates/horizon-client/assets/horizon/textures/gui/controller/`, built into the binary, one
+line of `pad_glyph::ART` per picture: a button with no line is text, and adding one is that line and its
+file. A resource pack replaces a picture by bringing the same path,
+`assets/horizon/textures/gui/controller/<file>.png`: the atlas packs other namespaces' `textures/gui/` as
+`horizon:gui/controller/<file>` and adds Horizon's own only when that sprite is missing (`HudAtlas`). A
+pack's picture of another size is drawn in the same place, and a pack can't add a picture for a button
+with no line. An atlas without the sprite falls back to text.
+
+The picture's texture is 32 pixels tall, drawn 16 GUI pixels tall with a clear edge of 2 all round, so a
+glyph shows 12 tall, as a text glyph does: a square picture 12 wide, a bumper or trigger 20. A declared
+button's label leaves room for it.
+
+Art shows on declared buttons and a focused field's A, in notices and splitscreen's strips. What runs
+inside a line of text stays text: the recipe tooltip, the on-screen keyboard's hint line and the buttons on
+the Bindings page. Vanilla's own messages that name a key (tutorial hints) keep the keyboard's names.
+
+The inventory crosshair is `crosshair_inv` in the same folder, drawn at 16 GUI pixels on the point it
+clicks (`pad_cursor.rs`).
+
+The family comes from the pad's USB ids (`GlyphStyle::of_device`) unless Controller Settings > Device
+forces one: Sony 054c and a few licensed pads (HORIPAD 4 FPS and FPS Plus, Razer Raiju, Nacon Revolution
+Pro) are PlayStation; Nintendo 057e and a few licensed pads (HORIPAD for Nintendo Switch, PowerA Wired
+Plus, PDP Faceoff Wired Pro) are Nintendo; Microsoft, Valve's Steam Deck and Steam Input's virtual pad,
+and everything else are Xbox.
 
 ## Options and remapping
 
 Controller settings are Horizon's own: **Options → Controls → Controller
-Settings...**, a screen in the graphics settings' style with a search field and General, Bindings and Device pages. It
+Settings...** (or **Options → Horizon Settings... → Controller Settings...**),
+a screen in the graphics settings' style with a search field and General, Bindings and Device pages. Bindings
+is a list like the key binds screen (pick an action, press a button; conflicts marked as vanilla does), and
+Reset. General's Play group has **Trigger Threshold**, how far a trigger is pulled before it counts as pressed:
+0.1 to 0.9, by default 0.4, which also places a DualSense's catch (see "Adaptive triggers"). The screen
 names the player whose profile it edits and the controller the game sees; Device also shows its vendor and
 product ids, the detected glyph family and the override. Changes apply at once; **Undo** (X) is there only
 while something differs from when the screen opened, and **Done** (B) leaves. They live in
@@ -372,13 +450,11 @@ toggleSneak:true
 glyphs:auto
 bind_key.jump:south
 bind_pad.hotbarNext:rb
+bindLayout:1
 ```
 
-Only bindings that differ from the defaults are written. The controls
-options get a Controller page: on/off, vibration, adaptive triggers, lightbar, look sensitivity, invert
-X/Y, deadzones, glyph style, sneak toggle, and a binding list like the key
-binds screen (pick an action, press a button; conflicts marked as vanilla
-does; reset).
+Only bindings that differ from the defaults are written. A file without `bindLayout` comes from before the
+current defaults and keeps its buttons where they were.
 
 Deadzones are radial (the stick's length, so diagonals aren't clipped) and the
 remaining range is rescaled to 0..1. Look uses a squared curve for precise
diff --git a/tests/test_mouse_scrolling_hook.py b/tests/test_mouse_scrolling_hook.py
index a6a575eb84..e901287643 100644
--- a/tests/test_mouse_scrolling_hook.py
+++ b/tests/test_mouse_scrolling_hook.py
@@ -5,6 +5,8 @@ import subprocess
 import tempfile
 import unittest
 
+from test_world_input_capture import method
+
 ROOT = Path(__file__).resolve().parents[1]
 
 
@@ -14,8 +16,10 @@ class MouseScrollingHookTests(unittest.TestCase):
         source = (ROOT / "crates/horizon-client/src/game.rs").read_text(encoding="utf-8")
         start = source.index("                    let (raw_x, raw_y) = match delta")
         normalize = source[start:source.index("                    // ScreenEvent.MouseScrolled.Pre", start)]
-        start = source.index("                    if self.screen == Screen::Playing", start)
+        start = source.index("                    if self.hotbar_takes_wheel()", start)
         dispatch = source[start:source.index("                    if self.screen == Screen::Chat", start)]
+        hotbar = "\n".join(method(source, name) for name in
+                            ("hotbar_takes_wheel", "hotbar_scroll_canceled", "hotbar_wheel_step"))
         fixture = r"""
 use std::collections::HashSet;
 #[allow(dead_code)]
@@ -52,6 +56,7 @@ impl Game {
         cursor: [f32;2], modifiers: u32, canceled: &mut bool) {
         self.calls.push((scroll, accumulated, buttons, cursor, modifiers)); *canceled = self.cancel;
     }
+    HOTBAR
     fn wheel(&mut self, delta: MouseScrollDelta) -> Result<(), ()> {
         NORMALIZE
         DISPATCH
@@ -104,7 +109,7 @@ fn source_and_legacy_gates() {
         assert_eq!(game.selected, if gate==5 {3} else {4});
     }
 }
-""".replace("MOUSE_PATH", (ROOT / "crates/horizon-client-input/src/mouse.rs").as_posix()).replace("NORMALIZE", normalize).replace("DISPATCH", dispatch)
+""".replace("MOUSE_PATH", (ROOT / "crates/horizon-client-input/src/mouse.rs").as_posix()).replace("NORMALIZE", normalize).replace("HOTBAR", hotbar).replace("DISPATCH", dispatch)
         with tempfile.TemporaryDirectory() as folder:
             src, exe = Path(folder) / "scroll.rs", Path(folder) / "scroll.exe"
             src.write_text(fixture, encoding="utf-8")
diff --git a/tests/test_screen_key_released_hook.py b/tests/test_screen_key_released_hook.py
index f1119eb211..66f893989a 100644
--- a/tests/test_screen_key_released_hook.py
+++ b/tests/test_screen_key_released_hook.py
@@ -39,6 +39,7 @@ fn gameplay_has_keyboard(screen: bool, title: bool, dialog: bool) -> bool { scre
 BUTTON
 fn container_key_clones(_: i32, _: KeyAction) -> bool { false }
 mod keybinds { pub fn key_name(key: i32) -> Option<&'static str> { (key == 1).then_some("key.keyboard.a") } }
+mod horizon_client { pub(crate) use crate::keybinds; }
 enum Source { Keyboard }
 struct Bindings;
 impl Bindings { fn translate_all(&self, _: i32) -> Vec<std::result::Result<i32, i32>> { vec![Ok(10), Ok(11), Err(2)] } }
@@ -55,7 +56,8 @@ impl Game {
     fn mapped_key(&mut self, key: i32, pressed: bool, repeat: bool, raw: i32, _: Source) -> Result<()> {
         assert!(!pressed && !repeat && raw == 1); self.released.push((false, key)); Ok(())
     }
-    fn play_mouse(&mut self, button: i32, pressed: bool) -> Result<()> {
+    fn shared_default_acts(&self, _: i32, _: Option<&str>) -> bool { true }
+    fn mouse_mapping(&mut self, button: i32, pressed: bool, _: Source) -> Result<()> {
         assert!(!pressed); self.released.push((true, button)); Ok(())
     }
     fn inventory_pick_key(&mut self) { panic!("release cannot clone") }
diff --git a/tests/test_screen_mouse_focus.py b/tests/test_screen_mouse_focus.py
index 71b1d3ffd6..79c21b855a 100644
--- a/tests/test_screen_mouse_focus.py
+++ b/tests/test_screen_mouse_focus.py
@@ -37,6 +37,7 @@ struct Pad { menu: Menu }
 struct Game { pad: Pad, cursor: (f32, f32), in_menu: bool }
 impl Game {
     fn pad_in_menu(&self) -> bool { self.in_menu }
+    fn key_focus_screen(&self) -> bool { self.in_menu }
     fn key_targets(&self) -> Vec<Target> { vec![Target { rect: [0., 0., 10., 10.] }] }
     METHOD
 }
diff --git a/tools/pad_menu_e2e.py b/tools/pad_menu_e2e.py
index 8d4c2bde26..393422a552 100644
--- a/tools/pad_menu_e2e.py
+++ b/tools/pad_menu_e2e.py
@@ -703,6 +703,11 @@ def pause_y(args, name):
         game.pad('start')
         game.wait_targets()
         check(game.focus() not in (None, exit_button), f'reopened on {game.focus()}')
+        # X is its Options, declared with a glyph like the others.
+        check(declared(game).get('Options') is True, f'Options is not declared: {declared(game)}')
+        check('West' in glyphs(game), f'no X on Options: {glyphs(game)}')
+        game.pad('west')
+        check(game.ctl('state')['screen'] == 'options', f"X opened {game.ctl('state')['screen']}")
     finally:
         game.quit()
     return check.failures
@@ -1335,7 +1340,7 @@ def controller_settings_pad(args, name):
         for _ in range(24):
             game.pad('down')
             reached.add(game.focused_label())
-        for want in ('Controller', 'Look Sensitivity', 'Move Deadzone', 'Repeat Interval',
+        for want in ('Controller', 'Look Sensitivity', 'Move Deadzone', 'Trigger Threshold', 'Repeat Interval',
                      'On-Screen Keyboard'):
             check(any(want.lower() in (r or '').lower() for r in reached), f'the D-pad never reached {want}: {reached}')
         # The bumpers change pages.
@@ -1576,6 +1581,349 @@ def erase_checkbox(args, name):
 
 
 
+def key_row_a_x(args, name):
+    game = Game(args, name)
+    check = Check()
+    try:
+        game.wait_targets()
+        game.title_buttons()
+        game.pad('west')
+        game.ctl('options', 'keybinds')
+        time.sleep(SETTLE)
+        game.wait_targets()
+        game.pad('down')
+        row = next(w for w in game.widgets() if w.get('label') in ('W', 'A', 'S', 'D'))
+        click_widget(game, row)
+        waiting = next(w for w in game.widgets() if w['bounds'] == row['bounds'])['label']
+        check(waiting != row['label'], f"the row isn't waiting: {waiting}")
+        for button in ('south', 'west', 'north', 'rb'):
+            game.pad(button)
+            after = next(w for w in game.widgets() if w['bounds'] == row['bounds'])['label']
+            check(after == waiting, f'{button} left the row on {after}')
+        game.pad('east')
+        after = next(w for w in game.widgets() if w['bounds'] == row['bounds'])['label']
+        check(after not in (waiting, 'Left Button', 'Right Button'), f'B left the row on {after}')
+    finally:
+        game.quit()
+    return check.failures
+
+
+def show_dialog(game, snbt):
+    """A server's dialog over the world, once it is drawn."""
+    game.ctl('command', f'dialog show @s {snbt}')
+    time.sleep(1)
+    check_open = game.ctl('state')['dialog']['open']
+    if not check_open:
+        raise RuntimeError(f'no dialog from {snbt}')
+    game.wait_targets()
+
+
+def dialog_open(game):
+    return game.ctl('state')['dialog']['open'] is not None
+
+
+def prompt_dialog(args, name):
+    game = Game(args, name, world=True)
+    check = Check()
+    try:
+        show_dialog(game, '{type:"minecraft:confirmation",title:"Sure?",yes:{label:"Yes"},no:{label:"No"}}')
+        check(game.ctl('state')['screen'] == 'dialog', f"screen is {game.ctl('state')['screen']}")
+        # The first A only lands the focus, on what answers no.
+        game.pad('south')
+        check(dialog_open(game), 'the first A answered the dialog')
+        check(game.focused_label() == 'No', f'the focus starts on {game.focused_label()}')
+        check(glyphs(game).get('East') is not None, f'no B on No: {glyphs(game)}')
+        # The stick drives the focus: the player stays.
+        before = game.ctl('state')['player']['position']
+        game.ctl('pad', 'stick', 'left', -1, 0)
+        time.sleep(0.6)
+        game.ctl('pad', 'stick', 'left', 0, 0)
+        time.sleep(SETTLE)
+        check(game.ctl('state')['player']['position'] == before, 'the stick walked the player behind the dialog')
+        check(game.focused_label() == 'Yes', f'the stick left the focus on {game.focused_label()}')
+        game.pad('right')
+        check(game.focused_label() == 'No', f'the D-pad left the focus on {game.focused_label()}')
+        # A presses it on the way up.
+        game.ctl('pad', 'south', 'down')
+        time.sleep(SETTLE)
+        check(dialog_open(game), 'A down answered the dialog')
+        game.ctl('pad', 'south', 'up')
+        time.sleep(SETTLE)
+        check(not dialog_open(game), 'A up did not answer the dialog')
+        check(game.ctl('state')['screen'] == 'playing', f"screen is {game.ctl('state')['screen']}")
+        # B answers as Escape does, and doesn't open the pause menu as well.
+        show_dialog(game, '{type:"minecraft:notice",title:"Hello"}')
+        game.pad('east')
+        check(not dialog_open(game), 'B did not close the notice')
+        check(game.ctl('state')['screen'] == 'playing', f"B left the screen on {game.ctl('state')['screen']}")
+        # One that Escape can't close stays, and doesn't pause either; A still answers it.
+        show_dialog(game, '{type:"minecraft:notice",title:"Stay",can_close_with_escape:false}')
+        game.pad('east')
+        game.pad('start')
+        check(dialog_open(game), 'B or Start closed a dialog that Escape cannot')
+        game.pad('south')
+        game.pad('south')
+        check(not dialog_open(game), 'A did not answer it')
+    finally:
+        game.quit()
+    return check.failures
+
+
+def prompt_dialog_field(args, name):
+    game = Game(args, name, world=True)
+    check = Check()
+
+    def typed():
+        return game.ctl('state')['dialog']['open']['inputs'][0]['value']
+
+    try:
+        show_dialog(game, '{type:"minecraft:notice",title:"Name",inputs:[{type:"minecraft:text",key:"who",label:"Name"}]}')
+        game.pad('south')
+        field = next(t for t in game.menu()['targets'] if t['kind'] == 'field')
+        check(game.focus() == tuple(field['rect']), f"the focus starts on {game.focus()}, not {field['rect']}")
+        game.pad('south')
+        check(game.menu()['keyboard'], 'A did not open the keyboard')
+        game.pad('south')
+        check(len(typed()) == 1, f'A on a key typed {typed()!r}')
+        game.pad('south')
+        check(len(typed()) == 2, f'A on a key again typed {typed()!r}')
+        game.pad('west')
+        check(len(typed()) == 1, f'X left {typed()!r}')
+        check(game.menu()['keyboard'], 'typing closed the keyboard')
+        game.pad('start')
+        check(not game.menu()['keyboard'], 'Start did not end the typing')
+        check(dialog_open(game) and len(typed()) == 1, 'Start answered the dialog')
+        game.pad('east')
+        check(not dialog_open(game), 'B did not close the dialog')
+    finally:
+        game.quit()
+    return check.failures
+
+
+def walk_to_field(game, check):
+    """The D-pad, towards the screen's text field."""
+    game.pad('down')
+    field = tuple(next(t for t in game.menu()['targets'] if t['kind'] == 'field')['rect'])
+    for _ in range(40):
+        focus = game.focus()
+        if focus == field:
+            return
+        if focus[1] != field[1]:
+            game.pad('up' if focus[1] > field[1] else 'down')
+        else:
+            game.pad('left' if focus[0] > field[0] else 'right')
+    check(game.focus() == field, f'the D-pad never reached the field {field}: on {game.focus()}')
+
+
+def prompt_keeps_typing(args, name):
+    game = Game(args, name, world=True)
+    check = Check()
+    try:
+        game.pad('up')
+        time.sleep(SETTLE)
+        check(game.ctl('state')['screen'] == 'chat', f"D-pad up left the screen on {game.ctl('state')['screen']}")
+        check(game.menu()['keyboard'], 'the keyboard did not open over chat')
+        show_dialog(game, '{type:"minecraft:notice",title:"Hello"}')
+        check(not game.menu()['keyboard'], 'the keyboard stayed over the dialog')
+        game.pad('east')
+        time.sleep(SETTLE)
+        check(not dialog_open(game), 'B did not close the notice')
+        check(game.menu()['keyboard'], 'the keyboard did not come back over chat')
+        # Closed by B, it stays closed through the next prompt.
+        game.pad('east')
+        time.sleep(SETTLE)
+        check(not game.menu()['keyboard'], 'B did not close the keyboard')
+        show_dialog(game, '{type:"minecraft:notice",title:"Hello"}')
+        game.pad('east')
+        time.sleep(SETTLE)
+        check(not dialog_open(game), 'B did not close the second notice')
+        check(not game.menu()['keyboard'], 'a prompt reopened the keyboard B had closed')
+    finally:
+        game.quit()
+    return check.failures
+
+
+def prompt_keeps_crosshair(args, name):
+    game = Game(args, name, world=True)
+    check = Check()
+    try:
+        game.ctl('command', 'gamemode survival')
+        game.ctl('key', 'e', 'tap')
+        time.sleep(SETTLE)
+        game.wait_targets()
+        screen = game.ctl('state')['screen']
+        game.pad('down')
+        time.sleep(1)
+        was = game.menu()['pointer']
+        show_dialog(game, '{type:"minecraft:notice",title:"Hello"}')
+        time.sleep(SETTLE)
+        check(game.menu()['pointer'] != was, 'the focus on the notice left the pointer on the slot')
+        game.pad('east')
+        time.sleep(1)
+        check(not dialog_open(game), 'B did not close the notice')
+        check(game.ctl('state')['screen'] == screen, f"the notice left the screen on {game.ctl('state')['screen']}")
+        at = game.menu()['pointer']
+        check(max(abs(at[0] - was[0]), abs(at[1] - was[1])) <= 1, f'the crosshair went from {was} to {at}')
+    finally:
+        game.quit()
+    return check.failures
+
+
+def osk_stays_open(game, check, what):
+    """A opens the keyboard on the focused field, and it types and deletes without closing."""
+    game.pad('south')
+    check(game.menu()['keyboard'], f'{what}: A did not open the keyboard')
+    game.pad('south')
+    check(game.menu()['keyboard'], f'{what}: typing closed the keyboard')
+    game.pad('west')
+    check(game.menu()['keyboard'], f'{what}: deleting closed the keyboard')
+
+
+def osk_social(args, name):
+    game = Game(args, name, world=True)
+    check = Check()
+    try:
+        game.ctl('key', 'p', 'tap')
+        time.sleep(1)
+        game.wait_targets()
+        walk_to_field(game, check)
+        osk_stays_open(game, check, 'social')
+        game.pad('start')
+        check(not game.menu()['keyboard'], 'Start did not end the typing')
+        check(game.ctl('state')['screen'] == 'social', f"Start left {game.ctl('state')['screen']}")
+    finally:
+        game.quit()
+    return check.failures
+
+
+def osk_debug_options(args, name):
+    game = Game(args, name, world=True)
+    check = Check()
+    try:
+        game.ctl('key', 'f3', 'down')
+        game.ctl('key', 'f6', 'tap')
+        game.ctl('key', 'f3', 'up')
+        time.sleep(1)
+        check(game.ctl('state')['screen'] == 'debug-options', f"screen is {game.ctl('state')['screen']}")
+        game.wait_targets()
+        walk_to_field(game, check)
+        rows = len(game.rects())
+        game.pad('south')
+        check(game.menu()['keyboard'], 'A did not open the keyboard')
+        # Few of the options have the first key's letter in them.
+        game.pad('south')
+        check(game.menu()['keyboard'], 'typing closed the keyboard')
+        check(len(game.rects()) < rows, f'the search kept {len(game.rects())} of {rows} targets')
+        game.pad('west')
+        check(len(game.rects()) == rows, f'deleting left {len(game.rects())} of {rows} targets')
+    finally:
+        game.quit()
+    return check.failures
+
+
+def osk_block(block, screen):
+    def case(args, name):
+        game = Game(args, name, world=True)
+        check = Check()
+        try:
+            # In front of the eyes, looking east.
+            game.ctl('command', f'setblock ~1 ~1 ~ {block}')
+            game.ctl('look', -90, 0)
+            time.sleep(1)
+            game.ctl('mouse', 'right', 'click')
+            time.sleep(1)
+            check(game.ctl('state')['screen'] == screen, f"screen is {game.ctl('state')['screen']}")
+            game.wait_targets()
+            walk_to_field(game, check)
+            osk_stays_open(game, check, screen)
+            # Enter is the screen's Done, as on the keyboard.
+            game.pad('start')
+            check(game.ctl('state')['screen'] == 'playing', f"Start left {game.ctl('state')['screen']}")
+            check(not game.menu()['keyboard'], 'the keyboard stayed after its screen closed')
+        finally:
+            game.quit()
+        return check.failures
+    return case
+
+
+osk_command_block = osk_block('command_block', 'command-block')
+
+
+osk_jigsaw = osk_block('jigsaw', 'block-editor')
+
+
+def seed_controller(text):
+    def seed(game_home):
+        (game_home / 'horizon-controller.txt').write_text(text)
+    return seed
+
+
+def glyph_art(args, name):
+    check = Check()
+    for style, west, east in (('xbox', 'xb_x', 'xb_b'), ('playstation', 'psx_square', 'psx_circle'), ('nintendo', 'nx_y', 'nx_a')):
+        game = Game(args, f'{name}-{style}', seed=seed_controller(f'glyphs:{style}\n'))
+        try:
+            game.wait_targets()
+            _, options, quit_game = game.title_buttons()
+            game.pad('down')
+            shown = {g['button']: g for g in game.menu()['glyphs']}
+            for button, art, widget in (('West', west, options), ('East', east, quit_game)):
+                glyph = shown.get(button)
+                check(glyph is not None, f'{style}: no {button} glyph in {shown}')
+                if glyph:
+                    sprite = art and f'horizon:gui/controller/{art}'
+                    check(glyph['sprite'] == sprite, f"{style} {button}: {glyph['sprite']}, not {sprite}")
+                    x, y, w, h = glyph['rect']
+                    bx, by, bw, bh = widget
+                    check(bx <= x and by <= y and x + w <= bx + bw and y + h <= by + bh,
+                          f'{style} {button}: {glyph["rect"]} is not inside its button {widget}')
+            shot(game, f'glyph_art_{style}_title')
+        finally:
+            game.quit()
+    return check.failures
+
+
+def glyph_art_world(args, name):
+    check = Check()
+    for style in ('xbox', 'playstation'):
+        game = Game(args, f'{name}-{style}', world=True, seed=seed_controller(f'glyphs:{style}\nbindLayout:1\n'))
+        try:
+            game.ctl('key', 'e', 'tap')
+            time.sleep(SETTLE)
+            game.wait_targets()
+            game.pad('down')
+            check(game.menu()['pointer'] is not None, f'{style}: no crosshair in the inventory')
+            shot(game, f'glyph_art_{style}_crosshair')
+        finally:
+            game.quit()
+    return check.failures
+
+
+def controller_trigger_threshold(args, name):
+    game = Game(args, name)
+    check = Check()
+    try:
+        open_controller(game)
+        game.pad('right')
+        for _ in range(24):
+            if 'trigger threshold' in (game.focused_label() or '').lower():
+                break
+            game.pad('down')
+        check('40%' in (game.focused_label() or ''), f'not on its default: {game.focused_label()}')
+        # A step of the D-pad is a pixel of the slider, which can be less than a percent.
+        for _ in range(6):
+            game.pad('right')
+            if '40%' not in (game.focused_label() or ''):
+                break
+        check('40%' not in (game.focused_label() or ''), f'right left it on {game.focused_label()}')
+        saved = next((line for line in controller_saved(game).splitlines() if line.startswith('triggerThreshold:')), '')
+        check(saved and float(saved.split(':')[1]) > 0.4, f'not saved: {saved}')
+    finally:
+        game.quit()
+    return check.failures
+
+
+
 CASES = {'idle_a': idle_a, 'idle_b': idle_b, 'idle_x': idle_x, 'release': release, 'move_cancels': move_cancels,
          'pad_release': pad_release, 'pause_y': pause_y, 'settings': settings, 'create_world': create_world,
          'world_options': world_options, 'key_row_b': key_row_b, 'lock_question': lock_question,
@@ -1609,7 +1957,19 @@ CASES = {'idle_a': idle_a, 'idle_b': idle_b, 'idle_x': idle_x, 'release': releas
          'controller_notices': controller_notices,
          'every_screen_has_targets': every_screen_has_targets,
          'pause_icon': pause_icon,
-         'erase_checkbox': erase_checkbox}
+         'erase_checkbox': erase_checkbox,
+         'glyph_art': glyph_art,
+         'glyph_art_world': glyph_art_world,
+         'key_row_a_x': key_row_a_x,
+         'prompt_dialog': prompt_dialog,
+         'prompt_dialog_field': prompt_dialog_field,
+         'prompt_keeps_typing': prompt_keeps_typing,
+         'prompt_keeps_crosshair': prompt_keeps_crosshair,
+         'osk_social': osk_social,
+         'osk_debug_options': osk_debug_options,
+         'osk_command_block': osk_command_block,
+         'osk_jigsaw': osk_jigsaw,
+         'controller_trigger_threshold': controller_trigger_threshold}
 
 
 def main():
diff --git a/tools/pad_parity_e2e.py b/tools/pad_parity_e2e.py
index a5898b1f6f..c6a8898d9e 100644
--- a/tools/pad_parity_e2e.py
+++ b/tools/pad_parity_e2e.py
@@ -13,6 +13,7 @@ Cases:
 - drop_stack: Ctrl+Q over an inventory slot throws the whole stack; the pad's left stick click
   (its "throw stack" button in menus) must too.
 - quick_move: Shift-click on an inventory slot moves the stack; so must the pad's Y.
+- gameplay_drop: Q in play throws one and Ctrl+Q the rest; the pad's drop button tapped and held must too.
 - screenshot: key.screenshot bound to the pad takes a screenshot as F2 does.
 
 Needs built fast binaries (`cargo build --profile fast -p horizon-client -p horizon-client-lib --bins`)
@@ -127,6 +128,35 @@ def quick_move(args, device):
         game.quit()
 
 
+def gameplay_drop(args, device):
+    """In play: one tap of drop, then the stack form. Returns the counts after each."""
+    game = Game(args, f'throw-{device}')
+    try:
+        game.ctl('command', 'gamemode survival')
+        game.ctl('command', 'item replace entity @s hotbar.0 with minecraft:oak_planks 16')
+        game.ctl('select', 1)
+        game.ctl('wait', 5)
+        if device == 'keyboard':
+            game.ctl('key', 'q', 'tap')
+        else:
+            game.ctl('pad', 'down', 'tap')
+        game.ctl('wait', 5)
+        one = hotbar_count(game, 0)
+        if device == 'keyboard':
+            game.ctl('key', 'ctrl', 'down')
+            game.ctl('key', 'q', 'tap')
+            game.ctl('key', 'ctrl', 'up')
+        else:
+            # Held past the stack threshold: Ctrl+Q has no button of its own.
+            game.ctl('pad', 'down', 'down')
+            time.sleep(1.5)
+            game.ctl('pad', 'down', 'up')
+        game.ctl('wait', 5)
+        return one, hotbar_count(game, 0)
+    finally:
+        game.quit()
+
+
 def screenshot(args, device):
     """Press the screenshot binding in game. Returns how many screenshots were written."""
     controller = 'bind_key.screenshot:select\nbind_key.playerlist:none\n' if device == 'pad' else ''
@@ -146,6 +176,7 @@ def screenshot(args, device):
 CASES = {
     'drop_stack': (drop_stack, 0),
     'quick_move': (quick_move, 0),
+    'gameplay_drop': (gameplay_drop, (15, 0)),
     'screenshot': (screenshot, 1),
 }