diff --git a/crates/benilla-app/assets/ui/ContainerFrameAdapters.xml b/crates/benilla-app/assets/ui/ContainerFrameAdapters.xml
index dbf4261d2..bb62cd9b8 100644
--- a/crates/benilla-app/assets/ui/ContainerFrameAdapters.xml
+++ b/crates/benilla-app/assets/ui/ContainerFrameAdapters.xml
@@ -6,11 +6,12 @@
 <Ui xmlns="http://www.blizzard.com/wow/ui/">
     <Script><![CDATA[
         -- ══ The two bag verbs benilla answers differently ═════════════════════════════════════
-        -- Deviation: `OpenBackpack` opens every equipped bag, not only the backpack, so the vendor
-        -- and mailbox windows that call it (MerchantFrame.lua:35, MailFrame.lua:39) bring up every
-        -- bag to sell or mail from. The was-open memory is keyed by bag id: `ContainerFrame1..12`
-        -- are recycled across bags. The stock `CloseAllBags` (ContainerFrame.lua:702-707) runs
-        -- unchanged: it calls this `CloseBackpack`, then closes bags 1 and up.
+        -- Deviation: `OpenBackpack` opens every equipped bag, not only the backpack, because that
+        -- way the vendor and mailbox windows that call it (MerchantFrame.lua:35, MailFrame.lua:39)
+        -- bring up every bag to sell or mail from. The was-open memory is keyed by bag id:
+        -- `ContainerFrame1..12` are recycled across bags. The stock `CloseAllBags`
+        -- (ContainerFrame.lua:702-707) runs unchanged: it calls this `CloseBackpack`, then closes
+        -- bags 1 and up.
         BENILLA_BAG_WAS_OPEN = {}
 
         -- The reference's `backpackWasOpen`, one entry per bag: CloseBackpack leaves those open.
diff --git a/crates/benilla-app/assets/ui/FrameXMLFixes.xml b/crates/benilla-app/assets/ui/FrameXMLFixes.xml
index 0d42f81bd..c19de9857 100644
--- a/crates/benilla-app/assets/ui/FrameXMLFixes.xml
+++ b/crates/benilla-app/assets/ui/FrameXMLFixes.xml
@@ -7,7 +7,7 @@
         -- oldAlpha even under a live hover, so leaving and re-entering within
         -- CHAT_FRAME_FADE_TIME (a flick to the scroll buttons, outside the hover box, does it)
         -- stops the plate fading in (l.873) for the rest of the session; this keeps oldAlpha while
-        -- hover is set.
+        -- hover is set because the stock one nils it even under a live hover.
         if FCF_ChatTabFadeFinished then
             function FCF_ChatTabFadeFinished(chatTab, chatFrame)
                 chatTab:Hide()
@@ -18,9 +18,9 @@
         end
 
         -- Deviation: re-runs UIParent_ManageFramePositions after DurabilityFrame's own OnEvent. The
-        -- pass seats the frame 20 further in while a side glyph shows (UIParent.lua:1759-1768),
-        -- but the stock frame runs it only from OnShow/OnHide, so a glyph appearing while the frame
-        -- is shown leaves the shield's overhang off the screen edge. The stock handler runs first,
+        -- pass seats the frame 20 further in while a side glyph shows (UIParent.lua:1759-1768); a
+        -- glyph appearing while the frame is shown leaves the shield's overhang off the screen edge
+        -- because the stock frame runs it only from OnShow/OnHide. The stock handler runs first,
         -- unchanged, on the this/event/arg1 already set for the dispatch.
         if DurabilityFrame then
             local refOnEvent = DurabilityFrame:GetScript("OnEvent")
@@ -30,9 +30,9 @@
             end)
         end
 
-        -- Deviation: friendly plates the player turned on come back at every world entry. The
-        -- stock UpdateNameplates (UIOptionsFrame.lua:768-780) shows them and hides them again at
-        -- once (l.775-776), and FRIENDNAMEPLATES_ON is never saved, since l.182 registers
+        -- Deviation: friendly plates the player turned on come back at every world entry; the stock
+        -- UpdateNameplates (UIOptionsFrame.lua:768-780) shows them and hides them again
+        -- at once (l.775-776), and FRIENDNAMEPLATES_ON is never saved because l.182 registers
         -- NAMEPLATES_ON a second time.
         function UpdateNameplates()
             if ( NAMEPLATES_ON ) then
@@ -49,7 +49,7 @@
         RegisterForSave("FRIENDNAMEPLATES_ON")
 
         -- Deviation: a button whose key moved away keeps the old key's label while it holds an
-        -- action with no range (a stance, a self buff). The stock ActionButton_UpdateHotkeys
+        -- action with no range (a stance, a self buff) because the stock ActionButton_UpdateHotkeys
         -- (ActionButton.lua:129-140) writes no text in that one unbound case; this clears it. The
         -- stock function runs first, unchanged.
         local refUpdateHotkeys = ActionButton_UpdateHotkeys
diff --git a/crates/benilla-app/assets/ui/OptionsFrame.xml b/crates/benilla-app/assets/ui/OptionsFrame.xml
index 6bd34b5de..159631509 100644
--- a/crates/benilla-app/assets/ui/OptionsFrame.xml
+++ b/crates/benilla-app/assets/ui/OptionsFrame.xml
@@ -1,10 +1,11 @@
 <Ui>
     <!--
         The Options window the game menu opens. Deviation: the 1.15 era client's single settings
-        window replaces the 1.12 four-panel family, which is much worse to use; the 1.12 frames
-        still load, hidden, for addons. Every art byte is 1.12-native or a colour fill, so era
-        names below cite geometry only. Hiding discards pending edits and Apply commits outright.
-        A slider shows the 1.12 range; an out-of-range value displays clamped, not written back.
+        window replaces the 1.12 four-panel family because that is much worse to use; the 1.12
+        frames still load, hidden, for addons. Every art byte is 1.12-native or a colour fill, so
+        era names below cite geometry only. Hiding discards pending edits and Apply commits
+        outright. A slider shows the 1.12 range; an out-of-range value displays clamped, not written
+        back.
     -->
 
     <!-- The era's 14 and 20 white fonts, outside Fonts.xml's 1.12 set; MasterFont's shadow. -->
@@ -28,8 +29,8 @@
     <Script><![CDATA[
         -- UIOptionsFrame.xml loads first and owns the uvars; each row captures its default at
         -- OnLoad.
-        -- Deviation: AUTO_QUEST_WATCH is the string "1". 1.12 assigns the number 1 (l.122) but
-        -- every consumer compares against "1" (QuestLogFrame.lua:64/68); 1 ~= "1" in Lua 5.0.
+        -- Deviation: AUTO_QUEST_WATCH is the string "1" because 1.12 assigns the number 1 (l.122)
+        -- but every consumer compares against "1" (QuestLogFrame.lua:64/68); 1 ~= "1" in Lua 5.0.
         AUTO_QUEST_WATCH = "1"
         RegisterForSave("AUTO_QUEST_WATCH")
 
@@ -495,8 +496,8 @@
                 "RowGuildMemberAlert", "RowRemoveChatDelay", "RowChatBubbles", "RowLootSpam",
                 "RowPartyChatBubbles", "RowSpamFilter",
             },
-            -- Deviation: the bar toggles precede the lock, which 1.12's box leads with, so what is
-            -- on screen reads first.
+            -- Deviation: the bar toggles precede the lock, which 1.12's box leads with, because
+            -- that way what is on screen reads first.
             ActionBars = {
                 "RowMultiBar1", "RowMultiBar2", "RowMultiBar3", "RowMultiBar4",
                 "RowAlwaysShowMultibars", "RowLockActionBar",
@@ -628,8 +629,8 @@
             row.fmt = fmt
             -- Kept for the "travel" readout, a share of the row's own range.
             row.minv, row.maxv = min, max
-            -- Deviation: a named ladder reads out its stop; 1.12's slider labels only its ends, and
-            -- a bare index would mean nothing to a player.
+            -- Deviation: a named ladder reads out its stop because 1.12's slider labels only its
+            -- ends, and a bare index would mean nothing to a player.
             row.stops = stops
             row.refreshing = 1
             slider:SetMinMaxValues(min, max)
@@ -743,8 +744,8 @@
                 GameTooltip:SetOwner(getglobal(row:GetName() .. "Tip"), "ANCHOR_RIGHT", -10, 0)
                 GameTooltip:SetText(text, nil, nil, nil, nil, 1)
             else
-                -- Deviation: 1.12 returns early here; a mute row hides the last plate, so a
-                -- neighbour's text cannot stand when its OnLeave was missed.
+                -- Deviation: 1.12 returns early here; a mute row hides the last plate because
+                -- otherwise a neighbour's text stands when its OnLeave was missed.
                 GameTooltip:Hide()
             end
         end
@@ -1695,8 +1696,8 @@
                                             </OnLoad></Scripts>
                                         </Frame>
                                         <!-- UIOptionsFrameSliders row 2. Deviation: no partner
-                                             write of cameraPitchSmoothSpeed, which has no reader:
-                                             the follow here has one rate. -->
+                                             write of cameraPitchSmoothSpeed because it has no
+                                             reader: the follow here has one rate. -->
                                         <Frame name="$parentRowAutoFollowSpeed" inherits="BenillaOptionsSliderRowTemplate">
                                             <Anchors>
                                                 <Anchor point="TOPLEFT" relativeTo="$parentRowHeadBob" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
@@ -1981,7 +1982,7 @@
                                             </Anchors>
                                             <Scripts><OnLoad>
                                                 -- Deviation: modern Classic's two-entry Display
-                                                -- Mode, as there is no exclusive fullscreen;
+                                                -- Mode, because there is no exclusive fullscreen;
                                                 -- gxWindow "0" is the borderless window.
                                                 BenillaOptionsRow_OnLoad(this, "gxWindow", "Display Mode",
                                                     "BENILLA_TOOLTIP_DISPLAY_MODE")
@@ -2010,7 +2011,7 @@
                                             </Anchors>
                                             <Scripts><OnLoad>
                                                 -- Deviation: our own row (the reference draws to
-                                                -- the backbuffer), and no Multisampling, which
+                                                -- the backbuffer), and no Multisampling because it
                                                 -- misses alpha-tested cutouts. Deferred: a write
                                                 -- rebuilds the render target.
                                                 BenillaOptionsRow_OnLoad(this, "renderScale", "Render Scale",
diff --git a/crates/benilla-app/assets/ui/ScriptLogFrame.xml b/crates/benilla-app/assets/ui/ScriptLogFrame.xml
index c11b5f066..59cfa695c 100644
--- a/crates/benilla-app/assets/ui/ScriptLogFrame.xml
+++ b/crates/benilla-app/assets/ui/ScriptLogFrame.xml
@@ -379,7 +379,8 @@
          declares SlashCmdList. -->
     <Script><![CDATA[
         -- Deviation: 1.12 has no `/reload` (later clients added it; 1.12 reloads through
-        -- `/console reloadui`); kept so a player can reload the interface after toggling addons.
+        -- `/console reloadui`); kept because it lets a player reload the interface after toggling
+        -- addons.
         SLASH_BENILLA_RELOAD1 = "/reload"
         SlashCmdList["BENILLA_RELOAD"] = function()
             ReloadUI()
diff --git a/crates/benilla-app/assets/ui/SpellBookAdapters.xml b/crates/benilla-app/assets/ui/SpellBookAdapters.xml
index 67ce0e97e..e7e9a3bc2 100644
--- a/crates/benilla-app/assets/ui/SpellBookAdapters.xml
+++ b/crates/benilla-app/assets/ui/SpellBookAdapters.xml
@@ -1,7 +1,7 @@
 <Ui>
     <!--
-        Deviation: the pet page's autocast widgets take the pet bar button's proportions, so the
-        shine and the corner brackets sit on the button's edge and share its centre. Stock
+        Deviation: the pet page's autocast widgets take the pet bar button's proportions because
+        that seats the shine and the corner brackets on the button's edge, sharing its centre. Stock
         SpellBookFrame.xml has the shine 36x36 at CENTER (1,1), scale 1.22, the brackets 60; 71.53
         is 37 x 58/30 (the art fills 33/64 of UI-AutoCastableOverlay.blp).
     -->
diff --git a/crates/benilla-app/src/bindings.rs b/crates/benilla-app/src/bindings.rs
index 6988a9e50..4c9a9fc3c 100644
--- a/crates/benilla-app/src/bindings.rs
+++ b/crates/benilla-app/src/bindings.rs
@@ -16,10 +16,10 @@
 //! - what the bodies call reaches the engine through the Lua binding functions
 //!   ([`benilla_ui::script::BindingInput`]) as [`BindingsState`]'s [`Input`]s.
 //!
-//! Deviation: a press with Super (Cmd) held runs no binding, so a system chord such as Cmd+Tab or
-//! Cmd+Q never acts in game. The reference has no such modifier and runs the bare key's binding:
-//! the Mac enqueues the key with Command held and skips only its text (`0x8a519`), and Windows
-//! hands `VK_LWIN`/`VK_RWIN` to the layout arm (`0x42da39`) like any key.
+//! Deviation: a press with Super (Cmd) held runs no binding because that way a system chord such as
+//! Cmd+Tab or Cmd+Q never acts in game. The reference has no such modifier and runs the bare key's
+//! binding: the Mac enqueues the key with Command held and skips only its text (`0x8a519`), and
+//! Windows hands `VK_LWIN`/`VK_RWIN` to the layout arm (`0x42da39`) like any key.
 //!
 //! Persistence: `benilla-config/bindings/account.txt` and `<Realm>-<Char>.txt` ([`store`]); the
 //! character file's existence is the character-set state, as in the reference.
@@ -636,8 +636,8 @@ pub(crate) fn world_takes_wheel(dispatch: Option<&BindingDispatch>, mods: Mods,
 ///
 /// Deviation: a trackpad's `Pixel` deltas are carried until they make a line, and step at most
 /// once per event ([`crate::ui_script::Record::Wheel`]). The reference steps on every
-/// `WM_MOUSEWHEEL`, whatever its delta (`0x76c1a9`); carried, a trackpad does not zoom or scroll
-/// at its event rate.
+/// `WM_MOUSEWHEEL`, whatever its delta (`0x76c1a9`); the carry is kept because a carried trackpad
+/// does not zoom or scroll at its event rate.
 ///
 /// For consumers that act per notch off the sign alone: the UI's `OnMouseWheel` (stock
 /// `ScrollFrameTemplate_OnMouseWheel` moves half a pane per call, `UIPanelTemplates.lua:150`) and
diff --git a/crates/benilla-app/src/bindings/chord.rs b/crates/benilla-app/src/bindings/chord.rs
index a4fec770c..82617c390 100644
--- a/crates/benilla-app/src/bindings/chord.rs
+++ b/crates/benilla-app/src/bindings/chord.rs
@@ -163,7 +163,8 @@ fn fixed_name(k: KeyCode) -> Option<KeyName> {
         F13 => Word("PRINTSCREEN"),
         // `IsValidBindingKeyString` accepts `F` + any digits (`0x846c04`) and the Mac table maps
         // keycode `0x6A` to `F16` (`0x30d`). Deviation: the Windows key table stops at `VK_F12`
-        // and drops later F-keys; they are named here so a stored `F13`-`F24` can be pressed.
+        // and drops later F-keys; they are named here because that way a stored `F13`-`F24` can be
+        // pressed.
         #[cfg(not(target_os = "macos"))]
         F13 => Word("F13"),
         // On a Mac F14 and F15 are ScrollLock and Pause: keycodes `0x6B` and `0x71` map to
diff --git a/crates/benilla-app/src/bindings/layout.rs b/crates/benilla-app/src/bindings/layout.rs
index f40525fc4..97b52b34b 100644
--- a/crates/benilla-app/src/bindings/layout.rs
+++ b/crates/benilla-app/src/bindings/layout.rs
@@ -213,10 +213,10 @@ fn one_char(key: &winit::keyboard::Key) -> Option<char> {
 /// The reference's name for the virtual key `vk`, given `MapVirtualKeyExW(vk, MAPVK_VK_TO_CHAR)`;
 /// `None` for a key `0x42d800`'s fixed table names.
 ///
-/// Deviation: a character above U+00FF names the key by itself. The reference's `MapVirtualKeyA`
-/// returns an ANSI code-page byte, which `0x42da4b` drops past `0xff` and the namer's UTF-8
-/// encoder (`0x41abb0`) otherwise reads as Latin-1, so such a key is mislabelled or dropped; named
-/// by what it types, it stays bindable and readable.
+/// Deviation: a character above U+00FF names the key by itself because the reference's
+/// `MapVirtualKeyA` returns an ANSI code-page byte, which `0x42da4b` drops past `0xff` and the
+/// namer's UTF-8 encoder (`0x41abb0`) otherwise reads as Latin-1, so such a key is mislabelled or
+/// dropped; named by what it types, it stays bindable and readable.
 #[cfg(any(target_os = "windows", test))]
 fn windows_name(vk: u32, to_char: u32) -> Option<LayoutName> {
     match vk {
@@ -288,11 +288,12 @@ mod windows {
 /// `KeyTranslate` gives the reference, or none.
 ///
 /// Deviation: a layout that is not ASCII-capable (Hebrew, Greek, Russian, Arabic, Thai) names its
-/// keys through the ASCII-capable layout macOS pairs with it, as macOS names its own shortcuts. The
-/// reference reads a non-Roman `KCHR`'s byte as MacRoman (`0x8a40f`), which names no real key.
+/// keys through the ASCII-capable layout macOS pairs with it, as macOS names its own shortcuts,
+/// because the reference reads a non-Roman `KCHR`'s byte as MacRoman (`0x8a40f`), which names no
+/// real key.
 ///
-/// Deviation: a character above U+00FF (Czech `ě`, Polish `ł`, Turkish `ş`) names the key by
-/// itself. The reference reads `KeyTranslate`'s byte as MacRoman (`0x8a40f`) and keeps it only if
+/// Deviation: a character above U+00FF (Czech `ě`, Polish `ł`, Turkish `ş`) names the key by itself
+/// because the reference reads `KeyTranslate`'s byte as MacRoman (`0x8a40f`) and keeps it only if
 /// it converts to Latin-1 (`CFStringGetBytes`, `0x8a46b`, stored at `0x8a482`), else leaves the
 /// slot `-1`, which `0x8a4aa` drops, so such a key is mislabelled or dropped; named by what it
 /// types, it stays bindable and readable.
diff --git a/crates/benilla-app/src/camera_shake.rs b/crates/benilla-app/src/camera_shake.rs
index 0a26a9681..b6daf0bf5 100644
--- a/crates/benilla-app/src/camera_shake.rs
+++ b/crates/benilla-app/src/camera_shake.rs
@@ -287,9 +287,9 @@ fn fire_shakes(
 /// Fire the shake group a spell-visual kit's field 14 names, once per kit play, with no stage test
 /// and no cancel (`0x620e11`, or `0x60f4e6` when the play created no effect node).
 ///
-/// Deviation: the shake spawns at the kit play's position. The reference passes `&node+0x48` to
-/// the shake (`0x620e0e`) before `0x62101d` fills it from the attachment, so a bone-attached first
-/// node (`0x61fdd0`, which never writes it) shakes at the world origin its constructor left
+/// Deviation: the shake spawns at the kit play's position because the reference passes `&node+0x48`
+/// to the shake (`0x620e0e`) before `0x62101d` fills it from the attachment, so a bone-attached
+/// first node (`0x61fdd0`, which never writes it) shakes at the world origin its constructor left
 /// (`0x61f4c1`) and is culled beyond 80 yards of it, silencing 26 of the 58 shipped shake kits;
 /// that is a read before the write, not a behaviour.
 fn fire_kit_shakes(
diff --git a/crates/benilla-app/src/chat_bubble.rs b/crates/benilla-app/src/chat_bubble.rs
index c818cbb48..eafc0de8e 100644
--- a/crates/benilla-app/src/chat_bubble.rs
+++ b/crates/benilla-app/src/chat_bubble.rs
@@ -22,7 +22,7 @@
 //! but the wire-type remap (`0x49a870`) that would admit other kinds is untraced.
 //!
 //! Deviation: sizes ride the plates' damped diagonal basis ([`plate_basis`]), not the unbounded
-//! reference law, so bubble text and plate text keep one em at every window size.
+//! reference law, because that way bubble text and plate text keep one em at every window size.
 //!
 //! Not built: the reference also ends a bubble whose speaker's model data is not resident
 //! (`0x7103d0`); here a speaker with no model yet only counts as not drawn.
diff --git a/crates/benilla-app/src/cinematic.rs b/crates/benilla-app/src/cinematic.rs
index cc4882495..2f2c6208c 100644
--- a/crates/benilla-app/src/cinematic.rs
+++ b/crates/benilla-app/src/cinematic.rs
@@ -184,8 +184,8 @@ impl Cinematic {
 }
 
 /// One of the two letterbox bars, full-width black, top or bottom.
-/// Deviation: Bevy UI nodes computed per frame, not `CinematicFrame.xml`'s textures, so a window
-/// resized mid-cinematic stays letterboxed. `CinematicFrame` still shows and owns ESC.
+/// Deviation: Bevy UI nodes computed per frame, not `CinematicFrame.xml`'s textures, because that
+/// way a window resized mid-cinematic stays letterboxed. `CinematicFrame` still shows and owns ESC.
 #[derive(Component)]
 struct LetterboxBar;
 
diff --git a/crates/benilla-app/src/combat_text/mod.rs b/crates/benilla-app/src/combat_text/mod.rs
index ec135c5b5..9f69de8d5 100644
--- a/crates/benilla-app/src/combat_text/mod.rs
+++ b/crates/benilla-app/src/combat_text/mod.rs
@@ -271,7 +271,7 @@ pub(crate) fn float_combat_text(
         let size_value = scale_value(t.category, life);
         let target_px = text_px(size_value, viewport);
         // Deviation: the reference stretches a raster of at most 32 px; each whole-pixel size is
-        // rasterized here, so the crit pop stays crisp.
+        // rasterized here because that way the crit pop stays crisp.
         let mut e = atlas.lock();
         let mut glyphs = layout_text_quads(
             &mut e,
diff --git a/crates/benilla-app/src/console.rs b/crates/benilla-app/src/console.rs
index 4dcf8784b..3275f3d46 100644
--- a/crates/benilla-app/src/console.rs
+++ b/crates/benilla-app/src/console.rs
@@ -465,15 +465,16 @@ const HELP_COMMAND_LINE: usize = 0xc4;
 /// - Anything else prints nothing.
 ///
 /// Deviation: a line of eight names is not left with its trailing `, ` and a list of a multiple
-/// of eight names is not followed by `NONE`, two slips of the reference's loop (`0x63ffed`,
-/// `0x64004d`). The commands list in registration order, then the CVars in the registry's list
-/// order, where the reference's one table interleaves them as start-up registers them.
+/// of eight names is not followed by `NONE`, because those are two slips of the reference's loop
+/// (`0x63ffed`, `0x64004d`). The commands list in registration order, then the CVars in the
+/// registry's list order, where the reference's one table interleaves them as start-up registers
+/// them.
 ///
 /// Deviation: a CVar lists under its registration's category with its registration's help, even
-/// when `config.toml` held it at boot. In the reference such a record was made by the config
-/// line's `set` (`0x63d569`-`0x63d582`), which registered its command in category 5 with the help
-/// `""` (`0x63ddc9`), and the later registration finds the record and returns without registering
-/// again (`0x63dc1a`-`0x63dc87`), so what `help` says would hang on what the file held.
+/// when `config.toml` held it at boot, because in the reference such a record was made by the
+/// config line's `set` (`0x63d569`-`0x63d582`), which registered its command in category 5 with the
+/// help `""` (`0x63ddc9`), and the later registration finds the record and returns without
+/// registering again (`0x63dc1a`-`0x63dc87`), so what `help` says would hang on what the file held.
 fn help(steps: &mut ConsoleSteps, args: &str) -> Vec<String> {
     if args.is_empty() {
         return vec![
diff --git a/crates/benilla-app/src/creature_anim/spell_visual.rs b/crates/benilla-app/src/creature_anim/spell_visual.rs
index e2ba7f543..397bca0a0 100644
--- a/crates/benilla-app/src/creature_anim/spell_visual.rs
+++ b/crates/benilla-app/src/creature_anim/spell_visual.rs
@@ -1349,9 +1349,9 @@ pub(crate) fn arm_aura_state_fx(
         // (`0x604e7b`-`0x604e85`), so the highest new slot's effect ends at the head.
         //
         // Deviation: a spell's state kit and body procs are reaped only once no slot holds the
-        // spell. The reference's removal of one slot (`0x612320` → `0x5ff290`) stops every
+        // spell because the reference's removal of one slot (`0x612320` → `0x5ff290`) stops every
         // effect of that spell on the unit (`0x614150(spell, 1)` at `0x5ff2d2`, and its procs
-        // through `0x60d150` and `0x5ff320`), even while another slot holds the same spell: it
+        // through `0x60d150` and `0x5ff320`), even while another slot holds the same spell, which
         // drops a visual the server says still holds.
         let mut cur: Vec<u32> = Vec::new();
         for a in store.0.unit_auras() {
diff --git a/crates/benilla-app/src/cvars/mod.rs b/crates/benilla-app/src/cvars/mod.rs
index f9066972a..243f023f0 100644
--- a/crates/benilla-app/src/cvars/mod.rs
+++ b/crates/benilla-app/src/cvars/mod.rs
@@ -1169,7 +1169,8 @@ const HEADER: &str = "\
 /// Dirty and one quiet second since the last change: save, so a crash loses at most that second.
 /// Deviation: the reference's `SaveConfig` (`0x63d980`) writes only at world entry (`0x46b6f6`),
 /// at the leave-world tail (`0x490c35`-`0x490c64`) and at shutdown (`0x63daf0`), so a crash or a
-/// kill loses every change since; here a player's settings survive one.
+/// kill loses every change since; here a player's settings survive one because the config saves a
+/// quiet second after a change.
 fn save_config_when_quiet(mut cvars: ResMut<Cvars>) {
     if cvars.dirty && cvars.last_change.is_none_or(|t| t.elapsed() >= SAVE_QUIET) {
         write_config(&mut cvars);
diff --git a/crates/benilla-app/src/death/mod.rs b/crates/benilla-app/src/death/mod.rs
index 982629d58..cac616b90 100644
--- a/crates/benilla-app/src/death/mod.rs
+++ b/crates/benilla-app/src/death/mod.rs
@@ -306,8 +306,9 @@ pub(crate) fn poll_corpse(mut vm: crate::script_calls::VmWith<CorpsePoll>) {
         let corpse = death_net.corpse.as_ref();
         let in_range = corpse.is_some_and(|cp| {
             // Deviation: `0x492130` compares the positions whatever map we stand on, so a
-            // ghost on another map at the corpse's coordinates reads in range for a reclaim
-            // the server refuses; here only the corpse's display map counts.
+            // ghost on another map at the corpse's coordinates reads in range for a reclaim the
+            // server refuses; here only the corpse's display map counts because the server refuses
+            // that reclaim.
             let on_display_map = map
                 .as_ref()
                 .is_some_and(|m| m.0 == u32::try_from(cp.display_map).unwrap_or(u32::MAX));
diff --git a/crates/benilla-app/src/entities/chain_beam.rs b/crates/benilla-app/src/entities/chain_beam.rs
index f58ffb702..3c64165b1 100644
--- a/crates/benilla-app/src/entities/chain_beam.rs
+++ b/crates/benilla-app/src/entities/chain_beam.rs
@@ -51,8 +51,9 @@ const PERP_EPSILON: f32 = 0.001;
 /// (`0x7afc10`/`0x7afc38`), which makes the per-frame re-roll crawl rather than strobe.
 const ADVECT_KEEP: f32 = 0.75;
 
-/// Deviation: a cap on one hop's sub-segment count, which the reference lacks, so a vertex run is
-/// never sized off table data alone; shipped rows peak at 12 (30 yd at `avgSegLen` 2.78).
+/// Deviation: a cap on one hop's sub-segment count, which the reference lacks, because that way a
+/// vertex run is never sized off table data alone; shipped rows peak at 12 (30 yd at `avgSegLen`
+/// 2.78).
 const MAX_SUBDIVISIONS: usize = 256;
 
 /// The caster's chain-target hop array, the reference's growable `unit+0xd44`: guids in wire
diff --git a/crates/benilla-app/src/entities/conform.rs b/crates/benilla-app/src/entities/conform.rs
index 9058b2951..5b1cc2e8d 100644
--- a/crates/benilla-app/src/entities/conform.rs
+++ b/crates/benilla-app/src/entities/conform.rs
@@ -65,9 +65,10 @@ fn conform_rotation(mode: u8, n_local: Vec3) -> Quat {
 /// `CMovement+0x24`; the two agree on a uniform slope), smoothed on the up-vector.
 ///
 /// Deviation: the reference updates every unit every frame; here only units showing a flagged
-/// visual are tracked, and a parked rig skips its ray and re-seeds at the slope on waking, to bound
-/// the cost at one ray per flagged unit on screen. Nothing shows: an unflagged unit's vector is
-/// never read, and a first-sight seed at the slope seats a mount-up at once, as the reference does.
+/// visual are tracked, and a parked rig skips its ray and re-seeds at the slope on waking, because
+/// that bounds the cost at one ray per flagged unit on screen. Nothing shows: an unflagged unit's
+/// vector is never read, and a first-sight seed at the slope seats a mount-up at once, as the
+/// reference does.
 #[allow(clippy::type_complexity)] // one Bevy system's full input set
 pub(super) fn conform_units(
     time: Res<Time>,
diff --git a/crates/benilla-app/src/entities/equipment/resolve.rs b/crates/benilla-app/src/entities/equipment/resolve.rs
index 370c49e3b..133009767 100644
--- a/crates/benilla-app/src/entities/equipment/resolve.rs
+++ b/crates/benilla-app/src/entities/equipment/resolve.rs
@@ -178,8 +178,9 @@ pub(crate) struct DressKey {
     pub(crate) display_id: Option<u32>,
     /// Mainhand, offhand, ranged: the display id, model kind and folded enchant ids.
     pub(crate) held: [Option<(u32, ItemModelKind, i32)>; HELD_SLOTS],
-    /// Every placed weapon's model has built parts. Deviation: the reference copies a finished
-    /// model, ours stream in, so while false the pane keeps re-taking and a late weapon is baked.
+    /// Every placed weapon's model has built parts. Deviation: while false the pane keeps re-taking
+    /// and a late weapon is baked, because the reference copies a finished model and ours stream
+    /// in.
     pub(crate) held_ready: bool,
 }
 
diff --git a/crates/benilla-app/src/local_state.rs b/crates/benilla-app/src/local_state.rs
index 41b38537c..1918b4e4c 100644
--- a/crates/benilla-app/src/local_state.rs
+++ b/crates/benilla-app/src/local_state.rs
@@ -430,8 +430,8 @@ pub(crate) fn shots_path() -> Option<PathBuf> {
 /// `benilla-config/Screenshots/`: where the print-screen key writes, each image once, not through
 /// [`write_atomic`].
 ///
-/// Deviation: the reference writes `Screenshots\\` inside the install, which benilla never writes
-/// to; the folder keeps the reference's name.
+/// Deviation: the reference writes `Screenshots\\` inside the install; benilla keeps the folder in
+/// its own state because it never writes to the install; the folder keeps the reference's name.
 pub(crate) fn screenshots_dir() -> Option<PathBuf> {
     home().map(|h| h.join("Screenshots"))
 }
diff --git a/crates/benilla-app/src/nameplates.rs b/crates/benilla-app/src/nameplates.rs
index b9d4b8906..271f1b12a 100644
--- a/crates/benilla-app/src/nameplates.rs
+++ b/crates/benilla-app/src/nameplates.rs
@@ -539,8 +539,9 @@ pub(crate) fn drive_nameplates(
                 ghost_visual: store.is_some_and(|s| s.0.unit_is_ghost_visual()),
                 is_self,
                 // No name over a fully faded first-person avatar. Deviation: `ShouldShowName`'s
-                // first leg is `IsSelectable` (`0x60be60`), which passes our own unit; what hides
-                // the own name in first person in 1.12.1 is untraced, so the avatar's fade stands in.
+                // first leg is `IsSelectable` (`0x60be60`), which passes our own unit; the avatar's
+                // fade stands in because what hides the own name in first person in 1.12.1 is
+                // untraced.
                 self_faded: rig
                     .as_deref()
                     .map_or(1.0, crate::player::CameraControl::self_fade)
diff --git a/crates/benilla-app/src/net/io.rs b/crates/benilla-app/src/net/io.rs
index de9723145..27b2f255c 100644
--- a/crates/benilla-app/src/net/io.rs
+++ b/crates/benilla-app/src/net/io.rs
@@ -10,7 +10,8 @@
 //! Deviation: the reference loads the world first and logs in after: the entry's first frame
 //! starts the load at the record's map and position (`0x401570`, called at `0x46c236`), and a
 //! later one, once its file reader is idle (`0x46c247`), sends the login (`0x46c272`). Here the two
-//! overlap, so entry is a round trip faster, and a refusal ends the cycle as a logout does.
+//! overlap because that way entry is a round trip faster; a refusal ends the cycle as a logout
+//! does.
 //!
 //! A logout or a later `SMSG_CHARACTER_LOGIN_FAILED` ends the world session, announced as a
 //! [`SessionEvent::Disconnected`] with [`SessionEnd::LoggedOut`], and parks at character select
diff --git a/crates/benilla-app/src/net/motion/remote.rs b/crates/benilla-app/src/net/motion/remote.rs
index 8db829437..13f39c738 100644
--- a/crates/benilla-app/src/net/motion/remote.rs
+++ b/crates/benilla-app/src/net/motion/remote.rs
@@ -93,8 +93,8 @@ pub(in crate::net) enum RelayOutcome {
     Seed,
     /// A server-authored pose for our own mover, handed to the controller as a
     /// [`crate::net::SelfMoveMessage`] at arrival. Deviation: the reference paces a self move
-    /// through the same replay chain as a remote's, which would only delay a correction to our own
-    /// pose.
+    /// through the same replay chain as a remote's; benilla hands it over at arrival because pacing
+    /// it would only delay a correction to our own pose.
     SelfMover,
     /// No entity for this guid: the packet changes nothing.
     Unknown,
diff --git a/crates/benilla-app/src/net/objects/update.rs b/crates/benilla-app/src/net/objects/update.rs
index 4e34f7972..d50545bd8 100644
--- a/crates/benilla-app/src/net/objects/update.rs
+++ b/crates/benilla-app/src/net/objects/update.rs
@@ -1086,7 +1086,7 @@ fn on_update_end(
             // Deviation: a first-pass values block the clear header byte left unwritten re-fires,
             // for a live object, its last write's edges against the watch copy (`0x465570`,
             // `0x466686`); benilla compares against this packet's copies, which hold none for it,
-            // so a stale edge never fires twice.
+            // because that way a stale edge never fires twice.
             Notify::Values { guid, sent } => {
                 let moved = copies.get(&guid).unwrap_or(&none);
                 let block = Notified::new(Sent::Fields(&sent), moved);
@@ -1099,7 +1099,8 @@ fn on_update_end(
             // `0x465d79`). For a first-pass create the clear header byte left unwritten, an
             // object not live crashes the reference, and a live one runs the all-fields watch
             // (`0x465d8e`) against its stale watch copy, re-firing its last write's edges as the
-            // values block above does; benilla's [`notify`] fires nothing for either.
+            // values block above does; benilla's [`notify`] fires nothing for either, because the
+            // faults the reference's passes have on malformed packets are recorded, not copied.
             Notify::Create { guid, kind } => {
                 if unshown.remove(&guid) {
                     create_hook(&mut sc, guid, kind, script.as_deref(), &mut arrival);
diff --git a/crates/benilla-app/src/net/session.rs b/crates/benilla-app/src/net/session.rs
index 39b3c6499..31256a1fb 100644
--- a/crates/benilla-app/src/net/session.rs
+++ b/crates/benilla-app/src/net/session.rs
@@ -308,9 +308,9 @@ fn on_disconnected(
         // so the selection ends as at the world's teardown, with nothing sent or signalled.
         //
         // Deviation: on benilla's unattended reconnect, which the reference lacks, the world's VM
-        // survives the loss, so the clear signals its `PLAYER_TARGET_CHANGED` and usable refresh
-        // as a release's teardown does (`0x493a69`, `0x493a73`), still sending nothing, and the
-        // surviving target frame lets the lost unit go.
+        // survives the loss; because of that the clear signals its `PLAYER_TARGET_CHANGED` and
+        // usable refresh as a release's teardown does (`0x493a69`, `0x493a73`), still sending
+        // nothing, and the surviving target frame lets the lost unit go.
         let LostSelection { selection, owed } = lost;
         if let Some(mut selection) = selection.filter(|s| s.guid.is_some()) {
             let before = selection.guid;
diff --git a/crates/benilla-app/src/player/approach.rs b/crates/benilla-app/src/player/approach.rs
index 3105ef4f2..834821523 100644
--- a/crates/benilla-app/src/player/approach.rs
+++ b/crates/benilla-app/src/player/approach.rs
@@ -417,8 +417,9 @@ impl AutoMove<'_, '_> {
     /// Deviation: the reference re-projects the point's height onto the first walkable facet a
     /// zero-size box gather finds at the enemy (`0x60fe25`-`0x60fe51`); here it keeps the enemy's
     /// height. The snap radius is the stop, so the two differ only while swimming or on a steep facet.
-    /// Deviation: the reference stores the world point unconverted and reads it back as deck-local
-    /// (`0x60fe6c`, `0x610e95`), so on a transport it walks astray; here it rides the deck.
+    /// Deviation: here it rides the deck, because the reference stores the world point unconverted
+    /// and reads it back as deck-local (`0x60fe6c`, `0x610e95`) and so, on a transport, walks
+    /// astray.
     pub(crate) fn walk_into_melee(
         &mut self,
         at: Vec3,
@@ -446,9 +447,9 @@ impl AutoMove<'_, '_> {
         self.arm(Toward::FacingTurn(facing), at, 0.0, stand).is_ok()
     }
 
-    /// Deviation: the reference converts back through the transport the player stands on each
-    /// frame (`0x610e6b`), so stepping off mid-walk sends the point astray; here the deck is fixed
-    /// at the arm.
+    /// Deviation: here the deck is fixed at the arm, because the reference converts back through
+    /// the transport the player stands on each frame (`0x610e6b`), so stepping off mid-walk sends
+    /// the point astray.
     fn anchor(&self, at: Vec3) -> Anchor {
         let frame = self.player.ride.as_ref().map(|r| r.entity);
         match frame.and_then(|e| self.transports.get(e).ok().map(|tf| (e, tf))) {
@@ -662,8 +663,8 @@ pub(super) fn steer_approach(
         if d2 <= arrive * arrive {
             info!("approach: arrived at {:.2} yd", d2.sqrt());
             // The canceller faces the armed guid (`0x60fbe8`): the object, and none for the ground.
-            // Deviation: the melee arm names the player's own guid (`0x60fe5f`), so the reference
-            // turns to face itself, a fixed heading; here the melee walk does not turn.
+            // Deviation: here the melee walk does not turn, because the reference's melee arm names
+            // the player's own guid (`0x60fe5f`), so it turns to face itself, a fixed heading.
             if let Toward::Object { verb, guid } = toward {
                 if delta.x * delta.x + delta.z * delta.z > f32::EPSILON {
                     player.face_yaw = bearing;
diff --git a/crates/benilla-app/src/player/camera_zoom.rs b/crates/benilla-app/src/player/camera_zoom.rs
index 63a889213..69ae0791a 100644
--- a/crates/benilla-app/src/player/camera_zoom.rs
+++ b/crates/benilla-app/src/player/camera_zoom.rs
@@ -10,7 +10,7 @@ use super::camera::CameraControl;
 /// head, and the avatar fades out. Deviation: the starting zoom, [`CAM_DIST_DEFAULT`], is 15 yd
 /// where the reference starts at 5.55, the third-person-A row of its default table `0x84f488`
 /// that `cameraView` 1 picks (`0x50c17a`, `0x50c18b`; the `cameraDistance` CVar itself registers
-/// "0.0"), for a wider view.
+/// "0.0"), because that gives a wider view.
 pub(super) const CAM_DIST_MIN: f32 = 0.0;
 /// The zoom ceiling, yd (`ds:0x8089a4` = 50.0): the cap on [`ZoomLimit`] (`0x511309`) and the top
 /// of the distance validator `0x50b310`; also the clamp for a distance read back off disk.
diff --git a/crates/benilla-app/src/player/state.rs b/crates/benilla-app/src/player/state.rs
index add73f378..1a3c154b1 100644
--- a/crates/benilla-app/src/player/state.rs
+++ b/crates/benilla-app/src/player/state.rs
@@ -118,8 +118,9 @@ pub(super) const SKIN_WIDTH: f32 = 0.02;
 /// deadline on while the world is stale or any load counter moves, so only a dead stream hits it.
 /// Terrain that never arrives still holds the body, by the world query gate ([`super::edge`]),
 /// so what the release can hand over early is a placement that never spawned. Deviation: the
-/// reference's blocking load (`0x694920`) waits out its reads before the frame goes on and has
-/// no such release; without one, a model that never loads would freeze our body for good.
+/// reference's blocking load (`0x694920`) waits out its reads before the frame goes on and has no
+/// such release; the timeout exists because without one a model that never loads would freeze our
+/// body for good.
 pub(crate) const SETTLE_TIMEOUT: f32 = 6.0;
 
 /// The player body's collision capsule, swept by avian's `MoveAndSlide`: origin at its centre, the
diff --git a/crates/benilla-app/src/shutdown.rs b/crates/benilla-app/src/shutdown.rs
index eaea82641..3cfcd70c7 100644
--- a/crates/benilla-app/src/shutdown.rs
+++ b/crates/benilla-app/src/shutdown.rs
@@ -51,9 +51,9 @@ pub(crate) fn on_app_exit(app: &mut App, systems: ScheduleConfigs<ScheduleSystem
 /// to `DefWindowProc`, whose `SC_CLOSE` becomes the kind-5 event (`0x42d287`, as `WM_CLOSE` posts at
 /// `0x42d292`) and closes at once: the running client's callback `0x63c9a0` (installed from
 /// `0x402840`, asked at `0x423a21`) answers 0 and tears the context down (`0x41f9b0`), with no
-/// logout timer, at the login screen and in game alike. A tiling window manager (i3,
-/// sway, Hyprland) binds nothing to it, so benilla reads the chord itself and asks for the same
-/// close, which the shutdown tail above already serves. Not on macOS: `Cmd+Q` is
+/// logout timer, at the login screen and in game alike. benilla reads the chord itself and asks for
+/// the same close, which the shutdown tail above already serves, because a tiling window manager
+/// (i3, sway, Hyprland) binds nothing to Alt+F4. Not on macOS: `Cmd+Q` is
 /// [`benilla_world::mac_quit`].
 pub(crate) struct AltF4Plugin;
 
diff --git a/crates/benilla-app/src/smart_rect.rs b/crates/benilla-app/src/smart_rect.rs
index cb6a40a69..ecd85724b 100644
--- a/crates/benilla-app/src/smart_rect.rs
+++ b/crates/benilla-app/src/smart_rect.rs
@@ -48,7 +48,7 @@ impl SmartBucket {
     }
 
     /// The seat without the claim. Deviation: the plate caller snaps the result to device
-    /// pixels before [`Self::claim`], so its border art blits 1:1.
+    /// pixels before [`Self::claim`], because that way its border art blits 1:1.
     pub(crate) fn resolve(&self, desired: Rect, viewport: Vec2) -> Rect {
         let (w, h) = (desired.width(), desired.height());
         let (half_w, half_h) = (w * 0.5, h * 0.5);
diff --git a/crates/benilla-app/src/sound/emitter_pool.rs b/crates/benilla-app/src/sound/emitter_pool.rs
index 005887c4a..5a486f81a 100644
--- a/crates/benilla-app/src/sound/emitter_pool.rs
+++ b/crates/benilla-app/src/sound/emitter_pool.rs
@@ -51,9 +51,9 @@ struct Record {
 struct Entry {
     /// `[+0xE00]`, the SoundEntries id; 0 is free.
     id: u32,
-    /// Deviation: the reference marks an unresolvable kit by negating the id (`[+0xE00] = -id`),
-    /// so the owner's next `$DSL` re-registers into a fresh entry every cycle; a flag keeps it in
-    /// place without the churn. Both are silent.
+    /// Deviation: a flag keeps an unresolvable kit in place without the churn, because the
+    /// reference marks it by negating the id (`[+0xE00] = -id`), so the owner's next `$DSL`
+    /// re-registers into a fresh entry every cycle. Both are silent.
     failed: bool,
     /// `[+0xC00]`'s active set, in claim order.
     records: Vec<Record>,
diff --git a/crates/benilla-app/src/sound/kit.rs b/crates/benilla-app/src/sound/kit.rs
index 554b41c6e..36b90d642 100644
--- a/crates/benilla-app/src/sound/kit.rs
+++ b/crates/benilla-app/src/sound/kit.rs
@@ -237,8 +237,8 @@ impl Bus {
 const BUS_CAP: [u32; 13] = [0x7fff_ffff, 1, 2, 2, 1, 1, 2, 2, 1, 6, 4, 1, 2];
 
 /// How many copies of one kit may sound at once, for kits without the `NO_DUPLICATES` flag.
-/// Deviation: the reference leaves those kits uncapped; sample-aligned copies of one file sum
-/// coherently (five are one sound +14 dB), so a mass buff distorts.
+/// Deviation: the reference leaves those kits uncapped; here they are capped because sample-aligned
+/// copies of one file sum coherently (five are one sound +14 dB), so a mass buff distorts.
 const SAME_KIT_MAX: usize = 2;
 
 /// The reference's duplicate suppressor: kit flag 0x20 and a channel of the same file still live
diff --git a/crates/benilla-app/src/sound/mod.rs b/crates/benilla-app/src/sound/mod.rs
index 2f4abb64c..6722cec88 100644
--- a/crates/benilla-app/src/sound/mod.rs
+++ b/crates/benilla-app/src/sound/mod.rs
@@ -102,8 +102,8 @@ pub(crate) struct SoundConfig {
     /// preset (`0x45a75b`) and the per-channel wet send (`0x458f13`). Read by
     /// [`reverb::zone_reverb`].
     ///
-    /// Deviation: default off where the reference registers "1". Its reverb is FMOD 3's EAX API,
-    /// which renders only with hardware 3D mixing, so off is what the reference is heard to
+    /// Deviation: default off where the reference registers "1", because its reverb is FMOD 3's EAX
+    /// API, which renders only with hardware 3D mixing, so off is what the reference is heard to
     /// produce (inferred: `fmod.dll`'s render side is untraced).
     pub reverb: bool,
     /// Not a CVar: set while the loading cover is up ([`feed_world_hold`]). No new sound starts
@@ -120,9 +120,9 @@ pub(crate) struct SoundConfig {
     /// it would save music off for a player who quits mid-cinematic. So the reference's restore
     /// latch (`[0xb4e278]`), needed there because its flag is the CVar itself, is not carried.
     pub music_suppressed: bool,
-    /// Deviation: `SoundOutputLimiter`, not a 1.12 CVar, default on, so overlapping full-scale
-    /// kits are limited rather than clipped. The reference has no headroom mechanism and clips at
-    /// full scale, as kira's hard clamp would (see [`limiter`]).
+    /// Deviation: `SoundOutputLimiter`, not a 1.12 CVar, default on, because that way overlapping
+    /// full-scale kits are limited rather than clipped. The reference has no headroom mechanism and
+    /// clips at full scale, as kira's hard clamp would (see [`limiter`]).
     pub limiter: bool,
     /// `SoundListenerAtCharacter` (default "1", `0x457890`), read once per frame at `0x483125`.
     /// `1` puts the listener on the mover with the character's facing, `0` at the camera eye with
diff --git a/crates/benilla-app/src/spell/targeting/mod.rs b/crates/benilla-app/src/spell/targeting/mod.rs
index d524112c4..b69a8ac22 100644
--- a/crates/benilla-app/src/spell/targeting/mod.rs
+++ b/crates/benilla-app/src/spell/targeting/mod.rs
@@ -704,17 +704,16 @@ fn bind_target_unit(
 /// range." or "Target too close") and binds nothing; otherwise the emptied word commits (`SendCast
 /// 0x6e54f0`).
 ///
-/// Deviation: a range failure leaves targeting armed and working. For a cast in flight the
+/// Deviation: a range failure leaves targeting armed and working because, for a cast in flight, the
 /// reference's report cancels it (`0x6e2218` → `0x6e4940`): its line, `SPELLCAST_FAILED` and the
-/// tradeskill disarm,
-/// which benilla keeps; with the word the bind emptied it also sends `CMSG_CANCEL_CAST` for the
-/// unsent spell (`0x6e4970`) and clears the caster, then restores the pre-click word (`0x6e6096`),
-/// so every later click fails the caster test (`0x6e5b93`) and the cursor is stranded until a
-/// cancel. That is a defect: benilla's cancel finds the cursor up, so it drops the word, with its
-/// signal (`0x6e495c`), instead of sending, and the cursor is re-armed as its attempt left it,
-/// its caster and its hold on the slot included, which is what a player can use. A record never
-/// pushed is not in flight, and its report cancels nothing: the word and the caster stand, as in
-/// the reference.
+/// tradeskill disarm, which benilla keeps; with the word the bind emptied it also sends
+/// `CMSG_CANCEL_CAST` for the unsent spell (`0x6e4970`) and clears the caster, then restores the
+/// pre-click word (`0x6e6096`), so every later click fails the caster test (`0x6e5b93`) and the
+/// cursor is stranded until a cancel. That is a defect: benilla's cancel finds the cursor up, so it
+/// drops the word, with its signal (`0x6e495c`), instead of sending, and the cursor is re-armed as
+/// its attempt left it, its caster and its hold on the slot included, which is what a player can
+/// use. A record never pushed is not in flight, and its report cancels nothing: the word and the
+/// caster stand, as in the reference.
 fn merge(
     ladder: &mut crate::spell::CastLadder,
     spell_id: u32,
diff --git a/crates/benilla-app/src/target/relations.rs b/crates/benilla-app/src/target/relations.rs
index 329c8c3c7..1df8c9385 100644
--- a/crates/benilla-app/src/target/relations.rs
+++ b/crates/benilla-app/src/target/relations.rs
@@ -485,7 +485,7 @@ impl Relations<'_> {
 /// forced. The lookup `0x4d6490` returns the stored rank verbatim (`0x4d64b3`).
 ///
 /// Deviation: the rank is held to 7, the top of the ring scale's eight entries (`0..=7`), where the
-/// reference keeps any value; a server rank past 7 would index outside our palette.
+/// reference keeps any value, because a server rank past 7 would index outside our palette.
 pub(crate) fn forced_rank(reputations: &Reputations, faction: u32) -> Option<u8> {
     reputations
         .forced_rank(faction)
diff --git a/crates/benilla-app/src/target/scan.rs b/crates/benilla-app/src/target/scan.rs
index 4a3544dcb..893d1a703 100644
--- a/crates/benilla-app/src/target/scan.rs
+++ b/crates/benilla-app/src/target/scan.rs
@@ -191,9 +191,10 @@ pub(super) fn load_creature_types(mut commands: Commands, world_assets: Option<R
 
 /// Everything the scan reads, shared by TAB, the attack acquire and the pet bar's Attack.
 ///
-/// Deviation: our own body is never a candidate. The reference's friendly scan picks the player at
-/// some facings (`CanAssist(P, P)` is true, `0x6061e0`; the cone test `0x47f220`), but our scoring
-/// always puts the player dead centre at distance 0, so CTRL-TAB would pick us on every press.
+/// Deviation: our own body is never a candidate because our scoring always puts the player dead
+/// centre at distance 0, so CTRL-TAB would pick us on every press. The reference's friendly scan
+/// picks the player at some facings (`CanAssist(P, P)` is true, `0x6061e0`; the cone test
+/// `0x47f220`).
 #[derive(SystemParam)]
 #[allow(clippy::type_complexity)] // one bundled system param, the app's convention
 pub(crate) struct TargetScan<'w, 's> {
@@ -1125,8 +1126,9 @@ pub(crate) struct LastEnemy(pub(crate) Option<u64>);
 /// alive was stamped the frame it was selected, so its death's deselect (`super::died`, in a later
 /// frame's packet) leaves it remembered.
 ///
-/// Deviation: sampled each frame, not stamped in `SetSelection`, so every selection writer is
-/// covered; a selected unit that turns hostile is remembered, where the reference's is not.
+/// Deviation: sampled each frame, not stamped in `SetSelection`, because that way every selection
+/// writer is covered; a selected unit that turns hostile is remembered, where the reference's is
+/// not.
 pub(super) fn remember_last_enemy(
     selection: Res<Selection>,
     stores: Query<&ObjectStore>,
diff --git a/crates/benilla-app/src/ui_action/cast_fail.rs b/crates/benilla-app/src/ui_action/cast_fail.rs
index c054e6bd1..5b068c4f5 100644
--- a/crates/benilla-app/src/ui_action/cast_fail.rs
+++ b/crates/benilla-app/src/ui_action/cast_fail.rs
@@ -412,8 +412,8 @@ impl CastFailLine {
 
 /// The line for a failed cast, `None` where the reference leaves before `DisplayError` and the
 /// log; `get` is the VM's GlobalStrings lookup. An empty [`CastFailLine::text`] shows nothing and
-/// still logs. Deviation: a reason past the table prints its hex code, so an unknown reason is
-/// visible.
+/// still logs. Deviation: a reason past the table prints its hex code, because that way an unknown
+/// reason is visible.
 pub(super) fn cast_fail_text(
     caster: Caster,
     reason: u8,
diff --git a/crates/benilla-app/src/ui_aura.rs b/crates/benilla-app/src/ui_aura.rs
index 714207a2f..95c626f34 100644
--- a/crates/benilla-app/src/ui_aura.rs
+++ b/crates/benilla-app/src/ui_aura.rs
@@ -1009,7 +1009,8 @@ fn join_duration(stamp: Option<&DurationStamp>, stamp_now: f64, script_now: f64)
 
 /// The session's end: drops the lists and stamps, so nothing reaches the next character's bar.
 /// Deviation: the reference clears its expiry array (`0xbc5f68`) at every game entry, in
-/// `ResetBuffCache` (`0x4e40c0`, called from `0x48f5a9`); benilla clears it at exit instead.
+/// `ResetBuffCache` (`0x4e40c0`, called from `0x48f5a9`); benilla clears it at exit instead,
+/// because that way a buff or debuff keeps its duration timer through a teleport.
 fn end_session_aura_state(
     mut hosted_vm: crate::script_calls::HostedVm,
     mut cache: ResMut<PlayerAuraCache>,
diff --git a/crates/benilla-app/src/ui_chat.rs b/crates/benilla-app/src/ui_chat.rs
index c2ab563a4..7a2d664a7 100644
--- a/crates/benilla-app/src/ui_chat.rs
+++ b/crates/benilla-app/src/ui_chat.rs
@@ -263,8 +263,8 @@ pub(crate) fn add_chat_lane(app: &mut App) {
 /// lines. The Lua state is itself replaced at the session end, as the reference destroys its own
 /// at logout.
 ///
-/// Deviation: not run on benilla's same-character reconnect, which the reference lacks (it
-/// returns to the login screen), so the window keeps its scrollback there.
+/// Deviation: not run on benilla's same-character reconnect, which the reference lacks (it returns
+/// to the login screen), because that way the window keeps its scrollback there.
 fn end_session_chat(
     mut hosted_vm: crate::script_calls::HostedVm,
     log: Res<ChatLog>,
diff --git a/crates/benilla-app/src/ui_chat/feed.rs b/crates/benilla-app/src/ui_chat/feed.rs
index 9281e33b9..0cbbe720b 100644
--- a/crates/benilla-app/src/ui_chat/feed.rs
+++ b/crates/benilla-app/src/ui_chat/feed.rs
@@ -395,7 +395,7 @@ impl ChatLog {
     ///
     /// Deviation: the reference holds every line that waits on its `$`-macro subject's name in
     /// the name cache's callback list (`0x49daea` → `0x55f080`) until the name answers, with no
-    /// bound; here at most [`MAX_HELD_SUBJECT_LINES`] wait, the oldest dropped past that, as a
+    /// bound; here at most [`MAX_HELD_SUBJECT_LINES`] wait, the oldest dropped past that, because a
     /// subject no player owns never answers.
     fn hold(&self, item: Pending) {
         let mut q = self.q();
diff --git a/crates/benilla-app/src/ui_chat/input/send.rs b/crates/benilla-app/src/ui_chat/input/send.rs
index 9f4cae60b..f03bbe98e 100644
--- a/crates/benilla-app/src/ui_chat/input/send.rs
+++ b/crates/benilla-app/src/ui_chat/input/send.rs
@@ -303,8 +303,8 @@ impl ChatSender<'_, '_> {
     /// `0x508680` over `text` for drunk byte `drunk` (`[[player+0xe68]+0x1d]`, `0x49f61a`): its
     /// strength is the byte cut to 100 and scaled by 0.01 (`0x49f62c`-`0x49f64e`), its buffer 256
     /// bytes (`0x49f651`). Deviation: a line of 256 bytes or more, which reaches here only through
-    /// `chat_send`'s deviation for `0x49f604`, is slurred whole instead of cut to that buffer, so
-    /// it reaches the server whole for the refusal that deviation leaves to it.
+    /// `chat_send`'s deviation for `0x49f604`, is slurred whole instead of cut to that buffer,
+    /// because that way it reaches the server whole for the refusal that deviation leaves to it.
     fn slur(&self, script: &UiScript, text: &str, drunk: u8) -> String {
         let cap = if text.len() < 0x100 {
             0x100
diff --git a/crates/benilla-app/src/ui_chat/settings.rs b/crates/benilla-app/src/ui_chat/settings.rs
index 9104cc059..6754b8152 100644
--- a/crates/benilla-app/src/ui_chat/settings.rs
+++ b/crates/benilla-app/src/ui_chat/settings.rs
@@ -625,7 +625,7 @@ fn write(script: &UiScript, channels: &super::edit::ChannelState, path: &std::pa
 ///   teardown (`0x499a80` from `0x490c55`) with no dirty check (`[0xb6e5c4]` is never read); host
 ///   state such as the zone mask never marks the file dirty.
 /// - Deviation: the debounce also writes Lua's changes (`dirty`) after the quiet time, where the
-///   reference writes only at teardown, so a crash loses at most a second of changes.
+///   reference writes only at teardown, because that way a crash loses at most a second of changes.
 ///
 /// A held reader has restored nothing, so neither writes, as `0x5afed0` skips a pending section
 /// (`0x5afee0`).
diff --git a/crates/benilla-app/src/ui_duel.rs b/crates/benilla-app/src/ui_duel.rs
index ef68c64ee..40ca26693 100644
--- a/crates/benilla-app/src/ui_duel.rs
+++ b/crates/benilla-app/src/ui_duel.rs
@@ -92,7 +92,7 @@ impl DuelState {
 
     /// `SMSG_DUEL_COUNTDOWN` (`0x4d4ae0`): the seconds stored and `ProcessCountdown`'s body run
     /// before its timer is armed, so the first line is the packet's; the line it owes.
-    /// Deviation: zero arms nothing, where the reference prints 0 and re-arms forever on the
+    /// Deviation: zero arms nothing, because the reference prints 0 and re-arms forever on the
     /// `dec`'s wraparound, a bug vmangos never reaches (it sends 3000).
     fn apply_countdown(&mut self, seconds: u32) -> Option<OwedLine> {
         self.countdown = (seconds > 0).then(|| Countdown {
diff --git a/crates/benilla-app/src/ui_gamma.rs b/crates/benilla-app/src/ui_gamma.rs
index fa48855cd..4e2797794 100644
--- a/crates/benilla-app/src/ui_gamma.rs
+++ b/crates/benilla-app/src/ui_gamma.rs
@@ -53,20 +53,20 @@ impl Default for UiGammaLane {
 /// `__ftol(pow(i / 255, gamma) · 65535)` (`0x591680`); there is no other whole-frame grade and
 /// no `Brightness` or `Contrast` CVar.
 ///
-/// Deviation: the reference skips that upload when windowed (`byte[dev+0x20b]` is `gxWindow`), and
-/// every benilla mode is windowed, so the same curve applies in the compositor, where the slider
-/// can move pixels: [`UiGammaNode`] raises the gamma byte the RAMDAC would have read to `gamma`
-/// before its decode, the continuous form of the 256-entry ramp.
+/// Deviation: the same curve applies in the compositor, where the slider can move pixels, because
+/// the reference skips that upload when windowed (`byte[dev+0x20b]` is `gxWindow`) and every
+/// benilla mode is windowed: [`UiGammaNode`] raises the gamma byte the RAMDAC would have read to
+/// `gamma` before its decode, the continuous form of the 256-entry ramp.
 #[derive(Resource, Debug, Clone, Copy, PartialEq)]
 pub(crate) struct DisplayGamma(pub(crate) f32);
 
 /// The registered `"1.0"`: the identity ramp, at which the pass changes no byte.
 pub(crate) const DEFAULT_GAMMA: f32 = 1.0;
 
-/// Deviation: the reference never clamps (`SetGamma` `0x4891f0` writes `-4.000000` for 5), but its
-/// ramp is a fullscreen OS call and ours is the image, where an extreme exponent blacks out the
-/// panel that would undo it. The range spans the stock slider's `[0.5, 1.5]` four times over; the
-/// CVar keeps the value written and only its consumers clamp.
+/// Deviation: the reference never clamps (`SetGamma` `0x4891f0` writes `-4.000000` for 5), but here
+/// the consumers clamp because its ramp is a fullscreen OS call and ours is the image, where an
+/// extreme exponent blacks out the panel that would undo it. The range spans the stock slider's
+/// `[0.5, 1.5]` four times over; the CVar keeps the value written and only its consumers clamp.
 pub(crate) const GAMMA_RANGE: std::ops::RangeInclusive<f32> = 0.25..=4.0;
 
 impl Default for DisplayGamma {
diff --git a/crates/benilla-app/src/ui_gm_ticket.rs b/crates/benilla-app/src/ui_gm_ticket.rs
index bdaef221b..688744963 100644
--- a/crates/benilla-app/src/ui_gm_ticket.rs
+++ b/crates/benilla-app/src/ui_gm_ticket.rs
@@ -166,7 +166,7 @@ fn update_ticket_args(ticket: Option<&benilla_protocol::messages::GmTicket>) ->
 /// (`0x5e7945`) the saved ebp, the return address into the dispatcher and the handler's first
 /// argument.
 ///
-/// Deviation: those three are stack residue, so benilla sends 0 for each.
+/// Deviation: benilla sends 0 for each of those three because they are stack residue.
 fn no_ticket_args() -> Vec<ScriptValue> {
     vec![
         ScriptValue::Int(0),
diff --git a/crates/benilla-app/src/ui_honor.rs b/crates/benilla-app/src/ui_honor.rs
index 96c4bf232..d116c9ebf 100644
--- a/crates/benilla-app/src/ui_honor.rs
+++ b/crates/benilla-app/src/ui_honor.rs
@@ -37,8 +37,8 @@ impl InspectHonor {
     ///
     /// Deviation: a new target zeroes the figures too, and dropping a held reply signals
     /// `INSPECT_HONOR_UPDATE`, where `0x4c6f70` keeps the figures and clears only has-data
-    /// (`0xb71fc8`) and pending (`0xb71fcc`): a server that never answers the ask, as vmangos
-    /// often does not, would leave the last player's figures shown under the new one.
+    /// (`0xb71fc8`) and pending (`0xb71fcc`), because a server that never answers the ask, as
+    /// vmangos often does not, would leave the last player's figures shown under the new one.
     pub(crate) fn set_target(&mut self, guid: u64) -> bool {
         if guid == self.target {
             return false;
diff --git a/crates/benilla-app/src/ui_item_text.rs b/crates/benilla-app/src/ui_item_text.rs
index 1c5a15b61..157278e51 100644
--- a/crates/benilla-app/src/ui_item_text.rs
+++ b/crates/benilla-app/src/ui_item_text.rs
@@ -509,8 +509,8 @@ fn open_tail(world: &mut World, place: Place) {
 /// (`0x4e35de`). In 1.12.1 a turn to a page not yet cached closes the book, which stays closed, and
 /// a letter whose author's name is not cached shows without its From line, then closes when the
 /// name lands. `0x4930d0`'s same-target test (`0x4930eb`-`0x4930f3`) only skips a unit's greeting,
-/// so this is a bug. benilla keeps the book open and shows it again ([`show_at`]): the page or the
-/// From line appears when it lands.
+/// so this is a bug, and benilla keeps the book open and shows it again ([`show_at`]) because of
+/// that: the page or the From line appears when it lands.
 fn answered(world: &mut World, wait: Wait, place: Place) {
     let Some(sess) = world
         .resource_mut::<ItemTextOpen>()
diff --git a/crates/benilla-app/src/ui_layout.rs b/crates/benilla-app/src/ui_layout.rs
index 981e86a7d..6ba9bfff3 100644
--- a/crates/benilla-app/src/ui_layout.rs
+++ b/crates/benilla-app/src/ui_layout.rs
@@ -86,8 +86,8 @@ pub(crate) enum Layout {
 /// with no name, belong to no frame and are dropped, as the reference applies them to a null frame
 /// (`0x4905e6`); a name no frame has drops its lines at the restore the same way.
 ///
-/// Deviation: a record's fields start empty. The reference's parser clears X, Y, W and the level
-/// at each `Frame:` (`ebx`, `edi`, `esi`, `[ebp-0x4]` at `0x49045b`–`0x490469`) but not H
+/// Deviation: a record's fields start empty because the reference's parser clears X, Y, W and the
+/// level at each `Frame:` (`ebx`, `edi`, `esi`, `[ebp-0x4]` at `0x49045b`–`0x490469`) but not H
 /// (`[ebp-0xc]`), so a record with no `H:` takes the one before's; benilla writes `H:` whenever it
 /// writes `W:`, so only a hand-edited file reaches the slip, which would size a window from
 /// another window's row.
diff --git a/crates/benilla-app/src/ui_loot/mod.rs b/crates/benilla-app/src/ui_loot/mod.rs
index 7b70cb7a8..c2af0df11 100644
--- a/crates/benilla-app/src/ui_loot/mod.rs
+++ b/crates/benilla-app/src/ui_loot/mod.rs
@@ -330,7 +330,8 @@ pub(crate) struct LootState {
     /// signal's handlers (`0x4c2917`, `0x4c21dc`), cleared by the confirmed send (`0x4c281a`) and
     /// by the next response (`0x4c1df5`), not by a close.
     /// Deviation: it is the display row, where the reference's is the item index plus one
-    /// (`0x4c2885`), so an addon's `GetLootSlotInfo(arg1)` reads the row the dialog is for.
+    /// (`0x4c2885`), because that way an addon's `GetLootSlotInfo(arg1)` reads the row the dialog
+    /// is for.
     pending_bind_confirm: Option<u32>,
     /// The candidates `GetMasterLootCandidate` looked up and the name cache missed, each a
     /// registration of the callback `0x4c2fb0` (dedupe flag 0, `0x4c2f61`), spent by the name's
@@ -861,9 +862,9 @@ impl LootState {
 
     /// `0xb71b44` above 0: a row's item record is still being fetched, counted from the copier
     /// (`0x4c1e77`) until its callback (`0x4c2ac0`); a negative answer releases the row, as
-    /// [`Window::records_pending`] has it. Deviation: a row cleared meanwhile stops counting, where
-    /// `ClearLootRow` (`0x4c1f00`) cancels its callback (`0x4c1f52`) and never lowers the count
-    /// (its writers are `0x4c1def`, `0x4c1e94` and `0x4c2af6` alone), so in 1.12.1 a group
+    /// [`Window::records_pending`] has it. Deviation: a row cleared meanwhile stops counting,
+    /// because `ClearLootRow` (`0x4c1f00`) cancels its callback (`0x4c1f52`) and never lowers the
+    /// count (its writers are `0x4c1def`, `0x4c1e94` and `0x4c2af6` alone), so in 1.12.1 a group
     /// member's take of an uncached item before the answer leaves that corpse's window shut until
     /// the next loot response resets the count (`0x4c1def`), and ours opens.
     fn records_pending(&self, items: &Items) -> bool {
@@ -920,7 +921,8 @@ impl Default for LootConfig {
 /// admits vmangos' type-1 answer for the item.
 ///
 /// Deviation: our close paths clear it guid-matched, where `CloseInteraction` clears it
-/// unconditionally (`0x48f2c9`), so closing an old window keeps a newer `CMSG_LOOT`'s latch.
+/// unconditionally (`0x48f2c9`), because that way closing an old window keeps a newer `CMSG_LOOT`'s
+/// latch.
 #[derive(Resource, Default)]
 pub(crate) struct LootLatch(pub(crate) Option<u64>);
 
diff --git a/crates/benilla-app/src/ui_loot_roll.rs b/crates/benilla-app/src/ui_loot_roll.rs
index e39924dc6..a5cc75ace 100644
--- a/crates/benilla-app/src/ui_loot_roll.rs
+++ b/crates/benilla-app/src/ui_loot_roll.rs
@@ -19,18 +19,18 @@
 //! free (`0x61b760`). Stock `GroupLootFrame_OpenNewFrame` has four frames and drops a fifth
 //! silently, so an unqueued fifth could never be voted.
 //!
-//! Deviation: the open count is the number of rolls announced and not closed. The reference keeps
-//! a counter that its server-close paths decrement for any roll whose closed byte is clear
+//! Deviation: the open count is the number of rolls announced and not closed, because the reference
+//! keeps a counter that its server-close paths decrement for any roll whose closed byte is clear
 //! (`0x61b6f8`, `0x61bc17`), a deferred roll that never counted up included, so it under-counts
 //! and lets a fifth frame open; here a deferred roll's close changes nothing.
 //!
 //! A result's line, its `CANCEL_LOOT_ROLL` and the promotion after it wait for the result's item
 //! record and, for a win, the winner's name (`0x61b96a` → `0x61b9a0` → `0x61b9bf` → `0x61b9e0`,
 //! `0x61b5c0` → `0x61b640`); until then the roll stays listed. Deviation: a refused record or name
-//! closes the roll unspoken. In 1.12.1 the failure callbacks (`0x61bc80`, `0x61bd50`, `0x61b7d0`)
-//! free the record with no `CANCEL_LOOT_ROLL` and leave the open count unlowered, so its frame
-//! stays up, empty and dead, until a `/reload`, and holds one of the four frames, so a later
-//! fourth roll never shows; benilla closes the roll instead.
+//! closes the roll unspoken because in 1.12.1 the failure callbacks (`0x61bc80`, `0x61bd50`,
+//! `0x61b7d0`) free the record with no `CANCEL_LOOT_ROLL` and leave the open count unlowered, so
+//! its frame stays up, empty and dead, until a `/reload`, and holds one of the four frames, so a
+//! later fourth roll never shows; benilla closes the roll instead.
 //!
 //! A promoted roll's `arg2` is still the wire's countdown (`0x61b430` and `0x61b79a` push
 //! `node+0x3c`, which nothing rewrites); only the bar is short, as `GetLootRollTimeLeft` counts
diff --git a/crates/benilla-app/src/ui_macro/store.rs b/crates/benilla-app/src/ui_macro/store.rs
index 771da80d8..7540ec202 100644
--- a/crates/benilla-app/src/ui_macro/store.rs
+++ b/crates/benilla-app/src/ui_macro/store.rs
@@ -19,8 +19,8 @@ const LINE_BYTES: usize = 0x100;
 const NAME_DELIMS: &[u8] = b" \"\r\n";
 
 /// A token as its buffer kept it. Deviation: the reference's 255-byte cut (`0x4f0677`,
-/// `0x4f0b93`) can end inside a character and keep its stray bytes; a `String` must stay UTF-8,
-/// so the cut backs off to the character's start.
+/// `0x4f0b93`) can end inside a character and keep its stray bytes; here the cut backs off to the
+/// character's start because a `String` must stay UTF-8.
 fn token_text(bytes: Vec<u8>) -> String {
     match String::from_utf8(bytes) {
         Ok(text) => text,
diff --git a/crates/benilla-app/src/ui_mail/net.rs b/crates/benilla-app/src/ui_mail/net.rs
index c4ea16c5b..becc0d9ae 100644
--- a/crates/benilla-app/src/ui_mail/net.rs
+++ b/crates/benilla-app/src/ui_mail/net.rs
@@ -231,7 +231,7 @@ fn on_session_end(
 ///
 /// Deviation: with no usable paper the reference reads the first record of an empty list through
 /// a null pointer (`0x4ad561`-`0x4ad56d`, `mov eax,[eax]` with `eax` 0) and faults; benilla keeps
-/// the row's wire id, so the inbox still opens.
+/// the row's wire id, because that way the inbox still opens.
 pub(super) fn mail_list(
     mails: Vec<MailListEntry>,
     mail: &mut MailOpen,
diff --git a/crates/benilla-app/src/ui_script/addons.rs b/crates/benilla-app/src/ui_script/addons.rs
index 00aee931b..58e42b4e4 100644
--- a/crates/benilla-app/src/ui_script/addons.rs
+++ b/crates/benilla-app/src/ui_script/addons.rs
@@ -263,8 +263,8 @@ const ADDONS_PREFIX: &str = "Interface/AddOns/";
 
 /// The addon folder, `<benilla-config>/AddOns/`, or `None` (always under `$WOW_CAPTURE`); addon
 /// textures and fonts resolve onto it too. Deviation: the reference reads the install's
-/// `Interface\AddOns\`; benilla reads an install and does not live in one, so its addons live in
-/// its own state folder, and only there.
+/// `Interface\AddOns\`; its addons live in its own state folder, and only there, because benilla
+/// reads an install and does not live in one.
 pub(crate) fn root() -> Option<PathBuf> {
     root_from(crate::local_state::home())
 }
@@ -681,8 +681,8 @@ pub(super) fn save_enable_state(script: &UiScript, identity: Option<&(String, St
 /// file, before `AddOns.txt`). No autosave and no dirty bit, as in the reference, whose write gate
 /// is the record's loaded byte: an addon that never loaded is not written. A scope declaring no
 /// names loses its file (`0x51f859`, `0x51f9ac`) when it ran cleanly this session.
-/// Deviation: that file is renamed to `<Name>.lua.bak`, where the reference deletes it, so an addon
-/// update that drops its toc line costs the player nothing they cannot get back.
+/// Deviation: that file is renamed to `<Name>.lua.bak`, where the reference deletes it, because
+/// that way an addon update that drops its toc line costs the player nothing they cannot get back.
 pub(super) fn save_addon_variables(script: &mut UiScript, identity: Option<&(String, String)>) {
     let account = crate::local_state::addon_saved_account_dir();
     let character = identity.and_then(|(r, c)| crate::local_state::addon_saved_character_dir(r, c));
diff --git a/crates/benilla-app/src/ui_script/extract/mod.rs b/crates/benilla-app/src/ui_script/extract/mod.rs
index e870a8bf0..ba9110eee 100644
--- a/crates/benilla-app/src/ui_script/extract/mod.rs
+++ b/crates/benilla-app/src/ui_script/extract/mod.rs
@@ -1461,8 +1461,8 @@ fn convert_entry(
                             );
                         }
                         // Deviation: the V-plate border is resampled sharp to the quad's physical
-                        // size rather than GPU-magnified, so its 1 px bevel stays crisp; keyed by
-                        // that size, so only a resize re-rasterises it.
+                        // size rather than GPU-magnified, because that way its 1 px bevel stays
+                        // crisp; keyed by that size, so only a resize re-rasterises it.
                         let px = |v: f32| (v * dpi).round().max(1.0) as u32;
                         a.resampled_sprite(
                             p,
diff --git a/crates/benilla-app/src/ui_script/glue.rs b/crates/benilla-app/src/ui_script/glue.rs
index d71cf7699..501f01c8b 100644
--- a/crates/benilla-app/src/ui_script/glue.rs
+++ b/crates/benilla-app/src/ui_script/glue.rs
@@ -346,8 +346,9 @@ pub(crate) fn watch_glue_aspect(
 /// Deviation: the reference's size callback only re-scales `GlueParent` and re-lays it out
 /// (`0x46ac51`, `0x46ac56`), as its root keeps `gxResolution`'s aspect until a rebuild (`0x41ad10`
 /// at `0x46a828`) and its window keeps that shape while dragged (`0x5989d7`); here the root is the
-/// window's, which takes any shape, so the box follows it on every resize, where a rebuild would
-/// reset the screen (the create screen's character and name, the typed password, the selection).
+/// window's, which takes any shape, so the box follows it on every resize, without a rebuild
+/// because that would reset the screen (the create screen's character and name, the typed password,
+/// the selection).
 pub(super) fn on_glue_screen_resized(script: &UiScript) {
     if let Err(e) = script.run(GLUE_PARENT_RESEAT) {
         error!("ui_script: GlueParent re-seat: {e}");
diff --git a/crates/benilla-app/src/ui_script/glue_mgr.rs b/crates/benilla-app/src/ui_script/glue_mgr.rs
index 5b3586452..0af0a66d7 100644
--- a/crates/benilla-app/src/ui_script/glue_mgr.rs
+++ b/crates/benilla-app/src/ui_script/glue_mgr.rs
@@ -1519,9 +1519,9 @@ impl GlueMgr {
     ///
     /// Deviation: the reference's handler completes whichever operation is current; here only the
     /// character list's does, in state 3, and a reply of another cause (a roster nothing of the
-    /// screen asked for) or of another link (before a realm change) completes nothing. Those
-    /// replies cannot be told from the operation they would be applied to in the reference, which
-    /// has one link and one request in flight; here the IO thread's park serves several.
+    /// screen asked for) or of another link (before a realm change) completes nothing, because the
+    /// reference has one link and one request in flight and so cannot tell those replies from the
+    /// operation they would be applied to, while here the IO thread's park serves several.
     fn on_roster(&mut self, roster: Vec<Character>, cause: RosterCause, epoch: u64) {
         if cause != RosterCause::Asked
             || epoch != self.link
diff --git a/crates/benilla-app/src/ui_script/input.rs b/crates/benilla-app/src/ui_script/input.rs
index 5b8b0912f..5076baf68 100644
--- a/crates/benilla-app/src/ui_script/input.rs
+++ b/crates/benilla-app/src/ui_script/input.rs
@@ -760,11 +760,11 @@ pub(crate) fn feed_key(
         // The char walk gates no binding (`0x765df0` reaches no keybinding), so whether a
         // frame took the character is not recorded: the key-down already decided that.
         //
-        // Deviation: the character is the platform's Unicode text, so a player can type any
-        // language on any platform.
-        // The reference's window is ANSI (`RegisterClassExA`, `DefWindowProcA`), so `WM_CHAR`
-        // carries a byte of the system code page, which `0x42d185`-`0x42d1f5` maps through a
-        // table `GetACP` picks; a character outside that code page never arrives.
+        // Deviation: the character is the platform's Unicode text, because that way a player can
+        // type any language on any platform. The reference's window is ANSI (`RegisterClassExA`,
+        // `DefWindowProcA`), so `WM_CHAR` carries a byte of the system code page, which
+        // `0x42d185`-`0x42d1f5` maps through a table `GetACP` picks; a character outside that code
+        // page never arrives.
         if let Some(text) = &ev.text {
             script.char_input(text);
         }
diff --git a/crates/benilla-app/src/ui_script/lifecycle.rs b/crates/benilla-app/src/ui_script/lifecycle.rs
index ff7410ece..2fe467d2f 100644
--- a/crates/benilla-app/src/ui_script/lifecycle.rs
+++ b/crates/benilla-app/src/ui_script/lifecycle.rs
@@ -177,7 +177,8 @@ fn new_vm<E: std::fmt::Display>(
         channels.mirror_into(&mut script);
     }
     // The reference seeds `rand` with the clock before `WinMain` (`0x5b800b`). Deviation: a
-    // capture run (`scenario_active`) keeps the CRT's default seed, 1, so its frames reproduce.
+    // capture run (`scenario_active`) keeps the CRT's default seed, 1, because that way its frames
+    // reproduce.
     if crate::run_mode::scenario_active() {
         script.lua().srand(1);
     }
diff --git a/crates/benilla-app/src/ui_script/load_log.rs b/crates/benilla-app/src/ui_script/load_log.rs
index 79567cc43..924841d9d 100644
--- a/crates/benilla-app/src/ui_script/load_log.rs
+++ b/crates/benilla-app/src/ui_script/load_log.rs
@@ -2,7 +2,7 @@
 //! line at a time as the reference's log layer writes one (`0x65ac20`): the stamp
 //! `"%u/%u %02u:%02u:%02u.%03u  "` (`0x866aa0`), the text, then `"\r\n"` (`0x82edfc`). The glue
 //! build writes its own `Logs\GlueXML.log` (`0x837024`, opened at `0x46a8ce`) the same way.
-//! Deviation: the files are under `benilla-config/Logs/`, since the install is read-only.
+//! Deviation: the files are under `benilla-config/Logs/`, because the install is read-only.
 
 use std::io::Write as _;
 
diff --git a/crates/benilla-app/src/ui_script/server_alert.rs b/crates/benilla-app/src/ui_script/server_alert.rs
index a625eed3b..7fc3a0f78 100644
--- a/crates/benilla-app/src/ui_script/server_alert.rs
+++ b/crates/benilla-app/src/ui_script/server_alert.rs
@@ -20,10 +20,10 @@
 //! client sets neither redirect flag (`0x4000`, `0x8000`); what WinINet does with an
 //! http-to-https redirect is the OS's, not in the client's bytes, and benilla does not follow one.
 //!
-//! Deviation: the body is read with 0x4000-byte reads filled to the end of the body, so what a
-//! read returns does not depend on how the network cut the packets; and the reading stops once
-//! the buffer is full, since no later byte can change it.
-//! Deviation: the connection is direct. The reference opens its session with access type 0
+//! Deviation: the body is read with 0x4000-byte reads filled to the end of the body, because that
+//! way what a read returns does not depend on how the network cut the packets; and the reading
+//! stops once the buffer is full, because no later byte can change it.
+//! Deviation: the connection is direct because the reference opens its session with access type 0
 //! (`InternetOpenA`, `0x7a6d97`), the system's proxy settings, which benilla does not read.
 
 use std::io::{self, BufRead, BufReader, Read, Write};
diff --git a/crates/benilla-app/src/ui_social/query.rs b/crates/benilla-app/src/ui_social/query.rs
index 2e9d4535f..6d7160f4f 100644
--- a/crates/benilla-app/src/ui_social/query.rs
+++ b/crates/benilla-app/src/ui_social/query.rs
@@ -75,7 +75,7 @@ pub(crate) fn parse(
         .collect();
     // Deviation: a filter of 127 bytes or more puts the copy's NUL in the name buffer's first byte
     // (`0x5aec1a`), so a name an earlier tag set is scanned as more filter. benilla ends the copy
-    // at its own NUL: the run-on reads one stack buffer through another.
+    // at its own NUL because the run-on reads one stack buffer through another.
     copy.push(b' ');
     let mut builder = Builder {
         tags,
@@ -161,9 +161,9 @@ fn is_space(c: u32) -> bool {
     match c as u16 {
         0xffff => false,
         w @ 0..=0xff => matches!(w, 0x09..=0x0d | 0x20),
-        // Deviation: `C1_SPACE` from `GetStringTypeW` is the Windows system's own table, which
-        // no file of the client holds; benilla answers Unicode's `White_Space` for those units,
-        // and nothing for a lone surrogate.
+        // Deviation: benilla answers Unicode's `White_Space` for those units, and nothing for a
+        // lone surrogate, because `C1_SPACE` from `GetStringTypeW` is the Windows system's own
+        // table, which no file of the client holds.
         w => char::from_u32(u32::from(w)).is_some_and(char::is_whitespace),
     }
 }
diff --git a/crates/benilla-app/src/ui_summon.rs b/crates/benilla-app/src/ui_summon.rs
index 04a2989e1..a9b366ff6 100644
--- a/crates/benilla-app/src/ui_summon.rs
+++ b/crates/benilla-app/src/ui_summon.rs
@@ -15,9 +15,9 @@
 //! - `ConfirmSummon()` (`0x48b770`) checks no deadline, so two Accepts are two packets; vmangos
 //!   ignores the guid and checks its own `m_summon_expire`.
 //!
-//! Deviation: the latch is dropped at session end and an Accept with nothing latched sends
-//! nothing, so no stale or zero guid reaches the server. The reference never clears the guid or
-//! zone, only the deadline (`0x49014a`), so its `ConfirmSummon()` sends whatever is left.
+//! Deviation: the latch is dropped at session end and an Accept with nothing latched sends nothing,
+//! because that way no stale or zero guid reaches the server. The reference never clears the guid
+//! or zone, only the deadline (`0x49014a`), so its `ConfirmSummon()` sends whatever is left.
 
 use benilla_ui::script::SummonConfirmUiState;
 use bevy::prelude::*;
diff --git a/crates/benilla-app/src/ui_text/engine/mod.rs b/crates/benilla-app/src/ui_text/engine/mod.rs
index f17103ad5..d32f02e96 100644
--- a/crates/benilla-app/src/ui_text/engine/mod.rs
+++ b/crates/benilla-app/src/ui_text/engine/mod.rs
@@ -360,8 +360,8 @@ impl TextEngine {
 
     /// [`Self::ensure_str`] without the raster: shape what is missing, so a string that is measured
     /// and never drawn never touches the sheet. Deviation: the reference's measure kernels
-    /// (`0x5c6940`, `0x5c6b70`, `0x5c6c50`, `0x5c7300`, `0x5c7470`) rasterize each character, but
-    /// the step law reads only the advance, so skipping the bitmap changes no width.
+    /// (`0x5c6940`, `0x5c6b70`, `0x5c6c50`, `0x5c7300`, `0x5c7470`) rasterize each character; here
+    /// the bitmap is skipped, which changes no width because the step law reads only the advance.
     pub(super) fn ensure_metrics(&mut self, face: usize, ppem: u16, text: &str) {
         for ch in text.chars() {
             self.ensure_char(face, ppem, None, ch);
diff --git a/crates/benilla-app/src/ui_text/outline.rs b/crates/benilla-app/src/ui_text/outline.rs
index dcced3d24..6e1cdb48c 100644
--- a/crates/benilla-app/src/ui_text/outline.rs
+++ b/crates/benilla-app/src/ui_text/outline.rs
@@ -57,8 +57,9 @@ fn fill_gray(coverage: u8) -> u8 {
 /// 4. Pack: the coverage as a 4-bit gray ([`fill_gray`]), so the pure ring is black and the fill
 ///    ramps toward it.
 ///
-/// Deviation: `r × floor(dpi)` passes, so the ring keeps its logical weight on a whole-number
-/// high-DPI raster; a fractional scale such as 1.5 rounds down to the reference's one texel a pass.
+/// Deviation: `r × floor(dpi)` passes, because that way the ring keeps its logical weight on a
+/// whole-number high-DPI raster; a fractional scale such as 1.5 rounds down to the reference's one
+/// texel a pass.
 ///
 /// It draws as one quad per glyph (`0x5ccbe0`) whose vertex colour tints the fill and leaves the
 /// ring black. Returns `(rgba, out_w, out_h, pad)`: the cell grows `pad` texels each side (the
diff --git a/crates/benilla-app/src/video.rs b/crates/benilla-app/src/video.rs
index 24f96ef6d..2645d7b93 100644
--- a/crates/benilla-app/src/video.rs
+++ b/crates/benilla-app/src/video.rs
@@ -19,8 +19,8 @@
 //! or `AutoVsync` (a maximize is a resize). The fault is in the driver's own DXGI present
 //! (`d3d11.dll`): it stays with `VK_LAYER_NV_present` disabled, and the validation layer reports
 //! nothing before it. `Mailbox`, `AutoNoVsync` and DX12 survive, so there
-//! "vsync on" is `AutoNoVsync` paced to the monitor's refresh rate ([`present_choice`]), which
-//! keeps the synced look without the crash. `$WOW_PRESENT=fifo` restores plain `Fifo`.
+//! "vsync on" is `AutoNoVsync` paced to the monitor's refresh rate ([`present_choice`]) because
+//! that keeps the synced look without the crash. `$WOW_PRESENT=fifo` restores plain `Fifo`.
 
 use benilla_ui::script::{ScreenResolution, UiScript};
 use bevy::prelude::*;
diff --git a/crates/benilla-app/src/vplates.rs b/crates/benilla-app/src/vplates.rs
index 9f8640dcd..4ce156255 100644
--- a/crates/benilla-app/src/vplates.rs
+++ b/crates/benilla-app/src/vplates.rs
@@ -16,7 +16,7 @@
 //!   large and soft at high resolutions.
 //! - Highlight: the mouseover or the target (`0x606f20` into `0x607080`) lights the plate.
 //!   Deviation: the bar fill brightens by `LIT_BOOST` in place of the reference's ADD
-//!   `Nameplate-Glow` rim, which reads as hard edge lines under benilla's linear blending.
+//!   `Nameplate-Glow` rim, because that reads as hard edge lines under benilla's linear blending.
 //!   Hovering a plate makes its unit the mouseover (`0x7cb850`) and turns the name yellow; a
 //!   click on it selects.
 //! - With a target, every other plate dims ([`DIM_ALPHA`]).
@@ -191,14 +191,15 @@ fn con_color(pl_level: u32, unit_level: u32) -> [f32; 4] {
 
 /// Snap a logical-pixel coordinate onto the device pixel grid, so the sharp-resampled border
 /// blits 1:1 at any scale factor. Deviation: the reference draws at fractional device
-/// coordinates; the snap keeps the magnified border crisp. Shared with the chat bubble.
+/// coordinates; here the position snaps because that keeps the magnified border crisp. Shared with
+/// the chat bubble.
 pub(crate) fn device_snap(v: f32, scale: f32) -> f32 {
     (v * scale).round() / scale
 }
 
-/// Deviation: the reference's plates grow with the diagonal without limit (`0x7705b0`), which
-/// reads too big and soft; past this diagonal, where the frame is the border art's native
-/// 128x32 px, the basis grows at [`PLATE_GROWTH_DAMP`] of that rate.
+/// Deviation: the reference's plates grow with the diagonal without limit (`0x7705b0`); past this
+/// diagonal, where the frame is the border art's native 128x32 px, the basis grows at
+/// [`PLATE_GROWTH_DAMP`] of that rate, because unlimited growth reads too big and soft.
 const PLATE_DIAG_KNEE: f32 = 1280.0;
 /// 0 pins the native size, 1 is the reference's rate.
 const PLATE_GROWTH_DAMP: f32 = 0.5;
@@ -668,8 +669,8 @@ fn drive_vplates(
                 name_height: text_px(NAME_H, basis) / seam,
                 level_height: text_px(LEVEL_H, basis) / seam,
                 // Deviation: a constant one-logical-pixel shadow, not the reference's 0.001 gx,
-                // which draws 2 px thick and too heavy at larger windows. Divided by the seam,
-                // which the shared text arm would otherwise scale it by.
+                // because that draws 2 px thick and too heavy at larger windows. Divided by the
+                // seam, which the shared text arm would otherwise scale it by.
                 shadow_offset: 1.0 / seam,
             },
             states,
diff --git a/crates/benilla-app/src/wdb.rs b/crates/benilla-app/src/wdb.rs
index 9406b6c25..864f779d6 100644
--- a/crates/benilla-app/src/wdb.rs
+++ b/crates/benilla-app/src/wdb.rs
@@ -343,7 +343,8 @@ struct Stores<'w> {
 ///
 /// Deviation: the reference keeps a saved store's ask "pending" for the rest of the process
 /// (`0x555740` clears only the stores built with persistence off), so a query a lost link dropped
-/// is never sent again until restart; benilla's reconnect asks it again.
+/// is never sent again until restart; benilla's reconnect asks it again because the name or text it
+/// was for would otherwise stay blank until restart.
 fn clear_saved_asks(In(ev): In<SessionEvent>, mut stores: Stores) {
     if !matches!(ev, SessionEvent::Disconnected { .. }) {
         return;
diff --git a/crates/benilla-app/src/world_console.rs b/crates/benilla-app/src/world_console.rs
index 9951290b3..ecbbe4486 100644
--- a/crates/benilla-app/src/world_console.rs
+++ b/crates/benilla-app/src/world_console.rs
@@ -214,7 +214,7 @@ fn water_ripples(world: &mut World, args: &str) -> Vec<String> {
 /// (`0x867c50`), a NaN passing both; else `__ftol(v · 255)` of each, the first in the top byte,
 /// goes to the shadow colour setter `0x672590`. Prints nothing when it takes them.
 ///
-/// Deviation: a float the scan leaves unread is 0.0, where the reference reads whatever its
+/// Deviation: a float the scan leaves unread is 0.0, because the reference reads whatever its
 /// uninitialised stack slot holds.
 fn set_shadow(world: &mut World, args: &str) -> Vec<String> {
     let mut v = [0.0f32; 4];
diff --git a/crates/benilla-assets/src/anim_rng.rs b/crates/benilla-assets/src/anim_rng.rs
index 77bf6f138..300ab3276 100644
--- a/crates/benilla-assets/src/anim_rng.rs
+++ b/crates/benilla-assets/src/anim_rng.rs
@@ -37,7 +37,7 @@ impl AnimRng {
     }
 
     /// The reference's `srand(GetTickCount())`: a wall-clock seed, once per process. Deviation: a
-    /// capture run (`deterministic`) keeps the default seed, so its frames reproduce.
+    /// capture run (`deterministic`) keeps the default seed, because that way its frames reproduce.
     pub fn seed_for_session(&mut self, deterministic: bool) {
         if deterministic {
             return;
diff --git a/crates/benilla-formats/src/chain.rs b/crates/benilla-formats/src/chain.rs
index 37c487b9f..6cdb79824 100644
--- a/crates/benilla-formats/src/chain.rs
+++ b/crates/benilla-formats/src/chain.rs
@@ -232,7 +232,7 @@ const LISTFILE_LINE_MAX: usize = 0x103;
 /// `EnumerateArchiveListfile` (`0x648fb0`) over one listfile, with `0x4014f0`'s prefix test: a line
 /// ends at a CR or LF (`0x649022`, `0x649026`); an empty one, and one whose text from its last dot
 /// is `.md5` without case (`0x865bd8`, `0x64905f`), is passed over. Deviation: a last line with no
-/// CR or LF after it is passed too, where `0x648fb0` ends at the buffer's end without a flush
+/// CR or LF after it is passed too, because `0x648fb0` ends at the buffer's end without a flush
 /// (`0x64907f`) and drops it, a bug that loses a listfile's last name when it lacks a newline.
 fn listfile_lines(listfile: &[u8], prefix: &str, out: &mut Vec<String>) {
     let mut line: Vec<u8> = Vec::with_capacity(LISTFILE_LINE_MAX);
diff --git a/crates/benilla-formats/src/elevators.rs b/crates/benilla-formats/src/elevators.rs
index 8616f6caf..67f553847 100644
--- a/crates/benilla-formats/src/elevators.rs
+++ b/crates/benilla-formats/src/elevators.rs
@@ -60,7 +60,7 @@ fn schema() -> Schema {
 }
 
 /// Read `TransportAnimation.dbc` off the patch chain. Deviation: a path that cannot drive a cycle
-/// is dropped and its GO stays at its spawn point, where the reference faults or hangs: a last
+/// is dropped and its GO stays at its spawn point, because the reference faults or hangs: a last
 /// frame at 0 divides by zero (`0x5f62a4`), and a first frame past 0, one frame among them, leaves
 /// a time before it in no bracket, which `0x5f62bc`-`0x5f62e7` seek forever.
 pub fn load_elevator_paths(chain: &mut Chain) -> Result<ElevatorPaths> {
diff --git a/crates/benilla-formats/src/emote_text.rs b/crates/benilla-formats/src/emote_text.rs
index 3eaaa9591..e1cdedb15 100644
--- a/crates/benilla-formats/src/emote_text.rs
+++ b/crates/benilla-formats/src/emote_text.rs
@@ -111,7 +111,7 @@ impl EmoteTextCatalog {
 }
 
 /// `SStrPrintf` (`0x64a7f0`) reduced to the `%s` these templates use. Deviation: a surplus `%s`
-/// stays verbatim, where the reference would print stack garbage; no shipped row has one.
+/// stays verbatim, because the reference would print stack garbage; no shipped row has one.
 fn fill(template: &str, args: &[&str]) -> String {
     let mut out = String::with_capacity(template.len() + 16);
     let mut rest = template;
diff --git a/crates/benilla-formats/src/loose.rs b/crates/benilla-formats/src/loose.rs
index c9522ddc7..9239f2798 100644
--- a/crates/benilla-formats/src/loose.rs
+++ b/crates/benilla-formats/src/loose.rs
@@ -30,8 +30,9 @@ pub enum LooseOpen {
 ///
 /// Deviation: a folder is listed the first time a key reaches it, where the reference lists every
 /// folder at the first open (`0x646ea0`), so a file added to a folder no key has reached is found
-/// before the index empties; the whole walk takes minutes and gigabytes where the install folder
-/// holds or links a large tree, as a Wine prefix's `z:` drive links `/`.
+/// before the index empties; folders are listed lazily because the whole walk takes minutes and
+/// gigabytes where the install folder holds or links a large tree, as a Wine prefix's `z:` drive
+/// links `/`.
 #[derive(Debug, Default)]
 pub struct LooseIndex {
     /// The base folder's walk, then `Data\`'s.
diff --git a/crates/benilla-formats/src/models/key_anim.rs b/crates/benilla-formats/src/models/key_anim.rs
index b1531047f..4e902cc91 100644
--- a/crates/benilla-formats/src/models/key_anim.rs
+++ b/crates/benilla-formats/src/models/key_anim.rs
@@ -127,8 +127,9 @@ impl<V: Lerp> KeyAnim<V> {
 /// The reference's track read at `t_ms` over the key window `[lo, hi]` (`0x713d50`, interp
 /// dispatch `0x71af20`): `keys[lo]` for a collapsed window (`lo >= hi`), else the last window key
 /// at or before `t_ms`, held for a step track or past the last key, else lerped toward the next.
-/// Deviation: the fraction is clamped to `[0, 1]`; the reference extrapolates, which for a window
-/// whose brackets miss the band can push a fix16 factor negative and cull the batch on a quirk.
+/// Deviation: the fraction is clamped to `[0, 1]` because the reference extrapolates, which for a
+/// window whose brackets miss the band can push a fix16 factor negative and cull the batch on a
+/// quirk.
 pub(super) fn sample_window<V: Lerp>(
     keys: &[(u32, V)],
     step: bool,
diff --git a/crates/benilla-formats/src/models/types.rs b/crates/benilla-formats/src/models/types.rs
index 1059edbd5..6e8a7e23f 100644
--- a/crates/benilla-formats/src/models/types.rs
+++ b/crates/benilla-formats/src/models/types.rs
@@ -380,7 +380,8 @@ pub struct TextureStage {
 /// A flat ground-plane quad: four vertices on one horizontal plane at or just above z = 0 (hover
 /// ≤ [`GROUND_HOVER_MAX`]), an axis-aligned XY rectangle wholly on one bone, as ground-ring spells
 /// author them (Battle Shout's crescents). The reference draws them as geometry slopes bury.
-/// Deviation: the fx lane redraws them as projected decals (`ground_fx`) so they drape the terrain.
+/// Deviation: the fx lane redraws them as projected decals (`ground_fx`) because that way they
+/// drape the terrain.
 #[derive(Debug, Clone, Copy)]
 pub struct GroundQuad {
     /// Posed through the joint's matrix × the bone's inverse bind pose, as a skinned vertex.
diff --git a/crates/benilla-formats/src/spells/tokens.rs b/crates/benilla-formats/src/spells/tokens.rs
index 94103f310..51f461ce4 100644
--- a/crates/benilla-formats/src/spells/tokens.rs
+++ b/crates/benilla-formats/src/spells/tokens.rs
@@ -687,9 +687,9 @@ pub fn substitute_parts(
         };
         match token_value(letter, slot, target, ctx, scale, at) {
             Some((sub, val)) => {
-                // Deviation: every token keys the `$l` plural. The reference's `$a`, `$d`, `$t`,
-                // `$e`, `$c`, `$p`, `$f`, `$F` and `$z` arms never write `[0xbe0b84]`, so its `$l`
-                // keys on the number before them, and Blizzard's "$s1 … every $t1
+                // Deviation: every token keys the `$l` plural because the reference's `$a`, `$d`,
+                // `$t`, `$e`, `$c`, `$p`, `$f`, `$F` and `$z` arms never write `[0xbe0b84]`, so its
+                // `$l` keys on the number before them, and Blizzard's "$s1 … every $t1
                 // $lsecond:seconds;" reads "every 1 seconds" in 1.12.1. We print the grammar the
                 // text means.
                 last_value = val;
diff --git a/crates/benilla-formats/src/tga.rs b/crates/benilla-formats/src/tga.rs
index 094b79cef..b5db91f14 100644
--- a/crates/benilla-formats/src/tga.rs
+++ b/crates/benilla-formats/src/tga.rs
@@ -6,21 +6,22 @@
 //! Deviation: grayscale types 3 and 11 decode where the reference refuses them, because no shipped
 //! or addon file is one and removing working code would buy nothing.
 //!
-//! Deviation: colour maps of 15, 16 and 32 bits decode at the entry width the file declares, where
-//! the reference has no defined result to copy for 15 and 16 bits and only a garble for 32. It
-//! sizes an entry as `(min(bits / 3, 8) · 3) >> 3` bytes (`0x5a3b40`): 3 for 24 and 32 bits, 1 for
-//! 15 and 16. A 16-bit map is read short and copied one byte a pixel (`0x5a3890`-`0x5a38fa`) into
-//! the three-byte-a-pixel buffer `0x5a3820` allocates and never zeroes, so the rest of the colours
-//! are heap garbage; a 32-bit map is read a byte an entry short and the pixels start inside it.
+//! Deviation: colour maps of 15, 16 and 32 bits decode at the entry width the file declares,
+//! because the reference has no defined result to copy for 15 and 16 bits and only a garble for 32.
+//! It sizes an entry as `(min(bits / 3, 8) · 3) >> 3` bytes (`0x5a3b40`): 3 for 24 and 32 bits, 1
+//! for 15 and 16. A 16-bit map is read short and copied one byte a pixel (`0x5a3890`-`0x5a38fa`)
+//! into the three-byte-a-pixel buffer `0x5a3820` allocates and never zeroes, so the rest of the
+//! colours are heap garbage; a 32-bit map is read a byte an entry short and the pixels start inside
+//! it.
 //!
-//! Deviation: a colour-mapped image whose descriptor has alpha bits decodes as its picture, where
+//! Deviation: a colour-mapped image whose descriptor has alpha bits decodes as its picture, because
 //! the reference has no defined result to copy. `0x5a3820` sizes each pixel as 24 plus the alpha
 //! bits (`0x5a382b`-`0x5a383d`, stored at `0x5a3973`) but copies 3-byte entries (`0x5a38f3`), then
 //! `0x5a3b80` moves `(bpp + 7) >> 3` bytes a pixel (`0x5a3c00`-`0x5a3c13`): each pixel after the
 //! first takes its bytes from its neighbours, and the last read heap that was never written.
 //!
 //! Deviation: a truecolour image whose depth less its alpha bits is 24, but whose depth is not 24
-//! or 32, is refused where the reference crashes. The check `0x5a37e0` admits it (25 to 31 bits
+//! or 32, is refused because the reference crashes. The check `0x5a37e0` admits it (25 to 31 bits
 //! with 1 to 7 alpha bits, 33 to 39 with 9 to 15), then `0x5a41f0` returns 0 for a depth that is
 //! not 32, and the copy at `0x4492c4` reads through that null pointer: there is no result to match.
 //!
diff --git a/crates/benilla-formats/src/transports/mod.rs b/crates/benilla-formats/src/transports/mod.rs
index eb7f98b1c..b19e7e55e 100644
--- a/crates/benilla-formats/src/transports/mod.rs
+++ b/crates/benilla-formats/src/transports/mod.rs
@@ -79,10 +79,10 @@ impl TransportTimetable {
     /// `accelRate`, each made a float through `fild` of the zero-extended value. `None` for no
     /// node or a period of 0, which the reference ticks with a modulus of 1 (`0x5f50d5`) and no
     /// leg ending after 0, so it never moves the ship (`0x5f511c`), as a ship with no timetable.
-    /// Deviation: `None` too where the reference's build overruns its stack or reads memory it
-    /// never wrote (`transports#path-faults`), so the ship stays at its spawn: more than 1024
-    /// nodes in a leg (`0x5f9530`), a leg of 3 nodes or fewer (`0x4532e3`) and a stop on a leg's
-    /// last node (`0x5f91a1`). No shipped path reaches one.
+    /// Deviation: `None` too, so the ship stays at its spawn, because there the reference's build
+    /// overruns its stack or reads memory it never wrote (`transports#path-faults`): more than
+    /// 1024 nodes in a leg (`0x5f9530`), a leg of 3 nodes or fewer (`0x4532e3`) and a stop on a
+    /// leg's last node (`0x5f91a1`). No shipped path reaches one.
     pub fn build(nodes: &[TaxiPathNode], move_speed: u32, accel_rate: u32) -> Option<Self> {
         let speed = f64::from(move_speed) as f32;
         let accel = f64::from(accel_rate) as f32;
diff --git a/crates/benilla-lua/src/api.rs b/crates/benilla-lua/src/api.rs
index f1857ecf3..32404c25b 100644
--- a/crates/benilla-lua/src/api.rs
+++ b/crates/benilla-lua/src/api.rs
@@ -30,8 +30,8 @@ pub fn c_int(n: f64) -> i32 {
 
 /// The longest string the libraries build, `INT32_MAX` bytes: more than the 1.12 client's 32-bit
 /// address space could hold. Deviation: the C build grows a string while `realloc` succeeds, and
-/// a failure is the catchable `not enough memory`; Rust's allocator aborts the process instead,
-/// and Linux grants far more than it can fill, so past this bound the libraries raise C's message.
+/// a failure is the catchable `not enough memory`; past this bound the libraries raise C's message
+/// because Rust's allocator aborts the process instead, and Linux grants far more than it can fill.
 pub const MAX_STRING: usize = i32::MAX as usize;
 
 /// 5.1's `LUAI_MAXCSTACK`: the most values a native's frame may hold.
diff --git a/crates/benilla-lua/src/lib_math.rs b/crates/benilla-lua/src/lib_math.rs
index f717b9a3b..c9d01ee21 100644
--- a/crates/benilla-lua/src/lib_math.rs
+++ b/crates/benilla-lua/src/lib_math.rs
@@ -229,7 +229,8 @@ fn max(vm: &mut Vm, nargs: usize) -> R<usize> {
 /// `RAND_MAX` is 32767. The client's state is the main thread's, seeded with the millisecond
 /// clock before `WinMain` (`0x5b800b` → `0x5d1c70`, `srand` at `0x5d1c8b`). Deviation: the
 /// client's one process-wide stream is shared with its engine draws; here each VM holds its own,
-/// seeded from the wall clock when it is built, so a fork or a clone draws its own sequence.
+/// seeded from the wall clock when it is built, because that way a fork or a clone draws its own
+/// sequence.
 #[derive(Clone)]
 pub(crate) struct CrtRand(u32);
 
diff --git a/crates/benilla-lua/src/lib_string.rs b/crates/benilla-lua/src/lib_string.rs
index bc2b831d0..7caea3081 100644
--- a/crates/benilla-lua/src/lib_string.rs
+++ b/crates/benilla-lua/src/lib_string.rs
@@ -95,8 +95,8 @@ fn upper(vm: &mut Vm, nargs: usize) -> R<usize> {
 /// `str_lower`'s loop: decode a code point, map it, encode it, advance by the bytes the decoder
 /// read (`0x7fbe8a`). A string of ASCII without a NUL maps byte by byte, as the loop would.
 ///
-/// Deviation: the decoder reads a NUL as no bytes (`0x7fbeda`), so the client's loop never
-/// passes one and the call never returns; here the result ends there.
+/// Deviation: here the result ends there, because the decoder reads a NUL as no bytes (`0x7fbeda`),
+/// so the client's loop never passes one and the call never returns.
 fn case_map(vm: &mut Vm, nargs: usize, map: fn(u32) -> u32) -> R<usize> {
     let s = vm.check_str(nargs, 1)?;
     let r = vm.heap.intern_with(|h, b| {
@@ -233,8 +233,8 @@ fn byte(vm: &mut Vm, nargs: usize) -> R<usize> {
 /// function with no upvalues (`0x6f4383`, `0x6f438a`), else `unable to dump given function`
 /// (`0x882284`). Deviation: the
 /// client writes 5.0 bytecode (`luaU_dump`, `0x6fb600`); benilla writes 5.1's header and the
-/// function's source name. The client loads no binary chunk (`0x6f6a15`), so the bytes are only
-/// data, and matching them would need 5.0's code generator.
+/// function's source name because the client loads no binary chunk (`0x6f6a15`), so the bytes are
+/// only data, and matching them would need 5.0's code generator.
 fn dump(vm: &mut Vm, nargs: usize) -> R<usize> {
     vm.check_function(nargs, 1)?;
     let source = match vm.arg(nargs, nargs - 1).unpack() {
diff --git a/crates/benilla-lua/src/lib_table.rs b/crates/benilla-lua/src/lib_table.rs
index bb1e1ba89..93cf916ab 100644
--- a/crates/benilla-lua/src/lib_table.rs
+++ b/crates/benilla-lua/src/lib_table.rs
@@ -32,9 +32,9 @@ pub fn open(vm: &mut Vm) {
 }
 
 /// The most elements one `insert` or `remove` may shift. Deviation: the client's loops have no
-/// bound (`0x7fb728`, `0x7fb7e0`), but a remembered size is whatever an addon wrote, and the
-/// instruction-budget hook never sees a native's loop, so one over two billion slots would hang
-/// the client.
+/// bound (`0x7fb728`, `0x7fb7e0`); here they are bounded because a remembered size is whatever an
+/// addon wrote, and the instruction-budget hook never sees a native's loop, so one over two billion
+/// slots would hang the client.
 const MAX_SHIFT: i64 = 1_000_000;
 
 /// `luaB_getn` (`0x7fb630`).
diff --git a/crates/benilla-protocol/examples/version_check_probe.rs b/crates/benilla-protocol/examples/version_check_probe.rs
index abceb7168..4f23d6e9b 100644
--- a/crates/benilla-protocol/examples/version_check_probe.rs
+++ b/crates/benilla-protocol/examples/version_check_probe.rs
@@ -6,7 +6,7 @@
 //!
 //! With an install directory it also derives that install's own digest the way the 1.12 client
 //! does, HMAC-SHA1 keyed by the challenge over five binaries, and says whether it is the stock
-//! one. Deviation: benilla always sends the published constant instead, since an install without
+//! one. Deviation: benilla always sends the published constant instead, because an install without
 //! those binaries could never answer for itself.
 //!
 //! Usage: `cargo run -p benilla-protocol --example version_check_probe -- <host[:port]> <user>
diff --git a/crates/benilla-protocol/src/auth.rs b/crates/benilla-protocol/src/auth.rs
index c447e8c7e..b4f0f1252 100644
--- a/crates/benilla-protocol/src/auth.rs
+++ b/crates/benilla-protocol/src/auth.rs
@@ -375,7 +375,7 @@ pub fn read_proof_reply(r: &mut impl Read) -> Result<Option<[u8; 20]>> {
     let server_proof = read_array::<20>(r)?;
     // Deviation: the survey id is read and dropped, and no survey runs, where the reference keeps
     // it on the link (`0x5bad53`) for the `Survey.dll` it downloads and calls (`GetSurveyId
-    // 0x5ab620`, called at `0x474064`). benilla runs no code a server sends
+    // 0x5ab620`, called at `0x474064`). benilla does this because it runs no code a server sends
     // ([`AuthReject::reply`] gives the rule).
     let _hardware_survey_id = read_u32_le(r)?;
     Ok(Some(server_proof))
diff --git a/crates/benilla-protocol/src/events/decode.rs b/crates/benilla-protocol/src/events/decode.rs
index 616b449a6..380172820 100644
--- a/crates/benilla-protocol/src/events/decode.rs
+++ b/crates/benilla-protocol/src/events/decode.rs
@@ -1149,7 +1149,8 @@ fn decode_objects(first_pass: bool, objects: Vec<Object>) -> Vec<SessionEvent> {
             // Deviation: an out-of-range list past the first block reads no body in the write
             // passes (`0x466076`), which misread every block behind it, while the notify pass
             // reads past it (`0x465fd0`) and stays in step; benilla reads the list and drops it,
-            // keeping the blocks behind it whole.
+            // keeping the blocks behind it whole, because the faults the reference's passes have on
+            // malformed packets are recorded, not copied.
             Object::OutOfRange { guids } => {
                 if at == 0 {
                     first.push(SessionEvent::ObjectsRemoved(guids));
@@ -1166,7 +1167,7 @@ fn decode_objects(first_pass: bool, objects: Vec<Object>) -> Vec<SessionEvent> {
             // Deviation: the flagged pass reads a movement block's guid as 8 raw bytes
             // (`0x467140`, `0x46714d`) where the wire packs it, so unless the packed guid happens
             // to be 8 bytes the reference misreads the rest of that pass; benilla reads the block
-            // once, packed, as pass 0 does (`0x467080`).
+            // once, packed, as pass 0 does (`0x467080`), because of the misreading just described.
             Object::Movement { guid, movement } => {
                 if let Some((position, orientation)) = movement.position {
                     second.push(SessionEvent::ObjectMove {
diff --git a/crates/benilla-protocol/src/messages/battlefield.rs b/crates/benilla-protocol/src/messages/battlefield.rs
index b4bc954aa..b686a5793 100644
--- a/crates/benilla-protocol/src/messages/battlefield.rs
+++ b/crates/benilla-protocol/src/messages/battlefield.rs
@@ -185,7 +185,7 @@ pub struct BattlefieldPositions {
     pub carrier: Option<BattlefieldPosition>,
 }
 
-/// The client's 40-entry store. Deviation: a larger count keeps the first 40, where the
+/// The client's 40-entry store. Deviation: a larger count keeps the first 40, because the
 /// reference's handler writes past the store.
 pub const BATTLEFIELD_POSITIONS_MAX: usize = 40;
 
diff --git a/crates/benilla-protocol/src/messages/guild.rs b/crates/benilla-protocol/src/messages/guild.rs
index fa0adc5c6..ba268d8d5 100644
--- a/crates/benilla-protocol/src/messages/guild.rs
+++ b/crates/benilla-protocol/src/messages/guild.rs
@@ -3,9 +3,9 @@
 //!
 //! Deviation: string reads are unbounded. The reference `0x4191b0` caps each field, counting the
 //! NUL (roster name `0x30`, notes `0x80`, MOTD `0x200`, info `0x7d0`, guild name `0x60`, rank name
-//! `0x40`), and on overflow empties it and no-ops every later read in the packet. Unbounded reads
-//! cannot poison a packet, and every cap is far above the server's own length limits, so a
-//! legitimate packet reads the same.
+//! `0x40`), and on overflow empties it and no-ops every later read in the packet. Reads stay
+//! unbounded because unbounded reads cannot poison a packet, and every cap is far above the
+//! server's own length limits, so a legitimate packet reads the same.
 
 use std::io::{self, Read};
 
diff --git a/crates/benilla-protocol/src/messages/pet.rs b/crates/benilla-protocol/src/messages/pet.rs
index 40a8e78a8..211d87011 100644
--- a/crates/benilla-protocol/src/messages/pet.rs
+++ b/crates/benilla-protocol/src/messages/pet.rs
@@ -69,7 +69,7 @@ impl PetActionEntry {
         ((self.packed >> 24) & 0x3F) as u8
     }
     /// Client types 1-5 take the spell branch. Deviation: a type outside 1-7 reads as nothing
-    /// rather than the reference's default arm, which under-pushes its returns.
+    /// rather than the reference's default arm, because that arm under-pushes its returns.
     pub fn is_spell(self) -> bool {
         (PET_TYPE_SPELL_FIRST..=PET_TYPE_SPELL_LAST).contains(&self.kind())
     }
@@ -189,7 +189,7 @@ pub(super) fn read_pet_spells(r: &mut &[u8]) -> io::Result<PetSpells> {
 /// The trailing cooldown block. The client reads `u8 count` then 12-byte entries
 /// `{u16 spell, u16 category, u32, u32}` (`0x4bda58`); vmangos writes `u16 count` then 14-byte
 /// entries with a `u32` spell (`Unit.cpp:11245-11278`). Deviation: both are read, told apart
-/// exactly by the tail length (`12n` vs `1 + 14n`), since the 1.12 client mis-parses vmangos's.
+/// exactly by the tail length (`12n` vs `1 + 14n`), because the 1.12 client mis-parses vmangos's.
 fn read_cooldown_block(r: &mut &[u8]) -> io::Result<Vec<PetSpellCooldown>> {
     let count = usize::from(read_u8(r)?);
     // At `count == 0` vmangos still leaves its `u16` count's high byte; it is consumed so the
diff --git a/crates/benilla-protocol/src/world/session.rs b/crates/benilla-protocol/src/world/session.rs
index 58db3d534..bb5b894db 100644
--- a/crates/benilla-protocol/src/world/session.rs
+++ b/crates/benilla-protocol/src/world/session.rs
@@ -20,7 +20,8 @@ use super::{recv_packet, send_packet, LinkTraffic};
 const HANDSHAKE_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 
 /// Read timeout in the login queue, where updates can be minutes apart. Deviation: the reference
-/// waits forever; a bound tells a server that died mid-queue from a long wait.
+/// waits forever; here the wait is bounded because that tells a server that died mid-queue from a
+/// long wait.
 const QUEUE_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(300);
 
 /// The world server refused the session. Its code is from `messages`' `AUTH_*` block, not
@@ -63,7 +64,7 @@ pub(super) struct LinkFacts {
     /// Roster guid to race, so [`WorldSession::player_login`] can pick the chat language.
     roster_races: std::collections::HashMap<u64, u8>,
     /// The billing group the last `SMSG_AUTH_RESPONSE` to carry one gave. Deviation: zeros until
-    /// one does, where the reference's words are never initialised (the session is allocated
+    /// one does, because the reference's words are never initialised (the session is allocated
     /// without zero-fill, `ui/billing` in benilla-re).
     billing: messages::Billing,
     /// `SMSG_ADDON_INFO`'s per-record status bytes in order; `None` until the server answers.
@@ -241,12 +242,14 @@ impl WorldSession {
         // `SMSG_ADDON_INFO` can reach any of the handshake's read loops, so it is caught here.
         match &packet {
             ServerPacket::AddonInfo { records } => self.link.addon_info = Some(records.clone()),
-            // Deviation: benilla runs no Warden module and answers nothing, where the reference
-            // hands `SMSG_WARDEN_DATA` to the module its connect loads (`0x6ca2f0`, `0x6ca5c0`)
-            // and sends that module's answer as `CMSG_WARDEN_DATA` (`0x6ca6a0`). The message is
-            // read past like any stray and the login goes on; what follows is the server's policy
-            // (vmangos kicks after `Warden.ClientResponseDelay`, `Warden.cpp:686-691`). benilla
-            // runs no code a server sends ([`crate::auth::AuthReject::reply`] gives the rule).
+            // Deviation: benilla runs no Warden module and answers nothing, because the answers
+            // come from native Win32 x86 code the server sends, which the client maps, links and
+            // runs in its own process (`0x7a79d0`), and benilla runs no such code on any platform
+            // ([`crate::auth::AuthReject::reply`] gives the rule). The reference hands
+            // `SMSG_WARDEN_DATA` to the module its connect loads (`0x6ca2f0`, `0x6ca5c0`) and sends
+            // that module's answer as `CMSG_WARDEN_DATA` (`0x6ca6a0`); here the message is read
+            // past like any stray and the login goes on. What follows is the server's
+            // policy (vmangos kicks after `Warden.ClientResponseDelay`, `Warden.cpp:686-691`).
             ServerPacket::Other {
                 opcode: opcode::SMSG_WARDEN_DATA,
             } => self.link.warden_asked = true,
diff --git a/crates/benilla-ui/src/civil.rs b/crates/benilla-ui/src/civil.rs
index d5b372488..3becf2f84 100644
--- a/crates/benilla-ui/src/civil.rs
+++ b/crates/benilla-ui/src/civil.rs
@@ -84,8 +84,8 @@ pub fn local(secs: i64) -> (Civil, bool) {
 /// `0x740825`), then adds `_dstbias` only when `isdst` is set (`0x740811`, `0x740836`). The sum is
 /// a 32-bit `time_t`'s, so a wrap past it is negative and refused.
 ///
-/// Deviation: a `_dstbias` that takes the time below 0 faults the client, which copies the second
-/// `localtime`'s null answer unchecked (`0x740842` → `0x740860`); here it is refused.
+/// Deviation: a `_dstbias` that takes the time below 0 is refused here because it faults the
+/// client, which copies the second `localtime`'s null answer unchecked (`0x740842` → `0x740860`).
 pub fn local_seconds(utc: i32, isdst: bool) -> Option<i32> {
     let (zone, bias) = zone().biases;
     let mut t = utc.wrapping_add(zone);
diff --git a/crates/benilla-ui/src/loader/mod.rs b/crates/benilla-ui/src/loader/mod.rs
index 0e0d0ec8d..e711e91b1 100644
--- a/crates/benilla-ui/src/loader/mod.rs
+++ b/crates/benilla-ui/src/loader/mod.rs
@@ -435,8 +435,9 @@ impl Loader<'_> {
                     }
                 }
                 TopLevel::Script(ScriptRef::Inline { body, line }) => {
-                    // Deviation: padded to the block's line, so a raise reports a line a reader can
-                    // find in the file; the reference counts from the body's first line.
+                    // Deviation: padded to the block's line, because that way a raise reports a
+                    // line a reader can find in the file; the reference counts from the body's
+                    // first line.
                     let mut chunk = "\n".repeat(line.saturating_sub(1) as usize).into_bytes();
                     chunk.extend_from_slice(body.as_bytes());
                     // The reference names an inline body `"%s:<Scripts>"` (`0x871074`, formatted at
@@ -544,7 +545,7 @@ impl Loader<'_> {
     /// `0x76fe60`).
     ///
     /// Deviation: a cycle (`A` inherits `B`, `B` inherits `A`) stops at the repeated name with a
-    /// warning. The reference has no guard: its `parent=` walk (`0x6ee390`-`0x6ee3c2`) spins
+    /// warning because the reference has no guard: its `parent=` walk (`0x6ee390`-`0x6ee3c2`) spins
     /// forever round a cycle with no `parent=` on it, and where one stops that walk, the level
     /// recursion (`0x76985c`, and `0x76a092` for the `<Frames>`) overflows the stack.
     pub(super) fn levels<'a>(&mut self, raw: &'a Element) -> Levels<'a> {
@@ -721,8 +722,8 @@ impl Loader<'_> {
     }
 
     /// Link font `id` to `to` for an XML attribute. Deviation: a link that would close a loop is
-    /// refused and reported; the reference's XML legs (`0x783ce6`, `0x783d22`) check nothing, and
-    /// the next push down such a loop would never end.
+    /// refused and reported because the reference's XML legs (`0x783ce6`, `0x783d22`) check
+    /// nothing, and the next push down such a loop would never end.
     fn link_font_node(
         &mut self,
         id: crate::script::font::FontId,
diff --git a/crates/benilla-ui/src/loader/widgets.rs b/crates/benilla-ui/src/loader/widgets.rs
index c58b315d9..84c379d92 100644
--- a/crates/benilla-ui/src/loader/widgets.rs
+++ b/crates/benilla-ui/src/loader/widgets.rs
@@ -213,9 +213,9 @@ impl Loader<'_> {
             .find(|(t, _)| is(t))
             {
                 // Each colour element (`0x6f23d0`) is its font's text colour. Deviation:
-                // `<HighlightColor>` and `<DisabledColor>` colour their own fonts; 1.12.1 sends
-                // both to the normal colour setter (`0x778aa4`, `0x778ada` call `0x778e20`), so
-                // neither could reach its state.
+                // `<HighlightColor>` and `<DisabledColor>` colour their own fonts because 1.12.1
+                // sends both to the normal colour setter (`0x778aa4`, `0x778ada` call `0x778e20`),
+                // so neither could reach its state.
                 self.call(wrapper, method, color_of(child).fractions(), dbg);
             } else if is("PushedTextOffset") {
                 // `0x778aec`: the dimension read (`0x6f1eb0`), stored as `SetPushedTextOffset`
diff --git a/crates/benilla-ui/src/order.rs b/crates/benilla-ui/src/order.rs
index 8a3fb20ec..a5cd50e28 100644
--- a/crates/benilla-ui/src/order.rs
+++ b/crates/benilla-ui/src/order.rs
@@ -541,10 +541,10 @@ fn emit_frame(
 /// The scroll child `sf`'s callback draws when it is shown (`0x787267`): a ScrollFrame's live
 /// child still in the scroll draw.
 ///
-/// Deviation: a child that left the scroll draw is drawn once, by the flat pass, where the client's
-/// callback, which reads only the child's visibility, draws it a second time, clipped, at the
-/// ScrollFrame's place. A `SetParent` of the child, of the ScrollFrame or of any ancestor of the
-/// child to an unflagged parent clears `0x2000` on the whole moved subtree (`0x76abcb` →
+/// Deviation: a child that left the scroll draw is drawn once, by the flat pass, because the
+/// client's callback, which reads only the child's visibility, draws it a second time, clipped, at
+/// the ScrollFrame's place. A `SetParent` of the child, of the ScrollFrame or of any ancestor of
+/// the child to an unflagged parent clears `0x2000` on the whole moved subtree (`0x76abcb` →
 /// `0x76a400`), so each of those reaches it.
 fn scroll_child(arena: &WidgetArena, sf: FrameHandle) -> Option<FrameHandle> {
     let KindState::Scroll(s) = &arena.frame(sf)?.kind_state else {
diff --git a/crates/benilla-ui/src/script/addon.rs b/crates/benilla-ui/src/script/addon.rs
index 2f9576c61..fdff4d7e5 100644
--- a/crates/benilla-ui/src/script/addon.rs
+++ b/crates/benilla-ui/src/script/addon.rs
@@ -205,8 +205,8 @@ fn rebuild_index(model: &mut Model) {
 /// check, whose answer 3 makes it SECURE (`0x51dbfb`).
 ///
 /// Deviation: the files the handler writes beside the install (`<Name>.pub` with the key,
-/// `<Name>.url`; `0x51dce0`, `0x51dde0`) are not written, as the install is read-only; the key is
-/// never read either, as there is no signature to verify with it.
+/// `<Name>.url`; `0x51dce0`, `0x51dde0`) are not written, because the install is read-only; the key
+/// is never read either, because there is no signature to verify with it.
 fn apply_reply(addons: &mut [AddOnInfo], reply: &[AddonReply]) {
     for record in reply {
         let Some(a) = addons
@@ -784,8 +784,8 @@ fn load_saved_variables(lua: &Lua, i: usize) {
             Err(e) => {
                 // The reference runs the file under the Lua error handler (`0x704ae0`,
                 // `[0x8722c8]`, `0x704b68`), which stock sets to show the error
-                // (`BasicControls.xml:16`). Deviation: holding the file, so the shutdown write
-                // keeps it.
+                // (`BasicControls.xml:16`). Deviation: holding the file, because that way the
+                // shutdown write keeps it.
                 log_error(lua, &format!("{}: {e}", path.display()));
                 hold(path);
             }
diff --git a/crates/benilla-ui/src/script/calls.rs b/crates/benilla-ui/src/script/calls.rs
index 3c6800714..bbeb66af7 100644
--- a/crates/benilla-ui/src/script/calls.rs
+++ b/crates/benilla-ui/src/script/calls.rs
@@ -729,7 +729,7 @@ fn run_held(lua: &Lua, held: Held) {
 /// such a chain always ends inside its frame.
 ///
 /// Deviation: the reference's only bound is `luaD_call`'s count of 200 nested calls (`0x6f65ae`),
-/// past which it raises `C stack overflow` (`0x6f65bf`); eight here, as each level keeps an
+/// past which it raises `C stack overflow` (`0x6f65bf`); eight here, because each level keeps an
 /// apply's frame on the Rust stack.
 pub(crate) const MAX_NESTING: u8 = 8;
 
diff --git a/crates/benilla-ui/src/script/chat_bubble.rs b/crates/benilla-ui/src/script/chat_bubble.rs
index c43dfffb4..f8fd5fb3c 100644
--- a/crates/benilla-ui/src/script/chat_bubble.rs
+++ b/crates/benilla-ui/src/script/chat_bubble.rs
@@ -480,8 +480,8 @@ fn drive(
 
     // The seat (`0x4b14a0`): the text's BOTTOM on the `WorldFrame`'s BOTTOMLEFT, re-anchored only
     // when the snapped point moved. Deviation: the frame's bottom-left origin is snapped onto the
-    // device grid so the border art blits 1:1; the reference ceils the anchor point itself onto
-    // it (`0x7666a0`, `0x766750`).
+    // device grid because that way the border art blits 1:1; the reference ceils the anchor point
+    // itself onto it (`0x7666a0`, `0x766750`).
     let width = model
         .region_data
         .get(&text)
diff --git a/crates/benilla-ui/src/script/clock.rs b/crates/benilla-ui/src/script/clock.rs
index eadb9c5e3..dae7da573 100644
--- a/crates/benilla-ui/src/script/clock.rs
+++ b/crates/benilla-ui/src/script/clock.rs
@@ -62,8 +62,9 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     let g = lua.globals();
     // GetTime() (`0x515ea0`): one number, `GetTickCount` times the f64 0.001 at `0x801608`.
     // Deviation: the reference reads the clock live at each call (`0x42c010`); ours is the session
-    // clock the tick advances by the paced frame step, one value per frame, so `GetTime()` deltas
-    // and the `elapsed` handed to OnUpdate agree, as FrameXML (CastingBarFrame and kin) assumes.
+    // clock the tick advances by the paced frame step, one value per frame, because that way
+    // `GetTime()` deltas and the `elapsed` handed to OnUpdate agree, as FrameXML (CastingBarFrame
+    // and kin) assumes.
     g.set("GetTime", lua.create_function(|lua, ()| Ok(now(lua)))?)?;
     // GetGameTime() (`0x515ee0`): two numbers, the hour `[0xce853c]` then the minute `[0xce8538]`,
     // the clock the server's time messages set, read at the call through the host; minute
diff --git a/crates/benilla-ui/src/script/container.rs b/crates/benilla-ui/src/script/container.rs
index 70843f85b..c317abf03 100644
--- a/crates/benilla-ui/src/script/container.rs
+++ b/crates/benilla-ui/src/script/container.rs
@@ -751,7 +751,7 @@ fn pickup_container_item(
         // `[0xb4d900] == 5`): `CMSG_BUY_ITEM_IN_SLOT` (0x1a3) with count 1, and the cursor clears
         // either way, the item the row names now; with no vendor open the row stays held
         // (`0x4f9f0f`). Deviation: a row index the list no longer holds buys nothing and drops,
-        // where this path reads through a null row (`0x4f9f35`).
+        // because this path reads through a null row in the reference (`0x4f9f35`).
         Some(CursorPayload::Merchant(_)) if !vendor.open => ContainerClick::Done,
         Some(CursorPayload::Merchant(_)) => {
             if let Some(entry) = vendor.held_entry {
diff --git a/crates/benilla-ui/src/script/craft.rs b/crates/benilla-ui/src/script/craft.rs
index 2c429fc62..83a0f8380 100644
--- a/crates/benilla-ui/src/script/craft.rs
+++ b/crates/benilla-ui/src/script/craft.rs
@@ -923,9 +923,9 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     // table at `0x84d0f4`, the global the stock window labels its button with
     // (`Blizzard_CraftUI.lua:106`). A close zeroes the type, so a closed window answers `USE`.
     // Type 4 reads the zero word after the table, which pushes nil.
-    // Deviation: the reference reads past the table unbounded (`0x4f6c90`), so type 5 would answer
-    // "CloseCraft"; no shipped opener carries a type past 3, and benilla answers nil rather than
-    // read past it.
+    // Deviation: benilla answers nil rather than read past the table, because the reference reads
+    // past it unbounded (`0x4f6c90`), so type 5 would answer "CloseCraft"; no shipped opener
+    // carries a type past 3.
     g.set(
         "GetCraftButtonToken",
         lua.create_function(|lua, ()| {
diff --git a/crates/benilla-ui/src/script/cursor.rs b/crates/benilla-ui/src/script/cursor.rs
index 70a168da1..7106c1d85 100644
--- a/crates/benilla-ui/src/script/cursor.rs
+++ b/crates/benilla-ui/src/script/cursor.rs
@@ -947,10 +947,10 @@ impl super::UiScript {
     /// The unlock-all (`0x495460`), on the revive edge (`0x5fefae`): the player array's items
     /// unlock, then one `ITEM_LOCK_CHANGED` (`0x49557d`).
     ///
-    /// Deviation: every lock lifts here, bag contents included. The reference's walk of a bag's
-    /// contents indexes the bag by its own player-array index (`0x495528`, `0x495535`), at least
-    /// 19, past a bag's slots in every case but the biggest bags, so it normally unlocks none of
-    /// them; a lock it strands lasts until the item's seat or stack moves, which this does not
+    /// Deviation: every lock lifts here, bag contents included, because the reference's walk of a
+    /// bag's contents indexes the bag by its own player-array index (`0x495528`, `0x495535`), at
+    /// least 19, past a bag's slots in every case but the biggest bags, so it normally unlocks none
+    /// of them; a lock it strands lasts until the item's seat or stack moves, which this does not
     /// copy.
     pub fn unlock_all_items(&mut self) {
         for guid in self.item_locks() {
@@ -1251,9 +1251,9 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
             Ok(flag(matches!(model.cursor, Some(CursorPayload::Spell(_)))))
         })?,
     )?;
-    // Deviation: returns nothing. The handler ends `mov eax,1` with nothing pushed (`0x4895bc`), so
-    // Lua 5.0 hands back the stack top, the last argument or the function itself: an accident of
-    // the handler, not an API, and copying a stack-top leak would copy a bug.
+    // Deviation: returns nothing because the handler ends `mov eax,1` with nothing pushed
+    // (`0x4895bc`), so Lua 5.0 hands back the stack top, the last argument or the function itself:
+    // an accident of the handler, not an API, and copying a stack-top leak would copy a bug.
     g.set(
         "ClearCursor",
         lua.create_function(|lua, ()| {
diff --git a/crates/benilla-ui/src/script/cursor/bag_verbs.rs b/crates/benilla-ui/src/script/cursor/bag_verbs.rs
index 2610efc21..213e200a5 100644
--- a/crates/benilla-ui/src/script/cursor/bag_verbs.rs
+++ b/crates/benilla-ui/src/script/cursor/bag_verbs.rs
@@ -130,8 +130,8 @@ fn put_item(lua: &Lua, model: &mut Model, dest: Dest, vendor: VendorAtCall) -> b
         Some(CursorPayload::Item(held)) => place_held(lua, model, dest, held),
         // Mode 5 with a vendor open: one of the row's item into the bag, slot `0xFF`, count 1
         // (`0x4c7e6f`-`0x4c7eaa`), the item the row names now. Deviation: a row index the list no
-        // longer holds buys nothing and drops, where this site reads through a null row
-        // (`0x4c7e9a`, `0x4c7ea5`).
+        // longer holds buys nothing and drops, because this site reads through a null row in the
+        // reference (`0x4c7e9a`, `0x4c7ea5`).
         Some(CursorPayload::Merchant(_)) => {
             if let Some(entry) = vendor.held_entry {
                 model.merchant_call_in_verb(crate::script::MerchantCall::BuyIntoBag {
diff --git a/crates/benilla-ui/src/script/cvars.rs b/crates/benilla-ui/src/script/cvars.rs
index 50d6401f1..6e9f3471f 100644
--- a/crates/benilla-ui/src/script/cvars.rs
+++ b/crates/benilla-ui/src/script/cvars.rs
@@ -894,8 +894,8 @@ const VIDEO_DEFAULT_GX: usize = 6;
 ///
 /// Deviation: the reference (`0x48dad0` into `0x639a20`) writes hardware-recommended values from
 /// its matched `VideoHardware.dbc` row and the `CGxFormat` preset it names (`[0xc4e6ac]`): twelve
-/// `gx*` CVars, a synchronous `RestartGx`, then sixteen more. benilla has no such matching, so its
-/// registered defaults are its recommended configuration.
+/// `gx*` CVars, a synchronous `RestartGx`, then sixteen more. its registered defaults are its
+/// recommended configuration because benilla has no such matching.
 pub const VIDEO_DEFAULT_CVARS: &[&str] = &[
     // Of the twelve `gx*` the device record writes (`0x639c40`), the six benilla registers.
     "gxWindow",
diff --git a/crates/benilla-ui/src/script/editbox/flush.rs b/crates/benilla-ui/src/script/editbox/flush.rs
index 6c04105e1..85ca3e9b1 100644
--- a/crates/benilla-ui/src/script/editbox/flush.rs
+++ b/crates/benilla-ui/src/script/editbox/flush.rs
@@ -26,7 +26,7 @@ pub(in crate::script) fn update(lua: &Lua, h: FrameHandle, dt: f32) {
 /// before the key or click acts.
 ///
 /// Deviation: the promotion's IME legs (`0x77d417`–`0x77d431`) and the IME writer's `or 6`
-/// (`0x77acde`, in `0x77ac60`) are not modelled: benilla has no IME composition.
+/// (`0x77acde`, in `0x77ac60`) are not modelled because benilla has no IME composition.
 pub(super) fn flush(lua: &Lua, h: FrameHandle) {
     let Some((entry, owed, left)) = with_eb(lua, h, |eb| {
         (eb.dirty, eb.relayout_owed, !eb.caret_in_window())
diff --git a/crates/benilla-ui/src/script/glue_core.rs b/crates/benilla-ui/src/script/glue_core.rs
index 1177292ba..21b66144a 100644
--- a/crates/benilla-ui/src/script/glue_core.rs
+++ b/crates/benilla-ui/src/script/glue_core.rs
@@ -421,9 +421,9 @@ const LAUNCH_HOSTS: [&str; 10] = [
 /// reference works on a C string, so the verb cuts its argument at a NUL before asking; a URL with
 /// a NUL in it is refused here.
 ///
-/// Deviation: a host of 0x80 bytes or more is refused. The reference copies the host into a 0x80-byte
-/// buffer (`0x5abc7c`-`0x5abc9c`) and writes its terminator one byte past the end, and the cut
-/// host could end in a whitelisted suffix the real one does not; this takes the safe side.
+/// Deviation: a host of 0x80 bytes or more is refused because the reference copies the host into a
+/// 0x80-byte buffer (`0x5abc7c`-`0x5abc9c`) and writes its terminator one byte past the end, and
+/// the cut host could end in a whitelisted suffix the real one does not; this takes the safe side.
 pub fn launch_url_allowed(url: &str) -> bool {
     if url.len() >= 0x400 || url.contains('\0') {
         return false;
diff --git a/crates/benilla-ui/src/script/glue_realm.rs b/crates/benilla-ui/src/script/glue_realm.rs
index 979684844..041ac8fa5 100644
--- a/crates/benilla-ui/src/script/glue_realm.rs
+++ b/crates/benilla-ui/src/script/glue_realm.rs
@@ -193,8 +193,8 @@ impl GlueRealmList {
     /// The categories: the Region's rows, or one that holds every realm when there are none.
     ///
     /// Deviation: with no Region rows the reference reads a NULL category (`0x46e5b8`,
-    /// `0x46f26a`) and faults; benilla lists every realm under one category, so a client whose
-    /// `Wow.ini` names another Region still reaches a realm.
+    /// `0x46f26a`) and faults; benilla lists every realm under one category, because that way a
+    /// client whose `Wow.ini` names another Region still reaches a realm.
     fn categories(&self) -> Vec<Category> {
         if self.rows.is_empty() {
             return vec![Category {
diff --git a/crates/benilla-ui/src/script/held.rs b/crates/benilla-ui/src/script/held.rs
index 339405680..556af6711 100644
--- a/crates/benilla-ui/src/script/held.rs
+++ b/crates/benilla-ui/src/script/held.rs
@@ -71,7 +71,7 @@ impl LiveQuery for HasKeyQuery {
 /// The slot `(bag, slot)` as a container binding finds it now, through the bag lookup's and
 /// `GetItemInSlot`'s bank gates ([`Model::bank_bag_shut`], [`Model::vault_shut`]): the host's,
 /// else the VM's copy.
-// Deviation: the backpack, the bank and the keyring are each bounded by their own slots, where
+// Deviation: the backpack, the bank and the keyring are each bounded by their own slots, because
 // `0x4f990f` bounds them only by the player list's count (0x71) from their bases (the bank at
 // `+0x27`, `0x4f98ae`; the keyring at `+0x51`, `0x4f98c0`), a reference bug that lets their index
 // read the next container's slots.
diff --git a/crates/benilla-ui/src/script/hyperlink.rs b/crates/benilla-ui/src/script/hyperlink.rs
index aad35aae9..e91b7ae53 100644
--- a/crates/benilla-ui/src/script/hyperlink.rs
+++ b/crates/benilla-ui/src/script/hyperlink.rs
@@ -164,9 +164,9 @@ pub(super) fn set_spans(lua: &Lua, spans: Vec<(FrameHandle, Rect, String, String
 /// size moved. A ScrollingMessageFrame compares its lines' box (`0x788394`, `0x7883b2`); a
 /// SimpleHTML's layout callback (`0x78a320`) raises the flag when the frame's width or height
 /// changed by [`HTML_RESIZE`] or more, or is NaN (`0x78a340`-`0x78a369`).
-/// Deviation: a span count that no longer matches the live set always rebuilds, so a state this
-/// model does not flag (a ring wiped by `SetMaxLines`, a hidden frame, a frame not yet laid out,
-/// which the reference's rebuild skips at `0x78af7b`) leaves no stale button.
+/// Deviation: a span count that no longer matches the live set always rebuilds, because that way a
+/// state this model does not flag (a ring wiped by `SetMaxLines`, a hidden frame, a frame not yet
+/// laid out, which the reference's rebuild skips at `0x78af7b`) leaves no stale button.
 fn due(lua: &Lua, owner: FrameHandle, list: &[Span]) -> bool {
     let mut model = lua.app_data_mut::<Model>().expect("model");
     let model = &mut *model;
diff --git a/crates/benilla-ui/src/script/item_stats.rs b/crates/benilla-ui/src/script/item_stats.rs
index 0f5e9ad05..19b14c0ea 100644
--- a/crates/benilla-ui/src/script/item_stats.rs
+++ b/crates/benilla-ui/src/script/item_stats.rs
@@ -657,7 +657,8 @@ fn equip_loc_token(inventory_type: u32) -> &'static str {
         "INVTYPE_QUIVER",
         "INVTYPE_RELIC",
     ];
-    // Deviation: bounds-checked where the reference indexes unguarded, so none reads past it.
+    // Deviation: bounds-checked where the reference indexes unguarded, because that way none reads
+    // past it.
     TOKENS.get(inventory_type as usize).copied().unwrap_or("")
 }
 
@@ -809,7 +810,7 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
                 Value::String(lua.create_string(str_or_empty(&info.item_sub_type))?),
                 Value::Integer(i64::from(info.stackable)),
                 Value::String(lua.create_string(equip_loc_token(inventory_type))?),
-                // Deviation: nil for a display row with no icon, where the reference answers the
+                // Deviation: nil for a display row with no icon, because the reference answers the
                 // unloadable `Interface\Icons\`, on which `SetTexture` keeps the previous image
                 // (`0x7702ac`), so a reused button would show its old icon.
                 match &icon {
diff --git a/crates/benilla-ui/src/script/keybind.rs b/crates/benilla-ui/src/script/keybind.rs
index b94e7aef4..44d7eee85 100644
--- a/crates/benilla-ui/src/script/keybind.rs
+++ b/crates/benilla-ui/src/script/keybind.rs
@@ -222,7 +222,8 @@ impl KeybindState {
     ///
     /// Deviation: a key rebound to the command it already has keeps a duplicate index in 1.12.1
     /// (`0x4b7786` lowers the other keys' indices before `0x4b77ac` returns on the same name), so
-    /// both getters there answer one key too few; that client fault is not reproduced.
+    /// both getters there answer one key too few; it is not reproduced because it is a client
+    /// fault.
     fn keys_of<'a>(&'a self, command: &'a str) -> impl Iterator<Item = &'a String> + 'a {
         self.live
             .iter()
diff --git a/crates/benilla-ui/src/script/layer_batch.rs b/crates/benilla-ui/src/script/layer_batch.rs
index 89b968aee..a6c63d180 100644
--- a/crates/benilla-ui/src/script/layer_batch.rs
+++ b/crates/benilla-ui/src/script/layer_batch.rs
@@ -6,13 +6,14 @@
 //! share ([`super::texel`]). The sort is not stable, so a batch of one texture comes out in the
 //! CRT's own order, two quads reversed.
 //!
-//! Deviation: the handle's value is the address of a `CGxTex` (`SMemAlloc(0x54)`, `0x594a96`),
-//! which benilla cannot reproduce; each texture ranks instead by a creation stamp, one global
-//! sequence number taken when its cache key is first created and taken anew once its last region
-//! has let go of it ([`super::texel::Texels`]). On a heap that grows as it allocates, a later
-//! device texture sits at a higher address, so the stamp orders textures as their addresses do,
-//! as far as anything deterministic can: it parts from them where the heap reuses a freed block
-//! or the device recycles a pooled texture of the same size (`0x448531`).
+//! Deviation: each texture ranks by a creation stamp, not by the handle's value, because the
+//! handle's value is the address of a `CGxTex` (`SMemAlloc(0x54)`, `0x594a96`), which benilla
+//! cannot reproduce. The stamp is one global sequence number taken when its cache key is first
+//! created and taken anew once its last region has let go of it ([`super::texel::Texels`]). On a
+//! heap that grows as it allocates, a later device texture sits at a higher address, so the stamp
+//! orders textures as their addresses do, as far as anything deterministic can: it parts from them
+//! where the heap reuses a freed block or the device recycles a pooled texture of the same size
+//! (`0x448531`).
 
 /// One texture quad of the extract: its index in the list, its batch and its texture's rank.
 pub(super) struct BatchQuad {
diff --git a/crates/benilla-ui/src/script/macros.rs b/crates/benilla-ui/src/script/macros.rs
index 42ff9e355..d6169b109 100644
--- a/crates/benilla-ui/src/script/macros.rs
+++ b/crates/benilla-ui/src/script/macros.rs
@@ -124,8 +124,8 @@ pub(super) fn cut_bytes(s: &str, max: usize) -> &str {
 }
 
 /// A name as `SStrCopy` keeps it (`0x4f11fc`): its first [`MAX_MACRO_NAME`] bytes, not trimmed.
-/// Deviation: the reference's byte copy can end inside a character and keep the stray bytes; a
-/// `String` must stay UTF-8, so the cut stops at the character boundary.
+/// Deviation: the reference's byte copy can end inside a character and keep the stray bytes; here
+/// the cut stops at the character boundary because a `String` must stay UTF-8.
 fn cut_name(name: &str) -> String {
     cut_bytes(name, MAX_MACRO_NAME).to_string()
 }
@@ -549,7 +549,7 @@ fn pickup_macro(lua: &Lua, index: usize) -> bool {
 
 /// Build the icon list if it is empty, as the three verbs do before they read it (`0x4f0090`
 /// behind a zero count). The source runs with no borrow of the model held. Deviation: a listing
-/// that finds no icon stays empty, to be listed again on the next ask, where the reference's
+/// that finds no icon stays empty, to be listed again on the next ask, because the reference's
 /// dedup then reads below its null list (`0x4f0134`-`0x4f0145`) and faults.
 fn ensure_macro_icons(lua: &Lua) {
     let source = {
diff --git a/crates/benilla-ui/src/script/mod.rs b/crates/benilla-ui/src/script/mod.rs
index 2fb452d61..7580f3134 100644
--- a/crates/benilla-ui/src/script/mod.rs
+++ b/crates/benilla-ui/src/script/mod.rs
@@ -951,8 +951,9 @@ impl UiScript {
     /// runs. The app arms it only for the world-entry load, so a hung load reports instead of
     /// freezing the loading screen, and disarms it ([`Self::clear_instruction_budget`]) before the
     /// session's first frame. Deviation: the client's Lua has no such bound, as nothing sets a
-    /// hook (`lua_sethook`, `0x6fba40`, has no caller and no pointer to it), so a load that
-    /// never ends hangs it.
+    /// hook (`lua_sethook`, `0x6fba40`, has no caller and no pointer to it), so a load that never
+    /// ends hangs it; benilla bounds it because a hung load would otherwise freeze the loading
+    /// screen instead of reporting.
     ///
     /// An abort runs no error handler, so its message waits and is handed to the error function
     /// when the budget is disarmed, as a compile failure is (`0x704b42`), once per arming: the
diff --git a/crates/benilla-ui/src/script/pvp/mod.rs b/crates/benilla-ui/src/script/pvp/mod.rs
index 129744afa..b8eeba6fe 100644
--- a/crates/benilla-ui/src/script/pvp/mod.rs
+++ b/crates/benilla-ui/src/script/pvp/mod.rs
@@ -565,9 +565,9 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     // pushes the buffer), and the miss asks the name cache with its callback (`0x55f080`,
     // `0x5fb840`) as `UnitName`'s does.
     //
-    // Deviation: a token resolving to guid 0 answers nil too. The reference jumps from the guid
-    // test (`0x5172f6`) to `return 1` (`0x517343`) with nothing pushed, so the one value is its
-    // top argument, the token it read (`0x5172e6`); that is a stack quirk, not an answer.
+    // Deviation: a token resolving to guid 0 answers nil too because the reference jumps from the
+    // guid test (`0x5172f6`) to `return 1` (`0x517343`) with nothing pushed, so the one value is
+    // its top argument, the token it read (`0x5172e6`); that is a stack quirk, not an answer.
     //
     // Deviation: with `UNIT_PVP_NAME` or the title missing from `_G` (no install) this answers
     // the plain name, where the reference would format an empty string, because the decoration
diff --git a/crates/benilla-ui/src/script/quest_log.rs b/crates/benilla-ui/src/script/quest_log.rs
index 583c7712e..1107353b0 100644
--- a/crates/benilla-ui/src/script/quest_log.rs
+++ b/crates/benilla-ui/src/script/quest_log.rs
@@ -1650,7 +1650,7 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     // The reference counts the reward ids to the first unset one (`0x4e0a34`-`0x4e0a40`), so
     // `[A, 0, B, 0]` counts 1, and `GetQuestLogRewardInfo` indexes the raw array (`0x4e0b98`);
     // the choices count the same way (`0x4e0ac4`-`0x4e0ad0`).
-    // Deviation: four set ids count 4, where the loop's exit `jmp 0x4e0a4c` (`0x4e0a42`) skips
+    // Deviation: four set ids count 4, because the loop's exit `jmp 0x4e0a4c` (`0x4e0a42`) skips
     // the store at `0x4e0a49` and answers 0, a client bug.
     install_detail_count(lua, "GetNumQuestLogRewards", |r| {
         count_to_first_unset(&r.rewards)
diff --git a/crates/benilla-ui/src/script/reputation.rs b/crates/benilla-ui/src/script/reputation.rs
index 6cc164255..073f4097c 100644
--- a/crates/benilla-ui/src/script/reputation.rs
+++ b/crates/benilla-ui/src/script/reputation.rs
@@ -628,9 +628,9 @@ fn slot_of(lua: &Lua, model: &Model, faction: i64) -> Option<u32> {
 /// (`0x4d6476`). A header key no header object holds changes nothing and sorts nothing
 /// (`0x4d6489`); `false` then.
 ///
-/// Deviation: the folds are keyed by header, not by the reference's mask positions, whose rebuild
-/// folds bit N-1 by registration index before the sort (`0x4d5d49`-`0x4d5d68`) and whose fold
-/// verbs search `0xb736c0` before `0x4d5c40` sorts it (`0x4d6400`), so Inactive opens at login
+/// Deviation: the folds are keyed by header, not by the reference's mask positions, because their
+/// rebuild folds bit N-1 by registration index before the sort (`0x4d5d49`-`0x4d5d68`) and their
+/// fold verbs search `0xb736c0` before `0x4d5c40` sorts it (`0x4d6400`), so Inactive opens at login
 /// whenever a childless header exists and inactivating a header's last child shows it expanded;
 /// that is a reference bug, and the folds follow the header the player clicked.
 fn set_collapsed(model: &mut Model, index: usize, collapse: bool) -> bool {
diff --git a/crates/benilla-ui/src/script/saved.rs b/crates/benilla-ui/src/script/saved.rs
index 6b399d1e9..11eccba55 100644
--- a/crates/benilla-ui/src/script/saved.rs
+++ b/crates/benilla-ui/src/script/saved.rs
@@ -19,14 +19,15 @@ use mlua::{Lua, Table, Value};
 use super::{binding_abi, Model};
 
 /// Deviation: nesting stops at 32 where the reference recurses uncapped (its indent saturates at
-/// `0x80`), so a hostile structure cannot exhaust the stack.
+/// `0x80`), because that way a hostile structure cannot exhaust the stack.
 const MAX_DEPTH: usize = 32;
 
 impl super::UiScript {
     /// Hold a saved-variables file that failed to load, so the shutdown write leaves it alone.
     /// Deviation: the reference rewrites it from the live defaults (`0x51f865`–`0x51f970`) after
     /// renaming the old file to `.bak` (`0x51f794`, `0x51f8eb`, `.bak` at `0x8431e4`), so a hand
-    /// edit with one typo survives only until the next logout.
+    /// edit with one typo survives only until the next logout; benilla holds the file instead,
+    /// because that way the shutdown write leaves it alone.
     pub fn hold_saved_file(&self, path: &std::path::Path) {
         let mut model = self.model_mut();
         if !model.held_saved_files.iter().any(|p| p == path) {
@@ -194,7 +195,7 @@ fn flat_line(line: &[u8]) -> Option<(Vec<u8>, Option<FlatValue>)> {
 
 /// A quoted value cut at its last `"` above index 1 (`0x4914c3`-`0x4914e0`), so `""` and an
 /// unterminated `"abc` are empty, which `0x704300` sets as nil (`0x70430f`).
-/// Deviation: the writer's escapes are undone ([`unescape`]), where the reference sets the bytes
+/// Deviation: the writer's escapes are undone ([`unescape`]), because the reference sets the bytes
 /// between the quotes raw, so a string holding a quote or a backslash would grow every session.
 fn flat_string(value: &[u8]) -> Option<Vec<u8>> {
     let close = (2..value.len())
diff --git a/crates/benilla-ui/src/script/spellbook.rs b/crates/benilla-ui/src/script/spellbook.rs
index 04457abdc..37f2dd200 100644
--- a/crates/benilla-ui/src/script/spellbook.rs
+++ b/crates/benilla-ui/src/script/spellbook.rs
@@ -8,7 +8,8 @@
 //! word and a `CMSG_PET_ACTION` instead.
 //!
 //! Deviation: `BOOKTYPE_SPELL`/`BOOKTYPE_PET` are engine globals here, where the reference defines
-//! them in `SpellBookFrame.lua:5-6`, so this module's tests run without the stock file.
+//! them in `SpellBookFrame.lua:5-6`, because that way this module's tests run without the stock
+//! file.
 
 use std::borrow::Cow;
 
diff --git a/crates/benilla-ui/src/script/stdlib.rs b/crates/benilla-ui/src/script/stdlib.rs
index 018bfbb44..e6afc5d54 100644
--- a/crates/benilla-ui/src/script/stdlib.rs
+++ b/crates/benilla-ui/src/script/stdlib.rs
@@ -98,9 +98,10 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
 /// counter's delta over `trunc(1000 / scale) / 1000` (`0x7028a6`-`0x7028c4`), `scale` being the
 /// millisecond clock's (`0x8332c8`). That is milliseconds only once the clock has moved onto the
 /// counter; on a multi-core processor it never does (`0x42b8be`), the scale stays 1.0, and the
-/// answer is a raw cycle count. Deviation: ours answers milliseconds, since a cycle count of unknown
-/// rate is no use to an addon timing its code. Both read a live monotonic clock at the call, as the
-/// counter is read, not the per-frame `GetTime()` clock, so a span inside one frame measures.
+/// answer is a raw cycle count. Deviation: ours answers milliseconds, because a cycle count of
+/// unknown rate is no use to an addon timing its code. Both read a live monotonic clock at the
+/// call, as the counter is read, not the per-frame `GetTime()` clock, so a span inside one frame
+/// measures.
 fn install_profile(lua: &Lua) -> mlua::Result<()> {
     use std::sync::atomic::{AtomicU64, Ordering};
     // The latch as nanoseconds past this VM's origin; 0 until a start, as `[0xceeb58]` is.
diff --git a/crates/benilla-ui/src/script/taxi.rs b/crates/benilla-ui/src/script/taxi.rs
index 5a16d9e3e..a110ce1a5 100644
--- a/crates/benilla-ui/src/script/taxi.rs
+++ b/crates/benilla-ui/src/script/taxi.rs
@@ -232,9 +232,9 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     )?;
 
     // The reference computes the hovered node's route here; the app precomputes every route.
-    // Deviation: returns nothing. The handler ends `mov eax,1` with nothing pushed (`0x4dcd7c`), so
-    // Lua 5.0 hands back the stack top, the node argument: an accident of the handler, not an API,
-    // and copying a stack-top leak would copy a bug.
+    // Deviation: returns nothing because the handler ends `mov eax,1` with nothing pushed
+    // (`0x4dcd7c`), so Lua 5.0 hands back the stack top, the node argument: an accident of the
+    // handler, not an API, and copying a stack-top leak would copy a bug.
     g.set(
         "TaxiNodeSetCurrent",
         lua.create_function(|lua, slot: Value| {
diff --git a/crates/benilla-ui/src/script/tooltip/verbs.rs b/crates/benilla-ui/src/script/tooltip/verbs.rs
index f4c2eb99e..1672c09a7 100644
--- a/crates/benilla-ui/src/script/tooltip/verbs.rs
+++ b/crates/benilla-ui/src/script/tooltip/verbs.rs
@@ -49,8 +49,8 @@ pub(in crate::script) fn install(lua: &Lua) -> mlua::Result<()> {
                 // hidden tooltip: its `[0]` with no type test, so a texture or a font string
                 // owns it too; a NULL raises `%s:SetOwner(): Couldn't find 'this' in owner
                 // object`, naming the tooltip (`0x5311bb`, `0x855150`). Deviation: the reference
-                // anchors a Font object through its +0x24 with no type test (`0x5313c9`),
-                // undefined; benilla raises the owner line.
+                // anchors a Font object through its +0x24 with no type test (`0x5313c9`); benilla
+                // raises the owner line because the result there is undefined.
                 let owner_h = owner_id(&owner)?
                     .filter(|id| {
                         let model = lua.app_data_ref::<Model>().expect("model app_data");
diff --git a/crates/benilla-ui/src/script/tooltip_aura.rs b/crates/benilla-ui/src/script/tooltip_aura.rs
index 6ab8118a4..0d676e598 100644
--- a/crates/benilla-ui/src/script/tooltip_aura.rs
+++ b/crates/benilla-ui/src/script/tooltip_aura.rs
@@ -241,7 +241,8 @@ pub(super) fn install_methods(lua: &Lua, m: &Table) -> mlua::Result<()> {
                 // remaining" (`0x4e447e`); else it is whatever the last occupant left, as
                 // `ResetBuffCache 0x4e40c0` and the compaction's tail reset (`0x4e4237`)
                 // call `0x4e44b0` with slot -1, which writes `+0x0` and `+0x4` alone
-                // (`0x4e44bc`-`0x4e44c0`). A line on a stale byte is a fault to not ape.
+                // (`0x4e44bc`-`0x4e44c0`). No time line follows here because a line on a stale byte
+                // is a fault to not ape.
                 None => (AuraKey::default(), None, None),
             };
             // `0x52fa50`'s text from the player's own strings; without them the line is skipped.
diff --git a/crates/benilla-ui/src/script/tooltip_item/build.rs b/crates/benilla-ui/src/script/tooltip_item/build.rs
index f8e2ae5f8..eb21b3e15 100644
--- a/crates/benilla-ui/src/script/tooltip_item/build.rs
+++ b/crates/benilla-ui/src/script/tooltip_item/build.rs
@@ -201,9 +201,9 @@ impl ItemBuild {
     /// and the durability. A name the build lacked is read as it is now.
     ///
     /// Deviation: an object no longer held rebuilds from the instance the build read, where the
-    /// reference's lookup finds no object and builds from the record and the block alone;
-    /// benilla's views carry no object to read once it is gone, and the kept instance is what the
-    /// plate showed.
+    /// reference's lookup finds no object and builds from the record and the block alone; benilla
+    /// rebuilds from the kept instance because its views carry no object to read once it is gone,
+    /// and the kept instance is what the plate showed.
     fn refreshed(mut self, lua: &Lua, model: &Model) -> Self {
         let Some(kept) = self.inst.take() else {
             return self;
diff --git a/crates/benilla-ui/src/script/tooltip_item/render.rs b/crates/benilla-ui/src/script/tooltip_item/render.rs
index 4c519d30f..e1c2d08a4 100644
--- a/crates/benilla-ui/src/script/tooltip_item/render.rs
+++ b/crates/benilla-ui/src/script/tooltip_item/render.rs
@@ -198,7 +198,7 @@ pub(in crate::script) struct BuilderFlags {
 
 /// The deepest product build a recipe line nests. Deviation: the reference recurses without a
 /// bound (`0x52dbce` builds the product whatever the depth), so a product that teaches a recipe
-/// for itself would recurse until the stack overflows; benilla stops here, so a cyclic
+/// for itself would recurse until the stack overflows; benilla stops here because that way a cyclic
 /// `Spell.dbc` chain cannot crash the client.
 const MAX_PRODUCT_DEPTH: u8 = 4;
 
@@ -572,7 +572,7 @@ pub(super) fn render_view_flagged(
         }
         // Stats in the display order of `0x808e88` (4,3,7,5,6,1,0, then 8,9,2,10 and zero padding;
         // `0x52c6b0..0x52c801`), not wire order. Deviation: the reference's padding repeats a mana
-        // stat once per zero entry; not emulated, since only the internal test ring 6674 has one.
+        // stat once per zero entry; not emulated, because only the internal test ring 6674 has one.
         const STAT_DISPLAY_ORDER: [u32; 7] = [4, 3, 7, 5, 6, 1, 0];
         for &want in &STAT_DISPLAY_ORDER {
             for &(t, val) in &v.stats {
diff --git a/crates/benilla-ui/src/script/unit/by_name.rs b/crates/benilla-ui/src/script/unit/by_name.rs
index 3efc97b0a..b7b74a296 100644
--- a/crates/benilla-ui/src/script/unit/by_name.rs
+++ b/crates/benilla-ui/src/script/unit/by_name.rs
@@ -58,7 +58,7 @@ impl Rank {
     /// [`Rank::beats`] with the guid as the last key: of two equal ranks the lower guid wins. A
     /// NaN distance is equal to nothing, so it still keeps the incumbent.
     ///
-    /// Deviation: a full tie goes to the lower guid, where the reference keeps the first unit its
+    /// Deviation: a full tie goes to the lower guid, because the reference keeps the first unit its
     /// walk (`0x493aa0`) reaches, an order neither of ours has; a guid keeps the two picks equal.
     pub fn beats_at(self, guid: u64, other: Rank, other_guid: u64) -> bool {
         self.beats(other) || (self == other && guid < other_guid)
diff --git a/crates/benilla-ui/src/script/unit/resolve.rs b/crates/benilla-ui/src/script/unit/resolve.rs
index d1cfdd67e..8df604cfe 100644
--- a/crates/benilla-ui/src/script/unit/resolve.rs
+++ b/crates/benilla-ui/src/script/unit/resolve.rs
@@ -82,8 +82,8 @@ pub fn resolve_unit_in(
         },
         UnitBase::Target => globals.target(),
         UnitBase::Npc => globals.npc(),
-        // Deviation: `0x4e81d0` has no bound and reads past its four-entry table, which is
-        // stale memory, not a mechanism; past it, nobody.
+        // Deviation: `0x4e81d0` has no bound and reads past its four-entry table; past it, nobody,
+        // because what it reads there is stale memory, not a mechanism.
         UnitBase::PartyPet(row) => pet(globals.party(row), &|| globals.party_pet_record(row)),
         // Capped at 4 (`0x4e81b0`).
         UnitBase::Party(row) => globals.party(row),
diff --git a/crates/benilla-ui/src/script/who_sort.rs b/crates/benilla-ui/src/script/who_sort.rs
index a08ff7eee..630b8add4 100644
--- a/crates/benilla-ui/src/script/who_sort.rs
+++ b/crates/benilla-ui/src/script/who_sort.rs
@@ -156,8 +156,8 @@ fn ascii_ci_cmp(a: &str, b: &str) -> Ordering {
 fn dbc_name_cmp(a: Option<&str>, b: Option<&str>) -> Ordering {
     match (a, b) {
         (None, None) => Ordering::Equal,
-        // Deviation: the reference ties a miss against a hit (`0x5adab6`); no total order can, and
-        // `sort_by` may panic on one that is not, so the miss goes last.
+        // Deviation: the reference ties a miss against a hit (`0x5adab6`); here the miss goes last
+        // because no total order can, and `sort_by` may panic on one that is not.
         (None, Some(_)) => Ordering::Greater,
         (Some(_), None) => Ordering::Less,
         (Some(a), Some(b)) => ascii_ci_cmp(a, b),
diff --git a/crates/benilla-ui/src/strings.rs b/crates/benilla-ui/src/strings.rs
index cd6ca0631..1a728727b 100644
--- a/crates/benilla-ui/src/strings.rs
+++ b/crates/benilla-ui/src/strings.rs
@@ -43,8 +43,8 @@ pub fn string_to_bool(s: &str) -> bool {
 /// that is not doubled (`||` skips its second) and is followed by a number that `SStrToInt`
 /// (`0x64ac60`) reads as 1 or 2, then rewrites every escape of that kind in the text
 /// ([`korean_particles`] for `|1`, [`french_articles`] for `|2`), and starts over on the result
-/// until neither is left. Deviation: a pass that changes nothing (`|01`, `|02`) ends the scan, where
-/// the reference loops on it for ever. Text with no `|` is returned as it came.
+/// until neither is left. Deviation: a pass that changes nothing (`|01`, `|02`) ends the scan,
+/// because the reference loops on it for ever. Text with no `|` is returned as it came.
 pub fn expand_grammar_escapes(text: &str) -> std::borrow::Cow<'_, str> {
     use std::borrow::Cow;
     let mut cur = Cow::Borrowed(text);
diff --git a/crates/benilla-ui/src/widget/kinds/editbox.rs b/crates/benilla-ui/src/widget/kinds/editbox.rs
index 744f74e50..c42c6fcb3 100644
--- a/crates/benilla-ui/src/widget/kinds/editbox.rs
+++ b/crates/benilla-ui/src/widget/kinds/editbox.rs
@@ -244,11 +244,11 @@ impl EditBoxState {
     /// One UP (`older`) or DOWN step, returning the text to show: the first UP stashes the draft,
     /// and DOWN past the newest entry restores it.
     ///
-    /// Deviation: the history browses as a shell's does, a small everyday gain: the first UP
-    /// stashes the line being typed and DOWN past the newest line brings it back, UP holds at the
-    /// oldest, DOWN does nothing when not browsing, typing or a focus gain ends the browse, and an
-    /// empty line is not kept. The reference's history is a ring of `historyLines` slots that
-    /// keeps any line (`0x77cf40`); UP scans back for the previous filled slot, wrapping
+    /// Deviation: the history browses as a shell's does because it is a small everyday gain: the
+    /// first UP stashes the line being typed and DOWN past the newest line brings it back, UP holds
+    /// at the oldest, DOWN does nothing when not browsing, typing or a focus gain ends the browse,
+    /// and an empty line is not kept. The reference's history is a ring of `historyLines` slots
+    /// that keeps any line (`0x77cf40`); UP scans back for the previous filled slot, wrapping
     /// (`0x77d030`), DOWN forward with `idiv` (`0x77cfd0`), each a `SetText` (`0x77be00`), with no
     /// draft and no stop at either end.
     pub fn history_step(&mut self, older: bool) -> Option<String> {
@@ -816,8 +816,8 @@ impl EditBoxState {
             self.extend_to(target);
         } else if self.sel_start != self.sel_end {
             // Deviation: a plain Left or Right (or Ctrl+B or F) with a selection collapses it to
-            // that edge, as every OS's own text fields do; the reference clears the selection and
-            // steps once from the caret (`0x77c6b0` from `0x77c70b`).
+            // that edge, because every OS's own text fields do; the reference clears the selection
+            // and steps once from the caret (`0x77c6b0` from `0x77c70b`).
             self.cursor = if right { self.sel_end } else { self.sel_start };
             self.collapse();
         } else {
@@ -835,7 +835,7 @@ impl EditBoxState {
     /// (`0x77c8c0`) steps back over the spaces before the caret, then over the non-spaces.
     ///
     /// Deviation: Left reads the whole character before the caret, not the lone byte `caret - 1`
-    /// the client reads (`0x77c8da`), which takes a multi-byte space for a non-space.
+    /// the client reads (`0x77c8da`), because that takes a multi-byte space for a non-space.
     pub fn move_by_word(&mut self, right: bool, extend: bool) {
         // Right crosses non-spaces, then spaces; left spaces, then non-spaces.
         let first_is_space = !right;
@@ -998,12 +998,12 @@ impl EditBoxState {
     /// click (`0x77b800`) and the drag (`0x77a860`). Bit 2 rises only when the caret moved; a
     /// click raises it on its own.
     ///
-    /// Deviation: the drag selects from its anchor, as every OS's own text fields do, where the
-    /// reference's applies `0x77cd10` to each mouse move's whole delta (`0x77a8a1`). The two part
-    /// in two cases. One move that carries the caret across the anchor keeps the far end selected
-    /// too in the reference. And a drag that starts with the caret inside a selection, as after a
-    /// focus that selects all, gives `(0, t)` here dragging right to `t`, where the reference
-    /// gives `(t, len)`.
+    /// Deviation: the drag selects from its anchor, because every OS's own text fields do, where
+    /// the reference's applies `0x77cd10` to each mouse move's whole delta (`0x77a8a1`). The two
+    /// part in two cases. One move that carries the caret across the anchor keeps the far end
+    /// selected too in the reference. And a drag that starts with the caret inside a selection, as
+    /// after a focus that selects all, gives `(0, t)` here dragging right to `t`, where the
+    /// reference gives `(t, len)`.
     pub fn move_caret_to(&mut self, target: usize, extend: bool) {
         let from = self.cursor;
         let target = snap_down(&self.text, target.min(self.text.len()));
@@ -1128,7 +1128,7 @@ fn colour_carry(display: &str, from: usize) -> Option<&str> {
 /// spaces. From U+0100 it is the system's `GetStringTypeW` space type: the Unicode spaces, but not
 /// the zero-width ones.
 ///
-/// Deviation: a code point past U+FFFF is no space, where the client tests its low 16 bits, so
+/// Deviation: a code point past U+FFFF is no space, because the client tests its low 16 bits, so
 /// U+10020 counts as a space there.
 fn is_space(c: char) -> bool {
     matches!(
diff --git a/crates/benilla-ui/src/widget/kinds/messageframe.rs b/crates/benilla-ui/src/widget/kinds/messageframe.rs
index 8fe4e6dd0..4d5b7bdff 100644
--- a/crates/benilla-ui/src/widget/kinds/messageframe.rs
+++ b/crates/benilla-ui/src/widget/kinds/messageframe.rs
@@ -118,8 +118,9 @@ impl Default for ScrollingMessageState {
 /// which stops one byte short of the size (`0x64a5cf`, `0x64a5e0`), so N - 1 bytes; 0 is the
 /// buffer that grows (`0x771e16`), and -1 a buffer of no bytes, so an empty line.
 /// Deviation: the cut backs up to a character start, where the reference cuts at the byte,
-/// because a Rust string holds whole characters. Deviation: N of -2 or less is an empty line too,
-/// where the reference asks `SMemAlloc` for about 4 GB and fails.
+/// because a Rust string holds whole characters.
+/// Deviation: N of -2 or less is an empty line too, because the reference asks `SMemAlloc` for
+/// about 4 GB and fails.
 fn clip_line(mut text: String, bytes: LineBytes) -> String {
     match bytes {
         LineBytes::Whole => {}
diff --git a/crates/benilla-ui/src/widget/kinds/mod.rs b/crates/benilla-ui/src/widget/kinds/mod.rs
index 536a44531..afc83cf0b 100644
--- a/crates/benilla-ui/src/widget/kinds/mod.rs
+++ b/crates/benilla-ui/src/widget/kinds/mod.rs
@@ -963,7 +963,7 @@ pub const MINIMAP_INDOOR_RADII: [f32; 6] = [150.0, 120.0, 90.0, 60.0, 40.0, 25.0
 /// The minimap's radius in yards (`0x6da9b0`): with the indoor byte set the indoor table at the
 /// indoor index (`0x6da9bf`), else the outdoor chunk count times 0.5 and 33.333332 (`0x6da9e9`,
 /// `0x6da9ef`). The ping, the blips and the dots all use it. Deviation: an index past 5 reads the
-/// last entry, where 1.12.1 reads past both six-entry tables (`0x6da9d5`, `0x6da9c4`), a client
+/// last entry, because 1.12.1 reads past both six-entry tables (`0x6da9d5`, `0x6da9c4`), a client
 /// fault a hand-edited CVar reaches.
 pub fn minimap_radius_yd(zoom: u32, inside_zoom: u32, inside: bool) -> f32 {
     let at = |z: u32| z.min(u32::from(MINIMAP_ZOOM_LEVELS - 1)) as usize;
@@ -1065,7 +1065,8 @@ pub struct ButtonState {
     /// and drag edges skip the button, and an `Enable`/`Disable` that runs (`0x779160`) clears it.
     pub locked: bool,
     /// [`FrameKind::LootButton`]'s 0-based slot (`+0x4dc`) from `SetSlot`. Deviation: `None`
-    /// until then, not the ctor's 0, so that an unset row takes nothing rather than slot 0.
+    /// until then, not the ctor's 0, because that way an unset row takes nothing rather than slot
+    /// 0.
     pub loot_slot: Option<u32>,
     /// A CheckButton's checked flag (`+0x4dc`, XML `checked`).
     pub checked: bool,
diff --git a/crates/benilla-world/src/clouds/kernel.rs b/crates/benilla-world/src/clouds/kernel.rs
index 6bb8924d1..8ef5df037 100644
--- a/crates/benilla-world/src/clouds/kernel.rs
+++ b/crates/benilla-world/src/clouds/kernel.rs
@@ -91,8 +91,8 @@ impl Default for CloudKernel {
             accum: vec![0.0; COLS * COLS],
             deriv: vec![[0.0; 2]; COLS * COLS],
             prevrow: vec![0.0; COLS],
-            // Deviation: the reference starts this buffer at 0xFFFFFFFF; alpha 0 keeps a dome
-            // drawn before the first build from flashing white.
+            // Deviation: the reference starts this buffer at 0xFFFFFFFF; here it starts at alpha 0
+            // because that keeps a dome drawn before the first build from flashing white.
             rgba: vec![[255, 255, 255, 0]; COLS * COLS],
             scroll: 0,
             phase: 0,
@@ -305,7 +305,7 @@ impl CloudKernel {
             return f32::from(self.tile[(COLS / 2) * COLS + COLS / 2]) / 255.0;
         };
         let (col, row) = (u as i32, v as i32);
-        // Deviation: the index wraps where the reference reads past the tile, only at `u == 1.0`.
+        // Deviation: the index wraps because the reference reads past the tile, only at `u == 1.0`.
         let cell = ((row as usize & (COLS - 1)) << SHIFT) + (col as usize & (COLS - 1));
         f32::from(self.tile[cell]) / 255.0
     }
@@ -335,7 +335,8 @@ fn project_cells(d: Vec3) -> Option<(f32, f32)> {
     }
     let quarter_pi = f64::from(std::f32::consts::FRAC_PI_4);
     let c = f64::from(d.y) + f64::from(std::f32::consts::FRAC_PI_4.cos());
-    // Deviation: clamped; the reference NaNs above about 70° elevation, where its bodies never go.
+    // Deviation: clamped because the reference NaNs above about 70° elevation, where its bodies
+    // never go.
     let theta = (c / len).clamp(-1.0, 1.0).acos();
     let phase = theta.min(quarter_pi) / quarter_pi * 0.5;
     let hyp = (f64::from(d.x) * f64::from(d.x) + f64::from(d.z) * f64::from(d.z)).sqrt();
diff --git a/crates/benilla-world/src/clouds/tables.rs b/crates/benilla-world/src/clouds/tables.rs
index 7ca6b523a..669c2fdb5 100644
--- a/crates/benilla-world/src/clouds/tables.rs
+++ b/crates/benilla-world/src/clouds/tables.rs
@@ -44,8 +44,8 @@ pub(crate) const CURVE: [u8; 256] = [
 ];
 
 /// The gradient table (`0xce92d8`, built by `0x6d0c90` loop 1): `1 − 2·rand()/32767` on MSVC's
-/// `rand`. Deviation: seed 1, the CRT default, for determinism; the reference's is the process
-/// `srand` state, and any uniform table looks the same.
+/// `rand`. Deviation: seed 1, the CRT default, because that makes the table deterministic; the
+/// reference's is the process `srand` state, and any uniform table looks the same.
 pub(crate) fn gradient_table() -> [f32; 256] {
     let mut seed: u32 = 1;
     std::array::from_fn(|_| {
diff --git a/crates/benilla-world/src/collision.rs b/crates/benilla-world/src/collision.rs
index c81ed10b5..2263361a1 100644
--- a/crates/benilla-world/src/collision.rs
+++ b/crates/benilla-world/src/collision.rs
@@ -54,8 +54,8 @@ pub(crate) enum CollisionLayer {
 }
 
 /// The camera probe's radius (yd) against the solid world. Deviation: the reference's camera
-/// trace is a bare ray (`0x672170`); the sphere keeps the near plane out of a wall. Nothing may
-/// hardcode it: a fixture sweeping another radius tests another client.
+/// trace is a bare ray (`0x672170`); here it is a sphere because that keeps the near plane out of a
+/// wall. Nothing may hardcode it: a fixture sweeping another radius tests another client.
 pub const CAMERA_PROBE_RADIUS: f32 = 0.3;
 
 /// `CollisionLayers` for a WMO's walking collider, which the camera query never hits.
diff --git a/crates/benilla-world/src/exterior_cull.rs b/crates/benilla-world/src/exterior_cull.rs
index d559dd4d9..43f086a96 100644
--- a/crates/benilla-world/src/exterior_cull.rs
+++ b/crates/benilla-world/src/exterior_cull.rs
@@ -26,8 +26,8 @@
 //! Terrain is tagged per 33.333 yd MCNK cell: a 533 yd tile around the camera reaches every
 //! window's side of the view. The far band keeps its whole-tile box, the reference's far tier.
 //!
-//! Deviation: the reference tests one AABB per object, but a doodad placement has no root entity
-//! here, so its submeshes are tested one by one, and a submesh outside a doorway's window drops
+//! Deviation: the reference tests one AABB per object, but its submeshes are tested one by one here
+//! because a doodad placement has no root entity; a submesh outside a doorway's window drops
 //! where the reference draws the doodad whole. A body has a root and is tested once.
 
 use bevy::camera::primitives::{Aabb, Frustum};
diff --git a/crates/benilla-world/src/shaders/static_gx.wgsl b/crates/benilla-world/src/shaders/static_gx.wgsl
index fd7888cc4..2bd6aae05 100644
--- a/crates/benilla-world/src/shaders/static_gx.wgsl
+++ b/crates/benilla-world/src/shaders/static_gx.wgsl
@@ -322,7 +322,7 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
     } else {
         // ---- exterior ADT doodads and exterior MODD props ----
         // Model2.bls order-2 SH sun lobe at intensity 0.5 Shaded (MCSH), 1.0 Matte, 2.5 Lit.
-        // Deviation: the `min(I, 1)` cap, as in wow_model.wgsl, since lifting it takes sun-facing
+        // Deviation: the `min(I, 1)` cap, as in wow_model.wgsl, because lifting it takes sun-facing
         // surfaces past 1.0; Matte keeps its own bit so it stays 1.0 if the cap goes.
         let shade_t = select(1.0, 0.0, (in.word & WORD_SHADE_LIT) != 0u);
         let intensity = min(
diff --git a/crates/benilla-world/src/terrain_stream.rs b/crates/benilla-world/src/terrain_stream.rs
index 1e5518e47..430ccd078 100644
--- a/crates/benilla-world/src/terrain_stream.rs
+++ b/crates/benilla-world/src/terrain_stream.rs
@@ -431,7 +431,7 @@ impl ViewFocus {
     /// live paced body and for a cinematic's camera; through entry, a teleport and a world swap
     /// the loading cover or the settle hold waits instead.
     ///
-    /// Deviation: the debug free-fly eye holds nothing: it is benilla's own tool with no
+    /// Deviation: the debug free-fly eye holds nothing because it is benilla's own tool with no
     /// reference counterpart, and a stall there only slows the developer.
     pub(crate) fn holds_inner(&self) -> bool {
         (self.follows_body() && self.paced) || self.cinematic
@@ -869,7 +869,7 @@ struct InnerWaitCap(Duration);
 ///
 /// Deviation: a read still loading after [`INNER_WAIT_CAP`] is given up on with a warning, once
 /// per request, and its tile then streams on unwaited like the outer ring, where the reference
-/// waits for ever: a hung read costs one capped stall, not one every frame.
+/// waits for ever, because that way a hung read costs one capped stall, not one every frame.
 fn await_inner_tiles(world: &mut World) {
     let pending: Vec<((i32, i32), Handle<AdtTile>)> = {
         let state = world.resource::<TerrainStreamer>();
diff --git a/crates/benilla-world/src/terrain_stream/residency.rs b/crates/benilla-world/src/terrain_stream/residency.rs
index 501fa01fd..abf6b993f 100644
--- a/crates/benilla-world/src/terrain_stream/residency.rs
+++ b/crates/benilla-world/src/terrain_stream/residency.rs
@@ -8,8 +8,8 @@
 //!
 //! Deviation: benilla gates on terrain alone, which is more permissive; the settle hold covers a
 //! building or doodad arriving after a teleport. And an authored tile whose ADT failed to load
-//! counts as resident, where the reference would have loaded it: a permanent wall over a bad file
-//! is worse for a player than walking on without its ground.
+//! counts as resident, where the reference would have loaded it, because a permanent wall over a
+//! bad file is worse for a player than walking on without its ground.
 
 use bevy::prelude::*;
 
diff --git a/crates/benilla-world/src/view.rs b/crates/benilla-world/src/view.rs
index c85a5f273..e75cba7bb 100644
--- a/crates/benilla-world/src/view.rs
+++ b/crates/benilla-world/src/view.rs
@@ -82,7 +82,7 @@ pub const FARCLIP_RANGE: std::ops::RangeInclusive<f32> = 177.0..=777.0;
 /// change callback `0x688d90`, `[0x8029d0]` = 0.01 and `[0x808300]` = 0.33.
 ///
 /// Deviation: the reference refuses a value outside them, echoing "NearClip must be in range
-/// 0.01 - 0.33" (`0x869abc`); ours clamps, as every CVar consumer here clamps at its own edge.
+/// 0.01 - 0.33" (`0x869abc`); ours clamps, because every CVar consumer here clamps at its own edge.
 pub const NEARCLIP_RANGE: std::ops::RangeInclusive<f32> = 0.01..=0.33;
 
 /// The world camera's multisampling, the `gxMultisample` CVar: a sample count in [`MSAA_RANGE`],
diff --git a/crates/benilla-world/src/water_fx/params.rs b/crates/benilla-world/src/water_fx/params.rs
index 92914439d..99334fdaa 100644
--- a/crates/benilla-world/src/water_fx/params.rs
+++ b/crates/benilla-world/src/water_fx/params.rs
@@ -84,7 +84,7 @@ pub(super) fn foam_params(
 }
 
 /// A record's size at `now`. Deviation: the first draw is `size0`, where the reference first ages
-/// the record one `dt·growth` step, a difference too small to see at our frame rates.
+/// the record one `dt·growth` step, because the difference is too small to see at our frame rates.
 pub(super) fn record_size(size0: f32, growth: f32, born: f32, now: f32) -> f32 {
     size0 + growth * (now - born)
 }
diff --git a/crates/benilla-world/src/zfill.rs b/crates/benilla-world/src/zfill.rs
index 644c2ec2f..401b4b0b0 100644
--- a/crates/benilla-world/src/zfill.rs
+++ b/crates/benilla-world/src/zfill.rs
@@ -7,10 +7,11 @@
 //! part while its `MeshTag` alpha is translucent.
 //!
 //! Deviation: the reference twins every translucent command, authored-blend glass included; here
-//! twins exist only during an instance alpha episode, so every steady-state look is untouched.
+//! twins exist only during an instance alpha episode, because that way every steady-state look is
+//! untouched.
 //!
-//! Deviation: Bevy sorts per entity, so twins lead by a fixed −8 yd sort bias
-//! ([`crate::model_render::ZFILL_SORT_BIAS`]) instead of by the instance's sort-key tie;
+//! Deviation: twins lead by a fixed −8 yd sort bias ([`crate::model_render::ZFILL_SORT_BIAS`])
+//! instead of by the instance's sort-key tie because Bevy sorts per entity;
 //! transparent content within that window behind a fading body is depth-clipped where the body
 //! covers it, for the episode.
 
diff --git a/docs/DEVIATIONS.md b/docs/DEVIATIONS.md
index 0051c1923..44f223140 100644
--- a/docs/DEVIATIONS.md
+++ b/docs/DEVIATIONS.md
@@ -47,26 +47,26 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### assets/ui
 
-- `OpenBackpack` opens every equipped bag, not only the backpack, so the vendor and mailbox windows that call it (MerchantFrame.lua:35, MailFrame.lua:39) bring up every bag to sell or mail from. ([`assets/ui/ContainerFrameAdapters.xml:9`](../crates/benilla-app/assets/ui/ContainerFrameAdapters.xml#L9))
-- The stock FCF\_ChatTabFadeFinished (FloatingChatFrame.lua:989-992) nils oldAlpha even under a live hover, so leaving and re-entering within CHAT\_FRAME\_FADE\_TIME (a flick to the scroll buttons, outside the hover box, does it) stops the plate fading in (l.873) for the rest of the session; this keeps oldAlpha while hover is set. ([`assets/ui/FrameXMLFixes.xml:6`](../crates/benilla-app/assets/ui/FrameXMLFixes.xml#L6))
+- `OpenBackpack` opens every equipped bag, not only the backpack, because that way the vendor and mailbox windows that call it (MerchantFrame.lua:35, MailFrame.lua:39) bring up every bag to sell or mail from. ([`assets/ui/ContainerFrameAdapters.xml:9`](../crates/benilla-app/assets/ui/ContainerFrameAdapters.xml#L9))
+- The stock FCF\_ChatTabFadeFinished (FloatingChatFrame.lua:989-992) nils oldAlpha even under a live hover, so leaving and re-entering within CHAT\_FRAME\_FADE\_TIME (a flick to the scroll buttons, outside the hover box, does it) stops the plate fading in (l.873) for the rest of the session; this keeps oldAlpha while hover is set because the stock one nils it even under a live hover. ([`assets/ui/FrameXMLFixes.xml:6`](../crates/benilla-app/assets/ui/FrameXMLFixes.xml#L6))
 - Re-runs UIParent\_ManageFramePositions after DurabilityFrame's own OnEvent. ([`assets/ui/FrameXMLFixes.xml:20`](../crates/benilla-app/assets/ui/FrameXMLFixes.xml#L20))
-- Friendly plates the player turned on come back at every world entry. The stock UpdateNameplates (UIOptionsFrame.lua:768-780) shows them and hides them again at once (l.775-776), and FRIENDNAMEPLATES\_ON is never saved, since l.182 registers NAMEPLATES\_ON a second time. ([`assets/ui/FrameXMLFixes.xml:33`](../crates/benilla-app/assets/ui/FrameXMLFixes.xml#L33))
-- A button whose key moved away keeps the old key's label while it holds an action with no range (a stance, a self buff). ([`assets/ui/FrameXMLFixes.xml:51`](../crates/benilla-app/assets/ui/FrameXMLFixes.xml#L51))
+- Friendly plates the player turned on come back at every world entry; the stock UpdateNameplates (UIOptionsFrame.lua:768-780) shows them and hides them again at once (l.775-776), and FRIENDNAMEPLATES\_ON is never saved because l.182 registers NAMEPLATES\_ON a second time. ([`assets/ui/FrameXMLFixes.xml:33`](../crates/benilla-app/assets/ui/FrameXMLFixes.xml#L33))
+- A button whose key moved away keeps the old key's label while it holds an action with no range (a stance, a self buff) because the stock ActionButton\_UpdateHotkeys (ActionButton.lua:129-140) writes no text in that one unbound case; this clears it. ([`assets/ui/FrameXMLFixes.xml:51`](../crates/benilla-app/assets/ui/FrameXMLFixes.xml#L51))
 - The rungs are the 1.15 era client's ESC menu, because its settings screens replace 1.12's, which are much worse to use; the era's AddOns rung is dropped, since the character-select AddOns screen is the only addon UI. ([`assets/ui/GameMenuAdapters.xml:4`](../crates/benilla-app/assets/ui/GameMenuAdapters.xml#L4))
 - The layout is the era Settings panel's Keybindings page (collapsible category sections), because 1.12's settings screens are much worse to use. ([`assets/ui/KeyBindingsPage.xml:5`](../crates/benilla-app/assets/ui/KeyBindingsPage.xml#L5))
 - Every bind, unbind and reset saves at once, as the era panel commits, where 1.12 had Okay and Cancel; only Reset To Default and leaving the character set confirm. ([`assets/ui/KeyBindingsPage.xml:11`](../crates/benilla-app/assets/ui/KeyBindingsPage.xml#L11))
 - The spacer headers BLANK, BLANK2 and BLANK3 over multibars 2-4 (Bindings.xml:883/967/1051), which 1.12 draws blank (BINDING\_HEADER\_BLANK is "  ", the other two are not defined), continue the section above, because this page's sections are named and collapsible. ([`assets/ui/KeyBindingsPage.xml:123`](../crates/benilla-app/assets/ui/KeyBindingsPage.xml#L123))
-- The 1.15 era client's single settings window replaces the 1.12 four-panel family, which is much worse to use; the 1.12 frames still load, hidden, for addons. ([`assets/ui/OptionsFrame.xml:3`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L3))
-- AUTO\_QUEST\_WATCH is the string "1". 1.12 assigns the number 1 (l.122) but every consumer compares against "1" (QuestLogFrame.lua:64/68); 1 ~= "1" in Lua 5.0. ([`assets/ui/OptionsFrame.xml:31`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L31))
-- The bar toggles precede the lock, which 1.12's box leads with, so what is on screen reads first. ([`assets/ui/OptionsFrame.xml:498`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L498))
-- A named ladder reads out its stop; 1.12's slider labels only its ends, and a bare index would mean nothing to a player. ([`assets/ui/OptionsFrame.xml:631`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L631))
-- 1.12 returns early here; a mute row hides the last plate, so a neighbour's text cannot stand when its OnLeave was missed. ([`assets/ui/OptionsFrame.xml:746`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L746))
-- No partner write of cameraPitchSmoothSpeed, which has no reader: the follow here has one rate. ([`assets/ui/OptionsFrame.xml:1697`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L1697))
-- Modern Classic's two-entry Display Mode, as there is no exclusive fullscreen; gxWindow "0" is the borderless window. ([`assets/ui/OptionsFrame.xml:1983`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L1983))
-- Our own row (the reference draws to the backbuffer), and no Multisampling, which misses alpha-tested cutouts. ([`assets/ui/OptionsFrame.xml:2012`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L2012))
-- 1.12 has no `/reload` (later clients added it; 1.12 reloads through `/console reloadui`); kept so a player can reload the interface after toggling addons. ([`assets/ui/ScriptLogFrame.xml:381`](../crates/benilla-app/assets/ui/ScriptLogFrame.xml#L381))
+- The 1.15 era client's single settings window replaces the 1.12 four-panel family because that is much worse to use; the 1.12 frames still load, hidden, for addons. ([`assets/ui/OptionsFrame.xml:3`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L3))
+- AUTO\_QUEST\_WATCH is the string "1" because 1.12 assigns the number 1 (l.122) but every consumer compares against "1" (QuestLogFrame.lua:64/68); 1 ~= "1" in Lua 5.0. ([`assets/ui/OptionsFrame.xml:32`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L32))
+- The bar toggles precede the lock, which 1.12's box leads with, because that way what is on screen reads first. ([`assets/ui/OptionsFrame.xml:499`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L499))
+- A named ladder reads out its stop because 1.12's slider labels only its ends, and a bare index would mean nothing to a player. ([`assets/ui/OptionsFrame.xml:632`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L632))
+- 1.12 returns early here; a mute row hides the last plate because otherwise a neighbour's text stands when its OnLeave was missed. ([`assets/ui/OptionsFrame.xml:747`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L747))
+- No partner write of cameraPitchSmoothSpeed because it has no reader: the follow here has one rate. ([`assets/ui/OptionsFrame.xml:1698`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L1698))
+- Modern Classic's two-entry Display Mode, because there is no exclusive fullscreen; gxWindow "0" is the borderless window. ([`assets/ui/OptionsFrame.xml:1984`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L1984))
+- Our own row (the reference draws to the backbuffer), and no Multisampling because it misses alpha-tested cutouts. ([`assets/ui/OptionsFrame.xml:2013`](../crates/benilla-app/assets/ui/OptionsFrame.xml#L2013))
+- 1.12 has no `/reload` (later clients added it; 1.12 reloads through `/console reloadui`); kept because it lets a player reload the interface after toggling addons. ([`assets/ui/ScriptLogFrame.xml:381`](../crates/benilla-app/assets/ui/ScriptLogFrame.xml#L381))
 - A three-slice where the reference overlaps two quads, since two quads reach only 362 units and a page here is 563 tall. ([`assets/ui/ScrollTemplates.xml:190`](../crates/benilla-app/assets/ui/ScrollTemplates.xml#L190))
-- The pet page's autocast widgets take the pet bar button's proportions, so the shine and the corner brackets sit on the button's edge and share its centre. ([`assets/ui/SpellBookAdapters.xml:3`](../crates/benilla-app/assets/ui/SpellBookAdapters.xml#L3))
+- The pet page's autocast widgets take the pet bar button's proportions because that seats the shine and the corner brackets on the button's edge, sharing its centre. ([`assets/ui/SpellBookAdapters.xml:3`](../crates/benilla-app/assets/ui/SpellBookAdapters.xml#L3))
 
 #### aura_visual
 
@@ -74,14 +74,14 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### bindings
 
-- A press with Super (Cmd) held runs no binding, so a system chord such as Cmd+Tab or Cmd+Q never acts in game. ([`src/bindings.rs:19`](../crates/benilla-app/src/bindings.rs#L19))
+- A press with Super (Cmd) held runs no binding because that way a system chord such as Cmd+Tab or Cmd+Q never acts in game. ([`src/bindings.rs:19`](../crates/benilla-app/src/bindings.rs#L19))
 - A trackpad's `Pixel` deltas are carried until they make a line, and step at most once per event (`crate::ui_script::Record::Wheel`). ([`src/bindings.rs:637`](../crates/benilla-app/src/bindings.rs#L637))
 - Latches die with the VM that made them, because a latch names a command of that VM's table and releasing it against a new one would run another load's up-half. ([`src/bindings.rs:682`](../crates/benilla-app/src/bindings.rs#L682))
-- The Windows key table stops at `VK_F12` and drops later F-keys; they are named here so a stored `F13`-`F24` can be pressed. ([`src/bindings/chord.rs:165`](../crates/benilla-app/src/bindings/chord.rs#L165))
+- The Windows key table stops at `VK_F12` and drops later F-keys; they are named here because that way a stored `F13`-`F24` can be pressed. ([`src/bindings/chord.rs:165`](../crates/benilla-app/src/bindings/chord.rs#L165))
 - On the Mac and Linux a key its platform reports no character for keeps its US name too, where the Mac reference drops it (`0x8a4aa`), and a Linux dead key not yet pressed bare stays bindable. ([`src/bindings/layout.rs:116`](../crates/benilla-app/src/bindings/layout.rs#L116))
-- A character above U+00FF names the key by itself. The reference's `MapVirtualKeyA` returns an ANSI code-page byte, which `0x42da4b` drops past `0xff` and the namer's UTF-8 encoder (`0x41abb0`) otherwise reads as Latin-1, so such a key is mislabelled or dropped; named by what it types, it stays bindable and readable. ([`src/bindings/layout.rs:216`](../crates/benilla-app/src/bindings/layout.rs#L216))
-- A layout that is not ASCII-capable (Hebrew, Greek, Russian, Arabic, Thai) names its keys through the ASCII-capable layout macOS pairs with it, as macOS names its own shortcuts. ([`src/bindings/layout.rs:290`](../crates/benilla-app/src/bindings/layout.rs#L290))
-- A character above U+00FF (Czech `ě`, Polish `ł`, Turkish `ş`) names the key by itself. ([`src/bindings/layout.rs:294`](../crates/benilla-app/src/bindings/layout.rs#L294))
+- A character above U+00FF names the key by itself because the reference's `MapVirtualKeyA` returns an ANSI code-page byte, which `0x42da4b` drops past `0xff` and the namer's UTF-8 encoder (`0x41abb0`) otherwise reads as Latin-1, so such a key is mislabelled or dropped; named by what it types, it stays bindable and readable. ([`src/bindings/layout.rs:216`](../crates/benilla-app/src/bindings/layout.rs#L216))
+- A layout that is not ASCII-capable (Hebrew, Greek, Russian, Arabic, Thai) names its keys through the ASCII-capable layout macOS pairs with it, as macOS names its own shortcuts, because the reference reads a non-Roman `KCHR`'s byte as MacRoman (`0x8a40f`), which names no real key. ([`src/bindings/layout.rs:290`](../crates/benilla-app/src/bindings/layout.rs#L290))
+- A character above U+00FF (Czech `ě`, Polish `ł`, Turkish `ş`) names the key by itself because the reference reads `KeyTranslate`'s byte as MacRoman (`0x8a40f`) and keeps it only if it converts to Latin-1 (`CFStringGetBytes`, `0x8a46b`, stored at `0x8a482`), else leaves the slot `-1`, which `0x8a4aa` drops, so such a key is mislabelled or dropped; named by what it types, it stays bindable and readable. ([`src/bindings/layout.rs:295`](../crates/benilla-app/src/bindings/layout.rs#L295))
 - The reference saves a full snapshot (`bindings-cache.wtf`); a diff is stored because a full snapshot would leave every command added later unbound for a saved file. ([`src/bindings/store.rs:13`](../crates/benilla-app/src/bindings/store.rs#L13))
 
 #### blob_shadow
@@ -90,24 +90,24 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### camera_shake
 
-- The shake spawns at the kit play's position. The reference passes `&node+0x48` to the shake (`0x620e0e`) before `0x62101d` fills it from the attachment, so a bone-attached first node (`0x61fdd0`, which never writes it) shakes at the world origin its constructor left (`0x61f4c1`) and is culled beyond 80 yards of it, silencing 26 of the 58 shipped shake kits; that is a read before the write, not a behaviour. ([`src/camera_shake.rs:290`](../crates/benilla-app/src/camera_shake.rs#L290))
+- The shake spawns at the kit play's position because the reference passes `&node+0x48` to the shake (`0x620e0e`) before `0x62101d` fills it from the attachment, so a bone-attached first node (`0x61fdd0`, which never writes it) shakes at the world origin its constructor left (`0x61f4c1`) and is culled beyond 80 yards of it, silencing 26 of the 58 shipped shake kits; that is a read before the write, not a behaviour. ([`src/camera_shake.rs:290`](../crates/benilla-app/src/camera_shake.rs#L290))
 
 #### chat_bubble
 
-- Sizes ride the plates' damped diagonal basis (`plate_basis`), not the unbounded reference law, so bubble text and plate text keep one em at every window size. ([`src/chat_bubble.rs:24`](../crates/benilla-app/src/chat_bubble.rs#L24))
+- Sizes ride the plates' damped diagonal basis (`plate_basis`), not the unbounded reference law, because that way bubble text and plate text keep one em at every window size. ([`src/chat_bubble.rs:24`](../crates/benilla-app/src/chat_bubble.rs#L24))
 
 #### cinematic
 
-- Bevy UI nodes computed per frame, not `CinematicFrame.xml`'s textures, so a window resized mid-cinematic stays letterboxed. `CinematicFrame` still shows and owns ESC. ([`src/cinematic.rs:187`](../crates/benilla-app/src/cinematic.rs#L187))
+- Bevy UI nodes computed per frame, not `CinematicFrame.xml`'s textures, because that way a window resized mid-cinematic stays letterboxed. `CinematicFrame` still shows and owns ESC. ([`src/cinematic.rs:187`](../crates/benilla-app/src/cinematic.rs#L187))
 
 #### combat_text
 
-- The reference stretches a raster of at most 32 px; each whole-pixel size is rasterized here, so the crit pop stays crisp. ([`src/combat_text/mod.rs:273`](../crates/benilla-app/src/combat_text/mod.rs#L273))
+- The reference stretches a raster of at most 32 px; each whole-pixel size is rasterized here because that way the crit pop stays crisp. ([`src/combat_text/mod.rs:273`](../crates/benilla-app/src/combat_text/mod.rs#L273))
 
 #### console
 
-- A line of eight names is not left with its trailing `, ` and a list of a multiple of eight names is not followed by `NONE`, two slips of the reference's loop (`0x63ffed`, `0x64004d`). ([`src/console.rs:467`](../crates/benilla-app/src/console.rs#L467))
-- A CVar lists under its registration's category with its registration's help, even when `config.toml` held it at boot. ([`src/console.rs:472`](../crates/benilla-app/src/console.rs#L472))
+- A line of eight names is not left with its trailing `, ` and a list of a multiple of eight names is not followed by `NONE`, because those are two slips of the reference's loop (`0x63ffed`, `0x64004d`). ([`src/console.rs:467`](../crates/benilla-app/src/console.rs#L467))
+- A CVar lists under its registration's category with its registration's help, even when `config.toml` held it at boot, because in the reference such a record was made by the config line's `set` (`0x63d569`-`0x63d582`), which registered its command in category 5 with the help `""` (`0x63ddc9`), and the later registration finds the record and returns without registering again (`0x63dc1a`-`0x63dc87`), so what `help` says would hang on what the file held. ([`src/console.rs:473`](../crates/benilla-app/src/console.rs#L473))
 
 #### creature_anim
 
@@ -115,13 +115,13 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 - A mounted draw is refused at the setter, because our rider track never replays the reference's per-play force-stow (`0x5fdf80`); the result is the same. ([`src/creature_anim/driver.rs:769`](../crates/benilla-app/src/creature_anim/driver.rs#L769))
 - The reference writes bone 0's rate blindly; we scope it to the swing's own node, because a moving attacker's gait would otherwise slow too. ([`src/creature_anim/driver.rs:1088`](../crates/benilla-app/src/creature_anim/driver.rs#L1088))
 - A time-based rate, because the reference's per-frame step changes with the frame rate. ([`src/creature_anim/select.rs:137`](../crates/benilla-app/src/creature_anim/select.rs#L137))
-- A spell's state kit and body procs are reaped only once no slot holds the spell. ([`src/creature_anim/spell_visual.rs:1351`](../crates/benilla-app/src/creature_anim/spell_visual.rs#L1351))
+- A spell's state kit and body procs are reaped only once no slot holds the spell because the reference's removal of one slot (`0x612320` → `0x5ff290`) stops every effect of that spell on the unit (`0x614150(spell, 1)` at `0x5ff2d2`, and its procs through `0x60d150` and `0x5ff320`), even while another slot holds the same spell, which drops a visual the server says still holds. ([`src/creature_anim/spell_visual.rs:1351`](../crates/benilla-app/src/creature_anim/spell_visual.rs#L1351))
 
 #### cvars
 
 - The reference's list runs in creation order, the records `Config.wtf` created first in file order (`0x63d8eb`), then each registration as start-up reaches it (`containers`), an order benilla-re has not traced. benilla lists in the table's order, which is register-site address order, then the rows the table lacks (benilla's own, an addon's) as they registered. ([`src/cvars/listing.rs:5`](../crates/benilla-app/src/cvars/listing.rs#L5))
 - For a row that is not latched the change callback runs, inside the call that restored it, where the reference runs no callback here (`0x63dff0`, `0x63e010`), because a knob moves only through its callback (`callbacks::CvarCallbacks`), which also stands in for the reference's direct reads of the record; without it knob and value would disagree until the next write. ([`src/cvars/mod.rs:439`](../crates/benilla-app/src/cvars/mod.rs#L439))
-- The reference's `SaveConfig` (`0x63d980`) writes only at world entry (`0x46b6f6`), at the leave-world tail (`0x490c35`-`0x490c64`) and at shutdown (`0x63daf0`), so a crash or a kill loses every change since; here a player's settings survive one. ([`src/cvars/mod.rs:1170`](../crates/benilla-app/src/cvars/mod.rs#L1170))
+- The reference's `SaveConfig` (`0x63d980`) writes only at world entry (`0x46b6f6`), at the leave-world tail (`0x490c35`-`0x490c64`) and at shutdown (`0x63daf0`), so a crash or a kill loses every change since; here a player's settings survive one because the config saves a quiet second after a change. ([`src/cvars/mod.rs:1170`](../crates/benilla-app/src/cvars/mod.rs#L1170))
 - The reference clips at full scale and has no headroom mechanism (its SFX-bus duck `0x457960` is a sidechain armed only by server-pushed voice lines); benilla limits because every SFX is mastered to full scale and overlapping kits clip. ([`src/cvars/table.rs:243`](../crates/benilla-app/src/cvars/table.rs#L243))
 - Here the dial multiplies the camera's own rate, because benilla does not change the OS pointer speed, a system-wide setting. ([`src/cvars/table.rs:485`](../crates/benilla-app/src/cvars/table.rs#L485))
 - "0" raises a borderless fullscreen window instead of mode-setting the display, because Wayland and macOS offer no mode-set and X11's leaves the desktop changed after a crash (`crate::video`). ([`src/cvars/table.rs:615`](../crates/benilla-app/src/cvars/table.rs#L615))
@@ -129,15 +129,15 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### death
 
-- `0x492130` compares the positions whatever map we stand on, so a ghost on another map at the corpse's coordinates reads in range for a reclaim the server refuses; here only the corpse's display map counts. ([`src/death/mod.rs:308`](../crates/benilla-app/src/death/mod.rs#L308))
+- `0x492130` compares the positions whatever map we stand on, so a ghost on another map at the corpse's coordinates reads in range for a reclaim the server refuses; here only the corpse's display map counts because the server refuses that reclaim. ([`src/death/mod.rs:308`](../crates/benilla-app/src/death/mod.rs#L308))
 
 #### entities
 
-- A cap on one hop's sub-segment count, which the reference lacks, so a vertex run is never sized off table data alone; shipped rows peak at 12 (30 yd at `avgSegLen` 2.78). ([`src/entities/chain_beam.rs:54`](../crates/benilla-app/src/entities/chain_beam.rs#L54))
-- Not the reference's generator (`((rand & 0x7fffff) | 0x3f800000)` re-centred through `2.0`), because the look rests on the amplitude and the advection, both exact, never on the draw sequence. ([`src/entities/chain_beam.rs:110`](../crates/benilla-app/src/entities/chain_beam.rs#L110))
-- The reference updates every unit every frame; here only units showing a flagged visual are tracked, and a parked rig skips its ray and re-seeds at the slope on waking, to bound the cost at one ray per flagged unit on screen. ([`src/entities/conform.rs:67`](../crates/benilla-app/src/entities/conform.rs#L67))
-- The reference copies a finished model, ours stream in, so while false the pane keeps re-taking and a late weapon is baked. ([`src/entities/equipment/resolve.rs:181`](../crates/benilla-app/src/entities/equipment/resolve.rs#L181))
-- It attaches at that clip's `$SHL`, where the reference attaches it at the draw's start, because it keys on the ranged slot's sheath so it arrives with the bow it feeds; the two are a few hundred ms apart in one clip and never seen apart. ([`src/entities/equipment/resolve.rs:560`](../crates/benilla-app/src/entities/equipment/resolve.rs#L560))
+- A cap on one hop's sub-segment count, which the reference lacks, because that way a vertex run is never sized off table data alone; shipped rows peak at 12 (30 yd at `avgSegLen` 2.78). ([`src/entities/chain_beam.rs:54`](../crates/benilla-app/src/entities/chain_beam.rs#L54))
+- Not the reference's generator (`((rand & 0x7fffff) | 0x3f800000)` re-centred through `2.0`), because the look rests on the amplitude and the advection, both exact, never on the draw sequence. ([`src/entities/chain_beam.rs:111`](../crates/benilla-app/src/entities/chain_beam.rs#L111))
+- The reference updates every unit every frame; here only units showing a flagged visual are tracked, and a parked rig skips its ray and re-seeds at the slope on waking, because that bounds the cost at one ray per flagged unit on screen. ([`src/entities/conform.rs:67`](../crates/benilla-app/src/entities/conform.rs#L67))
+- While false the pane keeps re-taking and a late weapon is baked, because the reference copies a finished model and ours stream in. ([`src/entities/equipment/resolve.rs:181`](../crates/benilla-app/src/entities/equipment/resolve.rs#L181))
+- It attaches at that clip's `$SHL`, where the reference attaches it at the draw's start, because it keys on the ranged slot's sheath so it arrives with the bow it feeds; the two are a few hundred ms apart in one clip and never seen apart. ([`src/entities/equipment/resolve.rs:561`](../crates/benilla-app/src/entities/equipment/resolve.rs#L561))
 - `Hold` is one repeating play where the reference re-arms it each pass with variation -1, a weighted random pick, because at most one `Spells\` model authors several variations. ([`src/entities/spell_fx/lifecycle.rs:11`](../crates/benilla-app/src/entities/spell_fx/lifecycle.rs#L11))
 
 #### game_tip
@@ -160,7 +160,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### local_state
 
-- The reference writes `Screenshots\\` inside the install, which benilla never writes to; the folder keeps the reference's name. ([`src/local_state.rs:433`](../crates/benilla-app/src/local_state.rs#L433))
+- The reference writes `Screenshots\\` inside the install; benilla keeps the folder in its own state because it never writes to the install; the folder keeps the reference's name. ([`src/local_state.rs:433`](../crates/benilla-app/src/local_state.rs#L433))
 
 #### minimap
 
@@ -171,7 +171,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 - `AlphaMode::Blend` writes no depth where the reference does, because overlapping names resolving by sort order look the same. ([`src/nameplates.rs:4`](../crates/benilla-app/src/nameplates.rs#L4))
 - A mounted plate keeps only this fraction of its seat's oscillation about a slow mean, because the raw seat, which the reference also rides, read more intense than the reference side by side. `1.0` is the raw seat; on-foot plates are untouched. ([`src/nameplates.rs:300`](../crates/benilla-app/src/nameplates.rs#L300))
 - Larger than the reference's 32 px `UNIT_NAME_FONT` raster, which it magnifies (`0x6c749b`), because a larger source is crisper up close. ([`src/nameplates.rs:309`](../crates/benilla-app/src/nameplates.rs#L309))
-- `ShouldShowName`'s first leg is `IsSelectable` (`0x60be60`), which passes our own unit; what hides the own name in first person in 1.12.1 is untraced, so the avatar's fade stands in. ([`src/nameplates.rs:541`](../crates/benilla-app/src/nameplates.rs#L541))
+- `ShouldShowName`'s first leg is `IsSelectable` (`0x60be60`), which passes our own unit; the avatar's fade stands in because what hides the own name in first person in 1.12.1 is untraced. ([`src/nameplates.rs:541`](../crates/benilla-app/src/nameplates.rs#L541))
 
 #### names
 
@@ -181,14 +181,14 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 - UTC days, where `mktime` reads the host's local time zone, because the app has no time zone source (`benilla_ui::civil` has the same). ([`src/net/game_time.rs:354`](../crates/benilla-app/src/net/game_time.rs#L354))
 - The reference loads the world first and logs in after: the entry's first frame starts the load at the record's map and position (`0x401570`, called at `0x46c236`), and a later one, once its file reader is idle (`0x46c247`), sends the login (`0x46c272`). ([`src/net/io.rs:10`](../crates/benilla-app/src/net/io.rs#L10))
-- The reference re-dials only from `RequestRealmList`, and only when the link is down (`[CLoginMgr+5]` clear, `0x5ab857` → `0x5b2200`), with the reconnect challenge (`0x5b2134`, `[Logon+0xc]`); the connect's query sends only on a link in state 6 (`0x5bc14c`) and otherwise nothing, leaving the screen on its connecting dialog for good. ([`src/net/io.rs:407`](../crates/benilla-app/src/net/io.rs#L407))
-- The reference's guard at `0x537e85` sends 0 whenever the write index is 0, one ping in sixteen; we send 0 only before the first pong, because the rest is an artefact of its index arithmetic that only the server stores. ([`src/net/io.rs:1300`](../crates/benilla-app/src/net/io.rs#L1300))
+- The reference re-dials only from `RequestRealmList`, and only when the link is down (`[CLoginMgr+5]` clear, `0x5ab857` → `0x5b2200`), with the reconnect challenge (`0x5b2134`, `[Logon+0xc]`); the connect's query sends only on a link in state 6 (`0x5bc14c`) and otherwise nothing, leaving the screen on its connecting dialog for good. ([`src/net/io.rs:408`](../crates/benilla-app/src/net/io.rs#L408))
+- The reference's guard at `0x537e85` sends 0 whenever the write index is 0, one ping in sixteen; we send 0 only before the first pong, because the rest is an artefact of its index arithmetic that only the server stores. ([`src/net/io.rs:1301`](../crates/benilla-app/src/net/io.rs#L1301))
 - The reference places collision and culling by the raw facing, ours follow the display facing, because a capsule and a sphere barely change under rotation. ([`src/net/motion/facing.rs:9`](../crates/benilla-app/src/net/motion/facing.rs#L9))
-- The reference paces a self move through the same replay chain as a remote's, which would only delay a correction to our own pose. ([`src/net/motion/remote.rs:95`](../crates/benilla-app/src/net/motion/remote.rs#L95))
+- The reference paces a self move through the same replay chain as a remote's; benilla hands it over at arrival because pacing it would only delay a correction to our own pose. ([`src/net/motion/remote.rs:95`](../crates/benilla-app/src/net/motion/remote.rs#L95))
 - Its rate-limited hover climb (`0x636fa1`, 7 yd/s) is not reproduced, because the cache gate needs a pure function; it converges to this answer. ([`src/net/motion/spline.rs:659`](../crates/benilla-app/src/net/motion/spline.rs#L659))
-- A first-pass values block the clear header byte left unwritten re-fires, for a live object, its last write's edges against the watch copy (`0x465570`, `0x466686`); benilla compares against this packet's copies, which hold none for it, so a stale edge never fires twice. ([`src/net/objects/update.rs:1086`](../crates/benilla-app/src/net/objects/update.rs#L1086))
+- A first-pass values block the clear header byte left unwritten re-fires, for a live object, its last write's edges against the watch copy (`0x465570`, `0x466686`); benilla compares against this packet's copies, which hold none for it, because that way a stale edge never fires twice. ([`src/net/objects/update.rs:1086`](../crates/benilla-app/src/net/objects/update.rs#L1086))
 - The create notify uses its lookup's result untested (`0x465c97`, `0x465d79`). ([`src/net/objects/update.rs:1098`](../crates/benilla-app/src/net/objects/update.rs#L1098))
-- On benilla's unattended reconnect, which the reference lacks, the world's VM survives the loss, so the clear signals its `PLAYER_TARGET_CHANGED` and usable refresh as a release's teardown does (`0x493a69`, `0x493a73`), still sending nothing, and the surviving target frame lets the lost unit go. ([`src/net/session.rs:310`](../crates/benilla-app/src/net/session.rs#L310))
+- On benilla's unattended reconnect, which the reference lacks, the world's VM survives the loss; because of that the clear signals its `PLAYER_TARGET_CHANGED` and usable refresh as a release's teardown does (`0x493a69`, `0x493a73`), still sending nothing, and the surviving target frame lets the lost unit go. ([`src/net/session.rs:310`](../crates/benilla-app/src/net/session.rs#L310))
 
 #### no_install
 
@@ -197,21 +197,21 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 #### player
 
 - The reference re-projects the point's height onto the first walkable facet a zero-size box gather finds at the enemy (`0x60fe25`-`0x60fe51`); here it keeps the enemy's height. ([`src/player/approach.rs:417`](../crates/benilla-app/src/player/approach.rs#L417))
-- The reference stores the world point unconverted and reads it back as deck-local (`0x60fe6c`, `0x610e95`), so on a transport it walks astray; here it rides the deck. ([`src/player/approach.rs:420`](../crates/benilla-app/src/player/approach.rs#L420))
-- The reference converts back through the transport the player stands on each frame (`0x610e6b`), so stepping off mid-walk sends the point astray; here the deck is fixed at the arm. ([`src/player/approach.rs:449`](../crates/benilla-app/src/player/approach.rs#L449))
-- The melee arm names the player's own guid (`0x60fe5f`), so the reference turns to face itself, a fixed heading; here the melee walk does not turn. ([`src/player/approach.rs:665`](../crates/benilla-app/src/player/approach.rs#L665))
+- Here it rides the deck, because the reference stores the world point unconverted and reads it back as deck-local (`0x60fe6c`, `0x610e95`) and so, on a transport, walks astray. ([`src/player/approach.rs:420`](../crates/benilla-app/src/player/approach.rs#L420))
+- Here the deck is fixed at the arm, because the reference converts back through the transport the player stands on each frame (`0x610e6b`), so stepping off mid-walk sends the point astray. ([`src/player/approach.rs:450`](../crates/benilla-app/src/player/approach.rs#L450))
+- Here the melee walk does not turn, because the reference's melee arm names the player's own guid (`0x60fe5f`), so it turns to face itself, a fixed heading. ([`src/player/approach.rs:666`](../crates/benilla-app/src/player/approach.rs#L666))
 - The shape is kept, its scale anchored to `LOOK_SENSITIVITY` on both axes at the default speeds, because the unit factor is a per-machine OS setting and this keeps the shipped feel: both axes turn alike, where the reference's yaw turns 1.5× faster than its pitch. ([`src/player/camera.rs:121`](../crates/benilla-app/src/player/camera.rs#L121))
 - A delay holds the channel at `from`, because the reference's `0x512830` backs the start time up by the delay, so `s` runs negative and the even cosine jumps the value away and back, an unclamped divide rather than a behaviour. ([`src/player/camera_channel.rs:13`](../crates/benilla-app/src/player/camera_channel.rs#L13))
 - A code table, not the reference's ninety `cameraTerrainTilt<Style><State>` CVars, because the matrix is a law, not a setting. ([`src/player/camera_dynamics.rs:285`](../crates/benilla-app/src/player/camera_dynamics.rs#L285))
 - The reference sweeps the camera collision against the bobbed eye (`0x50ed47`); benilla adds the offset after the sweep, because it shares camera shake's accumulator there. ([`src/player/camera_dynamics.rs:450`](../crates/benilla-app/src/player/camera_dynamics.rs#L450))
 - Both values clamp to the rig's range, because a hand-edited file should not land a pose play cannot reach; the reference stores them unbounded, the pitch until a mouse-look re-clamps it. ([`src/player/camera_saved.rs:64`](../crates/benilla-app/src/player/camera_saved.rs#L64))
 - `ResetView` writes the CVars back to their defaults, because the CVar store is our persistence; the reference (`0x50fae0`) touches no CVar, so its reset reverts at next launch. ([`src/player/camera_view.rs:15`](../crates/benilla-app/src/player/camera_view.rs#L15))
-- The starting zoom, `CAM_DIST_DEFAULT`, is 15 yd where the reference starts at 5.55, the third-person-A row of its default table `0x84f488` that `cameraView` 1 picks (`0x50c17a`, `0x50c18b`; the `cameraDistance` CVar itself registers "0.0"), for a wider view. ([`src/player/camera_zoom.rs:10`](../crates/benilla-app/src/player/camera_zoom.rs#L10))
+- The starting zoom, `CAM_DIST_DEFAULT`, is 15 yd where the reference starts at 5.55, the third-person-A row of its default table `0x84f488` that `cameraView` 1 picks (`0x50c17a`, `0x50c18b`; the `cameraDistance` CVar itself registers "0.0"), because that gives a wider view. ([`src/player/camera_zoom.rs:10`](../crates/benilla-app/src/player/camera_zoom.rs#L10))
 - No drunk field-of-view lane, because the reference's is invisible in play: its target `(179° − 90°)·fraction` (camera `+0x10c`, setter `0x511250`) eases at `cameraFoVSmoothSpeed`, 0.5°/s, and restarts on every drunk-byte change, so it creeps under 1°. ([`src/player/drunk.rs:46`](../crates/benilla-app/src/player/drunk.rs#L46))
 - Every end signals `END`, because the reference's three silent ends are a bug: two writers reset the follow mode cell `0xc4d888` directly (`0x5fb646`, `0x60396f`), leaving a stale guid at `0xc4d980`, and the canceller's early-out (`0x60fb70`) fires nothing. ([`src/player/follow.rs:24`](../crates/benilla-app/src/player/follow.rs#L24))
 - A settle hold is summed and sent once on release, without the push, because it stands in for the reference's blocking load (`0x694920`), not a refused substep, and lasts seconds. ([`src/player/movement_net.rs:470`](../crates/benilla-app/src/player/movement_net.rs#L470))
-- The reference's blocking load (`0x694920`) waits out its reads before the frame goes on and has no such release; without one, a model that never loads would freeze our body for good. ([`src/player/state.rs:120`](../crates/benilla-app/src/player/state.rs#L120))
-- Root is not merged, because a bare pose unrooting us while the server still roots us streams motion into `CHEAT_TYPE_ROOT_MOVE`; vmangos keeps a rooted mover's root bit (`MovementHandler.cpp:1064`), so the reference's merge of it is a no-op anyway. ([`src/player/state.rs:202`](../crates/benilla-app/src/player/state.rs#L202))
+- The reference's blocking load (`0x694920`) waits out its reads before the frame goes on and has no such release; the timeout exists because without one a model that never loads would freeze our body for good. ([`src/player/state.rs:120`](../crates/benilla-app/src/player/state.rs#L120))
+- Root is not merged, because a bare pose unrooting us while the server still roots us streams motion into `CHEAT_TYPE_ROOT_MOVE`; vmangos keeps a rooted mover's root bit (`MovementHandler.cpp:1064`), so the reference's merge of it is a no-op anyway. ([`src/player/state.rs:203`](../crates/benilla-app/src/player/state.rs#L203))
 - Applied at arrival, because our own avatar has no motion to de-jitter; the reference routes it through the replay chain remotes use, which paces to the sender's cadence and can hold an early packet (up to 1000 ms in `net::motion`). ([`src/player/wire_in.rs:503`](../crates/benilla-app/src/player/wire_in.rs#L503))
 
 #### portrait
@@ -252,24 +252,24 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### shutdown
 
-- The reference leaves it to the OS. Its key arm (`0x42d261`-`0x42d276`) hands Alt+F4 to `DefWindowProc`, whose `SC_CLOSE` becomes the kind-5 event (`0x42d287`, as `WM_CLOSE` posts at `0x42d292`) and closes at once: the running client's callback `0x63c9a0` (installed from `0x402840`, asked at `0x423a21`) answers 0 and tears the context down (`0x41f9b0`), with no logout timer, at the login screen and in game alike. ([`src/shutdown.rs:50`](../crates/benilla-app/src/shutdown.rs#L50))
+- The reference leaves it to the OS. Its key arm (`0x42d261`-`0x42d276`) hands Alt+F4 to `DefWindowProc`, whose `SC_CLOSE` becomes the kind-5 event (`0x42d287`, as `WM_CLOSE` posts at `0x42d292`) and closes at once: the running client's callback `0x63c9a0` (installed from `0x402840`, asked at `0x423a21`) answers 0 and tears the context down (`0x41f9b0`), with no logout timer, at the login screen and in game alike. benilla reads the chord itself and asks for the same close, which the shutdown tail above already serves, because a tiling window manager (i3, sway, Hyprland) binds nothing to Alt+F4. ([`src/shutdown.rs:50`](../crates/benilla-app/src/shutdown.rs#L50))
 
 #### smart_rect
 
-- The plate caller snaps the result to device pixels before `Self::claim`, so its border art blits 1:1. ([`src/smart_rect.rs:50`](../crates/benilla-app/src/smart_rect.rs#L50))
+- The plate caller snaps the result to device pixels before `Self::claim`, because that way its border art blits 1:1. ([`src/smart_rect.rs:50`](../crates/benilla-app/src/smart_rect.rs#L50))
 
 #### sound
 
 - `damage > 0` without a parry or block stands in for `0x2`, because vmangos clears that bit only for immune and a zero-damage miss or absorb (`Unit.cpp:1366`/`1587`), so it would grunt on every parry. ([`src/sound/combat.rs:587`](../crates/benilla-app/src/sound/combat.rs#L587))
 - The water column is chosen on liquid above the feet (`depth > 0`, the footstep splash's test), because the reference's test, the flag saying liquid was found at the unit's sampled position (`[node+0x90] & 0x20`, `0x670630`), has no depth and splashes a body on a lake's shore. ([`src/sound/death_thud.rs:28`](../crates/benilla-app/src/sound/death_thud.rs#L28))
-- The reference marks an unresolvable kit by negating the id (`[+0xE00] = -id`), so the owner's next `$DSL` re-registers into a fresh entry every cycle; a flag keeps it in place without the churn. ([`src/sound/emitter_pool.rs:54`](../crates/benilla-app/src/sound/emitter_pool.rs#L54))
-- The reference leaves those kits uncapped; sample-aligned copies of one file sum coherently (five are one sound +14 dB), so a mass buff distorts. ([`src/sound/kit.rs:240`](../crates/benilla-app/src/sound/kit.rs#L240))
+- A flag keeps an unresolvable kit in place without the churn, because the reference marks it by negating the id (`[+0xE00] = -id`), so the owner's next `$DSL` re-registers into a fresh entry every cycle. ([`src/sound/emitter_pool.rs:54`](../crates/benilla-app/src/sound/emitter_pool.rs#L54))
+- The reference leaves those kits uncapped; here they are capped because sample-aligned copies of one file sum coherently (five are one sound +14 dB), so a mass buff distorts. ([`src/sound/kit.rs:240`](../crates/benilla-app/src/sound/kit.rs#L240))
 - The reference never steals. Every WoW voice is an `FSOUND_Stream` at priority 256 (`fmod.dll 0x1002be47`) and FMOD's steal scan skips `>= 256` (`0x100268e9`), so its 13th sound is dropped. ([`src/sound/kit.rs:284`](../crates/benilla-app/src/sound/kit.rs#L284))
 - The reference sums at full scale and clips (a close 1.0 kit reaches `FSOUND_SetVolume(255)` through `0x7a5dc0`, FMOD's MMX mixers saturate with `paddsw`, and no gain depends on the live voice count); this limits, because every WoW SFX is mastered to full scale, so overlapping kits clip into broadband distortion, as when a mass buff lands five sample-aligned copies of one 0 dBFS file. `SoundOutputLimiter 0` turns it off. ([`src/sound/limiter.rs:3`](../crates/benilla-app/src/sound/limiter.rs#L3))
 - The mantissa-bit volume curve (`0x7a5d70`, `(v·255+512.5).bits >> 14 & 0xff`) and the `__ftol` truncations are dropped, because they only quantized to FMOD's integer levels and our backend takes float amplitudes. ([`src/sound/math.rs:4`](../crates/benilla-app/src/sound/math.rs#L4))
 - The reference also refuses to open a new non-music stream while inactive (`0x7a52bf`); benilla starts everything and gates the output, because a refusal at kit start would make an unattended capture record silence. ([`src/sound/mod.rs:97`](../crates/benilla-app/src/sound/mod.rs#L97))
-- Default off where the reference registers "1". Its reverb is FMOD 3's EAX API, which renders only with hardware 3D mixing, so off is what the reference is heard to produce (inferred: `fmod.dll`'s render side is untraced). ([`src/sound/mod.rs:105`](../crates/benilla-app/src/sound/mod.rs#L105))
-- `SoundOutputLimiter`, not a 1.12 CVar, default on, so overlapping full-scale kits are limited rather than clipped. ([`src/sound/mod.rs:123`](../crates/benilla-app/src/sound/mod.rs#L123))
+- Default off where the reference registers "1", because its reverb is FMOD 3's EAX API, which renders only with hardware 3D mixing, so off is what the reference is heard to produce (inferred: `fmod.dll`'s render side is untraced). ([`src/sound/mod.rs:105`](../crates/benilla-app/src/sound/mod.rs#L105))
+- `SoundOutputLimiter`, not a 1.12 CVar, default on, because that way overlapping full-scale kits are limited rather than clipped. ([`src/sound/mod.rs:123`](../crates/benilla-app/src/sound/mod.rs#L123))
 - With no character the reference leaves the listener where it was; benilla seats it on the camera, where the view is. ([`src/sound/mod.rs:488`](../crates/benilla-app/src/sound/mod.rs#L488))
 - The reference also plays an optimistic coin at the loot-money click, and at the auto-loot sweep's money, once per loot source (`0x4c201b`-`0x4c2020`, the same `0x458030` call; `0xb71bc4` set at `0x4c221e`, reset at `0x4c1d95`), so looted money sounds twice; benilla plays the watcher's coin alone, because one coin on the confirmed change reads cleanly and the round trip the early coin hides is imperceptible on a local server. ([`src/sound/money.rs:7`](../crates/benilla-app/src/sound/money.rs#L7))
 - 1.12.1 sets FMOD up on driver 0 and, when that fails, runs silent for the session (`Sound::Initialize` `0x7a4330`, the driver −1 → 0 at `0x7a445f`); here another output stands in, because on Linux the default is often a stock `dmix` whose card a sound server holds. ([`src/sound/output/cpal.rs:193`](../crates/benilla-app/src/sound/output/cpal.rs#L193))
@@ -279,17 +279,17 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 - An out-of-range byte drops the packet, because the reference's unchecked write overruns the table (`(64, 19)` lands on the class family at `0xcecaac`). ([`src/spell/mods.rs:131`](../crates/benilla-app/src/spell/mods.rs#L131))
 - The fallback is the packet's target guid, started only when the validator keeps it (`on_spell_go`), and with none there is no start, never the nearest-hostile acquire, because that would attack something the player never named. ([`src/spell/net.rs:1672`](../crates/benilla-app/src/spell/net.rs#L1672))
-- A range failure leaves targeting armed and working. For a cast in flight the reference's report cancels it (`0x6e2218` → `0x6e4940`): its line, `SPELLCAST_FAILED` and the tradeskill disarm, which benilla keeps; with the word the bind emptied it also sends `CMSG_CANCEL_CAST` for the unsent spell (`0x6e4970`) and clears the caster, then restores the pre-click word (`0x6e6096`), so every later click fails the caster test (`0x6e5b93`) and the cursor is stranded until a cancel. ([`src/spell/targeting/mod.rs:707`](../crates/benilla-app/src/spell/targeting/mod.rs#L707))
+- A range failure leaves targeting armed and working because, for a cast in flight, the reference's report cancels it (`0x6e2218` → `0x6e4940`): its line, `SPELLCAST_FAILED` and the tradeskill disarm, which benilla keeps; with the word the bind emptied it also sends `CMSG_CANCEL_CAST` for the unsent spell (`0x6e4970`) and clears the caster, then restores the pre-click word (`0x6e6096`), so every later click fails the caster test (`0x6e5b93`) and the cursor is stranded until a cancel. ([`src/spell/targeting/mod.rs:707`](../crates/benilla-app/src/spell/targeting/mod.rs#L707))
 
 #### target
 
 - The reference's arm reads the last object's stop (`0x611336` before `0x610383` stores this one's), so its first walk has no stop. ([`src/target/click.rs:729`](../crates/benilla-app/src/target/click.rs#L729))
 - It runs on the first frame with none, so an arrival that sends no stop (mid-air, rooted, under a held turn key) acts at once or on landing or release, where the reference waits for the next ground stop and can act long after, wherever the player then is. ([`src/target/click.rs:1707`](../crates/benilla-app/src/target/click.rs#L1707))
-- The rank is held to 7, the top of the ring scale's eight entries (`0..=7`), where the reference keeps any value; a server rank past 7 would index outside our palette. ([`src/target/relations.rs:487`](../crates/benilla-app/src/target/relations.rs#L487))
+- The rank is held to 7, the top of the ring scale's eight entries (`0..=7`), where the reference keeps any value, because a server rank past 7 would index outside our palette. ([`src/target/relations.rs:487`](../crates/benilla-app/src/target/relations.rs#L487))
 - TAB uses Classic Era's screen-space priority, not 1.12's ±30° facing cone and snapshot cursor (`0x493f60`), because the cone skips a close mob in front of the camera, which sits behind the character. ([`src/target/scan.rs:3`](../crates/benilla-app/src/target/scan.rs#L3))
-- Our own body is never a candidate. The reference's friendly scan picks the player at some facings (`CanAssist(P, P)` is true, `0x6061e0`; the cone test `0x47f220`), but our scoring always puts the player dead centre at distance 0, so CTRL-TAB would pick us on every press. ([`src/target/scan.rs:194`](../crates/benilla-app/src/target/scan.rs#L194))
-- No drawn gate (the reference's IsEntityDrawn, `0x6704c0`), because the draw election hides every body outside the frustum, which would empty the off-screen tier. ([`src/target/scan.rs:374`](../crates/benilla-app/src/target/scan.rs#L374))
-- Sampled each frame, not stamped in `SetSelection`, so every selection writer is covered; a selected unit that turns hostile is remembered, where the reference's is not. ([`src/target/scan.rs:1128`](../crates/benilla-app/src/target/scan.rs#L1128))
+- Our own body is never a candidate because our scoring always puts the player dead centre at distance 0, so CTRL-TAB would pick us on every press. ([`src/target/scan.rs:194`](../crates/benilla-app/src/target/scan.rs#L194))
+- No drawn gate (the reference's IsEntityDrawn, `0x6704c0`), because the draw election hides every body outside the frustum, which would empty the off-screen tier. ([`src/target/scan.rs:375`](../crates/benilla-app/src/target/scan.rs#L375))
+- Sampled each frame, not stamped in `SetSelection`, because that way every selection writer is covered; a selected unit that turns hostile is remembered, where the reference's is not. ([`src/target/scan.rs:1129`](../crates/benilla-app/src/target/scan.rs#L1129))
 
 #### textinput
 
@@ -298,7 +298,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 #### ui_action
 
 - The player's `0x5e` with no word falls back to the spell's own `RequiresSpellFocus`, which the reference never reads here, because it is the id vmangos sends (`Spell.cpp:4426`). `0x5d` has no such stand-in: vmangos takes its area from its own `spell_area` table (`Spell.cpp:4429`), which `Spell.dbc` does not carry. ([`src/ui_action/cast_fail.rs:311`](../crates/benilla-app/src/ui_action/cast_fail.rs#L311))
-- A reason past the table prints its hex code, so an unknown reason is visible. ([`src/ui_action/cast_fail.rs:415`](../crates/benilla-app/src/ui_action/cast_fail.rs#L415))
+- A reason past the table prints its hex code, because that way an unknown reason is visible. ([`src/ui_action/cast_fail.rs:415`](../crates/benilla-app/src/ui_action/cast_fail.rs#L415))
 - A declined arm's template loses its tokens ("Missing reagent: %s" reads "Missing reagent") where the reference shows the literal `%s`, because a raw token reads as broken. ([`src/ui_action/cast_fail.rs:534`](../crates/benilla-app/src/ui_action/cast_fail.rs#L534))
 - An empty chat line is dropped, where the reference adds a blank one (`0x49a870` refuses only a null text, `0x49a881`), because a blank line is worse than none; only a string an addon emptied, or a chain missing a stock key, reaches it. ([`src/ui_action/errors.rs:588`](../crates/benilla-app/src/ui_action/errors.rs#L588))
 - The book's and the bar's login packets run this over every staged spell word, where the reference re-points slots only at `SMSG_SUPERCEDED_SPELL`, old rank to new (`0x4e5e60`, `super::spell_slots`), because vmangos never rewrites stored slots on a rank-up (`Player::AddSpell`), drops superseded ranks from the book (`Player.cpp:3463`) and sends no supersede while loading (`Player.cpp:3704`), so a stored slot can name a spell the character no longer knows. ([`src/ui_action/ranks.rs:3`](../crates/benilla-app/src/ui_action/ranks.rs#L3))
@@ -307,7 +307,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 - On a catalog miss the reference keeps the record's stale value (`0x4e4533`, `0x4e4550` skip the write); this answers from the joined expiry, because a stale value is no mechanism to reproduce. `None` is that miss: the call reads the expiry (`AuraState::until_cancelled_unknown`). ([`src/ui_aura.rs:603`](../crates/benilla-app/src/ui_aura.rs#L603))
 - On other units' rows an id the catalog lacks stays visible, because every wire id is a real spell and failing closed would blank every aura on a catalog failure; the reference skips one there (`[0xc0d78c]`), though its player cache inserts one, as here. ([`src/ui_aura.rs:631`](../crates/benilla-app/src/ui_aura.rs#L631))
-- The reference clears its expiry array (`0xbc5f68`) at every game entry, in `ResetBuffCache` (`0x4e40c0`, called from `0x48f5a9`); benilla clears it at exit instead. ([`src/ui_aura.rs:1011`](../crates/benilla-app/src/ui_aura.rs#L1011))
+- The reference clears its expiry array (`0xbc5f68`) at every game entry, in `ResetBuffCache` (`0x4e40c0`, called from `0x48f5a9`); benilla clears it at exit instead, because that way a buff or debuff keeps its duration timer through a teleport. ([`src/ui_aura.rs:1011`](../crates/benilla-app/src/ui_aura.rs#L1011))
 
 #### ui_binder
 
@@ -315,16 +315,16 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### ui_chat
 
-- Not run on benilla's same-character reconnect, which the reference lacks (it returns to the login screen), so the window keeps its scrollback there. ([`src/ui_chat.rs:266`](../crates/benilla-app/src/ui_chat.rs#L266))
+- Not run on benilla's same-character reconnect, which the reference lacks (it returns to the login screen), because that way the window keeps its scrollback there. ([`src/ui_chat.rs:266`](../crates/benilla-app/src/ui_chat.rs#L266))
 - A missing global prints nothing, where the reference prints an empty line (`0x703c02`), because benilla's other `DisplayError` routes do the same. ([`src/ui_chat/broadcast.rs:167`](../crates/benilla-app/src/ui_chat/broadcast.rs#L167))
 - In a capital with a blank city word the walk composes `"Trade - "` (it tests the row pointer, not the string, `0x49a2e4`-`0x49a2ed`); we decline, because a wrong channel name is joined silently and for good. ([`src/ui_chat/channels.rs:157`](../crates/benilla-app/src/ui_chat/channels.rs#L157))
-- The reference holds every line that waits on its `$`-macro subject's name in the name cache's callback list (`0x49daea` → `0x55f080`) until the name answers, with no bound; here at most `MAX_HELD_SUBJECT_LINES` wait, the oldest dropped past that, as a subject no player owns never answers. ([`src/ui_chat/feed.rs:396`](../crates/benilla-app/src/ui_chat/feed.rs#L396))
+- The reference holds every line that waits on its `$`-macro subject's name in the name cache's callback list (`0x49daea` → `0x55f080`) until the name answers, with no bound; here at most `MAX_HELD_SUBJECT_LINES` wait, the oldest dropped past that, because a subject no player owns never answers. ([`src/ui_chat/feed.rs:396`](../crates/benilla-app/src/ui_chat/feed.rs#L396))
 - A probe's bare `/assist` assists the live selection, `AssistByName("")` (`0x489c89`), where the stock handler (`ChatFrame.lua:740`) resolves a selected player's name through `AssistByName`, because a name resolve can land on a different player. ([`src/ui_chat/input/mod.rs:594`](../crates/benilla-app/src/ui_chat/input/mod.rs#L594))
-- A line of 256 bytes or more, which reaches here only through `chat_send`'s deviation for `0x49f604`, is slurred whole instead of cut to that buffer, so it reaches the server whole for the refusal that deviation leaves to it. ([`src/ui_chat/input/send.rs:305`](../crates/benilla-app/src/ui_chat/input/send.rs#L305))
+- A line of 256 bytes or more, which reaches here only through `chat_send`'s deviation for `0x49f604`, is slurred whole instead of cut to that buffer, because that way it reaches the server whole for the refusal that deviation leaves to it. ([`src/ui_chat/input/send.rs:305`](../crates/benilla-app/src/ui_chat/input/send.rs#L305))
 - The files live in `benilla-config/Logs/`, not the install's `Logs`, because the install is read-only. ([`src/ui_chat/logging.rs:14`](../crates/benilla-app/src/ui_chat/logging.rs#L14))
 - No re-run when a remote player streams in, because the reference's re-run only repeats the join, which vmangos swallows, or the leave, whose "Not on channel" notice nothing prints. ([`src/ui_chat/recruitment.rs:10`](../crates/benilla-app/src/ui_chat/recruitment.rs#L10))
 - `set_chat_window_looks` drops an out-of-range window, where the reference's `WINDOW` bound is off by one (`0x498d17`, `ja` where the array needs `jae`), because that write would land past the array. ([`src/ui_chat/settings.rs:31`](../crates/benilla-app/src/ui_chat/settings.rs#L31))
-- The debounce also writes Lua's changes (`dirty`) after the quiet time, where the reference writes only at teardown, so a crash loses at most a second of changes. ([`src/ui_chat/settings.rs:627`](../crates/benilla-app/src/ui_chat/settings.rs#L627))
+- The debounce also writes Lua's changes (`dirty`) after the quiet time, where the reference writes only at teardown, because that way a crash loses at most a second of changes. ([`src/ui_chat/settings.rs:627`](../crates/benilla-app/src/ui_chat/settings.rs#L627))
 
 #### ui_dressup
 
@@ -333,16 +333,16 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 #### ui_duel
 
 - The challenger's name comes from the `NameCache`, so a name still being queried delays the popup to the name's answer rather than dropping it; the reference reads it off the streamed player and fires nothing without one (`0x4d4a72`). ([`src/ui_duel.rs:8`](../crates/benilla-app/src/ui_duel.rs#L8))
-- Zero arms nothing, where the reference prints 0 and re-arms forever on the `dec`'s wraparound, a bug vmangos never reaches (it sends 3000). ([`src/ui_duel.rs:95`](../crates/benilla-app/src/ui_duel.rs#L95))
+- Zero arms nothing, because the reference prints 0 and re-arms forever on the `dec`'s wraparound, a bug vmangos never reaches (it sends 3000). ([`src/ui_duel.rs:95`](../crates/benilla-app/src/ui_duel.rs#L95))
 
 #### ui_gamma
 
-- The reference skips that upload when windowed (`byte[dev+0x20b]` is `gxWindow`), and every benilla mode is windowed, so the same curve applies in the compositor, where the slider can move pixels: `UiGammaNode` raises the gamma byte the RAMDAC would have read to `gamma` before its decode, the continuous form of the 256-entry ramp. ([`src/ui_gamma.rs:56`](../crates/benilla-app/src/ui_gamma.rs#L56))
-- The reference never clamps (`SetGamma` `0x4891f0` writes `-4.000000` for 5), but its ramp is a fullscreen OS call and ours is the image, where an extreme exponent blacks out the panel that would undo it. ([`src/ui_gamma.rs:66`](../crates/benilla-app/src/ui_gamma.rs#L66))
+- The same curve applies in the compositor, where the slider can move pixels, because the reference skips that upload when windowed (`byte[dev+0x20b]` is `gxWindow`) and every benilla mode is windowed: `UiGammaNode` raises the gamma byte the RAMDAC would have read to `gamma` before its decode, the continuous form of the 256-entry ramp. ([`src/ui_gamma.rs:56`](../crates/benilla-app/src/ui_gamma.rs#L56))
+- The reference never clamps (`SetGamma` `0x4891f0` writes `-4.000000` for 5), but here the consumers clamp because its ramp is a fullscreen OS call and ours is the image, where an extreme exponent blacks out the panel that would undo it. ([`src/ui_gamma.rs:66`](../crates/benilla-app/src/ui_gamma.rs#L66))
 
 #### ui_gm_ticket
 
-- Those three are stack residue, so benilla sends 0 for each. ([`src/ui_gm_ticket.rs:169`](../crates/benilla-app/src/ui_gm_ticket.rs#L169))
+- Benilla sends 0 for each of those three because they are stack residue. ([`src/ui_gm_ticket.rs:169`](../crates/benilla-app/src/ui_gm_ticket.rs#L169))
 
 #### ui_gossip
 
@@ -358,7 +358,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### ui_honor
 
-- A new target zeroes the figures too, and dropping a held reply signals `INSPECT_HONOR_UPDATE`, where `0x4c6f70` keeps the figures and clears only has-data (`0xb71fc8`) and pending (`0xb71fcc`): a server that never answers the ask, as vmangos often does not, would leave the last player's figures shown under the new one. ([`src/ui_honor.rs:38`](../crates/benilla-app/src/ui_honor.rs#L38))
+- A new target zeroes the figures too, and dropping a held reply signals `INSPECT_HONOR_UPDATE`, where `0x4c6f70` keeps the figures and clears only has-data (`0xb71fc8`) and pending (`0xb71fcc`), because a server that never answers the ask, as vmangos often does not, would leave the last player's figures shown under the new one. ([`src/ui_honor.rs:38`](../crates/benilla-app/src/ui_honor.rs#L38))
 
 #### ui_instance
 
@@ -374,29 +374,29 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 #### ui_layout
 
 - A debounced autosave (`save_layout`) also writes a quiet second after a drag, because the reference has no crash-path write and a crash would lose the session's windows. ([`src/ui_layout.rs:13`](../crates/benilla-app/src/ui_layout.rs#L13))
-- A record's fields start empty. The reference's parser clears X, Y, W and the level at each `Frame:` (`ebx`, `edi`, `esi`, `[ebp-0x4]` at `0x49045b`–`0x490469`) but not H (`[ebp-0xc]`), so a record with no `H:` takes the one before's; benilla writes `H:` whenever it writes `W:`, so only a hand-edited file reaches the slip, which would size a window from another window's row. ([`src/ui_layout.rs:89`](../crates/benilla-app/src/ui_layout.rs#L89))
+- A record's fields start empty because the reference's parser clears X, Y, W and the level at each `Frame:` (`ebx`, `edi`, `esi`, `[ebp-0x4]` at `0x49045b`–`0x490469`) but not H (`[ebp-0xc]`), so a record with no `H:` takes the one before's; benilla writes `H:` whenever it writes `W:`, so only a hand-edited file reaches the slip, which would size a window from another window's row. ([`src/ui_layout.rs:89`](../crates/benilla-app/src/ui_layout.rs#L89))
 
 #### ui_loot
 
 - A negative answer releases the row, where the reference's callback `0x4c2ac0` returns on a failed query and the window never opens, because an entry the server cannot describe would otherwise keep the loot shut for good. ([`src/ui_loot/mod.rs:243`](../crates/benilla-app/src/ui_loot/mod.rs#L243))
-- It is the display row, where the reference's is the item index plus one (`0x4c2885`), so an addon's `GetLootSlotInfo(arg1)` reads the row the dialog is for. ([`src/ui_loot/mod.rs:332`](../crates/benilla-app/src/ui_loot/mod.rs#L332))
-- A row cleared meanwhile stops counting, where `ClearLootRow` (`0x4c1f00`) cancels its callback (`0x4c1f52`) and never lowers the count (its writers are `0x4c1def`, `0x4c1e94` and `0x4c2af6` alone), so in 1.12.1 a group member's take of an uncached item before the answer leaves that corpse's window shut until the next loot response resets the count (`0x4c1def`), and ours opens. ([`src/ui_loot/mod.rs:864`](../crates/benilla-app/src/ui_loot/mod.rs#L864))
-- `autoLootDefault` is benilla's own option, 1.12 auto-looting only on a shift-click, and off is 1.12's behaviour. ([`src/ui_loot/mod.rs:894`](../crates/benilla-app/src/ui_loot/mod.rs#L894))
-- Our close paths clear it guid-matched, where `CloseInteraction` clears it unconditionally (`0x48f2c9`), so closing an old window keeps a newer `CMSG_LOOT`'s latch. ([`src/ui_loot/mod.rs:922`](../crates/benilla-app/src/ui_loot/mod.rs#L922))
+- It is the display row, where the reference's is the item index plus one (`0x4c2885`), because that way an addon's `GetLootSlotInfo(arg1)` reads the row the dialog is for. ([`src/ui_loot/mod.rs:332`](../crates/benilla-app/src/ui_loot/mod.rs#L332))
+- A row cleared meanwhile stops counting, because `ClearLootRow` (`0x4c1f00`) cancels its callback (`0x4c1f52`) and never lowers the count (its writers are `0x4c1def`, `0x4c1e94` and `0x4c2af6` alone), so in 1.12.1 a group member's take of an uncached item before the answer leaves that corpse's window shut until the next loot response resets the count (`0x4c1def`), and ours opens. ([`src/ui_loot/mod.rs:865`](../crates/benilla-app/src/ui_loot/mod.rs#L865))
+- `autoLootDefault` is benilla's own option, 1.12 auto-looting only on a shift-click, and off is 1.12's behaviour. ([`src/ui_loot/mod.rs:895`](../crates/benilla-app/src/ui_loot/mod.rs#L895))
+- Our close paths clear it guid-matched, where `CloseInteraction` clears it unconditionally (`0x48f2c9`), because that way closing an old window keeps a newer `CMSG_LOOT`'s latch. ([`src/ui_loot/mod.rs:923`](../crates/benilla-app/src/ui_loot/mod.rs#L923))
 
 #### ui_loot_roll
 
 - A negative answer, or none within `TEMPLATE_HOLD_MAX_MS`, opens the frame unresolved, because a frame that never opens cannot even be passed on; the reference's callback fires on success only. ([`src/ui_loot_roll.rs:11`](../crates/benilla-app/src/ui_loot_roll.rs#L11))
-- The open count is the number of rolls announced and not closed. The reference keeps a counter that its server-close paths decrement for any roll whose closed byte is clear (`0x61b6f8`, `0x61bc17`), a deferred roll that never counted up included, so it under-counts and lets a fifth frame open; here a deferred roll's close changes nothing. ([`src/ui_loot_roll.rs:22`](../crates/benilla-app/src/ui_loot_roll.rs#L22))
-- A refused record or name closes the roll unspoken. In 1.12.1 the failure callbacks (`0x61bc80`, `0x61bd50`, `0x61b7d0`) free the record with no `CANCEL_LOOT_ROLL` and leave the open count unlowered, so its frame stays up, empty and dead, until a `/reload`, and holds one of the four frames, so a later fourth roll never shows; benilla closes the roll instead. ([`src/ui_loot_roll.rs:29`](../crates/benilla-app/src/ui_loot_roll.rs#L29))
+- The open count is the number of rolls announced and not closed, because the reference keeps a counter that its server-close paths decrement for any roll whose closed byte is clear (`0x61b6f8`, `0x61bc17`), a deferred roll that never counted up included, so it under-counts and lets a fifth frame open; here a deferred roll's close changes nothing. ([`src/ui_loot_roll.rs:22`](../crates/benilla-app/src/ui_loot_roll.rs#L22))
+- A refused record or name closes the roll unspoken because in 1.12.1 the failure callbacks (`0x61bc80`, `0x61bd50`, `0x61b7d0`) free the record with no `CANCEL_LOOT_ROLL` and leave the open count unlowered, so its frame stays up, empty and dead, until a `/reload`, and holds one of the four frames, so a later fourth roll never shows; benilla closes the roll instead. ([`src/ui_loot_roll.rs:29`](../crates/benilla-app/src/ui_loot_roll.rs#L29))
 
 #### ui_macro
 
-- The reference's 255-byte cut (`0x4f0677`, `0x4f0b93`) can end inside a character and keep its stray bytes; a `String` must stay UTF-8, so the cut backs off to the character's start. ([`src/ui_macro/store.rs:21`](../crates/benilla-app/src/ui_macro/store.rs#L21))
+- The reference's 255-byte cut (`0x4f0677`, `0x4f0b93`) can end inside a character and keep its stray bytes; here the cut backs off to the character's start because a `String` must stay UTF-8. ([`src/ui_macro/store.rs:21`](../crates/benilla-app/src/ui_macro/store.rs#L21))
 
 #### ui_mail
 
-- With no usable paper the reference reads the first record of an empty list through a null pointer (`0x4ad561`-`0x4ad56d`, `mov eax,[eax]` with `eax` 0) and faults; benilla keeps the row's wire id, so the inbox still opens. ([`src/ui_mail/net.rs:232`](../crates/benilla-app/src/ui_mail/net.rs#L232))
+- With no usable paper the reference reads the first record of an empty list through a null pointer (`0x4ad561`-`0x4ad56d`, `mov eax,[eax]` with `eax` 0) and faults; benilla keeps the row's wire id, because that way the inbox still opens. ([`src/ui_mail/net.rs:232`](../crates/benilla-app/src/ui_mail/net.rs#L232))
 - An open mailbox also re-lists at once, past `CheckInbox`'s 60 s throttle, because a mail announced while the player stands there should show; the reference waits for the close. ([`src/ui_mail/net.rs:388`](../crates/benilla-app/src/ui_mail/net.rs#L388))
 
 #### ui_merchant
@@ -434,33 +434,33 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### ui_script
 
-- The reference reads the install's `Interface\AddOns\`; benilla reads an install and does not live in one, so its addons live in its own state folder, and only there. ([`src/ui_script/addons.rs:265`](../crates/benilla-app/src/ui_script/addons.rs#L265))
-- That file is renamed to `<Name>.lua.bak`, where the reference deletes it, so an addon update that drops its toc line costs the player nothing they cannot get back. ([`src/ui_script/addons.rs:684`](../crates/benilla-app/src/ui_script/addons.rs#L684))
+- The reference reads the install's `Interface\AddOns\`; its addons live in its own state folder, and only there, because benilla reads an install and does not live in one. ([`src/ui_script/addons.rs:265`](../crates/benilla-app/src/ui_script/addons.rs#L265))
+- That file is renamed to `<Name>.lua.bak`, where the reference deletes it, because that way an addon update that drops its toc line costs the player nothing they cannot get back. ([`src/ui_script/addons.rs:684`](../crates/benilla-app/src/ui_script/addons.rs#L684))
 - The reference writes none (its file opens with a blank line); ours names the file, because players open this folder. ([`src/ui_script/addons.rs:742`](../crates/benilla-app/src/ui_script/addons.rs#L742))
 - The reference then re-reads the aspect (`0x492f13`), and on a change of 0.001 or more calls `0x491380`, which sets the reload trigger (`[0xb4b3f4]`) when the script-context check `0x494a50(0xa)` allows it; here a resize re-lays out the live UI, the chat bubbles' window-derived `BubbleGeometry` with it, because the window resizes freely and a reload on each resize would tear down every addon's state mid-play. ([`src/ui_script/extract/mod.rs:543`](../crates/benilla-app/src/ui_script/extract/mod.rs#L543))
-- The V-plate border is resampled sharp to the quad's physical size rather than GPU-magnified, so its 1 px bevel stays crisp; keyed by that size, so only a resize re-rasterises it. ([`src/ui_script/extract/mod.rs:1463`](../crates/benilla-app/src/ui_script/extract/mod.rs#L1463))
+- The V-plate border is resampled sharp to the quad's physical size rather than GPU-magnified, because that way its 1 px bevel stays crisp; keyed by that size, so only a resize re-rasterises it. ([`src/ui_script/extract/mod.rs:1463`](../crates/benilla-app/src/ui_script/extract/mod.rs#L1463))
 - No signature or digest check (`0x46a90b`, `0x46a9d3`, `0x401560(9)`), so the chain's toc always loads and `FRAMES_LOADED` follows, because the check verifies Blizzard's signature with a key carried in the client binary, which benilla does not ship, and a modified interface file is loaded rather than refused. ([`src/ui_script/glue.rs:14`](../crates/benilla-app/src/ui_script/glue.rs#L14))
-- The reference's size callback only re-scales `GlueParent` and re-lays it out (`0x46ac51`, `0x46ac56`), as its root keeps `gxResolution`'s aspect until a rebuild (`0x41ad10` at `0x46a828`) and its window keeps that shape while dragged (`0x5989d7`); here the root is the window's, which takes any shape, so the box follows it on every resize, where a rebuild would reset the screen (the create screen's character and name, the typed password, the selection). ([`src/ui_script/glue.rs:346`](../crates/benilla-app/src/ui_script/glue.rs#L346))
-- The reference's handler completes whichever operation is current; here only the character list's does, in state 3, and a reply of another cause (a roster nothing of the screen asked for) or of another link (before a realm change) completes nothing. ([`src/ui_script/glue_mgr.rs:1520`](../crates/benilla-app/src/ui_script/glue_mgr.rs#L1520))
-- The character is the platform's Unicode text, so a player can type any language on any platform. ([`src/ui_script/input.rs:763`](../crates/benilla-app/src/ui_script/input.rs#L763))
-- A capture run (`scenario_active`) keeps the CRT's default seed, 1, so its frames reproduce. ([`src/ui_script/lifecycle.rs:179`](../crates/benilla-app/src/ui_script/lifecycle.rs#L179))
-- The files are under `benilla-config/Logs/`, since the install is read-only. ([`src/ui_script/load_log.rs:5`](../crates/benilla-app/src/ui_script/load_log.rs#L5))
+- The reference's size callback only re-scales `GlueParent` and re-lays it out (`0x46ac51`, `0x46ac56`), as its root keeps `gxResolution`'s aspect until a rebuild (`0x41ad10` at `0x46a828`) and its window keeps that shape while dragged (`0x5989d7`); here the root is the window's, which takes any shape, so the box follows it on every resize, without a rebuild because that would reset the screen (the create screen's character and name, the typed password, the selection). ([`src/ui_script/glue.rs:346`](../crates/benilla-app/src/ui_script/glue.rs#L346))
+- The reference's handler completes whichever operation is current; here only the character list's does, in state 3, and a reply of another cause (a roster nothing of the screen asked for) or of another link (before a realm change) completes nothing, because the reference has one link and one request in flight and so cannot tell those replies from the operation they would be applied to, while here the IO thread's park serves several. ([`src/ui_script/glue_mgr.rs:1520`](../crates/benilla-app/src/ui_script/glue_mgr.rs#L1520))
+- The character is the platform's Unicode text, because that way a player can type any language on any platform. ([`src/ui_script/input.rs:763`](../crates/benilla-app/src/ui_script/input.rs#L763))
+- A capture run (`scenario_active`) keeps the CRT's default seed, 1, because that way its frames reproduce. ([`src/ui_script/lifecycle.rs:179`](../crates/benilla-app/src/ui_script/lifecycle.rs#L179))
+- The files are under `benilla-config/Logs/`, because the install is read-only. ([`src/ui_script/load_log.rs:5`](../crates/benilla-app/src/ui_script/load_log.rs#L5))
 - `FULLSCREEN_QUADS_RESEAT` re-sizes the full-screen quads, which the stock files size only in their OnLoads, because a resize here keeps the loaded UI and the blackout would stop short of the new screen. ([`src/ui_script/manifest.rs:64`](../crates/benilla-app/src/ui_script/manifest.rs#L64))
 - No `FrameXML.toc` signature check, where `UI_Init` loads on a failed one and then quits (`0x401560(0xa)` at `0x48ff90`), because the check verifies Blizzard's signature with a key carried in the client binary, which benilla does not ship, and a modified interface file is loaded rather than refused. ([`src/ui_script/manifest.rs:161`](../crates/benilla-app/src/ui_script/manifest.rs#L161))
 - A flat 0.9, because 1.0 reads oversized. With `useUiScale` off, its default (`0x8430c0`), the reference sets `max(768/H, 0.9)` above 768 px tall and 1.0 at or below (`0x492f70`, on a mode set and from `0x4908ad`), so the two agree from ~853 px up. benilla never reads `useUiScale`: this CVar always applies to `UIParent` alone, as with it on. ([`src/ui_script/mod.rs:275`](../crates/benilla-app/src/ui_script/mod.rs#L275))
-- The body is read with 0x4000-byte reads filled to the end of the body, so what a read returns does not depend on how the network cut the packets; and the reading stops once the buffer is full, since no later byte can change it. ([`src/ui_script/server_alert.rs:23`](../crates/benilla-app/src/ui_script/server_alert.rs#L23))
-- The connection is direct. The reference opens its session with access type 0 (`InternetOpenA`, `0x7a6d97`), the system's proxy settings, which benilla does not read. ([`src/ui_script/server_alert.rs:26`](../crates/benilla-app/src/ui_script/server_alert.rs#L26))
+- The body is read with 0x4000-byte reads filled to the end of the body, because that way what a read returns does not depend on how the network cut the packets; and the reading stops once the buffer is full, because no later byte can change it. ([`src/ui_script/server_alert.rs:23`](../crates/benilla-app/src/ui_script/server_alert.rs#L23))
+- The connection is direct because the reference opens its session with access type 0 (`InternetOpenA`, `0x7a6d97`), the system's proxy settings, which benilla does not read. ([`src/ui_script/server_alert.rs:26`](../crates/benilla-app/src/ui_script/server_alert.rs#L26))
 - On a worldport it fires with our descriptor present, so `UnitExists("player")` answers true where the reference's (`0x515970`) misses, because matching it breaks `UnitExists` for no stock reader. ([`src/ui_script/sweep.rs:154`](../crates/benilla-app/src/ui_script/sweep.rs#L154))
 
 #### ui_social
 
 - After a full 50 the reference reads the 160 bytes past the array (`0xc2a0f8`, the counts at `0xc2a120` among them); benilla answers the miss. ([`src/ui_social/live.rs:72`](../crates/benilla-app/src/ui_social/live.rs#L72))
-- A filter of 127 bytes or more puts the copy's NUL in the name buffer's first byte (`0x5aec1a`), so a name an earlier tag set is scanned as more filter. benilla ends the copy at its own NUL: the run-on reads one stack buffer through another. ([`src/ui_social/query.rs:76`](../crates/benilla-app/src/ui_social/query.rs#L76))
-- `C1_SPACE` from `GetStringTypeW` is the Windows system's own table, which no file of the client holds; benilla answers Unicode's `White_Space` for those units, and nothing for a lone surrogate. ([`src/ui_social/query.rs:164`](../crates/benilla-app/src/ui_social/query.rs#L164))
+- A filter of 127 bytes or more puts the copy's NUL in the name buffer's first byte (`0x5aec1a`), so a name an earlier tag set is scanned as more filter. benilla ends the copy at its own NUL because the run-on reads one stack buffer through another. ([`src/ui_social/query.rs:76`](../crates/benilla-app/src/ui_social/query.rs#L76))
+- Benilla answers Unicode's `White_Space` for those units, and nothing for a lone surrogate, because `C1_SPACE` from `GetStringTypeW` is the Windows system's own table, which no file of the client holds. ([`src/ui_social/query.rs:164`](../crates/benilla-app/src/ui_social/query.rs#L164))
 
 #### ui_summon
 
-- The latch is dropped at session end and an Accept with nothing latched sends nothing, so no stale or zero guid reaches the server. ([`src/ui_summon.rs:18`](../crates/benilla-app/src/ui_summon.rs#L18))
+- The latch is dropped at session end and an Accept with nothing latched sends nothing, because that way no stale or zero guid reaches the server. ([`src/ui_summon.rs:18`](../crates/benilla-app/src/ui_summon.rs#L18))
 
 #### ui_talent_wipe
 
@@ -471,12 +471,12 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 - Text the reference magnifies from a smaller raster is rasterized at its true size here: a `SetTextHeight` size (the bit cleared at `0x771600`), an em past 32 px, and 3-D unit names (`UNIT_NAME_FONT`, em 32, string flag `0x80`), because the 32 px cap is a raster-memory budget that blurs big text on a modern display (`super::FONTSTRING_EM_CAP`). ([`src/ui_text/engine/mod.rs:8`](../crates/benilla-app/src/ui_text/engine/mod.rs#L8))
 - The reference flushes every glyph cache on a window resize (`0x5c2b50` → `0x5ca6f0`); this keeps the old cells, because nameplate meshes bake UVs and a flush would rebuild them every resize frame. ([`src/ui_text/engine/mod.rs:13`](../crates/benilla-app/src/ui_text/engine/mod.rs#L13))
-- The reference's measure kernels (`0x5c6940`, `0x5c6b70`, `0x5c6c50`, `0x5c7300`, `0x5c7470`) rasterize each character, but the step law reads only the advance, so skipping the bitmap changes no width. ([`src/ui_text/engine/mod.rs:362`](../crates/benilla-app/src/ui_text/engine/mod.rs#L362))
+- The reference's measure kernels (`0x5c6940`, `0x5c6b70`, `0x5c6c50`, `0x5c7300`, `0x5c7470`) rasterize each character; here the bitmap is skipped, which changes no width because the step law reads only the advance. ([`src/ui_text/engine/mod.rs:362`](../crates/benilla-app/src/ui_text/engine/mod.rs#L362))
 - The reference evicts the least recently used glyph and repacks its hole (`0x5cad2b`, over `[CGxFont+0x64..0x6c]`); this drops every cell, because a shelf allocator cannot reclaim an interior cell and the sheet is far larger than the reference's 256×256 pages. ([`src/ui_text/engine/mod.rs:652`](../crates/benilla-app/src/ui_text/engine/mod.rs#L652))
 - Every UI text block sits 1 device px below the reference's snapped row, because at that row UI text reads high. ([`src/ui_text/layout/mod.rs:119`](../crates/benilla-app/src/ui_text/layout/mod.rs#L119))
 - The cap is 32 logical units, not 32 device px, because the reference's raster-memory ceiling draws all big text at the same 32 device px on a modern display; at the 768-tall design height the two agree. ([`src/ui_text/mod.rs:54`](../crates/benilla-app/src/ui_text/mod.rs#L54))
-- `r × floor(dpi)` passes, so the ring keeps its logical weight on a whole-number high-DPI raster; a fractional scale such as 1.5 rounds down to the reference's one texel a pass. ([`src/ui_text/outline.rs:60`](../crates/benilla-app/src/ui_text/outline.rs#L60))
-- `r × floor(dpi)` passes as in `outlined_cell`, the first `floor(dpi)` of them the opaque ring. ([`src/ui_text/outline.rs:168`](../crates/benilla-app/src/ui_text/outline.rs#L168))
+- `r × floor(dpi)` passes, because that way the ring keeps its logical weight on a whole-number high-DPI raster; a fractional scale such as 1.5 rounds down to the reference's one texel a pass. ([`src/ui_text/outline.rs:60`](../crates/benilla-app/src/ui_text/outline.rs#L60))
+- `r × floor(dpi)` passes as in `outlined_cell`, the first `floor(dpi)` of them the opaque ring. ([`src/ui_text/outline.rs:169`](../crates/benilla-app/src/ui_text/outline.rs#L169))
 - One sheet, where the reference keeps up to 8 pages per font (`[CGxFont+0x18c]`), because a nameplate bakes its glyphs into one mesh with one material, which a page would split. ([`src/ui_text/pack.rs:11`](../crates/benilla-app/src/ui_text/pack.rs#L11))
 
 #### ui_tooltip
@@ -500,27 +500,27 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 #### vplates
 
 - The basis is damped past `PLATE_DIAG_KNEE`, because the reference's unbounded growth (`0x7705b0`) draws plates too large and soft at high resolutions. ([`src/vplates.rs:14`](../crates/benilla-app/src/vplates.rs#L14))
-- The bar fill brightens by `LIT_BOOST` in place of the reference's ADD `Nameplate-Glow` rim, which reads as hard edge lines under benilla's linear blending. ([`src/vplates.rs:18`](../crates/benilla-app/src/vplates.rs#L18))
+- The bar fill brightens by `LIT_BOOST` in place of the reference's ADD `Nameplate-Glow` rim, because that reads as hard edge lines under benilla's linear blending. ([`src/vplates.rs:18`](../crates/benilla-app/src/vplates.rs#L18))
 - `LEVEL_H` is 0.0086, one em under the reference's 0.009, because the level number read too large. ([`src/vplates.rs:118`](../crates/benilla-app/src/vplates.rs#L118))
 - The reference dims non-target plates to `0x7F`; raised because that fades them too far to read. ([`src/vplates.rs:134`](../crates/benilla-app/src/vplates.rs#L134))
-- The reference draws at fractional device coordinates; the snap keeps the magnified border crisp. ([`src/vplates.rs:193`](../crates/benilla-app/src/vplates.rs#L193))
-- The reference's plates grow with the diagonal without limit (`0x7705b0`), which reads too big and soft; past this diagonal, where the frame is the border art's native 128x32 px, the basis grows at `PLATE_GROWTH_DAMP` of that rate. ([`src/vplates.rs:199`](../crates/benilla-app/src/vplates.rs#L199))
-- A constant one-logical-pixel shadow, not the reference's 0.001 gx, which draws 2 px thick and too heavy at larger windows. ([`src/vplates.rs:670`](../crates/benilla-app/src/vplates.rs#L670))
+- The reference draws at fractional device coordinates; here the position snaps because that keeps the magnified border crisp. ([`src/vplates.rs:193`](../crates/benilla-app/src/vplates.rs#L193))
+- The reference's plates grow with the diagonal without limit (`0x7705b0`); past this diagonal, where the frame is the border art's native 128x32 px, the basis grows at `PLATE_GROWTH_DAMP` of that rate, because unlimited growth reads too big and soft. ([`src/vplates.rs:200`](../crates/benilla-app/src/vplates.rs#L200))
+- A constant one-logical-pixel shadow, not the reference's 0.001 gx, because that draws 2 px thick and too heavy at larger windows. ([`src/vplates.rs:671`](../crates/benilla-app/src/vplates.rs#L671))
 - The reference magnifies the 128 × 32 `Interface\Tooltips\Nameplate-Border` art with `GL_LINEAR` (`0x770200`, filter `[0x878cf0]` = 1), smearing its 1 px bevel once the plate is larger than native; we resample the same pixels to the plate's physical size with sharp bilinear and draw it 1:1, because the chosen look is the same art with a crisp bevel. `super::drive_vplates` regenerates it when the physical size changes. ([`src/vplates/border.rs:3`](../crates/benilla-app/src/vplates/border.rs#L3))
 
 #### wdb
 
 - The files are `benilla-config/cache/<realm>/<store>.bin` through `crate::local_state`, not `WDB/` in the install, which is read-only; they are per realm, because another server may hold another template under the same key; and a store is written ten seconds after an answer lands as well as at exit, so a crash costs only re-asking. ([`src/wdb.rs:38`](../crates/benilla-app/src/wdb.rs#L38))
-- The reference keeps a saved store's ask "pending" for the rest of the process (`0x555740` clears only the stores built with persistence off), so a query a lost link dropped is never sent again until restart; benilla's reconnect asks it again. ([`src/wdb.rs:344`](../crates/benilla-app/src/wdb.rs#L344))
+- The reference keeps a saved store's ask "pending" for the rest of the process (`0x555740` clears only the stores built with persistence off), so a query a lost link dropped is never sent again until restart; benilla's reconnect asks it again because the name or text it was for would otherwise stay blank until restart. ([`src/wdb.rs:344`](../crates/benilla-app/src/wdb.rs#L344))
 
 #### world_console
 
-- A float the scan leaves unread is 0.0, where the reference reads whatever its uninitialised stack slot holds. ([`src/world_console.rs:217`](../crates/benilla-app/src/world_console.rs#L217))
+- A float the scan leaves unread is 0.0, because the reference reads whatever its uninitialised stack slot holds. ([`src/world_console.rs:217`](../crates/benilla-app/src/world_console.rs#L217))
 ### benilla-assets
 
 #### anim_rng
 
-- A capture run (`deterministic`) keeps the default seed, so its frames reproduce. ([`src/anim_rng.rs:39`](../crates/benilla-assets/src/anim_rng.rs#L39))
+- A capture run (`deterministic`) keeps the default seed, because that way its frames reproduce. ([`src/anim_rng.rs:39`](../crates/benilla-assets/src/anim_rng.rs#L39))
 
 #### model
 
@@ -548,7 +548,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 #### chain
 
 - An archive that fails to open is an error. In 1.12.1 a failed base archive is fatal (Error #134: `0x4038ea` → `0x64d0e0` → `0x64cfa0` → `0x64cc80`, `ExitProcess`) and only a failing patch archive is skipped, silently; benilla fails on that too, because a skipped corrupt archive surfaces only as missing files far downstream. ([`src/chain.rs:67`](../crates/benilla-formats/src/chain.rs#L67))
-- A last line with no CR or LF after it is passed too, where `0x648fb0` ends at the buffer's end without a flush (`0x64907f`) and drops it, a bug that loses a listfile's last name when it lacks a newline. ([`src/chain.rs:234`](../crates/benilla-formats/src/chain.rs#L234))
+- A last line with no CR or LF after it is passed too, because `0x648fb0` ends at the buffer's end without a flush (`0x64907f`) and drops it, a bug that loses a listfile's last name when it lacks a newline. ([`src/chain.rs:234`](../crates/benilla-formats/src/chain.rs#L234))
 
 #### characters
 
@@ -560,11 +560,11 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### elevators
 
-- A path that cannot drive a cycle is dropped and its GO stays at its spawn point, where the reference faults or hangs: a last frame at 0 divides by zero (`0x5f62a4`), and a first frame past 0, one frame among them, leaves a time before it in no bracket, which `0x5f62bc`-`0x5f62e7` seek forever. ([`src/elevators.rs:62`](../crates/benilla-formats/src/elevators.rs#L62))
+- A path that cannot drive a cycle is dropped and its GO stays at its spawn point, because the reference faults or hangs: a last frame at 0 divides by zero (`0x5f62a4`), and a first frame past 0, one frame among them, leaves a time before it in no bracket, which `0x5f62bc`-`0x5f62e7` seek forever. ([`src/elevators.rs:62`](../crates/benilla-formats/src/elevators.rs#L62))
 
 #### emote_text
 
-- A surplus `%s` stays verbatim, where the reference would print stack garbage; no shipped row has one. ([`src/emote_text.rs:113`](../crates/benilla-formats/src/emote_text.rs#L113))
+- A surplus `%s` stays verbatim, because the reference would print stack garbage; no shipped row has one. ([`src/emote_text.rs:113`](../crates/benilla-formats/src/emote_text.rs#L113))
 
 #### garble
 
@@ -573,7 +573,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### loose
 
-- A folder is listed the first time a key reaches it, where the reference lists every folder at the first open (`0x646ea0`), so a file added to a folder no key has reached is found before the index empties; the whole walk takes minutes and gigabytes where the install folder holds or links a large tree, as a Wine prefix's `z:` drive links `/`. ([`src/loose.rs:31`](../crates/benilla-formats/src/loose.rs#L31))
+- A folder is listed the first time a key reaches it, where the reference lists every folder at the first open (`0x646ea0`), so a file added to a folder no key has reached is found before the index empties; folders are listed lazily because the whole walk takes minutes and gigabytes where the install folder holds or links a large tree, as a Wine prefix's `z:` drive links `/`. ([`src/loose.rs:31`](../crates/benilla-formats/src/loose.rs#L31))
 
 #### macro_icons
 
@@ -581,10 +581,10 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### models
 
-- The fraction is clamped to `[0, 1]`; the reference extrapolates, which for a window whose brackets miss the band can push a fix16 factor negative and cull the batch on a quirk. ([`src/models/key_anim.rs:130`](../crates/benilla-formats/src/models/key_anim.rs#L130))
+- The fraction is clamped to `[0, 1]` because the reference extrapolates, which for a window whose brackets miss the band can push a fix16 factor negative and cull the batch on a quirk. ([`src/models/key_anim.rs:130`](../crates/benilla-formats/src/models/key_anim.rs#L130))
 - Owners past the ceiling (Maraudon's waterfalls, the glue screens) keep the interleave with their emitters, because a bias past a 200-yard owner would jump every transparent surface in the zone. ([`src/models/m2_batches.rs:682`](../crates/benilla-formats/src/models/m2_batches.rs#L682))
-- The fx lane redraws them as projected decals (`ground_fx`) so they drape the terrain. ([`src/models/types.rs:383`](../crates/benilla-formats/src/models/types.rs#L383))
-- Consumers light such a card off the side it presents, because the reference's shading of it is inverted and follows the camera. ([`src/models/types.rs:454`](../crates/benilla-formats/src/models/types.rs#L454))
+- The fx lane redraws them as projected decals (`ground_fx`) because that way they drape the terrain. ([`src/models/types.rs:383`](../crates/benilla-formats/src/models/types.rs#L383))
+- Consumers light such a card off the side it presents, because the reference's shading of it is inverted and follows the camera. ([`src/models/types.rs:455`](../crates/benilla-formats/src/models/types.rs#L455))
 - The UV comes from the model-space position, not each surface's own `(i, j)`, because the two agree on cell-aligned surfaces and the position never seams where they are not. ([`src/models/wmo/group.rs:19`](../crates/benilla-formats/src/models/wmo/group.rs#L19))
 
 #### particles
@@ -598,23 +598,23 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### spells
 
-- Every token keys the `$l` plural. The reference's `$a`, `$d`, `$t`, `$e`, `$c`, `$p`, `$f`, `$F` and `$z` arms never write `[0xbe0b84]`, so its `$l` keys on the number before them, and Blizzard's "$s1 … every $t1 $lsecond:seconds;" reads "every 1 seconds" in 1.12.1. ([`src/spells/tokens.rs:690`](../crates/benilla-formats/src/spells/tokens.rs#L690))
+- Every token keys the `$l` plural because the reference's `$a`, `$d`, `$t`, `$e`, `$c`, `$p`, `$f`, `$F` and `$z` arms never write `[0xbe0b84]`, so its `$l` keys on the number before them, and Blizzard's "$s1 … every $t1 $lsecond:seconds;" reads "every 1 seconds" in 1.12.1. ([`src/spells/tokens.rs:690`](../crates/benilla-formats/src/spells/tokens.rs#L690))
 
 #### tga
 
 - Grayscale types 3 and 11 decode where the reference refuses them, because no shipped or addon file is one and removing working code would buy nothing. ([`src/tga.rs:6`](../crates/benilla-formats/src/tga.rs#L6))
-- Colour maps of 15, 16 and 32 bits decode at the entry width the file declares, where the reference has no defined result to copy for 15 and 16 bits and only a garble for 32. ([`src/tga.rs:9`](../crates/benilla-formats/src/tga.rs#L9))
-- A colour-mapped image whose descriptor has alpha bits decodes as its picture, where the reference has no defined result to copy. `0x5a3820` sizes each pixel as 24 plus the alpha bits (`0x5a382b`-`0x5a383d`, stored at `0x5a3973`) but copies 3-byte entries (`0x5a38f3`), then `0x5a3b80` moves `(bpp + 7) >> 3` bytes a pixel (`0x5a3c00`-`0x5a3c13`): each pixel after the first takes its bytes from its neighbours, and the last read heap that was never written. ([`src/tga.rs:16`](../crates/benilla-formats/src/tga.rs#L16))
-- A truecolour image whose depth less its alpha bits is 24, but whose depth is not 24 or 32, is refused where the reference crashes. ([`src/tga.rs:22`](../crates/benilla-formats/src/tga.rs#L22))
+- Colour maps of 15, 16 and 32 bits decode at the entry width the file declares, because the reference has no defined result to copy for 15 and 16 bits and only a garble for 32. ([`src/tga.rs:9`](../crates/benilla-formats/src/tga.rs#L9))
+- A colour-mapped image whose descriptor has alpha bits decodes as its picture, because the reference has no defined result to copy. `0x5a3820` sizes each pixel as 24 plus the alpha bits (`0x5a382b`-`0x5a383d`, stored at `0x5a3973`) but copies 3-byte entries (`0x5a38f3`), then `0x5a3b80` moves `(bpp + 7) >> 3` bytes a pixel (`0x5a3c00`-`0x5a3c13`): each pixel after the first takes its bytes from its neighbours, and the last read heap that was never written. ([`src/tga.rs:17`](../crates/benilla-formats/src/tga.rs#L17))
+- A truecolour image whose depth less its alpha bits is 24, but whose depth is not 24 or 32, is refused because the reference crashes. ([`src/tga.rs:23`](../crates/benilla-formats/src/tga.rs#L23))
 
 #### transports
 
-- `None` too where the reference's build overruns its stack or reads memory it never wrote (`transports#path-faults`), so the ship stays at its spawn: more than 1024 nodes in a leg (`0x5f9530`), a leg of 3 nodes or fewer (`0x4532e3`) and a stop on a leg's last node (`0x5f91a1`). ([`src/transports/mod.rs:82`](../crates/benilla-formats/src/transports/mod.rs#L82))
+- `None` too, so the ship stays at its spawn, because there the reference's build overruns its stack or reads memory it never wrote (`transports#path-faults`): more than 1024 nodes in a leg (`0x5f9530`), a leg of 3 nodes or fewer (`0x4532e3`) and a stop on a leg's last node (`0x5f91a1`). ([`src/transports/mod.rs:82`](../crates/benilla-formats/src/transports/mod.rs#L82))
 ### benilla-lua
 
 #### api
 
-- The C build grows a string while `realloc` succeeds, and a failure is the catchable `not enough memory`; Rust's allocator aborts the process instead, and Linux grants far more than it can fill, so past this bound the libraries raise C's message. ([`src/api.rs:32`](../crates/benilla-lua/src/api.rs#L32))
+- The C build grows a string while `realloc` succeeds, and a failure is the catchable `not enough memory`; past this bound the libraries raise C's message because Rust's allocator aborts the process instead, and Linux grants far more than it can fill. ([`src/api.rs:32`](../crates/benilla-lua/src/api.rs#L32))
 
 #### heap
 
@@ -623,17 +623,17 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### lib_math
 
-- The client's one process-wide stream is shared with its engine draws; here each VM holds its own, seeded from the wall clock when it is built, so a fork or a clone draws its own sequence. ([`src/lib_math.rs:230`](../crates/benilla-lua/src/lib_math.rs#L230))
+- The client's one process-wide stream is shared with its engine draws; here each VM holds its own, seeded from the wall clock when it is built, because that way a fork or a clone draws its own sequence. ([`src/lib_math.rs:230`](../crates/benilla-lua/src/lib_math.rs#L230))
 
 #### lib_string
 
-- The decoder reads a NUL as no bytes (`0x7fbeda`), so the client's loop never passes one and the call never returns; here the result ends there. ([`src/lib_string.rs:98`](../crates/benilla-lua/src/lib_string.rs#L98))
-- The client writes 5.0 bytecode (`luaU_dump`, `0x6fb600`); benilla writes 5.1's header and the function's source name. ([`src/lib_string.rs:234`](../crates/benilla-lua/src/lib_string.rs#L234))
+- Here the result ends there, because the decoder reads a NUL as no bytes (`0x7fbeda`), so the client's loop never passes one and the call never returns. ([`src/lib_string.rs:98`](../crates/benilla-lua/src/lib_string.rs#L98))
+- The client writes 5.0 bytecode (`luaU_dump`, `0x6fb600`); benilla writes 5.1's header and the function's source name because the client loads no binary chunk (`0x6f6a15`), so the bytes are only data, and matching them would need 5.0's code generator. ([`src/lib_string.rs:234`](../crates/benilla-lua/src/lib_string.rs#L234))
 - 5.1's `match` recurses without a bound and overflows the C stack (near 32000 levels on 8 MB); this raises 5.2's `pattern too complex` instead. ([`src/lib_string.rs:528`](../crates/benilla-lua/src/lib_string.rs#L528))
 
 #### lib_table
 
-- The client's loops have no bound (`0x7fb728`, `0x7fb7e0`), but a remembered size is whatever an addon wrote, and the instruction-budget hook never sees a native's loop, so one over two billion slots would hang the client. ([`src/lib_table.rs:34`](../crates/benilla-lua/src/lib_table.rs#L34))
+- The client's loops have no bound (`0x7fb728`, `0x7fb7e0`); here they are bounded because a remembered size is whatever an addon wrote, and the instruction-budget hook never sees a native's loop, so one over two billion slots would hang the client. ([`src/lib_table.rs:34`](../crates/benilla-lua/src/lib_table.rs#L34))
 
 #### pools
 
@@ -653,17 +653,17 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 - The patch state downloads no patch and starts no updater, because benilla runs no code a server sends. ([`src/auth.rs:120`](../crates/benilla-protocol/src/auth.rs#L120))
 - A stored per-OS constant, not the reference's HMAC over its own executables (`0x5b1170`), because every mangos-family realmd issues this one salt. ([`src/auth.rs:302`](../crates/benilla-protocol/src/auth.rs#L302))
-- The survey id is read and dropped, and no survey runs, where the reference keeps it on the link (`0x5bad53`) for the `Survey.dll` it downloads and calls (`GetSurveyId 0x5ab620`, called at `0x474064`). benilla runs no code a server sends (`AuthReject::reply` gives the rule). ([`src/auth.rs:376`](../crates/benilla-protocol/src/auth.rs#L376))
+- The survey id is read and dropped, and no survey runs, where the reference keeps it on the link (`0x5bad53`) for the `Survey.dll` it downloads and calls (`GetSurveyId 0x5ab620`, called at `0x474064`). benilla does this because it runs no code a server sends (`AuthReject::reply` gives the rule). ([`src/auth.rs:376`](../crates/benilla-protocol/src/auth.rs#L376))
 
 #### events
 
 - `benilla::spell_mods` refuses an out-of-range pair, because the reference would overrun it. ([`src/events.rs:774`](../crates/benilla-protocol/src/events.rs#L774))
-- An out-of-range list past the first block reads no body in the write passes (`0x466076`), which misread every block behind it, while the notify pass reads past it (`0x465fd0`) and stays in step; benilla reads the list and drops it, keeping the blocks behind it whole. ([`src/events/decode.rs:1149`](../crates/benilla-protocol/src/events/decode.rs#L1149))
-- The flagged pass reads a movement block's guid as 8 raw bytes (`0x467140`, `0x46714d`) where the wire packs it, so unless the packed guid happens to be 8 bytes the reference misreads the rest of that pass; benilla reads the block once, packed, as pass 0 does (`0x467080`). ([`src/events/decode.rs:1166`](../crates/benilla-protocol/src/events/decode.rs#L1166))
+- An out-of-range list past the first block reads no body in the write passes (`0x466076`), which misread every block behind it, while the notify pass reads past it (`0x465fd0`) and stays in step; benilla reads the list and drops it, keeping the blocks behind it whole, because the faults the reference's passes have on malformed packets are recorded, not copied. ([`src/events/decode.rs:1149`](../crates/benilla-protocol/src/events/decode.rs#L1149))
+- The flagged pass reads a movement block's guid as 8 raw bytes (`0x467140`, `0x46714d`) where the wire packs it, so unless the packed guid happens to be 8 bytes the reference misreads the rest of that pass; benilla reads the block once, packed, as pass 0 does (`0x467080`), because of the misreading just described. ([`src/events/decode.rs:1167`](../crates/benilla-protocol/src/events/decode.rs#L1167))
 
 #### examples
 
-- Benilla always sends the published constant instead, since an install without those binaries could never answer for itself. ([`examples/version_check_probe.rs:9`](../crates/benilla-protocol/examples/version_check_probe.rs#L9))
+- Benilla always sends the published constant instead, because an install without those binaries could never answer for itself. ([`examples/version_check_probe.rs:9`](../crates/benilla-protocol/examples/version_check_probe.rs#L9))
 
 #### messages
 
@@ -671,7 +671,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 - The whole stream is sent, where the reference cuts it at the file's size (`0x5afb42`), because the server refuses a cut stream and the next login then downloads its old copy over the player's file. ([`src/messages/account_data.rs:85`](../crates/benilla-protocol/src/messages/account_data.rs#L85))
 - A fixed list, not read off the install, because no third-party addon sets `## Secure:`, so the two differ only where the `.pub` files were altered. ([`src/messages/addons.rs:93`](../crates/benilla-protocol/src/messages/addons.rs#L93))
 - Every row is kept, because the reference takes the count unclamped into its 80 row blocks and a larger one overruns them. ([`src/messages/battlefield.rs:98`](../crates/benilla-protocol/src/messages/battlefield.rs#L98))
-- A larger count keeps the first 40, where the reference's handler writes past the store. ([`src/messages/battlefield.rs:188`](../crates/benilla-protocol/src/messages/battlefield.rs#L188))
+- A larger count keeps the first 40, because the reference's handler writes past the store. ([`src/messages/battlefield.rs:188`](../crates/benilla-protocol/src/messages/battlefield.rs#L188))
 - Text without a NUL stops at `length`, because the reference reads on out of bounds. ([`src/messages/broadcast.rs:29`](../crates/benilla-protocol/src/messages/broadcast.rs#L29))
 - The 1.12 client appends a zlib chat transcript to a category 2 ticket (`0x5ef936`); we omit it because vmangos never reads it and logs the leftover bytes. ([`src/messages/gm_ticket.rs:48`](../crates/benilla-protocol/src/messages/gm_ticket.rs#L48))
 - String reads are unbounded. The reference `0x4191b0` caps each field, counting the NUL (roster name `0x30`, notes `0x80`, MOTD `0x200`, info `0x7d0`, guild name `0x60`, rank name `0x40`), and on overflow empties it and no-ops every later read in the packet. ([`src/messages/guild.rs:4`](../crates/benilla-protocol/src/messages/guild.rs#L4))
@@ -679,18 +679,18 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 - 2 or more prints nothing, because the reference prints an uninitialized buffer. ([`src/messages/opcode.rs:1059`](../crates/benilla-protocol/src/messages/opcode.rs#L1059))
 - The consumer refuses 64 and up, because there the reference's store overruns its table. ([`src/messages/packet.rs:654`](../crates/benilla-protocol/src/messages/packet.rs#L654))
 - A body too short for the position gives `None` where the client redisplays a stale global, because showing a stale queue position as current is a client bug. ([`src/messages/parse.rs:285`](../crates/benilla-protocol/src/messages/parse.rs#L285))
-- A type outside 1-7 reads as nothing rather than the reference's default arm, which under-pushes its returns. ([`src/messages/pet.rs:71`](../crates/benilla-protocol/src/messages/pet.rs#L71))
-- Both are read, told apart exactly by the tail length (`12n` vs `1 + 14n`), since the 1.12 client mis-parses vmangos's. ([`src/messages/pet.rs:191`](../crates/benilla-protocol/src/messages/pet.rs#L191))
+- A type outside 1-7 reads as nothing rather than the reference's default arm, because that arm under-pushes its returns. ([`src/messages/pet.rs:71`](../crates/benilla-protocol/src/messages/pet.rs#L71))
+- Both are read, told apart exactly by the tail length (`12n` vs `1 + 14n`), because the 1.12 client mis-parses vmangos's. ([`src/messages/pet.rs:191`](../crates/benilla-protocol/src/messages/pet.rs#L191))
 - The active player's gender is this byte too, where `CGPlayer_C::GetGender` (`0x5ed5b0`) reads `PLAYER_BYTES_3` byte 0 whole, because that byte also carries the drunk bits (`gender | drunk & 0xFFFE` on vmangos), so a drunk female reads as male. ([`src/messages/update_object/fields/player.rs:573`](../crates/benilla-protocol/src/messages/update_object/fields/player.rs#L573))
 
 #### world
 
 - A size past 23 bits is refused, where the reference sends it with bit 23 folded into the flag (`0x5b5712` `or dl,0x80` keeps one byte), because no client packet comes near 8 MB and a refusal beats a corrupt header. ([`src/world/mod.rs:139`](../crates/benilla-protocol/src/world/mod.rs#L139))
 - 10 s of silence ends the wait, where the reference has no timer and waits for the reply, a disconnect or the player's Cancel (`0x46b720`; its connect reports only success or a socket error, `0x5b60c6`-`0x5b61ac`), because each wait here is a blocking read on the net thread, which a server that stays connected and never answers would hold for good. ([`src/world/session.rs:15`](../crates/benilla-protocol/src/world/session.rs#L15))
-- The reference waits forever; a bound tells a server that died mid-queue from a long wait. ([`src/world/session.rs:22`](../crates/benilla-protocol/src/world/session.rs#L22))
-- Zeros until one does, where the reference's words are never initialised (the session is allocated without zero-fill, `ui/billing` in benilla-re). ([`src/world/session.rs:65`](../crates/benilla-protocol/src/world/session.rs#L65))
-- Checked per queue packet where the reference checks each tick, so a cancel can lag one server update. ([`src/world/session.rs:102`](../crates/benilla-protocol/src/world/session.rs#L102))
-- Benilla runs no Warden module and answers nothing, where the reference hands `SMSG_WARDEN_DATA` to the module its connect loads (`0x6ca2f0`, `0x6ca5c0`) and sends that module's answer as `CMSG_WARDEN_DATA` (`0x6ca6a0`). ([`src/world/session.rs:244`](../crates/benilla-protocol/src/world/session.rs#L244))
+- The reference waits forever; here the wait is bounded because that tells a server that died mid-queue from a long wait. ([`src/world/session.rs:22`](../crates/benilla-protocol/src/world/session.rs#L22))
+- Zeros until one does, because the reference's words are never initialised (the session is allocated without zero-fill, `ui/billing` in benilla-re). ([`src/world/session.rs:66`](../crates/benilla-protocol/src/world/session.rs#L66))
+- Checked per queue packet where the reference checks each tick, so a cancel can lag one server update. ([`src/world/session.rs:103`](../crates/benilla-protocol/src/world/session.rs#L103))
+- Benilla runs no Warden module and answers nothing, because the answers come from native Win32 x86 code the server sends, which the client maps, links and runs in its own process (`0x7a79d0`), and benilla runs no such code on any platform (`crate::auth::AuthReject::reply` gives the rule). ([`src/world/session.rs:245`](../crates/benilla-protocol/src/world/session.rs#L245))
 ### benilla-srp
 
 #### (crate root)
@@ -701,16 +701,16 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### civil
 
-- A `_dstbias` that takes the time below 0 faults the client, which copies the second `localtime`'s null answer unchecked (`0x740842` → `0x740860`); here it is refused. ([`src/civil.rs:87`](../crates/benilla-ui/src/civil.rs#L87))
+- A `_dstbias` that takes the time below 0 is refused here because it faults the client, which copies the second `localtime`'s null answer unchecked (`0x740842` → `0x740860`). ([`src/civil.rs:87`](../crates/benilla-ui/src/civil.rs#L87))
 - The zone database's offset for the date, where the reference's CRT applies the rules it read for every date, so a date in a zone whose offset has since changed does not round-trip through `time{}`. ([`src/civil.rs:121`](../crates/benilla-ui/src/civil.rs#L121))
 
 #### loader
 
 - A `<Script file=>` value with a separator joins the including document's directory, like a bare name. ([`src/loader/mod.rs:413`](../crates/benilla-ui/src/loader/mod.rs#L413))
-- Padded to the block's line, so a raise reports a line a reader can find in the file; the reference counts from the body's first line. ([`src/loader/mod.rs:438`](../crates/benilla-ui/src/loader/mod.rs#L438))
-- A cycle (`A` inherits `B`, `B` inherits `A`) stops at the repeated name with a warning. ([`src/loader/mod.rs:546`](../crates/benilla-ui/src/loader/mod.rs#L546))
-- A link that would close a loop is refused and reported; the reference's XML legs (`0x783ce6`, `0x783d22`) check nothing, and the next push down such a loop would never end. ([`src/loader/mod.rs:723`](../crates/benilla-ui/src/loader/mod.rs#L723))
-- `<HighlightColor>` and `<DisabledColor>` colour their own fonts; 1.12.1 sends both to the normal colour setter (`0x778aa4`, `0x778ada` call `0x778e20`), so neither could reach its state. ([`src/loader/widgets.rs:215`](../crates/benilla-ui/src/loader/widgets.rs#L215))
+- Padded to the block's line, because that way a raise reports a line a reader can find in the file; the reference counts from the body's first line. ([`src/loader/mod.rs:438`](../crates/benilla-ui/src/loader/mod.rs#L438))
+- A cycle (`A` inherits `B`, `B` inherits `A`) stops at the repeated name with a warning because the reference has no guard: its `parent=` walk (`0x6ee390`-`0x6ee3c2`) spins forever round a cycle with no `parent=` on it, and where one stops that walk, the level recursion (`0x76985c`, and `0x76a092` for the `<Frames>`) overflows the stack. ([`src/loader/mod.rs:547`](../crates/benilla-ui/src/loader/mod.rs#L547))
+- A link that would close a loop is refused and reported because the reference's XML legs (`0x783ce6`, `0x783d22`) check nothing, and the next push down such a loop would never end. ([`src/loader/mod.rs:724`](../crates/benilla-ui/src/loader/mod.rs#L724))
+- `<HighlightColor>` and `<DisabledColor>` colour their own fonts because 1.12.1 sends both to the normal colour setter (`0x778aa4`, `0x778ada` call `0x778e20`), so neither could reach its state. ([`src/loader/widgets.rs:215`](../crates/benilla-ui/src/loader/widgets.rs#L215))
 
 #### markup
 
@@ -719,13 +719,13 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### order
 
-- A child that left the scroll draw is drawn once, by the flat pass, where the client's callback, which reads only the child's visibility, draws it a second time, clipped, at the ScrollFrame's place. ([`src/order.rs:544`](../crates/benilla-ui/src/order.rs#L544))
+- A child that left the scroll draw is drawn once, by the flat pass, because the client's callback, which reads only the child's visibility, draws it a second time, clipped, at the ScrollFrame's place. ([`src/order.rs:544`](../crates/benilla-ui/src/order.rs#L544))
 
 #### script
 
 - An out-of-range slot answers nil, because the reference indexes `0xbc6980` with no bounds check and reads the memory beside its 120 slots. ([`src/script/action.rs:621`](../crates/benilla-ui/src/script/action.rs#L621))
-- The files the handler writes beside the install (`<Name>.pub` with the key, `<Name>.url`; `0x51dce0`, `0x51dde0`) are not written, as the install is read-only; the key is never read either, as there is no signature to verify with it. ([`src/script/addon.rs:207`](../crates/benilla-ui/src/script/addon.rs#L207))
-- Holding the file, so the shutdown write keeps it. ([`src/script/addon.rs:787`](../crates/benilla-ui/src/script/addon.rs#L787))
+- The files the handler writes beside the install (`<Name>.pub` with the key, `<Name>.url`; `0x51dce0`, `0x51dde0`) are not written, because the install is read-only; the key is never read either, because there is no signature to verify with it. ([`src/script/addon.rs:207`](../crates/benilla-ui/src/script/addon.rs#L207))
+- Holding the file, because that way the shutdown write keeps it. ([`src/script/addon.rs:787`](../crates/benilla-ui/src/script/addon.rs#L787))
 - The reference drops a send that resolves to PARTY while party slot 0's guid (`0xbc6f48`) is zero (`0x49fa9f`-`0x49faab`); benilla sends it, because `PartyState` is empty until the first `SMSG_GROUP_LIST` and the gate would swallow a real broadcast. vmangos drops a group-less party line anyway (`ChatHandler.cpp:476`). ([`src/script/addon_message.rs:7`](../crates/benilla-ui/src/script/addon_message.rs#L7))
 - Backed off to a char boundary, because a `String` must stay UTF-8; the cut is the same for ASCII. ([`src/script/addon_message.rs:125`](../crates/benilla-ui/src/script/addon_message.rs#L125))
 - `GetPlayerBuffApplications` answers 1 for a cleared record where the reference reads its stale `+0x9`, the previous occupant's count, because no guarded caller reaches it. ([`src/script/aura/player_buff.rs:98`](../crates/benilla-ui/src/script/aura/player_buff.rs#L98))
@@ -735,93 +735,93 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 - `pow(10, n)` is the platform's, where the reference's (`0x73f940`, `fyl2x`) rounds its extended-precision steps at 53 bits, so a power or a fraction term can differ in the last place. ([`src/script/binding_abi.rs:281`](../crates/benilla-ui/src/script/binding_abi.rs#L281))
 - The disabled-checked leg (`0x785380`) tests and reloads the checked slot (`[+0x4e0]`, `0x785388`/`0x7853a5`), a copy of the checked leg's (`0x785270`), so in 1.12.1 a check box with a checked texture repaints that one and never gets its disabled-checked texture from a path. benilla tests and reloads the slot the method names. ([`src/script/button.rs:621`](../crates/benilla-ui/src/script/button.rs#L621))
 - The slot is read before the handler, where the reference reads it after (`[esi+0x4dc]`), because reading first keeps the borrow simple and no stock handler re-slots its row. ([`src/script/button.rs:1213`](../crates/benilla-ui/src/script/button.rs#L1213))
-- The reference's only bound is `luaD_call`'s count of 200 nested calls (`0x6f65ae`), past which it raises `C stack overflow` (`0x6f65bf`); eight here, as each level keeps an apply's frame on the Rust stack. ([`src/script/calls.rs:731`](../crates/benilla-ui/src/script/calls.rs#L731))
+- The reference's only bound is `luaD_call`'s count of 200 nested calls (`0x6f65ae`), past which it raises `C stack overflow` (`0x6f65bf`); eight here, because each level keeps an apply's frame on the Rust stack. ([`src/script/calls.rs:731`](../crates/benilla-ui/src/script/calls.rs#L731))
 - The reference composes the Shortcut with `GetRealZoneText` alone (`0x49efe8`), so in a capital `/leave Trade` sends `Trade - Stormwind City` and leaves nothing; ours uses the join's city-aware name, because the reference's form cannot leave the channel it joined. ([`src/script/channel.rs:535`](../crates/benilla-ui/src/script/channel.rs#L535))
-- The frame's bottom-left origin is snapped onto the device grid so the border art blits 1:1; the reference ceils the anchor point itself onto it (`0x7666a0`, `0x766750`). ([`src/script/chat_bubble.rs:482`](../crates/benilla-ui/src/script/chat_bubble.rs#L482))
+- The frame's bottom-left origin is snapped onto the device grid because that way the border art blits 1:1; the reference ceils the anchor point itself onto it (`0x7666a0`, `0x766750`). ([`src/script/chat_bubble.rs:482`](../crates/benilla-ui/src/script/chat_bubble.rs#L482))
 - No truncation at 255 characters (`0x49f604`), because vmangos refuses a longer line itself (`Chat.cpp:2177`): it is dropped where the reference sends its first 255. ([`src/script/chat_send.rs:26`](../crates/benilla-ui/src/script/chat_send.rs#L26))
 - A value outside 0..1 clamps, where the reference keeps the low byte (alpha 2.0 stores 254, -1.0 stores 1), because no FrameXML or addon caller passes one. ([`src/script/chat_window.rs:17`](../crates/benilla-ui/src/script/chat_window.rs#L17))
 - An id outside the seven built windows raises, where the reference serves ten records and silently ignores any other id (`0x4a0be1`), because benilla keeps only the seven and every caller loops `1, NUM_CHAT_WINDOWS`. ([`src/script/chat_window.rs:221`](../crates/benilla-ui/src/script/chat_window.rs#L221))
 - One past `i32::MAX` clamps where the reference keeps the low 32 bits, for the colours' reason. ([`src/script/chat_window.rs:481`](../crates/benilla-ui/src/script/chat_window.rs#L481))
-- The reference reads the clock live at each call (`0x42c010`); ours is the session clock the tick advances by the paced frame step, one value per frame, so `GetTime()` deltas and the `elapsed` handed to OnUpdate agree, as FrameXML (CastingBarFrame and kin) assumes. ([`src/script/clock.rs:64`](../crates/benilla-ui/src/script/clock.rs#L64))
+- The reference reads the clock live at each call (`0x42c010`); ours is the session clock the tick advances by the paced frame step, one value per frame, because that way `GetTime()` deltas and the `elapsed` handed to OnUpdate agree, as FrameXML (CastingBarFrame and kin) assumes. ([`src/script/clock.rs:64`](../crates/benilla-ui/src/script/clock.rs#L64))
 - With no wheel it scales by the strip's, because the reference reads the missing wheel unguarded. ([`src/script/colorselect.rs:379`](../crates/benilla-ui/src/script/colorselect.rs#L379))
 - The reference's `set` registers an unknown name as a new category-5 record (`0x63d569`-`0x63d582`); benilla refuses it, because nothing would read the row and `config.toml` keeps an unknown key anyway. ([`src/script/console_exec.rs:120`](../crates/benilla-ui/src/script/console_exec.rs#L120))
 - A row the session owns (an env lever) is passed, because the env chose its value for this run and the file never holds it, so a reset would undo the lever and save nothing. ([`src/script/console_exec.rs:204`](../crates/benilla-ui/src/script/console_exec.rs#L204))
-- A row index the list no longer holds buys nothing and drops, where this path reads through a null row (`0x4f9f35`). ([`src/script/container.rs:753`](../crates/benilla-ui/src/script/container.rs#L753))
+- A row index the list no longer holds buys nothing and drops, because this path reads through a null row in the reference (`0x4f9f35`). ([`src/script/container.rs:753`](../crates/benilla-ui/src/script/container.rs#L753))
 - A last `spell_id` key breaks the remaining ties (Charge's six ranks all have `spellLevel` 0), because the reference leaves them to its qsort over an array benilla does not reproduce; ascending id is ascending rank in every 1.12 pet-ability family. ([`src/script/craft.rs:255`](../crates/benilla-ui/src/script/craft.rs#L255))
-- The reference reads past the table unbounded (`0x4f6c90`), so type 5 would answer "CloseCraft"; no shipped opener carries a type past 3, and benilla answers nil rather than read past it. ([`src/script/craft.rs:926`](../crates/benilla-ui/src/script/craft.rs#L926))
+- Benilla answers nil rather than read past the table, because the reference reads past it unbounded (`0x4f6c90`), so type 5 would answer "CloseCraft"; no shipped opener carries a type past 3. ([`src/script/craft.rs:926`](../crates/benilla-ui/src/script/craft.rs#L926))
 - On `Terrain` the reference keeps a spell, action, macro or pet action on the left button; we clear them, because otherwise a spell has no left-click way off the cursor. ([`src/script/cursor.rs:744`](../crates/benilla-ui/src/script/cursor.rs#L744))
-- Every lock lifts here, bag contents included. The reference's walk of a bag's contents indexes the bag by its own player-array index (`0x495528`, `0x495535`), at least 19, past a bag's slots in every case but the biggest bags, so it normally unlocks none of them; a lock it strands lasts until the item's seat or stack moves, which this does not copy. ([`src/script/cursor.rs:950`](../crates/benilla-ui/src/script/cursor.rs#L950))
-- Returns nothing. The handler ends `mov eax,1` with nothing pushed (`0x4895bc`), so Lua 5.0 hands back the stack top, the last argument or the function itself: an accident of the handler, not an API, and copying a stack-top leak would copy a bug. ([`src/script/cursor.rs:1254`](../crates/benilla-ui/src/script/cursor.rs#L1254))
+- Every lock lifts here, bag contents included, because the reference's walk of a bag's contents indexes the bag by its own player-array index (`0x495528`, `0x495535`), at least 19, past a bag's slots in every case but the biggest bags, so it normally unlocks none of them; a lock it strands lasts until the item's seat or stack moves, which this does not copy. ([`src/script/cursor.rs:950`](../crates/benilla-ui/src/script/cursor.rs#L950))
+- Returns nothing because the handler ends `mov eax,1` with nothing pushed (`0x4895bc`), so Lua 5.0 hands back the stack top, the last argument or the function itself: an accident of the handler, not an API, and copying a stack-top leak would copy a bug. ([`src/script/cursor.rs:1254`](../crates/benilla-ui/src/script/cursor.rs#L1254))
 - An auto-store into a bank item or keyring slot sends nothing, because no container id names it and no stock caller passes one; the reference sends it and the server refuses. ([`src/script/cursor/bag_verbs.rs:26`](../crates/benilla-ui/src/script/cursor/bag_verbs.rs#L26))
-- A row index the list no longer holds buys nothing and drops, where this site reads through a null row (`0x4c7e9a`, `0x4c7ea5`). ([`src/script/cursor/bag_verbs.rs:132`](../crates/benilla-ui/src/script/cursor/bag_verbs.rs#L132))
+- A row index the list no longer holds buys nothing and drops, because this site reads through a null row in the reference (`0x4c7e9a`, `0x4c7ea5`). ([`src/script/cursor/bag_verbs.rs:132`](../crates/benilla-ui/src/script/cursor/bag_verbs.rs#L132))
 - Slot 11 is refused, because the reference's gate (`cmp esi,0xa; jbe`) admits it; `0x4bce00` checks its bound (`0x4bce14`) but `0x4bc9a0` does not, so it writes one dword past the array (`0x4bcad9`), and the autocast toggle (`0x4bcbb0`) reads that word (`[0xb71438+0x28]`) with no bounds check. ([`src/script/cursor/pet.rs:20`](../crates/benilla-ui/src/script/cursor/pet.rs#L20))
 - The list is the window sizes this client can present, not the device's display modes, because benilla makes no exclusive mode-set. `"WxH"` is a contract: `OptionsFrame.lua:281-284` splits on the `x`, raising on a string without one, and `CT_Viewport.lua:107` matches `"(%d+)x(%d+)"`, failing silently. ([`src/script/cvars.rs:81`](../crates/benilla-ui/src/script/cvars.rs#L81))
 - The tie-break is ours, because area alone with the reference's adjacent-only dedupe can leave a duplicate `"WxH"` when two modes share an area (1280x960, 1600x768). ([`src/script/cvars.rs:94`](../crates/benilla-ui/src/script/cvars.rs#L94))
 - An id out of range is ignored, because the reference reads one entry past the last (`0x48c67c`) and a clamp would apply a format the player did not pick. ([`src/script/cvars.rs:779`](../crates/benilla-ui/src/script/cvars.rs#L779))
-- The reference (`0x48dad0` into `0x639a20`) writes hardware-recommended values from its matched `VideoHardware.dbc` row and the `CGxFormat` preset it names (`[0xc4e6ac]`): twelve `gx*` CVars, a synchronous `RestartGx`, then sixteen more. benilla has no such matching, so its registered defaults are its recommended configuration. ([`src/script/cvars.rs:895`](../crates/benilla-ui/src/script/cvars.rs#L895))
+- The reference (`0x48dad0` into `0x639a20`) writes hardware-recommended values from its matched `VideoHardware.dbc` row and the `CGxFormat` preset it names (`[0xc4e6ac]`): twelve `gx*` CVars, a synchronous `RestartGx`, then sixteen more. its registered defaults are its recommended configuration because benilla has no such matching. ([`src/script/cvars.rs:895`](../crates/benilla-ui/src/script/cvars.rs#L895))
 - The index is of the live window size, not of the `gxResolution` CVar the reference parses (`0x48bf20`), because the window here can be dragged to any size, where the reference's backbuffer stays at `gxResolution`'s, and `CT_Viewport` scales by the live one. ([`src/script/cvars.rs:948`](../crates/benilla-ui/src/script/cvars.rs#L948))
 - 0, a negative or an index past the count clamps to the nearer end, because the reference reads one element past the last there (`0x48c00d`), uninitialised memory. ([`src/script/cvars.rs:966`](../crates/benilla-ui/src/script/cvars.rs#L966))
 - Always empty, because a refresh rate is only selectable through an exclusive mode-set and benilla has none. ([`src/script/cvars.rs:1010`](../crates/benilla-ui/src/script/cvars.rs#L1010))
 - 1.12 has no such CVar; it exists because our Graphics page needs somewhere to keep the stop, and takes the API's name. ([`src/script/cvars.rs:1118`](../crates/benilla-ui/src/script/cvars.rs#L1118))
 - The getter reads `CVAR_WORLD_DETAIL`, where the reference's reads only `smallCull` (`0x488d77`), because benilla's stop follows the knob that draws: a console `frillDensity` write moves the ground clutter and `WorldDetail` with it, and no renderer reads `smallCull` (its callback's `[0x868620]` has no reader). ([`src/script/cvars.rs:1146`](../crates/benilla-ui/src/script/cvars.rs#L1146))
 - The minutes come from the server's table, not from spell 15007's `Spell.dbc` duration, because the aura the server applies is what the dialog must warn about. ([`src/script/death.rs:45`](../crates/benilla-ui/src/script/death.rs#L45))
-- The promotion's IME legs (`0x77d417`–`0x77d431`) and the IME writer's `or 6` (`0x77acde`, in `0x77ac60`) are not modelled: benilla has no IME composition. ([`src/script/editbox/flush.rs:28`](../crates/benilla-ui/src/script/editbox/flush.rs#L28))
+- The promotion's IME legs (`0x77d417`–`0x77d431`) and the IME writer's `or 6` (`0x77acde`, in `0x77ac60`) are not modelled because benilla has no IME composition. ([`src/script/editbox/flush.rs:28`](../crates/benilla-ui/src/script/editbox/flush.rs#L28))
 - The nameplate glow is shown but never drawn, because its additive rim reads as hard edge lines in our linear-blending pipeline; the lit plate brightens its bar instead. ([`src/script/extract.rs:223`](../crates/benilla-ui/src/script/extract.rs#L223))
-- A host of 0x80 bytes or more is refused. The reference copies the host into a 0x80-byte buffer (`0x5abc7c`-`0x5abc9c`) and writes its terminator one byte past the end, and the cut host could end in a whitelisted suffix the real one does not; this takes the safe side. ([`src/script/glue_core.rs:424`](../crates/benilla-ui/src/script/glue_core.rs#L424))
+- A host of 0x80 bytes or more is refused because the reference copies the host into a 0x80-byte buffer (`0x5abc7c`-`0x5abc9c`) and writes its terminator one byte past the end, and the cut host could end in a whitelisted suffix the real one does not; this takes the safe side. ([`src/script/glue_core.rs:424`](../crates/benilla-ui/src/script/glue_core.rs#L424))
 - Benilla keeps that decode and then encodes it again, every byte outside the URL characters `URL_SAFE` as `%XY` (a decoded `%` too), because the opener on some platforms is a shell script (`xdg-open`) or takes the raw command tail (`rundll32`) and the string comes off the wire: no space, quote, backtick, `$`, `;`, `<`, `>`, `|`, `^`, `\`, brace or control byte reaches it. ([`src/script/glue_core.rs:469`](../crates/benilla-ui/src/script/glue_core.rs#L469))
 - Past `NAME_TRIES` names the answer is nil, where the reference keeps trying, forever when the generator has learned nothing. ([`src/script/glue_create.rs:968`](../crates/benilla-ui/src/script/glue_create.rs#L968))
-- With no Region rows the reference reads a NULL category (`0x46e5b8`, `0x46f26a`) and faults; benilla lists every realm under one category, so a client whose `Wow.ini` names another Region still reaches a realm. ([`src/script/glue_realm.rs:195`](../crates/benilla-ui/src/script/glue_realm.rs#L195))
+- With no Region rows the reference reads a NULL category (`0x46e5b8`, `0x46f26a`) and faults; benilla lists every realm under one category, because that way a client whose `Wow.ini` names another Region still reaches a realm. ([`src/script/glue_realm.rs:195`](../crates/benilla-ui/src/script/glue_realm.rs#L195))
 - Equal nonzero counts tie here, where the reference answers +1 both ways (its name tie-break at `0x46e841` is clobbered by `0x46e846`), because a comparator that is not a total order has no defined sort. ([`src/script/glue_realm.rs:260`](../crates/benilla-ui/src/script/glue_realm.rs#L260))
-- The backpack, the bank and the keyring are each bounded by their own slots, where `0x4f990f` bounds them only by the player list's count (0x71) from their bases (the bank at `+0x27`, `0x4f98ae`; the keyring at `+0x51`, `0x4f98c0`), a reference bug that lets their index read the next container's slots. ([`src/script/held.rs:74`](../crates/benilla-ui/src/script/held.rs#L74))
-- A span count that no longer matches the live set always rebuilds, so a state this model does not flag (a ring wiped by `SetMaxLines`, a hidden frame, a frame not yet laid out, which the reference's rebuild skips at `0x78af7b`) leaves no stale button. ([`src/script/hyperlink.rs:167`](../crates/benilla-ui/src/script/hyperlink.rs#L167))
+- The backpack, the bank and the keyring are each bounded by their own slots, because `0x4f990f` bounds them only by the player list's count (0x71) from their bases (the bank at `+0x27`, `0x4f98ae`; the keyring at `+0x51`, `0x4f98c0`), a reference bug that lets their index read the next container's slots. ([`src/script/held.rs:74`](../crates/benilla-ui/src/script/held.rs#L74))
+- A span count that no longer matches the live set always rebuilds, because that way a state this model does not flag (a ring wiped by `SetMaxLines`, a hidden frame, a frame not yet laid out, which the reference's rebuild skips at `0x78af7b`) leaves no stale button. ([`src/script/hyperlink.rs:167`](../crates/benilla-ui/src/script/hyperlink.rs#L167))
 - `IsInInstance()` then answers `nil, "none"`, because the reference returns two results without pushing either (`0x48a7a9`), a stack bug. ([`src/script/instance.rs:24`](../crates/benilla-ui/src/script/instance.rs#L24))
-- Bounds-checked where the reference indexes unguarded, so none reads past it. ([`src/script/item_stats.rs:660`](../crates/benilla-ui/src/script/item_stats.rs#L660))
-- Nil for a display row with no icon, where the reference answers the unloadable `Interface\Icons\`, on which `SetTexture` keeps the previous image (`0x7702ac`), so a reused button would show its old icon. ([`src/script/item_stats.rs:812`](../crates/benilla-ui/src/script/item_stats.rs#L812))
-- A key rebound to the command it already has keeps a duplicate index in 1.12.1 (`0x4b7786` lowers the other keys' indices before `0x4b77ac` returns on the same name), so both getters there answer one key too few; that client fault is not reproduced. ([`src/script/keybind.rs:223`](../crates/benilla-ui/src/script/keybind.rs#L223))
-- An addon file whose first binding has no header opens a `HEADER_<addon>` row, where the reference files those rows under the previous file's last header, because under a foreign header the player could not find them. ([`src/script/keybind.rs:324`](../crates/benilla-ui/src/script/keybind.rs#L324))
-- The handle's value is the address of a `CGxTex` (`SMemAlloc(0x54)`, `0x594a96`), which benilla cannot reproduce; each texture ranks instead by a creation stamp, one global sequence number taken when its cache key is first created and taken anew once its last region has let go of it (`super::texel::Texels`). ([`src/script/layer_batch.rs:9`](../crates/benilla-ui/src/script/layer_batch.rs#L9))
-- The reference's byte copy can end inside a character and keep the stray bytes; a `String` must stay UTF-8, so the cut stops at the character boundary. ([`src/script/macros.rs:127`](../crates/benilla-ui/src/script/macros.rs#L127))
-- A listing that finds no icon stays empty, to be listed again on the next ask, where the reference's dedup then reads below its null list (`0x4f0134`-`0x4f0145`) and faults. ([`src/script/macros.rs:551`](../crates/benilla-ui/src/script/macros.rs#L551))
+- Bounds-checked where the reference indexes unguarded, because that way none reads past it. ([`src/script/item_stats.rs:660`](../crates/benilla-ui/src/script/item_stats.rs#L660))
+- Nil for a display row with no icon, because the reference answers the unloadable `Interface\Icons\`, on which `SetTexture` keeps the previous image (`0x7702ac`), so a reused button would show its old icon. ([`src/script/item_stats.rs:813`](../crates/benilla-ui/src/script/item_stats.rs#L813))
+- A key rebound to the command it already has keeps a duplicate index in 1.12.1 (`0x4b7786` lowers the other keys' indices before `0x4b77ac` returns on the same name), so both getters there answer one key too few; it is not reproduced because it is a client fault. ([`src/script/keybind.rs:223`](../crates/benilla-ui/src/script/keybind.rs#L223))
+- An addon file whose first binding has no header opens a `HEADER_<addon>` row, where the reference files those rows under the previous file's last header, because under a foreign header the player could not find them. ([`src/script/keybind.rs:325`](../crates/benilla-ui/src/script/keybind.rs#L325))
+- Each texture ranks by a creation stamp, not by the handle's value, because the handle's value is the address of a `CGxTex` (`SMemAlloc(0x54)`, `0x594a96`), which benilla cannot reproduce. ([`src/script/layer_batch.rs:9`](../crates/benilla-ui/src/script/layer_batch.rs#L9))
+- The reference's byte copy can end inside a character and keep the stray bytes; here the cut stops at the character boundary because a `String` must stay UTF-8. ([`src/script/macros.rs:127`](../crates/benilla-ui/src/script/macros.rs#L127))
+- A listing that finds no icon stays empty, to be listed again on the next ask, because the reference's dedup then reads below its null list (`0x4f0134`-`0x4f0145`) and faults. ([`src/script/macros.rs:551`](../crates/benilla-ui/src/script/macros.rs#L551))
 - Each line is trimmed, because the reference sends an indented `" /say hi"` as plain chat, never as the command meant. ([`src/script/macros/bind.rs:30`](../crates/benilla-ui/src/script/macros/bind.rs#L30))
 - The `/cast` argument is trimmed, because the reference binds `/cast  Fireball` (two spaces) to a name that never resolves. ([`src/script/macros/bind.rs:50`](../crates/benilla-ui/src/script/macros/bind.rs#L50))
-- The client's Lua has no such bound, as nothing sets a hook (`lua_sethook`, `0x6fba40`, has no caller and no pointer to it), so a load that never ends hangs it. ([`src/script/mod.rs:953`](../crates/benilla-ui/src/script/mod.rs#L953))
-- The reference sets the cells only when glue or the interface is built, `0x41ad10` from `0x46a828` (`0x46a7b0`) and `0x48fe2b` (`0x48fbf0`), and a resize reaches them only through the rebuild it asks for. ([`src/script/mod.rs:1041`](../crates/benilla-ui/src/script/mod.rs#L1041))
+- The client's Lua has no such bound, as nothing sets a hook (`lua_sethook`, `0x6fba40`, has no caller and no pointer to it), so a load that never ends hangs it; benilla bounds it because a hung load would otherwise freeze the loading screen instead of reporting. ([`src/script/mod.rs:953`](../crates/benilla-ui/src/script/mod.rs#L953))
+- The reference sets the cells only when glue or the interface is built, `0x41ad10` from `0x46a828` (`0x46a7b0`) and `0x48fe2b` (`0x48fbf0`), and a resize reaches them only through the rebuild it asks for. ([`src/script/mod.rs:1042`](../crates/benilla-ui/src/script/mod.rs#L1042))
 - A path that does not resolve is stored, where the reference raises `Invalid model file: %s` (`0x878b44`), because the file loads asynchronously here and the call cannot know yet. ([`src/script/modelframe.rs:333`](../crates/benilla-ui/src/script/modelframe.rs#L333))
 - The reference's free list is FIFO (`0x6087f0`, `0x608a5a`); either keeps every index stable, all an addon can observe of the pool's order. ([`src/script/nameplate.rs:807`](../crates/benilla-ui/src/script/nameplate.rs#L807))
 - The reference adds this rim over the bar; we brighten the bar (`LIT_BOOST`), because the rim reads as hard edge lines in our linear-blending pipeline. ([`src/script/nameplate.rs:1430`](../crates/benilla-ui/src/script/nameplate.rs#L1430))
 - A wrapper that decodes to no live widget takes `default_parent`, because the reference, with no `IsA` check, reads a wild pointer. ([`src/script/object/anchor_args.rs:218`](../crates/benilla-ui/src/script/object/anchor_args.rs#L218))
 - An `OnSizeChanged` that resolve produces fires at the next `UiScript::resolve`, because a Lua handler must not run in the middle of a level compaction. ([`src/script/object/toplevel.rs:77`](../crates/benilla-ui/src/script/object/toplevel.rs#L77))
 - A third `%s` gets an empty string, because the reference pushes two varargs (`0x6093f2 add esp,0x14`) and would read uninitialised stack. ([`src/script/pvp/mod.rs:319`](../crates/benilla-ui/src/script/pvp/mod.rs#L319))
-- A token resolving to guid 0 answers nil too. The reference jumps from the guid test (`0x5172f6`) to `return 1` (`0x517343`) with nothing pushed, so the one value is its top argument, the token it read (`0x5172e6`); that is a stack quirk, not an answer. ([`src/script/pvp/mod.rs:568`](../crates/benilla-ui/src/script/pvp/mod.rs#L568))
+- A token resolving to guid 0 answers nil too because the reference jumps from the guid test (`0x5172f6`) to `return 1` (`0x517343`) with nothing pushed, so the one value is its top argument, the token it read (`0x5172e6`); that is a stack quirk, not an answer. ([`src/script/pvp/mod.rs:568`](../crates/benilla-ui/src/script/pvp/mod.rs#L568))
 - With `UNIT_PVP_NAME` or the title missing from `_G` (no install) this answers the plain name, where the reference would format an empty string, because the decoration is install data. ([`src/script/pvp/mod.rs:572`](../crates/benilla-ui/src/script/pvp/mod.rs#L572))
 - An in-flight name reads `...`, where the reference's reads `" "` (`0x82ee00`), because a blank looks like a nameless objective. ([`src/script/quest_log.rs:54`](../crates/benilla-ui/src/script/quest_log.rs#L54))
 - One signal per missed record, where the reference runs every callback of every miss as its record lands (items at `0x55bea8` and `0x55bf39` in `0x55bdb0`, from `0x555140`; `0x4e083a`), 2^k - 1 updates for a walking handler over k first-seen records. ([`src/script/quest_log.rs:1211`](../crates/benilla-ui/src/script/quest_log.rs#L1211))
 - A local clock step mid-session (an NTP correction) jumps the reference's countdown but not ours, because the step changes no time the quest has left. ([`src/script/quest_log.rs:1281`](../crates/benilla-ui/src/script/quest_log.rs#L1281))
-- Four set ids count 4, where the loop's exit `jmp 0x4e0a4c` (`0x4e0a42`) skips the store at `0x4e0a49` and answers 0, a client bug. ([`src/script/quest_log.rs:1653`](../crates/benilla-ui/src/script/quest_log.rs#L1653))
+- Four set ids count 4, because the loop's exit `jmp 0x4e0a4c` (`0x4e0a42`) skips the store at `0x4e0a49` and answers 0, a client bug. ([`src/script/quest_log.rs:1653`](../crates/benilla-ui/src/script/quest_log.rs#L1653))
 - The reference bounds the index with `jbe` against the entry count (`0xb73760`), so an index one past the last entry reads the pool entry after it, which only an earlier, longer list wrote, or uninitialised heap (`0x4d5310`, the rebuild resetting the count without clearing, `0x4d547f`); that stale read answers 0 here, as an index further on does. ([`src/script/reputation.rs:563`](../crates/benilla-ui/src/script/reputation.rs#L563))
-- The folds are keyed by header, not by the reference's mask positions, whose rebuild folds bit N-1 by registration index before the sort (`0x4d5d49`-`0x4d5d68`) and whose fold verbs search `0xb736c0` before `0x4d5c40` sorts it (`0x4d6400`), so Inactive opens at login whenever a childless header exists and inactivating a header's last child shows it expanded; that is a reference bug, and the folds follow the header the player clicked. ([`src/script/reputation.rs:631`](../crates/benilla-ui/src/script/reputation.rs#L631))
-- Nesting stops at 32 where the reference recurses uncapped (its indent saturates at `0x80`), so a hostile structure cannot exhaust the stack. ([`src/script/saved.rs:21`](../crates/benilla-ui/src/script/saved.rs#L21))
-- The reference rewrites it from the live defaults (`0x51f865`–`0x51f970`) after renaming the old file to `.bak` (`0x51f794`, `0x51f8eb`, `.bak` at `0x8431e4`), so a hand edit with one typo survives only until the next logout. ([`src/script/saved.rs:27`](../crates/benilla-ui/src/script/saved.rs#L27))
-- The writer's escapes are undone (`unescape`), where the reference sets the bytes between the quotes raw, so a string holding a quote or a backslash would grow every session. ([`src/script/saved.rs:197`](../crates/benilla-ui/src/script/saved.rs#L197))
+- The folds are keyed by header, not by the reference's mask positions, because their rebuild folds bit N-1 by registration index before the sort (`0x4d5d49`-`0x4d5d68`) and their fold verbs search `0xb736c0` before `0x4d5c40` sorts it (`0x4d6400`), so Inactive opens at login whenever a childless header exists and inactivating a header's last child shows it expanded; that is a reference bug, and the folds follow the header the player clicked. ([`src/script/reputation.rs:631`](../crates/benilla-ui/src/script/reputation.rs#L631))
+- Nesting stops at 32 where the reference recurses uncapped (its indent saturates at `0x80`), because that way a hostile structure cannot exhaust the stack. ([`src/script/saved.rs:21`](../crates/benilla-ui/src/script/saved.rs#L21))
+- The reference rewrites it from the live defaults (`0x51f865`–`0x51f970`) after renaming the old file to `.bak` (`0x51f794`, `0x51f8eb`, `.bak` at `0x8431e4`), so a hand edit with one typo survives only until the next logout; benilla holds the file instead, because that way the shutdown write leaves it alone. ([`src/script/saved.rs:27`](../crates/benilla-ui/src/script/saved.rs#L27))
+- The writer's escapes are undone (`unescape`), because the reference sets the bytes between the quotes raw, so a string holding a quote or a backslash would grow every session. ([`src/script/saved.rs:198`](../crates/benilla-ui/src/script/saved.rs#L198))
 - The block step is not pixel-snapped (`0x766750`), because layout here is in logical units; the two differ by under a pixel, and not at all at the default spacing of 0. ([`src/script/simplehtml/mod.rs:13`](../crates/benilla-ui/src/script/simplehtml/mod.rs#L13))
 - A block of width 0, in a frame sized by anchors, gets its text's natural width where the reference keeps 0, because every width-less FontString here does. ([`src/script/simplehtml/mod.rs:15`](../crates/benilla-ui/src/script/simplehtml/mod.rs#L15))
 - The reference prints these to the console; here they are host warnings, because a malformed page is bad content, not a script error. ([`src/script/simplehtml/mod.rs:105`](../crates/benilla-ui/src/script/simplehtml/mod.rs#L105))
 - Only `%s` and `%%` are expanded and other specs copied, because the real `printf` would read the string pointers as other types. ([`src/script/simplehtml/parse.rs:247`](../crates/benilla-ui/src/script/simplehtml/parse.rs#L247))
 - Skipped as no command. The stock walk calls an entry only when one of its aliases matches (`ChatFrame.lua:2164-2178`), so only a matched one raises. ([`src/script/slash.rs:71`](../crates/benilla-ui/src/script/slash.rs#L71))
 - The app plays the queued file after the call, so the refusals (the bus-3 cap, a muted SFX channel, a missing file) come too late to answer, and a queued file answers 1. ([`src/script/sound.rs:68`](../crates/benilla-ui/src/script/sound.rs#L68))
-- `BOOKTYPE_SPELL`/`BOOKTYPE_PET` are engine globals here, where the reference defines them in `SpellBookFrame.lua:5-6`, so this module's tests run without the stock file. ([`src/script/spellbook.rs:10`](../crates/benilla-ui/src/script/spellbook.rs#L10))
-- Ours answers milliseconds, since a cycle count of unknown rate is no use to an addon timing its code. ([`src/script/stdlib.rs:101`](../crates/benilla-ui/src/script/stdlib.rs#L101))
-- A format that ends in `%` reads past its terminator in the client (`0x4135c3`), into whatever memory follows the string; here the output ends there. ([`src/script/stdlib.rs:637`](../crates/benilla-ui/src/script/stdlib.rs#L637))
-- With `#` and one byte of room, `_store_number` writes no digit and its reversal swaps before it tests (`0x413ab3`), trading the last byte written for the stale byte after it in the caller's buffer, which then ends the client's answer; here the output is kept. ([`src/script/stdlib.rs:688`](../crates/benilla-ui/src/script/stdlib.rs#L688))
+- `BOOKTYPE_SPELL`/`BOOKTYPE_PET` are engine globals here, where the reference defines them in `SpellBookFrame.lua:5-6`, because that way this module's tests run without the stock file. ([`src/script/spellbook.rs:10`](../crates/benilla-ui/src/script/spellbook.rs#L10))
+- Ours answers milliseconds, because a cycle count of unknown rate is no use to an addon timing its code. ([`src/script/stdlib.rs:101`](../crates/benilla-ui/src/script/stdlib.rs#L101))
+- A format that ends in `%` reads past its terminator in the client (`0x4135c3`), into whatever memory follows the string; here the output ends there. ([`src/script/stdlib.rs:638`](../crates/benilla-ui/src/script/stdlib.rs#L638))
+- With `#` and one byte of room, `_store_number` writes no digit and its reversal swaps before it tests (`0x413ab3`), trading the last byte written for the stale byte after it in the caller's buffer, which then ends the client's answer; here the output is kept. ([`src/script/stdlib.rs:689`](../crates/benilla-ui/src/script/stdlib.rs#L689))
 - The reference reads uninitialised fields before the seed; we answer the first legal design because that value is undefined. ([`src/script/tabard.rs:122`](../crates/benilla-ui/src/script/tabard.rs#L122))
-- Returns nothing. The handler ends `mov eax,1` with nothing pushed (`0x4dcd7c`), so Lua 5.0 hands back the stack top, the node argument: an accident of the handler, not an API, and copying a stack-top leak would copy a bug. ([`src/script/taxi.rs:235`](../crates/benilla-ui/src/script/taxi.rs#L235))
+- Returns nothing because the handler ends `mov eax,1` with nothing pushed (`0x4dcd7c`), so Lua 5.0 hands back the stack top, the node argument: an accident of the handler, not an API, and copying a stack-top leak would copy a bug. ([`src/script/taxi.rs:235`](../crates/benilla-ui/src/script/taxi.rs#L235))
 - `0x530a52` lays it out at once; getters resolve first, so only OnSizeChanged fires later. ([`src/script/tooltip/size.rs:180`](../crates/benilla-ui/src/script/tooltip/size.rs#L180))
-- The reference anchors a Font object through its +0x24 with no type test (`0x5313c9`), undefined; benilla raises the owner line. ([`src/script/tooltip/verbs.rs:51`](../crates/benilla-ui/src/script/tooltip/verbs.rs#L51))
+- The reference anchors a Font object through its +0x24 with no type test (`0x5313c9`); benilla raises the owner line because the result there is undefined. ([`src/script/tooltip/verbs.rs:51`](../crates/benilla-ui/src/script/tooltip/verbs.rs#L51))
 - No time line follows, where the reference's rides the record's `+0xc` (`0x532bdf`), a byte an empty record keeps from its history. 0 after `ClearBuffRecord 0x4e4490` prints a lone "0 seconds remaining" (`0x4e447e`); else it is whatever the last occupant left, as `ResetBuffCache 0x4e40c0` and the compaction's tail reset (`0x4e4237`) call `0x4e44b0` with slot -1, which writes `+0x0` and `+0x4` alone (`0x4e44bc`-`0x4e44c0`). ([`src/script/tooltip_aura.rs:238`](../crates/benilla-ui/src/script/tooltip_aura.rs#L238))
 - The reference's builder hides and clears on a missing record (`0x52b72e`..`0x52b73f`), where a source that knows the item's name shows that, because a blank plate under an on-screen name reads as broken; the template's arrival then builds it whole. ([`src/script/tooltip_item/build.rs:56`](../crates/benilla-ui/src/script/tooltip_item/build.rs#L56))
-- An object no longer held rebuilds from the instance the build read, where the reference's lookup finds no object and builds from the record and the block alone; benilla's views carry no object to read once it is gone, and the kept instance is what the plate showed. ([`src/script/tooltip_item/build.rs:203`](../crates/benilla-ui/src/script/tooltip_item/build.rs#L203))
-- The reference recurses without a bound (`0x52dbce` builds the product whatever the depth), so a product that teaches a recipe for itself would recurse until the stack overflows; benilla stops here, so a cyclic `Spell.dbc` chain cannot crash the client. ([`src/script/tooltip_item/render.rs:199`](../crates/benilla-ui/src/script/tooltip_item/render.rs#L199))
-- The reference's padding repeats a mana stat once per zero entry; not emulated, since only the internal test ring 6674 has one. ([`src/script/tooltip_item/render.rs:574`](../crates/benilla-ui/src/script/tooltip_item/render.rs#L574))
+- An object no longer held rebuilds from the instance the build read, where the reference's lookup finds no object and builds from the record and the block alone; benilla rebuilds from the kept instance because its views carry no object to read once it is gone, and the kept instance is what the plate showed. ([`src/script/tooltip_item/build.rs:203`](../crates/benilla-ui/src/script/tooltip_item/build.rs#L203))
+- The reference recurses without a bound (`0x52dbce` builds the product whatever the depth), so a product that teaches a recipe for itself would recurse until the stack overflows; benilla stops here because that way a cyclic `Spell.dbc` chain cannot crash the client. ([`src/script/tooltip_item/render.rs:199`](../crates/benilla-ui/src/script/tooltip_item/render.rs#L199))
+- The reference's padding repeats a mana stat once per zero entry; not emulated, because only the internal test ring 6674 has one. ([`src/script/tooltip_item/render.rs:574`](../crates/benilla-ui/src/script/tooltip_item/render.rs#L574))
 - The unknown-skill "Requires %s" shares it, though its reference red is `0xffff0000`, because a 32/255 difference in G and B does not show. ([`src/script/tooltip_unit.rs:135`](../crates/benilla-ui/src/script/tooltip_unit.rs#L135))
 - The selection clears to 0, because the header the reference re-selects (`0x4d7b42`, reading 1) has no spell id; the stock window's `> 1` test treats 0 and 1 alike. ([`src/script/trainer/mod.rs:332`](../crates/benilla-ui/src/script/trainer/mod.rs#L332))
 - A header clears it too, because it has no spell id; the reference stores its `0xffffffff` (`0x4d7b05`) and reads back 1, which the stock window's `> 1` test treats the same as 0. ([`src/script/trainer/mod.rs:1310`](../crates/benilla-ui/src/script/trainer/mod.rs#L1310))
@@ -829,9 +829,9 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 - Kept apart from `Self::vertex_color`, which the reference's `Texture:SetAlpha` (`0x79b580`) rewrites, because where stock sets both on one region (`PlayerFrame.lua:25-26`, `TargetFrame.lua:408` with `420-426`) the drawn product differs for about one frame, and a FontString's `SetAlpha` then keeps its font colour. ([`src/script/types.rs:428`](../crates/benilla-ui/src/script/types.rs#L428))
 - Among whole-name matches ours picks the nearest, because the reference's first-walked pick is order-dependent and reads as a bug. ([`src/script/unit/bindings.rs:1077`](../crates/benilla-ui/src/script/unit/bindings.rs#L1077))
 - The reference's matcher takes a whole-string hit at once only when it is nearer than the best so far (`0x493c88`-`0x493ca2`); an exact hit that is not nearer competes on prefix length alone (`0x493cf8`-`0x493d09`), so a nearer "Bobby" walked first beats an exact "Bob", and the pick follows the object list's order. ([`src/script/unit/by_name.rs:19`](../crates/benilla-ui/src/script/unit/by_name.rs#L19))
-- A full tie goes to the lower guid, where the reference keeps the first unit its walk (`0x493aa0`) reaches, an order neither of ours has; a guid keeps the two picks equal. ([`src/script/unit/by_name.rs:61`](../crates/benilla-ui/src/script/unit/by_name.rs#L61))
-- `0x4e81d0` has no bound and reads past its four-entry table, which is stale memory, not a mechanism; past it, nobody. ([`src/script/unit/resolve.rs:85`](../crates/benilla-ui/src/script/unit/resolve.rs#L85))
-- The reference ties a miss against a hit (`0x5adab6`); no total order can, and `sort_by` may panic on one that is not, so the miss goes last. ([`src/script/who_sort.rs:159`](../crates/benilla-ui/src/script/who_sort.rs#L159))
+- A full tie goes to the lower guid, because the reference keeps the first unit its walk (`0x493aa0`) reaches, an order neither of ours has; a guid keeps the two picks equal. ([`src/script/unit/by_name.rs:61`](../crates/benilla-ui/src/script/unit/by_name.rs#L61))
+- `0x4e81d0` has no bound and reads past its four-entry table; past it, nobody, because what it reads there is stale memory, not a mechanism. ([`src/script/unit/resolve.rs:85`](../crates/benilla-ui/src/script/unit/resolve.rs#L85))
+- The reference ties a miss against a hit (`0x5adab6`); here the miss goes last because no total order can, and `sort_by` may panic on one that is not. ([`src/script/who_sort.rs:159`](../crates/benilla-ui/src/script/who_sort.rs#L159))
 - The engine's own push (the world-enter sync) queues `WORLD_MAP_UPDATE` for the next frame's tick and fires only on a change, where the reference fires in place from the handler that moved the data: the app's feeds run after the frame's tick. ([`src/script/worldmap.rs:15`](../crates/benilla-ui/src/script/worldmap.rs#L15))
 
 #### status
@@ -840,31 +840,31 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### strings
 
-- A pass that changes nothing (`|01`, `|02`) ends the scan, where the reference loops on it for ever. ([`src/strings.rs:46`](../crates/benilla-ui/src/strings.rs#L46))
+- A pass that changes nothing (`|01`, `|02`) ends the scan, because the reference loops on it for ever. ([`src/strings.rs:46`](../crates/benilla-ui/src/strings.rs#L46))
 
 #### widget
 
-- The history browses as a shell's does, a small everyday gain: the first UP stashes the line being typed and DOWN past the newest line brings it back, UP holds at the oldest, DOWN does nothing when not browsing, typing or a focus gain ends the browse, and an empty line is not kept. ([`src/widget/kinds/editbox.rs:247`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L247))
-- A plain Left or Right (or Ctrl+B or F) with a selection collapses it to that edge, as every OS's own text fields do; the reference clears the selection and steps once from the caret (`0x77c6b0` from `0x77c70b`). ([`src/widget/kinds/editbox.rs:818`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L818))
-- Left reads the whole character before the caret, not the lone byte `caret - 1` the client reads (`0x77c8da`), which takes a multi-byte space for a non-space. ([`src/widget/kinds/editbox.rs:837`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L837))
+- The history browses as a shell's does because it is a small everyday gain: the first UP stashes the line being typed and DOWN past the newest line brings it back, UP holds at the oldest, DOWN does nothing when not browsing, typing or a focus gain ends the browse, and an empty line is not kept. ([`src/widget/kinds/editbox.rs:247`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L247))
+- A plain Left or Right (or Ctrl+B or F) with a selection collapses it to that edge, because every OS's own text fields do; the reference clears the selection and steps once from the caret (`0x77c6b0` from `0x77c70b`). ([`src/widget/kinds/editbox.rs:818`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L818))
+- Left reads the whole character before the caret, not the lone byte `caret - 1` the client reads (`0x77c8da`), because that takes a multi-byte space for a non-space. ([`src/widget/kinds/editbox.rs:837`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L837))
 - On the last row a walk may end at the text's end, because the end starts no row; the reference steps back from it as from a row's start (its line table ends with the text's length, `0x77d6ef`), so DOWN onto a short last line stops before its last letter. ([`src/widget/kinds/editbox.rs:888`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L888))
-- The drag selects from its anchor, as every OS's own text fields do, where the reference's applies `0x77cd10` to each mouse move's whole delta (`0x77a8a1`). ([`src/widget/kinds/editbox.rs:1001`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L1001))
-- A code point past U+FFFF is no space, where the client tests its low 16 bits, so U+10020 counts as a space there. ([`src/widget/kinds/editbox.rs:1131`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L1131))
-- The cut backs up to a character start, where the reference cuts at the byte. ([`src/widget/kinds/messageframe.rs:120`](../crates/benilla-ui/src/widget/kinds/messageframe.rs#L120))
-- N of -2 or less is an empty line too, where the reference asks `SMemAlloc` for about 4 GB and fails. ([`src/widget/kinds/messageframe.rs:121`](../crates/benilla-ui/src/widget/kinds/messageframe.rs#L121))
-- An index past 5 reads the last entry, where 1.12.1 reads past both six-entry tables (`0x6da9d5`, `0x6da9c4`), a client fault a hand-edited CVar reaches. ([`src/widget/kinds/mod.rs:965`](../crates/benilla-ui/src/widget/kinds/mod.rs#L965))
-- `None` until then, not the ctor's 0, so that an unset row takes nothing rather than slot 0. ([`src/widget/kinds/mod.rs:1067`](../crates/benilla-ui/src/widget/kinds/mod.rs#L1067))
-- On the thumb it is the grabbed point, where `CSimpleSlider` (`0x789ba0`/`0x789ca0`) always centers it, because that feels less surprising and a stock-sized thumb hides the difference. ([`src/widget/kinds/mod.rs:1525`](../crates/benilla-ui/src/widget/kinds/mod.rs#L1525))
+- The drag selects from its anchor, because every OS's own text fields do, where the reference's applies `0x77cd10` to each mouse move's whole delta (`0x77a8a1`). ([`src/widget/kinds/editbox.rs:1001`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L1001))
+- A code point past U+FFFF is no space, because the client tests its low 16 bits, so U+10020 counts as a space there. ([`src/widget/kinds/editbox.rs:1131`](../crates/benilla-ui/src/widget/kinds/editbox.rs#L1131))
+- The cut backs up to a character start, where the reference cuts at the byte, because a Rust string holds whole characters. ([`src/widget/kinds/messageframe.rs:120`](../crates/benilla-ui/src/widget/kinds/messageframe.rs#L120))
+- N of -2 or less is an empty line too, because the reference asks `SMemAlloc` for about 4 GB and fails. ([`src/widget/kinds/messageframe.rs:122`](../crates/benilla-ui/src/widget/kinds/messageframe.rs#L122))
+- An index past 5 reads the last entry, because 1.12.1 reads past both six-entry tables (`0x6da9d5`, `0x6da9c4`), a client fault a hand-edited CVar reaches. ([`src/widget/kinds/mod.rs:965`](../crates/benilla-ui/src/widget/kinds/mod.rs#L965))
+- `None` until then, not the ctor's 0, because that way an unset row takes nothing rather than slot 0. ([`src/widget/kinds/mod.rs:1067`](../crates/benilla-ui/src/widget/kinds/mod.rs#L1067))
+- On the thumb it is the grabbed point, where `CSimpleSlider` (`0x789ba0`/`0x789ca0`) always centers it, because that feels less surprising and a stock-sized thumb hides the difference. ([`src/widget/kinds/mod.rs:1526`](../crates/benilla-ui/src/widget/kinds/mod.rs#L1526))
 - Levels pack contiguously, because the reference's resuming cursor (`0x764fd3`/`0x764fd8`) leaves a hole past a wide gap ({0, 4, 6} at bound 7 gives {0, 1, 3} at bound 4). ([`src/widget/propagation.rs:189`](../crates/benilla-ui/src/widget/propagation.rs#L189))
 - The frame is still in the old parent's child list during `OnHide`, unlike the reference (`0x76ab34` unlinks first), because a handler that itself reparents must not find the lists half-spliced. ([`src/widget/propagation.rs:312`](../crates/benilla-ui/src/widget/propagation.rs#L312))
 ### benilla-world
 
 #### clouds
 
-- The reference starts this buffer at 0xFFFFFFFF; alpha 0 keeps a dome drawn before the first build from flashing white. ([`src/clouds/kernel.rs:94`](../crates/benilla-world/src/clouds/kernel.rs#L94))
-- The index wraps where the reference reads past the tile, only at `u == 1.0`. ([`src/clouds/kernel.rs:308`](../crates/benilla-world/src/clouds/kernel.rs#L308))
-- Clamped; the reference NaNs above about 70° elevation, where its bodies never go. ([`src/clouds/kernel.rs:338`](../crates/benilla-world/src/clouds/kernel.rs#L338))
-- Seed 1, the CRT default, for determinism; the reference's is the process `srand` state, and any uniform table looks the same. ([`src/clouds/tables.rs:47`](../crates/benilla-world/src/clouds/tables.rs#L47))
+- The reference starts this buffer at 0xFFFFFFFF; here it starts at alpha 0 because that keeps a dome drawn before the first build from flashing white. ([`src/clouds/kernel.rs:94`](../crates/benilla-world/src/clouds/kernel.rs#L94))
+- The index wraps because the reference reads past the tile, only at `u == 1.0`. ([`src/clouds/kernel.rs:308`](../crates/benilla-world/src/clouds/kernel.rs#L308))
+- Clamped because the reference NaNs above about 70° elevation, where its bodies never go. ([`src/clouds/kernel.rs:338`](../crates/benilla-world/src/clouds/kernel.rs#L338))
+- Seed 1, the CRT default, because that makes the table deterministic; the reference's is the process `srand` state, and any uniform table looks the same. ([`src/clouds/tables.rs:47`](../crates/benilla-world/src/clouds/tables.rs#L47))
 
 #### clutter
 
@@ -872,7 +872,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### collision
 
-- The reference's camera trace is a bare ray (`0x672170`); the sphere keeps the near plane out of a wall. ([`src/collision.rs:56`](../crates/benilla-world/src/collision.rs#L56))
+- The reference's camera trace is a bare ray (`0x672170`); here it is a sphere because that keeps the near plane out of a wall. ([`src/collision.rs:56`](../crates/benilla-world/src/collision.rs#L56))
 - The slide, step and snap are avian's kinematic controller, with parry's edge-hit normals, not the reference's resolver, because pieces of that resolver grafted onto the controller left the mover in states the reference never reaches; only its face filters, the facing law and the backface band, are ported. ([`src/collision/one_sided.rs:12`](../crates/benilla-world/src/collision/one_sided.rs#L12))
 - The reference keeps the later record in file order on an exact tie (`0x6327e2`), and its box-and-cone volume meets a lip where our capsule does not, so a capsule hit on an edge two different front faces share is classified by its contact normal. ([`src/collision/one_sided.rs:54`](../crates/benilla-world/src/collision/one_sided.rs#L54))
 
@@ -887,7 +887,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### exterior_cull
 
-- The reference tests one AABB per object, but a doodad placement has no root entity here, so its submeshes are tested one by one, and a submesh outside a doorway's window drops where the reference draws the doodad whole. ([`src/exterior_cull.rs:29`](../crates/benilla-world/src/exterior_cull.rs#L29))
+- The reference tests one AABB per object, but its submeshes are tested one by one here because a doodad placement has no root entity; a submesh outside a doorway's window drops where the reference draws the doodad whole. ([`src/exterior_cull.rs:29`](../crates/benilla-world/src/exterior_cull.rs#L29))
 
 #### ffx_glow
 
@@ -926,7 +926,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### shaders
 
-- The `min(I, 1)` cap, as in wow\_model.wgsl, since lifting it takes sun-facing surfaces past 1.0; Matte keeps its own bit so it stays 1.0 if the cap goes. ([`src/shaders/static_gx.wgsl:325`](../crates/benilla-world/src/shaders/static_gx.wgsl#L325))
+- The `min(I, 1)` cap, as in wow\_model.wgsl, because lifting it takes sun-facing surfaces past 1.0; Matte keeps its own bit so it stays 1.0 if the cap goes. ([`src/shaders/static_gx.wgsl:325`](../crates/benilla-world/src/shaders/static_gx.wgsl#L325))
 
 #### sky_order
 
@@ -935,9 +935,9 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### terrain_stream
 
-- The debug free-fly eye holds nothing: it is benilla's own tool with no reference counterpart, and a stall there only slows the developer. ([`src/terrain_stream.rs:434`](../crates/benilla-world/src/terrain_stream.rs#L434))
+- The debug free-fly eye holds nothing because it is benilla's own tool with no reference counterpart, and a stall there only slows the developer. ([`src/terrain_stream.rs:434`](../crates/benilla-world/src/terrain_stream.rs#L434))
 - A tile is released only one chunk past the outer window (`StreamWindow::keeps`), where the reference releases by window membership (`0x6984f0`), because our reload is a re-decode and re-spawn, not a cheap async read. ([`src/terrain_stream.rs:775`](../crates/benilla-world/src/terrain_stream.rs#L775))
-- A read still loading after `INNER_WAIT_CAP` is given up on with a warning, once per request, and its tile then streams on unwaited like the outer ring, where the reference waits for ever: a hung read costs one capped stall, not one every frame. ([`src/terrain_stream.rs:870`](../crates/benilla-world/src/terrain_stream.rs#L870))
+- A read still loading after `INNER_WAIT_CAP` is given up on with a warning, once per request, and its tile then streams on unwaited like the outer ring, where the reference waits for ever, because that way a hung read costs one capped stall, not one every frame. ([`src/terrain_stream.rs:870`](../crates/benilla-world/src/terrain_stream.rs#L870))
 - Benilla gates on terrain alone, which is more permissive; the settle hold covers a building or doodad arriving after a teleport. ([`src/terrain_stream/residency.rs:9`](../crates/benilla-world/src/terrain_stream/residency.rs#L9))
 - Tagged per submesh, where the reference tests the whole object, because a placement has no root entity to carry the bound. ([`src/terrain_stream/spawn/mod.rs:229`](../crates/benilla-world/src/terrain_stream/spawn/mod.rs#L229))
 - The box, where the reference tests its circumsphere (`0x683700` → `0x682ef0` → `0x686b80` on the `[rec+0x5c]` centre and `[rec+0x68]` radius × scale), because Bevy culls by box and the box is tighter. ([`src/terrain_stream/spawn/mod.rs:889`](../crates/benilla-world/src/terrain_stream/spawn/mod.rs#L889))
@@ -946,12 +946,12 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### view
 
-- The reference refuses a value outside them, echoing "NearClip must be in range 0.01 - 0.33" (`0x869abc`); ours clamps, as every CVar consumer here clamps at its own edge. ([`src/view.rs:84`](../crates/benilla-world/src/view.rs#L84))
+- The reference refuses a value outside them, echoing "NearClip must be in range 0.01 - 0.33" (`0x869abc`); ours clamps, because every CVar consumer here clamps at its own edge. ([`src/view.rs:84`](../crates/benilla-world/src/view.rs#L84))
 - The reference projects the detailed world to `farclip` and the horizon to `horizonfarclip` (default 2112, floored at `farclip + 528`); ours has one far plane well beyond `farclip`, because the WDL ring draws in the same projection, and the detailed world ends at `farclip` by the wall. ([`src/view.rs:242`](../crates/benilla-world/src/view.rs#L242))
 
 #### water_fx
 
-- The first draw is `size0`, where the reference first ages the record one `dt·growth` step, a difference too small to see at our frame rates. ([`src/water_fx/params.rs:86`](../crates/benilla-world/src/water_fx/params.rs#L86))
+- The first draw is `size0`, where the reference first ages the record one `dt·growth` step, because the difference is too small to see at our frame rates. ([`src/water_fx/params.rs:86`](../crates/benilla-world/src/water_fx/params.rs#L86))
 
 #### wdl
 
@@ -971,6 +971,6 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
 
 #### zfill
 
-- The reference twins every translucent command, authored-blend glass included; here twins exist only during an instance alpha episode, so every steady-state look is untouched. ([`src/zfill.rs:9`](../crates/benilla-world/src/zfill.rs#L9))
-- Bevy sorts per entity, so twins lead by a fixed −8 yd sort bias (`crate::model_render::ZFILL_SORT_BIAS`) instead of by the instance's sort-key tie; transparent content within that window behind a fading body is depth-clipped where the body covers it, for the episode. ([`src/zfill.rs:12`](../crates/benilla-world/src/zfill.rs#L12))
+- The reference twins every translucent command, authored-blend glass included; here twins exist only during an instance alpha episode, because that way every steady-state look is untouched. ([`src/zfill.rs:9`](../crates/benilla-world/src/zfill.rs#L9))
+- Twins lead by a fixed −8 yd sort bias (`crate::model_render::ZFILL_SORT_BIAS`) instead of by the instance's sort-key tie because Bevy sorts per entity; transparent content within that window behind a fading body is depth-clipped where the body covers it, for the episode. ([`src/zfill.rs:13`](../crates/benilla-world/src/zfill.rs#L13))
 
diff --git a/scripts/deviation-why.allow b/scripts/deviation-why.allow
new file mode 100644
index 000000000..d3d330d1b
--- /dev/null
+++ b/scripts/deviation-why.allow
@@ -0,0 +1,46 @@
+# Deviations still waiting for their reason (scripts/genmap.sh, "the reason check").
+# One `path<TAB>first twelve words of the comment` per line. This list only shrinks: when a comment
+# gains "because ...", delete its line here; never add one. A comment off the list must carry its reason.
+crates/benilla-app/assets/ui/KeyBindingsPage.xml	every bind, unbind and reset saves at once, as the era panel
+crates/benilla-app/src/bindings/layout.rs	on the Mac and Linux a key its platform reports no character
+crates/benilla-app/src/cvars/listing.rs	the reference's list runs in creation order, the records `Config.wtf` created first
+crates/benilla-app/src/game_tip.rs	the reference rasterizes the tip's font at most 32 px (`0x5ca096`/`0x5ca09b` in
+crates/benilla-app/src/go_templates.rs	one per entry, where the reference keeps one per call, as the
+crates/benilla-app/src/loading_screen/input.rs	the world pick is cleared, where the reference's freezes: the screen's layer
+crates/benilla-app/src/player/approach.rs	the reference re-projects the point's height onto the first walkable facet a
+crates/benilla-app/src/portrait/mod.rs	the reference widget draws only its model; a body pane clears to
+crates/benilla-app/src/sound/mod.rs	with no character the reference leaves the listener where it was; benilla
+crates/benilla-app/src/target/click.rs	the reference's arm reads the last object's stop (`0x611336` before `0x610383` stores
+crates/benilla-app/src/target/click.rs	it runs on the first frame with none, so an arrival that
+crates/benilla-app/src/ui_duel.rs	the challenger's name comes from the [`NameCache`], so a name still being
+crates/benilla-app/src/ui_guild/sort.rs	the reference ties a miss with a hit (`0x4d0e27`, `0x4d0ea1`), no total
+crates/benilla-app/src/ui_loot/mod.rs	`autoLootDefault` is benilla's own option, 1.12 auto-looting only on a shift-click, and
+crates/benilla-app/src/ui_quest/verbs.rs	the row one past a full pool is read from the cells
+crates/benilla-app/src/ui_social/live.rs	after a full 50 the reference reads the 160 bytes past the
+crates/benilla-app/src/ui_text/outline.rs	`r × floor(dpi)` passes as in [`outlined_cell`], the first `floor(dpi)` of them
+crates/benilla-app/src/ui_tooltip/spell_view.rs	a pet view with no pet unit costs 0, an empty cell,
+crates/benilla-assets/src/shaders/liquid.wgsl	this is the `specular`/`pixelShaders` = 1 leg the reference install runs; both
+crates/benilla-formats/src/macro_icons.rs	of names equal but for case, benilla keeps the first in source
+crates/benilla-lua/src/heap.rs	C Lua has no such bound; past it the string is `not
+crates/benilla-lua/src/heap.rs	the client's `luaM_realloc` (`0x6fc980`) has no failure path to ask from; here
+crates/benilla-lua/src/lib_string.rs	5.1's `match` recurses without a bound and overflows the C stack (near
+crates/benilla-lua/src/pools.rs	that sequence is not wholly the client's. A table's node vector is
+crates/benilla-lua/src/vm.rs	these are benilla's own needs, past what the client's checks ([`Vm::checkstack`]) reserve:
+crates/benilla-lua/src/vm.rs	benilla's scratch registers above a frame's `c_maxstack` (`Proto::maxstack`) stay on the stack;
+crates/benilla-protocol/src/world/session.rs	checked per queue packet where the reference checks each tick, so a
+crates/benilla-ui/src/civil.rs	the zone database's offset for the date, where the reference's CRT applies
+crates/benilla-ui/src/loader/mod.rs	a `<Script file=>` value with a separator joins the including document's directory,
+crates/benilla-ui/src/script/binding_abi.rs	`pow(10, n)` is the platform's, where the reference's (`0x73f940`, `fyl2x`) rounds its
+crates/benilla-ui/src/script/button.rs	the disabled-checked leg (`0x785380`) tests and reloads the checked slot (`[+0x4e0]`, `0x785388`/`0x7853a5`),
+crates/benilla-ui/src/script/chat_window.rs	one past `i32::MAX` clamps where the reference keeps the low 32 bits,
+crates/benilla-ui/src/script/glue_create.rs	past [`NAME_TRIES`] names the answer is nil, where the reference keeps trying,
+crates/benilla-ui/src/script/nameplate.rs	the reference's free list is FIFO (`0x6087f0`, `0x608a5a`); either keeps every index
+crates/benilla-ui/src/script/quest_log.rs	one signal per missed record, where the reference runs every callback of
+crates/benilla-ui/src/script/reputation.rs	the reference bounds the index with `jbe` against the entry count (`0xb73760`),
+crates/benilla-ui/src/script/slash.rs	skipped as no command. The stock walk calls an entry only when
+crates/benilla-ui/src/script/sound.rs	the app plays the queued file after the call, so the refusals
+crates/benilla-ui/src/script/stdlib.rs	a format that ends in `%` reads past its terminator in the
+crates/benilla-ui/src/script/stdlib.rs	with `#` and one byte of room, `_store_number` writes no digit and
+crates/benilla-ui/src/script/tooltip/size.rs	`0x530a52` lays it out at once; getters resolve first, so only OnSizeChanged
+crates/benilla-ui/src/script/worldmap.rs	the engine's own push (the world-enter sync) queues `WORLD_MAP_UPDATE` for the next
+crates/benilla-world/src/collision/one_sided.rs	the reference keeps the later record in file order on an exact
diff --git a/scripts/gates.sh b/scripts/gates.sh
index c8ab54caf..83c1c6a92 100755
--- a/scripts/gates.sh
+++ b/scripts/gates.sh
@@ -110,6 +110,8 @@ run() {
 }
 
 run fmt cargo fmt --all -- --check
+# deviation-why: every `Deviation:` comment and `Deviates` row names its reason (`scripts/genmap.sh --check`).
+run deviation-why scripts/genmap.sh --check
 run clippy cargo clippy --workspace --all-targets -- -D warnings
 
 # test: where the install resolves and the `wow-addons-vanilla` corpus link exists,
diff --git a/scripts/genmap.sh b/scripts/genmap.sh
index 0e27a881e..97d500d91 100755
--- a/scripts/genmap.sh
+++ b/scripts/genmap.sh
@@ -9,6 +9,10 @@
 set -u
 cd "$(dirname "$0")/.."
 
+# `--check` runs every stage but writes the docs into a scratch folder, for the gates.
+out=docs
+if [ "${1:-}" = "--check" ]; then out=$(mktemp -d "${TMPDIR:-/tmp}/genmap-out.XXXXXX"); trap 'rm -rf "$out"' EXIT; fi
+
 # Extract a quoted `key = "value"` field from a Cargo.toml.
 field() { grep -m1 "^$2" "$1" 2>/dev/null | sed -E "s/^$2[[:space:]]*=[[:space:]]*\"//; s/\".*$//"; }
 
@@ -122,16 +126,16 @@ field() { grep -m1 "^$2" "$1" 2>/dev/null | sed -E "s/^$2[[:space:]]*=[[:space:]
   done
   echo
 
-} > docs/MAP.md
+} > "$out/MAP.md"
 
-echo "genmap: wrote docs/MAP.md"
+echo "genmap: wrote $out/MAP.md"
 
 # ── docs/DEVIATIONS.md ─────────────────────────────────────────────────────────────────────────────
 # Every place benilla writes down that it differs from 1.12.1: the `Deviates` rows of the CVar table,
 # and each `Deviation:` comment in the crates (Rust and WGSL `//`, Lua `--`, XML `<!-- -->`). A
 # deviation's wording is read from where it lives, so the list cannot drift from the code.
 tmp=$(mktemp -d "${TMPDIR:-/tmp}/genmap.XXXXXX") || exit 1
-trap 'rm -rf "$tmp"' EXIT
+trap 'rm -rf "$tmp"; [ "$out" = docs ] || rm -rf "$out"' EXIT
 
 # Test code is left out: a file under `tests/`, named `tests.rs` or `*_tests.rs`, or declared by a
 # `#[cfg(test)] mod x;` (listed here, resolved the way rustc does, `#[path]` included), and a
@@ -210,7 +214,7 @@ LC_ALL=C grep -rIlE 'Deviation:' crates 2>/dev/null | LC_ALL=C sort | grep -vE '
     if (r ~ /^assets\//) { rest = substr(r, 8); m = "assets"; if (index(rest, "/")) { sub(/\/.*/, "", rest); m = m "/" rest } return m }
     sub(/\/.*/, "", r); return r
   }
-  function process(f,   n, i, j, s, t, ext, xin, skipping, tindent, pend, p, q, c, kind, code, marker, text, lab, cr, rel, first, cont) {
+  function process(f,   n, i, j, s, t, ext, xin, skipping, tindent, pend, p, q, c, kind, code, marker, text, lab, cr, rel, first, cont, full) {
     n = 0; delete L; delete K; delete C; delete Q; delete XI; delete T
     while ((getline s < f) > 0) L[++n] = s
     close(f)
@@ -270,6 +274,7 @@ LC_ALL=C grep -rIlE 'Deviation:' crates 2>/dev/null | LC_ALL=C sort | grep -vE '
         if (cont == "" || cont ~ /^([-*] |```)/ || label_at(cont)) break
         text = text " " cont
       }
+      full = trim(text); gsub(/\t/, " ", full)
       text = trim(lead(trim(text)))
       gsub(/\t/, " ", text)
       # A rustdoc link [`x`] or [`x`](path) reads as `x`.
@@ -280,7 +285,7 @@ LC_ALL=C grep -rIlE 'Deviation:' crates 2>/dev/null | LC_ALL=C sort | grep -vE '
       sub(/[.;,:]+$/, "", text)
       if (text == "") text = "(see the comment)"
       if (T[i] || skipfile) { skipped++; continue }
-      printf "%s\t%s\t%s\t%d\t%s\n", cr, module_of(rel), rel, i, text
+      printf "%s\t%s\t%s\t%d\t%s\t%s\n", cr, module_of(rel), rel, i, text, full
     }
   }
   BEGIN {
@@ -422,6 +427,46 @@ MDESC='
     $2 != module { if (module != "") print ""; module = $2; printf "#### %s\n\n", module }
     { printf "- %s. ([`%s:%d`](../crates/%s/%s#L%d))\n", mdesc($5), $3, $4, $1, $3, $4 }
     END { print "" }' "$tmp/code.sorted"
-} > docs/DEVIATIONS.md
+} > "$out/DEVIATIONS.md"
 
-echo "genmap: wrote docs/DEVIATIONS.md ($(wc -l < "$tmp/code.sorted" | tr -d ' ') code entries, $(wc -l < "$tmp/cvars.tsv" | tr -d ' ') CVar rows)"
+echo "genmap: wrote $out/DEVIATIONS.md ($(wc -l < "$tmp/code.sorted" | tr -d ' ') code entries, $(wc -l < "$tmp/cvars.tsv" | tr -d ' ') CVar rows)"
+
+# ── the reason check ───────────────────────────────────────────────────────────────────────────────
+# `docs/METHOD.md`: a deviation is written down with the reference fact and why we differ. So a
+# `Deviation:` comment carries "because …" somewhere in its paragraph, and a CVar `Deviates` row
+# carries a Why. `scripts/deviation-why.allow` is the ratchet for the comments still waiting for a
+# reason: one `path<TAB>first twelve words` per line. It only shrinks. An entry that gained its reason,
+# or whose comment is gone or reworded, fails until it is removed; a comment off the list without
+# "because" fails; and an entry new against origin/main's copy of the list fails.
+allow=scripts/deviation-why.allow
+haveold=0
+if git cat-file -e "origin/main:$allow" 2>/dev/null; then
+  haveold=1
+  git show "origin/main:$allow" | grep -vE '^(#|$)' > "$tmp/allow.old" || true
+else
+  : > "$tmp/allow.old"
+fi
+grep -vE '^(#|$)' "$allow" 2>/dev/null > "$tmp/allow.now" || : > "$tmp/allow.now"
+LC_ALL=C awk -F '\t' -v haveold="$haveold" -v oldf="$tmp/allow.old" -v nowf="$tmp/allow.now" '
+  function key(t,   n, w, i, k) { n = split(t, w, " "); k = ""; for (i = 1; i <= n && i <= 12; i++) k = k (i > 1 ? " " : "") w[i]; return k }
+  BEGIN {
+    while ((getline l < oldf) > 0) old[l] = 1
+    close(oldf)
+    FS = "\t"
+    while ((getline l < nowf) > 0) { listed[l] = 1; order[++nl] = l; if (haveold == 1 && !(l in old)) { print "deviation-why: new on the allowlist, which only shrinks: " l; bad++ } }
+  }
+  FILENAME ~ /cvars\.tsv$/ { if ($4 == "") { print "deviation-why: the `" $1 "` Deviates row has no Why"; bad++ } next }
+  {
+    path = "crates/" $1 "/" $3; k = path "\t" key($6)
+    seen[k] = 1
+    if (tolower($6) ~ /(^|[^a-z])because([^a-z]|$)/) {
+      if (k in listed) { print "deviation-why: " path ":" $4 " has its reason now; remove it from the allowlist"; bad++ }
+    } else {
+      if (++dup[k] > 1) { print "deviation-why: " path ":" $4 " shares its first twelve words with another comment without a reason; reword one"; bad++ }
+      if (!(k in listed)) { print "deviation-why: " path ":" $4 " gives no reason; add \"because …\" (" substr($6, 1, 60) "…)"; bad++ }
+    }
+  }
+  END {
+    for (i = 1; i <= nl; i++) if (!(order[i] in seen)) { print "deviation-why: stale allowlist entry, remove it: " order[i]; bad++ }
+    if (bad) { print "deviation-why: " bad " problem(s); docs/METHOD.md: a deviation names why we differ" > "/dev/stderr"; exit 1 }
+  }' "$tmp/cvars.tsv" "$tmp/code.sorted" >&2 || exit 1