diff --git a/crates/benilla-app/assets/ui/OptionsFrame.xml b/crates/benilla-app/assets/ui/OptionsFrame.xml
index 1b57d570..9c218bd4 100644
--- a/crates/benilla-app/assets/ui/OptionsFrame.xml
+++ b/crates/benilla-app/assets/ui/OptionsFrame.xml
@@ -635,8 +635,8 @@
 
         OPTIONS_PAGE_ROWS = {
             Controls = {
-                "RowStickyTarget", "RowAutoLoot", "RowInvertMouse", "RowMouseSpeed",
-                "RowCameraFollowStyle", "RowMaxCameraDistance",
+                "RowStickyTarget", "RowBlockTrades", "RowAutoLoot", "RowInvertMouse",
+                "RowMouseSpeed", "RowCameraFollowStyle", "RowMaxCameraDistance",
             },
             Audio = {
                 "RowEnableAll", "RowMaster", "RowSound", "RowMusic", "RowAmbience",
@@ -2102,11 +2102,27 @@
                                                 self.invert = 1
                                             </OnLoad></Scripts>
                                         </Frame>
-                                        <Frame name="$parentRowAutoLoot" inherits="OptionsCheckboxRowTemplate">
+                                        <!-- Block Trades (decision 1764). Seated here because
+                                             this page is where 1.12's Basic Options GENERAL box
+                                             lands, and Sticky Targeting above is the other row we
+                                             ship from it — the reference's own box order runs 45
+                                             (Sticky Targeting) down the left column and 14 (this)
+                                             down the right, so the two belong adjacent when the
+                                             box is flattened to one column. Its tooltip key IS the
+                                             reference's, unlike the row above. -->
+                                        <Frame name="$parentRowBlockTrades" inherits="OptionsCheckboxRowTemplate">
                                             <Anchors>
                                                 <Anchor point="TOPLEFT" relativeTo="$parentRowStickyTarget" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                                 <Anchor point="TOPRIGHT" relativeTo="$parentRowStickyTarget" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                             </Anchors>
+                                            <Scripts><OnLoad>OptionsRow_OnLoad(self, "BlockTrades", "Block Trades",
+                                                "OPTION_TOOLTIP_BLOCK_TRADES")</OnLoad></Scripts>
+                                        </Frame>
+                                        <Frame name="$parentRowAutoLoot" inherits="OptionsCheckboxRowTemplate">
+                                            <Anchors>
+                                                <Anchor point="TOPLEFT" relativeTo="$parentRowBlockTrades" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowBlockTrades" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                            </Anchors>
                                             <!-- No tip: 1.12 has no Auto Loot row, so no
                                                  OPTION_TOOLTIP_* for it either (verified — the
                                                  5875 GlobalStrings has no AUTO_LOOT key at all,
diff --git a/crates/benilla-app/src/char_select/mod.rs b/crates/benilla-app/src/char_select/mod.rs
index 5d4c2e4f..b877ee10 100644
--- a/crates/benilla-app/src/char_select/mod.rs
+++ b/crates/benilla-app/src/char_select/mod.rs
@@ -425,10 +425,11 @@ fn apply_roster_policy(
                 }
                 None
             }
-            // `WOW_CHAR`, or the login smoke's optional third field (decision 1262): the smoke's
-            // seat exists because `WOW_CHAR` is also an *unattended* marker
-            // ([`crate::run_mode::unattended_login`]), so using it to reach the world would switch
-            // the very branch a session test is trying to exercise. Same fast path, no marker.
+            // `WOW_CHAR`, or the login smoke's optional third field (decision 1262): the seat
+            // exists because `WOW_CHAR` *was* also an unattended marker, so using it to reach the
+            // world switched the very branch a session test was trying to exercise. 1769 severed
+            // that — `WOW_CHAR` now only means "skip the click" — and the seat stays as the
+            // smoke's own way in. Same fast path either way.
             None => std::env::var("WOW_CHAR").ok().or_else(|| {
                 std::env::var("WOW_LOGIN_SMOKE")
                     .ok()
@@ -509,13 +510,14 @@ fn apply_roster_policy(
                 }
                 None => {
                     warn!("char select: WOW_CHAR={name} not on this account — showing roster");
-                    // A harness run (env creds, no smoke) can never pick a different row itself —
-                    // parked here it burns its whole wall-clock. Same marker the login arm uses,
-                    // same greppable verdict for leg.sh.
-                    if crate::run_mode::unattended_login()
-                        && std::env::var_os("WOW_LOGIN_SMOKE").is_none()
+                    // A driverless run can never pick a different row itself — parked here it
+                    // burns its whole wall-clock. Same home as the login arm's verdict, so the
+                    // marker leg.sh greps for is written in exactly one place (1371, 1769).
+                    if std::env::var_os("WOW_LOGIN_SMOKE").is_none()
+                        && crate::run_mode::fatal_when_driverless(&format!(
+                            "WOW_CHAR={name} is not on this account"
+                        ))
                     {
-                        error!("login: FATAL — WOW_CHAR={name} is not on this account; exiting");
                         exit.write(AppExit::error());
                     }
                 }
diff --git a/crates/benilla-app/src/creature_anim.rs b/crates/benilla-app/src/creature_anim.rs
index 3cec502b..1628ced2 100644
--- a/crates/benilla-app/src/creature_anim.rs
+++ b/crates/benilla-app/src/creature_anim.rs
@@ -302,6 +302,20 @@ pub(crate) fn start_attack_local(
     commands: &mut Commands,
     net: &crate::net::NetCommands,
 ) {
+    // **Starting an attack stands you up** — `0x5ecc9b call 0x5ed430(0)`, inside this function and
+    // ahead of everything else it does (decision 1768).
+    //
+    // Its position is the content. It sits **after** the attackability cluster
+    // (`0x5ecc2e`/`0x5ecc35`, whose not-attackable leg diverts to `0x5ecc37` and never reaches the
+    // stand) — which is why a right-click on a friendly NPC does not stand you — and **before any
+    // range logic**, `CMSG_ATTACKSWING` being all the way down at `0x5eccfd`. So an attackable
+    // target out of reach *does* stand you, and so does re-issuing an attack you are already
+    // making: that skip lands at `0x5ecd78`, 73 bytes past the stand. Hence unconditional here,
+    // above the swing's own `engaged` fork, rather than inside it.
+    //
+    // benilla's callers own the attackability walk (see this function's header), so by the time we
+    // are called the diverting leg has already been taken elsewhere.
+    commands.write_message(crate::player::StandStateRequest { state: 0 });
     if !engaged || stop_in_flight {
         let _ = net
             .0
@@ -1122,6 +1136,65 @@ fn find_resolved<'a>(
     anims.find(resolved_id(anims, id, catalog))
 }
 
+#[cfg(test)]
+mod attack_stand_tests {
+    use super::*;
+
+    /// **`StartAttack` stands a seated player** — `0x5ecc9b`, and unconditionally within this
+    /// function (decision 1768).
+    ///
+    /// `engaged = true` is the case worth pinning. It takes `0x5ecb70`'s skip, which jumps to the
+    /// tail at `0x5ecd78` — **73 bytes past the stand** — so re-issuing an attack you are already
+    /// making still stands you, and no `CMSG_ATTACKSWING` goes out. A stand written only on the
+    /// swing's own leg would miss exactly this case.
+    ///
+    /// This is the behaviour that replaces the turn-driven stand 1766 deleted: what stands a
+    /// seated player on a right-click is the *action* the click dispatches, not the gesture.
+    #[test]
+    fn starting_an_attack_stands_you_even_when_the_swing_is_skipped() {
+        let mut app = App::new();
+        app.add_message::<SheathRequest>()
+            .add_message::<crate::player::StandStateRequest>();
+        // A dead-letter net channel: the send is `let _ = …` and no packet is under test here.
+        let (tx, _rx) = crossbeam_channel::unbounded();
+        app.insert_resource(crate::net::NetCommands(tx));
+        app.insert_resource(crate::ui_action::AutoRepeatActive(None));
+
+        let me = app.world_mut().spawn_empty().id();
+        app.add_systems(
+            Update,
+            move |mut commands: Commands,
+                  mut auto_repeat: ResMut<crate::ui_action::AutoRepeatActive>,
+                  mut sheath: MessageWriter<SheathRequest>,
+                  net: Res<crate::net::NetCommands>| {
+                start_attack_local(
+                    me,
+                    0xdead_beef,
+                    true, // already engaged — the skip leg
+                    false,
+                    &mut auto_repeat,
+                    &mut sheath,
+                    &mut commands,
+                    &net,
+                );
+            },
+        );
+        app.update();
+
+        let stands: Vec<u8> = app
+            .world_mut()
+            .resource_mut::<bevy::ecs::message::Messages<crate::player::StandStateRequest>>()
+            .drain()
+            .map(|r| r.state)
+            .collect();
+        assert_eq!(
+            stands,
+            vec![0],
+            "StartAttack asks for stand state 0 exactly once, even on the leg that sends no swing"
+        );
+    }
+}
+
 #[cfg(test)]
 mod nock_latch_tests {
     use super::*;
diff --git a/crates/benilla-app/src/cvars.rs b/crates/benilla-app/src/cvars.rs
index 2c415e2c..b353714e 100644
--- a/crates/benilla-app/src/cvars.rs
+++ b/crates/benilla-app/src/cvars.rs
@@ -103,6 +103,13 @@ pub(crate) const REGISTERED: &[(&str, &str)] = &[
     // pitch invert). `autoLootDefault` is era's — no 1.12 CVar exists, vanilla only had the
     // shift gesture — default off, like era's engine registrar.
     ("deselectOnClick", "1"),
+    // *Block Trades* (decision 1764) — 1.12's own `BlockTrades` (`0x842fbc`), the General-box
+    // checkbox at index 14 whose tooltip is "Block all incoming trade requests.". Registered
+    // **"0"**: the reference's own `0x4bf7bc` leg only refuses when the CVar is set, so an
+    // unset/absent value has to mean "trades allowed" — and a client that shipped with trades
+    // blocked would refuse every trade until the player found the box. The knob is
+    // [`crate::ui_trade::BlockTrades`], read by the incoming-request answerer.
+    ("BlockTrades", "0"),
     // 1.12's own `autoSelfCast` (`0x870dc0`) — a friendly cast that binds nothing falls back to
     // the caster. The behaviour has been here since the cast arm landed, welded to a Resource
     // default; it is a CVar now because 1.12's `TOGGLEAUTOSELFCAST` binding is `GetCVar`/`SetCVar`
@@ -567,6 +574,7 @@ pub(crate) struct KnobParams<'w> {
     tex_filter: ResMut<'w, benilla_assets::TexFilterSetting>,
     pane_rate: ResMut<'w, PaneRate>,
     guild_notify: ResMut<'w, crate::ui_guild::GuildMemberNotify>,
+    block_trades: ResMut<'w, crate::ui_trade::BlockTrades>,
     auto_self_cast: ResMut<'w, crate::ui_action::AutoSelfCast>,
     realmlist: ResMut<'w, crate::realmlist::Realmlist>,
 }
@@ -601,6 +609,7 @@ impl KnobParams<'_> {
             tex_filter: &mut self.tex_filter,
             pane_rate: &mut self.pane_rate,
             guild_notify: &mut self.guild_notify,
+            block_trades: &mut self.block_trades,
             auto_self_cast: &mut self.auto_self_cast,
             realmlist: &mut self.realmlist,
         }
@@ -631,6 +640,7 @@ struct Knobs<'a> {
     tex_filter: &'a mut benilla_assets::TexFilterSetting,
     pane_rate: &'a mut PaneRate,
     guild_notify: &'a mut crate::ui_guild::GuildMemberNotify,
+    block_trades: &'a mut crate::ui_trade::BlockTrades,
     auto_self_cast: &'a mut crate::ui_action::AutoSelfCast,
     realmlist: &'a mut crate::realmlist::Realmlist,
 }
@@ -721,6 +731,7 @@ fn apply_to_knobs(name: &str, value: &str, knobs: &mut Knobs) -> bool {
         "showlootspam" => knobs.loot.show_loot_spam = v != 0.0,
         // Guild Member Alert (1589) — conjunct 2 of the sign-on/sign-off line's condition.
         "guildmembernotify" => knobs.guild_notify.0 = v != 0.0,
+        "blocktrades" => knobs.block_trades.0 = v != 0.0,
         // The panel's 0/1/2 lands as the density multiplier ×1/×2/×3; the clamp is the 1.12
         // slider's own range (an off-grid hand-edit rides between stops, like every slider).
         "worlddetail" => knobs.clutter.density = v.clamp(0.0, 2.0) + 1.0,
@@ -1004,6 +1015,7 @@ fn sync_cvars(
             render_scale,
             pane_rate,
             guild_notify,
+            block_trades,
             auto_self_cast,
             msaa,
             msaa_formats,
@@ -1041,7 +1053,7 @@ fn sync_cvars(
                 .collect(),
         );
         let flag = |b: bool| if b { "1" } else { "0" }.to_string();
-        let session: [(&str, String); 41] = [
+        let session: [(&str, String); 42] = [
             ("MasterVolume", sound.master.to_string()),
             ("SoundVolume", sound.sfx.to_string()),
             ("MusicVolume", sound.music.to_string()),
@@ -1067,6 +1079,7 @@ fn sync_cvars(
             ("autoLootDefault", flag(loot.auto_loot)),
             ("showLootSpam", flag(loot.show_loot_spam)),
             ("guildMemberNotify", flag(guild_notify.0)),
+            ("BlockTrades", flag(block_trades.0)),
             ("UnitNamePlayer", flag(names.player)),
             ("UnitNameNPC", flag(names.npc)),
             ("UnitNameOwn", flag(names.own)),
@@ -1332,6 +1345,13 @@ mod tests {
             crate::ui_guild::GuildMemberNotify::default().0
         );
         assert_eq!(d["guildMemberNotify"], 0.0, "the binary registers \"0\"");
+        // Block Trades (1764) welds the same way, and its "0" is behaviour: the refusal leg only
+        // fires when the CVar is SET, so an unset value must read as "trades allowed".
+        assert_eq!(
+            d["BlockTrades"] != 0.0,
+            crate::ui_trade::BlockTrades::default().0
+        );
+        assert_eq!(d["BlockTrades"], 0.0, "an unset BlockTrades allows trades");
         // The name trio (0992) welds to NameConfig's defaults the same way.
         let names = NameConfig::default();
         assert_eq!(d["UnitNamePlayer"] != 0.0, names.player);
@@ -1394,6 +1414,7 @@ mod tests {
         let mut video = VideoConfig::default();
         let mut pane_rate = PaneRate::default();
         let mut guild_notify = crate::ui_guild::GuildMemberNotify::default();
+        let mut block_trades = crate::ui_trade::BlockTrades::default();
         // Literal, not Default: MsaaSetting::default() reads $WOW_MSAA.
         let mut msaa = MsaaSetting { samples: 1 };
         // What an Apple GPU answers for the trio we render into (Rgba16Float / Depth32Float /
@@ -1433,6 +1454,7 @@ mod tests {
             render_scale: &mut render_scale,
             pane_rate: &mut pane_rate,
             guild_notify: &mut guild_notify,
+            block_trades: &mut block_trades,
             msaa: &mut msaa,
             tex_filter: &mut tex_filter,
             msaa_formats: &msaa_formats,
@@ -1552,6 +1574,9 @@ mod tests {
         // Guild Member Alert (1589) — the row that ships OFF, so its ON is the interesting write.
         assert!(apply_to_knobs("guildMemberNotify", "1", &mut knobs));
         assert!(knobs.guild_notify.0);
+        // Block Trades (1764) — the other row that ships OFF; its ON is what refuses a trade.
+        assert!(apply_to_knobs("BlockTrades", "1", &mut knobs));
+        assert!(knobs.block_trades.0);
         // The name trio lands on its gates (0992).
         assert!(apply_to_knobs("UnitNameNPC", "0", &mut knobs));
         assert!(!knobs.names.npc);
@@ -1710,6 +1735,7 @@ mod tests {
             ))
             .init_resource::<PaneRate>()
             .init_resource::<crate::ui_guild::GuildMemberNotify>()
+            .init_resource::<crate::ui_trade::BlockTrades>()
             .init_resource::<crate::ui_action::AutoSelfCast>()
             .add_plugins(CvarPlugin);
         app.insert_non_send_resource(UiScript::new().unwrap());
diff --git a/crates/benilla-app/src/login/mod.rs b/crates/benilla-app/src/login/mod.rs
index 5cbb88fb..7d4d9720 100644
--- a/crates/benilla-app/src/login/mod.rs
+++ b/crates/benilla-app/src/login/mod.rs
@@ -12,8 +12,8 @@
 //!
 //! **A session that is lost is over** (decision 1262): the reference's `GlueParent.lua` answers
 //! `DISCONNECTED_FROM_SERVER` with `SetGlueScreen("login")` + `GlueDialog_Show("DISCONNECTED")`,
-//! and so does this. 0065's seamless reconnect survives only where nobody is here to type — an
-//! unattended run ([`crate::run_mode::unattended_login`]) — because a client that
+//! and so does this. 0065's seamless reconnect survives only where the run has *declared* that
+//! nobody is here ([`crate::run_mode::unattended`], decision 1769) — because a client that
 //! re-authenticates on its own takes the account back off whoever just displaced it.
 //!
 //! Module split: this file (state, policy, input, dialogs, the saved-account persistence),
@@ -456,16 +456,10 @@ fn drive_policy(
     // Those failures exit non-zero instead, on one greppable marker — "login: FATAL" — that
     // leg.sh keys on (decision 1371).
     //
-    // **"May" is the whole correction.** This flag is derived from the environment
-    // ([`crate::run_mode::unattended_login`] — any of `$WOW_USER`/`$WOW_PASS`/`$WOW_CHAR`), and
-    // the environment cannot see who is in the room. The director keeps `$WOW_CHAR` set to skip
-    // character select, which made every one of their sessions "a harness" — so a **typed**
-    // password with a typo killed the process instead of showing the dialog the reference shows.
-    // The env fact is the right answer to "should the client log in without waiting for someone
-    // to type?" and the wrong answer to "is there anybody here?"; it was answering both. Whether
-    // an *attempt* was typed is not an inference at all — see `announced` at the use sites.
-    let harness_env =
-        crate::run_mode::unattended_login() && std::env::var_os("WOW_LOGIN_SMOKE").is_none();
+    // **Nobody is here only if the run says so** (decision 1769). Whether the client may end the
+    // run itself is [`crate::run_mode::fatal_when_driverless`]'s to answer; the two facts this
+    // scope adds are local ones. The smoke owns its own verdict, so it is never ours to end.
+    let smoke = std::env::var_os("WOW_LOGIN_SMOKE").is_some();
     let empty = GlueStrings::default();
     let strings = strings.as_deref().unwrap_or(&empty);
 
@@ -474,10 +468,9 @@ fn drive_policy(
     // The login smoke drives its own credentials instead.
     if !attempt.intent.env_read {
         attempt.intent.env_read = true;
-        // The same fact a lost session asks about (decision 1262) — read from the one place that
-        // owns it, so "the harness logs in for us" and "the harness logs back in for us" can never
-        // be two different answers.
-        if crate::run_mode::unattended_login() && std::env::var_os("WOW_LOGIN_SMOKE").is_none() {
+        // Purely "are the credentials in the environment?" (decision 1769) — whether anybody is
+        // here to *react* is a different fact with a different home, `run_mode::unattended`.
+        if crate::run_mode::env_login() && std::env::var_os("WOW_LOGIN_SMOKE").is_none() {
             let user = std::env::var("WOW_USER").unwrap_or_else(|_| "one".into());
             let pass = std::env::var("WOW_PASS").unwrap_or_else(|_| "pone".into());
             // The account guard (decision 0649): a vmangos login KICKS whoever holds the account,
@@ -500,8 +493,11 @@ fn drive_policy(
                     dialog.open_error(&why);
                     // The refusal is deterministic — the slot is baked into the binary — so the
                     // run can never get past this screen (the 1371 legs burned 3 × timeout on it).
-                    error!("login: FATAL — account guard refused the only credentials this run has; exiting");
-                    exit.write(AppExit::error());
+                    if crate::run_mode::fatal_when_driverless(
+                        "the account guard refused the only credentials this run has",
+                    ) {
+                        exit.write(AppExit::error());
+                    }
                 }
             }
         }
@@ -550,13 +546,17 @@ fn drive_policy(
         // by definition, and an attended failure gets the reference's answer: the dialog, and
         // another go. Only an attempt nobody typed may kill the process.
         let typed = attempt.intent.announced;
-        let fatal = harness_env && !typed;
+        let may_end_the_run = !typed && !smoke;
         if msg.terminal {
             warn!("login: {}", msg.reason);
             attempt.intent.clear();
             dialog.open_error(&msg.reason);
-            if fatal {
-                error!("login: FATAL — terminal login failure with nobody at the keyboard ({}); exiting", msg.reason);
+            if may_end_the_run
+                && crate::run_mode::fatal_when_driverless(&format!(
+                    "terminal login failure with nobody at the keyboard ({})",
+                    msg.reason
+                ))
+            {
                 exit.write(AppExit::error());
             }
             continue;
@@ -569,8 +569,11 @@ fn drive_policy(
                 warn!("login: refused ({refusal:?}, {byte:#04x}) — {}", msg.reason);
                 attempt.intent.clear();
                 dialog.open_error(&fail_text(strings, Some(refusal), None));
-                if fatal {
-                    error!("login: FATAL — refused ({refusal:?}, {byte:#04x}) and no resubmit can change it; exiting");
+                if may_end_the_run
+                    && crate::run_mode::fatal_when_driverless(&format!(
+                        "refused ({refusal:?}, {byte:#04x}) and no resubmit can change it"
+                    ))
+                {
                     exit.write(AppExit::error());
                 }
             }
@@ -1655,31 +1658,46 @@ mod tests {
         exited(&mut app, &mut cursor)
     }
 
-    /// **A typo must not kill the client.**
+    /// **A typo must not kill the client**, and **env credentials alone must not either.**
     ///
     /// The reported crash: `login: FATAL — refused (code 0x04) … exiting`, on a password typed at
-    /// the screen. `$WOW_CHAR` was set — the director keeps it to skip character select — which
-    /// makes [`crate::run_mode::unattended_login`] true and therefore made *every* session "a
-    /// harness", so a refusal took `AppExit::error()` instead of the reference's dialog. The
-    /// environment cannot see who is in the room; `announced` can, because only the screen's own
-    /// submit sets it.
+    /// the screen, because `$WOW_CHAR` was set and the old predicate read any env credential as
+    /// "a harness". Two answers, both here, because they close the hole from both ends: whether
+    /// an *attempt* was typed is direct evidence (`announced`, set by the screen's own submit and
+    /// by nothing else), and whether the *run* is driverless is a declaration the run makes
+    /// (`WOW_UNATTENDED`, decision 1769) — never an inference off credentials the director's own
+    /// launch line carries.
     #[test]
     fn a_typed_password_refusal_never_exits() {
         let _lock = crate::local_state::test_env::ENV_LOCK.lock();
-        // The harness environment the director actually runs with.
-        let _char = crate::local_state::test_env::EnvGuard::set("WOW_CHAR", "Somebody");
         let _smoke = crate::local_state::test_env::EnvGuard::unset("WOW_LOGIN_SMOKE");
+
+        // 1 · The director's actual launch line, verbatim from `.cargo/config.toml`'s example.
+        //     Nothing here says anybody is absent, so nothing may end the run — typed or not.
+        let _user = crate::local_state::test_env::EnvGuard::set("WOW_USER", "one");
+        let _pass = crate::local_state::test_env::EnvGuard::set("WOW_PASS", "pone");
+        let _char = crate::local_state::test_env::EnvGuard::set("WOW_CHAR", "One");
+        let _decl = crate::local_state::test_env::EnvGuard::unset("WOW_UNATTENDED");
+        let _cap = crate::local_state::test_env::EnvGuard::unset("WOW_CAPTURE");
+        let _rig = crate::local_state::test_env::EnvGuard::unset("WOW_RIG");
         assert!(
-            crate::run_mode::unattended_login(),
-            "the fixture must reproduce the env that made this fatal",
+            crate::run_mode::env_login() && !crate::run_mode::unattended(),
+            "the fixture must be the env the director plays in: credentials, nobody declared away",
+        );
+        assert!(
+            !refusal_exits(false),
+            "an env-credentialled run with a person in it shows the dialog, it does not exit",
+        );
+
+        // 2 · A run that declares itself driverless keeps decision 1371's leg guarantee.
+        let _decl = crate::local_state::test_env::EnvGuard::set("WOW_UNATTENDED", "1");
+        assert!(
+            refusal_exits(false),
+            "an attempt nobody typed, in a run nobody is in, still exits non-zero",
         );
         assert!(
             !refusal_exits(true),
-            "a password typed at the screen is attended by definition — dialog, then another go",
-        );
-        assert!(
-            refusal_exits(false),
-            "an attempt nobody typed still exits non-zero: decision 1371's leg guarantee",
+            "a password typed at the screen is attended by direct evidence — dialog, another go",
         );
     }
 
diff --git a/crates/benilla-app/src/login/smoke.rs b/crates/benilla-app/src/login/smoke.rs
index f582c03c..1eb35ca9 100644
--- a/crates/benilla-app/src/login/smoke.rs
+++ b/crates/benilla-app/src/login/smoke.rs
@@ -31,12 +31,13 @@ pub(crate) fn smoke_character(spec: &str) -> Option<String> {
 /// log + exit failure on a refusal — the wrong-password path is provable headlessly.
 ///
 /// **Naming a character keeps the run going into the world instead of exiting** (decision 1262).
-/// This is the only headless way to reach the world down the *player's* path: `WOW_CHAR` also
-/// enters the world, but setting it makes the run **unattended**
-/// ([`crate::run_mode::unattended_login`]), and an unattended run takes the other branch at every
-/// session decision — so the attended half was untestable without a person at the keyboard. The
-/// pick itself stays `char_select`'s (`apply_roster_policy` reads the third field the same way it
-/// reads `WOW_CHAR`); this only declines to exit. Pair with `WOW_PROBE_EXIT_AT` to bound the run.
+/// It was the only headless way to reach the world down the *player's* path, back when setting
+/// `WOW_CHAR` also made the run unattended and so switched the very branch a session test wanted
+/// to exercise; decision 1769 severed that, and `WOW_CHAR` now says nothing about who is in the
+/// room. The seat stays because it is the smoke's own way in, and because a run that declares
+/// `WOW_UNATTENDED=1` still needs a way to name a character without taking it. The pick itself
+/// stays `char_select`'s (`apply_roster_policy` reads the third field the same way it reads
+/// `WOW_CHAR`); this only declines to exit. Pair with `WOW_PROBE_EXIT_AT` to bound the run.
 #[allow(clippy::too_many_arguments)]
 pub(super) fn debug_login_smoke(
     state: Res<State<ClientState>>,
diff --git a/crates/benilla-app/src/net.rs b/crates/benilla-app/src/net.rs
index 81ca5ab6..0634df05 100644
--- a/crates/benilla-app/src/net.rs
+++ b/crates/benilla-app/src/net.rs
@@ -1733,10 +1733,22 @@ pub(crate) enum ClientCommand {
     InitiateTrade {
         target: u64,
     },
-    /// The target's auto-reply to `BEGIN_TRADE` (`CMSG_BEGIN_TRADE`, empty) — makes the server emit
-    /// `OPEN_WINDOW` to both sides. Sent by the net bridge the frame it decodes a `BEGIN_TRADE`
-    /// status (decision 0592 P1; the reference client auto-answers, `TradeHandler.cpp`).
+    /// **Accept** an incoming trade request (`CMSG_BEGIN_TRADE`, empty) — makes the server emit
+    /// `OPEN_WINDOW` to both sides. Sent by [`crate::ui_trade::answer_trade_request`], never by the
+    /// net drain: *whether* to accept is a policy with five inputs and (decision 1764) the player's
+    /// own answer, so the arm that decodes `BEGIN_TRADE` only records the request.
     BeginTrade,
+    /// Decline an incoming trade request as **ignored** (`CMSG_IGNORE_TRADE`, `0x119`, empty) —
+    /// leg 2 of the reference's ladder (`0x4bf759` → `0x5d41c0`, its one call site image-wide),
+    /// and the only leg that answers on a different opcode. vmangos turns it into
+    /// `TRADE_STATUS_IGNORE_YOU`, so the initiator reads "… is ignoring you" rather than "busy".
+    IgnoreTrade,
+    /// **Decline** an incoming trade request as busy (`CMSG_BUSY_TRADE`, `0x118`, empty) — the
+    /// reference's own refusal sender (`0x5d4150`), which vmangos turns into `TRADE_STATUS_BUSY`
+    /// to *both* sides. Five of the ladder's eight refusal legs go out on this opcode (decision
+    /// 1764); the ignore leg uses [`Self::IgnoreTrade`], two legs send nothing at all, and the
+    /// **player's** own No is [`Self::CancelTrade`], not this.
+    BusyTrade,
     /// Press the Trade button (`CMSG_ACCEPT_TRADE`) — the accept half of the two-sided confirm.
     AcceptTrade,
     /// Drop your own accept but stay in the trade (`CMSG_UNACCEPT_TRADE`).
@@ -2294,11 +2306,19 @@ impl DisconnectedMessage {
     ///
     /// It is `false` twice over. A [`SessionEnd::LoggedOut`](benilla_protocol::SessionEnd::LoggedOut)
     /// teardown is the relist *inside* one session — the roster that follows IS the character
-    /// select the player asked for. And an unattended run ([`crate::run_mode::unattended_login`])
-    /// keeps 0065's seamless reconnect: a probe has nobody to press Okay.
+    /// select the player asked for. And a run that has **declared itself unattended**
+    /// ([`crate::run_mode::unattended`]) keeps 0065's seamless reconnect: a probe has nobody to
+    /// press Okay.
+    ///
+    /// That second clause used to read the *environment* instead
+    /// ([`crate::run_mode::env_login`] — "any of `$WOW_USER`/`$WOW_PASS`/`$WOW_CHAR`"), which is
+    /// true of the director's own launch line, so 1262's fix was inert in every session a person
+    /// was actually in: the kick came, and the client reconnected and took the account back off
+    /// whoever had displaced it. Decision 1769 — the doubt now falls the other way, and only a run
+    /// that says it is driverless gets to act instead of a person.
     pub(crate) fn new(reason: String, end: benilla_protocol::SessionEnd) -> Self {
         let session_over =
-            end == benilla_protocol::SessionEnd::Lost && !crate::run_mode::unattended_login();
+            end == benilla_protocol::SessionEnd::Lost && !crate::run_mode::unattended();
         Self {
             reason,
             end,
@@ -2498,6 +2518,64 @@ pub(crate) struct AiReactionMessage {
 mod tests {
     use super::*;
 
+    /// **The kick sends the player back to the login screen** — decision 1262's whole promise,
+    /// pinned at the one place that decides it, in the environment the director actually plays in.
+    ///
+    /// 1262 was built and verified in August and then quietly stopped working, with none of its
+    /// code touched: the verdict asked the *environment* whether anybody was here, and on
+    /// 2026-08-29 the director's launch line became `WOW_USER=one WOW_PASS=pone cargo play` — the
+    /// example line in our own `.cargo/config.toml`. From that moment every session they played
+    /// was "a probe", so a kick meant reconnect, and the account ping-ponged exactly as B252
+    /// reported. Nothing about the fix was wrong; the fact under it was. 1769 made the claim a
+    /// declaration, and this test is the tripwire: a run may only act instead of a person if it
+    /// said so.
+    #[test]
+    fn a_kick_ends_the_session_unless_the_run_declared_itself_driverless() {
+        use crate::local_state::test_env::{EnvGuard, ENV_LOCK};
+        let _lock = ENV_LOCK
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        let lost = || {
+            DisconnectedMessage::new("kicked".into(), benilla_protocol::SessionEnd::Lost)
+                .session_over
+        };
+
+        // The director's launch line, verbatim. Credentials in the environment, nobody declared
+        // absent — this is a person playing, and a lost session is over.
+        let _user = EnvGuard::set("WOW_USER", "one");
+        let _pass = EnvGuard::set("WOW_PASS", "pone");
+        let _char = EnvGuard::set("WOW_CHAR", "One");
+        let _decl = EnvGuard::unset("WOW_UNATTENDED");
+        let _cap = EnvGuard::unset("WOW_CAPTURE");
+        let _rig = EnvGuard::unset("WOW_RIG");
+        assert!(lost(), "the reported regression: this must be `true`");
+
+        // A clean `/logout` is never "over" — the roster that follows IS the screen they asked for.
+        assert!(
+            !DisconnectedMessage::new("bye".into(), benilla_protocol::SessionEnd::LoggedOut)
+                .session_over
+        );
+
+        // 0065's seamless reconnect survives exactly where the run says nobody is there to press
+        // Okay — a declaration, or the two runs that cannot be a person.
+        {
+            let _d = EnvGuard::set("WOW_UNATTENDED", "1");
+            assert!(!lost(), "a declared probe still reconnects");
+        }
+        {
+            let _r = EnvGuard::set("WOW_RIG", "at:229,0,0,0");
+            assert!(!lost(), "a rig drives the body; it cannot be a person");
+        }
+        {
+            let _c = EnvGuard::set("WOW_CAPTURE", "some-scenario");
+            assert!(
+                !lost(),
+                "a capture authors the camera; it cannot be a person"
+            );
+        }
+        assert!(lost(), "and the guards put every one of those back");
+    }
+
     /// The vanilla player set, and the one every number below is read against:
     /// walk 2.5 · run 7.0 · runBack 4.5 · swim 4.722 · swimBack 2.5 (vmangos `baseMoveSpeed`).
     fn vanilla() -> MoveSpeeds {
diff --git a/crates/benilla-app/src/net/apply.rs b/crates/benilla-app/src/net/apply.rs
index 73b881f9..84efeecf 100644
--- a/crates/benilla-app/src/net/apply.rs
+++ b/crates/benilla-app/src/net/apply.rs
@@ -1956,9 +1956,7 @@ pub(super) fn apply_net_updates(
             // The player-trade arc (decision 0592 P1): the status packet drives the open/accept/close
             // state machine, the extended snapshot replaces one side's item/gold — both into the
             // `TradeSession` the trade feed (`crate::ui_trade`) reads.
-            SessionEvent::TradeStatus { status } => {
-                trade::trade_status(status, &mut trade_session, &net_commands)
-            }
+            SessionEvent::TradeStatus { status } => trade::trade_status(status, &mut trade_session),
             SessionEvent::TradeStatusExtended { state } => {
                 trade::trade_status_extended(&state, &mut trade_session)
             }
diff --git a/crates/benilla-app/src/net/apply/auction.rs b/crates/benilla-app/src/net/apply/auction.rs
index ddc0f181..6c99caad 100644
--- a/crates/benilla-app/src/net/apply/auction.rs
+++ b/crates/benilla-app/src/net/apply/auction.rs
@@ -208,13 +208,13 @@ pub(super) fn auction_removed_notification(item_entry: u32, auction: &mut Auctio
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::ui_action::MsgSurface;
+    use crate::ui_action::MsgKind;
 
-    fn keys(auction: &AuctionOpen) -> Vec<(&'static str, MsgSurface, Option<u32>)> {
+    fn keys(auction: &AuctionOpen) -> Vec<(&'static str, MsgKind, Option<u32>)> {
         auction
             .messages
             .iter()
-            .map(|m| (m.key, m.surface, m.item))
+            .map(|m| (m.key, benilla_ui::messages::kind_of(m.key), m.item))
             .collect()
     }
 
@@ -259,7 +259,7 @@ mod tests {
         auction_owner_notification(&owner(0, 10_000), &mut a);
         assert_eq!(
             keys(&a),
-            vec![("ERR_AUCTION_SOLD_S", MsgSurface::Chat, Some(2589))]
+            vec![("ERR_AUCTION_SOLD_S", MsgKind::Chat, Some(2589))]
         );
 
         // Expired: guid zeroed, and nobody paid anything.
@@ -267,7 +267,7 @@ mod tests {
         auction_owner_notification(&owner(0, 0), &mut a);
         assert_eq!(
             keys(&a),
-            vec![("ERR_AUCTION_EXPIRED_S", MsgSurface::Chat, Some(2589))],
+            vec![("ERR_AUCTION_EXPIRED_S", MsgKind::Chat, Some(2589))],
             "a zero bid on a closed auction is an expiry, not a sale"
         );
     }
@@ -279,14 +279,14 @@ mod tests {
         auction_bidder_notification(&bidder(0), &mut a);
         assert_eq!(
             keys(&a),
-            vec![("ERR_AUCTION_WON_S", MsgSurface::Chat, Some(2589))]
+            vec![("ERR_AUCTION_WON_S", MsgKind::Chat, Some(2589))]
         );
 
         let mut a = AuctionOpen::default();
         auction_bidder_notification(&bidder(9_000), &mut a);
         assert_eq!(
             keys(&a),
-            vec![("ERR_AUCTION_OUTBID_S", MsgSurface::Chat, Some(2589))]
+            vec![("ERR_AUCTION_OUTBID_S", MsgKind::Chat, Some(2589))]
         );
     }
 
@@ -305,7 +305,7 @@ mod tests {
             auction_command_result(7, action, auction_error::OK, &tail, &mut a);
             assert_eq!(
                 keys(&a),
-                vec![(key, MsgSurface::Chat, None)],
+                vec![(key, MsgKind::Chat, None)],
                 "a successful {action} says so in chat, with no item fill"
             );
         }
@@ -314,7 +314,7 @@ mod tests {
         auction_removed_notification(2589, &mut a);
         assert_eq!(
             keys(&a),
-            vec![("ERR_AUCTION_REMOVED_S", MsgSurface::Chat, Some(2589))]
+            vec![("ERR_AUCTION_REMOVED_S", MsgKind::Chat, Some(2589))]
         );
 
         // A refusal, on the red frame.
@@ -322,7 +322,7 @@ mod tests {
         auction_command_result(0, auction_action::BID_PLACED, 10, &tail, &mut a);
         assert_eq!(
             keys(&a),
-            vec![("ERR_AUCTION_BID_OWN", MsgSurface::Error, None)]
+            vec![("ERR_AUCTION_BID_OWN", MsgKind::Error, None)]
         );
 
         // HIGHER_BID is the live outbid UPDATE path, not a message — the line the player sees is
@@ -345,7 +345,7 @@ mod tests {
         a.clear();
         assert_eq!(
             keys(&a),
-            vec![("ERR_AUCTION_SOLD_S", MsgSurface::Chat, Some(2589))]
+            vec![("ERR_AUCTION_SOLD_S", MsgKind::Chat, Some(2589))]
         );
     }
 }
diff --git a/crates/benilla-app/src/net/apply/chat.rs b/crates/benilla-app/src/net/apply/chat.rs
index a32bb481..195c6762 100644
--- a/crates/benilla-app/src/net/apply/chat.rs
+++ b/crates/benilla-app/src/net/apply/chat.rs
@@ -402,7 +402,10 @@ mod tests {
         notification("GM mode is ON".to_string(), &mut errors);
         assert_eq!(
             errors.0,
-            [("GM mode is ON".to_string(), false)],
+            [(
+                "GM mode is ON".to_string(),
+                crate::ui_action::MsgKind::Error
+            )],
             "the SendNotification half is the RED toast (0x4945b0's flag 1), never a second line"
         );
     }
@@ -420,7 +423,10 @@ mod tests {
         );
         assert_eq!(
             errors.0,
-            [("You must be at least level 58 to enter.".to_string(), true)]
+            [(
+                "You must be at least level 58 to enter.".to_string(),
+                crate::ui_action::MsgKind::Info
+            )]
         );
     }
 }
diff --git a/crates/benilla-app/src/net/apply/loot.rs b/crates/benilla-app/src/net/apply/loot.rs
index b260cb70..975abf64 100644
--- a/crates/benilla-app/src/net/apply/loot.rs
+++ b/crates/benilla-app/src/net/apply/loot.rs
@@ -103,7 +103,7 @@ pub(super) fn fish_verdict(escaped: bool, errors: &mut UiErrorKeys) {
         "ERR_FISH_NOT_HOOKED"
     };
     debug!("net: fishing verdict {key}");
-    errors.0.push(UiError::info_key(key));
+    errors.0.push(UiError::key(key));
 }
 
 /// The server refused to open the loot window (`SMSG_LOOT_RESPONSE`'s error shape — didn't kill
@@ -295,8 +295,8 @@ mod tests {
         assert_eq!(
             errors.0,
             vec![
-                UiError::info_key("ERR_FISH_NOT_HOOKED"),
-                UiError::info_key("ERR_FISH_ESCAPED"),
+                UiError::key("ERR_FISH_NOT_HOOKED"),
+                UiError::key("ERR_FISH_ESCAPED"),
             ]
         );
 
diff --git a/crates/benilla-app/src/net/apply/quests.rs b/crates/benilla-app/src/net/apply/quests.rs
index 9783c922..cd0510b3 100644
--- a/crates/benilla-app/src/net/apply/quests.rs
+++ b/crates/benilla-app/src/net/apply/quests.rs
@@ -9,7 +9,7 @@ use benilla_protocol::messages::{
 };
 use bevy::prelude::*;
 
-use crate::ui_action::{MsgSurface, UiError};
+use crate::ui_action::UiError;
 use crate::ui_chat::ChatLog;
 use crate::ui_quest::QuestGiver;
 use crate::ui_quest_log::QuestLog;
@@ -167,7 +167,7 @@ pub(super) fn quest_failed(
 /// English chat push here).
 pub(super) fn quest_log_full(quest: &mut QuestGiver) {
     debug!("net: quest log full");
-    quest.push_message(MsgSurface::Error, UiError::key("ERR_QUEST_LOG_FULL"));
+    quest.push_message(UiError::key("ERR_QUEST_LOG_FULL"));
 }
 
 /// The giver won't offer the quest (`SMSG_QUESTGIVER_QUEST_INVALID`, ref handler `0x5dbca0`): one
@@ -181,10 +181,9 @@ pub(super) fn quest_log_full(quest: &mut QuestGiver) {
 /// this the panel sat open on a refused accept (decision 0669).
 pub(super) fn quest_giver_invalid(reason: u32, quest: &mut QuestGiver) {
     debug!("net: questgiver refused to offer the quest (reason {reason})");
-    quest.push_message(
-        MsgSurface::Chat,
-        UiError::key(crate::ui_quest::questgiver_invalid_key(reason)),
-    );
+    quest.push_message(UiError::key(crate::ui_quest::questgiver_invalid_key(
+        reason,
+    )));
     quest.clear();
 }
 
@@ -210,17 +209,13 @@ pub(super) fn quest_giver_failed(
                 .map(|t| t.title.clone())
         })
         .unwrap_or_default();
-    quest.push_message(
-        MsgSurface::Chat,
-        UiError {
-            key: crate::ui_quest::questgiver_failed_key(reason),
-            fill_s: Some(title),
-            fill_d: None,
-            info: false,
-        },
-    );
+    quest.push_message(UiError {
+        key: crate::ui_quest::questgiver_failed_key(reason),
+        fill_s: Some(title),
+        fill_d: None,
+    });
     if matches!(reason, 4 | 50) {
-        quest.push_message(MsgSurface::Error, UiError::key("ERR_INV_FULL"));
+        quest.push_message(UiError::key("ERR_INV_FULL"));
     }
     quest.clear();
 }
@@ -283,8 +278,8 @@ mod tests {
         quest_giver_invalid(13, &mut giver);
         let msgs = giver.take_messages();
         assert_eq!(msgs.len(), 1);
-        assert_eq!(msgs[0].0, MsgSurface::Chat);
-        assert_eq!(msgs[0].1, UiError::key("ERR_QUEST_ALREADY_ON"));
+        assert_eq!(msgs[0].kind(), crate::ui_action::MsgKind::Chat);
+        assert_eq!(msgs[0], UiError::key("ERR_QUEST_ALREADY_ON"));
         assert!(!giver.is_open(), "the ref closes the window on a refusal");
     }
 
@@ -299,18 +294,17 @@ mod tests {
         quest_giver_failed(373, 4, &mut giver, &mut log, &commands);
         let msgs = giver.take_messages();
         assert_eq!(msgs.len(), 2);
-        assert_eq!(msgs[0].0, MsgSurface::Chat);
+        assert_eq!(msgs[0].kind(), crate::ui_action::MsgKind::Chat);
         assert_eq!(
-            msgs[0].1,
+            msgs[0],
             UiError {
                 key: "ERR_QUEST_FAILED_BAG_FULL_S",
                 fill_s: Some("A Threat Within".into()),
                 fill_d: None,
-                info: false,
             }
         );
-        assert_eq!(msgs[1].0, MsgSurface::Error);
-        assert_eq!(msgs[1].1, UiError::key("ERR_INV_FULL"));
+        assert_eq!(msgs[1].kind(), crate::ui_action::MsgKind::Error);
+        assert_eq!(msgs[1], UiError::key("ERR_INV_FULL"));
         assert!(!giver.is_open());
     }
 
@@ -322,8 +316,8 @@ mod tests {
         quest_log_full(&mut giver);
         let msgs = giver.take_messages();
         assert_eq!(msgs.len(), 1);
-        assert_eq!(msgs[0].0, MsgSurface::Error);
-        assert_eq!(msgs[0].1, UiError::key("ERR_QUEST_LOG_FULL"));
+        assert_eq!(msgs[0].kind(), crate::ui_action::MsgKind::Error);
+        assert_eq!(msgs[0], UiError::key("ERR_QUEST_LOG_FULL"));
         assert!(
             giver.is_open(),
             "the ref's 0x195 arm does not close the panel"
@@ -340,8 +334,8 @@ mod tests {
         let commands = NetCommands(tx);
         quest_giver_failed(999, 17, &mut giver, &mut log, &commands);
         let msgs = giver.take_messages();
-        assert_eq!(msgs[0].1.key, "ERR_QUEST_FAILED_MAX_COUNT_S");
-        assert_eq!(msgs[0].1.fill_s.as_deref(), Some(""));
+        assert_eq!(msgs[0].key, "ERR_QUEST_FAILED_MAX_COUNT_S");
+        assert_eq!(msgs[0].fill_s.as_deref(), Some(""));
     }
 
     // ── The share's BUSY refusal (decision 1738) ─────────────────────────────────────────────────
diff --git a/crates/benilla-app/src/net/apply/spells.rs b/crates/benilla-app/src/net/apply/spells.rs
index af301f80..370cac88 100644
--- a/crates/benilla-app/src/net/apply/spells.rs
+++ b/crates/benilla-app/src/net/apply/spells.rs
@@ -1055,6 +1055,7 @@ mod tests {
             .add_message::<CombatTextSpawn>()
             .add_message::<GoLidOpen>()
             .add_message::<crate::creature_anim::SheathRequest>()
+            .add_message::<crate::player::StandStateRequest>()
             .init_resource::<GuidIndex>()
             .init_resource::<SelfGuid>()
             .init_resource::<CastBarFeed>()
@@ -1222,6 +1223,7 @@ mod tests {
                 .add_message::<CombatTextSpawn>()
                 .add_message::<GoLidOpen>()
                 .add_message::<crate::creature_anim::SheathRequest>()
+                .add_message::<crate::player::StandStateRequest>()
                 .init_resource::<GuidIndex>()
                 .init_resource::<SelfGuid>()
                 .init_resource::<CastBarFeed>()
@@ -1354,6 +1356,7 @@ mod tests {
             .add_message::<CombatTextSpawn>()
             .add_message::<GoLidOpen>()
             .add_message::<crate::creature_anim::SheathRequest>()
+            .add_message::<crate::player::StandStateRequest>()
             .init_resource::<GuidIndex>()
             .init_resource::<SelfGuid>()
             .init_resource::<CastBarFeed>()
@@ -1661,6 +1664,7 @@ mod tests {
                 .add_message::<CombatTextSpawn>()
                 .add_message::<GoLidOpen>()
                 .add_message::<crate::creature_anim::SheathRequest>()
+                .add_message::<crate::player::StandStateRequest>()
                 .init_resource::<GuidIndex>()
                 .init_resource::<SelfGuid>()
                 .init_resource::<CastBarFeed>()
diff --git a/crates/benilla-app/src/net/apply/trade.rs b/crates/benilla-app/src/net/apply/trade.rs
index b9cc2428..cfde080a 100644
--- a/crates/benilla-app/src/net/apply/trade.rs
+++ b/crates/benilla-app/src/net/apply/trade.rs
@@ -7,26 +7,31 @@
 
 use benilla_protocol::messages::{TradeStatus, TradeStatusExtended};
 
-use crate::net::{ClientCommand, NetCommands};
 use crate::ui_trade::TradeSession;
 
 /// `SessionEvent::TradeStatus` (`SMSG_TRADE_STATUS`) — the trade state machine (decision 0592 P1).
-/// `BEGIN_TRADE` records the partner and auto-answers `CMSG_BEGIN_TRADE` (the reference client's
-/// auto-reply, vmangos `TradeHandler.cpp` — it makes the server emit `OPEN_WINDOW` to both sides);
-/// `OPEN_WINDOW` opens the window; `TRADE_ACCEPT`/`BACK_TO_TRADE` drive the accept glow; the terminal
-/// and refusal codes close it. The refusal statuses' red error text is decision 0592 P3;
-/// `ONLY_CONJURED` (a rejected item placement, not a window close) and any out-of-range code are inert.
-pub(super) fn trade_status(status: TradeStatus, trade: &mut TradeSession, commands: &NetCommands) {
+/// `BEGIN_TRADE` records the incoming request **without answering it** (decision 1764 — the reply
+/// is a policy with five gates and the player's own consent, so
+/// [`crate::ui_trade::answer_trade_request`] owns it); `OPEN_WINDOW` opens the window;
+/// `TRADE_ACCEPT`/`BACK_TO_TRADE` drive the accept glow; the terminal and refusal codes close it.
+/// The refusal statuses' red error text is decision 0592 P3; `ONLY_CONJURED` (a rejected item
+/// placement, not a window close) and any out-of-range code are inert.
+pub(super) fn trade_status(status: TradeStatus, trade: &mut TradeSession) {
     bevy::log::info!(target: "trade", "SMSG_TRADE_STATUS {status:?}");
     match status {
-        TradeStatus::BeginTrade { partner } => {
-            trade.begin(partner);
-            let _ = commands.0.send(ClientCommand::BeginTrade);
-        }
+        TradeStatus::BeginTrade { partner } => trade.request(partner),
         TradeStatus::OpenWindow => trade.open_window(),
         TradeStatus::Accept => trade.partner_accepted(),
         TradeStatus::BackToTrade => trade.back_to_trade(),
         // Terminal (complete/cancel/close) + every initiate/in-trade refusal → close the window.
+        //
+        // **Two statuses sit outside the reference's own clear set, and neither is reachable on
+        // vmangos** (decision 1764, noticed rather than chased). The reference clears its trade
+        // cells in the status handler's common tail on 0, 3, 5, 6, 8, 10, 11, 12, 13 and 14–21;
+        // this list is that set minus `Rejected` (9), which we close on and it does not, plus
+        // `Unknown13` (13), which it clears on and we treat as inert below. vmangos sends neither,
+        // so there is no observable to settle it against — which is exactly why it is written down
+        // here instead of being guessed at in either direction.
         TradeStatus::Canceled
         | TradeStatus::Complete
         | TradeStatus::CloseWindow { .. }
diff --git a/crates/benilla-app/src/net/io.rs b/crates/benilla-app/src/net/io.rs
index 2d0861b9..90f8b676 100644
--- a/crates/benilla-app/src/net/io.rs
+++ b/crates/benilla-app/src/net/io.rs
@@ -1028,6 +1028,8 @@ fn writer_loop(
                     // The player-trade arc (decision 0592) — the CMSG verbs onto the P0 writers.
                     ClientCommand::InitiateTrade { target } => w.initiate_trade(target),
                     ClientCommand::BeginTrade => w.begin_trade(),
+                    ClientCommand::BusyTrade => w.busy_trade(),
+                    ClientCommand::IgnoreTrade => w.ignore_trade(),
                     ClientCommand::AcceptTrade => w.accept_trade(),
                     ClientCommand::UnacceptTrade => w.unaccept_trade(),
                     ClientCommand::CancelTrade => w.cancel_trade(),
diff --git a/crates/benilla-app/src/run_mode.rs b/crates/benilla-app/src/run_mode.rs
index 93ea7c53..ee9adf42 100644
--- a/crates/benilla-app/src/run_mode.rs
+++ b/crates/benilla-app/src/run_mode.rs
@@ -51,30 +51,84 @@ pub(crate) fn scenario_active() -> bool {
     std::env::var("WOW_CAPTURE").is_ok()
 }
 
-/// **Is anything but a person answering this session's login?** (`$WOW_USER` / `$WOW_PASS` /
-/// `$WOW_CHAR` — the login screen's env fast path.)
+/// **Do the credentials come from the environment?** (`$WOW_USER` / `$WOW_PASS` / `$WOW_CHAR` —
+/// the login screen's env fast path.)
 ///
 /// The player answer is `false`, and it is the default: with none of these set the client opens at
-/// the login screen and waits for somebody to type. Setting any of them *is* a harness saying "log
-/// in without me" — a probe, a smoke, a rig — so it is also the honest answer to the question a
-/// dead session asks: **is there anybody here to log back in?**
+/// the login screen and waits for somebody to type. Setting any of them says *"log in without
+/// waiting for me to type"* — and **that is the only thing it says.** It is not a claim about who
+/// is in the room; [`unattended`] is the fact for that, and keeping the two apart is decision 1769.
 ///
-/// That question decides what a lost session does (decision 1262). A person gets the reference's
-/// answer — the world torn down, the account screen, "Disconnected from server", and nothing
-/// retried until they say so. An unattended run keeps 0065's seamless reconnect, because the
-/// alternative is a probe parked on a login dialog for the rest of its wall-clock. One environment
-/// fact, several readers, no shared symbol — the module doc's pattern, same as [`scenario_active`],
-/// and the reason the login policy's own fast path asks here instead of re-reading the three names.
-///
-/// The session-loss readers never call this directly: [`crate::net::DisconnectedMessage::new`]
-/// asks once, at the wire edge, and every reader acts on the verdict it carries — so the teardown,
-/// the screen flip and the credential policy cannot answer it three different ways.
-pub(crate) fn unattended_login() -> bool {
+/// One environment fact, several readers, no shared symbol — the module doc's pattern, same as
+/// [`scenario_active`], and the reason the roster's `WOW_CHAR` fast path asks here instead of
+/// re-reading the three names.
+pub(crate) fn env_login() -> bool {
     ["WOW_USER", "WOW_PASS", "WOW_CHAR"]
         .iter()
         .any(|k| std::env::var_os(k).is_some())
 }
 
+/// **Is there nobody here?** (`$WOW_UNATTENDED`, or the two runs that are automated by
+/// construction: `$WOW_CAPTURE` and `$WOW_RIG`.)
+///
+/// The player answer is `false` and it is the **default**, like every other answer in this module:
+/// a client with nobody at the keyboard is the exception, and an exception declares itself. The
+/// direction is the whole point — guessing "attended" when a probe is running costs that probe a
+/// timeout, loudly; guessing "unattended" when a person is playing ships them a client that fights
+/// another client for their account, silently. Those two are not worth the same, so the doubt goes
+/// one way.
+///
+/// **This is the fact [`env_login`] was mistaken for, twice.** Env credentials mean "log in without
+/// typing"; they say nothing about the room — and the director plays with
+/// `WOW_USER=one WOW_PASS=pone cargo play`, which is the example line in `.cargo/config.toml`. So
+/// every session they played read as "a harness": a typed password's refusal killed the process
+/// (fixed on 2026-08-28 by asking `announced` — direct evidence — instead of the environment) and,
+/// the half that fix left standing, a kick sent the client racing to take the account back instead
+/// of to the login screen. That is decision 1262's reported bug, reappearing three weeks later
+/// with not one line of its code changed, because the fact underneath it was never true. 1769.
+///
+/// `WOW_CAPTURE` and `WOW_RIG` are folded in because they *cannot* be a person: a capture authors
+/// the camera and a rig drives the body, so a run that sets either has already said what it is and
+/// cannot forget to. Everything else declares — `scripts/leg.sh`, `smoke.sh`, `cine.sh`,
+/// `summon-live.sh` and the ad-hoc probe recipe in `method.md` all pass `WOW_UNATTENDED=1`.
+///
+/// Read by whatever may act *instead of* a person: the lost-session verdict (decision 1262 — the
+/// session-loss readers never call this directly, [`crate::net::DisconnectedMessage::new`] asks
+/// once at the wire edge and every reader acts on the verdict it carries) and the two `FATAL`
+/// exits that keep a driverless run from burning its wall-clock on a dialog (decision 1371).
+pub(crate) fn unattended() -> bool {
+    ["WOW_UNATTENDED", "WOW_CAPTURE", "WOW_RIG"]
+        .iter()
+        .any(|k| std::env::var_os(k).is_some())
+}
+
+/// **This run cannot get past the screen it is on — may the client end it instead of a person?**
+/// (decision 1371's `FATAL` marker, resting on 1769's fact.)
+///
+/// `true` only for a run that has declared itself [`unattended`]: it exits non-zero on the one
+/// greppable marker `scripts/leg.sh` keys on, rather than parking a driverless run on a dialog for
+/// its whole wall-clock. Otherwise the dialog stays up for whoever is there.
+///
+/// The `false` arm still speaks, when the credentials came from the environment: a probe that
+/// quietly parks for 300 s instead of failing in 5 is precisely what 1769's default trades away,
+/// so the log names the declaration that buys the old behaviour back. Both arms live here because
+/// three call sites — two in [`crate::login`], one in [`crate::char_select`] — must not drift
+/// apart on either the verdict or the marker `leg.sh` greps for.
+pub(crate) fn fatal_when_driverless(why: &str) -> bool {
+    if unattended() {
+        error!("login: FATAL — {why}; exiting");
+        return true;
+    }
+    if env_login() {
+        warn!(
+            "login: {why} — leaving the dialog up, because nothing declared this run driverless. \
+             Set WOW_UNATTENDED=1 if nobody is here and it should exit non-zero instead \
+             (decision 1769)."
+        );
+    }
+    false
+}
+
 /// **Which screen the client starts on.** A player starts at the login screen, always; a capture
 /// boots straight into the world (no net, no picker), and a *glue* capture boots onto the very
 /// screen it photographs.
@@ -369,6 +423,43 @@ mod tests {
         );
     }
 
+    /// **Two questions, two facts** (decision 1769) — and the fixture is the line the director
+    /// actually types, so a future merge of the two answers fails here rather than in their game.
+    #[test]
+    fn env_credentials_are_not_a_claim_about_who_is_in_the_room() {
+        use crate::local_state::test_env::{EnvGuard, ENV_LOCK};
+        let _lock = ENV_LOCK
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        let _decl = EnvGuard::unset("WOW_UNATTENDED");
+        let _cap = EnvGuard::unset("WOW_CAPTURE");
+        let _rig = EnvGuard::unset("WOW_RIG");
+
+        // A player build's defaults: nothing set, nothing assumed.
+        {
+            let _u = EnvGuard::unset("WOW_USER");
+            let _p = EnvGuard::unset("WOW_PASS");
+            let _c = EnvGuard::unset("WOW_CHAR");
+            assert!(!env_login() && !unattended());
+        }
+        // `WOW_USER=one WOW_PASS=pone cargo play` — `.cargo/config.toml`'s own example, and the
+        // director's launch line since 2026-08-29. Log them in without typing, yes. Decide things
+        // on their behalf, no.
+        let _u = EnvGuard::set("WOW_USER", "one");
+        let _p = EnvGuard::set("WOW_PASS", "pone");
+        assert!(env_login(), "the fast path still submits for them");
+        assert!(
+            !unattended(),
+            "credentials in the environment are not an empty chair",
+        );
+        // The declaration, and the two runs that are automated by construction.
+        for key in ["WOW_UNATTENDED", "WOW_CAPTURE", "WOW_RIG"] {
+            let _d = EnvGuard::set(key, "1");
+            assert!(unattended(), "{key} declares the run driverless");
+        }
+        assert!(!unattended(), "and each guard puts it back");
+    }
+
     #[test]
     fn the_guard_only_polices_accounts_that_belong_to_someone() {
         // Our own slot's probe: the whole point of the identity.
diff --git a/crates/benilla-app/src/target/click.rs b/crates/benilla-app/src/target/click.rs
index 516d2d3d..c58c2af9 100644
--- a/crates/benilla-app/src/target/click.rs
+++ b/crates/benilla-app/src/target/click.rs
@@ -738,7 +738,6 @@ fn route_lock_refusal(
                 key: "ERR_USE_LOCKED_WITH_ITEM_S",
                 fill_s: Some(name),
                 fill_d: None,
-                info: false,
             }),
         },
         benilla_formats::LOCK_KEY_SKILL => {
@@ -749,14 +748,12 @@ fn route_lock_refusal(
                     key: "ERR_USE_LOCKED_WITH_SPELL_KNOWN_SI",
                     fill_s: Some(name),
                     fill_d: Some(required),
-                    info: false,
                 })
             } else {
                 Some(UiError {
                     key: "ERR_USE_LOCKED_WITH_SPELL_S",
                     fill_s: Some(name),
                     fill_d: None,
-                    info: false,
                 })
             }
         }
diff --git a/crates/benilla-app/src/target/scan.rs b/crates/benilla-app/src/target/scan.rs
index 1ad88716..87b8843e 100644
--- a/crates/benilla-app/src/target/scan.rs
+++ b/crates/benilla-app/src/target/scan.rs
@@ -1173,6 +1173,7 @@ mod tests {
         world.init_resource::<crate::ui_cast::QueuedMeleeSpell>();
         world.init_resource::<crate::ui_action::AutoRepeatActive>();
         world.init_resource::<Messages<crate::creature_anim::SheathRequest>>();
+        world.init_resource::<Messages<crate::player::StandStateRequest>>();
         world.init_resource::<Selection>();
         world.spawn(SelfPlayer);
 
diff --git a/crates/benilla-app/src/ui_action/cast_fail.rs b/crates/benilla-app/src/ui_action/cast_fail.rs
index 1ecf7359..b013f595 100644
--- a/crates/benilla-app/src/ui_action/cast_fail.rs
+++ b/crates/benilla-app/src/ui_action/cast_fail.rs
@@ -260,7 +260,47 @@ impl FailArgs<'_> {
     }
 }
 
-/// The displayed text for a failed cast — `None` = the reference shows nothing. `get` is the
+/// The errorId every reason that overrides nothing falls through to — `0x2c`, whose text is the
+/// bare `"%s"`, so what the player reads is the first layer's `SPELL_FAILED_*` string. benilla
+/// short-circuits the identity substitution and displays that string directly; the id still
+/// matters, because it is the id whose **record** decides the surface.
+pub(super) const PASSTHROUGH: &str = "ERR_SPELL_FAILED_S";
+
+/// One resolved cast-failure line: the text to show, and the **message id's key** that decides
+/// where to show it.
+///
+/// The key rides along because the reference's second layer hands its errorId to
+/// `CGGameUI::DisplayError`, and that function reads the record's kind — so the surface is a
+/// property of the id this dispatch picked, not of "cast failures" as a category. Seventeen of
+/// the overrides are red and `ERR_SPELL_FAILED_NOTUNSHEATHED` is **yellow**; before the catalog
+/// (decision 1770) benilla painted all eighteen red, because nothing here knew which id it had
+/// chosen by the time the line reached the frame.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(super) struct CastFailLine {
+    pub key: &'static str,
+    pub text: String,
+}
+
+impl CastFailLine {
+    /// A line the second layer left on its default errorId — the drain builds these for the three
+    /// argument arms it owns (`0x78` TOTEMS, `0x5c` REAGENTS, `0x19`-`0x1b` EQUIPPED_ITEM_CLASS*),
+    /// whose fills need the item caches.
+    pub(super) fn passthrough(text: String) -> Self {
+        Self {
+            key: PASSTHROUGH,
+            text,
+        }
+    }
+
+    fn fill(self, name: &str) -> Self {
+        Self {
+            text: self.text.replace("%s", name),
+            ..self
+        }
+    }
+}
+
+/// The displayed line for a failed cast — `None` = the reference shows nothing. `get` is the
 /// VM's GlobalStrings lookup (an absent or empty key resolves to `None`, the data-suppression
 /// face). Reasons beyond the table print their code — our debug affordance, not a ref string.
 pub(super) fn cast_fail_text(
@@ -268,16 +308,17 @@ pub(super) fn cast_fail_text(
     spell: Option<&SpellDisplay>,
     args: FailArgs<'_>,
     get: &dyn Fn(&str) -> Option<String>,
-) -> Option<String> {
-    let get_display = |key: &str| get(key).filter(|s| !s.is_empty());
+) -> Option<CastFailLine> {
+    let get_text = |key: &str| get(key).filter(|s| !s.is_empty());
+    let get_display = |key: &'static str| get_text(key).map(|text| CastFailLine { key, text });
     // The errorId overrides (`0x6e1aab–0x6e1c5f`): the replaced-message reasons.
     match reason {
         0x01 => return get_display("ERR_SPELL_FAILED_ALREADY_AT_FULL_HEALTH"),
         0x02 => {
             let t = get_display("ERR_SPELL_FAILED_ALREADY_AT_FULL_POWER_S")?;
             let power = spell.map_or(0, |d| d.power_type);
-            let name = get_display(power_keys(power).1).unwrap_or_default();
-            return Some(t.replace("%s", &name));
+            let name = get_text(power_keys(power).1).unwrap_or_default();
+            return Some(t.fill(&name));
         }
         0x09 => return get_display("ERR_GENERIC_NO_TARGET"),
         0x17 => return None, // DONT_REPORT: control-flow hidden (jumps past DisplayError)
@@ -312,12 +353,19 @@ pub(super) fn cast_fail_text(
     }
     // The passthrough layer: errorId 0x2c ("%s") displays GetText(SPELL_FAILED_<name>) as-is.
     let Some(key) = CAST_FAIL_KEYS.get(usize::from(reason)) else {
-        return Some(format!("Spell failed ({reason:#04x})"));
+        return Some(CastFailLine {
+            key: PASSTHROUGH,
+            text: format!("Spell failed ({reason:#04x})"),
+        });
+    };
+    let text = get_text(key)?;
+    let line = |text: String| CastFailLine {
+        key: PASSTHROUGH,
+        text,
     };
-    let text = get_display(key)?;
     // The argument arms (`0x6e1d8e`): fill the template's `%s` from the reason's own DBC.
     if let Some(name) = args.fill(reason, spell) {
-        return Some(text.replace("%s", &name));
+        return Some(line(text.replace("%s", &name)));
     }
     // An arm we don't model (or one whose lookup missed) — strip the tokens so the stem reads
     // clean ("Missing reagent: %s" → "Missing reagent"), never a raw % on screen.
@@ -328,13 +376,13 @@ pub(super) fn cast_fail_text(
             .split_whitespace()
             .collect::<Vec<_>>()
             .join(" ");
-        return Some(
+        return Some(line(
             stripped
                 .trim_end_matches([' ', ':', '.', '(', ')'])
                 .to_string(),
-        );
+        ));
     }
-    Some(text)
+    Some(line(text))
 }
 
 #[cfg(test)]
@@ -357,9 +405,45 @@ mod tests {
             ("ERR_POTION_COOLDOWN", "Item is not ready yet."),
             ("ERR_OUT_OF_MANA", "Not enough mana"),
             ("ERR_OUT_OF_RAGE", "Not enough rage"),
+            (
+                "ERR_SPELL_FAILED_NOTUNSHEATHED",
+                "You have nothing to attack with.",
+            ),
         ])
     }
 
+    /// **The one cast failure that is not a red line.** Reason `0x41` overrides to
+    /// `ERR_SPELL_FAILED_NOTUNSHEATHED` (id 320), and that record's kind is `1` — the yellow
+    /// `UI_INFO_MESSAGE`, not the red `UI_ERROR_MESSAGE` its seventeen override neighbours take.
+    ///
+    /// benilla painted it red until decision 1770, and could not have done otherwise: the drain
+    /// fired one event for every resolved cast-failure line, because by the time a line got there
+    /// nothing knew which errorId this dispatch had chosen. Carrying the key out is what makes the
+    /// surface answerable, and this test is the answer.
+    ///
+    /// Its two yellow siblings, `ERR_FISH_NOT_HOOKED` (318) and `ERR_FISH_ESCAPED` (319), sit one
+    /// and two ids below it and were hand-traced correctly by an earlier round — which is exactly
+    /// how a hand-swept surface goes wrong: two of the three neighbours seen, the third not.
+    #[test]
+    fn the_unsheathed_refusal_is_yellow_and_its_neighbours_are_red() {
+        use benilla_ui::messages::{kind_of, MsgKind};
+        let m = gs();
+        let g = getter(&m);
+
+        let line = cast_fail_text(0x41, None, FailArgs::default(), &g).expect("a line");
+        assert_eq!(line.key, "ERR_SPELL_FAILED_NOTUNSHEATHED");
+        assert_eq!(kind_of(line.key), MsgKind::Info);
+
+        // An override that IS red, and a passthrough that falls to errorId 0x2c.
+        let red = cast_fail_text(0x59, None, FailArgs::default(), &g).expect("a line");
+        assert_eq!(red.key, "ERR_SPELL_OUT_OF_RANGE");
+        assert_eq!(kind_of(red.key), MsgKind::Error);
+
+        let through = cast_fail_text(0x43, None, FailArgs::default(), &g).expect("a line");
+        assert_eq!(through.key, PASSTHROUGH);
+        assert_eq!(kind_of(through.key), MsgKind::Error);
+    }
+
     fn getter<'a>(
         map: &'a HashMap<&'static str, &'static str>,
     ) -> impl Fn(&str) -> Option<String> + 'a {
@@ -392,35 +476,49 @@ mod tests {
         let m = gs();
         let g = getter(&m);
         assert_eq!(
-            cast_fail_text(0x43, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x43, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Out of ammo"
         );
         assert_eq!(
-            cast_fail_text(0x59, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x59, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Out of range."
         );
         assert_eq!(
-            cast_fail_text(0x76, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x76, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Target too close"
         );
         assert_eq!(
-            cast_fail_text(0x09, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x09, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "You have no target."
         );
         // 0x3c: plain spell → spell cooldown; Attr&0x10 → ability; potion category → potion.
         let plain = spell(0, 0, 0);
         assert_eq!(
-            cast_fail_text(0x3C, Some(&plain), FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x3C, Some(&plain), FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Spell is not ready yet."
         );
         let ability = spell(1, 0, 0x10);
         assert_eq!(
-            cast_fail_text(0x3C, Some(&ability), FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x3C, Some(&ability), FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Ability is not ready yet."
         );
         let potion = spell(0, 4, 0);
         assert_eq!(
-            cast_fail_text(0x3C, Some(&potion), FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x3C, Some(&potion), FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Item is not ready yet."
         );
     }
@@ -433,12 +531,16 @@ mod tests {
         let g = getter(&m);
         let rage = spell(1, 0, 0);
         assert_eq!(
-            cast_fail_text(0x4D, Some(&rage), FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x4D, Some(&rage), FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Not enough rage"
         );
         let mana = spell(0, 0, 0);
         assert_eq!(
-            cast_fail_text(0x4D, Some(&mana), FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x4D, Some(&mana), FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Not enough mana"
         );
     }
@@ -453,11 +555,15 @@ mod tests {
         assert_eq!(cast_fail_text(0x17, None, FailArgs::default(), &g), None);
         assert_eq!(cast_fail_text(0x08, None, FailArgs::default(), &g), None);
         assert_eq!(
-            cast_fail_text(0x92, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x92, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Spell failed (0x92)"
         );
         assert_eq!(
-            cast_fail_text(0x5C, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x5C, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Missing reagent"
         );
     }
@@ -479,31 +585,43 @@ mod tests {
         let g = |key: &str| s.lua().globals().get::<String>(key).ok();
 
         assert_eq!(
-            cast_fail_text(0x43, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x43, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Out of ammo"
         );
         assert_eq!(
-            cast_fail_text(0x59, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x59, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Out of range."
         );
         assert_eq!(
-            cast_fail_text(0x3C, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x3C, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Spell is not ready yet."
         );
         let rage = spell(1, 0, 0);
         assert_eq!(
-            cast_fail_text(0x4D, Some(&rage), FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x4D, Some(&rage), FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Not enough rage"
         );
         // The environment gate's pair (decision 1056) — both are plain passthroughs, so what the
         // player reads IS the GlobalStrings value. A typo'd key here would degrade a real refusal
         // to a dead-looking button, which is what this test exists to catch.
         assert_eq!(
-            cast_fail_text(0x50, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x50, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Cannot use while swimming"
         );
         assert_eq!(
-            cast_fail_text(0x58, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x58, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "Can only use while swimming"
         );
         // The data-suppression face on the real file: the absent keys show nothing.
@@ -524,26 +642,28 @@ mod tests {
         // 0x5e REQUIRES_SPELL_FOCUS: the Crown of the Earth phials' own refusal. Focus 12 is the
         // Starbreeze Village moonwell — using the Jade Phial at any *other* pool is the report.
         assert_eq!(
-            cast_fail_text(0x5E, None, args(12), &g).unwrap(),
+            cast_fail_text(0x5E, None, args(12), &g).unwrap().text,
             "Requires Starbreeze Village Moonwell"
         );
         assert_eq!(
-            cast_fail_text(0x5E, None, args(1), &g).unwrap(),
+            cast_fail_text(0x5E, None, args(1), &g).unwrap().text,
             "Requires Anvil"
         );
         // 0x5d REQUIRES_AREA: area 1657 is Darnassus.
         assert_eq!(
-            cast_fail_text(0x5D, None, args(1657), &g).unwrap(),
+            cast_fail_text(0x5D, None, args(1657), &g).unwrap().text,
             "You need to be in Darnassus"
         );
         // The fallbacks. An id the DBC doesn't name, and a wire word the server never sent, both
         // decline the arm and fall through to the strip — never a raw `%s` on screen.
         assert_eq!(
-            cast_fail_text(0x5E, None, args(999_999), &g).unwrap(),
+            cast_fail_text(0x5E, None, args(999_999), &g).unwrap().text,
             "Requires"
         );
         assert_eq!(
-            cast_fail_text(0x5D, None, FailArgs::default(), &g).unwrap(),
+            cast_fail_text(0x5D, None, FailArgs::default(), &g)
+                .unwrap()
+                .text,
             "You need to be in"
         );
         // 0x5e alone has a client-side stand-in: the failing spell's own `RequiresSpellFocus`
@@ -563,7 +683,8 @@ mod tests {
                 },
                 &g
             )
-            .unwrap(),
+            .unwrap()
+            .text,
             "Requires Shadowglen Moonwell"
         );
     }
diff --git a/crates/benilla-app/src/ui_action/cast_send.rs b/crates/benilla-app/src/ui_action/cast_send.rs
index 33ee13d0..25eedf7a 100644
--- a/crates/benilla-app/src/ui_action/cast_send.rs
+++ b/crates/benilla-app/src/ui_action/cast_send.rs
@@ -764,6 +764,7 @@ mod tests {
         // The sheath request the commit tail writes for a ranged spell — a bare World has no
         // message storage until it is asked for.
         world.init_resource::<Messages<crate::creature_anim::SheathRequest>>();
+        world.init_resource::<Messages<crate::player::StandStateRequest>>();
         (world, rx)
     }
 
diff --git a/crates/benilla-app/src/ui_action/errors.rs b/crates/benilla-app/src/ui_action/errors.rs
index 322a060e..afb98708 100644
--- a/crates/benilla-app/src/ui_action/errors.rs
+++ b/crates/benilla-app/src/ui_action/errors.rs
@@ -15,9 +15,10 @@
 //!   `SMSG_NOTIFICATION` / `SMSG_AREA_TRIGGER_MESSAGE` text, the death durability notice), so
 //!   there is no key to look up — only the arm to pick.
 //!
-//! All four drain in `super::feed_actions`, firing `UI_ERROR_MESSAGE` (or, for the info arm,
-//! `UI_INFO_MESSAGE`) per resolved line;
-//! every string comes from the VM's own loaded `GlobalStrings.lua`, never hardcoded, so an
+//! All four drain in `super::feed_actions` into the one sink [`show_messages`], which puts each
+//! resolved line on the surface its message record names — read from the catalog
+//! ([`benilla_ui::messages`], decision 1770) rather than carried to the call site by hand.
+//! Every string comes from the VM's own loaded `GlobalStrings.lua`, never hardcoded, so an
 //! absent key shows nothing (the reference's data-suppression face) and localization rides
 //! for free.
 
@@ -74,24 +75,15 @@ impl CastErrors {
 #[derive(Resource, Default)]
 pub(crate) struct MountErrors(pub Vec<(bool, u32)>);
 
-/// Where a client message is SHOWN — the `kind` field (`+0x04`) of the reference's message record
-/// (`0xb4b498 + 20*msgId`), which `CGGameUI::DisplayError` (`0x496720`) dispatches on through the
-/// four-way jump at `0x496888`: **0 → the chat window** (`0x49a870`), 1 → `AddErrorMessage(text, 0)`
-/// (the yellow info line), **2 → `AddErrorMessage(text, 1)`** (the red error line), 3 → the console.
-/// Only the two our messages use are modeled (decision 0669); the info line has its own established
-/// route (`UI_INFO_MESSAGE`, decision 0340) and rides [`UiError::info`] instead.
+/// Where a client message is SHOWN is **not a decision this crate makes** — it is the `kind` field
+/// (`+0x04`) of the reference's message record, and it now arrives from the catalog
+/// ([`benilla_ui::messages`], decision 1770) instead of being hand-carried to every call site
+/// beside the key. [`MsgKind`] is that field; [`UiError::kind`] is the whole lookup.
 ///
-/// This lives beside [`UiError`] rather than in any one window because the surface is a property of
-/// the MESSAGE, not of the window that raised it — and it has more than one tenant: the quest
-/// refusals (0669) and, since 1523, the auction house, where the twenty `ERR_AUCTION_*` ids split
-/// clean down the middle of this enum.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum MsgSurface {
-    /// kind 0 — a chat-window system line.
-    Chat,
-    /// kind 2 — the red `UIErrorsFrame` line.
-    Error,
-}
+/// It reads as a property of the MESSAGE rather than of the window that raised it because that is
+/// exactly what it is: the quest refusals (0669), the auction house (1523) and the party
+/// quest-share (1733) all ask the same table the same question.
+pub(crate) use benilla_ui::messages::MsgKind;
 
 /// One `DisplayError` message: a GlobalStrings key plus the argText fills. The 1.12 error
 /// formats use at most one `%s` and one `%d` ("Requires %s", "Requires %s %d" — wow-re
@@ -104,13 +96,6 @@ pub(crate) struct UiError {
     pub key: &'static str,
     pub fill_s: Option<String>,
     pub fill_d: Option<u32>,
-    /// The message record's **type arm** (wow-re `fish-msg-handlers.md`, byte-proven — the
-    /// registry entry's `+4` type, last written `mov edx,1` at `0x486235`): the reference's
-    /// `DisplayError` pipeline is one, and the type selects the UIErrorsFrame event — type 1
-    /// fires the **yellow** `UI_INFO_MESSAGE` (0xe1), type 2 the **red** `UI_ERROR_MESSAGE`
-    /// (0xe0). `true` = the yellow info arm (the fishing verdicts are the first tenants);
-    /// `false` = the red error arm, the default.
-    pub info: bool,
 }
 
 impl UiError {
@@ -121,16 +106,13 @@ impl UiError {
             key,
             fill_s: None,
             fill_d: None,
-            info: false,
         }
     }
 
-    /// A fill-less **type-1** message — the yellow `UI_INFO_MESSAGE` arm (see [`UiError::info`]).
-    pub(crate) fn info_key(key: &'static str) -> Self {
-        Self {
-            info: true,
-            ..Self::key(key)
-        }
+    /// Where this message is shown, straight off the catalog row its key names — the reference's
+    /// `DisplayError` reading `[record+0x04]`, which is the only place that answer has ever lived.
+    pub(crate) fn kind(&self) -> MsgKind {
+        benilla_ui::messages::kind_of(self.key)
     }
 }
 
@@ -142,27 +124,30 @@ impl UiError {
 pub(crate) struct UiErrorKeys(pub Vec<UiError>);
 
 /// [`UiErrorKeys`]' twin for lines that arrive **already resolved** — text with no GlobalStrings
-/// key to look up, because the server (or a fixed literal) already wrote it. Same frame, same two
-/// events, same drain.
+/// key to look up, because the server (or a fixed literal) already wrote it. Same frame, same
+/// sink, same drain.
 ///
-/// The wire tenants are the reference's own: `SMSG_NOTIFICATION` (`0x1cb`, handler `0x401800` —
+/// This is the one route that does **not** consult the catalog, and faithfully so: its tenants do
+/// not go through `DisplayError` at all, so there is no record and no id to read a kind from. The
+/// wire tenants are the reference's own: `SMSG_NOTIFICATION` (`0x1cb`, handler `0x401800` —
 /// `mov edx,1; call 0x4945b0` → `UI_ERROR_MESSAGE`) and `SMSG_AREA_TRIGGER_MESSAGE` (`0x2b8`, the
 /// shared handler `0x48f690`'s arm at `0x48f8ff` — `xor edx,edx; call 0x4945b0` →
 /// `UI_INFO_MESSAGE`). `0x4945b0(text, flag)` is the whole sink: null/empty guard, then
 /// `neg edx; sbb edx,edx; add edx,0xe1` = event `0xe1` when the flag is 0 and `0xe0` when it is 1
-/// (wow-re `system/ui/ui.md` l.2459). So the flag IS [`UiError::info`] under another name.
+/// (wow-re `system/ui/ui.md` l.2459). The handler's own choice of flag is what the [`MsgKind`]
+/// here carries — the same two surfaces the catalog names, reached by a different road.
 #[derive(Resource, Default)]
-pub(crate) struct UiErrorTexts(pub Vec<(String, bool)>);
+pub(crate) struct UiErrorTexts(pub Vec<(String, MsgKind)>);
 
 impl UiErrorTexts {
     /// The red `UI_ERROR_MESSAGE` arm (`0x4945b0(text, 1)`).
     pub(crate) fn error(&mut self, text: String) {
-        self.0.push((text, false));
+        self.0.push((text, MsgKind::Error));
     }
 
     /// The yellow `UI_INFO_MESSAGE` arm (`0x4945b0(text, 0)`).
     pub(crate) fn info(&mut self, text: String) {
-        self.0.push((text, true));
+        self.0.push((text, MsgKind::Info));
     }
 }
 
@@ -181,28 +166,37 @@ pub(crate) fn ui_error_text(e: &UiError, get: &dyn Fn(&str) -> Option<String>) -
     (!text.is_empty()).then_some(text)
 }
 
-/// Show already-resolved [`UiError`] lines on the surface each message record names — the second
-/// half of every [`MsgSurface`] tenant's drain, factored out once it had three (the questgiver
-/// refusals 0669, the auction house 1523, the party quest-share 1733). The tenants differ only in
-/// how they *build* their lines (a window's queue, a deferred item template, a guid awaiting a
-/// name); what they do with a resolved one is this, identically, down to the debug line — which
-/// exists because the chat path keeps no log of its own, so without it a live probe can count
-/// lines but never read one (0669's in-app leg).
+/// **The one sink** for a resolved message line: put it on the surface its [`MsgKind`] names.
 ///
-/// `who` is the caller's module tag for that debug line.
+/// Every route into the client's message display ends here — the window queues that resolve a
+/// [`UiError`] (the questgiver refusals 0669, the auction house 1523, the party quest-share 1733),
+/// the client-local [`UiErrorKeys`], and the already-resolved [`UiErrorTexts`] off the wire. They
+/// differ only in how they *build* a line and where the kind comes from; what happens to a built
+/// one is this, once, so the three cannot drift apart.
+///
+/// `who` is the caller's module tag for the debug line — which exists because the chat path keeps
+/// no log of its own, so without it a live probe can count lines but never read one (0669's
+/// in-app leg).
+///
+/// [`MsgKind::Chat`] lines go out as `CHAT_MSG_SYSTEM`. Three catalog rows ask for
+/// `CHAT_MSG_SKILL` instead (the skill-up trio, [`benilla_ui::messages::MessageRecord::chat_type`])
+/// and benilla raises none of them yet; when it does, this is the line that has to read the field.
 pub(crate) fn show_messages(
     script: &mut UiScript,
     chat: &mut ChatLog,
     who: &str,
-    lines: impl IntoIterator<Item = (MsgSurface, String)>,
+    lines: impl IntoIterator<Item = (MsgKind, String)>,
 ) {
-    for (surface, text) in lines {
-        debug!("{who}: message ({surface:?}) {text:?}");
-        match surface {
-            MsgSurface::Chat => {
+    for (kind, text) in lines {
+        debug!("{who}: message ({kind:?}) {text:?}");
+        match kind {
+            MsgKind::Chat => {
                 chat.push_event(ChatEvent::text_only(ChatEventKind::System, text));
             }
-            MsgSurface::Error => {
+            MsgKind::Info => {
+                script.fire_event("UI_INFO_MESSAGE", vec![ScriptValue::Str(text)]);
+            }
+            MsgKind::Error => {
                 script.fire_event("UI_ERROR_MESSAGE", vec![ScriptValue::Str(text)]);
             }
         }
@@ -428,7 +422,6 @@ mod ui_error_tests {
             key,
             fill_s: s.map(String::from),
             fill_d: d,
-            info: false,
         }
     }
 
diff --git a/crates/benilla-app/src/ui_action/feed.rs b/crates/benilla-app/src/ui_action/feed.rs
index 8337a33c..592cfb75 100644
--- a/crates/benilla-app/src/ui_action/feed.rs
+++ b/crates/benilla-app/src/ui_action/feed.rs
@@ -39,8 +39,8 @@ use crate::net::{NetCommands, ObjectStore, SelfPlayer};
 use super::errors::{first_missing_totem, first_short_reagent, mount_result_key};
 use super::weapon_icon::{auto_attack_icon, substitutes_weapon_icon};
 use super::{
-    cast_fail, ui_error_text, CastErrors, MountErrors, PlayerActions, Spells, UiError, UiErrorKeys,
-    UiErrorTexts,
+    cast_fail, show_messages, ui_error_text, CastErrors, MountErrors, MsgKind, PlayerActions,
+    Spells, UiError, UiErrorKeys, UiErrorTexts,
 };
 
 /// What an ITEM action shows when its icon cannot be resolved — the reference's own hardcoded
@@ -127,7 +127,7 @@ pub(super) fn feed_actions(
         focus: spell_focus.as_deref().map(|f| &f.catalog),
         areas: areas.as_deref().map(|a| &a.0),
     };
-    let texts: Vec<String> = cast_errors
+    let texts: Vec<cast_fail::CastFailLine> = cast_errors
         .0
         .drain(..)
         .filter_map(|fail| {
@@ -156,7 +156,7 @@ pub(super) fn feed_actions(
                     let key = cast_fail::CAST_FAIL_KEYS[reason as usize];
                     return get(key)
                         .filter(|s| !s.is_empty())
-                        .map(|t| t.replace("%s", &name));
+                        .map(|t| cast_fail::CastFailLine::passthrough(t.replace("%s", &name)));
                 }
             }
             if reason == 0x78 || reason == 0x5c {
@@ -191,7 +191,7 @@ pub(super) fn feed_actions(
                 };
                 return get(key)
                     .filter(|s| !s.is_empty())
-                    .map(|t| t.replace("%s", &name));
+                    .map(|t| cast_fail::CastFailLine::passthrough(t.replace("%s", &name)));
             }
             // The combat-log twin. **Only the `…SELF` half is reachable here**: `SMSG_CAST_FAILED`
             // is addressed to the caster alone, so benilla never learns that somebody *else's*
@@ -257,56 +257,56 @@ pub(super) fn feed_actions(
     for line in fail_lines {
         chat_log.push_combat(line);
     }
-    for text in texts {
-        script.fire_event("UI_ERROR_MESSAGE", vec![ScriptValue::Str(text)]);
-    }
+    show_messages(
+        &mut script,
+        &mut chat_log,
+        "ui_action",
+        texts
+            .into_iter()
+            .map(|l| (benilla_ui::messages::kind_of(l.key), l.text)),
+    );
 
-    // (Dis)mount refusals ride the same red line, keyed straight into GlobalStrings
+    // (Dis)mount refusals ride the same route, keyed straight into GlobalStrings
     // ([`mount_result_key`] — no format arguments in any of these strings).
-    let mount_texts: Vec<String> = mount_errors
+    let mount_texts: Vec<(&'static str, String)> = mount_errors
         .0
         .drain(..)
         .filter_map(|(mount, code)| {
             let key = mount_result_key(mount, code)?;
-            script.lua().globals().get::<String>(key).ok()
+            Some((key, script.lua().globals().get::<String>(key).ok()?))
         })
         .collect();
-    for text in mount_texts {
-        script.fire_event("UI_ERROR_MESSAGE", vec![ScriptValue::Str(text)]);
-    }
+    show_messages(
+        &mut script,
+        &mut chat_log,
+        "ui_action",
+        mount_texts
+            .into_iter()
+            .map(|(key, text)| (benilla_ui::messages::kind_of(key), text)),
+    );
 
     // Client-local by-key refusals (the `DisplayError` route — [`UiErrorKeys`]); the key IS the
-    // GlobalStrings lookup, no code table between. The entry's type arm picks the line: type 1
-    // (`UiError::info`) is the yellow `UI_INFO_MESSAGE`, type 2 the red `UI_ERROR_MESSAGE` —
-    // the reference's one pipeline forking on the registry type (wow-re `fish-msg-handlers.md`;
-    // the fishing verdicts are the yellow tenants).
-    let key_texts: Vec<(String, bool)> = ui_error_keys
+    // GlobalStrings lookup, no code table between, and the key is also what names the surface:
+    // [`UiError::kind`] reads the message record straight out of the catalog instead of the queue
+    // carrying a hand-set flag alongside every push (decision 1770).
+    let key_lines: Vec<(MsgKind, String)> = ui_error_keys
         .0
         .drain(..)
         .filter_map(|e| {
             ui_error_text(&e, &|key| script.lua().globals().get::<String>(key).ok())
-                .map(|t| (t, e.info))
+                .map(|t| (e.kind(), t))
         })
         .collect();
-    for (text, info) in key_texts {
-        let event = if info {
-            "UI_INFO_MESSAGE"
-        } else {
-            "UI_ERROR_MESSAGE"
-        };
-        script.fire_event(event, vec![ScriptValue::Str(text)]);
-    }
+    show_messages(&mut script, &mut chat_log, "ui_action", key_lines);
 
-    // Already-resolved lines ([`UiErrorTexts`]) — the wire's own text, no key to look up. Same
-    // frame, same two events; the queued bool IS the reference's `0x4945b0` flag.
-    for (text, info) in ui_error_texts.0.drain(..) {
-        let event = if info {
-            "UI_INFO_MESSAGE"
-        } else {
-            "UI_ERROR_MESSAGE"
-        };
-        script.fire_event(event, vec![ScriptValue::Str(text)]);
-    }
+    // Already-resolved lines ([`UiErrorTexts`]) — the wire's own text, no key to look up and no
+    // record behind it; the queued kind IS the reference's `0x4945b0` flag.
+    let resolved: Vec<(MsgKind, String)> = ui_error_texts
+        .0
+        .drain(..)
+        .map(|(text, kind)| (kind, text))
+        .collect();
+    show_messages(&mut script, &mut chat_log, "ui_action", resolved);
 
     // The ENGINE's own by-key refusals ride the very same line. `benilla_ui` is engine-free and
     // cannot reach [`UiErrorKeys`], so a refusal raised inside the script crate (today: dropping a
@@ -315,17 +315,15 @@ pub(super) fn feed_actions(
     // frame late by construction (the refusal happens during the input pass this feed precedes),
     // which is invisible on a toast.
     let engine_keys = script.take_ui_errors();
-    let engine_texts: Vec<String> = engine_keys
+    let engine_lines: Vec<(MsgKind, String)> = engine_keys
         .into_iter()
         .filter_map(|key| {
-            ui_error_text(&UiError::key(key), &|k| {
-                script.lua().globals().get::<String>(k).ok()
-            })
+            let e = UiError::key(key);
+            ui_error_text(&e, &|k| script.lua().globals().get::<String>(k).ok())
+                .map(|t| (e.kind(), t))
         })
         .collect();
-    for text in engine_texts {
-        script.fire_event("UI_ERROR_MESSAGE", vec![ScriptValue::Str(text)]);
-    }
+    show_messages(&mut script, &mut chat_log, "ui_action", engine_lines);
 
     let store = self_q.iter().next();
 
diff --git a/crates/benilla-app/src/ui_action/mod.rs b/crates/benilla-app/src/ui_action/mod.rs
index 8440f5f3..f1000202 100644
--- a/crates/benilla-app/src/ui_action/mod.rs
+++ b/crates/benilla-app/src/ui_action/mod.rs
@@ -67,7 +67,7 @@ pub(crate) use cast_send::{CastCommit, CastLadder};
 pub(crate) use cast_target::AutoSelfCast;
 pub(crate) use errors::{
     attack_actor_refusal, reagent_totem_refusal, show_messages, ui_error_text, CastErrors,
-    CastFail, MountErrors, MsgSurface, UiError, UiErrorKeys, UiErrorTexts,
+    CastFail, MountErrors, MsgKind, UiError, UiErrorKeys, UiErrorTexts,
 };
 // `pub(crate)`: the target chain registers the cursor pre-empt + the click commit, and the
 // spellbook/stance/craft drains thread the mode through the one cast-send path (decision 0792).
diff --git a/crates/benilla-app/src/ui_auction/mod.rs b/crates/benilla-app/src/ui_auction/mod.rs
index 080f0c0c..c27d72c6 100644
--- a/crates/benilla-app/src/ui_auction/mod.rs
+++ b/crates/benilla-app/src/ui_auction/mod.rs
@@ -48,7 +48,7 @@ use crate::entities::ItemDisplays;
 use crate::items::Items;
 use crate::names::NameCache;
 use crate::net::{ClientCommand, NetCommands, ObjectStore, SelfPlayer};
-use crate::ui_action::{show_messages, ui_error_text, MsgSurface, UiError};
+use crate::ui_action::{show_messages, ui_error_text, UiError};
 use crate::ui_script::UiInput;
 use crate::ui_session::{close_npc_session_out_of_range, NpcSession};
 
@@ -255,7 +255,6 @@ pub(crate) struct AuctionOpen {
 /// That split is the whole reason this is a queue of records rather than a queue of red strings.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct AuctionMessage {
-    pub(crate) surface: MsgSurface,
     pub(crate) key: &'static str,
     /// The item entry whose name fills the `%s`; `None` for the six fill-less lines.
     ///
@@ -267,31 +266,22 @@ pub(crate) struct AuctionMessage {
 }
 
 impl AuctionMessage {
-    /// A chat line with no fill (`ERR_AUCTION_STARTED` and friends).
+    /// A line with no fill (`ERR_AUCTION_STARTED` and friends).
     pub(crate) fn chat(key: &'static str) -> Self {
-        Self {
-            surface: MsgSurface::Chat,
-            key,
-            item: None,
-        }
+        Self { key, item: None }
     }
 
-    /// A chat line about one item — the five `_S` outcomes.
+    /// A line about one item — the five `_S` outcomes.
     pub(crate) fn chat_item(key: &'static str, item: u32) -> Self {
         Self {
-            surface: MsgSurface::Chat,
             key,
             item: Some(item),
         }
     }
 
-    /// A red line — the twelve refusals, none of which take a fill.
+    /// A refusal — the twelve precondition failures, none of which take a fill.
     pub(crate) fn error(key: &'static str) -> Self {
-        Self {
-            surface: MsgSurface::Error,
-            key,
-            item: None,
-        }
+        Self { key, item: None }
     }
 }
 
@@ -622,10 +612,9 @@ fn feed_auction(
                 key: msg.key,
                 fill_s: fill,
                 fill_d: None,
-                info: false,
             };
             if let Some(text) = ui_error_text(&err, &get) {
-                lines.push((msg.surface, text));
+                lines.push((benilla_ui::messages::kind_of(msg.key), text));
             }
         }
         auction.messages = deferred;
diff --git a/crates/benilla-app/src/ui_chat/broadcast.rs b/crates/benilla-app/src/ui_chat/broadcast.rs
index a35bc850..1d42aeee 100644
--- a/crates/benilla-app/src/ui_chat/broadcast.rs
+++ b/crates/benilla-app/src/ui_chat/broadcast.rs
@@ -62,7 +62,7 @@
 //! Its arm reads nothing off the wire — `0x5e4a09` is `push 0x1c3; call 0x496720`, three
 //! instructions — so the whole packet is "show message 451". benilla already models
 //! `CGGameUI::DisplayError 0x496720` and its message registry
-//! ([`crate::ui_action::MsgSurface`]); what this packet needed was the two facts that registry
+//! ([`crate::ui_action::MsgKind`]); what this packet needed was the two facts that registry
 //! entry carries, and both are VERIFIED here:
 //!
 //! - **451 is `ERR_CHAT_RESTRICTED`.** The string `"ERR_CHAT_RESTRICTED"` (`0x83f6d4`) has exactly
@@ -239,6 +239,14 @@ pub(super) fn feed_broadcasts(
                 push_channel_lines(&mut log, &channels, zone, player_zone, &text);
             }
             Broadcast::ChatRestricted => {
+                // The system line is written out here rather than routed through
+                // `ui_action::show_messages`, and that is not an oversight: of this feed's four
+                // arms only this one is a `DisplayError` tenant at all — the two defence
+                // broadcasts are engine-composed CHANNEL lines and `SMSG_SERVER_MESSAGE` composes
+                // from `ServerMessages.dbc`, so three of the four have no message record to read a
+                // surface from. The claim that this one's record says "chat" is checked instead,
+                // in `chat_restricted_is_a_chat_row` below.
+                //
                 // An absent key shows nothing — this crate's uniform GlobalStrings stance, and a
                 // deliberate half-step short of the reference: `0x496720` suppresses on the message
                 // record's own key field being NULL or empty (`0x4967c5`), but `FrameScript_GetText`
@@ -289,6 +297,16 @@ fn push_channel_lines(
 
 #[cfg(test)]
 mod tests {
+    /// `ERR_CHAT_RESTRICTED` (id 451) carries kind 0, so the arm above is right to write a chat
+    /// system line and not a red toast — the one hand-set surface left in this feed, checked
+    /// rather than trusted (decision 1770).
+    #[test]
+    fn chat_restricted_is_a_chat_row() {
+        use benilla_ui::messages::{by_key, kind_of, MsgKind};
+        assert_eq!(by_key("ERR_CHAT_RESTRICTED").expect("a real row").id, 451);
+        assert_eq!(kind_of("ERR_CHAT_RESTRICTED"), MsgKind::Chat);
+    }
+
     use super::*;
     use benilla_formats::{ChatChannelRow, ChatChannelsCatalog};
 
diff --git a/crates/benilla-app/src/ui_chat/feed.rs b/crates/benilla-app/src/ui_chat/feed.rs
index 1ff9c91a..a6931e60 100644
--- a/crates/benilla-app/src/ui_chat/feed.rs
+++ b/crates/benilla-app/src/ui_chat/feed.rs
@@ -425,6 +425,21 @@ impl ChatLog {
             .collect()
     }
 
+    /// The text of every parked line headed for a chat window, in order — test-only, the
+    /// text-shaped twin of [`Self::pending_len`]. A count proves a line was queued; only the text
+    /// proves it is the *right* line, which is the whole question for a composed one (decision
+    /// 1764's `ERR_TRADE_BLOCKED_S`, whose `%s` has to name the right player).
+    #[cfg(test)]
+    pub(crate) fn pending_texts(&self) -> Vec<String> {
+        self.pending
+            .iter()
+            .filter_map(|p| match p {
+                Pending::Event(e) => Some(e.text.clone()),
+                _ => None,
+            })
+            .collect()
+    }
+
     /// How many parked items are headed for a CHAT WINDOW.
     ///
     /// Addon lines are excluded on purpose. They park in the same queue for the same ask-once name
diff --git a/crates/benilla-app/src/ui_petition/feed.rs b/crates/benilla-app/src/ui_petition/feed.rs
index bfcea9f3..af718589 100644
--- a/crates/benilla-app/src/ui_petition/feed.rs
+++ b/crates/benilla-app/src/ui_petition/feed.rs
@@ -29,7 +29,7 @@
 //! composed at apply time and fired here.
 
 use benilla_ui::script::{
-    PetitionRecordView, PetitionRequest, PetitionState as VmPetition, ScriptValue, UiScript,
+    PetitionRecordView, PetitionRequest, PetitionState as VmPetition, UiScript,
     PETITION_TYPE_CHARTER, PETITION_TYPE_PETITION,
 };
 use bevy::prelude::*;
@@ -37,7 +37,7 @@ use bevy::prelude::*;
 use crate::items::Items;
 use crate::names::NameCache;
 use crate::net::{ClientCommand, NetCommands, ObjectStore, SelfGuid, SelfPlayer};
-use crate::ui_chat::{ChatEvent, ChatEventKind, ChatLog};
+use crate::ui_chat::ChatLog;
 use crate::ui_items::{find_item, ItemSearch};
 use crate::ui_session::{npc_switched, NpcSession};
 
@@ -76,18 +76,10 @@ pub(super) fn feed_petition(
     };
     let fed = fed.get(&script);
 
-    // The composed lines, onto their two channels. Drained before the snapshot so a refusal shows
-    // in the same frame as the state change that caused it.
-    for line in std::mem::take(&mut petition.lines) {
-        match line {
-            lines::Line::Chat(text) => {
-                chat_log.push_event(ChatEvent::text_only(ChatEventKind::System, text));
-            }
-            lines::Line::Error(text) => {
-                script.fire_event("UI_ERROR_MESSAGE", vec![ScriptValue::Str(text)]);
-            }
-        }
-    }
+    // The composed lines, each onto the surface its message record names. Drained before the
+    // snapshot so a refusal shows in the same frame as the state change that caused it.
+    let composed = std::mem::take(&mut petition.lines);
+    crate::ui_action::show_messages(&mut script, &mut chat_log, "ui_petition", composed);
 
     // **Rebuilt every frame, deliberately.** Half of what this window shows arrives from a CACHE,
     // not a packet, and reading that cache is what ISSUES its query (decision 0660's law). So a
diff --git a/crates/benilla-app/src/ui_petition/lines.rs b/crates/benilla-app/src/ui_petition/lines.rs
index a9b3a4ff..fa525cc2 100644
--- a/crates/benilla-app/src/ui_petition/lines.rs
+++ b/crates/benilla-app/src/ui_petition/lines.rs
@@ -14,6 +14,10 @@
 //! - the **five** refusals `0x145`-`0x149`, and `ERR_NO_GUILD_CHARTER` (`0x7c`), carry kind `2` →
 //!   `UI_ERROR_MESSAGE` (`0xe0`), the **red UIErrorsFrame line**.
 //!
+//! That sweep is no longer this module's to carry: since decision 1770 the whole registry ships as
+//! [`benilla_ui::messages`], and each line below asks it by key. The paragraphs above stay because
+//! they record *why* the split is not guessable — the reason a lookup was worth building.
+//!
 //! Two more facts from the same sweep that shape the tables below:
 //!
 //! - **`PETITION_SIGN_NEED_MORE` (4) has no user-visible message on the SIGN path at all.** It
@@ -32,45 +36,93 @@
 
 use benilla_protocol::messages::petition_result;
 
+use crate::ui_action::MsgKind;
+
+/// One message this module composes: the **catalog key**, which names both the row and — through
+/// [`benilla_ui::messages`] — the surface it goes to, and the 1.12 text.
+///
+/// The key rides beside the text rather than the surface doing so, because the surface is not this
+/// module's to know: it is the message record's `+0x04`, and reading it here from the catalog is
+/// what retired the hand-swept table this file used to carry (decision 1770). The five
+/// `ERR_GUILD_NAME_*` rows below were recorded as **INFERRED** for exactly that reason; the sweep
+/// confirms all five are kind 2, so the inference is now a lookup.
+#[derive(Debug, Clone, Copy)]
+struct Msg {
+    key: &'static str,
+    text: &'static str,
+}
+
+const fn msg(key: &'static str, text: &'static str) -> Msg {
+    Msg { key, text }
+}
+
 // ── The templates, quoted verbatim from the reference's own patch chain; the `GlobalStrings.lua`
 //    line is on each ──────────────────────────────────────────────────────────────────────────
-const ERR_PETITION_ALREADY_SIGNED: &str = "You have already signed that guild charter."; // :1762
-const ERR_PETITION_CREATOR: &str = "You can't sign your own guild charter."; // :1763
-const ERR_PETITION_DECLINED_S: &str = "%s has declined your guild invitation."; // :1764
-const ERR_PETITION_IN_GUILD: &str = "You are already in a guild."; // :1765
-const ERR_PETITION_NOT_ENOUGH_SIGNATURES: &str = "You need more signatures."; // :1766
-const ERR_PETITION_NOT_SAME_SERVER: &str = "That player is not from your server"; // :1767
-const ERR_PETITION_OFFERED_S: &str = "You have requested %s's signature."; // :1768
-const ERR_PETITION_SIGNED: &str = "Guild charter signed."; // :1769
-const ERR_PETITION_SIGNED_S: &str = "%s has signed your guild charter."; // :1770
-const ERR_NO_GUILD_CHARTER: &str = "You don't have a guild charter."; // :1745
+const ERR_PETITION_ALREADY_SIGNED: Msg = msg(
+    "ERR_PETITION_ALREADY_SIGNED",
+    "You have already signed that guild charter.",
+); // :1762
+const ERR_PETITION_CREATOR: Msg = msg(
+    "ERR_PETITION_CREATOR",
+    "You can't sign your own guild charter.",
+); // :1763
+const ERR_PETITION_DECLINED_S: Msg = msg(
+    "ERR_PETITION_DECLINED_S",
+    "%s has declined your guild invitation.",
+); // :1764
+const ERR_PETITION_IN_GUILD: Msg = msg("ERR_PETITION_IN_GUILD", "You are already in a guild."); // :1765
+const ERR_PETITION_NOT_ENOUGH_SIGNATURES: Msg = msg(
+    "ERR_PETITION_NOT_ENOUGH_SIGNATURES",
+    "You need more signatures.",
+); // :1766
+const ERR_PETITION_NOT_SAME_SERVER: Msg = msg(
+    "ERR_PETITION_NOT_SAME_SERVER",
+    "That player is not from your server",
+); // :1767
+const ERR_PETITION_OFFERED_S: Msg = msg(
+    "ERR_PETITION_OFFERED_S",
+    "You have requested %s's signature.",
+); // :1768
+const ERR_PETITION_SIGNED: Msg = msg("ERR_PETITION_SIGNED", "Guild charter signed."); // :1769
+const ERR_PETITION_SIGNED_S: Msg =
+    msg("ERR_PETITION_SIGNED_S", "%s has signed your guild charter."); // :1770
+const ERR_NO_GUILD_CHARTER: Msg = msg("ERR_NO_GUILD_CHARTER", "You don't have a guild charter."); // :1745
 
 // The guild-name validator's messages (`0x4f5160`'s seven arms). Only the three
 // `benilla_ui::script::validate_guild_name` implements can be produced; the rest are here so the
 // key→text map is complete and a later carve of `0x6c9b70` only has to add the branch.
-const ERR_GUILD_ENTER_NAME: &str = "Enter a name for your guild."; // :1603
-const ERR_GUILD_NAME_INVALID: &str = "That name contains invalid characters,  Enter a new name."; // :1616
-const ERR_GUILD_NAME_INVALID_SPACE: &str =
-    "Guild names cannot start or end with a space.  Enter a new name."; // :1617
-const ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES: &str =
-    "Consecutive spaces are not allowed.  Enter a new name."; // :1619
-const ERR_GUILD_NAME_TOO_SHORT: &str = "That name is too short.  Enter a new name."; // :1622
+const ERR_GUILD_ENTER_NAME: Msg = msg("ERR_GUILD_ENTER_NAME", "Enter a name for your guild."); // :1603
+const ERR_GUILD_NAME_INVALID: Msg = msg(
+    "ERR_GUILD_NAME_INVALID",
+    "That name contains invalid characters,  Enter a new name.",
+); // :1616
+const ERR_GUILD_NAME_INVALID_SPACE: Msg = msg(
+    "ERR_GUILD_NAME_INVALID_SPACE",
+    "Guild names cannot start or end with a space.  Enter a new name.",
+); // :1617
+const ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES: Msg = msg(
+    "ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES",
+    "Consecutive spaces are not allowed.  Enter a new name.",
+); // :1619
+const ERR_GUILD_NAME_TOO_SHORT: Msg = msg(
+    "ERR_GUILD_NAME_TOO_SHORT",
+    "That name is too short.  Enter a new name.",
+); // :1622
 
-/// Which of the client's two channels a line goes to — the `+4 kind` field, as a type.
-///
-/// Modelled rather than left implicit because the split does not follow the key names, and a
-/// `String` return would let a future edit put a refusal in the chat log without anything noticing.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(super) enum Line {
-    /// Kind `0` → the `CHAT_MSG_SYSTEM` chat line.
-    Chat(String),
-    /// Kind `2` → the red `UI_ERROR_MESSAGE` frame.
-    Error(String),
+/// One composed line: the surface its message record names, and the text.
+pub(super) type Line = (MsgKind, String);
+
+/// A line with nothing to fill.
+fn line(m: Msg) -> Line {
+    (benilla_ui::messages::kind_of(m.key), m.text.to_string())
 }
 
-/// One `%s` substitution.
-fn fill(template: &str, arg: &str) -> String {
-    template.replacen("%s", arg, 1)
+/// A line with one `%s` substitution.
+fn fill(m: Msg, arg: &str) -> Line {
+    (
+        benilla_ui::messages::kind_of(m.key),
+        m.text.replacen("%s", arg, 1),
+    )
 }
 
 /// The line one `SMSG_PETITION_SIGN_RESULTS` prints **when the signer is us** — the switch at
@@ -82,11 +134,11 @@ fn fill(template: &str, arg: &str) -> String {
 /// `NEED_MORE` and anything `>= 6` return `None` — the default arm reaches only the debug console.
 pub(super) fn my_sign_line(result: u32) -> Option<Line> {
     Some(match result {
-        petition_result::OK => Line::Chat(ERR_PETITION_SIGNED.to_string()),
-        petition_result::ALREADY_SIGNED => Line::Error(ERR_PETITION_ALREADY_SIGNED.to_string()),
-        petition_result::ALREADY_IN_GUILD => Line::Error(ERR_PETITION_IN_GUILD.to_string()),
-        petition_result::CANT_SIGN_OWN => Line::Error(ERR_PETITION_CREATOR.to_string()),
-        petition_result::NOT_SERVER => Line::Error(ERR_PETITION_NOT_SAME_SERVER.to_string()),
+        petition_result::OK => line(ERR_PETITION_SIGNED),
+        petition_result::ALREADY_SIGNED => line(ERR_PETITION_ALREADY_SIGNED),
+        petition_result::ALREADY_IN_GUILD => line(ERR_PETITION_IN_GUILD),
+        petition_result::CANT_SIGN_OWN => line(ERR_PETITION_CREATOR),
+        petition_result::NOT_SERVER => line(ERR_PETITION_NOT_SAME_SERVER),
         // `NEED_MORE` (4) and >= 6: the default arm, debug console only.
         _ => return None,
     })
@@ -96,15 +148,15 @@ pub(super) fn my_sign_line(result: u32) -> Option<Line> {
 /// emitted **only when the signer's name is already cached** (`0x4f42f6`); on a cache miss the
 /// client increments its pending-name counter instead and says nothing until the name lands.
 pub(super) fn signed_by_other(name: &str) -> Line {
-    Line::Chat(fill(ERR_PETITION_SIGNED_S, name))
+    fill(ERR_PETITION_SIGNED_S, name)
 }
 
 /// The line one `SMSG_TURN_IN_PETITION_RESULTS` prints. **Success prints nothing** — see the module
 /// doc; it is not an omission here.
 pub(super) fn turn_in_line(result: u32) -> Option<Line> {
     Some(match result {
-        petition_result::ALREADY_IN_GUILD => Line::Error(ERR_PETITION_IN_GUILD.to_string()),
-        petition_result::NEED_MORE => Line::Error(ERR_PETITION_NOT_ENOUGH_SIGNATURES.to_string()),
+        petition_result::ALREADY_IN_GUILD => line(ERR_PETITION_IN_GUILD),
+        petition_result::NEED_MORE => line(ERR_PETITION_NOT_ENOUGH_SIGNATURES),
         _ => return None,
     })
 }
@@ -113,47 +165,45 @@ pub(super) fn turn_in_line(result: u32) -> Option<Line> {
 /// **only if the declining player's name is already cached**. There is no query and no retry: an
 /// uncached name means the owner is told nothing at all (`0x5ef12a`/`0x5ef139`).
 pub(super) fn declined_line(name: &str) -> Line {
-    Line::Chat(fill(ERR_PETITION_DECLINED_S, name))
+    fill(ERR_PETITION_DECLINED_S, name)
 }
 
 /// The local echo for a charter we just offered — emitted **optimistically on the send**, with no
 /// server confirmation (`0x4f48fa`). Nothing comes back on success; the *target* is the one the
 /// server answers.
 pub(super) fn offered_line(name: &str) -> Line {
-    Line::Chat(fill(ERR_PETITION_OFFERED_S, name))
+    fill(ERR_PETITION_OFFERED_S, name)
 }
 
 /// Offering a charter to yourself — guard 6 of `OfferPetition`'s eight (`0x4f4839`), which emits
 /// `ERR_PETITION_CREATOR`, the same red line signing your own charter gets.
 pub(super) fn self_offer_line() -> Line {
-    Line::Error(ERR_PETITION_CREATOR.to_string())
+    line(ERR_PETITION_CREATOR)
 }
 
 /// The local refusal when `TurnInGuildCharter()`'s bag scan finds no charter — a **red** line
 /// (`0x5ef49a` emits id `0x7c`, kind 2), and no packet is built.
 pub(super) fn no_charter_line() -> Line {
-    Line::Error(ERR_NO_GUILD_CHARTER.to_string())
+    line(ERR_NO_GUILD_CHARTER)
 }
 
 /// The line for a name the client's own validator refused
-/// ([`benilla_ui::script::validate_guild_name`]) — a red line, by the class every other
-/// `ERR_GUILD_NAME_*` row in the catalog belongs to.
+/// ([`benilla_ui::script::validate_guild_name`]) — a red line.
 ///
-/// **The kind of these five rows is INFERRED**, unlike the nine petition rows above: that round
-/// swept the petition ids and `0x7c`, not the `0x75`-`0x7b` band. They are refusals, and every
-/// refusal in the swept set is kind 2. An unknown key falls back to the generic invalid-name text
-/// rather than showing a raw key.
+/// **These five rows were recorded here as INFERRED** — the sweep that settled the nine petition
+/// ids and `0x7c` never covered the `0x75`-`0x7b` band, so the kind was reasoned from the fact
+/// that every refusal in the swept set is kind 2. The full catalog (decision 1770) confirms all
+/// five: the inference was right, and it is a lookup now rather than a reason.
+///
+/// An unknown key falls back to the generic invalid-name text rather than showing a raw key.
 pub(super) fn name_refused_line(key: &str) -> Line {
-    Line::Error(
-        match key {
-            "ERR_GUILD_ENTER_NAME" => ERR_GUILD_ENTER_NAME,
-            "ERR_GUILD_NAME_INVALID_SPACE" => ERR_GUILD_NAME_INVALID_SPACE,
-            "ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES" => ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES,
-            "ERR_GUILD_NAME_TOO_SHORT" => ERR_GUILD_NAME_TOO_SHORT,
-            _ => ERR_GUILD_NAME_INVALID,
-        }
-        .to_string(),
-    )
+    line(match key {
+        "ERR_GUILD_ENTER_NAME" => ERR_GUILD_ENTER_NAME,
+        "ERR_GUILD_NAME_INVALID_SPACE" => ERR_GUILD_NAME_INVALID_SPACE,
+        "ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES" => ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES,
+        "ERR_GUILD_NAME_TOO_SHORT" => ERR_GUILD_NAME_TOO_SHORT,
+        _ => ERR_GUILD_NAME_INVALID,
+    })
 }
 
 #[cfg(test)]
@@ -167,19 +217,22 @@ mod tests {
     fn successes_go_to_chat_and_refusals_go_to_the_red_line() {
         assert_eq!(
             my_sign_line(petition_result::OK),
-            Some(Line::Chat("Guild charter signed.".into()))
+            Some((MsgKind::Chat, "Guild charter signed.".into()))
         );
         assert_eq!(
             signed_by_other("Bob"),
-            Line::Chat("Bob has signed your guild charter.".into())
+            (MsgKind::Chat, "Bob has signed your guild charter.".into())
         );
         assert_eq!(
             declined_line("Bob"),
-            Line::Chat("Bob has declined your guild invitation.".into())
+            (
+                MsgKind::Chat,
+                "Bob has declined your guild invitation.".into()
+            )
         );
         assert_eq!(
             offered_line("Bob"),
-            Line::Chat("You have requested Bob's signature.".into())
+            (MsgKind::Chat, "You have requested Bob's signature.".into())
         );
 
         for (code, text) in [
@@ -202,13 +255,13 @@ mod tests {
         ] {
             assert_eq!(
                 my_sign_line(code),
-                Some(Line::Error(text.into())),
+                Some((MsgKind::Error, text.into())),
                 "code {code} is a RED line"
             );
         }
         assert_eq!(
             no_charter_line(),
-            Line::Error("You don't have a guild charter.".into())
+            (MsgKind::Error, "You don't have a guild charter.".into())
         );
     }
 
@@ -224,7 +277,7 @@ mod tests {
         );
         assert_eq!(
             turn_in_line(petition_result::NEED_MORE),
-            Some(Line::Error("You need more signatures.".into()))
+            Some((MsgKind::Error, "You need more signatures.".into()))
         );
     }
 
@@ -262,30 +315,24 @@ mod tests {
                 .unwrap_or_else(|e| panic!("{key} missing from GlobalStrings: {e}"))
         };
 
-        for (key, ours) in [
-            ("ERR_PETITION_ALREADY_SIGNED", ERR_PETITION_ALREADY_SIGNED),
-            ("ERR_PETITION_CREATOR", ERR_PETITION_CREATOR),
-            ("ERR_PETITION_DECLINED_S", ERR_PETITION_DECLINED_S),
-            ("ERR_PETITION_IN_GUILD", ERR_PETITION_IN_GUILD),
-            (
-                "ERR_PETITION_NOT_ENOUGH_SIGNATURES",
-                ERR_PETITION_NOT_ENOUGH_SIGNATURES,
-            ),
-            ("ERR_PETITION_NOT_SAME_SERVER", ERR_PETITION_NOT_SAME_SERVER),
-            ("ERR_PETITION_OFFERED_S", ERR_PETITION_OFFERED_S),
-            ("ERR_PETITION_SIGNED", ERR_PETITION_SIGNED),
-            ("ERR_PETITION_SIGNED_S", ERR_PETITION_SIGNED_S),
-            ("ERR_NO_GUILD_CHARTER", ERR_NO_GUILD_CHARTER),
-            ("ERR_GUILD_ENTER_NAME", ERR_GUILD_ENTER_NAME),
-            ("ERR_GUILD_NAME_INVALID", ERR_GUILD_NAME_INVALID),
-            ("ERR_GUILD_NAME_INVALID_SPACE", ERR_GUILD_NAME_INVALID_SPACE),
-            (
-                "ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES",
-                ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES,
-            ),
-            ("ERR_GUILD_NAME_TOO_SHORT", ERR_GUILD_NAME_TOO_SHORT),
+        for m in [
+            ERR_PETITION_ALREADY_SIGNED,
+            ERR_PETITION_CREATOR,
+            ERR_PETITION_DECLINED_S,
+            ERR_PETITION_IN_GUILD,
+            ERR_PETITION_NOT_ENOUGH_SIGNATURES,
+            ERR_PETITION_NOT_SAME_SERVER,
+            ERR_PETITION_OFFERED_S,
+            ERR_PETITION_SIGNED,
+            ERR_PETITION_SIGNED_S,
+            ERR_NO_GUILD_CHARTER,
+            ERR_GUILD_ENTER_NAME,
+            ERR_GUILD_NAME_INVALID,
+            ERR_GUILD_NAME_INVALID_SPACE,
+            ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES,
+            ERR_GUILD_NAME_TOO_SHORT,
         ] {
-            assert_eq!(g(key), ours, "{key} is not what the client says");
+            assert_eq!(g(m.key), m.text, "{} is not what the client says", m.key);
         }
     }
 
@@ -295,15 +342,21 @@ mod tests {
     fn refused_names_resolve_their_key_and_degrade_safely() {
         assert_eq!(
             name_refused_line("ERR_GUILD_ENTER_NAME"),
-            Line::Error("Enter a name for your guild.".into())
+            (MsgKind::Error, "Enter a name for your guild.".into())
         );
         assert_eq!(
             name_refused_line("ERR_GUILD_NAME_INVALID_SPACE"),
-            Line::Error("Guild names cannot start or end with a space.  Enter a new name.".into())
+            (
+                MsgKind::Error,
+                "Guild names cannot start or end with a space.  Enter a new name.".into()
+            )
         );
         assert_eq!(
             name_refused_line("ERR_SOMETHING_UNCARVED"),
-            Line::Error("That name contains invalid characters,  Enter a new name.".into()),
+            (
+                MsgKind::Error,
+                "That name contains invalid characters,  Enter a new name.".into()
+            ),
             "never a raw key on screen"
         );
     }
diff --git a/crates/benilla-app/src/ui_quest.rs b/crates/benilla-app/src/ui_quest.rs
index 02a77d3a..f70068f2 100644
--- a/crates/benilla-app/src/ui_quest.rs
+++ b/crates/benilla-app/src/ui_quest.rs
@@ -29,7 +29,7 @@ use crate::entities::ItemDisplays;
 use crate::items::Items;
 use crate::names::NameCache;
 use crate::net::{ClientCommand, Guid, GuidIndex, NetCommands, ObjectStore, SelfPlayer};
-use crate::ui_action::{show_messages, ui_error_text, MsgSurface, UiError};
+use crate::ui_action::{show_messages, ui_error_text, MsgKind, UiError};
 use crate::ui_chat::ChatLog;
 use crate::ui_script::UiInput;
 use crate::ui_session::{close_npc_session_out_of_range, npc_switched, NpcSession};
@@ -69,7 +69,7 @@ pub(crate) struct QuestGiver {
     /// reference's `DisplayError(msgId)` split into (surface, GlobalStrings key + fills), so the
     /// line comes from the VM's own strings and never from a hardcoded English literal
     /// (decision 0669).
-    messages: Vec<(MsgSurface, UiError)>,
+    messages: Vec<UiError>,
     /// The re-ask epoch — see [`Self::bump_reask`].
     reask: u32,
 }
@@ -163,13 +163,14 @@ impl QuestGiver {
     }
 
     /// Queue one client message for [`feed_quest`] to resolve and show — the net apply's half of
-    /// the reference's `DisplayError(msgId)` (decision 0669).
-    pub(crate) fn push_message(&mut self, surface: MsgSurface, msg: UiError) {
-        self.messages.push((surface, msg));
+    /// the reference's `DisplayError(msgId)` (decision 0669). The message carries its own surface
+    /// in its key; the caller does not choose one (decision 1770).
+    pub(crate) fn push_message(&mut self, msg: UiError) {
+        self.messages.push(msg);
     }
 
     /// Take the queued client messages (drained by [`feed_quest`], which owns the VM).
-    pub(crate) fn take_messages(&mut self) -> Vec<(MsgSurface, UiError)> {
+    pub(crate) fn take_messages(&mut self) -> Vec<UiError> {
         std::mem::take(&mut self.messages)
     }
 
@@ -465,12 +466,12 @@ fn feed_quest(
     // VM's own GlobalStrings first (immutable script), then show each on the surface its message
     // record names — decision 0669's `DisplayError` kind. Drained BEFORE the snapshot's early-out
     // so a refusal that also closes the panel still gets its line out this frame.
-    let lines: Vec<(MsgSurface, String)> = giver
+    let lines: Vec<(MsgKind, String)> = giver
         .take_messages()
         .into_iter()
-        .filter_map(|(surface, msg)| {
+        .filter_map(|msg| {
             let get = |key: &str| script.lua().globals().get::<String>(key).ok();
-            ui_error_text(&msg, &get).map(|text| (surface, text))
+            ui_error_text(&msg, &get).map(|text| (msg.kind(), text))
         })
         .collect();
     show_messages(&mut script, &mut chat, "ui_quest", lines);
@@ -978,7 +979,6 @@ mod tests {
                     key: questgiver_failed_key(4),
                     fill_s: Some("A Threat Within".into()),
                     fill_d: None,
-                    info: false,
                 },
                 &g
             )
diff --git a/crates/benilla-app/src/ui_quest_share.rs b/crates/benilla-app/src/ui_quest_share.rs
index 85e1a280..d6fce73f 100644
--- a/crates/benilla-app/src/ui_quest_share.rs
+++ b/crates/benilla-app/src/ui_quest_share.rs
@@ -47,7 +47,7 @@ use bevy::prelude::*;
 
 use crate::names::NameCache;
 use crate::net::{ClientCommand, NetCommands};
-use crate::ui_action::{show_messages, ui_error_text, MsgSurface, UiError};
+use crate::ui_action::{show_messages, ui_error_text, MsgKind, UiError};
 use crate::ui_chat::ChatLog;
 use crate::ui_script::UiInput;
 
@@ -116,7 +116,7 @@ impl QuestShare {
 /// `push 0x0` at `0x487dc9`-`0x487e69`), which `CGGameUI::DisplayError` dispatches to the chat
 /// window as `CHAT_MSG_SYSTEM`. Not one of them reaches `UIErrorsFrame`, which is what 1733
 /// guessed and is why the guess is recorded as having been a guess.
-fn verdict_message(msg: QuestShareMsg) -> Option<(MsgSurface, &'static str)> {
+fn verdict_message(msg: QuestShareMsg) -> Option<&'static str> {
     let key = match msg {
         QuestShareMsg::SHARING_QUEST => "ERR_QUEST_PUSH_SUCCESS_S",
         QuestShareMsg::CANT_TAKE_QUEST => "ERR_QUEST_PUSH_INVALID_S",
@@ -129,7 +129,7 @@ fn verdict_message(msg: QuestShareMsg) -> Option<(MsgSurface, &'static str)> {
         QuestShareMsg::FINISH_QUEST => "ERR_QUEST_PUSH_ALREADY_DONE_S",
         _ => return None,
     };
-    Some((MsgSurface::Chat, key))
+    Some(key)
 }
 
 /// Owns [`QuestShare`] and its two systems — a plugin of its own rather than a lodger in
@@ -166,10 +166,10 @@ fn feed_quest_share(
     };
 
     // The verdicts: one line per resolved name, the rest kept for the next frame.
-    let mut lines: Vec<(MsgSurface, String)> = Vec::new();
+    let mut lines: Vec<(MsgKind, String)> = Vec::new();
     let mut waiting = Vec::new();
     for mut v in std::mem::take(&mut share.verdicts) {
-        let Some((surface, key)) = verdict_message(v.msg) else {
+        let Some(key) = verdict_message(v.msg) else {
             debug!(
                 "ui_quest_share: unmapped push verdict {} — no line",
                 v.msg.0
@@ -182,11 +182,10 @@ fn feed_quest_share(
                     key,
                     fill_s: Some(name),
                     fill_d: None,
-                    info: false,
                 };
                 let get = |k: &str| script.lua().globals().get::<String>(k).ok();
                 if let Some(text) = ui_error_text(&err, &get) {
-                    lines.push((surface, text));
+                    lines.push((err.kind(), text));
                 }
             }
             None => {
@@ -259,7 +258,7 @@ mod tests {
     #[test]
     fn verdict_keys_are_distinct() {
         let mut keys: Vec<&str> = (0u8..=8)
-            .filter_map(|v| verdict_message(QuestShareMsg(v)).map(|(_, k)| k))
+            .filter_map(|v| verdict_message(QuestShareMsg(v)))
             .collect();
         keys.sort_unstable();
         let n = keys.len();
@@ -284,7 +283,7 @@ mod tests {
         let g = |key: &str| s.lua().globals().get::<String>(key).ok();
 
         for raw in 0u8..=8 {
-            let (_, key) = verdict_message(QuestShareMsg(raw)).expect("mapped");
+            let key = verdict_message(QuestShareMsg(raw)).expect("mapped");
             let text = g(key).unwrap_or_default();
             assert!(!text.is_empty(), "{key} (verdict {raw}) missing");
             assert!(text.contains("%s"), "{key} names no member: {text:?}");
@@ -293,13 +292,12 @@ mod tests {
         // The two ends of the flow, filled: the opener the sharer sees the instant they click, and
         // the answer a decline produces.
         let line = |raw: u8| {
-            let (_, key) = verdict_message(QuestShareMsg(raw)).unwrap();
+            let key = verdict_message(QuestShareMsg(raw)).unwrap();
             ui_error_text(
                 &UiError {
                     key,
                     fill_s: Some("Mate".into()),
                     fill_d: None,
-                    info: false,
                 },
                 &g,
             )
diff --git a/crates/benilla-app/src/ui_script/options_tests.rs b/crates/benilla-app/src/ui_script/options_tests.rs
index c16a3641..8b39424f 100644
--- a/crates/benilla-app/src/ui_script/options_tests.rs
+++ b/crates/benilla-app/src/ui_script/options_tests.rs
@@ -2151,9 +2151,11 @@ fn every_row_tooltip_key_resolves_in_the_real_global_strings() {
     // bar as the other two. Camera Following Style is counted on the key it wears at rest (Smart's
     // OPTION_TOOLTIP_CAMERA1) and Show When on its own (Always's OPTION_TOOLTIP_TARGETOFTARGET5);
     // their other entries ride the same census as the selection moves.
-    // 53 of the 55 are 1.12's own; the other two are Render Scale (1639) and Display Mode
+    // 54 of the 56 are 1.12's own; the other two are Render Scale (1639) and Display Mode
     // (1650), whose descriptions are benilla's and whose carve-out is above.
-    assert_eq!(checked, 55, "every tipped row carries a live key");
+    // The 28th CVar row is Block Trades (1764), on the Controls page — its key
+    // OPTION_TOOLTIP_BLOCK_TRADES is the reference's, so it is counted here like the rest.
+    assert_eq!(checked, 56, "every tipped row carries a live key");
     assert_eq!(
         untipped,
         vec![
@@ -2260,7 +2262,8 @@ fn every_flavor_of_row_raises_its_plate_from_the_page_it_lives_on() {
     // Cloak / Show Helm, 1472; the four multibar switches, 1500).
     // …plus the Graphics page's Render Scale (1639) and Display Mode (1650), the two rows whose
     // descriptions are benilla's own rather than 1.12 GlobalStrings — see the guard above.
-    assert_eq!(raised, 55, "every row but Auto Loot raises a description");
+    // …and Block Trades (1764), the Controls page's 28th CVar row.
+    assert_eq!(raised, 56, "every row but Auto Loot raises a description");
 }
 
 /// The **Combat page** (decision 1134) — the first rows in this window whose store is a
diff --git a/crates/benilla-app/src/ui_social/mod.rs b/crates/benilla-app/src/ui_social/mod.rs
index d3978789..e0140f3f 100644
--- a/crates/benilla-app/src/ui_social/mod.rs
+++ b/crates/benilla-app/src/ui_social/mod.rs
@@ -140,6 +140,13 @@ impl SocialState {
         self.friends_dirty = true;
     }
 
+    /// Seat the ignore list directly — test-only, for the neighbours that consult it rather than
+    /// build it (decision 1764's trade-request ladder, whose leg 2 answers on its own opcode).
+    #[cfg(test)]
+    pub(crate) fn set_ignores_for_test(&mut self, guids: Vec<u64>) {
+        self.apply_ignore_list(guids);
+    }
+
     /// `SMSG_IGNORE_LIST` — likewise.
     fn apply_ignore_list(&mut self, guids: Vec<u64>) {
         self.ignores = guids;
diff --git a/crates/benilla-app/src/ui_trade.rs b/crates/benilla-app/src/ui_trade.rs
index c73776f3..7cd4fffd 100644
--- a/crates/benilla-app/src/ui_trade.rs
+++ b/crates/benilla-app/src/ui_trade.rs
@@ -14,6 +14,24 @@
 //! intents (`InitiateTrade`/`AcceptTrade`/`CancelTradeAccept`/`CloseTrade`) back out into the trade
 //! `CMSG`s.
 //!
+//! **An incoming request is answered here, not on the wire** (decision 1764).
+//! `SMSG_TRADE_STATUS(BEGIN_TRADE)` only *records* the request; [`answer_trade_request`] walks the
+//! reference's own eight-leg ladder (`0x4bf736`) and either refuses it — on one of three different
+//! opcodes, or with no packet at all — or accepts it, which is what the client did unconditionally
+//! before. The split is what makes the ladder possible: it reads the ignore list, the cinematic
+//! state, player control, the auction house, the initiator's descriptor, an outbound initiate of
+//! ours and the [`BlockTrades`] CVar, none of which can reach `apply_net_updates` at Bevy's
+//! 16-`SystemParam` ceiling — and its answer may span frames, which a wire decoder cannot do at
+//! all. Decision 1725 left the cinematic leg unbuilt for exactly that reason and said so; this is
+//! the seam that makes it, and the seven beside it, ordinary.
+//!
+//! **There is no consent prompt, and that is faithful rather than missing.** 1.12.1 registers a
+//! `TRADE_REQUEST` event and signals it from nowhere, so the `TRADE` StaticPopup that would have
+//! asked is dead code in the real client (§5 cross-checked — wow-re
+//! `ui/scratch/incoming-trade-request-law.md` §3). benilla wired that dialog up and took it back
+//! out (decision 1764): the reference's answer to an unwanted trade is the ignore list and the
+//! *Block Trades* checkbox, both of which are legs of the ladder below.
+//!
 //! **The partner's portrait** rides the shared `"npc"` booth token: [`TradeSession`] implements
 //! [`NpcSession`] so [`crate::ui_session::feed_interact_npc`] points the `"npc"` portrait at the
 //! partner's live entity while the window is open — the partner is a nearby player (within
@@ -36,7 +54,7 @@ use benilla_ui::script::{ScriptValue, TradeSideState, TradeSlotItem, TradeState,
 use crate::entities::ItemDisplays;
 use crate::items::Items;
 use crate::names::NameCache;
-use crate::net::{ClientCommand, NetCommands, ObjectStore, SelfPlayer};
+use crate::net::{ClientCommand, GuidIndex, NetCommands, ObjectStore, SelfPlayer};
 use crate::target::Selection;
 use crate::ui_party::GroupState;
 use crate::ui_script::UiInput;
@@ -59,12 +77,35 @@ struct TradeOffer {
 ///
 /// `partner` is set the moment the trade begins (the initiator records its target at
 /// `CMSG_INITIATE_TRADE` time, since the later `OPEN_WINDOW` carries no guid; the target records it
-/// from `BEGIN_TRADE`); `open` flips on `OPEN_WINDOW`. `npc()` is gated on `open` so the `"npc"`
-/// portrait bakes only while the window is up.
+/// when the ladder *accepts* the request — see `request`); `open` flips on `OPEN_WINDOW`. `npc()`
+/// is gated on `open` so the `"npc"` portrait bakes only while the window is up.
 #[derive(Resource, Default)]
 pub(crate) struct TradeSession {
-    /// The trade partner's guid; `Some` from the initiate/begin onward, `None` = no trade.
+    /// The trade partner's guid; `Some` from the initiate/accept onward, `None` = no trade.
     partner: Option<u64>,
+    /// An incoming `BEGIN_TRADE` **this client has not answered yet** (decision 1764) — the
+    /// initiator's guid. Set by [`Self::request`] and cleared the moment
+    /// [`answer_trade_request`] resolves it, either by promoting it to `partner`
+    /// ([`Self::begin`]) or by refusing ([`Self::refuse_request`]). Mutually exclusive with
+    /// `partner`: a request that has not been answered is not yet a trade.
+    request: Option<u64>,
+    /// **An outbound `CMSG_INITIATE_TRADE` of ours is live** — the reference's `[0xc4bec8]`, and
+    /// leg 1 of [`answer_trade_request`]'s ladder, where it drops an incoming request without a
+    /// reply of any kind.
+    ///
+    /// Its own field rather than `partner.is_some()` because the two are different sets, and the
+    /// binary is explicit about which — a complete 5-site census of `[0xc4bec8]`: set at
+    /// `0x5d4021` as `CMSG_INITIATE_TRADE` goes out, zeroed at module init (`0x5d478e`) and in the
+    /// status handler's common tail (`0x5d4931`), read twice. So a trade we did not start has it
+    /// clear for its whole life, while `partner` is set the moment we accept one.
+    ///
+    /// **It survives `OPEN_WINDOW`**, which is the half that is easy to get wrong and was worth
+    /// asking about: the tail only clears on the statuses that set `esi`, and 1, 2 (`OPEN_WINDOW`),
+    /// 4, 7, 9 and 22 do not — so the latch stands for the whole life of a trade *we* opened, and
+    /// leg 1 drops an incoming request throughout it. Modelling it as "we asked and no window has
+    /// opened yet" would have been strictly narrower, and wrong in exactly the window where it
+    /// matters. Ours is cleared by the session reset, which is the same moment.
+    initiated: bool,
     /// The window is up (`OPEN_WINDOW` arrived). `partner` can be `Some` before this (an initiate in
     /// flight the server hasn't opened yet).
     open: bool,
@@ -86,12 +127,40 @@ impl TradeSession {
     pub(crate) fn initiate(&mut self, target: u64) {
         *self = TradeSession {
             partner: Some(target),
+            initiated: true,
             ..Default::default()
         };
     }
 
-    /// `BEGIN_TRADE(initiator guid)` — the target learns the partner and (via the drain-adjacent
-    /// bridge) auto-answers `CMSG_BEGIN_TRADE`. Resets any stale prior offer.
+    /// `BEGIN_TRADE(initiator guid)` — record the incoming request, **unanswered**. Nothing goes
+    /// on the wire here (decision 1764): [`answer_trade_request`] owns the reply.
+    ///
+    /// Records it *beside* whatever session already exists rather than resetting — a request is
+    /// not a trade, and a request arriving over a live one must not destroy it. That reset is
+    /// [`Self::begin`]'s, at the moment the request is accepted and there really is a fresh trade.
+    /// Leaving it here would also have made the "already trading" refusal leg dead code, since
+    /// the ladder reads the very fields the reset had just cleared.
+    pub(crate) fn request(&mut self, initiator: u64) {
+        self.request = Some(initiator);
+    }
+
+    /// The incoming request awaiting an answer, if any.
+    pub(crate) fn pending_request(&self) -> Option<u64> {
+        self.request
+    }
+
+    /// Spend the pending request **without touching the rest of the session** — the refusal path's
+    /// counterpart to [`Self::begin`]. It clears only the request for the same reason
+    /// [`Self::request`] sets only the request: refusing an offer is not cancelling the trade you
+    /// are in, and on a fresh session the two are indistinguishable anyway (there is nothing else
+    /// to clear). The server's own `TRADE_STATUS_BUSY` reply closes what needs closing.
+    pub(crate) fn refuse_request(&mut self) {
+        self.request = None;
+    }
+
+    /// Accept the pending request: the initiator becomes the partner and the request is spent. The
+    /// caller sends `CMSG_BEGIN_TRADE` in the same breath; the server answers both sides
+    /// `OPEN_WINDOW`.
     pub(crate) fn begin(&mut self, partner: u64) {
         *self = TradeSession {
             partner: Some(partner),
@@ -215,21 +284,213 @@ pub(crate) struct UiTradePlugin;
 
 impl Plugin for UiTradePlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<TradeSession>().add_systems(
-            Update,
-            (
-                // Feed before the input pass so an open/close/mirror is on screen the same frame;
-                // drain after it so a click's intent (initiate, accept, close) goes out the same
-                // frame (the ui_mail ordering exactly). After the UnitFeed set so the resolved
-                // item-template store is landed. No range-guard registration — a trade's cancel is
-                // server-driven (the module doc).
-                feed_trade.after(crate::ui_unit::UnitFeed).before(UiInput),
-                drain_trade.after(UiInput),
-            ),
-        );
+        app.init_resource::<TradeSession>()
+            .init_resource::<BlockTrades>()
+            .add_systems(
+                Update,
+                (
+                    // Feed before the input pass so an open/close/mirror is on screen the same
+                    // frame; drain after it so a click's intent (initiate, accept, close) goes out
+                    // the same frame (the ui_mail ordering exactly). After the UnitFeed set so the
+                    // resolved item-template store is landed. No range-guard registration — a
+                    // trade's cancel is server-driven (the module doc).
+                    feed_trade.after(crate::ui_unit::UnitFeed).before(UiInput),
+                    // The incoming request's answer needs no VM at all — it is wire policy over
+                    // engine state — so it sits ahead of the feed, and an accepted request's
+                    // `partner` is on screen the same frame the window opens.
+                    answer_trade_request.before(feed_trade),
+                    drain_trade.after(UiInput),
+                ),
+            );
     }
 }
 
+/// **Block Trades** — 1.12's own `BlockTrades` CVar (`0x842fbc`), the *Block Trades* checkbox in
+/// Basic Options' General box (`UIOptionsFrame.lua` l.11: `UIOptionsFrameCheckButtons`
+/// `["BLOCK_TRADES"] = { index = 14, cvar = "BlockTrades" }`, tooltip
+/// `OPTION_TOOLTIP_BLOCK_TRADES` = "Block all incoming trade requests.").
+///
+/// A knob resource rather than a field on [`TradeSession`], for the same reason
+/// [`crate::ui_guild::GuildMemberNotify`] is one: it is a *setting*, and `TradeSession` is cleared
+/// on every disconnect.
+///
+/// Its one reader is [`answer_trade_request`]'s last refusal leg — the only leg of that ladder
+/// that speaks, which is why the silent ones are ordered ahead of it.
+#[derive(Resource, Default)]
+pub(crate) struct BlockTrades(pub(crate) bool);
+
+/// `ERR_TRADE_BLOCKED_S` (`GlobalStrings.lua` l.1889) — the line the *Block Trades* refusal prints,
+/// naming the would-be partner. Two spaces after the full stop, as shipped.
+const ERR_TRADE_BLOCKED_S: &str = "%s has requested to trade.  You have refused.";
+
+/// **Answer an incoming trade request** — the arm the reference keeps inside `CGTradeInfo`'s
+/// dispatcher (`0x4bf736`, case 1 of the 23-case `0x4bf720`), lifted out to where its inputs live.
+///
+/// The net drain only *records* the request ([`TradeSession::request`]); this system decides. The
+/// split is the point: the decision reads the ignore list, the cinematic state, player control, the
+/// auction house, the initiator's own descriptor, an outbound initiate of ours and a CVar, and none
+/// of those can reach `apply_net_updates`, whose signature is at Bevy's 16-`SystemParam` ceiling.
+/// That ceiling is exactly why decision 1725 left the cinematic leg unbuilt and said so; it is not
+/// a ceiling this side of the seam has. The answer can also **span frames**, which a wire decoder
+/// cannot do at all: the `BlockTrades` line names the initiator, and that name may need a
+/// `CMSG_NAME_QUERY` first.
+///
+/// **The ladder is the reference's, in its order** — eight legs, walked contiguously over
+/// `[0x4bf736, 0x4bf7f8)` and cross-checked by four independent derivations (wow-re
+/// `ui/scratch/incoming-trade-request-law.md` §2). Three answer with something other than "busy",
+/// which is why this is a ladder and not a boolean:
+///
+/// | # | condition | benilla reads | answer |
+/// |---|---|---|---|
+/// | 1 | our own `CMSG_INITIATE_TRADE` is in flight (`[0xc4bec8]`) | [`TradeSession::initiated`] | **nothing at all** |
+/// | 2 | the initiator is on our **ignore list** (`0x5ae5a0`, by guid, cap 25) | [`crate::ui_social::SocialState::is_ignored`] | **`CMSG_IGNORE_TRADE`**, silent |
+/// | 3 | the initiator resolves to no streamed **player** object (`0x468460(TYPEMASK_PLAYER)`) | [`GuidIndex`] + [`ObjectStore`] | **nothing at all** |
+/// | 4 | the initiator is dead or a ghost (`0x605f30`) | raw health ≤ 0, or `PLAYER_FLAGS` ghost | `CMSG_BUSY_TRADE`, silent |
+/// | 5 | a cinematic is playing (`[0xb4e310]`) | [`crate::cinematic::Cinematic`] | `CMSG_BUSY_TRADE`, silent |
+/// | 6 | we have lost **player control** (`[0xb4b3e4]`) | `Player::control_lost` | `CMSG_BUSY_TRADE`, silent |
+/// | 7 | an **auction house** window is open (`[0xb725f8]`/`[0xb725fc]`) | [`crate::ui_auction::AuctionOpen`] | `CMSG_BUSY_TRADE`, silent |
+/// | 8 | the `BlockTrades` CVar is set (`0x842fbc`) | [`BlockTrades`] | `CMSG_BUSY_TRADE` **+ the one chat line** |
+/// | — | nothing refuses it | — | **`CMSG_BEGIN_TRADE`**, and the server opens both windows |
+///
+/// Only leg 8 speaks, so the **order is behaviour**, not taste: a request during a cinematic is
+/// refused silently because that leg returns before the message.
+///
+/// **There is no consent step, and that is the reference's answer, not an omission.** The 5875
+/// client registers a `TRADE_REQUEST` event (id `0x11d`) and signals it from nowhere — a
+/// whole-image census — so `StaticPopupDialogs["TRADE"]`, its `TRADE_WITH_QUESTION` text and its
+/// `BeginTrade`/`CancelTrade` verbs are dead code there, and an incoming trade that survives the
+/// ladder opens the window unasked. benilla briefly wired that dialog up and then took it back out
+/// (decision 1764): a popup the real client never shows is a divergence every addon and every
+/// player would feel, and the reference's own answer to an unwanted trade is leg 2 and leg 8 —
+/// ignore them, or tick *Block Trades*.
+///
+/// Three legs were wrong in wow-re's earlier five-condition gloss and were corrected by the round
+/// that produced the note above — `[0xb4b3e4]` is player *control*, not "in world"; `[0xb725f8]` is
+/// the auction house, not a pending trade; and the ignore leg was missing entirely. This is why the
+/// gloss was not built from.
+#[allow(clippy::too_many_arguments)]
+fn answer_trade_request(
+    mut trade: ResMut<TradeSession>,
+    commands: Res<NetCommands>,
+    mut names: ResMut<NameCache>,
+    mut chat_log: ResMut<crate::ui_chat::ChatLog>,
+    social: Res<crate::ui_social::SocialState>,
+    cinematic: Res<crate::cinematic::Cinematic>,
+    player: Res<crate::player::Player>,
+    auction: Res<crate::ui_auction::AuctionOpen>,
+    block_trades: Res<BlockTrades>,
+    index: Res<GuidIndex>,
+    stores: Query<&ObjectStore>,
+) {
+    let Some(initiator) = trade.pending_request() else {
+        return;
+    };
+
+    // ── Legs 1 and 3: the two that send NOTHING ─────────────────────────────────────────────────
+    //
+    // Leg 1 — our own `CMSG_INITIATE_TRADE` is in flight. See [`TradeSession::initiated`]: the
+    // latch is "we asked somebody", it survives `OPEN_WINDOW`, and it is never set by a trade we
+    // did not start.
+    //
+    // Leg 3 — the initiator does not resolve to a streamed **player**. The reference asks
+    // `0x468460(TYPEMASK_PLAYER)` and returns on NULL; ours is the guid index plus the store, and
+    // it fails in exactly the case the reference's does (nothing of that guid in the world).
+    let initiator_store = index
+        .0
+        .get(&initiator)
+        .and_then(|e| stores.get(*e).ok())
+        .filter(|_| benilla_protocol::guid::is_player(initiator));
+    if trade.initiated || initiator_store.is_none() {
+        info!(
+            target: "trade",
+            "BEGIN_TRADE from {initiator:#x} dropped without a reply (own initiate in flight: {}, \
+             initiator resolved: {})",
+            trade.initiated,
+            initiator_store.is_some(),
+        );
+        trade.refuse_request();
+        return;
+    }
+
+    // ── Leg 2: the ignore list, and the ONLY leg that answers on a different opcode ─────────────
+    //
+    // The server has no ignore check for trade at all (vmangos `HandleInitiateTradeOpcode` reads
+    // no social list), so this refusal is entirely the client's — the same shape as the duel
+    // challenge's (decision 0668). `CMSG_IGNORE_TRADE` rather than busy is what makes the
+    // initiator read "… is ignoring you" instead of "… is busy", and it is a single call site
+    // image-wide (`0x4bf759` → `0x5d41c0`). Both sides key on the guid, and both cap at 25.
+    if social.is_ignored(initiator) {
+        info!(target: "trade", "BEGIN_TRADE from an ignored {initiator:#x}; sending CMSG_IGNORE_TRADE");
+        let _ = commands.0.send(ClientCommand::IgnoreTrade);
+        trade.refuse_request();
+        return;
+    }
+
+    // ── Legs 4-7: the silent "busy" refusals. None needs a name, so none waits for one ──────────
+    //
+    // Leg 4 — the initiator is dead or a ghost. `0x605f30` is **raw** health ≤ 0 or the
+    // `PLAYER_FLAGS` ghost bit; deliberately NOT `unit_reads_dead()`, which also takes the
+    // dead-looking dynflag and would refuse a feigning hunter the reference trades with.
+    // Leg 5 — a cinematic (`[0xb4e310]`): decision 1725 named this exact hole and left it for want
+    // of a param slot here.
+    // Leg 6 — player control lost (`[0xb4b3e4]`): NOT an in-world flag. The cell is written by
+    // `0x4958e0`, which signals `PLAYER_CONTROL_GAINED`/`LOST` — the same wire fact
+    // `SMSG_CLIENT_CONTROL_UPDATE` gives `Player::control_lost`.
+    // Leg 7 — an auction house is open (`[0xb725f8]`/`[0xb725fc]`, one auctioneer guid split
+    // across two cells, set and cleared with the AH window).
+    let dead_or_ghost = initiator_store
+        .is_some_and(|s| s.0.unit_health().is_some_and(|hp| hp == 0) || s.0.player_is_ghost());
+    if dead_or_ghost
+        || cinematic.is_playing()
+        || player.control_lost
+        || auction.auctioneer.is_some()
+    {
+        info!(target: "trade", "BEGIN_TRADE from {initiator:#x} refused silently; sending CMSG_BUSY_TRADE");
+        let _ = commands.0.send(ClientCommand::BusyTrade);
+        trade.refuse_request();
+        return;
+    }
+
+    // ── Leg 8 is the only one that names the initiator, so only it waits for the name cache ─────
+    //
+    // The reference reads it straight off the initiator's live `CGUnit` (`0x609210`) and does not
+    // have to wait; benilla may need a `CMSG_NAME_QUERY` round trip first. Leg 3 above has already
+    // established the initiator is streamed, which is exactly the case the reference has the name
+    // for free, so in practice there is nothing to wait for.
+    //
+    // **The wait needs no timer, because the server already bounds it.** The only way a name never
+    // arrives is a player the server can no longer find — and that is precisely the case where
+    // vmangos's `CleanupsBeforeDelete` sends US `TRADE_STATUS_TRADE_CANCELED` regardless of the
+    // leaver's own `sendback`, which clears the request through `close`. `NameCache` asks once per
+    // guid per connection, so the frames spent here cost one query, not one per frame.
+    //
+    // It is also the one leg that could not live in the net drain even with a param to spare: the
+    // answer may land a frame or two after the packet did.
+    if block_trades.0 {
+        let Some(name) = names.resolve(initiator, &commands).map(str::to_string) else {
+            return;
+        };
+        info!(target: "trade", "BEGIN_TRADE from {name} refused by BlockTrades; sending CMSG_BUSY_TRADE");
+        let _ = commands.0.send(ClientCommand::BusyTrade);
+        trade.refuse_request();
+        // `0x496720(0xbb, 0x609210(initiator))` — and catalog row `0xbb` carries `kind = 0`, chat
+        // type `0xa`, no sound cue. So this is a **system chat line**, not the red
+        // `UI_ERROR_MESSAGE` (`kind = 2`). All three trade rows are chat rows; `crate::ui_duel`'s
+        // note that benilla models `DisplayError` as the red toast is true of its own two ids and
+        // not of these.
+        chat_log.push_event(crate::ui_chat::ChatEvent::text_only(
+            crate::ui_chat::ChatEventKind::System,
+            ERR_TRADE_BLOCKED_S.replacen("%s", &name, 1),
+        ));
+        return;
+    }
+
+    // Nothing refuses it: accept, exactly as the reference does at the bottom of the same ladder.
+    info!(target: "trade", "BEGIN_TRADE from {initiator:#x} accepted; sending CMSG_BEGIN_TRADE");
+    trade.begin(initiator);
+    let _ = commands.0.send(ClientCommand::BeginTrade);
+}
+
 /// Resolve one wire [`TradeItem`] into the Lua-facing [`TradeSlotItem`]: name/quality through the
 /// ask-once item-template cache, icon through the wire `display_id` + `ItemDisplayInfo.dbc`. `None`s
 /// stay `None` while a template query is in flight — the slot shows the icon (from the wire) and fills
@@ -557,12 +818,61 @@ mod tests {
         assert_eq!(s.npc(), None);
     }
 
+    /// An incoming `BEGIN_TRADE` is a *request*, not a trade: nothing is a partner until it is
+    /// answered, so the "npc" portrait, the snapshot and the already-in-a-trade refusal leg all
+    /// read the same "no trade here" they read before it arrived (decision 1764).
     #[test]
-    fn begin_records_partner_for_the_target_side() {
+    fn an_incoming_request_is_not_yet_a_trade() {
         let mut s = TradeSession::default();
+        s.request(0xABCD);
+        assert_eq!(s.pending_request(), Some(0xABCD));
+        assert_eq!(s.partner, None, "an unanswered request has no partner");
+        assert!(!s.is_open(), "BEGIN_TRADE does not itself open the window");
+        assert_eq!(s.npc(), None);
+    }
+
+    /// Accepting the request promotes the initiator to partner and spends the request — the exact
+    /// state the initiator's own side reaches through `initiate`.
+    #[test]
+    fn accepting_a_request_promotes_the_initiator_to_partner() {
+        let mut s = TradeSession::default();
+        s.request(0xABCD);
         s.begin(0xABCD);
         assert_eq!(s.partner, Some(0xABCD));
-        assert!(!s.is_open(), "BEGIN_TRADE does not itself open the window");
+        assert_eq!(s.pending_request(), None, "the request is spent");
+        assert!(!s.is_open(), "the window waits for OPEN_WINDOW");
+    }
+
+    /// Refusing (or any close) clears the request with everything else, so a refusal in flight can
+    /// never be answered twice.
+    #[test]
+    fn closing_clears_a_pending_request() {
+        let mut s = TradeSession::default();
+        s.request(0xABCD);
+        s.close();
+        assert_eq!(s.pending_request(), None);
+    }
+
+    /// A `BEGIN_TRADE` arriving over a **live** trade leaves that trade completely alone — and so
+    /// does refusing it. This is what makes the "already trading" leg of the ladder readable at
+    /// all: it reads the fields a reset would have cleared a line earlier.
+    #[test]
+    fn a_request_leaves_a_live_trade_alone() {
+        let mut s = TradeSession::default();
+        s.initiate(0x1);
+        s.open_window();
+        s.partner_accepted();
+
+        s.request(0x2);
+        assert_eq!(s.pending_request(), Some(0x2));
+        assert_eq!(s.partner, Some(0x1), "the live trade is untouched");
+        assert!(s.is_open());
+        assert!(s.their_accept);
+
+        s.refuse_request();
+        assert_eq!(s.pending_request(), None);
+        assert_eq!(s.partner, Some(0x1), "refusing an offer is not cancelling");
+        assert!(s.is_open());
     }
 
     #[test]
@@ -703,6 +1013,243 @@ mod tests {
         );
     }
 
+    /// A request that survives every leg is **accepted unasked** — the bottom of the reference's
+    /// own ladder, and the behaviour benilla briefly replaced with a consent dialog before taking
+    /// it back out (decision 1764). The 5875 client never asks: it registers `TRADE_REQUEST` and
+    /// signals it from nowhere.
+    #[test]
+    fn a_request_that_survives_the_ladder_is_accepted() {
+        let (mut app, rx) = request_app(false, false, true);
+        app.world_mut().resource_mut::<TradeSession>().request(0x7);
+        app.update();
+
+        assert!(
+            matches!(rx.try_recv(), Ok(ClientCommand::BeginTrade)),
+            "nothing refused it, so the client answers — the server opens both windows"
+        );
+        let trade = app.world().resource::<TradeSession>();
+        assert_eq!(trade.partner, Some(0x7));
+        assert_eq!(trade.pending_request(), None, "the request is spent");
+        assert!(
+            !trade.initiated,
+            "a trade we did not start never sets the initiate latch"
+        );
+        assert!(
+            app.world()
+                .resource::<crate::ui_chat::ChatLog>()
+                .pending_texts()
+                .is_empty(),
+            "and an accepted request says nothing — only leg 8 speaks"
+        );
+    }
+
+    /// **Block Trades** refuses without asking, and it is the one refusal that speaks: the
+    /// `ERR_TRADE_BLOCKED_S` line naming the initiator (`0x496720(0xbb, …)`). Catalog row `0xbb`
+    /// is `kind = 0` — the **chat frame**, chat type `0xa` — so this is a system chat line and
+    /// **not** the red `UI_ERROR_MESSAGE`, which is `kind = 2`. That correction is the RE's.
+    #[test]
+    fn block_trades_refuses_and_says_so() {
+        let (mut app, rx) = request_app(true, false, true);
+        app.world_mut().resource_mut::<TradeSession>().request(0x7);
+        app.update();
+
+        assert!(matches!(rx.try_recv(), Ok(ClientCommand::BusyTrade)));
+        assert_eq!(
+            app.world()
+                .resource::<crate::ui_chat::ChatLog>()
+                .pending_texts(),
+            vec!["Grubbis has requested to trade.  You have refused.".to_string()],
+        );
+    }
+
+    /// Legs 5 and 6 — a cinematic (decision 1725's named hole) and lost player control — refuse
+    /// with **no** line. Only leg 8 reaches the message, which is why the ladder's order is
+    /// behaviour and not taste.
+    #[test]
+    fn the_silent_legs_refuse_without_a_word() {
+        for (cinematic, controlled) in [(true, true), (false, false)] {
+            let (mut app, rx) = request_app(false, cinematic, controlled);
+            app.world_mut().resource_mut::<TradeSession>().request(0x7);
+            app.update();
+            assert!(
+                matches!(rx.try_recv(), Ok(ClientCommand::BusyTrade)),
+                "cinematic={cinematic} controlled={controlled}: refused as busy"
+            );
+            assert!(
+                app.world()
+                    .resource::<crate::ui_chat::ChatLog>()
+                    .pending_texts()
+                    .is_empty(),
+                "cinematic={cinematic} controlled={controlled}: a silent leg says nothing"
+            );
+        }
+    }
+
+    /// Leg 7 — an open auction house refuses the request. `[0xb725f8]`/`[0xb725fc]` is the open
+    /// auctioneer's guid, which the old five-condition gloss had mislabelled as "a trade is
+    /// already pending". benilla was one commit from building that wrong leg.
+    #[test]
+    fn an_open_auction_house_refuses_the_request() {
+        let (mut app, rx) = request_app(false, false, true);
+        app.world_mut()
+            .resource_mut::<crate::ui_auction::AuctionOpen>()
+            .auctioneer = Some(0x1234);
+        app.world_mut().resource_mut::<TradeSession>().request(0x7);
+        app.update();
+        assert!(matches!(rx.try_recv(), Ok(ClientCommand::BusyTrade)));
+    }
+
+    /// Leg 2 — an ignored initiator is refused on a **different opcode**, silently. The server has
+    /// no ignore check for trade at all (vmangos's `HandleInitiateTradeOpcode` reads no social
+    /// list), so this refusal is entirely the client's; `IGNORE_TRADE` rather than `BUSY_TRADE` is
+    /// what makes the initiator read "is ignoring you" instead of "is busy".
+    #[test]
+    fn an_ignored_initiator_is_refused_as_ignored() {
+        let (mut app, rx) = request_app(false, false, true);
+        app.world_mut()
+            .resource_mut::<crate::ui_social::SocialState>()
+            .set_ignores_for_test(vec![0x7]);
+        app.world_mut().resource_mut::<TradeSession>().request(0x7);
+        app.update();
+        assert!(
+            matches!(rx.try_recv(), Ok(ClientCommand::IgnoreTrade)),
+            "the ignore leg does NOT answer busy"
+        );
+        assert!(app
+            .world()
+            .resource::<crate::ui_chat::ChatLog>()
+            .pending_texts()
+            .is_empty());
+    }
+
+    /// Leg 4 — a dead or ghost initiator is refused as busy. The predicate is the reference's
+    /// `0x605f30`: **raw** health ≤ 0, or the `PLAYER_FLAGS` ghost bit. Deliberately not
+    /// `unit_reads_dead()` (`UnitIsDead 0x517ac0`), which also takes the dead-looking dynflag and
+    /// would refuse a feigning hunter the reference trades with quite happily.
+    #[test]
+    fn a_dead_or_ghost_initiator_is_refused() {
+        // `UNIT_FIELD_HEALTH` and `PLAYER_FLAGS`, spelled here the way `ui_unit`'s tests spell
+        // their field ids — the protocol crate keeps them private.
+        const HEALTH: u16 = 22;
+        const PLAYER_FLAGS: u16 = 190;
+        const GHOST: u32 = 0x10;
+        for (label, fields) in [
+            ("dead", vec![(HEALTH, 0u32)]),
+            ("ghost", vec![(HEALTH, 1u32), (PLAYER_FLAGS, GHOST)]),
+        ] {
+            let (mut app, rx) = request_app(false, false, true);
+            let entity = app.world().resource::<GuidIndex>().0[&0x7];
+            app.world_mut().entity_mut(entity).insert(ObjectStore(
+                benilla_protocol::messages::ObjectFields::from_pairs(&fields),
+            ));
+            app.world_mut().resource_mut::<TradeSession>().request(0x7);
+            app.update();
+            assert!(
+                matches!(rx.try_recv(), Ok(ClientCommand::BusyTrade)),
+                "{label}: refused as busy"
+            );
+        }
+    }
+
+    /// Legs 1 and 3 — the two that answer with **nothing at all**: our own initiate in flight
+    /// (`[0xc4bec8]`), and an initiator that resolves to no streamed player object. Both drop the
+    /// request without a packet, which is the reference's behaviour and not an oversight — it has
+    /// nothing to say to a trade it cannot see. Leg 1 is also what replaced the "already trading"
+    /// leg the old gloss claimed: the latch is set by the initiate sender and never by
+    /// `OPEN_WINDOW`, so it is "we asked somebody", not "a window is up".
+    #[test]
+    fn two_legs_answer_with_no_packet_at_all() {
+        let answered = |rx: &crossbeam_channel::Receiver<ClientCommand>| {
+            rx.try_iter().any(|c| {
+                matches!(
+                    c,
+                    ClientCommand::BusyTrade
+                        | ClientCommand::IgnoreTrade
+                        | ClientCommand::BeginTrade
+                        | ClientCommand::CancelTrade
+                )
+            })
+        };
+
+        // Leg 1: we asked somebody else first, and the request arrives over it.
+        let (mut app, rx) = request_app(false, false, true);
+        {
+            let mut trade = app.world_mut().resource_mut::<TradeSession>();
+            trade.initiate(0x9);
+            trade.request(0x7);
+        }
+        app.update();
+        assert!(
+            !answered(&rx),
+            "an initiate of our own in flight drops the request in silence"
+        );
+        let trade = app.world().resource::<TradeSession>();
+        assert_eq!(
+            trade.pending_request(),
+            None,
+            "…and spends it, so it is not retried every frame"
+        );
+        assert_eq!(trade.partner, Some(0x9), "…and our own trade survives it");
+
+        // Leg 3: nothing of that guid is streamed.
+        let (mut app, rx) = request_app(false, false, true);
+        app.world_mut().resource_mut::<GuidIndex>().0.remove(&0x7);
+        app.world_mut().resource_mut::<TradeSession>().request(0x7);
+        app.update();
+        assert!(
+            !answered(&rx),
+            "an unresolvable initiator drops the request in silence"
+        );
+    }
+
+    /// The harness for [`answer_trade_request`]: an app carrying the eight pieces of state the
+    /// ladder reads, and two streamed player objects to be asked by. **No VM** — the system needs
+    /// none, which is the shape it settled into once the consent dialog came back out (decision
+    /// 1764): the answer is wire policy over engine state, and the only reason it is not in the
+    /// net drain is the parameter ceiling there.
+    fn request_app(
+        block_trades: bool,
+        cinematic: bool,
+        controlled: bool,
+    ) -> (App, crossbeam_channel::Receiver<ClientCommand>) {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        let mut app = App::new();
+        let mut names = NameCache::default();
+        // Two names, because several of these tests need a SECOND asker — and an unresolved name
+        // parks leg 8 before it reaches the line, which would let a test pass for the wrong
+        // reason (it did, once).
+        names.insert_player(0x7, "Grubbis".to_string(), None);
+        names.insert_player(0x8, "Skarrid".to_string(), None);
+        app.init_resource::<TradeSession>()
+            .init_resource::<crate::ui_chat::ChatLog>()
+            .init_resource::<crate::ui_social::SocialState>()
+            .init_resource::<crate::ui_auction::AuctionOpen>()
+            .init_resource::<GuidIndex>()
+            .init_resource::<crate::player::Player>()
+            .insert_resource(names)
+            .insert_resource(NetCommands(tx))
+            .insert_resource(BlockTrades(block_trades))
+            .insert_resource(if cinematic {
+                crate::cinematic::Cinematic::playing_for_test()
+            } else {
+                crate::cinematic::Cinematic::default()
+            });
+        app.world_mut()
+            .resource_mut::<crate::player::Player>()
+            .control_lost = !controlled;
+        // The two askers are streamed player objects — leg 3 drops a request from a guid that
+        // resolves to nothing, so every test that expects to reach the ladder needs them present.
+        for guid in [0x7u64, 0x8] {
+            let e = app.world_mut().spawn(ObjectStore::default()).id();
+            app.world_mut()
+                .resource_mut::<GuidIndex>()
+                .0
+                .insert(guid, e);
+        }
+        app.add_systems(Update, answer_trade_request);
+        (app, rx)
+    }
+
     /// Draining a `SetTradeMoney` offer ships `CMSG_SET_TRADE_GOLD` — but only while the window is
     /// open, so a stray value with no trade is dropped (decision 0592 P2).
     #[test]
diff --git a/crates/benilla-app/tests/message_keys.rs b/crates/benilla-app/tests/message_keys.rs
new file mode 100644
index 00000000..9cc9d455
--- /dev/null
+++ b/crates/benilla-app/tests/message_keys.rs
@@ -0,0 +1,82 @@
+//! Every `ERR_*` key this workspace names must be a real row of the client's message catalog.
+//!
+//! benilla writes these keys as string literals at ~160 call sites, and each one used to arrive by
+//! hand-tracing a `push <id>; call CGGameUI::DisplayError` in the binary. A typo, a key from a
+//! later expansion, or a plausible-looking invention would all have been invisible: the string
+//! simply would not resolve in `GlobalStrings.lua`, and the reference's own data-suppression rule
+//! means benilla shows *nothing* for an unresolvable key. Silence is the failure mode, which is the
+//! worst kind — nobody files a bug about a toast they never saw.
+//!
+//! Since decision 1770 the surface those keys are shown on is read from
+//! [`benilla_ui::messages`] rather than carried beside them, so a key that is not in the catalog
+//! also silently takes the fallback. This walk is what keeps that fallback unreachable: it is the
+//! tripwire that turns "we believe these are message ids" into a checked claim.
+//!
+//! It reads source text rather than any registry the code keeps, deliberately — a registry could
+//! only contain what somebody remembered to register.
+
+use std::collections::BTreeSet;
+use std::path::Path;
+
+/// Not message ids, and not meant to be — both are fixtures for the unknown-key *fallback*, which
+/// needs a key the client does not have in order to be tested at all: `ui_petition::lines`'
+/// degrade-to-generic arm, and `benilla_ui::messages`' own proof that `kind_of` answers for a key
+/// it has never heard of. Anything else appearing here is a defect, not an entry to add.
+const NOT_A_MESSAGE: &[&str] = &["ERR_SOMETHING_UNCARVED", "ERR_NOT_A_REAL_MESSAGE"];
+
+/// The generated table itself, which is the answer and not a question — walking it would make
+/// every key trivially present and the check vacuous.
+const GENERATED: &str = "catalog.rs";
+
+fn walk(dir: &Path, into: &mut Vec<String>) {
+    for entry in std::fs::read_dir(dir).unwrap_or_else(|e| panic!("read {}: {e}", dir.display())) {
+        let path = entry.expect("dir entry").path();
+        if path.is_dir() {
+            walk(&path, into);
+        } else if path.extension().is_some_and(|e| e == "rs")
+            && path.file_name().is_some_and(|n| n != GENERATED)
+        {
+            into.push(std::fs::read_to_string(&path).expect("read source"));
+        }
+    }
+}
+
+/// Pull every `"ERR_…"` string literal out of a source file, the way the call sites write them.
+fn err_keys(src: &str) -> impl Iterator<Item = String> + '_ {
+    src.match_indices("\"ERR_").filter_map(|(i, _)| {
+        let rest = &src[i + 1..];
+        let end = rest.find('"')?;
+        let key = &rest[..end];
+        key.chars()
+            .all(|c| c.is_ascii_uppercase() || c.is_ascii_digit() || c == '_')
+            .then(|| key.to_string())
+    })
+}
+
+#[test]
+fn every_error_key_in_the_source_is_a_catalog_row() {
+    let mut sources = Vec::new();
+    walk(Path::new("src"), &mut sources);
+    walk(Path::new("../benilla-ui/src"), &mut sources);
+    assert!(sources.len() > 100, "the walk found almost nothing to read");
+
+    let keys: BTreeSet<String> = sources.iter().flat_map(|s| err_keys(s)).collect();
+    // 163 at the time of writing — the point is only that the walk found the vocabulary and not
+    // a handful of files, so this is a floor and not a ledger to keep updated.
+    assert!(
+        keys.len() > 150,
+        "expected the hand-written `ERR_*` vocabulary, found {}",
+        keys.len()
+    );
+
+    let strays: Vec<&String> = keys
+        .iter()
+        .filter(|k| !NOT_A_MESSAGE.contains(&k.as_str()))
+        .filter(|k| benilla_ui::messages::by_key(k).is_none())
+        .collect();
+    assert!(
+        strays.is_empty(),
+        "these keys are not rows of the 5875 message catalog, so the client would show nothing \
+         for them: {strays:?}"
+    );
+}
diff --git a/crates/benilla-ui/src/lib.rs b/crates/benilla-ui/src/lib.rs
index 73b6687e..641e4db6 100644
--- a/crates/benilla-ui/src/lib.rs
+++ b/crates/benilla-ui/src/lib.rs
@@ -28,6 +28,7 @@ pub mod justify;
 pub mod layout;
 pub mod loader;
 pub mod markup;
+pub mod messages;
 pub mod order;
 pub mod script;
 pub mod source;
diff --git a/crates/benilla-ui/src/messages.rs b/crates/benilla-ui/src/messages.rs
new file mode 100644
index 00000000..24459837
--- /dev/null
+++ b/crates/benilla-ui/src/messages.rs
@@ -0,0 +1,167 @@
+//! The client's **message catalog** — the one table that decides where a UI message is shown.
+//!
+//! Every user-visible refusal, notice and confirmation the engine raises goes through a single
+//! function, `CGGameUI::DisplayError` (`0x496720`), which takes a **message id** and nothing else.
+//! The id indexes the registry at `0xb4b498`, 465 records of 20 bytes:
+//!
+//! | offset | field | what it is |
+//! |---|---|---|
+//! | `+0x00` | [`MessageRecord::key`] | the `GlobalStrings.lua` key, resolved by `FrameScript_GetText` |
+//! | `+0x04` | [`MessageRecord::kind`] | **where it goes** — the four-way jump at `0x496888` ([`MsgKind`]) |
+//! | `+0x08` | [`MessageRecord::sound`] | a sound cue name, or nothing |
+//! | `+0x0c` | [`MessageRecord::type_tag`] | `0x44` = play the cue; anything else is an error-speech id |
+//! | `+0x10` | [`MessageRecord::chat_type`] | the chat type handed to `0x49a870` — read on [`MsgKind::Chat`] only |
+//!
+//! **Why this table is in the tree at all.** benilla names ~160 of these keys across a dozen
+//! modules, and until now every one of them arrived by hand-tracing a `push <id>; call 0x496720`
+//! in the binary and reading the record by eye — the key *and* the surface, carried separately to
+//! the call site, with nothing checking they agreed. That is how [`super::script`]'s petition lines
+//! got their split wrong on the first try (`ui_petition::lines`' own module doc records it), and
+//! it is a tax on every future message. The registry is a **fact about the client**, of exactly the
+//! kind this project already carries as code — opcode numbers, struct offsets, DBC schemas — so it
+//! belongs here as a table, once, instead of being re-derived per call site. Nothing localized
+//! ships with it: the *keys* are `GlobalStrings.lua` identifiers (interface code, decision 1602)
+//! and the text itself is still read at runtime out of the player's own install.
+//!
+//! It is **generated**, never hand-edited — `scripts/gen-message-catalog.py` from wow-5875-re's
+//! `re/ui/message-catalog.tsv`, whose extractor decodes the CRT static initializer
+//! `[0x484ca0, 0x488408)` that fills the table.
+//!
+//! **What the sweep settles that guessing could not:** the split does not follow the key names.
+//! `ERR_PETITION_SIGNED_S` is a chat line and `ERR_PETITION_ALREADY_SIGNED` is a red toast;
+//! `ERR_FISH_ESCAPED` is yellow and `ERR_INV_FULL` is red. 170 rows are [`MsgKind::Chat`], 28 are
+//! [`MsgKind::Info`], 267 are [`MsgKind::Error`] — and **none is the console arm**, which the
+//! dispatcher has and this build's table never reaches (`0x63cb50`'s console lines are called
+//! directly, not through a record), so [`MsgKind`] models three.
+
+mod catalog;
+
+pub use catalog::CATALOG;
+
+/// Where a message is shown — the record's `+0x04`, as the four-way jump at `0x496888` reads it.
+///
+/// The reference's fourth arm (`3` → the debug console `0x63cd00`) has **no tenant in 5875's
+/// table**: no row carries it, so modelling it would be modelling something that cannot happen.
+/// The generator refuses a kind it does not know, so a build whose table did use it would fail
+/// loudly here rather than silently pick a surface.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MsgKind {
+    /// `0` → the chat window, through the shared composer `0x49a870` with the record's own
+    /// [`MessageRecord::chat_type`].
+    Chat,
+    /// `1` → `AddErrorMessage(text, 0)`, which fires `UI_INFO_MESSAGE` (`0xe1`) — the **yellow**
+    /// `UIErrorsFrame` line.
+    Info,
+    /// `2` → `AddErrorMessage(text, 1)`, which fires `UI_ERROR_MESSAGE` (`0xe0`) — the **red**
+    /// `UIErrorsFrame` line. The commonest by a wide margin, which is exactly why guessing it
+    /// usually works and is not good enough.
+    Error,
+}
+
+/// One row of `0xb4b498`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct MessageRecord {
+    /// The message id — the argument `DisplayError` is called with, and this row's index.
+    pub id: u16,
+    /// The `GlobalStrings.lua` key whose text is displayed. An absent or empty string shows
+    /// nothing at all: the reference's own data-suppression face (`0x4967bd`/`0x4967c5`).
+    pub key: &'static str,
+    /// Where it is shown.
+    pub kind: MsgKind,
+    /// The sound cue played with it, or `None` for the 435 silent rows. Carried as data;
+    /// benilla does not wire message cues yet.
+    pub sound: Option<&'static str>,
+    /// `+0x0c`. `0x44` means "play [`Self::sound`]"; the other 56 rows carry an error-speech id
+    /// instead. Unmodelled, recorded.
+    pub type_tag: u8,
+    /// The chat type handed to the composer, meaningful for [`MsgKind::Chat`] rows only. `10`
+    /// (`CHAT_MSG_SYSTEM`) for all but three — the skill-up trio `ERR_PROFICIENCY_GAINED_S`,
+    /// `ERR_SKILL_GAINED_S` and `ERR_SKILL_UP_SI` speak on `23` (`CHAT_MSG_SKILL`).
+    pub chat_type: u8,
+}
+
+/// The record for a message id, or `None` past the table's end — the reference's own bound, the
+/// `cmp id,0x1d1; jge` at `0x49672c`.
+pub fn by_id(id: u16) -> Option<&'static MessageRecord> {
+    CATALOG.get(usize::from(id))
+}
+
+/// The record for a `GlobalStrings` key. Keys are unique across the table (the generator refuses a
+/// duplicate), so this is well defined.
+///
+/// A linear scan, deliberately: this is reached once per *displayed message* — a toast, a system
+/// line — which is a handful per second at the very worst, and a sorted side-table would be one
+/// more generated thing to keep true for no measurable gain.
+pub fn by_key(key: &str) -> Option<&'static MessageRecord> {
+    CATALOG.iter().find(|r| r.key == key)
+}
+
+/// Where a message goes, by key — the one question nearly every caller has.
+///
+/// A key with no row falls back to [`MsgKind::Error`]. That case cannot arise in the reference (a
+/// message is an *index*, so an unknown key is not expressible), so it only ever means benilla
+/// named a key the client does not have; the red line is both the commonest kind and the most
+/// visible place for such a mistake to show itself. `benilla-app`'s
+/// `every_error_key_in_the_source_is_a_catalog_row` test is what keeps it unreachable.
+pub fn kind_of(key: &str) -> MsgKind {
+    by_key(key).map_or(MsgKind::Error, |r| r.kind)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The table is complete and dense, so `CATALOG[id]` is the reference's own addressing.
+    #[test]
+    fn ids_are_dense_and_the_table_is_whole() {
+        assert_eq!(CATALOG.len(), 465);
+        for (i, r) in CATALOG.iter().enumerate() {
+            assert_eq!(usize::from(r.id), i, "row {i} carries id {}", r.id);
+        }
+        assert!(by_id(465).is_none(), "the reference bounds at 0x1d1");
+    }
+
+    /// Keys are unique — [`by_key`] would otherwise be answering an ambiguous question.
+    #[test]
+    fn keys_are_unique() {
+        let mut keys: Vec<&str> = CATALOG.iter().map(|r| r.key).collect();
+        keys.sort_unstable();
+        let n = keys.len();
+        keys.dedup();
+        assert_eq!(keys.len(), n);
+    }
+
+    /// **The split does not follow the key names.** Four rows that a re-implementation reading
+    /// English would sort differently than the binary does — the petition pair that was actually
+    /// got wrong once, and the fishing verdict that sits one id away from two red neighbours.
+    #[test]
+    fn the_surface_is_not_guessable_from_the_key() {
+        assert_eq!(kind_of("ERR_PETITION_SIGNED_S"), MsgKind::Chat);
+        assert_eq!(kind_of("ERR_PETITION_ALREADY_SIGNED"), MsgKind::Error);
+        assert_eq!(kind_of("ERR_FISH_ESCAPED"), MsgKind::Info);
+        assert_eq!(kind_of("ERR_INV_FULL"), MsgKind::Error);
+    }
+
+    /// The three rows that speak on a chat type other than `CHAT_MSG_SYSTEM`.
+    #[test]
+    fn the_skill_up_rows_speak_on_chat_msg_skill() {
+        for key in [
+            "ERR_PROFICIENCY_GAINED_S",
+            "ERR_SKILL_GAINED_S",
+            "ERR_SKILL_UP_SI",
+        ] {
+            let r = by_key(key).expect(key);
+            assert_eq!(r.kind, MsgKind::Chat);
+            assert_eq!(r.chat_type, 23, "{key}");
+        }
+        assert_eq!(by_key("ERR_QUEST_ALREADY_ON").unwrap().chat_type, 10);
+    }
+
+    /// A key the client does not have is not expressible as a message id; the fallback exists so
+    /// that a benilla typo is loud rather than silent.
+    #[test]
+    fn an_unknown_key_falls_back_to_the_red_line() {
+        assert!(by_key("ERR_NOT_A_REAL_MESSAGE").is_none());
+        assert_eq!(kind_of("ERR_NOT_A_REAL_MESSAGE"), MsgKind::Error);
+    }
+}
diff --git a/crates/benilla-ui/src/messages/catalog.rs b/crates/benilla-ui/src/messages/catalog.rs
new file mode 100644
index 00000000..a9053e54
--- /dev/null
+++ b/crates/benilla-ui/src/messages/catalog.rs
@@ -0,0 +1,482 @@
+//! The 5875 message catalog, row for row.
+//!
+//! @generated by `scripts/gen-message-catalog.py` from wow-5875-re `re/ui/message-catalog.tsv`
+//! (itself generated by that repo's `re/ui/extract-message-catalog.py` out of `WoW.exe`).
+//! Do not edit by hand — regenerate.
+
+use super::{MessageRecord, MsgKind};
+
+/// Every row of `0xb4b498`, indexed by message id (the ids are dense `0..465`, so
+/// `CATALOG[id]` *is* the reference's `0xb4b498 + 20*id`).
+///
+/// `rustfmt` is held off so that a regeneration is a no-op diff: one row per line is the shape
+/// this script emits, and a formatter that rewrapped it would make the file drift from its own
+/// generator.
+#[rustfmt::skip]
+pub static CATALOG: [MessageRecord; 465] = [
+    MessageRecord { id: 0, key: "ERR_INV_FULL", kind: MsgKind::Error, sound: None, type_tag: 0x00, chat_type: 10 },
+    MessageRecord { id: 1, key: "ERR_BANK_FULL", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 2, key: "ERR_CANT_EQUIP_LEVEL_I", kind: MsgKind::Error, sound: None, type_tag: 0x02, chat_type: 10 },
+    MessageRecord { id: 3, key: "ERR_CANT_EQUIP_SKILL", kind: MsgKind::Error, sound: None, type_tag: 0x29, chat_type: 10 },
+    MessageRecord { id: 4, key: "ERR_CANT_EQUIP_EVER", kind: MsgKind::Error, sound: None, type_tag: 0x03, chat_type: 10 },
+    MessageRecord { id: 5, key: "ERR_CANT_EQUIP_RANK", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 6, key: "ERR_CANT_EQUIP_REPUTATION", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 7, key: "ERR_PROFICIENCY_NEEDED", kind: MsgKind::Error, sound: None, type_tag: 0x30, chat_type: 10 },
+    MessageRecord { id: 8, key: "ERR_WRONG_SLOT", kind: MsgKind::Error, sound: None, type_tag: 0x1b, chat_type: 10 },
+    MessageRecord { id: 9, key: "ERR_BAG_FULL", kind: MsgKind::Error, sound: None, type_tag: 0x1d, chat_type: 10 },
+    MessageRecord { id: 10, key: "ERR_INTERNAL_BAG_ERROR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 11, key: "ERR_DESTROY_NONEMPTY_BAG", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 12, key: "ERR_BAG_IN_BAG", kind: MsgKind::Error, sound: None, type_tag: 0x1a, chat_type: 10 },
+    MessageRecord { id: 13, key: "ERR_TOO_MANY_SPECIAL_BAGS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 14, key: "ERR_TRADE_EQUIPPED_BAG", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 15, key: "ERR_AMMO_ONLY", kind: MsgKind::Error, sound: None, type_tag: 0x1c, chat_type: 10 },
+    MessageRecord { id: 16, key: "ERR_NO_SLOT_AVAILABLE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 17, key: "ERR_WRONG_BAG_TYPE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 18, key: "ERR_ITEM_MAX_COUNT", kind: MsgKind::Error, sound: None, type_tag: 0x1e, chat_type: 10 },
+    MessageRecord { id: 19, key: "ERR_NOT_EQUIPPABLE", kind: MsgKind::Error, sound: None, type_tag: 0x2c, chat_type: 10 },
+    MessageRecord { id: 20, key: "ERR_CANT_STACK", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 21, key: "ERR_CANT_SWAP", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 22, key: "ERR_SLOT_EMPTY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 23, key: "ERR_ITEM_NOT_FOUND", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 24, key: "ERR_TOO_FEW_TO_SPLIT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 25, key: "ERR_SPLIT_FAILED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 26, key: "ERR_NOT_A_BAG", kind: MsgKind::Error, sound: None, type_tag: 0x19, chat_type: 10 },
+    MessageRecord { id: 27, key: "ERR_NOT_OWNER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 28, key: "ERR_ONLY_ONE_QUIVER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 29, key: "ERR_NO_BANK_SLOT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 30, key: "ERR_NO_BANK_HERE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 31, key: "ERR_ITEM_LOCKED", kind: MsgKind::Error, sound: None, type_tag: 0x3d, chat_type: 10 },
+    MessageRecord { id: 32, key: "ERR_2HANDED_EQUIPPED", kind: MsgKind::Error, sound: None, type_tag: 0x2a, chat_type: 10 },
+    MessageRecord { id: 33, key: "ERR_VENDOR_NOT_INTERESTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 34, key: "ERR_VENDOR_HATES_YOU", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 35, key: "ERR_VENDOR_SOLD_OUT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 36, key: "ERR_VENDOR_TOO_FAR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 37, key: "ERR_NOT_ENOUGH_MONEY", kind: MsgKind::Error, sound: None, type_tag: 0x28, chat_type: 10 },
+    MessageRecord { id: 38, key: "ERR_RECEIVE_ITEM_S", kind: MsgKind::Chat, sound: Some("ITEMGENERICSOUND"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 39, key: "ERR_DROP_BOUND_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x04, chat_type: 10 },
+    MessageRecord { id: 40, key: "ERR_TRADE_BOUND_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x3b, chat_type: 10 },
+    MessageRecord { id: 41, key: "ERR_TRADE_QUEST_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x3b, chat_type: 10 },
+    MessageRecord { id: 42, key: "ERR_TRADE_GROUND_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 43, key: "ERR_TRADE_BAG", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 44, key: "ERR_SPELL_FAILED_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 45, key: "ERR_ITEM_COOLDOWN", kind: MsgKind::Error, sound: None, type_tag: 0x05, chat_type: 10 },
+    MessageRecord { id: 46, key: "ERR_POTION_COOLDOWN", kind: MsgKind::Error, sound: None, type_tag: 0x2f, chat_type: 10 },
+    MessageRecord { id: 47, key: "ERR_FOOD_COOLDOWN", kind: MsgKind::Error, sound: None, type_tag: 0x07, chat_type: 10 },
+    MessageRecord { id: 48, key: "ERR_SPELL_COOLDOWN", kind: MsgKind::Error, sound: None, type_tag: 0x0c, chat_type: 10 },
+    MessageRecord { id: 49, key: "ERR_ABILITY_COOLDOWN", kind: MsgKind::Error, sound: None, type_tag: 0x32, chat_type: 10 },
+    MessageRecord { id: 50, key: "ERR_SPELL_ALREADY_KNOWN_S", kind: MsgKind::Error, sound: None, type_tag: 0x0d, chat_type: 10 },
+    MessageRecord { id: 51, key: "ERR_PET_SPELL_ALREADY_KNOWN_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 52, key: "ERR_PROFICIENCY_GAINED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 23 },
+    MessageRecord { id: 53, key: "ERR_SKILL_GAINED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 23 },
+    MessageRecord { id: 54, key: "ERR_SKILL_UP_SI", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 23 },
+    MessageRecord { id: 55, key: "ERR_LEARN_SPELL_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 56, key: "ERR_LEARN_ABILITY_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 57, key: "ERR_LEARN_RECIPE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 58, key: "ERR_INVITE_PLAYER_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 59, key: "ERR_INVITE_SELF", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 60, key: "ERR_INVITED_TO_GROUP_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 61, key: "ERR_ALREADY_IN_GROUP_S", kind: MsgKind::Chat, sound: None, type_tag: 0x14, chat_type: 10 },
+    MessageRecord { id: 62, key: "ERR_PLAYER_BUSY_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 63, key: "ERR_NEW_LEADER_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 64, key: "ERR_NEW_LEADER_YOU", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 65, key: "ERR_LEFT_GROUP_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 66, key: "ERR_LEFT_GROUP_YOU", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 67, key: "ERR_GROUP_DISBANDED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 68, key: "ERR_DECLINE_GROUP_S", kind: MsgKind::Chat, sound: Some("igPlayerInviteDecline"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 69, key: "ERR_JOINED_GROUP_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 70, key: "ERR_UNINVITE_YOU", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 71, key: "ERR_BAD_PLAYER_NAME_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 72, key: "ERR_NOT_IN_GROUP", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 73, key: "ERR_TARGET_NOT_IN_GROUP_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 74, key: "ERR_GROUP_FULL", kind: MsgKind::Chat, sound: None, type_tag: 0x08, chat_type: 10 },
+    MessageRecord { id: 75, key: "ERR_NOT_LEADER", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 76, key: "ERR_PLAYER_DIED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 77, key: "ERR_GUILD_CREATE_S", kind: MsgKind::Chat, sound: Some("LEVELUP"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 78, key: "ERR_GUILD_INVITE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 79, key: "ERR_INVITED_TO_GUILD_SS", kind: MsgKind::Chat, sound: Some("LEVELUP"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 80, key: "ERR_ALREADY_IN_GUILD_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 81, key: "ERR_ALREADY_INVITED_TO_GUILD_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 82, key: "ERR_INVITED_TO_GUILD", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 83, key: "ERR_ALREADY_IN_GUILD", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 84, key: "ERR_GUILD_ACCEPT", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 85, key: "ERR_GUILD_DECLINE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 86, key: "ERR_GUILD_PERMISSIONS", kind: MsgKind::Chat, sound: None, type_tag: 0x3e, chat_type: 10 },
+    MessageRecord { id: 87, key: "ERR_GUILD_JOIN_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 88, key: "ERR_GUILD_FOUNDER_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 89, key: "ERR_GUILD_PROMOTE_SSS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 90, key: "ERR_GUILD_DEMOTE_SSS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 91, key: "ERR_GUILD_QUIT_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 92, key: "ERR_GUILD_LEAVE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 93, key: "ERR_GUILD_REMOVE_SS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 94, key: "ERR_GUILD_REMOVE_SELF", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 95, key: "ERR_GUILD_DISBAND_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 96, key: "ERR_GUILD_DISBAND_SELF", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 97, key: "ERR_GUILD_LEADER_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 98, key: "ERR_GUILD_LEADER_SELF", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 99, key: "ERR_GUILD_PLAYER_NOT_FOUND_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 100, key: "ERR_GUILD_PLAYER_NOT_IN_GUILD_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 101, key: "ERR_GUILD_PLAYER_NOT_IN_GUILD", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 102, key: "ERR_GUILD_CANT_PROMOTE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 103, key: "ERR_GUILD_CANT_DEMOTE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 104, key: "ERR_GUILD_NOT_IN_A_GUILD", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 105, key: "ERR_GUILD_INTERNAL", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 106, key: "ERR_GUILD_LEADER_IS_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 107, key: "ERR_GUILD_LEADER_CHANGED_SS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 108, key: "ERR_GUILD_DISBANDED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 109, key: "ERR_GUILD_NOT_ALLIED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 110, key: "ERR_GUILD_LEADER_LEAVE", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 111, key: "ERR_GUILD_RANKS_LOCKED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 112, key: "ERR_GUILD_RANK_IN_USE", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 113, key: "ERR_GUILD_RANK_TOO_HIGH_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 114, key: "ERR_GUILD_RANK_TOO_LOW_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 115, key: "ERR_GUILD_NAME_INVALID", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 116, key: "ERR_GUILD_NAME_EXISTS_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 117, key: "ERR_GUILD_ENTER_NAME", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 118, key: "ERR_GUILD_NAME_TOO_SHORT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 119, key: "ERR_GUILD_NAME_MIXED_LANGUAGES", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 120, key: "ERR_GUILD_NAME_PROFANE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 121, key: "ERR_GUILD_NAME_RESERVED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 122, key: "ERR_GUILD_NAME_INVALID_SPACE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 123, key: "ERR_GUILD_NAME_NAME_CONSECUTIVE_SPACES", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 124, key: "ERR_NO_GUILD_CHARTER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 125, key: "ERR_OUT_OF_RANGE", kind: MsgKind::Error, sound: None, type_tag: 0x0a, chat_type: 10 },
+    MessageRecord { id: 126, key: "ERR_PLAYER_DEAD", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 127, key: "ERR_CLIENT_LOCKED_OUT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 128, key: "ERR_KILLED_BY_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 129, key: "ERR_LOOT_LOCKED", kind: MsgKind::Error, sound: None, type_tag: 0x21, chat_type: 10 },
+    MessageRecord { id: 130, key: "ERR_LOOT_TOO_FAR", kind: MsgKind::Error, sound: None, type_tag: 0x23, chat_type: 10 },
+    MessageRecord { id: 131, key: "ERR_LOOT_DIDNT_KILL", kind: MsgKind::Error, sound: None, type_tag: 0x1f, chat_type: 10 },
+    MessageRecord { id: 132, key: "ERR_LOOT_BAD_FACING", kind: MsgKind::Error, sound: None, type_tag: 0x20, chat_type: 10 },
+    MessageRecord { id: 133, key: "ERR_LOOT_NOTSTANDING", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 134, key: "ERR_LOOT_STUNNED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 135, key: "ERR_LOOT_NO_UI", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 136, key: "ERR_LOOT_WHILE_INVULNERABLE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 137, key: "ERR_QUEST_ACCEPTED_S", kind: MsgKind::Chat, sound: Some("QUESTADDED"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 138, key: "ERR_QUEST_COMPLETE_S", kind: MsgKind::Chat, sound: Some("igQuestListComplete"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 139, key: "ERR_QUEST_FAILED_S", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 140, key: "ERR_QUEST_FAILED_BAG_FULL_S", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 141, key: "ERR_QUEST_FAILED_MAX_COUNT_S", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 142, key: "ERR_QUEST_FAILED_LOW_LEVEL", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 143, key: "ERR_QUEST_FAILED_MISSING_ITEMS", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 144, key: "ERR_QUEST_FAILED_WRONG_RACE", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 145, key: "ERR_QUEST_FAILED_NOT_ENOUGH_MONEY", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 146, key: "ERR_QUEST_ONLY_ONE_TIMED", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 147, key: "ERR_QUEST_NEED_PREREQS", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 148, key: "ERR_QUEST_ALREADY_ON", kind: MsgKind::Chat, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 149, key: "ERR_QUEST_REWARD_EXP_I", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 150, key: "ERR_QUEST_REWARD_ITEM_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 151, key: "ERR_QUEST_REWARD_MONEY_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 152, key: "ERR_QUEST_MUST_CHOOSE", kind: MsgKind::Error, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 153, key: "ERR_QUEST_LOG_FULL", kind: MsgKind::Error, sound: Some("igQuestFailed"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 154, key: "ERR_COMBAT_DAMAGE_SSI", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 155, key: "ERR_INSPECT_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 156, key: "ERR_CANT_USE_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x33, chat_type: 10 },
+    MessageRecord { id: 157, key: "ERR_MUST_EQUIP_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x31, chat_type: 10 },
+    MessageRecord { id: 158, key: "ERR_PASSIVE_ABILITY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 159, key: "ERR_2HSKILLNOTFOUND", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 160, key: "ERR_NO_ATTACK_TARGET", kind: MsgKind::Error, sound: None, type_tag: 0x26, chat_type: 10 },
+    MessageRecord { id: 161, key: "ERR_INVALID_ATTACK_TARGET", kind: MsgKind::Error, sound: None, type_tag: 0x0b, chat_type: 10 },
+    MessageRecord { id: 162, key: "ERR_ATTACK_STUNNED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 163, key: "ERR_ATTACK_PACIFIED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 164, key: "ERR_ATTACK_MOUNTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 165, key: "ERR_ATTACK_FLEEING", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 166, key: "ERR_ATTACK_CONFUSED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 167, key: "ERR_ATTACK_CHARMED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 168, key: "ERR_ATTACK_DEAD", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 169, key: "ERR_ATTACK_PREVENTED_BY_MECHANIC_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 170, key: "ERR_TAXISAMENODE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 171, key: "ERR_TAXINOSUCHPATH", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 172, key: "ERR_TAXIUNSPECIFIEDSERVERERROR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 173, key: "ERR_TAXINOTENOUGHMONEY", kind: MsgKind::Info, sound: None, type_tag: 0x36, chat_type: 10 },
+    MessageRecord { id: 174, key: "ERR_TAXITOOFARAWAY", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 175, key: "ERR_TAXINOVENDORNEARBY", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 176, key: "ERR_TAXINOTVISITED", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 177, key: "ERR_TAXIPLAYERBUSY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 178, key: "ERR_TAXIPLAYERALREADYMOUNTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 179, key: "ERR_TAXIPLAYERSHAPESHIFTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 180, key: "ERR_TAXIPLAYERMOVING", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 181, key: "ERR_TAXINOPATHS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 182, key: "ERR_TAXINOTSTANDING", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 183, key: "ERR_NO_REPLY_TARGET", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 184, key: "ERR_GENERIC_NO_TARGET", kind: MsgKind::Error, sound: None, type_tag: 0x2d, chat_type: 10 },
+    MessageRecord { id: 185, key: "ERR_INITIATE_TRADE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 186, key: "ERR_TRADE_REQUEST_S", kind: MsgKind::Chat, sound: Some("LEVELUP"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 187, key: "ERR_TRADE_BLOCKED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 188, key: "ERR_TRADE_TARGET_DEAD", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 189, key: "ERR_TRADE_TOO_FAR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 190, key: "ERR_TRADE_CANCELLED", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 191, key: "ERR_TRADE_COMPLETE", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 192, key: "ERR_TRADE_BAG_FULL", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 193, key: "ERR_TRADE_TARGET_BAG_FULL", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 194, key: "ERR_TRADE_MAX_COUNT_EXCEEDED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 195, key: "ERR_TRADE_TARGET_MAX_COUNT_EXCEEDED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 196, key: "ERR_ALREADY_TRADING", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 197, key: "ERR_MOUNT_INVALIDMOUNTEE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 198, key: "ERR_MOUNT_TOOFARAWAY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 199, key: "ERR_MOUNT_ALREADYMOUNTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 200, key: "ERR_MOUNT_NOTMOUNTABLE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 201, key: "ERR_MOUNT_NOTYOURPET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 202, key: "ERR_MOUNT_OTHER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 203, key: "ERR_MOUNT_LOOTING", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 204, key: "ERR_MOUNT_RACECANTMOUNT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 205, key: "ERR_MOUNT_SHAPESHIFTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 206, key: "ERR_DISMOUNT_NOPET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 207, key: "ERR_DISMOUNT_NOTMOUNTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 208, key: "ERR_DISMOUNT_NOTYOURPET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 209, key: "ERR_SPELL_FAILED_TOTEMS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 210, key: "ERR_SPELL_FAILED_REAGENTS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 211, key: "ERR_SPELL_FAILED_REAGENTS_GENERIC", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 212, key: "ERR_SPELL_FAILED_EQUIPPED_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 213, key: "ERR_SPELL_FAILED_EQUIPPED_ITEM_CLASS_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 214, key: "ERR_SPELL_FAILED_SHAPESHIFT_FORM_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 215, key: "ERR_BADATTACKFACING", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 216, key: "ERR_BADATTACKPOS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 217, key: "ERR_CHEST_IN_USE", kind: MsgKind::Error, sound: None, type_tag: 0x34, chat_type: 10 },
+    MessageRecord { id: 218, key: "ERR_USE_CANT_OPEN", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 219, key: "ERR_USE_LOCKED", kind: MsgKind::Error, sound: None, type_tag: 0x3d, chat_type: 10 },
+    MessageRecord { id: 220, key: "ERR_DOOR_LOCKED", kind: MsgKind::Error, sound: None, type_tag: 0x3d, chat_type: 10 },
+    MessageRecord { id: 221, key: "ERR_BUTTON_LOCKED", kind: MsgKind::Error, sound: None, type_tag: 0x3d, chat_type: 10 },
+    MessageRecord { id: 222, key: "ERR_USE_LOCKED_WITH_ITEM_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 223, key: "ERR_USE_LOCKED_WITH_SPELL_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 224, key: "ERR_USE_LOCKED_WITH_SPELL_KNOWN_SI", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 225, key: "ERR_USE_TOO_FAR", kind: MsgKind::Error, sound: None, type_tag: 0x39, chat_type: 10 },
+    MessageRecord { id: 226, key: "ERR_USE_BAD_ANGLE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 227, key: "ERR_USE_OBJECT_MOVING", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 228, key: "ERR_USE_SPELL_FOCUS", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 229, key: "ERR_USE_DESTROYED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 230, key: "ERR_SET_LOOT_FREEFORALL", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 231, key: "ERR_SET_LOOT_ROUNDROBIN", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 232, key: "ERR_SET_LOOT_MASTER", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 233, key: "ERR_SET_LOOT_GROUP", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 234, key: "ERR_SET_LOOT_NBG", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 235, key: "ERR_SET_LOOT_THRESHOLD_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 236, key: "ERR_NEW_LOOT_MASTER_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 237, key: "ERR_SPECIFY_MASTER_LOOTER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 238, key: "ERR_TAME_FAILED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 239, key: "ERR_CHAT_WHILE_DEAD", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 240, key: "ERR_CHAT_WRONG_FACTION", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 241, key: "ERR_CHAT_PLAYER_NOT_FOUND_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 242, key: "ERR_NEWTAXIPATH", kind: MsgKind::Info, sound: Some("TaxiNodeDiscovered"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 243, key: "ERR_NO_PET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 244, key: "ERR_NOTYOURPET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 245, key: "ERR_PET_NOT_RENAMEABLE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 246, key: "ERR_NULL_PETNAME", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 247, key: "ERR_INVALID_PETNAME", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 248, key: "ERR_QUEST_OBJECTIVE_COMPLETE_S", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 249, key: "ERR_QUEST_UNKNOWN_COMPLETE", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 250, key: "ERR_QUEST_ADD_KILL_SII", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 251, key: "ERR_QUEST_ADD_FOUND_SII", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 252, key: "ERR_QUEST_ADD_ITEM_SII", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 253, key: "ERR_CANNOTCREATEDIRECTORY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 254, key: "ERR_CANNOTCREATEFILE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 255, key: "ERR_PLAYER_WRONG_FACTION", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 256, key: "ERR_BANKSLOT_FAILED_TOO_MANY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 257, key: "ERR_BANKSLOT_INSUFFICIENT_FUNDS", kind: MsgKind::Error, sound: None, type_tag: 0x16, chat_type: 10 },
+    MessageRecord { id: 258, key: "ERR_BANKSLOT_NOTBANKER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 259, key: "ERR_FRIEND_DB_ERROR", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 260, key: "ERR_FRIEND_LIST_FULL", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 261, key: "ERR_FRIEND_ADDED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 262, key: "ERR_FRIEND_ONLINE_SS", kind: MsgKind::Chat, sound: Some("FRIENDJOINGAME"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 263, key: "ERR_FRIEND_OFFLINE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 264, key: "ERR_FRIEND_NOT_FOUND", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 265, key: "ERR_FRIEND_WRONG_FACTION", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 266, key: "ERR_FRIEND_REMOVED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 267, key: "ERR_FRIEND_ERROR", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 268, key: "ERR_FRIEND_ALREADY_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 269, key: "ERR_FRIEND_SELF", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 270, key: "ERR_IGNORE_FULL", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 271, key: "ERR_IGNORE_SELF", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 272, key: "ERR_IGNORE_NOT_FOUND", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 273, key: "ERR_IGNORE_ALREADY_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 274, key: "ERR_IGNORE_ADDED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 275, key: "ERR_IGNORE_REMOVED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 276, key: "ERR_IGNORE_AMBIGUOUS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 277, key: "ERR_ONLY_ONE_BOLT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 278, key: "ERR_ONLY_ONE_AMMO", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 279, key: "ERR_SPELL_FAILED_EQUIPPED_SPECIFIC_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 280, key: "ERR_WRONG_BAG_TYPE_SUBCLASS", kind: MsgKind::Error, sound: None, type_tag: 0x1c, chat_type: 10 },
+    MessageRecord { id: 281, key: "ERR_CANT_WRAP_STACKABLE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 282, key: "ERR_CANT_WRAP_EQUIPPED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 283, key: "ERR_CANT_WRAP_WRAPPED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 284, key: "ERR_CANT_WRAP_BOUND", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 285, key: "ERR_CANT_WRAP_UNIQUE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 286, key: "ERR_CANT_WRAP_BAGS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 287, key: "ERR_OUT_OF_MANA", kind: MsgKind::Error, sound: None, type_tag: 0x0f, chat_type: 10 },
+    MessageRecord { id: 288, key: "ERR_OUT_OF_RAGE", kind: MsgKind::Error, sound: None, type_tag: 0x3f, chat_type: 10 },
+    MessageRecord { id: 289, key: "ERR_OUT_OF_FOCUS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 290, key: "ERR_OUT_OF_ENERGY", kind: MsgKind::Error, sound: None, type_tag: 0x40, chat_type: 10 },
+    MessageRecord { id: 291, key: "ERR_OUT_OF_HEALTH", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 292, key: "ERR_LOOT_GONE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 293, key: "ERR_MOUNT_FORCEDDISMOUNT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 294, key: "ERR_AUTOFOLLOW_TOO_FAR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 295, key: "ERR_UNIT_NOT_FOUND", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 296, key: "ERR_INVALID_FOLLOW_TARGET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 297, key: "ERR_INVALID_INSPECT_TARGET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 298, key: "ERR_GUILDEMBLEM_SUCCESS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 299, key: "ERR_GUILDEMBLEM_INVALID_TABARD_COLORS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 300, key: "ERR_GUILDEMBLEM_NOGUILD", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 301, key: "ERR_GUILDEMBLEM_NOTGUILDMASTER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 302, key: "ERR_GUILDEMBLEM_NOTENOUGHMONEY", kind: MsgKind::Error, sound: None, type_tag: 0x28, chat_type: 10 },
+    MessageRecord { id: 303, key: "ERR_GUILDEMBLEM_INVALIDVENDOR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 304, key: "ERR_EMBLEMERROR_NOTABARDGEOSET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 305, key: "ERR_SPELL_OUT_OF_RANGE", kind: MsgKind::Error, sound: None, type_tag: 0x2e, chat_type: 10 },
+    MessageRecord { id: 306, key: "ERR_COMMAND_NEEDS_TARGET", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 307, key: "ERR_NOAMMO_S", kind: MsgKind::Error, sound: None, type_tag: 0x01, chat_type: 10 },
+    MessageRecord { id: 308, key: "ERR_TOOBUSYTOFOLLOW", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 309, key: "ERR_DUEL_REQUESTED", kind: MsgKind::Chat, sound: Some("LEVELUP"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 310, key: "ERR_DUEL_CANCELLED", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 311, key: "ERR_DEATHBINDALREADYBOUND", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 312, key: "ERR_DEATHBIND_SUCCESS_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 313, key: "ERR_NOEMOTEWHILERUNNING", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 314, key: "ERR_ZONE_EXPLORED", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 315, key: "ERR_ZONE_EXPLORED_XP", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 316, key: "ERR_INVALID_ITEM_TARGET", kind: MsgKind::Error, sound: None, type_tag: 0x33, chat_type: 10 },
+    MessageRecord { id: 317, key: "ERR_IGNORING_YOU_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 318, key: "ERR_FISH_NOT_HOOKED", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 319, key: "ERR_FISH_ESCAPED", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 320, key: "ERR_SPELL_FAILED_NOTUNSHEATHED", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 321, key: "ERR_PETITION_OFFERED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 322, key: "ERR_PETITION_SIGNED", kind: MsgKind::Chat, sound: Some("igPlayerInviteAccept"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 323, key: "ERR_PETITION_SIGNED_S", kind: MsgKind::Chat, sound: Some("igPlayerInviteAccept"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 324, key: "ERR_PETITION_DECLINED_S", kind: MsgKind::Chat, sound: Some("igPlayerInviteDecline"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 325, key: "ERR_PETITION_ALREADY_SIGNED", kind: MsgKind::Error, sound: Some("igPlayerInviteDecline"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 326, key: "ERR_PETITION_IN_GUILD", kind: MsgKind::Error, sound: Some("igPlayerInviteDecline"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 327, key: "ERR_PETITION_CREATOR", kind: MsgKind::Error, sound: Some("igPlayerInviteDecline"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 328, key: "ERR_PETITION_NOT_ENOUGH_SIGNATURES", kind: MsgKind::Error, sound: Some("igPlayerInviteDecline"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 329, key: "ERR_PETITION_NOT_SAME_SERVER", kind: MsgKind::Error, sound: Some("igPlayerInviteDecline"), type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 330, key: "ERR_SPELL_UNLEARNED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 331, key: "ERR_PET_SPELL_ROOTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 332, key: "ERR_PET_SPELL_AFFECTING_COMBAT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 333, key: "ERR_PET_SPELL_OUT_OF_RANGE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 334, key: "ERR_PET_SPELL_NOT_BEHIND", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 335, key: "ERR_PET_SPELL_TARGETS_DEAD", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 336, key: "ERR_PET_SPELL_DEAD", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 337, key: "ERR_PET_SPELL_NOPATH", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 338, key: "ERR_ITEM_CANT_BE_DESTROYED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 339, key: "ERR_TICKET_ALREADY_EXISTS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 340, key: "ERR_TICKET_CREATE_ERROR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 341, key: "ERR_TICKET_UPDATE_ERROR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 342, key: "ERR_TICKET_DB_ERROR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 343, key: "ERR_TICKET_NO_TEXT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 344, key: "ERR_OBJECT_IS_BUSY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 345, key: "ERR_EXHAUSTION_WELLRESTED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 346, key: "ERR_EXHAUSTION_RESTED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 347, key: "ERR_EXHAUSTION_NORMAL", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 348, key: "ERR_EXHAUSTION_TIRED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 349, key: "ERR_EXHAUSTION_EXHAUSTED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 350, key: "ERR_NO_ITEMS_WHILE_SHAPESHIFTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 351, key: "ERR_CANT_INTERACT_SHAPESHIFTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 352, key: "ERR_MAIL_QUEST_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x3b, chat_type: 10 },
+    MessageRecord { id: 353, key: "ERR_MAIL_BOUND_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x3b, chat_type: 10 },
+    MessageRecord { id: 354, key: "ERR_MAIL_CONJURED_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 355, key: "ERR_MAIL_BAG", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 356, key: "ERR_MAIL_TO_SELF", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 357, key: "ERR_MAIL_TARGET_NOT_FOUND", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 358, key: "ERR_MAIL_DATABASE_ERROR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 359, key: "ERR_MAIL_SENT", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 360, key: "ERR_NOT_HAPPY_ENOUGH", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 361, key: "ERR_USE_CANT_IMMUNE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 362, key: "ERR_CANT_BE_DISENCHANTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 363, key: "ERR_CANT_USE_DISARMED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 364, key: "ERR_AUCTION_QUEST_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x3b, chat_type: 10 },
+    MessageRecord { id: 365, key: "ERR_AUCTION_BOUND_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x3b, chat_type: 10 },
+    MessageRecord { id: 366, key: "ERR_AUCTION_CONJURED_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 367, key: "ERR_AUCTION_WRAPPED_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 368, key: "ERR_AUCTION_LOOT_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 369, key: "ERR_AUCTION_BAG", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 370, key: "ERR_AUCTION_DATABASE_ERROR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 371, key: "ERR_AUCTION_BID_OWN", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 372, key: "ERR_AUCTION_BID_INCREMENT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 373, key: "ERR_AUCTION_HIGHER_BID", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 374, key: "ERR_AUCTION_MIN_BID", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 375, key: "ERR_AUCTION_REPAIR_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 376, key: "ERR_AUCTION_STARTED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 377, key: "ERR_AUCTION_REMOVED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 378, key: "ERR_AUCTION_OUTBID_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 379, key: "ERR_AUCTION_WON_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 380, key: "ERR_AUCTION_SOLD_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 381, key: "ERR_AUCTION_EXPIRED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 382, key: "ERR_AUCTION_REMOVED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 383, key: "ERR_AUCTION_BID_PLACED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 384, key: "ERR_LOGOUT_FAILED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 385, key: "ERR_QUEST_PUSH_SUCCESS_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 386, key: "ERR_QUEST_PUSH_INVALID_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 387, key: "ERR_QUEST_PUSH_ACCEPTED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 388, key: "ERR_QUEST_PUSH_DECLINED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 389, key: "ERR_QUEST_PUSH_TOO_FAR_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 390, key: "ERR_QUEST_PUSH_BUSY_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 391, key: "ERR_QUEST_PUSH_LOG_FULL_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 392, key: "ERR_QUEST_PUSH_ONQUEST_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 393, key: "ERR_QUEST_PUSH_ALREADY_DONE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 394, key: "ERR_RAID_GROUP_ONLY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 395, key: "ERR_RAID_GROUP_FULL", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 396, key: "ERR_PVP_KILL_HONORABLE", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 397, key: "ERR_PVP_KILL_DISHONORABLE", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 398, key: "ERR_SPELL_FAILED_ALREADY_AT_FULL_HEALTH", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 399, key: "ERR_SPELL_FAILED_ALREADY_AT_FULL_POWER_S", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 400, key: "ERR_AUTOLOOT_MONEY_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 401, key: "ERR_GENERIC_STUNNED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 402, key: "ERR_TARGET_STUNNED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 403, key: "ERR_MUST_REPAIR_DURABILITY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 404, key: "ERR_RAID_YOU_JOINED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 405, key: "ERR_RAID_YOU_LEFT", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 406, key: "ERR_RAID_MEMBER_ADDED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 407, key: "ERR_RAID_MEMBER_REMOVED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 408, key: "ERR_CLICK_ON_ITEM_TO_FEED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 409, key: "ERR_TOO_MANY_CHAT_CHANNELS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 410, key: "ERR_LOOT_ROLL_PENDING", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 411, key: "ERR_LOOT_PLAYER_NOT_FOUND", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 412, key: "ERR_NOT_IN_RAID", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 413, key: "ERR_LOGGING_OUT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 414, key: "ERR_TARGET_LOGGING_OUT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 415, key: "ERR_NOT_WHILE_MOUNTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 416, key: "ERR_NOT_WHILE_SHAPESHIFTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 417, key: "ERR_NOT_IN_COMBAT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 418, key: "ERR_NOT_WHILE_DISARMED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 419, key: "ERR_PET_BROKEN", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 420, key: "ERR_TALENT_WIPE_ERROR", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 421, key: "ERR_FEIGN_DEATH_RESISTED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 422, key: "ERR_MEETING_STONE_IN_QUEUE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 423, key: "ERR_MEETING_STONE_LEFT_QUEUE_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 424, key: "ERR_MEETING_STONE_OTHER_MEMBER_LEFT", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 425, key: "ERR_MEETING_STONE_PARTY_KICKED_FROM_QUEUE", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 426, key: "ERR_MEETING_STONE_MEMBER_STILL_IN_QUEUE", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 427, key: "ERR_MEETING_STONE_SUCCESS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 428, key: "ERR_MEETING_STONE_IN_PROGRESS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 429, key: "ERR_MEETING_STONE_MEMBER_ADDED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 430, key: "ERR_MEETING_STONE_GROUP_FULL", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 431, key: "ERR_MEETING_STONE_NOT_LEADER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 432, key: "ERR_MEETING_STONE_INVALID_LEVEL", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 433, key: "ERR_MEETING_STONE_MUST_BE_LEADER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 434, key: "ERR_MEETING_STONE_NO_RAID_GROUP", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 435, key: "ERR_GUILDEMBLEM_SAME", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 436, key: "ERR_EQUIP_TRADE_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 437, key: "ERR_PVP_TOGGLE_ON", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 438, key: "ERR_PVP_TOGGLE_OFF", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 439, key: "ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 440, key: "ERR_GROUP_JOIN_BATTLEGROUND_S", kind: MsgKind::Info, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 441, key: "ERR_GROUP_JOIN_BATTLEGROUND_FAIL", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 442, key: "ERR_GROUP_JOIN_BATTLEGROUND_TOO_MANY", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 443, key: "ERR_INVALID_PROMOTION_CODE", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 444, key: "ERR_BG_PLAYER_JOINED_SS", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 445, key: "ERR_BG_PLAYER_LEFT_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 446, key: "ERR_RESTRICTED_ACCOUNT", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 447, key: "ERR_PLAY_TIME_EXCEEDED", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 448, key: "ERR_APPROACHING_PARTIAL_PLAY_TIME", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 449, key: "ERR_APPROACHING_NO_PLAY_TIME", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 450, key: "ERR_UNHEALTHY_TIME", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 451, key: "ERR_CHAT_RESTRICTED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 452, key: "ERR_MAIL_REACHED_CAP", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 453, key: "ERR_INVALID_RAID_TARGET", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 454, key: "ERR_RAID_LEADER_READY_CHECK_START_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 455, key: "ERR_READY_CHECK_IN_PROGRESS", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 456, key: "ERR_DUNGEON_DIFFICULTY_FAILED", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 457, key: "ERR_DUNGEON_DIFFICULTY_CHANGED_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 458, key: "ERR_TRADE_WRONG_REALM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 459, key: "ERR_CHAT_PLAYER_AMBIGUOUS_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 460, key: "ERR_LOOT_CANT_LOOT_THAT_NOW", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 461, key: "ERR_LOOT_MASTER_INV_FULL", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 462, key: "ERR_LOOT_MASTER_UNIQUE_ITEM", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 463, key: "ERR_LOOT_MASTER_OTHER", kind: MsgKind::Error, sound: None, type_tag: 0x44, chat_type: 10 },
+    MessageRecord { id: 464, key: "ERR_FILTERING_YOU_S", kind: MsgKind::Chat, sound: None, type_tag: 0x44, chat_type: 10 },
+];