diff --git a/docs/dodstudio_commands.md b/docs/dodstudio_commands.md
index 29382f4a9..f42ec9074 100644
--- a/docs/dodstudio_commands.md
+++ b/docs/dodstudio_commands.md
@@ -43,6 +43,7 @@ the death cam).
 | `ds_sound_mute_voice_commands` | `0` | silences "fire in the hole!" and the rest, without touching the game's own `.wav` files; subtitles and speaker icons still show | [`goldsrc_hud_suppression.md`](goldsrc_hud_suppression.md) |
 | `ds_hud_hide_crosshair` | `0` | hides the crosshair and keeps it hidden, which the stock `crosshair` cvar can't do because `CHud::Redraw` forces the value back every frame | [`goldsrc_crosshair.md`](goldsrc_crosshair.md) |
 | `ds_spec_hide_bars` | `0` | hides the spectator panel while spectating, in a demo or live: the two dark bands across the top and bottom of the screen, the score, timer and player name on them, and the menu row DUCK brings up. On screen, with no capture running | [`goldsrc_spectator_bars.md`](goldsrc_spectator_bars.md) |
+| `ds_spec_hide_text` | `0` | hides the two lines the game prints when the view becomes a spectator camera: the camera mode's name, centred just above the bottom bar ("Locked Chase Cam", "Free Chase Cam", "Free Look", "First Person", `#Spec_Mode1`..`4`), and the green "Press DUCK for Spectator Menu" (`#Spec_Duck`). Both show in a POV demo when the player dies, and in HLTV when the camera mode changes. The mode name comes twice, from the game itself and as a `TextMsg` the server sent; both go. Every other centre-print and HUD message still shows. A line already on screen when it's turned on stays until it times out (#677) | `goldsrc-hooks/src/spectator_text.rs` |
 | `ds_spec_lock` | `0` | HLTV demos: the camera stays on the player being watched when they die. Without it the game moves to the next player four seconds later. The viewer's own keys still change player | [`goldsrc_spectator_camera.md`](goldsrc_spectator_camera.md) |
 | `ds_spec_deathcam` | `0` | HLTV demos: when the player being watched in first person dies, the view becomes the death cam their own recording shows, the camera 64 units behind their body pulling back and turning to the killer, with no gun, for 2.4 s; then it is the game's own view from their eyes again until they respawn. Without it the game rolls the dead player's eye view 80° and the dropped weapon fills the clip. A switch of its own, not part of `ds_spec_match_pov`: a movie wants it, a shoutcast following the fight does not. Stands down in a POV demo (`goldsrc-hooks/src/spectator_deathcam.rs`) | [`goldsrc_spectator_camera.md`](goldsrc_spectator_camera.md) |
 | `ds_hud_overview_players` | `0` | which players get an icon on the overview map: `0` the game's own (the team of the player being watched), `1` everyone, `2` only the other team, `3` only the player being watched (the recorder in a POV demo), `4` nobody. A POV demo only holds the enemies the recorder was sent, so in one they come and go; HLTV demos have everybody | `goldsrc-hooks/src/overview_players.rs` |
@@ -50,7 +51,8 @@ the death cam).
 | `ds_view_use_cl_bob` | `0` | a POV demo bobs the view and the gun by the `cl_bob` (and `cl_bobcycle`, `cl_bobup`) set now (#359). At `0` a POV demo shows the bob it recorded, the recording player's own settings (some recorders had none), because the engine replaces the view `client.dll` works out live with the recorded one (HLTV demos already follow the cvars). At `1` the recorded bob is swapped for the live one and keeps the rest of the recorded view. The gun's bob tilt stays out, as in every POV demo | `goldsrc-hooks/src/pov_live_bob.rs` |
 | `ds_capture_run_in_background` | `0` | the game runs at full speed while another window is in front. The engine otherwise waits up to 20 ms for input every frame while it isn't the active app (`CEngine::Frame` calls `SleepUntilInput` when `IsActiveApp` is false), about 45 frames a second, which slows a capture batch's fast-forward between clips 5-8x; this skips that wait. A menu left in the background keeps drawing at full speed while it's on | `goldsrc-hooks/src/run_in_background.rs` |
 | `ds_capture_stay_behind` | `0` | the game window stays behind the other windows while it records: HLAE no longer brings it to the front, topmost, for every recording. A minimised game records black frames (its window owns no pixels), so while this is on a minimise parks the game off-screen instead: restored without being activated and moved left of the whole desktop, same size, taskbar button kept (#723). Activating it (its taskbar button, alt-tab) or turning this off moves it back where it was. Studio turns it on for every batch unless Keep the Game Behind Your Windows While Capturing is off | `goldsrc-hooks/src/hlae_window.rs` |
-| `ds_hud_overview_team_marker` | `0` | HLTV: marks the player being watched on the overview map with their team's camera icon (`allies_camera.spr` / `axis_camera.spr` / `brit_camera.spr`) instead of `spec_camera.spr`. DoD Studio's bordered ones go in `dod_addon/sprites` | `goldsrc-hooks/src/overview_marker.rs` |
+| `ds_hud_overview_team_marker` | `0` | which camera icon marks the player being watched on the overview map: `0` the game's own, `1` their team's in HLTV too, `2` none. `1` uses `allies_camera.spr` / `axis_camera.spr` / `brit_camera.spr` instead of `spec_camera.spr`; DoD Studio's bordered ones go in `dod_addon/sprites`. `2` works in POV and HLTV, so `spec_camera.spr` needs no blanking, and the player icons stay (#677) | `goldsrc-hooks/src/overview_marker.rs` |
+| `ds_hud_overview_hide_speaker` | `0` | leaves the speaker icon (`mapsprites/speakerIcon.spr`) off the players' icons on the overview map, so the sprite needs no blanking; the player icons stay, unlike `ds_hud_overview_players 4`. What makes the game draw it (a player talking or using a voice command) is a guess (#677) | `goldsrc-hooks/src/overview_speaker.rs` |
 | `ds_view_hide_headshot_red_screen` | `0` | POV demos: drops the red screen flash (a server `ScreenFade` of (128,0,0) at alpha 200, flags 0) that comes with every hit on the player's head hitbox, fatal or not, grenades included (#606). The black fades (the clear at respawn, the end of the map) still play | `goldsrc-hooks/src/screen_effects.rs` |
 | `ds_view_hide_screen_shake` | `0` | POV demos: drops every server `ScreenShake`, which in DoD demos is the blast shake from a grenade going off nearby (always amplitude 15 for 1 s; no WSOD25 map has an `env_shake`) (#606) | same |
 | `ds_hud_show_scope` | `1` | shows the sniper scope while a demo plays. The game turns it off for playback (`CHudScope::DrawTriApiScope` skips its draw when `IsPlayingback()`). A POV demo shows the recorder's own scope whenever they zoomed. Watching in-eye, the game always picks the Springfield's scope; with this on it is the watched player's rifle: the scoped K98 and scoped FG42 get `scope_k43`, the Springfield `scope_spring`, the scoped Enfield `scope_enfield` (that one only when the game's scoped-weapon flag is set, which an HLTV viewer may not have). Still only while the view is zoomed (#307). The round scope keeps its size and everything outside its frame is black, at any FOV: DoD sizes the frame for the view it expects, so `gl_widescreen_yfov 1` (25th Anniversary) or a wider `mirv_fov` used to show the map around it; demos only, live play keeps the game's own scope (#799) | `goldsrc-hooks/src/demo_scope.rs`, `goldsrc-hooks/src/demo_scope/fill.rs`, [`goldsrc_hud_elements.md`](goldsrc_hud_elements.md) |
@@ -58,6 +60,7 @@ the death cam).
 | `ds_hud_hide_voice_menus` | `0` | hides the numbered menus a POV demo's player picked voice commands and hand signals from: the three voice-command menus (`voice_menu1`-`3`, which the server sends as `ShowMenu` with the nine `#Menu_*Voice*` keys) and the command menu `+commandmenu` opens, where the hand signals are. The menus still take the recorded number presses, so weapon switches replay as recorded; other `ShowMenu` text menus (server plugin votes) still show. While on, `+commandmenu` doesn't open in live play either. Turning it on or off with a voice menu up hides or shows it at once | `goldsrc-hooks/src/voice_menus.rs` |
 | `ds_hud_hide_map_text` | `0` | hides the text a map puts on screen itself -- the `dod_anzio` mortar warning, the round result -- by matching each `HudText` message against the `message` strings the loaded map's own entities declare. DoD's own prompts on the same channel (`#Clan_allies_ready` and friends) still show. Reads the map's BSP once per level | `goldsrc-hooks/src/map_text.rs` |
 | `ds_hud_hide_clan_text` | `0` | hides all of DoD's clan-match text: the warm-up and ready rules, "Warmup Mode" on the left, the countdown to the match and "MATCH IS LIVE!". Drops the `#clan_*` `TextMsg` keys, swallows `ClanTimer` (which draws both the countdown and "MATCH IS LIVE!") and clears `GameRules`' warm-up flag. Turning it off mid-countdown brings the countdown back at once; turning it on mid-countdown removes "Warmup Mode" but not yet a countdown already showing (#618). Leaves everything else alone, round-start text included | `goldsrc-hooks/src/clan_text.rs` |
+| `ds_hud_hide_center_text` | `0` | hides the text the server prints in the middle of the screen: every `TextMsg` to `HUD_PRINTCENTER` (destination 4), such as match plugins' `print_center` countdowns and notices. Chat, joins and leaves (destination 3) still show. Turning it on also ends the centre line showing at that moment. Takes the server's copy of the spectator camera mode's name too, but not the game's own (`ds_spec_hide_text` hides both); doesn't reach the clan countdown (`ds_hud_hide_clan_text`) or the engine's own `svc_centerprint` (#677) | `goldsrc-hooks/src/center_text.rs` |
 | `ds_demo_ex_interp_max` | `100` (the engine's own ceiling) | raises the engine's clamp on `ex_interp` above its stock 100 ms ceiling, for smoother entity motion between snapshots; refuses `<=50` or `>1000`. Mechanism live-proven on pre-Anniversary, no specific value settled on yet. On the 25th Anniversary build (where HLTV demos already get 200 ms) any value but the default sets both paths | [`goldsrc_ex_interp.md`](goldsrc_ex_interp.md) |
 | `ds_hd_enabled` | `1` if there's a `dodstudio_hd` folder (in `dod_addon`, or `dod` for an install built before #415), else `0`; `GOLDSRC_HOOKS_TEXTURE_HIRES=1`/`0` at launch overrides | HD textures on/off: map textures, model skins, sprites (world and HUD, #728), decals, detail textures and skies from `dodstudio_hd`, and player sprays from PNGs in `logos` (`ds_player_spray`). `ds_debug_status` counts each kind's loads and replacements (HUD sprites apart from world sprites). A change applies to what loads next -- walls, detail and skies from the next map, models, sprites and decals already loaded after a restart. Turning it on in a session that started off installs the hook then | `goldsrc-hooks/src/texture_hires.rs`, `goldsrc-hooks/tools/hd/README.md` |
 | `ds_hd_style` | `ultrasharp` | which `dodstudio_hd/<type>/<style>` folder to use; a name with no folder means originals (plus `overrides`). Same timing as `ds_hd_enabled` | same |
diff --git a/docs/goldsrc_hud_elements.md b/docs/goldsrc_hud_elements.md
index 4541edf58..bc0f6cbba 100644
--- a/docs/goldsrc_hud_elements.md
+++ b/docs/goldsrc_hud_elements.md
@@ -146,8 +146,8 @@ ever been seen to make it draw:
 
 ### `vgui2print` is narrower than its name suggests
 
-`CHudVGUI2Print` has three real callers, but only one goes through the
-vtable slot this element hides:
+`CHudVGUI2Print` has two queueing methods and a drawing method. Only the
+queued text goes through the vtable slot this element hides:
 
 - `CHudDoDCommon` (key `Dod_mg_reload` -- "Deploy your machine gun to
   Reload!") calls a *queueing* method (`client+0x3a990`) that only writes
@@ -155,6 +155,17 @@ vtable slot this element hides:
   are drawn later, when `CHudVGUI2Print::Draw` itself runs and reads that
   state -- the vtable-dispatched path this element's hide actually
   intercepts. Live-confirmed.
+- A second queueing method (`client+0x3a830`, the same fields) takes every
+  centre-print: each `HUD_PRINTCENTER` `TextMsg` (`MsgFunc_TextMsg`'s
+  destination-4 branch, `client+0x4c3e9`), which includes the spectator
+  camera mode's name (`CHudSpectator::SetMode` calls `MsgFunc_TextMsg`
+  directly), and the clan-match countdown (`DrawClanTimer`,
+  `client+0x2d3f7`). `CHudVGUI2Print::Draw` (`client+0x3aa10`) draws these
+  too, so hiding `vgui2print` should hide **all centre text** along with the
+  MG-reload hint. Found offline (#677), not checked in the game. The narrow
+  switches are `ds_hud_hide_center_text` (server centre text),
+  `ds_spec_hide_text` (the camera mode's name) and
+  `ds_hud_hide_clan_text` (the countdown).
 - `CObjectiveIcons` (key `clan_warmup_mode` -- "Warmup Mode") calls a
   *drawing* method (`client+0x3a3f0`) that renders immediately via a shared
   low-level helper (`client+0x3a4b0`) at a fixed address, never touching
@@ -166,9 +177,9 @@ vtable slot this element hides:
   `menu`'s own vftable hide is what stops this, by not letting
   `CHudMenu::Draw` run at all.
 
-So `vgui2print` only ever hides queued, timed prompts like the MG-reload
-message. Anything drawn immediately through the shared helper is a different
-code path this element's vtable slot cannot see.
+So `vgui2print` only ever hides queued, timed prompts: the MG-reload message
+and every centre-print. Anything drawn immediately through the shared helper
+is a different code path this element's vtable slot cannot see.
 
 ### `all 1` is refused
 
diff --git a/goldsrc-hooks/src/center_text.rs b/goldsrc-hooks/src/center_text.rs
new file mode 100644
index 000000000..f407d0189
--- /dev/null
+++ b/goldsrc-hooks/src/center_text.rs
@@ -0,0 +1,160 @@
+//! `ds_hud_hide_center_text`: drop every `TextMsg` the server sends to the
+//! middle of the screen (`HUD_PRINTCENTER`, destination 4) -- match plugins'
+//! `print_center` countdowns and notices among them (#677).
+//!
+//! ## Where it comes from
+//!
+//! `CHudTextMessage::MsgFunc_TextMsg` (`+0x4c250`) switches on the first
+//! byte. Destination 4 goes to `+0x4c36a`, which posts the line to the
+//! centre-print object (`+0x175c6c`) through `+0x3a830`; it then shows until
+//! 4 s after the post. Destinations 1 (notify), 2 (console) and 3 (chat) go
+//! elsewhere and are left alone, so joins, leaves and chat lines still show.
+//!
+//! The only narrower-than-this switch before was `ds_hud_hide_element
+//! vgui2print 1`, which also takes the machine gun's "Deploy to reload" hint.
+//!
+//! ## What it doesn't reach
+//!
+//! - The spectator camera mode's name: `CHudSpectator::SetMode` calls
+//!   `MsgFunc_TextMsg` directly, not through the message dispatcher, so this
+//!   never sees the client's own copy. (The server's copy, a `#Spec_Mode`
+//!   `TextMsg` a demo carries, is centre text like any other and goes.)
+//!   `ds_spec_hide_text` hides both.
+//! - The viewport's own way in: entry 13 of the function table at
+//!   `+0xc1aa0` (`+0x20480`) also calls `MsgFunc_TextMsg` directly. What, if
+//!   anything, uses it has not been looked into.
+//! - The clan-match countdown: `ClanTimer` posts to the same object every
+//!   frame without a `TextMsg`; `ds_hud_hide_clan_text` covers it.
+//! - The engine's own `svc_centerprint`, which `client.dll` never sees.
+//!
+//! ## Mechanism
+//!
+//! `clan_text` already keeps a `TextMsg` handler at the front of the engine's
+//! list on every level, so its filter asks [`hide`] rather than a second
+//! handler taking turns with it. Turning the cvar on also ends the line on
+//! screen at that moment (`clan_text::end_center_line`), so a notice isn't
+//! left up for its last 4 s.
+
+use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicU32, Ordering};
+
+use crate::engine::CvarSPartial;
+use crate::names::console_name;
+
+pub const NAME: &str = console_name!("hud_hide_center_text");
+
+/// `TextMsg`'s destination byte for the middle of the screen.
+const HUD_PRINTCENTER: u8 = 4;
+
+/// Hidden messages logged one by one before only the count goes on.
+const LOGGED_MAX: u32 = 20;
+
+static CVAR: AtomicPtr<CvarSPartial> = AtomicPtr::new(std::ptr::null_mut());
+/// The cvar's value as last seen: what the message handler reads.
+static WANTED: AtomicBool = AtomicBool::new(false);
+/// Messages hidden this session.
+static HIDDEN: AtomicU32 = AtomicU32::new(0);
+
+/// Called by `commands.rs` once the cvar is registered.
+pub fn set_cvar(cvar: *mut CvarSPartial) {
+    CVAR.store(cvar, Ordering::Release);
+}
+
+/// Whether a `TextMsg` payload (destination byte, then the text or key) goes
+/// to the middle of the screen.
+fn is_center_text(payload: &[u8]) -> bool {
+    payload.first() == Some(&HUD_PRINTCENTER)
+}
+
+/// Whether `clan_text`'s `TextMsg` filter should drop this payload. Called
+/// with the game's message handling waiting on the answer, so it costs an
+/// atomic load and a byte compare unless it hides something.
+pub(crate) fn hide(payload: &[u8]) -> bool {
+    if !WANTED.load(Ordering::Relaxed) || !is_center_text(payload) {
+        return false;
+    }
+    let count = HIDDEN.fetch_add(1, Ordering::Relaxed) + 1;
+    if count <= LOGGED_MAX {
+        let text = payload[1..].split(|&b| b == 0).next().unwrap_or_default();
+        unsafe {
+            crate::debug::report(&format!(
+                "center_text: hid \"{}\"{}",
+                String::from_utf8_lossy(text).trim(),
+                if count == LOGGED_MAX {
+                    " (the rest are only counted)"
+                } else {
+                    ""
+                }
+            ))
+        };
+    }
+    true
+}
+
+/// Follows the cvar. Called every frame from `commands::poll`.
+pub fn poll() {
+    let cvar = CVAR.load(Ordering::Acquire);
+    if cvar.is_null() {
+        return;
+    }
+    let wanted = unsafe { (*cvar).value } != 0.0;
+    if wanted == WANTED.swap(wanted, Ordering::Relaxed) {
+        return;
+    }
+    let cleared = if wanted {
+        match crate::clan_text::end_center_line() {
+            Ok(()) => ", the line on screen ended".to_string(),
+            Err(why) => format!(", a line on screen stays up to 4 s: {why}"),
+        }
+    } else {
+        String::new()
+    };
+    unsafe {
+        crate::debug::report(&format!(
+            "center_text: {NAME} = {}{cleared}",
+            if wanted {
+                "1 (server centre text hidden)"
+            } else {
+                "0 (normal)"
+            }
+        ))
+    };
+}
+
+/// A `ds_debug_status` line, or `None` while off and never used.
+pub fn status_line() -> Option<String> {
+    let wanted = WANTED.load(Ordering::Relaxed);
+    let hidden = HIDDEN.load(Ordering::Relaxed);
+    if !wanted && hidden == 0 {
+        return None;
+    }
+    Some(format!(
+        "{NAME} = {} -- {hidden} centre-text message(s) hidden this session",
+        u8::from(wanted)
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn text_msg(dest: u8, text: &str) -> Vec<u8> {
+        let mut out = vec![dest];
+        out.extend(text.as_bytes());
+        out.push(0);
+        out
+    }
+
+    #[test]
+    fn only_destination_four_is_centre_text() {
+        assert!(is_center_text(&text_msg(4, "Match starts in 10")));
+        assert!(is_center_text(&text_msg(4, "#Clan_time_remaining")));
+        for dest in [1, 2, 3, 5, 0] {
+            assert!(
+                !is_center_text(&text_msg(dest, "#Game_joined_game")),
+                "{dest}"
+            );
+        }
+        assert!(!is_center_text(&[]));
+        assert!(is_center_text(&[4]), "an empty centre line is still one");
+    }
+}
diff --git a/goldsrc-hooks/src/clan_text.rs b/goldsrc-hooks/src/clan_text.rs
index 8f96fc392..664caef04 100644
--- a/goldsrc-hooks/src/clan_text.rs
+++ b/goldsrc-hooks/src/clan_text.rs
@@ -51,7 +51,8 @@
 //! through `msglog`'s thunk table, nothing is patched. While
 //! `ds_debug_msglog` watches one of these messages its record sits in
 //! front and asks [`filter`] instead, so the two don't take turns at the head
-//! of the engine's list.
+//! of the engine's list. `center_text` (#677) rides on the same `TextMsg`
+//! handler for the same reason: [`filter`] asks it too.
 
 use std::ffi::{CStr, CString, c_char, c_void};
 use std::sync::Mutex;
@@ -178,6 +179,16 @@ pub(crate) fn filter(name: &str, size: i32, buf: *mut c_void) -> Option<i32> {
             note_hidden(&format!("TextMsg \"{}\"", String::from_utf8_lossy(key)));
             return Some(1);
         }
+        // ds_hud_hide_center_text shares this handler rather than taking
+        // turns with it at the head of the engine's list (#677).
+        if crate::center_text::hide(payload) {
+            return Some(1);
+        }
+        // And ds_spec_hide_text, for the server's own copy of
+        // the camera mode name.
+        if crate::spectator_text::hide_text_msg(payload) {
+            return Some(1);
+        }
         return None;
     }
     if name.eq_ignore_ascii_case(CLAN_TIMER) {
@@ -213,10 +224,11 @@ fn remember(update: impl FnOnce(&mut Last)) {
     }
 }
 
-/// Ends the hold on the countdown's last line, so it goes the moment the
-/// countdown stops instead of 4 s later. Only called while the countdown is
-/// running, when that line is the one the object shows.
-fn end_countdown_line() -> Result<(), String> {
+/// Ends the hold on the centre-print object's line, so it goes now instead of
+/// 4 s after its post. Called here only while the countdown is running, when
+/// that line is the one the object shows; `center_text` calls it as its cvar
+/// turns on, when any centre line showing is one to end (#677).
+pub(crate) fn end_center_line() -> Result<(), String> {
     let base = engine::client_module_base().ok_or("client.dll is not loaded yet")?;
     // Safety: `client_module_base` only returns a base for a mapped module,
     // and it stays mapped for the session.
@@ -251,7 +263,7 @@ fn redeliver(hide: bool) {
                 let sent = if hide { 0 } else { left };
                 let result = deliver(CLAN_TIMER, &mut [sent]);
                 let line = if hide {
-                    match end_countdown_line() {
+                    match end_center_line() {
                         Ok(()) => ", its last line cleared".to_string(),
                         Err(why) => format!(", its last line stays up to 4 s: {why}"),
                     }
diff --git a/goldsrc-hooks/src/commands.rs b/goldsrc-hooks/src/commands.rs
index dd0bae252..75c1ea63e 100644
--- a/goldsrc-hooks/src/commands.rs
+++ b/goldsrc-hooks/src/commands.rs
@@ -542,6 +542,11 @@ pub fn poll() {
     // the game's countdown and warm-up flag right when
     // ds_hud_hide_clan_text changes.
     crate::clan_text::poll();
+    // ds_hud_hide_center_text: its filter rides on clan_text's TextMsg
+    // handler, so this only follows the cvar.
+    crate::center_text::poll();
+    // ds_spec_hide_text: two code patches, byte-checked each frame.
+    crate::spectator_text::poll();
     // Keeps the ShowMenu handler prepended and the voice and command menus
     // hidden while ds_hud_hide_voice_menus is on.
     crate::voice_menus::poll();
@@ -595,6 +600,7 @@ pub fn poll() {
     crate::spectator_buttons::poll();
     crate::overview_players::poll();
     crate::overview_marker::poll();
+    crate::overview_speaker::poll();
     // Lifts the scope's demo gate and keeps the in-eye rifle current (#307).
     crate::demo_scope::poll();
     crate::run_in_background::poll();
@@ -799,6 +805,9 @@ fn status_text() -> String {
     if let Some(marker) = crate::overview_marker::status_line() {
         lines.push(marker);
     }
+    if let Some(speaker) = crate::overview_speaker::status_line() {
+        lines.push(speaker);
+    }
     if let Some(scope) = crate::demo_scope::status_line() {
         lines.push(scope);
     }
@@ -811,6 +820,12 @@ fn status_text() -> String {
     if let Some(clan_text) = crate::clan_text::status_line() {
         lines.push(clan_text);
     }
+    if let Some(center_text) = crate::center_text::status_line() {
+        lines.push(center_text);
+    }
+    if let Some(spectator_text) = crate::spectator_text::status_line() {
+        lines.push(spectator_text);
+    }
     if let Some(voice_menus) = crate::voice_menus::status_line() {
         lines.push(voice_menus);
     }
@@ -1651,6 +1666,12 @@ pub fn install() {
     if let Some(clan_text) = register(crate::clan_text::NAME, "0") {
         crate::clan_text::set_cvar(clan_text);
     }
+    if let Some(center_text) = register(crate::center_text::NAME, "0") {
+        crate::center_text::set_cvar(center_text);
+    }
+    if let Some(spectator_text) = register(crate::spectator_text::NAME, "0") {
+        crate::spectator_text::set_cvar(spectator_text);
+    }
     if let Some(voice_menus) = register(crate::voice_menus::NAME, "0") {
         crate::voice_menus::set_cvar(voice_menus);
     }
@@ -1675,6 +1696,9 @@ pub fn install() {
     if let Some(marker) = register(crate::overview_marker::NAME, "0") {
         crate::overview_marker::set_cvar(marker);
     }
+    if let Some(speaker) = register(crate::overview_speaker::NAME, "0") {
+        crate::overview_speaker::set_cvar(speaker);
+    }
     // On by default: a demo then shows the sniper scope the player saw.
     if let Some(scope) = register(crate::demo_scope::NAME, "1") {
         crate::demo_scope::set_cvar(scope);
@@ -1858,6 +1882,9 @@ mod tests {
             crate::spectator_deathcam::NAME,
             crate::overview_players::NAME,
             crate::overview_marker::NAME,
+            crate::overview_speaker::NAME,
+            crate::center_text::NAME,
+            crate::spectator_text::NAME,
             crate::demo_scope::NAME,
             crate::run_in_background::NAME,
             crate::hlae_window::CLOAK_NAME,
@@ -1871,6 +1898,43 @@ mod tests {
         }
     }
 
+    /// The console's autocomplete swaps a name that is the whole start of
+    /// another for the longer one on space, so none of #677's names may be
+    /// the start of any name in the crate, or have one as its start.
+    #[test]
+    fn the_hide_text_names_are_no_other_names_start() {
+        let ours = [
+            crate::overview_speaker::NAME,
+            crate::center_text::NAME,
+            crate::spectator_text::NAME,
+        ];
+        let mut all: Vec<String> = Vec::new();
+        for entry in std::fs::read_dir("src")
+            .unwrap()
+            .chain(std::fs::read_dir("src/anim_fix").unwrap())
+        {
+            let path = entry.unwrap().path();
+            if path.extension().is_none_or(|e| e != "rs") {
+                continue;
+            }
+            let text = std::fs::read_to_string(&path).unwrap();
+            for part in text.split("console_name!(\"").skip(1) {
+                let name = part.split('"').next().unwrap();
+                all.push(format!("dodstudio_{name}"));
+            }
+        }
+        assert!(all.len() > 50, "found only {} names", all.len());
+        for a in ours {
+            for b in &all {
+                if a == b {
+                    continue;
+                }
+                assert!(!b.starts_with(a), "{a} is the start of {b}");
+                assert!(!a.starts_with(b.as_str()), "{b} is the start of {a}");
+            }
+        }
+    }
+
     /// Every suppression cvar reads the same way: **1 does the thing the name
     /// says**, 0 leaves the game alone. That is the whole point of naming them
     /// `hide_*` / `mute_*` rather than after the thing they act on, and it is
diff --git a/goldsrc-hooks/src/hide_asset.rs b/goldsrc-hooks/src/hide_asset.rs
index 125278a0e..21161c81b 100644
--- a/goldsrc-hooks/src/hide_asset.rs
+++ b/goldsrc-hooks/src/hide_asset.rs
@@ -30,8 +30,10 @@
 //! `client.dll` has **zero** references to the string `"caparea"` anywhere in
 //! the binary (confirmed by a full binary string search) — it doesn't load
 //! or draw this sprite by name at all, unlike `mapsprites/speakerIcon.spr`/
-//! `voiceIcon.spr`, which are hardcoded HUD elements and already reachable
-//! through `voice.rs`.
+//! `voiceIcon.spr`, which `CHudSpectator::VidInit` loads by name for its own
+//! HUD drawing. `voice.rs` doesn't reach them (it only mutes
+//! voice-command sounds); `ds_hud_overview_hide_speaker`
+//! (`overview_speaker.rs`) skips the speaker icon's draw (#677).
 //!
 //! ## The mechanism: `HUD_AddEntity`
 //!
diff --git a/goldsrc-hooks/src/hudelement.rs b/goldsrc-hooks/src/hudelement.rs
index d97639d9a..c604dce43 100644
--- a/goldsrc-hooks/src/hudelement.rs
+++ b/goldsrc-hooks/src/hudelement.rs
@@ -120,8 +120,8 @@
 //!
 //! ## `vgui2print` is narrower than its name suggests
 //!
-//! `CHudVGUI2Print` has three real callers, not one, but only one of them goes
-//! through the vtable slot this element hides:
+//! `CHudVGUI2Print` has two queueing methods and a drawing method, and only
+//! the queued text goes through the vtable slot this element hides:
 //!
 //! - `CHudDoDCommon` (`client+0x3c007`, key `Dod_mg_reload` -- "Deploy your
 //!   machine gun to Reload!") calls a *queueing* method (`client+0x3a990`)
@@ -129,6 +129,12 @@
 //!   fields. The pixels are drawn later, when `CHudVGUI2Print::Draw` itself
 //!   runs and reads that state -- the vtable-dispatched path this element's
 //!   hide actually intercepts. Live-confirmed.
+//! - The second queueing method (`client+0x3a830`, the same fields) takes
+//!   every centre-print: `MsgFunc_TextMsg`'s `HUD_PRINTCENTER` branch
+//!   (`client+0x4c3e9`), and through it the spectator camera mode's name, and
+//!   the clan countdown (`client+0x2d3f7`). `Draw` (`client+0x3aa10`) shows
+//!   them until the time at `+0x14`, so hiding `vgui2print` should take all
+//!   centre text too -- offline (#677), not checked in the game.
 //! - `CObjectiveIcons` (`client+0x300f4`, key `clan_warmup_mode` -- "Warmup
 //!   Mode") calls a *drawing* method (`client+0x3a3f0`) that renders
 //!   immediately by calling a shared low-level helper (`client+0x3a4b0`) at
@@ -140,9 +146,10 @@
 //!   untouched by hiding `vgui2print` -- `menu`'s own vftable hide is what
 //!   stops this, by not letting `CHudMenu::Draw` run at all.
 //!
-//! So `vgui2print` only ever hides queued, timed prompts like the MG-reload
-//! message -- anything drawn immediately through the shared helper is a
-//! different code path this element's vtable slot cannot see.
+//! So `vgui2print` only ever hides queued, timed prompts -- the MG-reload
+//! message and centre text -- and anything drawn immediately through the
+//! shared helper is a different code path this element's vtable slot cannot
+//! see.
 //!
 //! ## Re-applied every frame
 //!
@@ -247,7 +254,7 @@ pub const ELEMENTS: &[Element] = &[
         name: "vgui2print",
         class: ".?AVCHudVGUI2Print@@",
         vftable_rva: 0xac3e0,
-        what: "queued timed text prompts, e.g. the MG \"Deploy...to Reload!\" message (see module docs)",
+        what: "queued timed text prompts: the MG \"Deploy...to Reload!\" message and centre text (see module docs)",
     },
 ];
 
diff --git a/goldsrc-hooks/src/lib.rs b/goldsrc-hooks/src/lib.rs
index 6d17245cc..687de9b2d 100644
--- a/goldsrc-hooks/src/lib.rs
+++ b/goldsrc-hooks/src/lib.rs
@@ -54,7 +54,10 @@
 //!   icon on the overview map -- the game's own team, everyone, the other
 //!   team, only the player being watched, or nobody (issue #304).
 //! - `overview_marker`: `ds_hud_overview_team_marker`, which marks the
-//!   player being watched in HLTV with his team's camera icon (#304).
+//!   player being watched in HLTV with his team's camera icon (#304), or
+//!   leaves the camera icon off the map (`2`, #677).
+//! - `overview_speaker`: `ds_hud_overview_hide_speaker`, which leaves the
+//!   speaker icon off the players' overview map icons (#677).
 //! - `demo_scope`: `ds_hud_show_scope`, which draws the sniper scope
 //!   while a demo plays, in-eye with the watched player's rifle (#307).
 //! - `run_in_background`: `ds_capture_run_in_background`, full speed while
@@ -157,6 +160,11 @@
 //! - `clan_text`: the `ds_hud_hide_clan_text` cvar -- hide all of DoD's
 //!   clan-match text: the warm-up and ready rules, "Warmup Mode", the
 //!   countdown and "MATCH IS LIVE!" (issue #608).
+//! - `center_text`: the `ds_hud_hide_center_text` cvar -- drop every
+//!   `TextMsg` the server sends to the middle of the screen (#677).
+//! - `spectator_text`: the `ds_spec_hide_text` cvar -- hide the
+//!   camera mode's name and the green "Press DUCK for Spectator Menu" when
+//!   the view becomes a spectator camera (#677).
 //! - `hltv_messages`: the `ds_spec_hide_hltv_messages` cvar -- drop the
 //!   HLTV proxy's on-screen text ("You're watching HLTV...") as it arrives,
 //!   instead of patching it out of the demo (issue #30).
@@ -188,6 +196,7 @@ mod anim_fix;
 mod batch;
 mod batch_end;
 mod behind_imports;
+mod center_text;
 mod clan_text;
 mod cmd_list;
 mod commands;
@@ -237,6 +246,7 @@ mod overview_hd;
 mod overview_map;
 mod overview_marker;
 mod overview_players;
+mod overview_speaker;
 mod panic_log;
 mod particle_hide;
 mod patch;
@@ -265,6 +275,7 @@ mod spectator_follow;
 mod spectator_gun;
 mod spectator_hud;
 mod spectator_target;
+mod spectator_text;
 mod spray;
 mod spray_hltv;
 mod sprite_blend;
diff --git a/goldsrc-hooks/src/msglog.rs b/goldsrc-hooks/src/msglog.rs
index e500af717..b7231956e 100644
--- a/goldsrc-hooks/src/msglog.rs
+++ b/goldsrc-hooks/src/msglog.rs
@@ -260,7 +260,8 @@ unsafe extern "C" fn hooked_msg(name: *const c_char, size: i32, buf: *mut c_void
             return 1;
         }
     }
-    // Same for ds_hud_hide_clan_text's three messages.
+    // Same for ds_hud_hide_clan_text's three messages, and
+    // ds_hud_hide_center_text's TextMsg, which clan_text's filter asks.
     if let Some(result) = name_str
         .as_deref()
         .and_then(|n| crate::clan_text::filter(n, size, buf))
diff --git a/goldsrc-hooks/src/overview_marker.rs b/goldsrc-hooks/src/overview_marker.rs
index 1ad31bf59..0fc94ba43 100644
--- a/goldsrc-hooks/src/overview_marker.rs
+++ b/goldsrc-hooks/src/overview_marker.rs
@@ -1,5 +1,6 @@
 //! `ds_hud_overview_team_marker`: in HLTV, mark the player being watched
-//! on the overview map with his team's camera icon, not `spec_camera.spr`.
+//! on the overview map with their team's camera icon, not `spec_camera.spr`
+//! (`1`), or leave the camera icon off the map altogether (`2`, #677).
 //!
 //! ## What the game does
 //!
@@ -26,9 +27,31 @@
 //! The stock `*_camera.spr` files are byte-for-byte the player icons, so on
 //! their own this changes nothing visible. DoD Studio puts bordered, themed
 //! ones in `dod_addon/sprites`; the game draws the camera icon about 1.5x the
-//! player icons, so the watched player stands out over his own icon.
+//! player icons, so the watched player stands out over their own icon.
+//!
+//! ## No camera icon (`2`)
+//!
+//! Whichever sprite was chosen, the draw is skipped when it is null:
+//!
+//! ```text
+//!     +0x2f43b  test esi, esi
+//!     +0x2f43d  je   +0x2f4a5               ; <- 74 66, made EB 66
+//!     +0x2f43f  fld  [...]                  ; the draw
+//!     ...
+//!     +0x2f4a5  pop  edi                    ; the function's epilogue
+//! ```
+//!
+//! With that `je` made a `jmp`, the game takes its own "no sprite" exit, the
+//! one it takes when a camera sprite failed to load, so nothing is left half
+//! done (the x87 stack is balanced there: the `fld` is after the branch).
+//! It works in POV and HLTV alike, since both reach this draw. Only the
+//! camera icon goes; the player icons were drawn in the loop before it.
+//! Without it the only way to hide the icon is blanking
+//! `sprites/spec_camera.spr`, which only HLTV draws: POV draws its team's
+//! `*_camera.spr` (#677). `tools/verify_hide_text_offsets.py` checks both
+//! branches, the `fld` after the skip and the epilogue it lands on.
 
-use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI32, AtomicPtr, AtomicUsize, Ordering};
 
 use crate::engine::{self, CvarSPartial};
 use crate::names::console_name;
@@ -36,25 +59,39 @@ use crate::scan;
 
 pub const NAME: &str = console_name!("hud_overview_team_marker");
 
-/// From the `IsSpectateOnly` call to the team test's `jne`.
+/// From the `IsSpectateOnly` call, through the team sprite choice, to the
+/// `je` that skips the draw when no sprite was chosen.
 const PATTERN: &str = "FF 15 ?? ?? ?? ?? 85 C0 74 08 8B 35 ?? ?? ?? ?? EB 26 \
-                       83 3D ?? ?? ?? ?? 02 75 08";
-/// The `je` in [`PATTERN`].
+                       83 3D ?? ?? ?? ?? 02 75 08 8B 35 ?? ?? ?? ?? EB 15 \
+                       A0 ?? ?? ?? ?? 8B 35 ?? ?? ?? ?? 84 C0 75 06 8B 35 ?? ?? ?? ?? \
+                       85 F6 74 66";
+/// The sprite choice's `je` in [`PATTERN`].
 const JE_AT: usize = 8;
+/// The draw's "no sprite" `je` in [`PATTERN`].
+const SKIP_AT: usize = 58;
 const JE: u8 = 0x74;
 const JMP: u8 = 0xEB;
 
+/// The game's own: `spec_camera.spr` in HLTV, the team's icon in POV.
+pub const GAME: i32 = 0;
+/// The team's camera icon in HLTV too.
+pub const TEAM: i32 = 1;
+/// No camera icon at all.
+pub const NONE: i32 = 2;
+
 static CVAR: AtomicPtr<CvarSPartial> = AtomicPtr::new(std::ptr::null_mut());
+/// The pattern's start, 0 before a successful scan.
 static ADDRESS: AtomicUsize = AtomicUsize::new(0);
 static SCANNED_BASE: AtomicUsize = AtomicUsize::new(0);
-static ON: AtomicBool = AtomicBool::new(false);
+/// The setting both bytes currently follow.
+static MODE: AtomicI32 = AtomicI32::new(GAME);
 static COMPLAINED: AtomicBool = AtomicBool::new(false);
 
 pub fn set_cvar(cvar: *mut CvarSPartial) {
     CVAR.store(cvar, Ordering::Release);
 }
 
-fn je_address() -> Result<usize, String> {
+fn pattern_address() -> Result<usize, String> {
     let base = engine::client_module_base().ok_or("client.dll is not loaded yet")?;
     if SCANNED_BASE.load(Ordering::Acquire) == base {
         let cached = ADDRESS.load(Ordering::Acquire);
@@ -64,41 +101,50 @@ fn je_address() -> Result<usize, String> {
     }
     // Safety: a mapped module, for the session.
     let found = unsafe { scan::find_unique(base, PATTERN) }
-        .map_err(|why| format!("could not find the camera icon's sprite choice -- {why}"))?;
-    let address = found + JE_AT;
-    ADDRESS.store(address, Ordering::Release);
+        .map_err(|why| format!("could not find the overview map's camera icon -- {why}"))?;
+    ADDRESS.store(found, Ordering::Release);
     SCANNED_BASE.store(base, Ordering::Release);
-    Ok(address)
+    Ok(found)
 }
 
-/// Applies or removes the change, returning whether a byte was written.
-/// Decides from the byte, so it is cheap to call every frame.
-pub fn set_on(on: bool) -> Result<bool, String> {
-    let address = je_address()?;
-    let want = if on { JMP } else { JE };
+/// Puts one short `je` in the wanted state, returning whether it was written.
+fn set_branch(address: usize, jump: bool, what: &str) -> Result<bool, String> {
+    let want = if jump { JMP } else { JE };
     // Safety: the scan proved this byte is mapped code.
     let present = unsafe { *(address as *const u8) };
     if present == want {
-        ON.store(on, Ordering::Release);
         return Ok(false);
     }
     if present != JE && present != JMP {
         return Err(format!(
-            "the camera icon's sprite choice holds {present:#04x}, neither {JE:#04x} nor {JMP:#04x} -- something else has patched it"
+            "{what} holds {present:#04x}, neither {JE:#04x} nor {JMP:#04x} -- something else has patched it"
         ));
     }
     if !unsafe { crate::patch::write_code_bytes(address, &[want]) } {
-        return Err("could not make the camera icon's sprite choice writable".to_string());
+        return Err(format!("could not make {what} writable"));
     }
-    ON.store(on, Ordering::Release);
     Ok(true)
 }
 
-fn describe(on: bool) -> &'static str {
-    if on {
-        "1: in HLTV the watched player is marked with their team's camera icon"
-    } else {
-        "0: in HLTV the watched player is marked with spec_camera.spr"
+/// Applies one setting, returning whether a byte was written. Decides from
+/// the bytes, so it is cheap to call every frame.
+pub fn set_mode(mode: i32) -> Result<bool, String> {
+    let found = pattern_address()?;
+    let chose = set_branch(
+        found + JE_AT,
+        mode == TEAM,
+        "the camera icon's sprite choice",
+    )?;
+    let skipped = set_branch(found + SKIP_AT, mode == NONE, "the camera icon's draw")?;
+    MODE.store(mode, Ordering::Release);
+    Ok(chose || skipped)
+}
+
+fn describe(mode: i32) -> &'static str {
+    match mode {
+        TEAM => "1: in HLTV the watched player is marked with their team's camera icon",
+        NONE => "2: no camera icon on the overview map",
+        _ => "0: in HLTV the watched player is marked with spec_camera.spr",
     }
 }
 
@@ -108,8 +154,14 @@ pub fn poll() {
     if cvar.is_null() {
         return;
     }
-    let wanted = unsafe { (*cvar).value } != 0.0;
-    match set_on(wanted) {
+    let raw = unsafe { (*cvar).value };
+    let wanted = if raw.is_finite() { raw as i32 } else { GAME };
+    let wanted = if (GAME..=NONE).contains(&wanted) {
+        wanted
+    } else {
+        GAME
+    };
+    match set_mode(wanted) {
         Ok(false) => COMPLAINED.store(false, Ordering::Relaxed),
         Ok(true) => {
             COMPLAINED.store(false, Ordering::Relaxed);
@@ -118,7 +170,7 @@ pub fn poll() {
             };
         }
         Err(why) => {
-            if wanted && !COMPLAINED.swap(true, Ordering::Relaxed) {
+            if wanted != GAME && !COMPLAINED.swap(true, Ordering::Relaxed) {
                 unsafe {
                     crate::debug::report(&format!(
                         "overview_marker: {NAME} not applied yet -- {why}"
@@ -129,10 +181,11 @@ pub fn poll() {
     }
 }
 
-/// One line for `ds_debug_status`, once it has been on: the setting,
-/// and the team the game is choosing the icon by right now.
+/// One line for `ds_debug_status`, while it is not the game's own:
+/// the setting, and the team the game is choosing the icon by right now.
 pub fn status_line() -> Option<String> {
-    if !ON.load(Ordering::Relaxed) {
+    let mode = MODE.load(Ordering::Relaxed);
+    if mode == GAME {
         return None;
     }
     let team = engine::client_module_base()
@@ -140,7 +193,7 @@ pub fn status_line() -> Option<String> {
         .map(|base| unsafe { *((base + 0xe8_8d0) as *const i32) });
     Some(format!(
         "overview map marker: {NAME} = {}; g_iTeamNumber = {team:?}",
-        describe(true)
+        describe(mode)
     ))
 }
 
@@ -164,4 +217,19 @@ mod tests {
             "cmp [g_iTeamNumber], 2"
         );
     }
+
+    #[test]
+    fn skip_at_indexes_the_no_sprite_je() {
+        let t: Vec<&str> = PATTERN.split_whitespace().collect();
+        assert_eq!(&t[SKIP_AT - 2..SKIP_AT], &["85", "F6"], "test esi, esi");
+        assert_eq!(&t[SKIP_AT..], &["74", "66"], "je, the pattern's last bytes");
+    }
+
+    #[test]
+    fn every_setting_has_words_and_out_of_range_is_the_games() {
+        for mode in GAME..=NONE {
+            assert!(describe(mode).starts_with(&mode.to_string()));
+        }
+        assert_eq!(describe(GAME), describe(7));
+    }
 }
diff --git a/goldsrc-hooks/src/overview_speaker.rs b/goldsrc-hooks/src/overview_speaker.rs
new file mode 100644
index 000000000..445bc1469
--- /dev/null
+++ b/goldsrc-hooks/src/overview_speaker.rs
@@ -0,0 +1,235 @@
+//! `ds_hud_overview_hide_speaker`: leave the speaker icon
+//! (`sprites/mapsprites/speakerIcon.spr`) off the players' icons on the
+//! overview map (#677).
+//!
+//! ## What the game does
+//!
+//! Inside `CHudDoDMap::DrawOverviewEntities`' per-player loop, right after a
+//! player's own icon, the game decides whether to put the speaker on it:
+//!
+//! ```text
+//!     +0x2f266  ... call CHudSpectator+0x3a230  ; is he talking? -> a timer
+//!     +0x2f287  mov  eax, [esi+4]               ; <- E9 to +0x2f31e
+//!     +0x2f28a  test eax, eax
+//!     +0x2f28c  je   ...                        ; a player, index 1..64,
+//!     ...                                       ; flagged; or the timer
+//!     +0x2f2b6  jne  +0x2f31e                   ; still running
+//!     +0x2f2b8  ...                             ; draw speakerIcon.spr
+//!     +0x2f31c  jmp  +0x2f322
+//!     +0x2f31e  mov  bl, [esp+0x13]             ; the next entry
+//! ```
+//!
+//! What sets the flag is a guess (a player talking, or a voice command);
+//! where it is drawn is not. The first five bytes of the decision, two whole
+//! instructions, become a `jmp` to the game's own "no speaker" exit, which
+//! the `jne` above names, so the loop goes straight on to the next entry. The
+//! talking timer is still kept; nothing reads `eax` or the flags at
+//! `+0x2f31e`, and the stock path into it arrives with `eax` holding an FPU
+//! status word anyway. Nothing branches into the patched span.
+//!
+//! The player icons stay, unlike `ds_hud_overview_players 4`, which was the
+//! only way to lose the speaker without blanking the sprite file.
+//!
+//! `tools/verify_hide_text_offsets.py` checks the span, the exit, that the
+//! skipped block draws the handle `CHudSpectator::VidInit` loads from
+//! `speakerIcon.spr`, and that nothing branches into the span.
+
+use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicU64, AtomicUsize, Ordering};
+
+use crate::engine::{self, CvarSPartial};
+use crate::names::console_name;
+use crate::scan;
+
+pub const NAME: &str = console_name!("hud_overview_hide_speaker");
+
+/// From the talking check's `mov ecx, [esi]` to the first instruction of the
+/// speaker draw, so both the span and the `jne` that names its exit are in it.
+const PATTERN: &str = "8B 0E 51 B9 ?? ?? ?? ?? E8 ?? ?? ?? ?? 84 C0 74 10 \
+                       DD 44 24 20 DC 05 ?? ?? ?? ?? D9 9E 28 01 00 00 \
+                       8B 46 04 85 C0 74 17 8B 06 83 F8 01 7C 10 83 F8 40 7F 0B \
+                       8B 0C 85 ?? ?? ?? ?? 85 C9 75 13 \
+                       D9 86 28 01 00 00 DC 5C 24 20 DF E0 25 00 41 00 00 75 66 \
+                       8A 5C 24 13";
+/// The patched span in [`PATTERN`]: `mov eax, [esi+4]; test eax, eax`.
+const SPAN_AT: usize = 33;
+/// What the span holds in the stock game.
+const STOCK: [u8; 5] = [0x8b, 0x46, 0x04, 0x85, 0xc0];
+/// The `jne rel8` whose target is the "no speaker" exit.
+const JNE_AT: usize = 80;
+
+static CVAR: AtomicPtr<CvarSPartial> = AtomicPtr::new(std::ptr::null_mut());
+/// The span's address, 0 before a successful scan.
+static ADDRESS: AtomicUsize = AtomicUsize::new(0);
+static SCANNED_BASE: AtomicUsize = AtomicUsize::new(0);
+/// A base the scan already failed on, so it isn't repeated every frame.
+static FAILED_BASE: AtomicUsize = AtomicUsize::new(0);
+/// The `jmp` to the exit, packed little-endian.
+static HIDDEN: AtomicU64 = AtomicU64::new(0);
+/// Set the first time the cvar is on, so a session that never asks for it
+/// never scans.
+static TOUCHED: AtomicBool = AtomicBool::new(false);
+static HIDDEN_NOW: AtomicBool = AtomicBool::new(false);
+static COMPLAINED: AtomicBool = AtomicBool::new(false);
+
+pub fn set_cvar(cvar: *mut CvarSPartial) {
+    CVAR.store(cvar, Ordering::Release);
+}
+
+/// `jmp rel32` from the span at `span` to `target`.
+fn jmp_to(span: usize, target: usize) -> [u8; 5] {
+    let rel = (target as i64 - (span as i64 + 5)) as i32;
+    let mut out = [0xe9, 0, 0, 0, 0];
+    out[1..].copy_from_slice(&rel.to_le_bytes());
+    out
+}
+
+fn span_address(base: usize) -> Result<usize, String> {
+    if SCANNED_BASE.load(Ordering::Acquire) == base {
+        let cached = ADDRESS.load(Ordering::Acquire);
+        if cached != 0 {
+            return Ok(cached);
+        }
+    }
+    if FAILED_BASE.load(Ordering::Acquire) == base {
+        return Err("the speaker icon's draw was not found in this client.dll".to_string());
+    }
+    // Safety: a mapped module, for the session.
+    let found = match unsafe { scan::find_unique(base, PATTERN) } {
+        Ok(found) => found,
+        Err(why) => {
+            FAILED_BASE.store(base, Ordering::Release);
+            return Err(format!("could not find the speaker icon's draw -- {why}"));
+        }
+    };
+    let jne = found + JNE_AT;
+    // Safety: inside the matched pattern.
+    let rel = unsafe { *((jne + 1) as *const i8) };
+    let exit = (jne + 2).wrapping_add_signed(rel as isize);
+    let span = found + SPAN_AT;
+    let mut packed = [0u8; 8];
+    packed[..5].copy_from_slice(&jmp_to(span, exit));
+    HIDDEN.store(u64::from_le_bytes(packed), Ordering::Release);
+    ADDRESS.store(span, Ordering::Release);
+    SCANNED_BASE.store(base, Ordering::Release);
+    Ok(span)
+}
+
+/// Shows or hides the speaker icon, returning whether anything was written.
+/// Decides from the bytes, so it is cheap to call every frame.
+fn set_hidden(base: usize, hidden: bool) -> Result<bool, String> {
+    let span = span_address(base)?;
+    let jump = HIDDEN.load(Ordering::Acquire).to_le_bytes();
+    let jump = &jump[..STOCK.len()];
+    let want: &[u8] = if hidden { jump } else { &STOCK };
+    // Safety: the scan proved these bytes are mapped code.
+    let present = unsafe { std::slice::from_raw_parts(span as *const u8, STOCK.len()) };
+    if present == want {
+        return Ok(false);
+    }
+    if present != STOCK && present != jump {
+        return Err(format!(
+            "the speaker icon's draw starts {present:02x?}, neither the stock {STOCK:02x?} nor {jump:02x?} -- something else has patched it"
+        ));
+    }
+    if !unsafe { crate::patch::write_code_bytes(span, want) } {
+        return Err("could not make the speaker icon's draw writable".to_string());
+    }
+    Ok(true)
+}
+
+/// Follows the cvar. Called every frame from `commands::poll`.
+pub fn poll() {
+    let cvar = CVAR.load(Ordering::Acquire);
+    if cvar.is_null() {
+        return;
+    }
+    let wanted = unsafe { (*cvar).value } != 0.0;
+    if wanted {
+        TOUCHED.store(true, Ordering::Relaxed);
+    } else if !TOUCHED.load(Ordering::Relaxed) {
+        return;
+    }
+    let Some(base) = engine::client_module_base() else {
+        return;
+    };
+    match set_hidden(base, wanted) {
+        Ok(wrote) => {
+            COMPLAINED.store(false, Ordering::Relaxed);
+            HIDDEN_NOW.store(wanted, Ordering::Relaxed);
+            if wrote {
+                unsafe {
+                    crate::debug::report(&format!(
+                        "overview_speaker: {NAME} = {}",
+                        if wanted {
+                            "1 (no speaker icon on the overview map)"
+                        } else {
+                            "0 (normal)"
+                        }
+                    ))
+                };
+            }
+        }
+        Err(why) => {
+            HIDDEN_NOW.store(false, Ordering::Relaxed);
+            if wanted && !COMPLAINED.swap(true, Ordering::Relaxed) {
+                unsafe {
+                    crate::debug::report(&format!(
+                        "overview_speaker: {NAME} not applied yet -- {why}"
+                    ))
+                };
+            }
+        }
+    }
+}
+
+/// One line for `ds_debug_status`, once the cvar has been on.
+pub fn status_line() -> Option<String> {
+    TOUCHED.load(Ordering::Relaxed).then(|| {
+        if HIDDEN_NOW.load(Ordering::Relaxed) {
+            format!("{NAME} = 1 -- the overview map draws no speaker icons")
+        } else {
+            format!("{NAME}: the overview map draws speaker icons")
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tokens() -> Vec<&'static str> {
+        PATTERN.split_whitespace().collect()
+    }
+
+    #[test]
+    fn the_offsets_index_the_instructions_they_name() {
+        let t = tokens();
+        for (i, byte) in STOCK.iter().enumerate() {
+            assert_eq!(
+                u8::from_str_radix(t[SPAN_AT + i], 16).ok(),
+                Some(*byte),
+                "STOCK is the pattern's own bytes at the span"
+            );
+        }
+        assert_eq!(&t[SPAN_AT + 5..SPAN_AT + 7], &["74", "17"], "je after it");
+        assert_eq!(t[JNE_AT], "75", "jne rel8");
+        assert_eq!(
+            &t[JNE_AT + 2..JNE_AT + 4],
+            &["8A", "5C"],
+            "the draw starts after the jne"
+        );
+        assert!(t.len() > JNE_AT + 2);
+    }
+
+    #[test]
+    fn the_jump_lands_on_its_target() {
+        // As in the shipped client.dll: +0x2f287 to +0x2f31e.
+        assert_eq!(
+            jmp_to(0x0192_f287, 0x0192_f31e),
+            [0xe9, 0x92, 0x00, 0x00, 0x00]
+        );
+        // And backwards.
+        assert_eq!(jmp_to(0x1000, 0x0f00), [0xe9, 0xfb, 0xfe, 0xff, 0xff]);
+        assert_eq!(STOCK.len(), jmp_to(0, 0).len(), "as wide as the span");
+    }
+}
diff --git a/goldsrc-hooks/src/spectator_text.rs b/goldsrc-hooks/src/spectator_text.rs
new file mode 100644
index 000000000..e4fb3b2bd
--- /dev/null
+++ b/goldsrc-hooks/src/spectator_text.rs
@@ -0,0 +1,362 @@
+//! `ds_spec_hide_text`: hide the two lines DoD prints when the
+//! view becomes a spectator camera (#677) -- the camera mode's name, centred
+//! just above the bottom bar ("Locked Chase Cam", "Free Look", ...), and the
+//! green "Press DUCK for Spectator Menu" written out above it.
+//!
+//! Neither has a narrow switch of its own. `ds_hud_hide_element
+//! vgui2print 1` takes the mode name with every other centre-print, and
+//! `message 1` takes the green line with map text, clan prompts and HLTV
+//! director text.
+//!
+//! ## The camera mode name
+//!
+//! `CHudSpectator::SetMode` (`+0x38850`), after a real mode change, builds
+//! `"%c%s"` with `HUD_PRINTCENTER` and `#Spec_Mode1`..`4`, then calls
+//! `CHudTextMessage::MsgFunc_TextMsg` (`+0x4c250`) **directly**, not through
+//! the engine's user-message dispatcher -- which is why a `TextMsg` hook
+//! (`clan_text`, `center_text`) never sees it:
+//!
+//! ```text
+//!     +0x38a11  push ecx                 ; pbuf: the "%c%s" buffer
+//!     +0x38a19  push ecx                 ; iSize: its length
+//!     +0x38a1a  push eax                 ; pszName: 0
+//!     +0x38a1b  mov  ecx, gHUD.m_TextMessage
+//!     +0x38a20  call MsgFunc_TextMsg     ; E8 rel32, ret 0xc   <- patched
+//!     +0x38a25  mov  ecx, [...]          ; eax and the flags are not read
+//! ```
+//!
+//! The call becomes `add esp, 0xc; nop; nop`: the three arguments come off
+//! the stack exactly as the callee's `ret 0xc` would have taken them, and
+//! nothing after it reads `eax`. Only this one call site changes, so every
+//! other centre-print (server text, the clan countdown) is untouched.
+//!
+//! ## The server's copy of the mode name
+//!
+//! A demo also carries the mode name as an ordinary `TextMsg` from the
+//! server: destination 4 with the key `#Spec_Mode1`..`4`, at every POV death
+//! and HLTV mode change. That one goes through the engine's message
+//! dispatcher, not `SetMode`, so the patch above never sees it, and in game it
+//! showed with the patch in place. `clan_text`'s `TextMsg` filter asks
+//! [`hide_text_msg`] for it, the same way it asks `center_text`.
+//!
+//! ## "Press DUCK for Spectator Menu"
+//!
+//! A helper at `+0x84780` fills a fixed `client_textmessage_t` (green, written
+//! out, `Spec_Duck`) and hands it to `CHudMessage::MessageAdd` through the
+//! viewport's function table. Its four callers all pass `#Spec_Duck`, and all
+//! pop their argument themselves (cdecl), so a `ret` (`C3`) over its first
+//! byte hides exactly this line and nothing else.
+//!
+//! ## Both are applied every frame
+//!
+//! Like `crosshair.rs`, the decision comes from the bytes: written while the
+//! cvar is 1, restored at 0, and a re-loaded `client.dll` is patched again.
+//! A line already on screen when the cvar turns on stays until it times out
+//! (the green line holds 6 s).
+//!
+//! `tools/verify_hide_text_offsets.py` checks both sites against a real
+//! `client.dll` (one file, identical in every install): the call's target and
+//! its `ret 0xc`, the three pushes, every `#Spec_Duck` caller popping its own
+//! argument, and nothing branching into either span.
+
+use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicU64, AtomicUsize, Ordering};
+
+use crate::engine::{self, CvarSPartial};
+use crate::names::console_name;
+use crate::scan;
+
+pub const NAME: &str = console_name!("spec_hide_text");
+
+/// One patched span in `client.dll`.
+struct Site {
+    /// For the log.
+    what: &'static str,
+    pattern: &'static str,
+    /// Where the patched span starts in `pattern`.
+    at: usize,
+    /// What the span holds while hidden. Its stock bytes are read at the scan,
+    /// so a revert writes back exactly what was there.
+    hidden: &'static [u8],
+}
+
+/// `CHudSpectator::SetMode`, from `push 4` (`HUD_PRINTCENTER`) to the
+/// instruction after the call to `MsgFunc_TextMsg`.
+const MODE_NAME: Site = Site {
+    what: "the camera mode name",
+    pattern: "6A 04 8D 44 24 40 68 ?? ?? ?? ?? 50 E8 ?? ?? ?? ?? 83 C4 20 \
+              8D 4C 24 28 8D 7C 24 28 33 C0 51 83 C9 FF F2 AE F7 D1 51 50 \
+              B9 ?? ?? ?? ?? E8 ?? ?? ?? ?? 8B 0D",
+    at: 45,
+    // add esp, 0xc; nop; nop
+    hidden: &[0x83, 0xc4, 0x0c, 0x90, 0x90],
+};
+
+/// The `#Spec_Duck` helper's prologue: the `strncpy` into its own buffer and
+/// the first two colour bytes (40 and 200).
+const SPEC_DUCK: Site = Site {
+    what: "\"Press DUCK for Spectator Menu\"",
+    pattern: "8B 44 24 04 68 80 00 00 00 50 68 ?? ?? ?? ?? E8 ?? ?? ?? ?? B0 28 B1 C8",
+    at: 0,
+    // ret
+    hidden: &[0xc3],
+};
+
+const SITES: [Site; 2] = [MODE_NAME, SPEC_DUCK];
+
+/// What one site's scan found.
+struct State {
+    /// The span's address, 0 before a successful scan.
+    address: AtomicUsize,
+    /// The module base `address` belongs to.
+    base: AtomicUsize,
+    /// A base the scan already failed on, so it isn't repeated every frame.
+    failed_base: AtomicUsize,
+    /// The stock bytes, little-endian, `hidden.len()` of them.
+    stock: AtomicU64,
+    /// Whether a failure has been reported, so it is said once.
+    complained: AtomicBool,
+}
+
+impl State {
+    const fn new() -> Self {
+        Self {
+            address: AtomicUsize::new(0),
+            base: AtomicUsize::new(0),
+            failed_base: AtomicUsize::new(0),
+            stock: AtomicU64::new(0),
+            complained: AtomicBool::new(false),
+        }
+    }
+}
+
+static STATES: [State; 2] = [State::new(), State::new()];
+
+static CVAR: AtomicPtr<CvarSPartial> = AtomicPtr::new(std::ptr::null_mut());
+/// Set the first time the cvar is on, so a session that never asks for it
+/// never scans.
+static TOUCHED: AtomicBool = AtomicBool::new(false);
+/// Whether both lines are hidden right now.
+static HIDDEN_NOW: AtomicBool = AtomicBool::new(false);
+/// The cvar's value as last seen: what [`hide_text_msg`] reads.
+static WANTED: AtomicBool = AtomicBool::new(false);
+
+/// `TextMsg`'s destination byte for the middle of the screen.
+const HUD_PRINTCENTER: u8 = 4;
+/// The start of the mode names' `titles.txt` keys.
+const MODE_KEY: &[u8] = b"#Spec_Mode";
+
+/// Called by `commands.rs` once the cvar is registered.
+pub fn set_cvar(cvar: *mut CvarSPartial) {
+    CVAR.store(cvar, Ordering::Release);
+}
+
+/// Whether a `TextMsg` payload (destination byte, then the key) is the
+/// server's copy of the camera mode name.
+fn is_mode_name(payload: &[u8]) -> bool {
+    payload.first() == Some(&HUD_PRINTCENTER) && payload[1..].starts_with(MODE_KEY)
+}
+
+/// Whether `clan_text`'s `TextMsg` filter should drop this payload: the
+/// cvar is on and it is the server's copy of the mode name (see the module
+/// doc). An atomic load and a byte compare.
+pub(crate) fn hide_text_msg(payload: &[u8]) -> bool {
+    WANTED.load(Ordering::Relaxed) && is_mode_name(payload)
+}
+
+fn pack(bytes: &[u8]) -> u64 {
+    let mut out = [0u8; 8];
+    out[..bytes.len()].copy_from_slice(bytes);
+    u64::from_le_bytes(out)
+}
+
+fn unpack(packed: u64, len: usize) -> Vec<u8> {
+    packed.to_le_bytes()[..len].to_vec()
+}
+
+/// The site's address in the module at `base`, scanning once per module.
+fn resolve(site: &Site, state: &State, base: usize) -> Result<usize, String> {
+    if state.base.load(Ordering::Acquire) == base {
+        let cached = state.address.load(Ordering::Acquire);
+        if cached != 0 {
+            return Ok(cached);
+        }
+    }
+    if state.failed_base.load(Ordering::Acquire) == base {
+        return Err(format!("{} was not found in this client.dll", site.what));
+    }
+    // Safety: `client_module_base` only returns a base for a mapped module,
+    // and it stays mapped for the session.
+    let found = match unsafe { scan::find_unique(base, site.pattern) } {
+        Ok(found) => found,
+        Err(why) => {
+            state.failed_base.store(base, Ordering::Release);
+            return Err(format!("could not find {} -- {why}", site.what));
+        }
+    };
+    let address = found + site.at;
+    // Safety: the pattern matched, so the span is mapped code.
+    let present =
+        unsafe { std::slice::from_raw_parts(address as *const u8, site.hidden.len()) }.to_vec();
+    if present == site.hidden {
+        state.failed_base.store(base, Ordering::Release);
+        return Err(format!(
+            "{} is already patched in a client.dll this module never scanned",
+            site.what
+        ));
+    }
+    state.stock.store(pack(&present), Ordering::Release);
+    state.address.store(address, Ordering::Release);
+    state.base.store(base, Ordering::Release);
+    Ok(address)
+}
+
+/// Puts one site in the wanted state, returning whether anything was written.
+fn apply(site: &Site, state: &State, base: usize, hidden: bool) -> Result<bool, String> {
+    let address = resolve(site, state, base)?;
+    let stock = unpack(state.stock.load(Ordering::Acquire), site.hidden.len());
+    let want: &[u8] = if hidden { site.hidden } else { &stock };
+    // Safety: `resolve` proved the span is mapped code.
+    let present = unsafe { std::slice::from_raw_parts(address as *const u8, want.len()) };
+    if present == want {
+        return Ok(false);
+    }
+    if present != stock.as_slice() && present != site.hidden {
+        return Err(format!(
+            "{} holds {present:02x?}, neither the stock {stock:02x?} nor {:02x?} -- something else has patched it",
+            site.what, site.hidden
+        ));
+    }
+    if !unsafe { crate::patch::write_code_bytes(address, want) } {
+        return Err(format!("could not make {} writable", site.what));
+    }
+    Ok(true)
+}
+
+/// Follows the cvar. Called every frame from `commands::poll`.
+pub fn poll() {
+    let cvar = CVAR.load(Ordering::Acquire);
+    if cvar.is_null() {
+        return;
+    }
+    let wanted = unsafe { (*cvar).value } != 0.0;
+    WANTED.store(wanted, Ordering::Relaxed);
+    if wanted {
+        TOUCHED.store(true, Ordering::Relaxed);
+    } else if !TOUCHED.load(Ordering::Relaxed) {
+        return;
+    }
+    let Some(base) = engine::client_module_base() else {
+        return;
+    };
+    let mut all = true;
+    for (site, state) in SITES.iter().zip(&STATES) {
+        match apply(site, state, base, wanted) {
+            Ok(wrote) => {
+                state.complained.store(false, Ordering::Relaxed);
+                if wrote {
+                    unsafe {
+                        crate::debug::report(&format!(
+                            "spectator_text: {NAME} = {} -- {} {}",
+                            u8::from(wanted),
+                            site.what,
+                            if wanted { "hidden" } else { "shows again" }
+                        ))
+                    };
+                }
+            }
+            Err(why) => {
+                all = false;
+                if wanted && !state.complained.swap(true, Ordering::Relaxed) {
+                    unsafe {
+                        crate::debug::report(&format!(
+                            "spectator_text: {NAME} not applied yet -- {why}"
+                        ))
+                    };
+                }
+            }
+        }
+    }
+    HIDDEN_NOW.store(wanted && all, Ordering::Relaxed);
+}
+
+/// One line for `ds_debug_status`, once the cvar has been on.
+pub fn status_line() -> Option<String> {
+    if !TOUCHED.load(Ordering::Relaxed) {
+        return None;
+    }
+    Some(if HIDDEN_NOW.load(Ordering::Relaxed) {
+        format!(
+            "{NAME} = 1 -- the camera mode name and \"Press DUCK for Spectator Menu\" are hidden"
+        )
+    } else {
+        format!("{NAME}: the camera mode name and \"Press DUCK for Spectator Menu\" show")
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tokens(site: &Site) -> Vec<&'static str> {
+        site.pattern.split_whitespace().collect()
+    }
+
+    #[test]
+    fn every_pattern_is_hex_or_wildcard_and_reaches_past_its_span() {
+        for site in &SITES {
+            let t = tokens(site);
+            assert!(t.len() > site.at + site.hidden.len(), "{}", site.what);
+            assert_ne!(t[0], "??", "a pattern can't start with a wildcard");
+            for token in &t {
+                assert!(
+                    *token == "??" || u8::from_str_radix(token, 16).is_ok(),
+                    "{token:?} in {}",
+                    site.what
+                );
+            }
+            assert!(site.hidden.len() <= 8, "the stock bytes are kept in a u64");
+        }
+    }
+
+    /// The mode name's span is the `call rel32`, and what replaces it pops the
+    /// callee's three arguments: `ret 0xc` on a `__thiscall` of three.
+    #[test]
+    fn the_mode_name_call_becomes_add_esp_12() {
+        let t = tokens(&MODE_NAME);
+        assert_eq!(t[MODE_NAME.at], "E8", "call rel32");
+        assert_eq!(t[MODE_NAME.at - 5], "B9", "mov ecx, imm32");
+        assert_eq!(MODE_NAME.hidden.len(), 5, "as wide as the call");
+        assert_eq!(&MODE_NAME.hidden[..3], &[0x83, 0xc4, 0x0c], "add esp, 0xc");
+        assert!(MODE_NAME.hidden[3..].iter().all(|&b| b == 0x90));
+        // HUD_PRINTCENTER is what this call site prints with.
+        assert_eq!(&t[..2], &["6A", "04"]);
+    }
+
+    /// `ret` over the helper's first byte, which the pattern pins as the
+    /// start of `mov eax, [esp+4]` -- its first instruction.
+    #[test]
+    fn the_spec_duck_helper_returns_at_once() {
+        let t = tokens(&SPEC_DUCK);
+        assert_eq!(SPEC_DUCK.at, 0);
+        assert_eq!(&t[..4], &["8B", "44", "24", "04"]);
+        assert_eq!(SPEC_DUCK.hidden, &[0xc3]);
+    }
+
+    #[test]
+    fn only_a_centre_spec_mode_key_is_the_servers_mode_name() {
+        assert!(is_mode_name(b"\x04#Spec_Mode4\0"));
+        assert!(is_mode_name(b"\x04#Spec_Mode1\0"));
+        assert!(!is_mode_name(b"\x03#Spec_Mode4\0"), "chat, not centre");
+        assert!(!is_mode_name(b"\x04#Spec_Duck\0"));
+        assert!(!is_mode_name(b"\x04#clan_ready_rules\0"));
+        assert!(!is_mode_name(b"\x04"));
+        assert!(!is_mode_name(b""));
+    }
+
+    #[test]
+    fn stock_bytes_survive_the_round_trip() {
+        let bytes = [0xe8, 0x2b, 0x38, 0x01, 0x00];
+        assert_eq!(unpack(pack(&bytes), bytes.len()), bytes);
+        assert_eq!(unpack(pack(&[0x8b]), 1), [0x8b]);
+    }
+}
diff --git a/goldsrc-hooks/tools/verify_hide_text_offsets.py b/goldsrc-hooks/tools/verify_hide_text_offsets.py
new file mode 100644
index 000000000..7c420a01d
--- /dev/null
+++ b/goldsrc-hooks/tools/verify_hide_text_offsets.py
@@ -0,0 +1,419 @@
+#!/usr/bin/env python3
+"""Checks #677's patches against a real DoD `client.dll`: `spectator_text.rs`,
+`overview_marker.rs`'s camera-icon skip, `overview_speaker.rs`, and the
+centre-print object `center_text.rs` relies on `clan_text.rs` to clear.
+
+Every pattern, offset and byte string is read out of the Rust rather than
+restated, and each patch is checked for what makes it safe, not only for
+where it lands.
+
+`spectator_text.rs`, the camera mode name:
+
+  1. The signature matches exactly once, a few instructions after
+     `push "#Spec_Mode%d"` (so it is `CHudSpectator::SetMode`).
+  2. The patched span is one `call`, to the function the `TextMsg` message
+     thunk (`msglog.rs`'s table) calls: `MsgFunc_TextMsg`.
+  3. Every `ret` in that function is `ret 0xc`, and exactly three arguments
+     are pushed for this call, so `add esp, 0xc` takes off what it would have.
+  4. The replacement decodes to `add esp, 0xc` and `nop`s, the same width.
+  5. Nothing after the call reads `eax` or the flags before the next call.
+
+`spectator_text.rs`, "Press DUCK for Spectator Menu":
+
+  6. The signature matches exactly once, at a function that names
+     `Spec_Duck` in its `client_textmessage_t`.
+  7. Every call to it pushes `"#Spec_Duck"` and pops its argument itself
+     (`add esp, 4` or `pop ecx`), so a `ret` there leaves the stack as it was.
+
+`overview_marker.rs`:
+
+  8. The signature matches once; `JE_AT` and `SKIP_AT` are short `je`s; the
+     skip follows `test esi, esi`, the draw after it starts with `fld`, and its
+     target is the function's epilogue (no x87 instruction before the `ret`).
+
+`overview_speaker.rs`:
+
+  9. The signature matches once; the span is `STOCK`, two whole instructions,
+     5 bytes; the `jne` at `JNE_AT` targets the next-entry code.
+ 10. The block between the `jne` and that target draws the sprite
+     `CHudSpectator::VidInit` loads from `speakerIcon.spr` (the instance in the
+     pattern's `mov ecx, imm32` plus the member `VidInit` stores it in).
+
+`center_text.rs` / `clan_text.rs`:
+
+ 11. `MsgFunc_TextMsg`'s destination-4 case posts to the same object whose
+     hold `clan_text::end_center_line` clears.
+
+All five patched spans:
+
+ 12. Nothing in `.text` branches into the middle of one.
+
+Usage:
+    python goldsrc-hooks/tools/verify_hide_text_offsets.py [path-to-client.dll]
+
+Defaults to the pre-Anniversary movies install. Requires `pefile` and
+`capstone` (`pip install pefile capstone`).
+"""
+
+import hashlib
+import re
+import struct
+import sys
+from pathlib import Path
+
+try:
+    import capstone
+    import pefile
+except ImportError:  # pragma: no cover - developer tooling
+    sys.exit("needs `pip install pefile capstone`")
+
+DEFAULT_DLL = Path(
+    r"C:\Program Files (x86)\Steam\steamapps\common"
+    r"\Half-Life - PRE-Anniversary for Movies\dod\cl_dlls\client.dll"
+)
+SRC = Path(__file__).resolve().parent.parent / "src"
+
+
+def join_rust_string(raw: str) -> str:
+    raw = re.sub(r"\\\s*\n\s*", " ", raw)
+    return " ".join(" ".join(re.findall(r'"([^"]*)"', raw)).split())
+
+
+def rust_str_const(src: str, name: str) -> str:
+    m = re.search(rf"const {name}:\s*&str\s*=\s*(.*?);", src, re.S)
+    if not m:
+        sys.exit(f"could not find const {name}")
+    return join_rust_string(m.group(1))
+
+
+def rust_usize(src: str, name: str) -> int:
+    m = re.search(rf"const {name}:\s*usize\s*=\s*(\d+);", src)
+    if not m:
+        sys.exit(f"could not find const {name}")
+    return int(m.group(1))
+
+
+def rust_bytes(text: str) -> bytes:
+    return bytes(int(x, 16) for x in re.findall(r"0x([0-9a-fA-F]{1,2})\b", text))
+
+
+def rust_site(src: str, name: str):
+    m = re.search(rf"const {name}: Site = Site \{{(.*?)\n\}};", src, re.S)
+    if not m:
+        sys.exit(f"could not find Site {name}")
+    body = m.group(1)
+    pattern = join_rust_string(re.search(r"pattern:\s*(.*?),\n\s*at:", body, re.S).group(1))
+    at = int(re.search(r"\bat:\s*(\d+)", body).group(1))
+    hidden = rust_bytes(re.search(r"hidden:\s*&\[(.*?)\]", body, re.S).group(1))
+    return pattern, at, hidden
+
+
+def parse_pattern(text):
+    return [None if t == "??" else int(t, 16) for t in text.split()]
+
+
+class Image:
+    def __init__(self, path: Path):
+        self.pe = pefile.PE(str(path), fast_load=True)
+        self.img = self.pe.get_memory_mapped_image()
+        self.base = self.pe.OPTIONAL_HEADER.ImageBase
+        text = self.pe.sections[0]
+        self.lo = text.VirtualAddress
+        self.hi = text.VirtualAddress + text.Misc_VirtualSize
+        self.md = capstone.Cs(capstone.CS_ARCH_X86, capstone.CS_MODE_32)
+        self.md.detail = True
+        self._sweep = None
+
+    def find_all(self, pattern):
+        pat = parse_pattern(pattern)
+        code = self.img[self.lo : self.hi]
+        out = []
+        first = pat[0]
+        i = code.find(bytes([first]))
+        while i >= 0 and i + len(pat) <= len(code):
+            if all(w is None or code[i + k] == w for k, w in enumerate(pat)):
+                out.append(self.lo + i)
+            i = code.find(bytes([first]), i + 1)
+        return out
+
+    def dis(self, rva, size):
+        return list(self.md.disasm(self.img[rva : rva + size], self.base + rva))
+
+    def one(self, rva):
+        return next(self.md.disasm(self.img[rva : rva + 16], self.base + rva))
+
+    def u32(self, rva):
+        return struct.unpack_from("<I", self.img, rva)[0]
+
+    def cstr_rva(self, text: bytes):
+        i = self.img.find(text + b"\0")
+        while i > 0 and self.img[i - 1] != 0:
+            i = self.img.find(text + b"\0", i + 1)
+        return i if i >= 0 else None
+
+    def target(self, ins):
+        """The RVA a direct call/jump goes to, or None."""
+        op = ins.op_str
+        if op.startswith("0x"):
+            return int(op, 16) - self.base
+        return None
+
+    def sweep(self):
+        """Every instruction in .text by linear sweep (data decodes as junk,
+        which is why only direct branches are taken from it)."""
+        if self._sweep is None:
+            md = capstone.Cs(capstone.CS_ARCH_X86, capstone.CS_MODE_32)
+            md.skipdata = True
+            self._sweep = [
+                (i.address - self.base, i.size, i.mnemonic, i.op_str)
+                for i in md.disasm(self.img[self.lo : self.hi], self.base + self.lo)
+            ]
+        return self._sweep
+
+    def branches_into(self, start, end):
+        """Direct calls and jumps landing strictly inside (start, end)."""
+        hits = []
+        for addr, _size, mnem, op in self.sweep():
+            if (mnem == "call" or mnem.startswith("j")) and op.startswith("0x"):
+                t = int(op, 16) - self.base
+                if start < t < end:
+                    hits.append((addr, mnem, t))
+        return hits
+
+    def callers(self, rva):
+        return [a for a, _s, m, op in self.sweep() if m == "call" and op.startswith("0x") and int(op, 16) - self.base == rva]
+
+    def function_rets(self, start, limit=0x800):
+        """The `ret`s of the function at `start`: walks forward, following the
+        furthest forward branch target, and stops at a ret past all of them."""
+        rets = []
+        furthest = start
+        for ins in self.dis(start, limit):
+            rva = ins.address - self.base
+            t = self.target(ins)
+            if t is not None and ins.mnemonic.startswith("j") and t > furthest:
+                furthest = t
+            if ins.mnemonic == "ret":
+                rets.append((rva, ins.op_str))
+                if rva >= furthest:
+                    break
+        return rets
+
+
+def main() -> int:
+    dll = Path(sys.argv[1]) if len(sys.argv) > 1 else DEFAULT_DLL
+    if not dll.is_file():
+        sys.exit(f"no client.dll at {dll}")
+    im = Image(dll)
+    print(f"client.dll: {dll}")
+    print(f"sha256: {hashlib.sha256(dll.read_bytes()).hexdigest()}\n")
+    ok = True
+
+    def check(cond, good, bad):
+        nonlocal ok
+        print(f"  {'OK  ' if cond else 'FAIL'} {good if cond else bad}")
+        ok = ok and bool(cond)
+        return cond
+
+    spans = []  # (what, start, length)
+
+    # msglog's TextMsg thunk -> MsgFunc_TextMsg
+    msrc = (SRC / "msglog.rs").read_text(encoding="utf-8")
+    thunk = int(re.search(r'\("TextMsg",\s*0x([0-9a-f_]+)\)', msrc).group(1).replace("_", ""), 16)
+    call = next(i for i in im.dis(thunk, 0x40) if i.mnemonic == "call")
+    textmsg = im.target(call)
+    print(f"TextMsg thunk +{thunk:#x} calls MsgFunc_TextMsg at +{textmsg:#x}\n")
+
+    # ── spectator_text.rs: the camera mode name ─────────────────────────────
+    ssrc = (SRC / "spectator_text.rs").read_text(encoding="utf-8")
+    pattern, at, hidden = rust_site(ssrc, "MODE_NAME")
+    print(f"== spectator_text.rs MODE_NAME ==  at={at}  hidden={hidden.hex(' ')}")
+    hits = im.find_all(pattern)
+    if check(len(hits) == 1, f"the signature matches once, at +{hits[0]:#x}" if hits else "", f"the signature matches {len(hits)} time(s)"):
+        start = hits[0]
+        spec_mode = im.cstr_rva(b"#Spec_Mode%d")
+        pushes = [i for i in im.dis(start - 0x40, 0x40) if i.mnemonic == "push" and i.op_str == hex(spec_mode + im.base)]
+        check(pushes, 'it follows `push "#Spec_Mode%d"` (CHudSpectator::SetMode)', 'no `push "#Spec_Mode%d"` in the 0x40 bytes before it')
+        site = start + at
+        ins = im.one(site)
+        check(ins.mnemonic == "call" and ins.size == len(hidden) and im.target(ins) == textmsg,
+              f"+{site:#x} is a {ins.size}-byte `call` to MsgFunc_TextMsg (+{textmsg:#x})",
+              f"+{site:#x} is `{ins.mnemonic} {ins.op_str}` ({ins.size} bytes)")
+        rets = im.function_rets(textmsg)
+        check(rets and all(op == "0xc" for _, op in rets),
+              f"MsgFunc_TextMsg's {len(rets)} ret(s) are all `ret 0xc`",
+              f"MsgFunc_TextMsg's rets: {rets}")
+        body = [i for i in im.dis(start, at) if i.address - im.base < site]
+        last_clean = max((k for k, i in enumerate(body) if i.mnemonic == "add" and i.op_str.startswith("esp")), default=-1)
+        npush = sum(1 for i in body[last_clean + 1 :] if i.mnemonic == "push")
+        check(npush == 3, "three arguments are pushed for the call", f"{npush} pushes before the call")
+        rep = list(im.md.disasm(hidden, 0))
+        check(rep[0].mnemonic == "add" and rep[0].op_str == "esp, 0xc" and all(r.mnemonic == "nop" for r in rep[1:]) and sum(r.size for r in rep) == len(hidden),
+              "the replacement is `add esp, 0xc` and nops, as wide as the call",
+              f"the replacement decodes to {[(r.mnemonic, r.op_str) for r in rep]}")
+        after = []
+        for i in im.dis(site + ins.size, 0x20):
+            if i.mnemonic in ("call", "ret") or i.mnemonic.startswith("j"):
+                after.append(i)
+                break
+            after.append(i)
+        reads = [i for i in after[:-1] if "eax" in i.op_str and not i.op_str.startswith("eax,")]
+        flags = after[-1].mnemonic.startswith("j") and after[-1].mnemonic != "jmp"
+        check(not reads and not flags, "nothing after the call reads eax or the flags before the next call",
+              f"after the call: {[(i.mnemonic, i.op_str) for i in after]}")
+        spans.append(("the mode name call", site, len(hidden)))
+
+    # ── spectator_text.rs: Press DUCK ───────────────────────────────────────
+    pattern, at, hidden = rust_site(ssrc, "SPEC_DUCK")
+    print(f"\n== spectator_text.rs SPEC_DUCK ==  at={at}  hidden={hidden.hex(' ')}")
+    hits = im.find_all(pattern)
+    if check(len(hits) == 1, f"the signature matches once, at +{hits[0]:#x}" if hits else "", f"the signature matches {len(hits)} time(s)"):
+        helper = hits[0] + at
+        name = im.cstr_rva(b"Spec_Duck")
+        named = any(hex(name + im.base) in i.op_str for i in im.dis(helper, 0xc0))
+        check(named, "the function stores the message name `Spec_Duck`", "no reference to `Spec_Duck` in the function")
+        check(hidden == b"\xc3", "the replacement is a bare `ret`", f"the replacement is {hidden.hex(' ')}")
+        duck = im.cstr_rva(b"#Spec_Duck")
+        callers = im.callers(helper)
+        check(callers, f"{len(callers)} caller(s): {', '.join(f'+{c:#x}' for c in callers)}", "no callers found")
+        for c in callers:
+            # Raw bytes rather than a disassembly from an arbitrary point
+            # before the call, which can start mid-instruction.
+            pushed = (b"\x68" + struct.pack("<I", duck + im.base)) in im.img[c - 16 : c]
+            nxt = im.dis(c + 5, 0x20)
+            cleaned = False
+            for i in nxt[:4]:
+                if (i.mnemonic == "add" and i.op_str == "esp, 4") or (i.mnemonic == "pop" and i.op_str == "ecx"):
+                    cleaned = True
+                    break
+                if i.mnemonic in ("ret", "call") or i.mnemonic.startswith("j"):
+                    break
+            check(pushed and cleaned, f'+{c:#x} pushes "#Spec_Duck" and pops it itself',
+                  f"+{c:#x}: pushed={pushed} cleaned={cleaned}")
+        first = im.one(helper)
+        spans.append(("the Spec_Duck helper's first instruction", helper, first.size))
+
+    # ── overview_marker.rs ──────────────────────────────────────────────────
+    osrc = (SRC / "overview_marker.rs").read_text(encoding="utf-8")
+    pattern = rust_str_const(osrc, "PATTERN")
+    je_at = rust_usize(osrc, "JE_AT")
+    skip_at = rust_usize(osrc, "SKIP_AT")
+    print(f"\n== overview_marker.rs ==  JE_AT={je_at}  SKIP_AT={skip_at}")
+    hits = im.find_all(pattern)
+    if check(len(hits) == 1, f"the signature matches once, at +{hits[0]:#x}" if hits else "", f"the signature matches {len(hits)} time(s)"):
+        start = hits[0]
+        je = im.one(start + je_at)
+        check(je.mnemonic == "je" and je.size == 2, f"+{start + je_at:#x} is a short `je` (the sprite choice)", f"+{start + je_at:#x} is `{je.mnemonic} {je.op_str}`")
+        skip = im.one(start + skip_at)
+        check(skip.mnemonic == "je" and skip.size == 2, f"+{start + skip_at:#x} is a short `je` (the draw's no-sprite exit)", f"+{start + skip_at:#x} is `{skip.mnemonic} {skip.op_str}`")
+        prev = im.one(start + skip_at - 2)
+        check(prev.mnemonic == "test" and prev.op_str == "esi, esi", "it follows `test esi, esi`", f"it follows `{prev.mnemonic} {prev.op_str}`")
+        draw = im.one(start + skip_at + 2)
+        check(draw.mnemonic == "fld", "the draw it skips starts with `fld`, so the x87 stack is untouched on the skip", f"the draw starts `{draw.mnemonic} {draw.op_str}`")
+        exit_ = im.target(skip)
+        tail = []
+        for i in im.dis(exit_, 0x20):
+            tail.append(i)
+            if i.mnemonic == "ret":
+                break
+        fpu = [i for i in tail if i.mnemonic.startswith("f")]
+        check(tail and tail[-1].mnemonic == "ret" and not fpu and all(i.mnemonic in ("pop", "mov", "ret") for i in tail),
+              f"its target +{exit_:#x} is the epilogue: {' / '.join(i.mnemonic + ' ' + i.op_str for i in tail)}",
+              f"its target +{exit_:#x}: {[(i.mnemonic, i.op_str) for i in tail]}")
+        spans.append(("the camera sprite je", start + je_at, 2))
+        spans.append(("the camera draw je", start + skip_at, 2))
+
+    # ── overview_speaker.rs ─────────────────────────────────────────────────
+    vsrc = (SRC / "overview_speaker.rs").read_text(encoding="utf-8")
+    pattern = rust_str_const(vsrc, "PATTERN")
+    span_at = rust_usize(vsrc, "SPAN_AT")
+    jne_at = rust_usize(vsrc, "JNE_AT")
+    stock = rust_bytes(re.search(r"const STOCK:[^=]*=\s*\[(.*?)\];", vsrc, re.S).group(1))
+    print(f"\n== overview_speaker.rs ==  SPAN_AT={span_at}  JNE_AT={jne_at}  STOCK={stock.hex(' ')}")
+    hits = im.find_all(pattern)
+    if check(len(hits) == 1, f"the signature matches once, at +{hits[0]:#x}" if hits else "", f"the signature matches {len(hits)} time(s)"):
+        start = hits[0]
+        span = start + span_at
+        check(im.img[span : span + len(stock)] == stock, f"+{span:#x} holds STOCK", f"+{span:#x} holds {im.img[span:span + len(stock)].hex(' ')}")
+        ins = im.dis(span, 16)
+        consumed, n = 0, 0
+        for i in ins:
+            if consumed >= len(stock):
+                break
+            consumed += i.size
+            n += 1
+        check(consumed == len(stock), f"the span is {n} whole instruction(s): " + " / ".join(f"{i.mnemonic} {i.op_str}" for i in ins[:n]),
+              f"the span ends mid-instruction ({consumed} bytes)")
+        jne = im.one(start + jne_at)
+        exit_ = im.target(jne)
+        check(jne.mnemonic == "jne" and jne.size == 2, f"+{start + jne_at:#x} is `jne +{exit_:#x}`", f"+{start + jne_at:#x} is `{jne.mnemonic} {jne.op_str}`")
+        land = im.one(exit_)
+        check(land.mnemonic == "mov" and land.op_str.startswith("bl,"),
+              f"its target +{exit_:#x} is the next-entry code (`{land.mnemonic} {land.op_str}`)",
+              f"its target +{exit_:#x} is `{land.mnemonic} {land.op_str}`")
+        rel = exit_ - (span + 5)
+        print(f"       the hidden span is `jmp +{exit_:#x}` = e9 {struct.pack('<i', rel).hex(' ')}")
+        # the instance the talking check uses, and VidInit's member for the sprite
+        mov_ecx = next(i for i in im.dis(start, span_at) if i.mnemonic == "mov" and i.op_str.startswith("ecx, 0x"))
+        instance = int(mov_ecx.op_str.split(",")[1], 16) - im.base
+        spr = im.cstr_rva(b"sprites/mapsprites/speakerIcon.spr")
+        refs = [a for a, _s, m, op in im.sweep() if m == "push" and op == hex(spr + im.base)]
+        member = None
+        for r in refs:
+            seen_call = False
+            for i in im.dis(r, 0x20):
+                if i.mnemonic == "call":
+                    seen_call = True
+                elif seen_call and i.mnemonic == "mov" and i.op_str.endswith(", eax") and "[esi + " in i.op_str:
+                    member = int(re.search(r"\+ (0x[0-9a-f]+)\]", i.op_str).group(1), 16)
+                    break
+        handle = instance + member if member is not None else None
+        block = im.dis(start + jne_at + 2, exit_ - (start + jne_at + 2))
+        uses = [i for i in block if handle is not None and hex(handle + im.base) in i.op_str]
+        check(uses, f"the skipped block reads the speakerIcon.spr handle (CHudSpectator +{instance:#x} + member {member:#x})",
+              f"the skipped block never reads the speakerIcon.spr handle (instance {instance:#x}, member {member})")
+        spans.append(("the speaker decision", span, len(stock)))
+
+    # ── center_text.rs / clan_text.rs ───────────────────────────────────────
+    csrc = (SRC / "clan_text.rs").read_text(encoding="utf-8")
+    post = rust_str_const(csrc, "POST_PATTERN")
+    post_at = rust_usize(csrc, "POST_OBJECT_AT")
+    print("\n== center_text.rs / clan_text.rs ==")
+    hits = im.find_all(post)
+    if check(len(hits) == 1, f"POST_PATTERN matches once, at +{hits[0]:#x}" if hits else "", f"POST_PATTERN matches {len(hits)} time(s)"):
+        obj = im.u32(hits[0] + post_at) - im.base
+        queue = im.target(im.one(hits[0] + post_at + 4))
+        print(f"       DrawClanTimer posts to +{obj:#x} through +{queue:#x}")
+        table = None
+        for i in im.dis(textmsg, 0x200):
+            m = re.match(r"dword ptr \[eax\*4 \+ (0x[0-9a-f]+)\]", i.op_str)
+            if i.mnemonic == "jmp" and m:
+                table = int(m.group(1), 16) - im.base
+                break
+        if check(table is not None, f"MsgFunc_TextMsg switches through a table at +{table:#x}" if table else "", "no jump table in MsgFunc_TextMsg"):
+            case4 = im.u32(table + 3 * 4) - im.base
+            posted = None
+            for i in im.dis(case4, 0x100):
+                if i.mnemonic == "mov" and i.op_str.startswith("ecx, 0x"):
+                    posted = int(i.op_str.split(",")[1], 16) - im.base
+                if i.mnemonic == "call" and im.target(i) == queue:
+                    break
+                if i.mnemonic == "ret":
+                    posted = None
+                    break
+            check(posted == obj, f"destination 4 (+{case4:#x}) posts through +{queue:#x} to +{obj:#x}, the object end_center_line clears",
+                  f"destination 4 posts to {posted and hex(posted)}, end_center_line clears +{obj:#x}")
+
+    # ── every span ──────────────────────────────────────────────────────────
+    print("\n== branches into the patched spans ==")
+    for what, start, length in spans:
+        into = im.branches_into(start, start + length)
+        check(not into, f"nothing branches into {what} (+{start:#x}, {length} bytes)",
+              f"{what}: {[(f'+{a:#x}', m, f'+{t:#x}') for a, m, t in into]}")
+
+    print("\nSIGNATURES VERIFIED" if ok else "\nMISMATCH -- do not ship")
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/goldsrc-hooks/ui/Commands.txt b/goldsrc-hooks/ui/Commands.txt
index 56f186bee..95a32c297 100644
--- a/goldsrc-hooks/ui/Commands.txt
+++ b/goldsrc-hooks/ui/Commands.txt
@@ -9,6 +9,8 @@ SPECTATING (HLTV demos)
       Put the camera on a player (number 1-32; ds_hud_deathmsg players lists them).
   ds_spec_hide_bars 0/1
       Hide the spectator bars and everything on them.
+  ds_spec_hide_text 0/1
+      Hide the camera mode's name ('Free Look', ...) and the green 'Press DUCK for Spectator Menu' (POV deaths too).
   ds_spec_hide_hltv_messages 0/1
       Hide the HLTV proxy's on-screen messages.
 
@@ -25,6 +27,10 @@ HUD
       Hide the text a map puts on screen itself (mortar warnings, round results).
   ds_hud_hide_clan_text 0/1
       Hide clan-match text: warm-up and ready rules, Warmup Mode, the countdown, MATCH IS LIVE!
+  ds_hud_hide_center_text 0/1
+      Hide the text the server prints in the middle of the screen (plugin countdowns and notices).
+  ds_map_hide_asset list|add|del|clear <model|hud.txt name>...
+      Hide an asset (sprite, model) by its file path, like mirv_matte_entities.
   ds_hud_deathmsg
       Kill feed: max lines, offset, block players, fake a kill, font <face> <size> [bold] [shadow], scale <1..8> (both live). The bare command shows the options.
   ds_hud_objectives
@@ -33,8 +39,10 @@ HUD
       Move or resize the overview map.
   ds_hud_overview_players 0-4
       Which players the overview map shows: 0 the game's own, 1 everyone, 2 the other team, 3 the watched player, 4 nobody.
-  ds_hud_overview_team_marker 0/1
-      HLTV: mark the watched player on the overview map with their team's camera icon.
+  ds_hud_overview_team_marker 0-2
+      The camera icon on the overview map: 0 the game's own, 1 their team's icon in HLTV too, 2 none.
+  ds_hud_overview_hide_speaker 0/1
+      Leave the speaker icon off the players on the overview map.
   ds_hud_show_scope 0/1
       Show the sniper scope while a demo plays; in-eye it is the watched player's rifle.
 
diff --git a/native/src/patch/console_prefix.rs b/native/src/patch/console_prefix.rs
index c9e0fc036..e57148909 100644
--- a/native/src/patch/console_prefix.rs
+++ b/native/src/patch/console_prefix.rs
@@ -98,7 +98,11 @@ mod tests {
     use super::*;
 
     /// Names the hook registers that never had a `dodstudio_` one.
-    const NEW_SINCE_555: &[&str] = &[];
+    const NEW_SINCE_555: &[&str] = &[
+        "hud_hide_center_text",
+        "hud_overview_hide_speaker",
+        "spec_hide_text",
+    ];
 
     #[test]
     fn an_old_name_becomes_the_name_in_the_table() {
diff --git a/studio/src/console_commands_data.js b/studio/src/console_commands_data.js
index 239b9bf8c..121dcc26f 100644
--- a/studio/src/console_commands_data.js
+++ b/studio/src/console_commands_data.js
@@ -9,4 +9,4 @@ export const GAME_NAMES = [["+alt1","cmd","both"],["+attack","cmd","both"],["+at
 export const HLAE_NAMES = ["mirv_agr","mirv_aim","mirv_aim_layers","mirv_aim_lingertime","mirv_aim_offset","mirv_aim_oneway","mirv_aim_onlyvisible","mirv_aim_snapto","mirv_aim_start","mirv_aim_stop","mirv_cameraofs_cs","mirv_camexport_mode","mirv_camexport_timeinfo","mirv_camimport_basetime","mirv_camimport_end","mirv_camimport_load","mirv_campath","mirv_crop_height","mirv_crop_yofs","mirv_cstrike_deathmsg","mirv_cstrike_force_knife_righthand","mirv_cstrike_hltv_animation_fix","mirv_cstrike_smoke","mirv_cstrike_spectator_fix","mirv_deathmsg","mirv_decalfilter","mirv_depth_exr","mirv_depth_streams","mirv_disable_specmenu","mirv_disableautodirector","mirv_draw_sv_hitboxes_enable","mirv_draw_sv_hitboxes_ignore1","mirv_draw_sv_hitboxes_seticolor","mirv_draw_sv_hitboxes_setucolor","mirv_draw_sv_hitboxes_width","mirv_entity_jump","mirv_entity_lookat","mirv_entity_next","mirv_entity_prev","mirv_fov","mirv_fx_lightmap","mirv_fx_noblend","mirv_fx_skyhd","mirv_fx_viewmodel_lightmap","mirv_fx_wh_additive","mirv_fx_wh_alpha","mirv_fx_wh_enable","mirv_fx_wh_noquads","mirv_fx_wh_tint_colorf","mirv_fx_wh_tint_enable","mirv_fx_wh_xtendvis","mirv_fx_xtendvis","mirv_gameoverlay","mirv_input","mirv_listplayers","mirv_matte_entities","mirv_matte_entityquads","mirv_matte_method","mirv_matte_particles","mirv_matte_setcolor","mirv_matte_setcolorf","mirv_matte_viewmodel","mirv_matte_worldmodels","mirv_matte_xray","mirv_movie_bmp","mirv_movie_campath","mirv_movie_clearscreen","mirv_movie_depthdump","mirv_movie_export_sound","mirv_movie_ffmpeg","mirv_movie_filename","mirv_movie_fps","mirv_movie_hidepanels","mirv_movie_playdemostop","mirv_movie_separate_hud","mirv_movie_simulate","mirv_movie_simulate_delay","mirv_movie_sound_extra","mirv_movie_sound_volume","mirv_movie_splitstreams","mirv_movie_stereo_centerdist","mirv_movie_stereo_yawdegrees","mirv_movie_stereomode","mirv_movie_wireframe","mirv_movie_wireframesize","mirv_noadverts","mirv_recordmovie","mirv_recordmovie_start","mirv_recordmovie_stop","mirv_roll","mirv_sample_enable","mirv_sample_exposure","mirv_sample_sps","mirv_showentities","mirv_tas_mode","mirv_voice_block","mirv_whereami","mirv_zoom","mirv_zoom_digital","mirv_zoom_digital_x","mirv_zoom_digital_y","mirv_zoom_optical","mirv_zoom_speed","mirv_zoom_start","mirv_zoom_stop"];
 
 /** [name, hint] for DoD Studio's own (goldsrc-hooks). */
-export const DODSTUDIO_NAMES = [["ds_capture_batch","Studio's **Seek Between Clips** (#434): runs a capture batch on the original demos instead of patched copies"],["ds_capture_run_in_background","the game runs at full speed while another window is in front"],["ds_capture_schedule","R&D for #434 (the hook runs a batch's commands instead of frames patched into the demo)"],["ds_capture_stay_behind","the game window stays behind the other windows while it records: HLAE no longer brings it to the front, topmost, for ..."],["ds_debug_cloak_instead","with ds_capture_run_in_background on, a minimised game is DWM-cloaked in place (DWMWA_CLOAK, from inside the game's p..."],["ds_debug_hd_misses","Lists every texture that kept its original this session, map by map, grouped by why: the HD file is for a different v..."],["ds_debug_keep_detail_cache","puts the engine's detail texture cache back, to compare"],["ds_debug_log_spectator_target","logs who the spectator HUD thinks is being followed next to the entity the engine renders a viewmodel for, whenever e..."],["ds_debug_log_texture_loads","logs every HD-eligible texture load: replaced (from which file) or why not"],["ds_debug_log_weapon_model","logs the third-person weapon model the spectated player holds, each time it changes"],["ds_debug_msglog","ds_debug_msglog <name>"],["ds_debug_position","Prints where the view is, as spec_pos does while the map has no overview (once it has one, spec_pos prints the overvi..."],["ds_debug_status","Always reports the four suppression cvars, the two debug_log_* cvars and ds_hud_deathmsg's own status"],["ds_demo_ex_interp_max","raises the engine's clamp on ex_interp above its stock 100 ms ceiling, for smoother entity motion between snapshots"],["ds_demo_fast_load","viewdemo reads the demo into its world for up to 8 ms of each frame instead of the engine's 33 network packets a fram..."],["ds_demo_other_drives","viewdemo and playdemo open a demo on another drive by its full path, as in viewdemo \"D:/folder/demo\""],["ds_demo_reload","Plays the last demo started with playdemo or viewdemo again, from the start, by running the same command with the sam..."],["ds_demo_review","DoD Studio's **Review highlights** (#623): plays each queued highlight at normal speed, from 4 s before its first kil..."],["ds_demo_seek_by","ds_demo_seek_to <seconds> jumps viewdemo playback to a world time (the clock the editor's events list shows)"],["ds_demo_seek_skip_between","1 makes ds_demo_seek_to/_by land without running the director events and console commands they jump over"],["ds_demo_seek_to","ds_demo_seek_to <seconds> jumps viewdemo playback to a world time (the clock the editor's events list shows)"],["ds_hd_enabled","HD textures on/off: map textures, model skins, sprites (world and HUD, #728), decals, detail textures and skies from ..."],["ds_hd_style","which dodstudio_hd/<type>/<style> folder to use"],["ds_hud_deathmsg","Raises DoD's four-line cap on the kill feed, moves it, hides frags, injects one by hand, changes the names' font, or ..."],["ds_hud_hide_clan_text","hides all of DoD's clan-match text: the warm-up and ready rules, \"Warmup Mode\" on the left, the countdown to the matc..."],["ds_hud_hide_crosshair","hides the crosshair and keeps it hidden, which the stock crosshair cvar can't do because CHud::Redraw forces the valu..."],["ds_hud_hide_element","ds_hud_hide_element <name> <0|1> with no arguments lists the nine elements DoD draws that the stock cl_hud_* cvars do..."],["ds_hud_hide_map_text","hides the text a map puts on screen itself -- the dod_anzio mortar warning, the round result -- by matching each HudT..."],["ds_hud_hide_scoreboard","stops a POV demo's recorded TAB presses from putting the scoreboard over the shot"],["ds_hud_hide_voice_menus","hides the numbered menus a POV demo's player picked voice commands and hand signals from: the three voice-command men..."],["ds_hud_objectives","Places the territory-flag icon row and the objective timer beside it, or draws them bigger for high resolutions"],["ds_hud_overview_layout","ds_hud_overview_layout <full|mini> <x> <y> <w> <h> places and sizes DoD's overview map"],["ds_hud_overview_players","which players get an icon on the overview map: 0 the game's own (the team of the player being watched), 1 everyone, 2..."],["ds_hud_overview_team_marker","HLTV: marks the player being watched on the overview map with their team's camera icon (allies_camera.spr / axis_came..."],["ds_hud_show_scope","shows the sniper scope while a demo plays"],["ds_map_allow_shaders","25th Anniversary only: lets the engine draw map surfaces through its own GLSL shaders (platform/gl_shaders/fs_world.f..."],["ds_map_clear_decals","Empties the engine's 4096-slot decal pool on command, unlinking each decal from its surface first the way the engine'..."],["ds_map_hide_asset","ds_map_hide_asset stops the game drawing an asset -- a sprite, model or brush entity, named by its file path -- here,..."],["ds_player_hide_hand_signals","replaces any hs_* body sequence (the nod, the point, the wave -- players miming their own voice commands) with that p..."],["ds_player_overrides","sprays and crosshairs in demos follow Studio's Players table (Configuration > Players, #428)"],["ds_player_spray","Player sprays and crosshairs per player in demos, and switching your own spray (#428)"],["ds_sound_mute_voice_commands","silences \"fire in the hole!\" and the rest, without touching the game's own .wav files"],["ds_spec_deathcam","HLTV demos: when the player being watched in first person dies, the view becomes the death cam their own recording sh..."],["ds_spec_hide_bars","hides the spectator panel while spectating, in a demo or live: the two dark bands across the top and bottom of the sc..."],["ds_spec_hide_hltv_messages","drops the text an HLTV proxy puts on screen during playback (\"You're watching HLTV"],["ds_spec_lock","HLTV demos: the camera stays on the player being watched when they die"],["ds_spec_match_pov","one switch for making a spectated first-person view look and sound like the player's own recording"],["ds_spec_target","ds_spec_target <player> puts the camera on a player while watching an HLTV demo"],["ds_ui_console_in_panel","the console key (toggleconsole) opens the DoD Studio window on its Console tab, which holds the real console's histor..."],["ds_ui_demo_list_count_subfolders","a folder row's demo count on the Demos tab includes its subfolders (the Settings tab's \"Include subfolders\")"],["ds_ui_demo_list_folders","the Load Demo window, and the DoD Studio window's Demos tab, also list folders and open them, so demos in subfolders ..."],["ds_ui_demo_list_hide_empty","while folders are listed and counted (ds_ui_demo_list_show_counts 1), a folder with no demo anywhere inside it (any d..."],["ds_ui_demo_list_show_counts","folders are counted in the background, and folder rows on the Demos tab end in \"(N demos)\" (the game's own Load Demo ..."],["ds_ui_panel","Opens DoD Studio's own window in the game, or closes it if it's open"],["ds_ui_remember_layout","each GameUI window comes back where it was left, and at its size when resizable, after the game restarts"],["ds_ui_resizable_windows","every GameUI window (VCR bar, events list, Load Demo, Options...) can be resized by its edges, like the console"],["ds_ui_viewdemo_in_panel","viewdemo opens the DoD Studio window (ds_ui_panel) on its Playback tab, which takes the VCR bar's time slider and tim..."],["ds_view_hide_headshot_red_screen","POV demos: drops the red screen flash (a server ScreenFade of (128,0,0) at alpha 200, flags 0) that comes with every ..."],["ds_view_hide_screen_shake","POV demos: drops every server ScreenShake, which in DoD demos is the blast shake from a grenade going off nearby (alw..."],["ds_view_use_cl_bob","a POV demo bobs the view and the gun by the cl_bob (and cl_bobcycle, cl_bobup) set now (#359)"]];
+export const DODSTUDIO_NAMES = [["ds_capture_batch","Studio's **Seek Between Clips** (#434): runs a capture batch on the original demos instead of patched copies"],["ds_capture_run_in_background","the game runs at full speed while another window is in front"],["ds_capture_schedule","R&D for #434 (the hook runs a batch's commands instead of frames patched into the demo)"],["ds_capture_stay_behind","the game window stays behind the other windows while it records: HLAE no longer brings it to the front, topmost, for ..."],["ds_debug_cloak_instead","with ds_capture_run_in_background on, a minimised game is DWM-cloaked in place (DWMWA_CLOAK, from inside the game's p..."],["ds_debug_hd_misses","Lists every texture that kept its original this session, map by map, grouped by why: the HD file is for a different v..."],["ds_debug_keep_detail_cache","puts the engine's detail texture cache back, to compare"],["ds_debug_log_spectator_target","logs who the spectator HUD thinks is being followed next to the entity the engine renders a viewmodel for, whenever e..."],["ds_debug_log_texture_loads","logs every HD-eligible texture load: replaced (from which file) or why not"],["ds_debug_log_weapon_model","logs the third-person weapon model the spectated player holds, each time it changes"],["ds_debug_msglog","ds_debug_msglog <name>"],["ds_debug_position","Prints where the view is, as spec_pos does while the map has no overview (once it has one, spec_pos prints the overvi..."],["ds_debug_status","Always reports the four suppression cvars, the two debug_log_* cvars and ds_hud_deathmsg's own status"],["ds_demo_ex_interp_max","raises the engine's clamp on ex_interp above its stock 100 ms ceiling, for smoother entity motion between snapshots"],["ds_demo_fast_load","viewdemo reads the demo into its world for up to 8 ms of each frame instead of the engine's 33 network packets a fram..."],["ds_demo_other_drives","viewdemo and playdemo open a demo on another drive by its full path, as in viewdemo \"D:/folder/demo\""],["ds_demo_reload","Plays the last demo started with playdemo or viewdemo again, from the start, by running the same command with the sam..."],["ds_demo_review","DoD Studio's **Review highlights** (#623): plays each queued highlight at normal speed, from 4 s before its first kil..."],["ds_demo_seek_by","ds_demo_seek_to <seconds> jumps viewdemo playback to a world time (the clock the editor's events list shows)"],["ds_demo_seek_skip_between","1 makes ds_demo_seek_to/_by land without running the director events and console commands they jump over"],["ds_demo_seek_to","ds_demo_seek_to <seconds> jumps viewdemo playback to a world time (the clock the editor's events list shows)"],["ds_hd_enabled","HD textures on/off: map textures, model skins, sprites (world and HUD, #728), decals, detail textures and skies from ..."],["ds_hd_style","which dodstudio_hd/<type>/<style> folder to use"],["ds_hud_deathmsg","Raises DoD's four-line cap on the kill feed, moves it, hides frags, injects one by hand, changes the names' font, or ..."],["ds_hud_hide_center_text","hides the text the server prints in the middle of the screen: every TextMsg to HUD_PRINTCENTER (destination 4), such ..."],["ds_hud_hide_clan_text","hides all of DoD's clan-match text: the warm-up and ready rules, \"Warmup Mode\" on the left, the countdown to the matc..."],["ds_hud_hide_crosshair","hides the crosshair and keeps it hidden, which the stock crosshair cvar can't do because CHud::Redraw forces the valu..."],["ds_hud_hide_element","ds_hud_hide_element <name> <0|1> with no arguments lists the nine elements DoD draws that the stock cl_hud_* cvars do..."],["ds_hud_hide_map_text","hides the text a map puts on screen itself -- the dod_anzio mortar warning, the round result -- by matching each HudT..."],["ds_hud_hide_scoreboard","stops a POV demo's recorded TAB presses from putting the scoreboard over the shot"],["ds_hud_hide_voice_menus","hides the numbered menus a POV demo's player picked voice commands and hand signals from: the three voice-command men..."],["ds_hud_objectives","Places the territory-flag icon row and the objective timer beside it, or draws them bigger for high resolutions"],["ds_hud_overview_hide_speaker","leaves the speaker icon (mapsprites/speakerIcon.spr) off the players' icons on the overview map, so the sprite needs ..."],["ds_hud_overview_layout","ds_hud_overview_layout <full|mini> <x> <y> <w> <h> places and sizes DoD's overview map"],["ds_hud_overview_players","which players get an icon on the overview map: 0 the game's own (the team of the player being watched), 1 everyone, 2..."],["ds_hud_overview_team_marker","which camera icon marks the player being watched on the overview map: 0 the game's own, 1 their team's in HLTV too, 2..."],["ds_hud_show_scope","shows the sniper scope while a demo plays"],["ds_map_allow_shaders","25th Anniversary only: lets the engine draw map surfaces through its own GLSL shaders (platform/gl_shaders/fs_world.f..."],["ds_map_clear_decals","Empties the engine's 4096-slot decal pool on command, unlinking each decal from its surface first the way the engine'..."],["ds_map_hide_asset","ds_map_hide_asset stops the game drawing an asset -- a sprite, model or brush entity, named by its file path -- here,..."],["ds_player_hide_hand_signals","replaces any hs_* body sequence (the nod, the point, the wave -- players miming their own voice commands) with that p..."],["ds_player_overrides","sprays and crosshairs in demos follow Studio's Players table (Configuration > Players, #428)"],["ds_player_spray","Player sprays and crosshairs per player in demos, and switching your own spray (#428)"],["ds_sound_mute_voice_commands","silences \"fire in the hole!\" and the rest, without touching the game's own .wav files"],["ds_spec_deathcam","HLTV demos: when the player being watched in first person dies, the view becomes the death cam their own recording sh..."],["ds_spec_hide_bars","hides the spectator panel while spectating, in a demo or live: the two dark bands across the top and bottom of the sc..."],["ds_spec_hide_hltv_messages","drops the text an HLTV proxy puts on screen during playback (\"You're watching HLTV"],["ds_spec_hide_text","hides the two lines the game prints when the view becomes a spectator camera: the camera mode's name, centred just ab..."],["ds_spec_lock","HLTV demos: the camera stays on the player being watched when they die"],["ds_spec_match_pov","one switch for making a spectated first-person view look and sound like the player's own recording"],["ds_spec_target","ds_spec_target <player> puts the camera on a player while watching an HLTV demo"],["ds_ui_console_in_panel","the console key (toggleconsole) opens the DoD Studio window on its Console tab, which holds the real console's histor..."],["ds_ui_demo_list_count_subfolders","a folder row's demo count on the Demos tab includes its subfolders (the Settings tab's \"Include subfolders\")"],["ds_ui_demo_list_folders","the Load Demo window, and the DoD Studio window's Demos tab, also list folders and open them, so demos in subfolders ..."],["ds_ui_demo_list_hide_empty","while folders are listed and counted (ds_ui_demo_list_show_counts 1), a folder with no demo anywhere inside it (any d..."],["ds_ui_demo_list_show_counts","folders are counted in the background, and folder rows on the Demos tab end in \"(N demos)\" (the game's own Load Demo ..."],["ds_ui_panel","Opens DoD Studio's own window in the game, or closes it if it's open"],["ds_ui_remember_layout","each GameUI window comes back where it was left, and at its size when resizable, after the game restarts"],["ds_ui_resizable_windows","every GameUI window (VCR bar, events list, Load Demo, Options...) can be resized by its edges, like the console"],["ds_ui_viewdemo_in_panel","viewdemo opens the DoD Studio window (ds_ui_panel) on its Playback tab, which takes the VCR bar's time slider and tim..."],["ds_view_hide_headshot_red_screen","POV demos: drops the red screen flash (a server ScreenFade of (128,0,0) at alpha 200, flags 0) that comes with every ..."],["ds_view_hide_screen_shake","POV demos: drops every server ScreenShake, which in DoD demos is the blast shake from a grenade going off nearby (alw..."],["ds_view_use_cl_bob","a POV demo bobs the view and the gun by the cl_bob (and cl_bobcycle, cl_bobup) set now (#359)"]];