diff --git a/crates/benilla-app/assets/ui/OptionsFrame.xml b/crates/benilla-app/assets/ui/OptionsFrame.xml
index 0a10b5a9..e3f2892a 100644
--- a/crates/benilla-app/assets/ui/OptionsFrame.xml
+++ b/crates/benilla-app/assets/ui/OptionsFrame.xml
@@ -852,7 +852,12 @@
             local v = OptionsRow_Get(row)
             local match
             for _, e in ipairs(row.entries) do
-                if e.value == v then match = e end
+                -- `alt` is a second value the same entry ANSWERS to (1502): 1.12's own Camera
+                -- Following Style dropdown writes "3" for Never where the engine's tables are
+                -- indexed 0/1/2, so a config or addon carrying that value means Never — and the
+                -- nearest-stop fallback below, which assumes the values are ordinal, would show
+                -- "Always" for it. A categorical dropdown says which strays are its own.
+                if e.value == v or e.alt == v then match = e end
             end
             if not match and tonumber(v) then
                 local best
@@ -1989,14 +1994,22 @@
                                              "22" means the wheel stops at 22 yards, which is the
                                              thing being chosen. Our default is the factor fully
                                              raised (30 yd), where 1.12 ships 1.0. -->
-                                        <!-- Camera Following Style (decision 1493): 1.12's own
-                                             dropdown (UIOptionsFrameCameraDropDown), values and
-                                             order and all — Smart "1", Always "2", Never "3", with
-                                             each entry carrying the reference's own description key
-                                             so the row's plate changes with the selection, the way
-                                             that dropdown's does. Seated at the head of the camera
-                                             block because it decides whether the camera follows at
-                                             all; the distance slider under it decides how far. -->
+                                        <!-- Camera Following Style (1493, values re-pinned by
+                                             1502): 1.12's own dropdown
+                                             (UIOptionsFrameCameraDropDown) in its own order —
+                                             Smart, Always, Never — each entry carrying the
+                                             reference's own description key (keyed by POSITION,
+                                             OPTION_TOOLTIP_CAMERA1..3) so the row's plate changes
+                                             with the selection, the way that dropdown's does.
+                                             The VALUES are the ENGINE's, not that dropdown's: the
+                                             reference writes 1/2/3 and 3 is not a style at all —
+                                             its validator accepts it while the terrain-tilt
+                                             consumer indexes 360 bytes off the end of its table.
+                                             0/1/2 is what the client's own tables are indexed by
+                                             (wow-re camera-smooth-style.md §2/§4). Seated at the
+                                             head of the camera block because it decides whether
+                                             the camera follows at all; the distance slider under
+                                             it decides how far. -->
                                         <Frame name="$parentRowCameraFollowStyle" inherits="OptionsDropdownRowTemplate">
                                             <Anchors>
                                                 <Anchor point="TOPLEFT" relativeTo="$parentRowMouseSpeed" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
@@ -2008,7 +2021,7 @@
                                                 OptionsDropdownRow_Setup(self, {
                                                     { text = "Smart", value = "1", tip = "OPTION_TOOLTIP_CAMERA1" },
                                                     { text = "Always", value = "2", tip = "OPTION_TOOLTIP_CAMERA2" },
-                                                    { text = "Never", value = "3", tip = "OPTION_TOOLTIP_CAMERA3" },
+                                                    { text = "Never", value = "0", alt = "3", tip = "OPTION_TOOLTIP_CAMERA3" },
                                                 })
                                             </OnLoad></Scripts>
                                         </Frame>
diff --git a/crates/benilla-app/src/capture/mod.rs b/crates/benilla-app/src/capture/mod.rs
index 387d7458..dc1e3bb3 100644
--- a/crates/benilla-app/src/capture/mod.rs
+++ b/crates/benilla-app/src/capture/mod.rs
@@ -117,7 +117,7 @@ pub(crate) use probes::{
     fx_draw_census_plugin, DressCensusPlugin, EntityCensusPlugin, GroundCensusPlugin,
     LiveFpsPlugin, NodeProbePlugin, ParticleCensusPlugin, ProbeChatPlugin, ProbeClock,
     ProbeExitPlugin, ProbeFocusPlugin, ProbeKeyPlugin, ProbeLuaPlugin, ProbeResizePlugin,
-    SchedCensusPlugin, UnitVisualsPlugin,
+    RevealAuditPlugin, SchedCensusPlugin, UnitVisualsPlugin,
 };
 use scenarios::GlueScreen;
 use scenarios::{Scenario, SubjectKind, UiFixture, GLUE_SCENARIOS, GROUND_EYE, SCENARIOS};
diff --git a/crates/benilla-app/src/capture/probes/mod.rs b/crates/benilla-app/src/capture/probes/mod.rs
index d92792cb..5a91fd05 100644
--- a/crates/benilla-app/src/capture/probes/mod.rs
+++ b/crates/benilla-app/src/capture/probes/mod.rs
@@ -47,6 +47,11 @@ pub(crate) use visual_census::UnitVisualsPlugin;
 mod dress_census;
 pub(crate) use dress_census::DressCensusPlugin;
 
+/// The reveal audit — per-frame, from a snap: every term that decides whether the world about
+/// to be shown is actually drawable (decision 1498).
+mod reveal;
+pub(crate) use reveal::RevealAuditPlugin;
+
 /// The two exclusive-`World` reflection dumps: the bevy_ui node inventory and the archetype
 /// census — "what is resident right now, and what is it made of".
 mod world_census;
diff --git a/crates/benilla-app/src/capture/probes/reveal.rs b/crates/benilla-app/src/capture/probes/reveal.rs
new file mode 100644
index 00000000..abab995b
--- /dev/null
+++ b/crates/benilla-app/src/capture/probes/reveal.rs
@@ -0,0 +1,137 @@
+//! The **reveal audit** (`WOW_REVEAL=<frames>`) — one line per frame from a snap, naming every
+//! term that decides whether the world the player is about to be shown is actually there.
+//!
+//! "Teleported and the city wasn't drawn for a frame or more" is a *temporal* claim about the
+//! frames either side of a reveal, and neither a screenshot nor the loading screen's own 3-second
+//! wait line can hold one: the screenshot is one frame with no state attached, and the wait line
+//! only speaks for loads slow enough to be stuck. This prints the whole window — the cover, the
+//! residency terms behind [`WorldLoadProgress::presentable`], the settle hold, and the retained
+//! pass's collected-vs-published region counts — so "which term let the reveal through" is read
+//! off a column instead of guessed.
+//!
+//! ```text
+//! WOW_USER=probe1 WOW_PASS=pprobe1 WOW_CHAR=Probeone \
+//!   WOW_PROBE_CHAT=".go xyz -9250.45 160.86 67.90 0;.tele stormwind" \
+//!   WOW_PROBE_CHAT_AT=20 WOW_PROBE_CHAT_EVERY=25 WOW_REVEAL=120 \
+//!   WOW_PROBE_EXIT_AT=70 cargo run -q -p benilla | grep REVEAL
+//! ```
+//!
+//! The arming edge is the snap itself (a same-map teleport or a worldport), so the window covers
+//! the frames a cover would have to be up for — and, when none is, the frames the player is
+//! looking at the destination through nothing at all.
+//!
+//! **It runs in `Last`, and that is load-bearing.** Half of what decides whether a frame has a
+//! world in it is settled in `PostUpdate` — bevy's visibility check, the exterior-scene gate, the
+//! retained pass's own scene walk — and a line printed in `Update` reports those columns from the
+//! *previous* frame. Against a one-or-two-frame artefact an off-by-one instrument is worse than
+//! none: it attributes the hole to the frame beside it. In `Last` every column below is this
+//! frame's, residency and draw alike.
+//!
+//! The columns split into two halves on purpose. **Residency** (`res`, `focus`, `scene`, `place`,
+//! `coll`, `merge`, `gx`) is *what the world has* — the terms behind
+//! [`WorldLoadProgress::presentable`], the ones the cover is raised and cleared on. **Draw**
+//! (`drawn`, `hid`, `sel`, `room`, `win`, `pvseye`) is *what the frame put on screen*. A reveal
+//! defect where every residency term reads ready and the draw half has collapsed is not a
+//! streaming bug at all — it is the visibility authority answering about somewhere else.
+
+use bevy::prelude::*;
+
+use super::ProbeClock;
+use benilla_world::static_gx::StaticGx;
+use benilla_world::terrain_stream::WorldLoadProgress;
+use benilla_world::world_census::WorldCensus;
+
+/// The audit's window: how many frames after a snap to report, from `WOW_REVEAL`.
+#[derive(Resource)]
+struct RevealAudit {
+    frames: u32,
+    /// Frames printed since the current arm; `None` = not armed.
+    n: Option<u32>,
+    /// [`ProbeClock`] seconds at the arming snap — the `t=` column. The wall clock, like every
+    /// other probe schedule (decision 0789): a reveal window is measured in real milliseconds,
+    /// and the virtual clock clamps exactly the hitching frames this instrument exists to see.
+    since: f32,
+}
+
+pub(crate) struct RevealAuditPlugin;
+
+impl Plugin for RevealAuditPlugin {
+    fn build(&self, app: &mut App) {
+        let frames = std::env::var("WOW_REVEAL")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .unwrap_or(120u32);
+        app.insert_resource(RevealAudit {
+            frames,
+            n: None,
+            since: 0.0,
+        })
+        // In `Last`: after the streamer published residency, after the screen decided what to do
+        // with it, and after `PostUpdate` settled what actually draws (see the module docs).
+        .add_systems(Last, drive_reveal_audit);
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn drive_reveal_audit(
+    mut audit: ResMut<RevealAudit>,
+    progress: Res<WorldLoadProgress>,
+    gx: Option<Res<StaticGx>>,
+    screen: Res<crate::loading_screen::LoadingScreen>,
+    player: Option<Res<crate::player::Player>>,
+    census: WorldCensus,
+    cam: Query<&GlobalTransform, With<benilla_world::view::WorldCamera>>,
+    time: ProbeClock,
+    mut teleports: MessageReader<crate::net::TeleportMessage>,
+    mut worldports: MessageReader<crate::net::WorldportMessage>,
+) {
+    let now = time.elapsed_secs();
+    if teleports.read().next().is_some() || worldports.read().next().is_some() {
+        audit.n = Some(0);
+        audit.since = now;
+    }
+    let Some(n) = audit.n else {
+        return;
+    };
+    if n >= audit.frames {
+        audit.n = None;
+        return;
+    }
+    audit.n = Some(n + 1);
+
+    let (collected, published, selected) = gx
+        .as_deref()
+        .map_or((0, 0, 0), benilla_world::static_gx::StaticGx::wmo_census);
+    let (cells_drawn, wmo_drawn, groups_drawn) = gx
+        .as_deref()
+        .map_or((0, 0, 0), benilla_world::static_gx::StaticGx::draw_census);
+    let seen = census.take();
+    // How far the visibility authority's pose is from the eye this frame is actually drawn from
+    // — ~0 in steady play, the whole jump on a snap frame it has not caught up with.
+    let pvs_lag = match (seen.pvs_eye, cam.iter().next()) {
+        (Some(eye), Some(now_eye)) => eye.distance(now_eye.translation()),
+        _ => f32::NAN,
+    };
+    info!(
+        "REVEAL n={n} t={:.0}ms cover={} res={}/{} focus={} scene={} place={} coll={} merge={} \
+         gx={} wmo={collected}/{published}/{selected} settling={} | drawn={}/{} hid={}/{} \
+         sel={cells_drawn}/{wmo_drawn}/{groups_drawn} room={} win={} pvslag={pvs_lag:.0}",
+        (now - audit.since) * 1000.0,
+        u8::from(screen.covering()),
+        progress.ready,
+        progress.total,
+        u8::from(progress.focus_resident),
+        u8::from(progress.scene_ready),
+        progress.placements_pending,
+        progress.colliders_pending,
+        progress.merge_pending,
+        progress.gx_pending,
+        u8::from(player.is_some_and(|p| p.settling)),
+        seen.drawn,
+        seen.submeshes,
+        seen.hidden,
+        seen.tagged,
+        seen.room.as_deref().unwrap_or("-"),
+        seen.windows.as_deref().unwrap_or("-"),
+    );
+}
diff --git a/crates/benilla-app/src/chat_bubble.rs b/crates/benilla-app/src/chat_bubble.rs
index 49364655..a6da4070 100644
--- a/crates/benilla-app/src/chat_bubble.rs
+++ b/crates/benilla-app/src/chat_bubble.rs
@@ -32,6 +32,14 @@
 //!   with no bone matrix anywhere in its call tree — and the scaled product is **latched** at
 //!   `bubble+0x354` behind a parity guard, so it is queried exactly **once per chat line**
 //!   ([`crate::entities::StandBoxHeight`], wow-re's anchor cross-check 2026-08-17; 1406).
+//! - **Stacking** (`0x4b1060`, the per-frame pass over ALL live bubbles — one caller, `0x4817a3`):
+//!   each bubble is its own frame and its frame LEVEL is restamped every frame from the CAMERA's
+//!   distance to the speaker. The list re-sorts farthest-first (`0x4b1360`, comparing
+//!   `[bubble+0x350]` = |cam − unit|², written at `0x4b12c0`), then a head→tail walk stamps
+//!   `SetFrameLevel(2), (3), (4)…` (`0x4b1309`). Level outranks draw layer in the client's total
+//!   order, so overlapping bubbles stack as WHOLE cards with the nearest speaker's on top —
+//!   nothing interleaves. ([`level_z`]; benilla read the bytes for this one, 1504 — wow-re's
+//!   `chat-bubble.md` covers the spawn/geometry/anchor and never reached the manager tick.)
 //!
 //! Named divergences (all deliberate, decisions 0598/0599):
 //! - **`ChatBubblesParty` defaults ON** (binary default "0") — the director asked for `/p`
@@ -71,7 +79,7 @@ use benilla_ui::script::{JustifyH, JustifyV, Outline};
 use crate::entities::StandBoxHeight;
 use crate::net::{Embodied, Guid, NetEntity, SelfGuid};
 use crate::ui_chat::{default_color, ChatEventKind};
-use crate::ui_pass::{UiQuad, UiQuadAppend, UiQuads, UvRect};
+use crate::ui_pass::{overlay_z, UiQuad, UiQuadAppend, UiQuads, UvRect};
 use crate::ui_text::{layout_text_quads, measure_text, FontSpec, Justify, UiFontAtlas};
 use crate::vplates::{device_snap, gx_px, plate_basis, text_px, VPlateSet, VPlates};
 use benilla_assets::{AssetSet, WorldAssets};
@@ -121,15 +129,25 @@ const WRAP_W: f32 = 0.2;
 /// (`G44·16.0/(S·1024.0)` — G44/S nets the width in the diagonal gx basis).
 const BORDER_FRAC: f32 = 16.0 / 1024.0;
 
-/// Paint order inside the overlays lane: the whole bubble sits UNDER the V-plates' 4..8 band
-/// (same-unit overlap can't happen — the mutual exclusion — so this only orders cross-unit
-/// stacking). The tail draws over the frame's bottom edge piece: its art carries the border
-/// lines that make the seam read continuous.
+/// Paint order **inside one bubble's frame level** — the four pieces, back→front. The tail draws
+/// over the frame's bottom edge piece: its art carries the border lines that make the seam read
+/// continuous, and the reference gets the same result from its own layer key (the tail is an
+/// ARTWORK texture, the text an ARTWORK font string, and a batch drains every texture before
+/// every font string — wow-re `ui/scratch/draw-order-law.md` §4).
 const Z_BG: u64 = 0;
 const Z_EDGE: u64 = 1;
 const Z_TAIL: u64 = 2;
 const Z_TEXT: u64 = 3;
 
+/// The z base for the bubble at `rank` in this frame's farthest→nearest order — the port of the
+/// reference's per-frame `SetFrameLevel(2 + i)` walk (`0x4b12d5`–`0x4b1312`, decision 1504). One
+/// LEVEL per bubble, [`overlay_z::BUBBLE_STRIDE`] keys wide, so a whole bubble stacks over a whole
+/// bubble; the whole band stays under the V-plates ([`crate::ui_pass::overlay_z`]).
+fn level_z(rank: usize) -> u64 {
+    let level = (rank as u64).min(overlay_z::BUBBLE_MAX_LEVEL);
+    overlay_z::BUBBLE + level * overlay_z::BUBBLE_STRIDE
+}
+
 /// Which CVar gates this chat kind's bubble — `None` = the kind never bubbles in v1.
 /// PARTY selects `ChatBubblesParty`, every other bubbling kind `ChatBubbles` (`0x608b0d`).
 /// Guild/officer/whisper/emote are structurally implied by the byte gate but INFERRED on an
@@ -455,6 +473,7 @@ fn drive_bubbles(
     let scale = window.single().map_or(1.0, Window::scale_factor);
     let trace = std::env::var("WOW_BUBBLE_TRACE").as_deref() == Ok("1");
     let mut dead = Vec::new();
+    let mut pending: Vec<Pending> = Vec::new();
     for (guid, b) in bubbles.0.iter_mut() {
         let Some((entity, _, tf)) = find(*guid) else {
             dead.push(*guid); // the speaker despawned — the unit teardown takes its bubble
@@ -485,9 +504,9 @@ fn drive_bubbles(
         if b.alpha <= 0.0 {
             continue;
         }
-        let (Some((cam, cam_pose)), Some(atlas), Some(art)) = (cam, atlas.as_deref_mut(), art)
-        else {
-            continue; // no camera/atlas/art — lifetimes still tick, nothing draws
+        // No camera/atlas/art — lifetimes still tick, nothing draws.
+        let (Some((cam, cam_pose)), true) = (cam, atlas.is_some() && art.is_some()) else {
+            continue;
         };
         // World anchor (`0x4b0c30`): the unit's position, Z lifted by the LATCHED Stand-box height
         // + 0.7 yd — seated BOTTOM at the projected point, growing upward. Every term is this
@@ -509,24 +528,80 @@ fn drive_bubbles(
             refuse("no-viewport", *guid);
             continue;
         };
+        // Seated and projected here, DRAWN below: the level a bubble draws at is a property of
+        // the whole live set, not of this bubble ([`level_z`]), so the draw waits for the sort.
+        pending.push(Pending {
+            guid: *guid,
+            entity,
+            seat,
+            viewport,
+            // The sort key (`0x4b1251`–`0x4b12c0`): |camera − speaker|², the CAMERA's distance,
+            // not the local player's (which is the eligibility gate's, above).
+            cam_dist_sq: cam_pose.translation.distance_squared(tf.translation),
+            anchor: seat_world,
+            unit_pos: tf.translation,
+        });
+    }
+    for g in dead {
+        bubbles.0.remove(&g);
+    }
+
+    // ── The frame-level pass (`0x4b12d5`–`0x4b1312`) ─────────────────────────────────────────
+    // The reference re-sorts its live-bubble list by camera distance, FARTHEST at the head, and
+    // then walks head→tail stamping `SetFrameLevel(2), (3), (4)…` — so every bubble owns a frame
+    // level of its own and the NEAREST speaker's bubble ends up on top. (It only re-sorts when
+    // the camera moved or a bubble is dirty; the stamping walk runs unconditionally. Sorting
+    // every frame is the same list with no state to keep.) Ties break on guid so an exact
+    // distance tie can't flip the stack frame to frame.
+    stack_sort(&mut pending);
+    let (Some((_, cam_pose)), Some(atlas), Some(art)) = (cam, atlas.as_deref_mut(), art) else {
+        return; // nothing reached `pending` either — the same gate refused it in the tick
+    };
+    for (rank, p) in pending.iter().enumerate() {
+        let Some(b) = bubbles.0.get(&p.guid) else {
+            continue; // despawned between the tick and the draw
+        };
         draw_bubble(
             atlas,
             &mut quads,
             art,
             b,
-            seat,
-            viewport,
+            p.seat,
+            p.viewport,
             scale,
             trace,
-            entity,
-            seat_world,
-            tf.translation,
+            p.entity,
+            p.anchor,
+            p.unit_pos,
             cam_pose,
+            level_z(rank),
         );
     }
-    for g in dead {
-        bubbles.0.remove(&g);
-    }
+}
+
+/// The stack order: **farthest camera distance first**, so the enumeration index that follows is
+/// the reference's frame level and the nearest speaker's bubble draws last (on top). Ties break on
+/// guid — the reference's list keeps its previous order across an exact tie because it re-inserts
+/// only ahead of a *strictly* closer node, and a `HashMap` walk has no such memory.
+fn stack_sort(pending: &mut [Pending]) {
+    pending.sort_by(|a, b| {
+        b.cam_dist_sq
+            .total_cmp(&a.cam_dist_sq)
+            .then(a.guid.cmp(&b.guid))
+    });
+}
+
+/// One bubble that passed the tick and projected on screen, waiting for the frame-level sort.
+struct Pending {
+    guid: u64,
+    entity: Entity,
+    seat: Vec2,
+    viewport: Vec2,
+    /// |camera − speaker|², the reference's own sort key (`[bubble+0x350]`).
+    cam_dist_sq: f32,
+    /// The world seat and the speaker's position — the `bub` jitter trace's decomposition.
+    anchor: Vec3,
+    unit_pos: Vec3,
 }
 
 /// Append one bubble's draw list: the Backdrop pieces (bg fill inset by the border-unit +
@@ -546,6 +621,8 @@ fn draw_bubble(
     anchor: Vec3,
     unit_pos: Vec3,
     cam_pose: &Transform,
+    // This bubble's frame level, flattened to a z base ([`level_z`]).
+    z: u64,
 ) {
     let basis = plate_basis(viewport);
     let border = border_px(viewport, basis);
@@ -628,7 +705,7 @@ fn draw_bubble(
         };
         quads.overlays.push(UiQuad {
             rect,
-            z_key: if p.is_bg { Z_BG } else { Z_EDGE },
+            z_key: z + if p.is_bg { Z_BG } else { Z_EDGE },
             texture: Some(if p.is_bg {
                 art.bg.clone()
             } else {
@@ -645,7 +722,7 @@ fn draw_bubble(
     let cx = (frame.min.x + frame.max.x) * 0.5;
     quads.overlays.push(UiQuad {
         rect: Rect::new(cx - border, tail_top, cx, tail_top + border),
-        z_key: Z_TAIL,
+        z_key: z + Z_TAIL,
         texture: Some(art.tail.clone()),
         uv: UvRect::FULL,
         color: [1.0, 1.0, 1.0, alpha],
@@ -663,7 +740,7 @@ fn draw_bubble(
             h: JustifyH::Center,
             v: JustifyV::Middle,
         },
-        Z_TEXT,
+        z + Z_TEXT,
         spec,
     );
     drop(e);
@@ -893,6 +970,57 @@ mod tests {
         );
     }
 
+    /// Every bubble owns a frame LEVEL: its four pieces are one contiguous band, bands ascend
+    /// with rank, and no two bubbles can interleave. This is the whole 1504 fix — with a flat
+    /// per-piece key, every bubble's background painted under every bubble's text, so a speaker's
+    /// line bled across a neighbour's card.
+    #[test]
+    fn each_bubble_gets_its_own_level_band() {
+        // The four pieces of one bubble, in paint order, all inside one level.
+        const { assert!(Z_BG < Z_EDGE && Z_EDGE < Z_TAIL && Z_TAIL < Z_TEXT) };
+        const { assert!(Z_TEXT < overlay_z::BUBBLE_STRIDE) };
+        for rank in 0..8usize {
+            // ...and every piece strictly below the NEXT bubble's background.
+            assert!(level_z(rank) + Z_TEXT < level_z(rank + 1) + Z_BG);
+        }
+        assert!(level_z(1) > level_z(0), "later rank draws later");
+    }
+
+    /// The band is bounded: however many bubbles are live, none of them can reach the V-plates'
+    /// band above ([`crate::ui_pass::overlay_z`]) or the floating combat text's below.
+    #[test]
+    fn the_bubble_band_stays_between_its_neighbours() {
+        for rank in [0, 1, 1_000, usize::MAX] {
+            let z = level_z(rank);
+            assert!(z >= overlay_z::BUBBLE, "over the floating numbers");
+            assert!(z + Z_TEXT < overlay_z::VPLATE, "under the V-plates");
+        }
+    }
+
+    /// The stack order is the reference's: farthest camera distance first (so the nearest
+    /// speaker's bubble ends up on top), guid breaking an exact tie deterministically.
+    #[test]
+    fn the_stack_is_sorted_farthest_first() {
+        let at = |guid: u64, d2: f32| Pending {
+            guid,
+            entity: Entity::PLACEHOLDER,
+            seat: Vec2::ZERO,
+            viewport: Vec2::ONE,
+            cam_dist_sq: d2,
+            anchor: Vec3::ZERO,
+            unit_pos: Vec3::ZERO,
+        };
+        let mut p = vec![at(7, 25.0), at(3, 400.0), at(9, 1.0), at(2, 400.0)];
+        stack_sort(&mut p);
+        assert_eq!(
+            p.iter().map(|q| q.guid).collect::<Vec<_>>(),
+            vec![2, 3, 7, 9],
+            "farthest first; the 400-yd² pair ordered by guid"
+        );
+        // The rank the draw uses IS the frame level: the nearest speaker draws last.
+        assert!(level_z(0) < level_z(p.len() - 1));
+    }
+
     /// The border-unit lands the byte constants: 16 px at 1024-wide 4:3 (G44·16/(S·1024)
     /// nets width/64), damped past the plate knee like every other size.
     #[test]
diff --git a/crates/benilla-app/src/combat_text/mod.rs b/crates/benilla-app/src/combat_text/mod.rs
index 05eacc2a..7e569632 100644
--- a/crates/benilla-app/src/combat_text/mod.rs
+++ b/crates/benilla-app/src/combat_text/mod.rs
@@ -113,7 +113,7 @@ use bevy::prelude::*;
 use benilla_ui::script::{JustifyH, JustifyV, Outline};
 
 use crate::entities::{overhead_anchor, BoneAttach, OverheadFallback};
-use crate::ui_pass::{UiQuadAppend, UiQuads};
+use crate::ui_pass::{overlay_z, UiQuadAppend, UiQuads};
 use crate::ui_text::{layout_text_quads, FontSpec, Justify, UiFontAtlas};
 use benilla_world::view::WorldCamera;
 
@@ -158,8 +158,9 @@ pub(crate) struct WorldTexts(Vec<WorldText>);
 const MAX_PER_UNIT: usize = 4;
 
 /// World text draws beneath every scripted UI quad (the real client renders it in the world scene,
-/// under all UI): z 0 sorts first against the frame quads' packed strata keys.
-const Z_WORLD_TEXT: u64 = 0;
+/// under all UI) and beneath the other two append-lane systems: the append lane's bottom band
+/// ([`crate::ui_pass::overlay_z`]) sorts first against the frame quads' packed strata keys.
+const Z_WORLD_TEXT: u64 = overlay_z::WORLD_TEXT;
 
 /// Admit a spawn against the per-unit cap: the client scans the unit's 4 slots for the first
 /// NULL and **returns** when all are occupied — a hard drop, no eviction, no queue (`0x6c73f0`).
diff --git a/crates/benilla-app/src/cvars.rs b/crates/benilla-app/src/cvars.rs
index 1c41b60f..c7d703b6 100644
--- a/crates/benilla-app/src/cvars.rs
+++ b/crates/benilla-app/src/cvars.rs
@@ -31,7 +31,9 @@ use bevy::prelude::*;
 use crate::chat_bubble::BubbleConfig;
 use crate::minimap::MinimapZoom;
 use crate::nameplates::NameConfig;
-use crate::player::camera::{FollowStyle, LookConfig, ZoomLimit, MOUSE_SPEED_RANGE};
+use crate::player::camera::{
+    FollowConfig, FollowStyle, LookConfig, ZoomLimit, FOLLOW_SPEED_RANGE, MOUSE_SPEED_RANGE,
+};
 use crate::portrait::PaneRate;
 use crate::sound::SoundConfig;
 use crate::target::ClickConfig;
@@ -107,13 +109,22 @@ pub(crate) const REGISTERED: &[(&str, &str)] = &[
     // raised — because that IS benilla's shipped 30 yd ceiling, a knowing divergence from the
     // reference's registrar "1" that camera.rs has carried in prose since it was written.
     ("cameraDistanceMaxFactor", "2"),
-    // Camera Following Style (1493): 1.12's `cameraSmoothStyle` — the auto-follow that swings the
-    // camera back behind the character. Registered "1" = Smart, which is BOTH the reference's
-    // registrar default and the director's call; benilla behaved as "3" (Never) unconditionally
-    // until this row, so the knob is what un-freezes a camera that was frozen by design. The three
-    // values are the reference dropdown's own (UIOptionsFrameCameraDropDown: 1 Smart, 2 Always,
-    // 3 Never) — see `FollowStyle`.
+    // Camera Following Style (1493, re-pinned by 1502): 1.12's `cameraSmoothStyle` — the
+    // auto-return that swings the camera back behind the character. Registered "1" = Smart, which
+    // is BOTH the reference's registrar default (byte-verified: the argument is loaded from
+    // `[0x84f4f4]` -> "1" at the `0x50ba92` register site) and the director's call; benilla behaved
+    // as Never unconditionally until this row. The enum is the ENGINE's — 0 Never, 1 Smart,
+    // 2 Always — NOT the 1/2/3 the reference's own dropdown writes; see `FollowStyle`.
     ("cameraSmoothStyle", "1"),
+    // Its sibling selector (1502), also registered "1": the reference reads THIS style instead
+    // whenever the state mask contains Track or Fear — the externally-driven states — indexing the
+    // same matrices. No row on any 1.12 panel, here or there; the reader is the host.
+    ("cameraSmoothTrackingStyle", "1"),
+    // The auto-follow's rate (1502), °/s — 1.12's own AUTO_FOLLOW_SPEED slider
+    // (`UIOptionsFrameSliders`, 90..270 by 10), registered at the binary's "180.0" (`[0xbe1070]`).
+    // It sets the transition's DURATION (`|dyaw| / rate * factor`), so it is an average rate, not a
+    // slew. No row yet — the slider is a one-line follow-on now that the knob exists.
+    ("cameraYawSmoothSpeed", "180"),
     // Status Text (1140): 1.12's `statusBarText`, the "always show value / max on a status bar"
     // switch. **No host knob** — its consumer is Lua (TextStatusBar.xml, decision 1082, which was
     // written waiting for this key and reads it on every repaint). Default "0": the reference's
@@ -241,7 +252,7 @@ struct Knobs<'a> {
     minimap: &'a mut MinimapZoom,
     bubbles: &'a mut BubbleConfig,
     zoom: &'a mut ZoomLimit,
-    follow: &'a mut FollowStyle,
+    follow: &'a mut FollowConfig,
     video: &'a mut VideoConfig,
     pane_rate: &'a mut PaneRate,
 }
@@ -271,7 +282,14 @@ fn apply_to_knobs(name: &str, value: &str, knobs: &mut Knobs) -> bool {
         "cameradistancemaxfactor" => knobs.zoom.set_factor(v),
         // The three stops are 1 Smart / 2 Always / 3 Never; anything else reads as the registrar
         // default rather than as a dead camera (`FollowStyle::from_cvar`).
-        "camerasmoothstyle" => *knobs.follow = FollowStyle::from_cvar(v),
+        "camerasmoothstyle" => knobs.follow.style = FollowStyle::from_cvar(v),
+        // Its sibling selector — the one the reference swaps in for the externally-driven states.
+        "camerasmoothtrackingstyle" => knobs.follow.tracking_style = FollowStyle::from_cvar(v),
+        // The auto-follow rate, clamped to 1.12's own AUTO_FOLLOW_SPEED slider range.
+        "camerayawsmoothspeed" => {
+            knobs.follow.yaw_speed =
+                v.clamp(*FOLLOW_SPEED_RANGE.start(), *FOLLOW_SPEED_RANGE.end());
+        }
         // The 1.12 slider's own range; an off-grid hand-edit rides between stops, like the others.
         "mousespeed" => {
             knobs.look.sensitivity = v.clamp(*MOUSE_SPEED_RANGE.start(), *MOUSE_SPEED_RANGE.end());
@@ -332,7 +350,7 @@ fn load_config(
     mut minimap: ResMut<MinimapZoom>,
     mut bubbles: ResMut<BubbleConfig>,
     mut zoom: ResMut<ZoomLimit>,
-    mut follow: ResMut<FollowStyle>,
+    mut follow: ResMut<FollowConfig>,
     mut video: ResMut<VideoConfig>,
     mut pane_rate: ResMut<PaneRate>,
 ) {
@@ -427,7 +445,7 @@ fn sync_cvars(
     mut minimap: ResMut<MinimapZoom>,
     mut bubbles: ResMut<BubbleConfig>,
     mut zoom: ResMut<ZoomLimit>,
-    mut follow: ResMut<FollowStyle>,
+    mut follow: ResMut<FollowConfig>,
     mut video: ResMut<VideoConfig>,
     mut pane_rate: ResMut<PaneRate>,
 ) {
@@ -449,7 +467,7 @@ fn sync_cvars(
         );
         script.register_cvars(REGISTERED.iter().copied());
         let flag = |b: bool| if b { "1" } else { "0" }.to_string();
-        let session: [(&str, String); 26] = [
+        let session: [(&str, String); 28] = [
             ("MasterVolume", sound.master.to_string()),
             ("SoundVolume", sound.sfx.to_string()),
             ("MusicVolume", sound.music.to_string()),
@@ -464,7 +482,12 @@ fn sync_cvars(
             ("mouseInvertPitch", flag(look.invert_pitch)),
             ("mousespeed", look.sensitivity.to_string()),
             ("cameraDistanceMaxFactor", zoom.factor().to_string()),
-            ("cameraSmoothStyle", follow.cvar().to_string()),
+            ("cameraSmoothStyle", follow.style.cvar().to_string()),
+            (
+                "cameraSmoothTrackingStyle",
+                follow.tracking_style.cvar().to_string(),
+            ),
+            ("cameraYawSmoothSpeed", follow.yaw_speed.to_string()),
             ("autoLootDefault", flag(loot.auto_loot)),
             ("UnitNamePlayer", flag(names.player)),
             ("UnitNameNPC", flag(names.npc)),
@@ -548,7 +571,7 @@ pub(crate) fn fold_dying_vm_cvars(world: &mut World) {
         Option<ResMut<MinimapZoom>>,
         Option<ResMut<BubbleConfig>>,
         Option<ResMut<ZoomLimit>>,
-        Option<ResMut<FollowStyle>>,
+        Option<ResMut<FollowConfig>>,
         Option<ResMut<VideoConfig>>,
         Option<ResMut<PaneRate>>,
     )> = bevy::ecs::system::SystemState::new(world);
@@ -756,13 +779,19 @@ mod tests {
         );
         assert_eq!(d["mousespeed"], LookConfig::default().sensitivity);
         assert_eq!(d["cameraDistanceMaxFactor"], ZoomLimit::default().factor());
-        // The following style (1493) welds to the enum's own Default — and BOTH sides are the
-        // reference's registrar "1" = Smart, the one row in this arc that agrees with the binary
-        // outright.
+        // The follow trio (1493/1502) welds to FollowConfig's own defaults — and all three ARE
+        // the binary's registrar values, byte-verified: "1"/"1"/"180.0". The one corner of this
+        // arc that agrees with the reference outright.
+        let follow = FollowConfig::default();
         assert_eq!(
             d["cameraSmoothStyle"],
-            FollowStyle::default().cvar().parse::<f32>().unwrap()
+            follow.style.cvar().parse::<f32>().unwrap()
         );
+        assert_eq!(
+            d["cameraSmoothTrackingStyle"],
+            follow.tracking_style.cvar().parse::<f32>().unwrap()
+        );
+        assert_eq!(d["cameraYawSmoothSpeed"], follow.yaw_speed);
         assert_eq!(FollowStyle::default(), FollowStyle::Smart);
         assert_eq!(d["autoLootDefault"] != 0.0, LootConfig::default().auto_loot);
         // The name trio (0992) welds to NameConfig's defaults the same way.
@@ -810,7 +839,7 @@ mod tests {
         let mut minimap = MinimapZoom::default();
         let mut bubbles = BubbleConfig::default();
         let mut zoom = ZoomLimit::default();
-        let mut follow = FollowStyle::default();
+        let mut follow = FollowConfig::default();
         let mut video = VideoConfig::default();
         let mut pane_rate = PaneRate::default();
         let mut knobs = Knobs {
@@ -851,14 +880,25 @@ mod tests {
         assert_eq!(knobs.look.sensitivity, 1.4);
         assert!(apply_to_knobs("mousespeed", "9", &mut knobs));
         assert_eq!(knobs.look.sensitivity, 1.5);
-        // The following style lands as the enum, on the reference's own numbering — and an
-        // off-grid value reads as the registrar default rather than as a dead camera.
-        assert!(apply_to_knobs("cameraSmoothStyle", "3", &mut knobs));
-        assert_eq!(*knobs.follow, FollowStyle::Never);
-        assert!(apply_to_knobs("camerasmoothstyle", "2", &mut knobs));
-        assert_eq!(*knobs.follow, FollowStyle::Always);
+        // The following style lands as the ENGINE's enum (0 Never / 1 Smart / 2 Always), and the
+        // "3" the reference's own dropdown writes for Never still means Never.
         assert!(apply_to_knobs("cameraSmoothStyle", "0", &mut knobs));
-        assert_eq!(*knobs.follow, FollowStyle::Smart);
+        assert_eq!(knobs.follow.style, FollowStyle::Never);
+        assert!(apply_to_knobs("camerasmoothstyle", "2", &mut knobs));
+        assert_eq!(knobs.follow.style, FollowStyle::Always);
+        assert!(apply_to_knobs("cameraSmoothStyle", "3", &mut knobs));
+        assert_eq!(knobs.follow.style, FollowStyle::Never);
+        assert!(apply_to_knobs("cameraSmoothStyle", "1", &mut knobs));
+        assert_eq!(knobs.follow.style, FollowStyle::Smart);
+        // Its two siblings land on the same knob — the tracking selector, and the rate, which
+        // clamps to 1.12's AUTO_FOLLOW_SPEED slider range.
+        assert!(apply_to_knobs("cameraSmoothTrackingStyle", "2", &mut knobs));
+        assert_eq!(knobs.follow.tracking_style, FollowStyle::Always);
+        assert_eq!(knobs.follow.style, FollowStyle::Smart, "and only that one");
+        assert!(apply_to_knobs("cameraYawSmoothSpeed", "270", &mut knobs));
+        assert_eq!(knobs.follow.yaw_speed, 270.0);
+        assert!(apply_to_knobs("cameraYawSmoothSpeed", "9000", &mut knobs));
+        assert_eq!(knobs.follow.yaw_speed, *FOLLOW_SPEED_RANGE.end());
         // The max-orbit factor lands as YARDS on the knob (base 15 x factor), clamped to 1..2.
         assert!(apply_to_knobs("cameraDistanceMaxFactor", "1", &mut knobs));
         assert_eq!(knobs.zoom.max, 15.0);
@@ -953,7 +993,7 @@ mod tests {
             .init_resource::<MinimapZoom>()
             .init_resource::<BubbleConfig>()
             .init_resource::<ZoomLimit>()
-            .init_resource::<FollowStyle>()
+            .init_resource::<FollowConfig>()
             .init_resource::<VideoConfig>()
             .init_resource::<PaneRate>()
             .add_plugins(CvarPlugin);
@@ -1024,7 +1064,7 @@ mod tests {
             .init_resource::<MinimapZoom>()
             .init_resource::<BubbleConfig>()
             .init_resource::<ZoomLimit>()
-            .init_resource::<FollowStyle>()
+            .init_resource::<FollowConfig>()
             .init_resource::<VideoConfig>()
             .init_resource::<PaneRate>()
             .add_plugins(CvarPlugin);
diff --git a/crates/benilla-app/src/dev.rs b/crates/benilla-app/src/dev.rs
index 084b0b6b..63f6fba3 100644
--- a/crates/benilla-app/src/dev.rs
+++ b/crates/benilla-app/src/dev.rs
@@ -203,6 +203,13 @@ impl Plugin for DevProbesPlugin {
             if std::env::var("WOW_DRESS_CENSUS").is_ok() {
                 app.add_plugins(crate::capture::DressCensusPlugin);
             }
+            // The reveal audit: `WOW_REVEAL=<frames>` prints one line per frame from a snap —
+            // the cover, every residency term behind `presentable()`, the settle hold and the
+            // retained pass's collected-vs-published regions. The instrument for "the teleport
+            // showed me a world with no buildings in it" (see `capture::RevealAuditPlugin`).
+            if std::env::var("WOW_REVEAL").is_ok() {
+                app.add_plugins(crate::capture::RevealAuditPlugin);
+            }
             // The entity census: `WOW_ENTITY_CENSUS=<secs>` prints per-archetype entity counts once —
             // what the resident entity count is made of (see `capture::EntityCensusPlugin`).
             if std::env::var("WOW_ENTITY_CENSUS").is_ok() {
diff --git a/crates/benilla-app/src/loading_screen.rs b/crates/benilla-app/src/loading_screen.rs
index 0ce214b6..3f2340ad 100644
--- a/crates/benilla-app/src/loading_screen.rs
+++ b/crates/benilla-app/src/loading_screen.rs
@@ -69,6 +69,14 @@ const CLEAR_AFTER_READY_FRAMES: u32 = 3;
 /// nothing extra.
 const WAIT_LOG_AFTER: f32 = 3.0;
 const WAIT_LOG_EVERY: f32 = 2.0;
+/// How far a same-map snap must move the body before its destination is treated as a **load** at
+/// all (yards). Under this, a teleport cannot outrun the streamer — the ground and buildings you
+/// land on are the ones you left — and the raise below would only be able to flash a cover over
+/// content that happened to be arriving anyway. Sized to clear every *combat* relocation with
+/// room to spare (charge/intercept 25 yd, blink 20 yd, the knockbacks under 30), because those
+/// end in a server teleport too and a black screen mid-fight is the one thing this must never
+/// do; the reported case — `.tele` across a city — is 458 yd.
+const SNAP_LOAD_MIN_YD: f32 = 100.0;
 
 /// Bevy resource wrapper around the format-crate [`LoadingScreenCatalog`] (the `LoadingScreenID` → BLP
 /// path table). Paired with [`MapCatalogRes`] (the `mapId` → `LoadingScreenID` FK) to resolve art.
@@ -109,6 +117,10 @@ pub(crate) struct LoadingScreen {
     /// [`WAIT_LOG_AFTER`]).
     active_since: f32,
     last_wait_log: f32,
+    /// The avatar's position as of LAST frame — so a snap's own displacement is knowable here
+    /// (the snap is applied in `Input`, a stage before this one). Read only by the snap raise
+    /// below, which uses it to tell a relocation from a spell's little hop.
+    last_pos: Option<Vec3>,
 }
 
 impl LoadingScreen {
@@ -385,7 +397,8 @@ fn drive_loading_screen(
     for w in worldports.read() {
         screen.raise("worldport", false, Some(w.map_id), now);
     }
-    if teleports.read().next().is_some() {
+    let teleported = teleports.read().next().is_some();
+    if teleported {
         screen.awaiting_snap = false;
         screen.pending_map = None;
     }
@@ -437,6 +450,34 @@ fn drive_loading_screen(
         screen.raise("focus not resident", false, None, now);
     }
 
+    // --- …and the same test at the SNAP, on everything the reveal actually needs. The backstop
+    // above watches one term — the focus TERRAIN tile — and a teleport inside the streamer's keep
+    // band (up to ~1600 yd, three tiles) lands on ground that is already resident, so it never
+    // fires. The destination's *buildings* are a different question: their placements may still be
+    // spawning, and since the retained pass (1429) a spawned building still has a bake between it
+    // and the screen. That is how `.tele` across a city put the player down in a Stormwind with no
+    // Stormwind in it, uncovered, for the frames it took to arrive.
+    //
+    // Only at a snap, and only against the same predicate that CLEARS the screen: a summon across
+    // a room whose world is already there raises nothing (no flash), and ordinary walking — which
+    // crosses tile lines with placements pending all day — is not a snap and cannot reach this. ---
+    let body = player.as_ref().map(|p| p.pos);
+    let relocated = match (teleported, screen.last_pos, body) {
+        (true, Some(was), Some(now_pos)) => was.distance(now_pos) >= SNAP_LOAD_MIN_YD,
+        // No previous position to compare (the entry frame): treat the snap as a relocation, the
+        // conservative arm — a covered load is recoverable, a naked one is what this closes.
+        (true, _, _) => true,
+        _ => false,
+    };
+    screen.last_pos = body;
+    if relocated
+        && !screen.active
+        && *state.get() == crate::char_select::ClientState::InWorld
+        && !(progress.is_ready() && progress.presentable())
+    {
+        screen.raise("teleport, destination not presentable", false, None, now);
+    }
+
     // --- Clear: the destination snap has landed, the scene is presentable (tiles + focus
     // placements + colliders — [`WorldLoadProgress::presentable`]), and the physics hold is done,
     // sustained a few frames. ---
diff --git a/crates/benilla-app/src/pipe_warm/mod.rs b/crates/benilla-app/src/pipe_warm/mod.rs
index 7d49c75b..85225680 100644
--- a/crates/benilla-app/src/pipe_warm/mod.rs
+++ b/crates/benilla-app/src/pipe_warm/mod.rs
@@ -290,6 +290,16 @@ pub(crate) struct WarmPass {
     effect_tex: Option<Handle<Image>>,
     /// Consecutive covered+in-world frames seen while idle (see [`WARM_COVER_PRESENT_FRAMES`]).
     covered_frames: u32,
+    /// **The menagerie has drained cleanly once in this process.** The warm set is a fixed
+    /// variant cross built from `Startup`-populated stores (see `menagerie`) — not the resident
+    /// map's art — and `PipelineCache` is process-global and never evicts, so a second pass
+    /// compiles nothing. Re-running it under every later cover was pure cost, and *visible*
+    /// cost: it holds the cover (`satisfied`) for the whole paced reveal, which measured 3.8 s
+    /// on a mid-session teleport whose world was resident in 0.7 s. Later covers therefore skip
+    /// the pass. If that is ever wrong the tripwire says so out loud — `PipeWatch`'s "compiled
+    /// LIVE" warn is exactly the instrument for it — which is why this can be a latch and not a
+    /// guess. A timeout does NOT latch it: something was still pending.
+    warmed_once: bool,
     /// Pacing state (1116): rigs warmed so far, when the last slice went out, how many frames
     /// the reveal spanned, and the slice currently on screen (hidden again next frame).
     revealed: usize,
@@ -410,6 +420,11 @@ fn run_warm_pass(
         return;
     }
     let now = time.elapsed_secs();
+    // Already warmed in this process: nothing to compile, so nothing to hold the cover for.
+    if warm.warmed_once {
+        warm.done = true;
+        return;
+    }
     let Some(spawned) = warm.spawned_at else {
         // The cover just rose (or the world just became live under one): raise the gate and
         // spawn the menagerie once the camera + shared light exist (both are entry-frame-early;
@@ -507,6 +522,7 @@ fn run_warm_pass(
         .saturating_sub(watch.0.settled.load(Ordering::Relaxed));
     if all_revealed && pending == 0 && now - last_reveal >= WARM_SETTLE_SECS {
         warm.done = true;
+        warm.warmed_once = true;
         warm.effect_tex = None;
         despawn_rigs(&mut commands, &rigs);
         info!(
diff --git a/crates/benilla-app/src/player.rs b/crates/benilla-app/src/player.rs
index 085e2a31..147afbbe 100644
--- a/crates/benilla-app/src/player.rs
+++ b/crates/benilla-app/src/player.rs
@@ -189,7 +189,7 @@ impl Plugin for PlayerPlugin {
         );
         app.init_resource::<camera::LookConfig>();
         app.init_resource::<camera::ZoomLimit>();
-        app.init_resource::<camera::FollowStyle>();
+        app.init_resource::<camera::FollowConfig>();
         // Far sight: resolve `PLAYER_FARSIGHT` into a pose before `control` reads it to seat the
         // camera. A separate system rather than another query on `control` for a hard reason —
         // `control` already holds the self entity's `Transform` mutably, so it cannot also read an
@@ -351,7 +351,7 @@ fn control(
         Res<AccumulatedMouseMotion>,
         Res<camera::LookConfig>,
         Res<camera::ZoomLimit>,
-        Res<camera::FollowStyle>,
+        Res<camera::FollowConfig>,
     ),
     // The net bridge, bundled into one param (16-param limit): the outbound command channel + the
     // inbound teleport/worldport messages `apply_net_updates` wrote earlier this frame
@@ -493,15 +493,24 @@ fn control(
     let view_subject = &speed_capsule.8;
     let self_guid = speed_capsule.9 .0;
     let scoped = &speed_capsule.10;
-    // The auto-follow style (decision 1493), with far sight's one exception folded in here so both
-    // camera seats below agree: while the rig orbits somebody ELSE's body (Mind Vision, Sentry
-    // Totem), our own facing is not what "behind" means, so the chase is forced off rather than
+    // The auto-follow knobs (decisions 1493/1502), with far sight's one exception folded in here so
+    // both camera seats below agree: while the rig orbits somebody ELSE's body (Mind Vision, Sentry
+    // Totem), our own facing is not what "behind" means, so the return is forced off rather than
     // reeling that camera toward a heading with nothing to do with the view.
-    let follow_style = if view_subject.remote.is_some() {
-        camera::FollowStyle::Never
-    } else {
-        *pointer.3
+    let follow_cfg = camera::FollowConfig {
+        style: if view_subject.remote.is_some() {
+            camera::FollowStyle::Never
+        } else {
+            pointer.3.style
+        },
+        tracking_style: if view_subject.remote.is_some() {
+            camera::FollowStyle::Never
+        } else {
+            pointer.3.tracking_style
+        },
+        ..*pointer.3
     };
+
     let dt = time.delta_secs();
     // While a focused UI EditBox (the chat input, a mail field) owns the keyboard, keyboard reads see
     // "no keys held" — so the avatar isn't also driven while typing (a `.tele` command). Mouse still
@@ -522,6 +531,61 @@ fn control(
     let both_buttons =
         (buttons.pressed(MouseButton::Left) && buttons.pressed(MouseButton::Right)) || steer_held;
 
+    // The camera's **input command word** (decision 1502) — 1.12's `[InputControl+0x4]`, bit for
+    // bit. The auto-follow is armed by *edges on this word* and its state is classified from it, so
+    // it is built once here, from the same binding state the movement code below reads, and handed
+    // to both camera seats. MOVEANDSTEER sets both mouse bits because that is what the reference's
+    // binding does — it runs the identical CameraOrSelectOrMove + TurnOrAction pair.
+    let follow_command = {
+        use camera::follow_cmd as bit;
+        let mut w = 0;
+        let mut set = |on: bool, b: u32| {
+            if on {
+                w |= b;
+            }
+        };
+        set(
+            buttons.pressed(MouseButton::Right) || steer_held,
+            bit::RIGHT_MOUSE,
+        );
+        set(
+            buttons.pressed(MouseButton::Left) || steer_held,
+            bit::LEFT_MOUSE,
+        );
+        // `/follow` is the forward bit in the reference too — the same setter the W key drives
+        // (decision 0890), so it arms the camera exactly like a held W.
+        set(
+            binds.pressed(crate::bindings::cmd::MOVE_FORWARD) || player.follow_forward,
+            bit::FORWARD,
+        );
+        set(
+            binds.pressed(crate::bindings::cmd::MOVE_BACKWARD),
+            bit::BACKWARD,
+        );
+        set(
+            binds.pressed(crate::bindings::cmd::STRAFE_LEFT),
+            bit::STRAFE_LEFT,
+        );
+        set(
+            binds.pressed(crate::bindings::cmd::STRAFE_RIGHT),
+            bit::STRAFE_RIGHT,
+        );
+        set(
+            binds.pressed(crate::bindings::cmd::TURN_LEFT),
+            bit::TURN_LEFT,
+        );
+        set(
+            binds.pressed(crate::bindings::cmd::TURN_RIGHT),
+            bit::TURN_RIGHT,
+        );
+        set(player.autorun, bit::AUTORUN);
+        // The two externally-driven flags, which the reference folds into the camera's own
+        // Track/Fear bits rather than the input word — carried here so one word carries every edge.
+        set(player.server_riding, bit::TRACK);
+        set(player.control_lost, bit::FEAR);
+        w
+    };
+
     // The look session gets a SHADOW copy of `CursorOptions`, written back only on a real change:
     // handing it the component's `Mut` directly reborrowed mutably every frame, which marks it
     // Changed regardless of writes — and bevy_winit's `changed_cursor_options` then re-applied
@@ -733,16 +797,9 @@ fn control(
             // `reseat` window is excluded — there the resource still describes the body we are
             // letting go of, and `apply_server_moves` owns the adoption.
             //
-            // The same sync answers the auto-follow's Smart gate (1493): is the body we are NOT
-            // driving nevertheless moving? A taxi, a Charge, a knockback or a fear all translate
-            // the avatar while the controller stands down, and a camera that ignored them would
-            // sit at the angle you left it while the body ran out from under it. A spline ride is
-            // translation by definition; a driven body is measured against the pose we held.
-            let mut driven_moving = player.server_riding;
             if player.control_lost && !player.reseat {
                 if let Ok((_, t, ..)) = body.single() {
                     let yaw = server_ride::yaw_of(t.rotation);
-                    driven_moving |= t.translation.distance_squared(player.pos) > 1.0e-6;
                     player.pos = t.translation;
                     player.face_yaw = yaw;
                     player.model_yaw = yaw;
@@ -772,10 +829,15 @@ fn control(
                 &mut cam_t,
                 &collide,
                 cam_probe,
+                // The auto-follow still runs here — a taxi, a Charge, a knockback or a fear
+                // all translate the avatar while the controller stands down, and the reference
+                // has states for exactly those (`Track`, `Fear`: a 0.4 s delay and a lazy 18 °/s
+                // return under Smart). The word carries both flags, so the edge into and out of
+                // one of them is what arms it.
                 &camera::FollowInput {
-                    style: follow_style,
+                    cfg: follow_cfg,
                     face_yaw: player.face_yaw,
-                    moving: driven_moving,
+                    command: follow_command,
                 },
             );
             // Flush a stale run once, so observers stop extrapolating it — but never under a ride,
@@ -1706,12 +1768,12 @@ fn control(
         // — the deck's yaw delta was already applied to `cam.yaw` at the ride block (frame motion
         // carries the camera unconditionally; only input turns respect `seat_camera`'s
         // look-session gate).
-        // The auto-follow's own three facts (decision 1493): the player's style, where "behind"
-        // is, and whether the character is translating — Smart's gate.
+        // The auto-follow's own three facts (decisions 1493/1502): the knobs, where "behind" is,
+        // and the input word whose edges arm a return.
         let follow = camera::FollowInput {
-            style: follow_style,
+            cfg: follow_cfg,
             face_yaw: player.face_yaw,
-            moving,
+            command: follow_command,
         };
         seat_camera(
             dt,
diff --git a/crates/benilla-app/src/player/camera.rs b/crates/benilla-app/src/player/camera.rs
index 18a5e7f9..c186806d 100644
--- a/crates/benilla-app/src/player/camera.rs
+++ b/crates/benilla-app/src/player/camera.rs
@@ -195,43 +195,65 @@ impl LookConfig {
         LOOK_SENSITIVITY * self.sensitivity
     }
 }
-/// The auto-follow's angular rate — 1.12's `cameraYawSmoothSpeed`, whose registrar default is
-/// **180 °/s** (`WoW.exe` `[0xbe1070]`, the yaw transition channel's own CVar float — wow-re
-/// `ui/scratch/camera-control.md`). The reference exposes it as the AUTO_FOLLOW_SPEED slider
-/// (`UIOptionsFrameSliders`, 90 … 270 °/s by 10) and *disables that slider* when the style is
-/// Never; benilla ships the registrar default as a constant, since it has no row for it yet.
-const FOLLOW_RATE: f32 = std::f32::consts::PI;
+/// The auto-follow's angular rate — 1.12's `cameraYawSmoothSpeed`, registrar default **180 °/s**
+/// (`WoW.exe` `[0xbe1070]`, read at `0x512d75`). It is not a slew rate but a *duration* divisor:
+/// the transition below lasts `|Δyaw| / rate × factor`, so 180 °/s is the **average** rate at
+/// factor 1, and the cosine profile peaks at π/2 × that. 1.12 exposes it as the AUTO_FOLLOW_SPEED
+/// slider (`UIOptionsFrameSliders`, 90 … 270 by 10), disabled while the style is Never.
+pub(crate) const FOLLOW_SPEED_DEFAULT: f32 = 180.0;
+/// The 1.12 slider's own range for [`FollowConfig::yaw_speed`].
+pub(crate) const FOLLOW_SPEED_RANGE: std::ops::RangeInclusive<f32> = 90.0..=270.0;
+/// `cameraSmoothTimeMin`/`Max` — the transition's duration floor and ceiling, **VERIFIED
+/// 0.1 s / 2.0 s** (`[0xbe105c]`/`[0xbe1038]`, clamped at `0x510f4d`). These are why the felt
+/// rate is *not* 180 °/s at the ends: a 5° correction still takes 0.1 s, and a lazy `Track`
+/// return (factor 10) is capped at 2 s however far it has to come.
+const FOLLOW_TIME_MIN: f32 = 0.1;
+const FOLLOW_TIME_MAX: f32 = 2.0;
+/// The "already there / already arming this" epsilon — the reference's own `0.001`
+/// (`[0x801360]`, `0x512ce4`/`0x512d41`). A float-equality guard, not a perceptible deadzone.
+const FOLLOW_EPS: f32 = 1.0e-3;
 
-/// **Camera Following Style** — 1.12's `cameraSmoothStyle` (decision 1493): does the camera swing
-/// back behind the character on its own?
+/// **Camera Following Style** — 1.12's `cameraSmoothStyle` (decisions 1493/1502): does the camera
+/// return to behind the character on its own?
 ///
 /// benilla shipped the reference behaviour *removed* from the day the camera was written (the
-/// orbit offset simply persisted, a director's call) — this is the setting that gives it back, and
-/// the director's call now is the reference's own default: **Smart**.
+/// orbit offset simply persisted, a director's call) — this is the setting that gives it back, at
+/// the reference's own default: **Smart**.
 ///
-/// The three values are the reference's, dropdown order and all (`UIOptionsFrameCameraDropDown`,
-/// which writes this CVar): `"1"` Smart, `"2"` Always, `"3"` Never — note that Never is **3**, not
-/// 0. The registrar default is `"1"`.
-#[derive(Resource, Clone, Copy, PartialEq, Eq, Debug, Default)]
+/// **The enum is the ENGINE's, `0 = Never · 1 = Smart · 2 = Always`** — byte-verified twice over
+/// (wow-re `ui/scratch/camera-smooth-style.md` §2: the registration loop walks
+/// `{"Never","Smart","Always"}` filling three blocks in order, and both consumers index by
+/// `style × stride`). 1.12's own *dropdown* writes `1/2/3` instead (`UIOptionsFrameCameraDropDown`
+/// — Smart 1, Always 2, Never **3**), and 3 is not a style at all: the validator accepts it
+/// (`0x50b330(v, 0, 3)`) but the terrain-tilt consumer does not bound-check and indexes 360 bytes
+/// past its table. So the reference's shipped UI writes an out-of-range value for Never, and a
+/// client must clamp to 0..2. We do: our own dropdown writes the engine's numbers, and a stray
+/// `3` is *read* as Never — what whoever wrote it meant.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
 pub(crate) enum FollowStyle {
-    /// Stay where placed, *except while the character is moving* — the reference's own
+    /// Never auto-adjust: the orbit offset stays exactly where the hand left it. This is what
+    /// benilla did unconditionally before 1493. It does **not** stop the rigid keyboard-turn
+    /// carry — in the reference that is a different mechanism entirely (the camera yaw is stored
+    /// *relative* to the followed unit's facing), and Never leaves it running.
+    Never,
+    /// Stay where placed, *except* while the character is being driven — the reference's own
     /// "(Recommended Mode)" and its registrar default.
     #[default]
     Smart,
-    /// Always prefer being behind the character.
+    /// Always prefer being behind the character: every input edge arms a return, standing still
+    /// included.
     Always,
-    /// Never auto-adjust: the orbit offset stays exactly where the hand left it. This is what
-    /// benilla did unconditionally before 1493.
-    Never,
 }
 
 impl FollowStyle {
-    /// From the CVar's number. Anything off the three stops reads as the registrar default —
-    /// a hand-edited config or an addon's stray write gets the shipped behaviour, not a dead
-    /// camera.
+    /// From the CVar's number. `3` is the shipped-UI's Never (see the type doc); anything else off
+    /// the ladder reads as the registrar default rather than as a dead camera.
     pub(crate) fn from_cvar(v: f32) -> Self {
         match v as i32 {
+            0 => Self::Never,
             2 => Self::Always,
+            // The 1.12 dropdown's own Never. Out of range for the engine's tables — accepted here
+            // because a config or addon carrying it means Never, not "surprise me".
             3 => Self::Never,
             _ => Self::Smart,
         }
@@ -240,47 +262,292 @@ impl FollowStyle {
     /// The CVar string this style is — the value the table and `config.toml` carry.
     pub(crate) fn cvar(self) -> &'static str {
         match self {
+            Self::Never => "0",
             Self::Smart => "1",
             Self::Always => "2",
-            Self::Never => "3",
         }
     }
 
-    /// Should the camera chase the character's facing this frame? `moving` is the character's own
-    /// translation intent (Smart's gate — the reference's "except when your character is moving").
-    fn chases(self, moving: bool) -> bool {
+    /// The `cameraSmooth<Style><State>{Delay,Factor}` row — family A at `[0xbe0e70]`, dumped at
+    /// its defaults in wow-re `camera-smooth-style.md` §3. Factor `0` means *cancel*: the armed
+    /// transition is dropped and the camera keeps the offset it has.
+    ///
+    /// Family B (`cameraSmoothViewData<Style>Yaw{Delay,Factor}`) multiplies in: its Yaw factor is
+    /// `1.0` under Smart and Always and `0.0` under Never, and its delay is `0.0` at every style —
+    /// so for the yaw channel the composition is the identity and the table below is the answer.
+    fn row(self, state: FollowState) -> (f32, f32) {
         match self {
-            Self::Always => true,
-            Self::Smart => moving,
-            Self::Never => false,
+            // Every row is 0/0 — and family B's Never Yaw factor is 0.0 as well, twice over.
+            Self::Never => (0.0, 0.0),
+            Self::Smart => match state {
+                // The two states that make Smart *smart*: nothing returns while you stand or stop.
+                FollowState::Idle | FollowState::Stop => (0.0, 0.0),
+                // Driven from outside (a taxi, a spline, a fear): a lazy return — 0.4 s of delay
+                // and factor 10, which is 18 °/s of average rate before the 2 s cap bites.
+                FollowState::Track | FollowState::Fear => (0.4, 10.0),
+                FollowState::Move | FollowState::Strafe | FollowState::Turn => (0.0, 1.0),
+            },
+            // Always is factor 1.0 in every state, Idle and Stop included.
+            Self::Always => (0.0, 1.0),
         }
     }
 }
 
-/// What [`seat_camera`] needs to run the auto-follow this frame — the style, where "behind" is,
-/// and whether the character is moving. Bundled because the three are one question, and
+/// The seven arming states of 1.12's auto-return classifier (`0x510960`, wow-re
+/// `camera-smooth-style.md` §6.2), **in the reference's own priority order — highest first**. The
+/// winner is the highest-priority bit set, and the states are read off the *camera's* input
+/// command word, not off the character's velocity: right-mouse alone is a `Turn`, a turn key
+/// under right-mouse is a `Strafe`, and both mouse buttons are a `Move`.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(super) enum FollowState {
+    /// Driven by something that is not us and is not a spline — the reference's external-control
+    /// flag `[cam+0x90] & 0x1000`.
+    Fear,
+    Turn,
+    Strafe,
+    Move,
+    /// Externally-driven movement (taxi / server spline) — `[cam+0x90] & 0x100`.
+    Track,
+    /// This edge released a movement input (the reference's `stopping` argument). Carries the same
+    /// `(0, 0)` / `(0, 1)` rows as [`FollowState::Idle`] at every shipped style, so the two are
+    /// currently indistinguishable in behaviour — kept apart because the *matrix* keeps them apart.
+    Stop,
+    Idle,
+}
+
+/// The camera's input command word — 1.12's `[InputControl+0x4]` bit for bit (wow-re
+/// `camera-smooth-style.md` §6.1), because the state classifier and the *edge* that arms a
+/// transition are both defined on it. benilla has no PitchUp/PitchDown bindings, so those two bits
+/// are simply never set.
+pub(super) mod follow_cmd {
+    /// `TurnOrAction` — right mouse / mouselook.
+    pub(in crate::player) const RIGHT_MOUSE: u32 = 0x1;
+    /// `CameraOrSelectOrMove` — left mouse.
+    pub(in crate::player) const LEFT_MOUSE: u32 = 0x2;
+    pub(in crate::player) const FORWARD: u32 = 0x10;
+    pub(in crate::player) const BACKWARD: u32 = 0x20;
+    pub(in crate::player) const STRAFE_LEFT: u32 = 0x40;
+    pub(in crate::player) const STRAFE_RIGHT: u32 = 0x80;
+    pub(in crate::player) const TURN_LEFT: u32 = 0x100;
+    pub(in crate::player) const TURN_RIGHT: u32 = 0x200;
+    pub(in crate::player) const AUTORUN: u32 = 0x1000;
+    /// The union of bits 20/21/23, which the reference folds into the camera's `Track` flag —
+    /// externally-driven movement.
+    pub(in crate::player) const TRACK: u32 = 0x100000;
+    /// External control (the reference's own `[cam+0x90] & 0x1000`, not an InputControl bit —
+    /// carried here so one word carries every edge the arming function reacts to).
+    pub(in crate::player) const FEAR: u32 = 0x2000_0000;
+
+    /// The bits `Move` reads: forward, backward, autorun.
+    pub(in crate::player) const MOVE_BITS: u32 = FORWARD | BACKWARD | AUTORUN;
+    pub(in crate::player) const STRAFE_BITS: u32 = STRAFE_LEFT | STRAFE_RIGHT;
+    pub(in crate::player) const TURN_BITS: u32 = TURN_LEFT | TURN_RIGHT;
+}
+
+/// The knobs behind the auto-follow (decision 1502) — the style, the style the *externally-driven*
+/// states use instead, and the rate. All three are 1.12 CVars with the reference's own defaults.
+#[derive(Resource, Clone, Copy, PartialEq, Debug)]
+pub(crate) struct FollowConfig {
+    /// `cameraSmoothStyle`.
+    pub(crate) style: FollowStyle,
+    /// `cameraSmoothTrackingStyle` — the selector the reference swaps in when the state mask so
+    /// much as *contains* `Track` or `Fear` (`0x510a51 test bl,0x44`, before the priority scan),
+    /// indexing the very same matrices. Registrar default `"1"` = Smart, like its sibling.
+    pub(crate) tracking_style: FollowStyle,
+    /// `cameraYawSmoothSpeed`, °/s — see [`FOLLOW_SPEED_DEFAULT`].
+    pub(crate) yaw_speed: f32,
+}
+
+impl Default for FollowConfig {
+    fn default() -> Self {
+        Self {
+            style: FollowStyle::default(),
+            tracking_style: FollowStyle::default(),
+            yaw_speed: FOLLOW_SPEED_DEFAULT,
+        }
+    }
+}
+
+/// What [`seat_camera`] needs to run the auto-follow this frame: the knobs, where "behind" is, and
+/// the input word whose *edges* arm a return. Bundled because they are one question, and
 /// `seat_camera` is already at its argument ceiling.
 pub(super) struct FollowInput {
-    pub(super) style: FollowStyle,
+    pub(super) cfg: FollowConfig,
     /// The character's own facing (same yaw convention as [`FlyCam::yaw`] — a right-drag couples
-    /// the two directly).
+    /// the two directly), so the camera's *offset* is `cam.yaw − face_yaw`.
     pub(super) face_yaw: f32,
-    /// Is the character translating this frame? (Turn-in-place is not movement here: a keyboard
-    /// turn already carries the camera rigidly, so there is no offset left for the chase.)
-    pub(super) moving: bool,
+    /// This frame's [`follow_cmd`] word.
+    pub(super) command: u32,
 }
 
 impl FollowInput {
-    /// The yaw this frame's chase adds — the shortest arc to the character's facing, capped at
-    /// [`FOLLOW_RATE`]·dt so the camera *slews* rather than snapping, and exactly zero on a style
-    /// (or a stillness) that isn't chasing. The cap stops **at** the target: the clamp can never
-    /// overshoot, so a settled camera writes nothing and the no-op gate downstream stays quiet.
-    fn step(&self, cam_yaw: f32, dt: f32) -> f32 {
-        if !self.style.chases(self.moving) {
-            return 0.0;
+    /// The winning state — the reference's descending priority scan, highest bit first.
+    fn state(&self, stopping: bool) -> FollowState {
+        let mf = self.command;
+        let held = |bits: u32| mf & bits != 0;
+        if held(follow_cmd::FEAR) {
+            FollowState::Fear
+        } else if held(follow_cmd::TURN_BITS) || held(follow_cmd::RIGHT_MOUSE) {
+            FollowState::Turn
+        } else if held(follow_cmd::STRAFE_BITS)
+            || (held(follow_cmd::RIGHT_MOUSE) && held(follow_cmd::TURN_BITS))
+        {
+            FollowState::Strafe
+        } else if held(follow_cmd::MOVE_BITS)
+            || (held(follow_cmd::RIGHT_MOUSE) && held(follow_cmd::LEFT_MOUSE))
+        {
+            FollowState::Move
+        } else if held(follow_cmd::TRACK) {
+            FollowState::Track
+        } else if stopping {
+            FollowState::Stop
+        } else {
+            FollowState::Idle
         }
-        let step = FOLLOW_RATE * dt;
-        wrap_pi(self.face_yaw - cam_yaw).clamp(-step, step)
+    }
+
+    /// Which style picks the row: the *tracking* style whenever the mask so much as contains
+    /// `Track` or `Fear`, even when a higher-priority state supplies the row.
+    fn style(&self) -> FollowStyle {
+        if self.command & (follow_cmd::TRACK | follow_cmd::FEAR) != 0 {
+            self.cfg.tracking_style
+        } else {
+            self.cfg.style
+        }
+    }
+}
+
+/// The armed yaw transition — the reference's descriptor `[+0x208 startMs, +0x20c dur,
+/// +0x210 target, +0x214 start]`, in seconds and in *offset* space.
+#[derive(Clone, Copy, Debug)]
+struct FollowArm {
+    /// The offset the transition started from, radians (camera yaw minus character facing).
+    from: f32,
+    /// Where it is going. `0.0` — directly behind — at the shipped defaults, because
+    /// `cameraYawSmoothMin`/`Max` are both `0.0` and the reference *substitutes* the crossed bound
+    /// for the saved view yaw whenever the live offset is outside the band.
+    to: f32,
+    /// Seconds the move takes, already clamped to `[FOLLOW_TIME_MIN, FOLLOW_TIME_MAX]`.
+    dur: f32,
+    /// Seconds of dead time before it starts (`Track`/`Fear` under Smart: 0.4).
+    delay: f32,
+    /// Seconds since it was armed.
+    elapsed: f32,
+    /// What it was armed with — the reference's re-arm memo (`[+0x218, +0x21c]`), so a repeated
+    /// edge asking for the same transition is a no-op instead of restarting the swing.
+    armed_with: (f32, f32),
+}
+
+/// The auto-follow's own state on the rig: the input word we last saw (edges are what arm a
+/// return) and the transition in flight, if any.
+#[derive(Default)]
+pub(super) struct FollowRig {
+    last_command: Option<u32>,
+    arm: Option<FollowArm>,
+}
+
+impl FollowRig {
+    /// Run the auto-follow for a frame and return the camera yaw it wants, if it wants one.
+    ///
+    /// The shape is the reference's, and the shape is the point (wow-re `camera-smooth-style.md`
+    /// §6/§8): a transition is **armed on an input edge**, from a snapshot taken at that instant,
+    /// and then plays out unattended — it is *not* a per-frame chase of a moving target. That is
+    /// why "drag the camera aside, then press W" swings you back over one smooth arc, while
+    /// holding W changes nothing at all.
+    fn advance(
+        &mut self,
+        input: &FollowInput,
+        cam_yaw: f32,
+        dt: f32,
+        look_held: bool,
+    ) -> Option<f32> {
+        let word = input.command;
+        let previous = self.last_command.replace(word);
+        // A held drag owns the camera: the yaw channel is frozen (`0x50f623`), arming is gated
+        // (`0x510850`'s `!([cam+0x90] & 1)`), and **entering** mouse-look cancels whatever was in
+        // flight outright (`0x50fe30` zeroes the descriptors). So the return does not resume when
+        // the button comes up — it begins at the next input edge after the release, which is
+        // usually the release itself (the mouse bits are part of the word).
+        if look_held {
+            self.arm = None;
+            return None;
+        }
+        // The EDGE: any movement/camera binding changing state re-evaluates the transition. The
+        // reference re-evaluates on the binding call itself, not on a change of the classified
+        // state, which is why releasing the drag while standing still is an Idle *arming* under
+        // Always and an Idle *cancel* under Smart.
+        if let Some(p) = previous.filter(|p| *p != word) {
+            // `stopping` — the reference's second argument, set by the Stop half of a movement
+            // binding. Our equivalent is the edge itself: a movement bit went away.
+            let stopping = (p & !word)
+                & (follow_cmd::MOVE_BITS | follow_cmd::STRAFE_BITS | follow_cmd::TURN_BITS)
+                != 0;
+            self.arm(input, cam_yaw, stopping);
+        }
+        let arm = self.arm.as_mut()?;
+        arm.elapsed += dt;
+        let t = arm.elapsed - arm.delay;
+        if t < 0.0 {
+            return None; // still inside the delay window
+        }
+        let s = t / arm.dur;
+        let offset = if s >= 1.0 {
+            let to = arm.to;
+            self.arm = None;
+            to
+        } else {
+            // The reference's kernel `0x5b7bb0` — a **cosine** smoothstep, eased at both ends:
+            // `a + (b − a)·(1 − cos(πs))/2`.
+            let e = (1.0 - (std::f32::consts::PI * s).cos()) * 0.5;
+            arm.from + (arm.to - arm.from) * e
+        };
+        Some(wrap_pi(input.face_yaw + offset))
+    }
+
+    /// What the transition is doing, for `WOW_CAM_DUMP` — `None` when nothing is armed, else
+    /// `(elapsed, delay, duration)` in seconds. The auto-follow is the one camera behaviour with
+    /// no headless retest (nothing synthesizes a mouse drag), so the trace line is how a run says
+    /// what it armed and when.
+    fn probe(&self) -> Option<(f32, f32, f32)> {
+        self.arm.map(|a| (a.elapsed, a.delay, a.dur))
+    }
+
+    /// The arming half (`0x510960` → `0x512c70`): pick the row, then either cancel outright or
+    /// snapshot a transition to the target offset.
+    fn arm(&mut self, input: &FollowInput, cam_yaw: f32, stopping: bool) {
+        let (delay, factor) = input.style().row(input.state(stopping));
+        if factor == 0.0 {
+            // Cancel: the target becomes the live yaw and the channel disarms — the camera simply
+            // keeps the offset it has. This is Smart standing still, and it is all of Never.
+            self.arm = None;
+            return;
+        }
+        // The target: directly behind, at the shipped defaults (see [`FollowArm::to`]).
+        let to = 0.0;
+        let from = wrap_pi(cam_yaw - input.face_yaw);
+        let gap = (to - from).abs();
+        if gap < FOLLOW_EPS {
+            return; // already there — the reference returns without arming
+        }
+        // The re-arm memo: an edge asking for the transition already in flight is a no-op, so a
+        // second keypress mid-swing does not restart it from the current angle.
+        if self.arm.is_some_and(|a| {
+            a.to == to
+                && (a.armed_with.0 - delay).abs() < FOLLOW_EPS
+                && (a.armed_with.1 - factor).abs() < FOLLOW_EPS
+        }) {
+            return;
+        }
+        let rate = input.cfg.yaw_speed.to_radians().max(FOLLOW_EPS);
+        let dur = (gap / rate * factor).clamp(FOLLOW_TIME_MIN, FOLLOW_TIME_MAX);
+        self.arm = Some(FollowArm {
+            from,
+            to,
+            dur,
+            delay,
+            elapsed: 0.0,
+            armed_with: (delay, factor),
+        });
     }
 }
 
@@ -355,6 +622,10 @@ pub(crate) struct CameraControl {
     /// the camera zooms into the head (first-person). `control` computes it (it owns the pivot + camera
     /// pose); [`apply_self_model_fade`] applies it to the body parts. Starts opaque.
     pub(super) self_fade_alpha: f32,
+    /// The auto-follow's own state (decision 1502): the input word we last saw, and the armed
+    /// return in flight. It lives on the rig rather than beside the knob because it is *pose*, not
+    /// setting — a transition survives the frame, not the session.
+    pub(super) follow: FollowRig,
 }
 
 impl CameraControl {
@@ -646,14 +917,19 @@ pub(super) fn seat_camera(
     // — no INPUT-turn carry against the user's hand. (A transport deck's turn is not an input and
     // never arrives here — the ride block applies it to `cam.yaw` directly, drag or no drag.)
     //
-    // **The auto-follow** (decision 1493, 1.12's `cameraSmoothStyle`) rides the same gate for the
-    // same reason — a held drag owns the camera, hand on it: swing the camera back behind the
-    // character, along the shortest arc, at [`FOLLOW_RATE`]. Which frames it runs on is the
-    // player's setting — Always every frame, Smart only while the character is translating, Never
-    // not at all (the behaviour benilla shipped unconditionally until now).
-    if rig.look.is_none() {
+    // **The auto-follow** (1.12's `cameraSmoothStyle`, decisions 1493/1502) rides the same gate
+    // for the same reason — a held drag owns the camera, hand on it. It is NOT a per-frame chase:
+    // an input edge arms a cosine-smoothstep return to directly-behind and that transition then
+    // plays out unattended ([`FollowRig::advance`]). It writes an absolute yaw because our camera
+    // stores one; the reference stores the *offset* and re-adds the facing at render time, which
+    // is the same picture and a different mechanism (wow-re `camera-smooth-style.md` §10 — and
+    // the reason Never must not, and here does not, touch the rigid carry above).
+    let look_held = rig.look.is_some();
+    if !look_held {
         cam.yaw += turn_delta;
-        cam.yaw += follow.step(cam.yaw, dt);
+    }
+    if let Some(yaw) = rig.follow.advance(follow, cam.yaw, dt, look_held) {
+        cam.yaw = yaw;
     }
     // Orient the camera, then orbit it behind the avatar's torso. The framing **pivot** is
     // `feet + cam_pivot_height` (model-derived, ~neck height — [`CameraPivot`]); the camera looks at
@@ -722,9 +998,15 @@ pub(super) fn seat_camera(
     // measured. `open` is printed beside the eased arm so a hit/miss alternation in the CAST is
     // visible even on a frame where the ease has not yet moved the camera far enough to see.
     if std::env::var_os("WOW_CAM_DUMP").is_some() {
+        // `follow=` is the auto-follow's own reading (1502): the offset the return is animating,
+        // the state the input word classifies to, and — once armed — how far through the
+        // transition this frame is. `off` moving while `arm` reads `-` means something other than
+        // the follow moved the camera.
+        let (elapsed, delay, dur) = rig.follow.probe().unwrap_or((-1.0, -1.0, -1.0));
         eprintln!(
             "[cam] yaw {:.6} pitch {:.6} dist {:.6} open {:.6} coll {:.6} frac {:.6} \
-             pos [{:.6},{:.6},{:.6}] bits [{:08x},{:08x},{:08x}]",
+             pos [{:.6},{:.6},{:.6}] bits [{:08x},{:08x},{:08x}] \
+             follow off {:.6} state {:?} word {:06x} arm {:.3}/{:.3}+{:.3}",
             cam.yaw,
             cam.pitch,
             rig.distance,
@@ -737,6 +1019,12 @@ pub(super) fn seat_camera(
             translation.x.to_bits(),
             translation.y.to_bits(),
             translation.z.to_bits(),
+            wrap_pi(cam.yaw - follow.face_yaw),
+            follow.state(false),
+            follow.command,
+            elapsed,
+            dur,
+            delay,
         );
     }
 
@@ -1110,47 +1398,243 @@ mod tests {
         assert_eq!(slow.rate(), LOOK_SENSITIVITY * 0.5);
     }
 
-    /// **The auto-follow** (decision 1493) — 1.12's `cameraSmoothStyle`, the setting benilla spent
-    /// its whole life behaving as "Never". Four properties, and the last two are the ones a
-    /// re-derivation gets wrong: the style gate (Smart is *movement*-gated, Always is not, Never is
-    /// never), the rate cap, the fact that the chase takes the SHORT way round the ±π seam, and
-    /// that it stops exactly ON the facing rather than oscillating across it.
+    /// **The auto-follow** (decisions 1493/1502) — 1.12's `cameraSmoothStyle`, the setting benilla
+    /// spent its whole life behaving as "Never". The properties that a re-derivation gets wrong,
+    /// and that the byte-verified mechanism (wow-re `camera-smooth-style.md`) turns on:
+    /// it is armed by an input **edge** and then plays out unattended (not a per-frame chase of a
+    /// moving target), the profile is a **cosine** smoothstep, the duration is `|Δ| / rate ×
+    /// factor` **clamped to [0.1 s, 2.0 s]**, and Smart's `Idle`/`Stop` rows are a *cancel* — which
+    /// is what "stays where you put it, except while you're moving" actually is.
     #[test]
-    fn the_auto_follow_chases_on_the_styles_that_chase_and_never_overshoots() {
-        const DT: f32 = 1.0 / 60.0;
-        let step = |style, moving, face_yaw, cam_yaw| {
-            FollowInput {
+    fn the_auto_follow_is_armed_by_an_input_edge_and_eases_home() {
+        const DT: f32 = 1.0 / 120.0;
+        // A quarter turn of orbit offset, left there by a drag.
+        const OFFSET: f32 = std::f32::consts::FRAC_PI_2;
+
+        fn cfg(style: FollowStyle) -> FollowConfig {
+            FollowConfig {
                 style,
-                face_yaw,
-                moving,
+                tracking_style: style,
+                yaw_speed: FOLLOW_SPEED_DEFAULT,
             }
-            .step(cam_yaw, DT)
-        };
+        }
+        /// Run `secs` of frames at a fixed input word; returns the camera yaw it ends on.
+        fn run(rig: &mut FollowRig, cfg: FollowConfig, word: u32, cam_yaw: f32, secs: f32) -> f32 {
+            let mut yaw = cam_yaw;
+            for _ in 0..((secs / DT).round() as i32).max(0) {
+                let input = FollowInput {
+                    cfg,
+                    face_yaw: 0.0,
+                    command: word,
+                };
+                if let Some(y) = rig.advance(&input, yaw, DT, false) {
+                    yaw = y;
+                }
+            }
+            yaw
+        }
 
-        // Never is inert — the camera stays exactly where the hand left it, moving or not.
-        assert_eq!(step(FollowStyle::Never, true, 1.0, 0.0), 0.0);
-        // Smart is gated on the character actually translating ("except when your character is
-        // moving"); Always is not.
-        assert_eq!(step(FollowStyle::Smart, false, 1.0, 0.0), 0.0);
-        assert!(step(FollowStyle::Smart, true, 1.0, 0.0) > 0.0);
-        assert!(step(FollowStyle::Always, false, 1.0, 0.0) > 0.0);
-
-        // A big gap slews at the rate, not in one frame.
-        let capped = step(FollowStyle::Always, true, 3.0, 0.0);
-        assert!((capped - FOLLOW_RATE * DT).abs() < 1.0e-6, "{capped}");
-        // A gap smaller than one frame's slew lands ON the facing — no overshoot, and the next
-        // frame writes exactly nothing (which is what keeps the no-op transform gate quiet).
-        let small = 0.5 * FOLLOW_RATE * DT;
-        let landed = step(FollowStyle::Always, true, small, 0.0);
-        assert!((landed - small).abs() < 1.0e-6, "{landed} vs {small}");
-        assert_eq!(step(FollowStyle::Always, true, 0.0, 0.0), 0.0);
-
-        // Across the ±π seam the chase takes the short way: a facing at −3.1 from a camera at 3.1
-        // is 0.08 rad AHEAD, not 6.2 rad behind.
-        assert!(
-            step(FollowStyle::Always, true, -3.1, 3.1) > 0.0,
-            "the shortest arc, not the long way round"
+        // ── Smart: standing still with the camera dragged aside, nothing happens; the moment the
+        // W edge lands, one armed transition brings it home over |Δ|/180°/s = 0.5 s.
+        let mut rig = FollowRig::default();
+        let c = cfg(FollowStyle::Smart);
+        let parked = run(&mut rig, c, 0, OFFSET, 1.0);
+        assert_eq!(
+            parked, OFFSET,
+            "Smart standing still leaves the camera alone"
         );
+        let half = run(&mut rig, c, follow_cmd::FORWARD, parked, 0.25);
+        assert!(
+            half < OFFSET * 0.75 && half > OFFSET * 0.25,
+            "mid-swing, eased: {half}"
+        );
+        let home = run(&mut rig, c, follow_cmd::FORWARD, half, 0.3);
+        assert!(home.abs() < 1.0e-4, "arrived behind the character: {home}");
+        // And holding W changes nothing further — the transition is spent, not a standing chase.
+        let still_home = run(&mut rig, c, follow_cmd::FORWARD, home + 0.4, 1.0);
+        assert_eq!(
+            still_home,
+            home + 0.4,
+            "a HELD key re-arms nothing: only edges arm"
+        );
+
+        // ── Smart: releasing W (an edge into Stop) cancels rather than arming, so a camera nudged
+        // while stopping stays nudged.
+        let mut rig = FollowRig::default();
+        let held = run(&mut rig, c, follow_cmd::FORWARD, 0.0, 0.1);
+        let released = run(&mut rig, c, 0, held + OFFSET, 0.5);
+        assert_eq!(released, held + OFFSET, "Stop is a cancel under Smart");
+
+        // ── Always arms on that very same Idle edge — the one row where the two styles differ.
+        let mut rig = FollowRig::default();
+        let a = cfg(FollowStyle::Always);
+        let held = run(&mut rig, a, follow_cmd::FORWARD, 0.0, 0.1);
+        let returned = run(&mut rig, a, 0, held + OFFSET, 1.0);
+        assert!(
+            returned.abs() < 1.0e-4,
+            "Always returns even from a standstill: {returned}"
+        );
+
+        // ── Never is inert, edge or no edge.
+        let mut rig = FollowRig::default();
+        let n = cfg(FollowStyle::Never);
+        let _ = run(&mut rig, n, 0, OFFSET, 0.1);
+        assert_eq!(
+            run(&mut rig, n, follow_cmd::FORWARD, OFFSET, 2.0),
+            OFFSET,
+            "Never never arms"
+        );
+
+        // ── The duration floor: a 5° correction is 0.028 s of travel at 180 °/s, and the
+        // reference's 0.1 s minimum overrides it — so it is NOT finished after 0.05 s.
+        let mut rig = FollowRig::default();
+        let small = 5.0_f32.to_radians();
+        let _ = run(&mut rig, c, 0, small, DT);
+        let mid = run(&mut rig, c, follow_cmd::FORWARD, small, 0.05);
+        assert!(
+            mid.abs() > 1.0e-4,
+            "the 0.1 s floor is doing the work: {mid}"
+        );
+        assert!(run(&mut rig, c, follow_cmd::FORWARD, mid, 0.06).abs() < 1.0e-4);
+
+        // ── Track (a taxi, a spline): Smart takes it lazily — 0.4 s of dead time first, then a
+        // factor-10 return the 2 s ceiling caps.
+        let mut rig = FollowRig::default();
+        let _ = run(&mut rig, c, 0, OFFSET, DT);
+        let delayed = run(&mut rig, c, follow_cmd::TRACK, OFFSET, 0.3);
+        assert_eq!(delayed, OFFSET, "nothing moves inside the 0.4 s delay");
+        let crawling = run(&mut rig, c, follow_cmd::TRACK, delayed, 0.6);
+        assert!(
+            crawling > OFFSET * 0.5,
+            "a factor-10 return is a crawl, not a swing: {crawling}"
+        );
+        assert!(
+            run(&mut rig, c, follow_cmd::TRACK, crawling, 2.0).abs() < 1.0e-4,
+            "and it does arrive, inside the 2 s cap"
+        );
+
+        // ── A held drag freezes the channel outright: the hand owns the camera.
+        let mut rig = FollowRig::default();
+        let input = FollowInput {
+            cfg: c,
+            face_yaw: 0.0,
+            command: follow_cmd::FORWARD,
+        };
+        assert!(rig.advance(&input, OFFSET, DT, true).is_none());
+        assert!(rig.advance(&input, OFFSET, DT, true).is_none());
+
+        // ── …and entering the drag **cancels** what was in flight (`0x50fe30` zeroes the
+        // descriptors), so the return does not simply resume when the button comes up. Grab the
+        // camera mid-swing and it stays where the hand left it until the next input edge.
+        let mut rig = FollowRig::default();
+        let _ = run(&mut rig, c, 0, OFFSET, DT);
+        let mid = run(&mut rig, c, follow_cmd::FORWARD, OFFSET, 0.1);
+        assert!(mid < OFFSET && mid > 0.0, "mid-swing: {mid}");
+        let dragging = FollowInput {
+            cfg: c,
+            face_yaw: 0.0,
+            command: follow_cmd::FORWARD | follow_cmd::LEFT_MOUSE,
+        };
+        assert!(rig.advance(&dragging, mid, DT, true).is_none());
+        // The word is unchanged from the drag frame's, so nothing re-arms on its own…
+        let parked = {
+            let mut yaw = mid;
+            for _ in 0..120 {
+                let input = FollowInput {
+                    cfg: c,
+                    face_yaw: 0.0,
+                    command: follow_cmd::FORWARD | follow_cmd::LEFT_MOUSE,
+                };
+                if let Some(y) = rig.advance(&input, yaw, DT, false) {
+                    yaw = y;
+                }
+            }
+            yaw
+        };
+        assert_eq!(parked, mid, "the cancelled transition does not resume");
+        // …and the release's own edge (the mouse bit leaving the word) is what starts a new one.
+        assert!(
+            run(&mut rig, c, follow_cmd::FORWARD, parked, 1.0).abs() < 1.0e-4,
+            "the release edge arms a fresh return"
+        );
+    }
+
+    /// The state classifier's three vanilla input rules (wow-re `camera-smooth-style.md` §6.2) —
+    /// the ones a client that keys off character *velocity* cannot reproduce, because they are
+    /// read off the camera's own command word: right-mouse alone is a `Turn`, a turn key held
+    /// **under** right-mouse is a `Strafe`, and both mouse buttons together are a `Move`. Plus the
+    /// priority order, which is what decides the row when several are true at once.
+    #[test]
+    fn the_follow_state_reads_the_camera_input_word_not_the_character() {
+        let state = |command: u32, stopping: bool| {
+            FollowInput {
+                cfg: FollowConfig::default(),
+                face_yaw: 0.0,
+                command,
+            }
+            .state(stopping)
+        };
+        assert_eq!(state(0, false), FollowState::Idle);
+        assert_eq!(state(0, true), FollowState::Stop);
+        assert_eq!(state(follow_cmd::RIGHT_MOUSE, false), FollowState::Turn);
+        assert_eq!(
+            state(follow_cmd::RIGHT_MOUSE | follow_cmd::TURN_LEFT, false),
+            FollowState::Turn,
+            "Turn outranks the Strafe its own condition also satisfies"
+        );
+        assert_eq!(state(follow_cmd::STRAFE_LEFT, false), FollowState::Strafe);
+        assert_eq!(
+            state(follow_cmd::RIGHT_MOUSE | follow_cmd::LEFT_MOUSE, false),
+            FollowState::Turn,
+            "both buttons satisfy Move, but Turn outranks it"
+        );
+        assert_eq!(state(follow_cmd::LEFT_MOUSE, false), FollowState::Idle);
+        assert_eq!(state(follow_cmd::AUTORUN, false), FollowState::Move);
+        assert_eq!(state(follow_cmd::TRACK, false), FollowState::Track);
+        assert_eq!(
+            state(follow_cmd::TRACK | follow_cmd::FORWARD, false),
+            FollowState::Move,
+            "Move outranks Track"
+        );
+        assert_eq!(
+            state(follow_cmd::FEAR | follow_cmd::FORWARD, false),
+            FollowState::Fear,
+            "Fear outranks everything"
+        );
+        // …and the tracking style is the selector the moment Track or Fear is merely PRESENT,
+        // even when a higher-priority state supplies the row.
+        let mixed = FollowInput {
+            cfg: FollowConfig {
+                style: FollowStyle::Never,
+                tracking_style: FollowStyle::Always,
+                yaw_speed: FOLLOW_SPEED_DEFAULT,
+            },
+            face_yaw: 0.0,
+            command: follow_cmd::TRACK | follow_cmd::FORWARD,
+        };
+        assert_eq!(mixed.style(), FollowStyle::Always);
+        assert_eq!(mixed.state(false), FollowState::Move);
+    }
+
+    /// The enum is the ENGINE's (0/1/2), not the 1/2/3 the reference's own dropdown writes — and
+    /// that stray `3` still has to mean Never, because that is what whoever wrote it meant.
+    #[test]
+    fn the_follow_style_enum_is_the_engines_and_tolerates_the_dropdowns_stray() {
+        assert_eq!(FollowStyle::from_cvar(0.0), FollowStyle::Never);
+        assert_eq!(FollowStyle::from_cvar(1.0), FollowStyle::Smart);
+        assert_eq!(FollowStyle::from_cvar(2.0), FollowStyle::Always);
+        assert_eq!(FollowStyle::from_cvar(3.0), FollowStyle::Never);
+        // Off the ladder entirely: the registrar default, not a dead camera.
+        assert_eq!(FollowStyle::from_cvar(-1.0), FollowStyle::Smart);
+        assert_eq!(FollowStyle::from_cvar(9.0), FollowStyle::Smart);
+        for style in [FollowStyle::Never, FollowStyle::Smart, FollowStyle::Always] {
+            assert_eq!(
+                FollowStyle::from_cvar(style.cvar().parse::<f32>().unwrap()),
+                style,
+                "the string round-trips"
+            );
+        }
+        assert_eq!(FollowStyle::default(), FollowStyle::Smart);
     }
 
     /// The second arm: between 200 and 800 world the travel gate applies, per axis and independently
diff --git a/crates/benilla-app/src/player/world_focus.rs b/crates/benilla-app/src/player/world_focus.rs
index 2b7a48c5..3cf9a3f6 100644
--- a/crates/benilla-app/src/player/world_focus.rs
+++ b/crates/benilla-app/src/player/world_focus.rs
@@ -105,7 +105,7 @@ pub(super) fn release_post_snap_hold(
     mut player: ResMut<Player>,
     progress: Option<Res<WorldLoadProgress>>,
     time: Res<Time>,
-    mut last_counters: Local<Option<[usize; 5]>>,
+    mut last_counters: Local<Option<[usize; 6]>>,
     net_cmds: Option<Res<crate::net::NetCommands>>,
 ) {
     let Some(p) = progress else { return };
@@ -127,7 +127,8 @@ pub(super) fn release_post_snap_hold(
         player.world_stale = false;
     }
     // Did the stream move since last frame? Any counter changing — a tile spawned, a placement
-    // up, a collider queued or attached — is the destination still arriving. Tracked every frame
+    // up, a collider queued or attached, a retained region baked — is the destination still
+    // arriving. Tracked every frame
     // (not just while settling) so the first settling frame compares against a real baseline.
     let counters = [
         p.ready,
@@ -135,6 +136,7 @@ pub(super) fn release_post_snap_hold(
         p.colliders_pending,
         p.merge_pending,
         p.placements_pending,
+        p.gx_pending,
     ];
     let progressed = last_counters.replace(counters) != Some(counters);
     if !player.settling {
@@ -318,6 +320,27 @@ mod tests {
         assert!(!settling(&mut app), "presentable world, hold still on");
     }
 
+    /// Decision 1498: geometry that has SPAWNED but not yet baked is a hole in the world exactly
+    /// like an unattached collider, so it holds the post-snap freeze too. The retained pass took
+    /// the static world off the entity path (1429), and from then on "the placement spawned" and
+    /// "the building is on screen" stopped being the same fact — the hold, like the reveal, keys
+    /// on the second.
+    #[test]
+    fn an_unbaked_region_holds_the_settle() {
+        let mut app = app();
+        app.world_mut().resource_mut::<Player>().world_stale = false;
+        step(&mut app, 1.0, |p| {
+            p.total = 2000;
+            p.ready = 2000;
+            p.colliders_pending = 0;
+            p.scene_ready = true;
+            p.gx_pending = 4;
+        });
+        assert!(settling(&mut app), "spawned but undrawn is not presentable");
+        step(&mut app, 0.1, |p| p.gx_pending = 0);
+        assert!(!settling(&mut app), "baked — the world is really there");
+    }
+
     /// B263 round 3 (decision 1336): residency published for ANOTHER tile never releases the hold
     /// and never clears the stale flag — the live defect was the focus publish racing the teleport
     /// snap, so on the snap frame the streamer described the DEPARTURE city as fully resident and
diff --git a/crates/benilla-app/src/ui_pass.rs b/crates/benilla-app/src/ui_pass.rs
index b586e68e..f3860b47 100644
--- a/crates/benilla-app/src/ui_pass.rs
+++ b/crates/benilla-app/src/ui_pass.rs
@@ -274,6 +274,39 @@ pub(crate) struct UiQuads {
     pub dirty: bool,
 }
 
+/// The **append lane's own z bands** — the world-anchored overlays' slice of the same `z_key`
+/// total order the scripted UI packs its `(stratum, level, layer, …)` tuple into
+/// ([`benilla_ui::order::ZKey`]).
+///
+/// The lane's three producers are three *different* client systems that all draw over the world,
+/// and their relative order is a fidelity fact each one owns (the floating combat numbers are a
+/// world-scene draw under all UI; the plates and the bubbles are frames). What is NOT a fidelity
+/// fact is the arithmetic that keeps them apart — and while each producer picked its own small
+/// integer, that arithmetic was three private conventions with nothing naming the shared law:
+/// combat text at 0, the bubble's four pieces at 0..=3 *on top of it*, the plates at 4..=8. The
+/// bands below make the split explicit and, more to the point, give the middle band **room** —
+/// a chat bubble is one frame per speaker with its own frame level (decision 1504), which a
+/// four-key allocation cannot express. Everything here stays far below the scripted UI's keys
+/// (a `ZKey` region carries its is-region bit at `1 << 20`), so the whole lane still paints
+/// under the player UI.
+pub(crate) mod overlay_z {
+    /// Floating combat/XP/honor numbers — the client draws them in the world scene, beneath
+    /// every UI frame ([`crate::combat_text`]).
+    pub(crate) const WORLD_TEXT: u64 = 0;
+    /// The chat bubbles' band ([`crate::chat_bubble`]): one **frame level** per live bubble,
+    /// [`BUBBLE_STRIDE`] keys wide, ordered farthest-camera-distance first.
+    pub(crate) const BUBBLE: u64 = 1 << 8;
+    /// Keys per bubble level — the frame's own four pieces (bg, edge, tail, text).
+    pub(crate) const BUBBLE_STRIDE: u64 = 4;
+    /// The V-plates ([`crate::vplates`]), above every bubble. Same-unit overlap cannot happen
+    /// (the plate/bubble mutual exclusion), so this only orders cross-unit stacking.
+    pub(crate) const VPLATE: u64 = 1 << 16;
+    /// The highest bubble level the band holds before it would reach [`VPLATE`]. Far past any
+    /// real population (a bubble needs a speaker within 20 yd), so the clamp is a guard rail,
+    /// not a policy.
+    pub(crate) const BUBBLE_MAX_LEVEL: u64 = (VPLATE - BUBBLE) / BUBBLE_STRIDE - 1;
+}
+
 /// Clear the append lane at the top of the [`UiQuadAppend`] window — every appender re-emits its
 /// frame's quads after this; [`rebuild_ui_mesh`] then diffs the lane to decide if anything changed.
 fn clear_ui_overlays(mut quads: ResMut<UiQuads>) {
diff --git a/crates/benilla-app/src/ui_script/mod.rs b/crates/benilla-app/src/ui_script/mod.rs
index 47d8103e..a794f16f 100644
--- a/crates/benilla-app/src/ui_script/mod.rs
+++ b/crates/benilla-app/src/ui_script/mod.rs
@@ -853,6 +853,11 @@ mod shipped_xml_tests;
 #[cfg(test)]
 mod bagnon_render_tests;
 
+/// Bug B267 end to end: a hunter's Quiver publishes its global functions (see the file header for
+/// the three walls that stopped it).
+#[cfg(test)]
+mod quiver_tests;
+
 /// The UI's per-world-entry lifecycle: teardown at the character screen, a genuine second load at
 /// the next login (decision 1290).
 #[cfg(test)]
diff --git a/crates/benilla-app/src/ui_script/options_tests.rs b/crates/benilla-app/src/ui_script/options_tests.rs
index c93b2596..6218cf53 100644
--- a/crates/benilla-app/src/ui_script/options_tests.rs
+++ b/crates/benilla-app/src/ui_script/options_tests.rs
@@ -2803,16 +2803,16 @@ fn the_max_camera_distance_slider_stores_a_factor_and_reads_out_yards() {
     assert!(s.errors().is_empty(), "script errors: {:?}", s.errors());
 }
 
-/// **Camera Following Style** (decision 1493) — 1.12's `cameraSmoothStyle`, worn as a Controls-page
-/// dropdown, and the setting that decides whether the camera swings back behind the character at
-/// all. Three things pinned: the reference's own values *and* their order (Smart `"1"`, Always
-/// `"2"`, Never `"3"` — Never is **3**, not 0, which is exactly what a tidy-up would get wrong);
-/// the registered default landing on Smart, where benilla behaved as Never for its whole life
-/// before this row; and the plate following the SELECTION rather than the row — the reference's own
-/// dropdown repaints its tooltip per entry (`OPTION_TOOLTIP_CAMERA1/2/3`) and this is the first row
-/// here whose description is not a property of the row alone.
+/// **Camera Following Style** (decisions 1493/1502) — 1.12's `cameraSmoothStyle`, worn as a
+/// Controls-page dropdown, and the setting that decides whether the camera returns to behind the
+/// character at all. What is pinned here is the trap: the reference's own dropdown writes `1/2/3`,
+/// but the ENGINE's tables are indexed `0 = Never · 1 = Smart · 2 = Always`, and `3` is not a style
+/// — the validator accepts it while the terrain-tilt consumer indexes off the end of its table
+/// (wow-re `camera-smooth-style.md` §2/§4). So our entries carry the engine's numbers in the
+/// reference's display order, a stray `3` still reads as Never rather than as the numerically
+/// nearest "Always", and the plate follows the SELECTION the way that dropdown's own does.
 #[test]
-fn the_camera_following_style_dropdown_carries_the_reference_values_and_plate() {
+fn the_camera_following_style_dropdown_carries_the_engine_enum_and_plate() {
     let mut s = harness_on(audio_harness());
     s.run("ShowUIPanel(OptionsFrame)").unwrap();
     s.run("OptionsFrameCategoryListRowControls:Click()")
@@ -2843,8 +2843,7 @@ fn the_camera_following_style_dropdown_carries_the_reference_values_and_plate()
         "reading the table on select must not write it back"
     );
 
-    // The list is the reference dropdown's, entry for entry: Smart, Always, Never — with the
-    // stored value checked.
+    // The list is the reference dropdown's, entry for entry and in its order.
     s.run("OptionsFrameContainerBodyControlsRowCameraFollowStyleDropdownButton:Click()")
         .unwrap();
     assert_eq!(
@@ -2863,12 +2862,12 @@ fn the_camera_following_style_dropdown_carries_the_reference_values_and_plate()
         .eval::<bool>("return DropDownList1Button1Check:IsVisible()")
         .unwrap());
 
-    // Never stores "3" — the value the reference writes, not the 0 a fresh enum would invent —
+    // Never stores "0" — the engine's own index, not the "3" the reference's dropdown writes —
     // and the row's plate becomes Never's own description.
     s.run("DropDownList1Button3:Click()").unwrap();
     assert_eq!(
         s.take_cvar_changes(),
-        vec![("cameraSmoothStyle".to_string(), "3".to_string())]
+        vec![("cameraSmoothStyle".to_string(), "0".to_string())]
     );
     assert_eq!(
         s.eval::<String>(
@@ -2884,8 +2883,7 @@ fn the_camera_following_style_dropdown_carries_the_reference_values_and_plate()
         "the plate follows the selection, like the reference dropdown's own"
     );
 
-    // Always is the middle entry and stores "2" (the pairing that goes wrong if the order is read
-    // off the alphabet instead of off the reference).
+    // Always is the middle entry and stores "2".
     s.run("OptionsFrameContainerBodyControlsRowCameraFollowStyleDropdownButton:Click()")
         .unwrap();
     s.run("DropDownList1Button2:Click()").unwrap();
@@ -2894,6 +2892,24 @@ fn the_camera_following_style_dropdown_carries_the_reference_values_and_plate()
         vec![("cameraSmoothStyle".to_string(), "2".to_string())]
     );
 
+    // A config written by a REAL 1.12 client says "3" for Never. It must not display as the
+    // numerically nearest stop — which is Always, the opposite of what it means.
+    s.set_cvar_host("cameraSmoothStyle", "3");
+    s.run("OptionsFrameCategoryListRowAudio:Click(); OptionsFrameCategoryListRowControls:Click()")
+        .unwrap();
+    assert_eq!(
+        s.eval::<String>(
+            "return OptionsFrameContainerBodyControlsRowCameraFollowStyleDropdownText:GetText()"
+        )
+        .unwrap(),
+        "Never",
+        "the reference dropdown's own stray value still means Never"
+    );
+    assert!(
+        s.take_cvar_changes().is_empty(),
+        "displaying a stray value must not write it back"
+    );
+
     // Defaults walks it back to Smart.
     s.run("OptionsFrameContainerDefaults:Click()").unwrap();
     assert_eq!(
diff --git a/crates/benilla-app/src/ui_script/quiver_tests.rs b/crates/benilla-app/src/ui_script/quiver_tests.rs
new file mode 100644
index 00000000..cc978dc5
--- /dev/null
+++ b/crates/benilla-app/src/ui_script/quiver_tests.rs
@@ -0,0 +1,272 @@
+//! **"`Quiver.CastPetAction` is nil when the addon's own macro runs"** — bug B267, reproduced end
+//! to end and then closed.
+//!
+//! ## Why this file exists
+//!
+//! The report is a `/run Quiver.CastPetAction("Furious Howl")` macro raising
+//! `attempt to call field 'CastPetAction' (a nil value)`. The field is published on the addon's
+//! **last** line of `VARIABLES_LOADED`:
+//!
+//! ```lua
+//! if event == "VARIABLES_LOADED" then
+//!     LoadLocale() Migrations() savedVariablesRestore()
+//!     initSlashCommandsAndModules()      -- builds the whole config UI, HUNTERS ONLY
+//!     RegisterGlobalFunctions()          -- <- Quiver.CastPetAction = … lives here
+//! ```
+//!
+//! so anything that raises in that handler takes every global function with it. Three separate
+//! walls did, one behind the other, and each is a real gap of ours:
+//!
+//! | | what it does | who found it |
+//! |---|---|---|
+//! | the Region method map was two implementations, not one | `Api._Height = WorldFrame.GetHeight` applied to a Texture raised `stale or invalid frame handle` | this bug |
+//! | `Button:SetFontString` missing | every dropdown option row died on its first line | behind wall 1 |
+//! | `Frame:SetMinResize`/`SetMaxResize` missing | `SideEffectMakeMoveable` died on every module frame | behind wall 2 |
+//!
+//! **The addon survey scored Quiver `loaded, session=ok, probe=ok` through all three.** It seats a
+//! WARRIOR, and every one of these is behind `if cl == "HUNTER"` — the same blind spot shape as
+//! Bagnon's (`ui_script::bagnon_render_tests`), one axis over: there the columns asked "did it
+//! raise" and never "did it draw"; here they ask both, of a session the addon declines to run in.
+//! So the fixture below seats a **hunter**, and that is the load-bearing part of it.
+//!
+//! Nothing from the corpus is committed, and the test skips cleanly on a machine without it — the
+//! `ui_chat::ace_gate_tests` rule.
+
+use std::path::{Path, PathBuf};
+
+use benilla_ui::script::{ScriptValue, UiScript, UnitState};
+use benilla_ui::toc::Toc;
+
+/// Where the vanilla addon corpus might be — `$BENILLA_ADDON_CORPUS`, else a sibling checkout
+/// resolved from this crate's manifest (a pool worktree's cwd is not stable across tool calls).
+fn corpus_candidates() -> Vec<PathBuf> {
+    let mut out = Vec::new();
+    if let Some(over) = std::env::var_os("BENILLA_ADDON_CORPUS") {
+        out.push(PathBuf::from(over));
+    }
+    let manifest = Path::new(env!("CARGO_MANIFEST_DIR"));
+    for up in [2usize, 3, 4] {
+        if let Some(root) = manifest.ancestors().nth(up) {
+            out.push(root.join("wow-addons-vanilla"));
+        }
+    }
+    out
+}
+
+/// The corpus root **and** a Quiver in it, or `None` — a skip, never a failure. Quiver is a live
+/// third-party addon (`github.com/SabineWren/Quiver`) whose shipped file is a generated bundle, so
+/// a machine that wants this test builds it into the corpus once.
+fn quiver_root() -> Option<PathBuf> {
+    corpus_candidates()
+        .into_iter()
+        .find(|c| c.join("Quiver").join("Quiver.toc").is_file())
+}
+
+macro_rules! quiver_or_skip {
+    () => {
+        match quiver_root() {
+            Some(root) => root,
+            None => {
+                eprintln!(
+                    "skipping: no Quiver in the addon corpus — looked in {:?} \
+                     (set $BENILLA_ADDON_CORPUS; the folder needs Quiver.toc + Quiver.bundle.lua)",
+                    corpus_candidates()
+                );
+                return;
+            }
+        }
+    };
+}
+
+fn read_toc(root: &Path, name: &str) -> Toc {
+    let path = root.join(name).join(format!("{name}.toc"));
+    Toc::parse(&benilla_ui::source::decode(
+        &std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e}", path.display())),
+    ))
+}
+
+/// One addon's `.toc` files through the same two arms the real loader uses (decision 1186).
+fn load_addon_files(script: &UiScript, root: &Path, name: &str) -> Vec<String> {
+    let toc = read_toc(root, name);
+    let provider = |req: &str| -> Option<Vec<u8>> { std::fs::read(root.join(req)).ok() };
+    let mut errors = Vec::new();
+    for file in &toc.files {
+        let path = benilla_ui::loader::join_ref(name, file);
+        let Ok(bytes) = std::fs::read(root.join(&path)) else {
+            errors.push(format!("{file}: not found"));
+            continue;
+        };
+        if file.to_ascii_lowercase().ends_with(".lua") {
+            if let Err(e) =
+                script.run_chunk_named(&bytes, &benilla_ui::script::addon_chunk_name(name, file))
+            {
+                errors.push(format!("{file}: {e}"));
+            }
+            continue;
+        }
+        match benilla_ui::framexml::parse(&benilla_ui::source::decode(&bytes)) {
+            Ok(doc) => {
+                let report = benilla_ui::loader::load_in(script, &doc, &path, &provider);
+                errors.extend(report.errors.into_iter().map(|e| format!("{file}: {e}")));
+            }
+            Err(e) => errors.push(format!("{file}: {e}")),
+        }
+    }
+    errors
+}
+
+/// A VM shaped like the reporter's session: our whole interface, and a **hunter** at the keyboard.
+///
+/// The class is the point (see the module doc). Everything else is the addon-survey seat's own
+/// minimum — a named player on a named realm, with a faction group, because a character in a real
+/// session always has all three and a nil one is a failure mode no player can produce.
+fn seat_a_hunter(root: &Path) -> UiScript {
+    let mut s = UiScript::new().expect("VM");
+    s.set_screen_size(1024.0, 768.0);
+    s.register_cvars(crate::cvars::REGISTERED.iter().copied());
+    s.set_realm_name("Harness");
+    s.set_unit(
+        "player",
+        Some(UnitState {
+            exists: true,
+            name: Some("Harness".into()),
+            health: 100,
+            max_health: 100,
+            level: 60,
+            power_type: 0,
+            power: 100,
+            max_power: 100,
+            race: Some("Night Elf".into()),
+            race_file: Some("NightElf".into()),
+            class: Some("Hunter".into()),
+            class_file: Some("HUNTER".into()),
+            sex: 2,
+            is_player: true,
+            faction_group: Some("Alliance".into()),
+            ..Default::default()
+        }),
+    );
+    // A HUNTER'S SPELLBOOK. Quiver's `Api.Spell.FindSpellIndex` opens
+    // `GetSpellTabInfo(GetNumSpellTabs())` and adds `offset + numSpells`, so an EMPTY book is
+    // `attempt to perform arithmetic on local 'tabOffset'` every tick — the reference answers nil
+    // there too, so that is the addon's own defect on a spell-less character and not a gap of
+    // ours. Seating a book is what lets this test TICK, which is where the module OnUpdates live.
+    // Two tabs and four spells is the addon-survey fixture's own shape, with a hunter's names.
+    {
+        use benilla_ui::script::{SpellBookState, SpellSlotView, SpellTabView};
+        let slot = |spell_id: u32, name: &str, rank: Option<&str>| SpellSlotView {
+            spell_id,
+            name: name.to_string(),
+            rank: rank.map(str::to_string),
+            texture: Some("Interface\\Icons\\INV_Misc_QuestionMark".into()),
+            ..Default::default()
+        };
+        s.set_spellbook(SpellBookState {
+            tabs: vec![
+                SpellTabView {
+                    name: "General".into(),
+                    texture: Some("Interface\\Icons\\INV_Misc_QuestionMark".into()),
+                    offset: 0,
+                    num_spells: 2,
+                },
+                SpellTabView {
+                    name: "Marksmanship".into(),
+                    texture: Some("Interface\\Icons\\Ability_Marksmanship".into()),
+                    offset: 2,
+                    num_spells: 2,
+                },
+            ],
+            slots: vec![
+                slot(6603, "Attack", None),
+                slot(75, "Auto Shot", None),
+                slot(2973, "Raptor Strike", Some("Rank 1")),
+                slot(1978, "Serpent Sting", Some("Rank 1")),
+            ],
+        });
+    }
+
+    let info = super::addons::info_from_toc("Quiver", &read_toc(root, "Quiver"));
+    s.register_addons(vec![info], Some(root.to_path_buf()), None, None);
+    let failures = super::load_default_ui(&s);
+    assert!(
+        failures.is_empty(),
+        "our own FrameXML failed to load: {failures:#?}"
+    );
+    s
+}
+
+/// **The reported symptom.** Load Quiver into a hunter's session, drive the session start the
+/// client drives, and ask the question the macro asked.
+///
+/// The assertion is deliberately the addon's own field and not "no errors": B267 was filed as a
+/// nil field, and a future wall inside `initSlashCommandsAndModules` would take this field out
+/// again even if it left a different error behind.
+#[test]
+fn quiver_publishes_its_global_functions_for_a_hunter() {
+    let root = quiver_or_skip!();
+    let mut s = seat_a_hunter(&root);
+
+    let load_errors = load_addon_files(&s, &root, "Quiver");
+    assert!(load_errors.is_empty(), "Quiver's files: {load_errors:#?}");
+
+    s.fire_event("ADDON_LOADED", vec![ScriptValue::Str("Quiver".into())]);
+    for e in ["VARIABLES_LOADED", "PLAYER_LOGIN", "PLAYER_ENTERING_WORLD"] {
+        s.fire_event(e, Vec::new());
+    }
+
+    // The macro the report ran: `/run Quiver.CastPetAction("Furious Howl"); …`
+    assert_eq!(
+        s.eval::<String>("return type(Quiver.CastPetAction)")
+            .unwrap(),
+        "function",
+        "B267: the addon's own field is nil because its VARIABLES_LOADED handler died \
+         before publishing it — errors so far: {:#?}",
+        s.errors()
+    );
+    // The whole of `RegisterGlobalFunctions`, not just the one the report named — they publish
+    // together, so any of them missing means the same handler died at the same place.
+    for name in [
+        "CastNoClip",
+        "CastPetAction",
+        "FdPrepareTrap",
+        "GetSecondsRemainingReload",
+        "GetSecondsRemainingShoot",
+        "PredMidShot",
+        "TrinketSwap1",
+        "TrinketSwap2",
+    ] {
+        assert_eq!(
+            s.eval::<String>(&format!("return type(Quiver.{name})"))
+                .unwrap(),
+            "function",
+            "Quiver.{name} was never published"
+        );
+    }
+}
+
+/// The session start itself raises **nothing** — the three walls, stated as the thing they were.
+///
+/// Separate from the field assertion above because it fails differently and more usefully: this is
+/// the test that names a *new* wall the moment one appears, instead of reporting a nil field.
+#[test]
+fn quiver_survives_a_hunter_session_start_without_raising() {
+    let root = quiver_or_skip!();
+    let mut s = seat_a_hunter(&root);
+    assert!(load_addon_files(&s, &root, "Quiver").is_empty());
+
+    s.fire_event("ADDON_LOADED", vec![ScriptValue::Str("Quiver".into())]);
+    for e in ["VARIABLES_LOADED", "PLAYER_LOGIN", "PLAYER_ENTERING_WORLD"] {
+        s.fire_event(e, Vec::new());
+    }
+    // …and then a second of frames, because Quiver's modules are OnUpdate-driven (the auto-shot
+    // timer, the range indicator, the aspect tracker) and a handler that only raises once it is
+    // *running* is invisible to the event burst alone.
+    for _ in 0..10 {
+        s.tick(0.1);
+    }
+    let raised = s.take_errors();
+    assert!(
+        raised.is_empty(),
+        "Quiver raised at session start: {raised:#?}"
+    );
+}
diff --git a/crates/benilla-app/src/vplates.rs b/crates/benilla-app/src/vplates.rs
index c58ee82c..64015363 100644
--- a/crates/benilla-app/src/vplates.rs
+++ b/crates/benilla-app/src/vplates.rs
@@ -79,7 +79,7 @@ use crate::entities::{overhead_anchor, BoneAttach, OverheadFallback};
 use crate::names::NameCache;
 use crate::net::{Guid, NetCommands, NetEntity, ObjectStore, Reputations, SelfPlayer};
 use crate::target::{ring_reaction, Factions, Hovered, Selection, TargetUpdate};
-use crate::ui_pass::{UiQuad, UiQuadAppend, UiQuads, UvRect};
+use crate::ui_pass::{overlay_z, UiQuad, UiQuadAppend, UiQuads, UvRect};
 use crate::ui_text::{layout_text_quads, FontSpec, Justify, UiFontAtlas};
 use benilla_assets::{AssetSet, WorldAssets};
 use benilla_world::view::WorldCamera;
@@ -172,13 +172,14 @@ const LIT_BOOST: f32 = 255.0 / 215.0;
 /// The plate quads' z keys — back→front: bar fill, then the border OVER it (the border art's
 /// rounded inner bevels cap the fill's square ends and crop the gradient's soft edges — the
 /// reference look, director-pinned from a ref crop 2026-07-07; corrects the §7 transcription's
-/// border-first order), then texts → skull; all above the floating combat text (z 0, a
-/// world-scene draw) and far below every scripted-UI packed key.
-const Z_FILL: u64 = 4;
-const Z_BORDER: u64 = 5;
-const Z_TEXT: u64 = 6;
-const Z_RAID: u64 = 7;
-const Z_SKULL: u64 = 8;
+/// border-first order), then texts → skull; all above the floating combat text and the chat
+/// bubbles (the append lane's lower bands, [`crate::ui_pass::overlay_z`]) and far below every
+/// scripted-UI packed key.
+const Z_FILL: u64 = overlay_z::VPLATE;
+const Z_BORDER: u64 = overlay_z::VPLATE + 1;
+const Z_TEXT: u64 = overlay_z::VPLATE + 2;
+const Z_RAID: u64 = overlay_z::VPLATE + 3;
+const Z_SKULL: u64 = overlay_z::VPLATE + 4;
 
 /// The bar-fill palette — the byte-confirmed dwords (`0xcf60d0/e8/c8/dc`): pure
 /// red/blue/yellow/green (NOT the ring's pale player-blue). Client-space sRGB, the [`UiQuads`]
diff --git a/crates/benilla-app/tests/world_api_wall.rs b/crates/benilla-app/tests/world_api_wall.rs
index ab4fb92c..3a65b3bb 100644
--- a/crates/benilla-app/tests/world_api_wall.rs
+++ b/crates/benilla-app/tests/world_api_wall.rs
@@ -256,7 +256,16 @@ fn is_instrument_consumer(rel: &str) -> bool {
 /// input, which is game-side; a one-field resource is the smallest honest expression of that. The
 /// alternative was ordering a game system against an engine system, which crosses this same line
 /// *and* publishes a schedule point to do it.
-const CEILING: usize = 159;
+/// And 159 → 160: `WorldLoadProgress::gx_pending`, a PUBLISH beside the two residency terms
+/// already through this door (`colliders_pending`, `merge_pending`). The retained pass (1429)
+/// moved the static world off the entity path, so a placement that has SPAWNED still draws
+/// nothing until its region bakes — and the game reads residency for two decisions the engine
+/// does not own: when the loading cover may lift, and when the post-snap physics hold may
+/// release (decision 0737's split). Both were answering "is the world there" with a fact that
+/// had stopped meaning it (decision 1498). The alternative was the game reaching into
+/// `StaticGx` itself, which is a whole engine subsystem through the door instead of one
+/// `usize` on the residency struct that exists to be read from outside.
+const CEILING: usize = 160;
 
 /// How far under [`CEILING`] the real count may sit before this test asks for the ceiling to be
 /// lowered. Slack, not tolerance: it keeps a single closure from failing the gate, while making it
diff --git a/crates/benilla-ui/src/script/button.rs b/crates/benilla-ui/src/script/button.rs
index 27509c3b..55a7cfd7 100644
--- a/crates/benilla-ui/src/script/button.rs
+++ b/crates/benilla-ui/src/script/button.rs
@@ -296,6 +296,38 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
         lua.create_function(|lua, this: Table| get_slot_texture(lua, &this, Slot::Text))?,
     )?;
 
+    // SetFontString(fontString) — ADOPT a caller-made FontString as this Button's label
+    // (`0x780a60`; the pointer it writes is the Button's `+0x338`, the field
+    // `GetFontString`/`SetText`/`GetTextWidth` all read — wow-re `widget-api-batch-benilla.md` Q8).
+    //
+    // The idiom it exists for: build the label yourself so you can style and place it, then hand it
+    // to the button so `SetText` and the per-state font machinery drive it.
+    //
+    //     local fs = btn:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+    //     btn:SetFontString(fs)
+    //
+    // Quiver's `Component/Select.wow.lua` builds every dropdown option row that way, and with the
+    // method nil the row died on its first line — the second of B267's three walls.
+    //
+    // Adoption only: no region is created, and the argument keeps its own parent and its own
+    // anchors (callers anchor it after the call as often as before). A non-region argument leaves
+    // the button unchanged rather than raising — the reference marshals it and writes a pointer,
+    // and what it does with a bad one is not byte-read.
+    m.set(
+        "SetFontString",
+        lua.create_function(|lua, (this, fs): (Table, Value)| {
+            let Value::Table(fs) = fs else { return Ok(()) };
+            let Ok(rh) = super::region::region_handle_of(lua, &fs) else {
+                return Ok(());
+            };
+            with_button(lua, &this, |bs| bs.text = Some(rh))?;
+            let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+            // The label is a measured region, and its new role feeds the button's text extents.
+            model.touch_measure(rh);
+            Ok(())
+        })?,
+    )?;
+
     // GetTextWidth / GetTextHeight — the Button's OWN text-extent readers (`0x782290` / `0x782390`,
     // wow-re `system/ui/scratch/item9-firing34-merge.md` l.36 and the Button method carve in
     // `widget-api-batch-benilla.md` Q8, which lists both present on Button and `GetStringWidth`
diff --git a/crates/benilla-ui/src/script/mod.rs b/crates/benilla-ui/src/script/mod.rs
index bc8c0325..daf62db6 100644
--- a/crates/benilla-ui/src/script/mod.rs
+++ b/crates/benilla-ui/src/script/mod.rs
@@ -99,6 +99,9 @@ mod pvp;
 mod quest;
 mod quest_log;
 mod region;
+/// The 19 Region-map methods, shared by frames and regions the way the reference shares them
+/// (decision 1501) — its header is the byte-verified chain and the bug that found the split.
+mod region_map;
 mod reputation;
 mod saved;
 mod scrollframe;
diff --git a/crates/benilla-ui/src/script/object.rs b/crates/benilla-ui/src/script/object.rs
index 51bfe699..a2841297 100644
--- a/crates/benilla-ui/src/script/object.rs
+++ b/crates/benilla-ui/src/script/object.rs
@@ -224,6 +224,9 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     super::statusbar::install(lua)?;
     super::button::install(lua)?;
     super::editbox::install(lua)?;
+    // AFTER every table above exists: collapse the 19 Region-map names to one shared
+    // implementation each, so a method pulled off a frame works on a texture (decision 1501).
+    super::region_map::install(lua)?;
 
     // Shared frame metatable: __index is a Rust dispatcher over the frame method table (RF-0023),
     // checking the frame's *kind-specific* method table first. Per-kind resolution matters beyond
diff --git a/crates/benilla-ui/src/script/object/layout_methods.rs b/crates/benilla-ui/src/script/object/layout_methods.rs
index 6302698c..4ab17362 100644
--- a/crates/benilla-ui/src/script/object/layout_methods.rs
+++ b/crates/benilla-ui/src/script/object/layout_methods.rs
@@ -78,6 +78,21 @@ pub(super) fn install(lua: &Lua, m: &Table) -> mlua::Result<()> {
             ))
         })?,
     )?;
+    // GetNumPoints() → how many anchors this frame carries. On the Region map (`0x87c9b8`), so
+    // every widget answers it — the region twin shipped first and noted this side was missing;
+    // collapsing the map to one implementation each (decision 1501) is what made the gap fatal
+    // rather than merely absent, and this is the arm it was missing.
+    m.set(
+        "GetNumPoints",
+        lua.create_function(|lua, this: Table| {
+            let h = frame_handle_of(lua, &this)?;
+            let model = lua.app_data_ref::<Model>().expect("model");
+            Ok(model
+                .layout_inputs
+                .get(&h)
+                .map_or(0, |i| i.anchors.len() as i64))
+        })?,
+    )?;
     // SetAllPoints([relativeTo]) — pin TOPLEFT+BOTTOMRIGHT to the target (default: the parent),
     // the XML `setAllPoints="true"` behavior as a method (rf24 `0x767800`'s SetAllPoints path).
     m.set(
diff --git a/crates/benilla-ui/src/script/object/movable.rs b/crates/benilla-ui/src/script/object/movable.rs
index 00dc66fd..272b2fe0 100644
--- a/crates/benilla-ui/src/script/object/movable.rs
+++ b/crates/benilla-ui/src/script/object/movable.rs
@@ -78,7 +78,7 @@
 //!   for both halves in the reference too — already covers the stop side of a resize that does
 //!   not exist yet.
 
-use mlua::{Lua, Table};
+use mlua::{Lua, MultiValue, Table, Value};
 
 use crate::script::Model;
 use crate::widget::FrameHandle;
@@ -155,6 +155,93 @@ pub(super) fn install(lua: &Lua, m: &Table) -> mlua::Result<()> {
         "IsResizable",
         lua.create_function(|lua, this: Table| get_flag(lua, &this, Flag::Resizable))?,
     )?;
+    // ── The resize-bounds quad — `Set/GetMinResize`, `Set/GetMaxResize` ────────────────────────
+    //
+    // Frame method table `0x878ec0`: `GetMinResize 0x775f20` · `SetMinResize 0x776020` ·
+    // `GetMaxResize 0x7761a0` · `SetMaxResize 0x7762a0`. The setters' `Usage:` strings are in the
+    // image verbatim — `0x8797b8 "Usage: %s:SetMinResize(minWidth, minHeight)"` and
+    // `0x8797e4 "Usage: %s:SetMaxResize(maxWidth, maxHeight)"` — so a bad argument RAISES, and
+    // that is what is reproduced here.
+    //
+    // **Who asks.** They are the second and third lines of every resizable-window kit, right after
+    // `SetResizable(true)`; Quiver's `SideEffectMakeMoveable` calls `SetMinResize` on every module
+    // frame it builds, and with the method nil its `OnEnable` died before the addon's
+    // `VARIABLES_LOADED` handler could publish anything (bug B267's third wall).
+    //
+    // **Two halves are out with wow-re and fold into ONE place** ([`clamp_resize`]): whether the
+    // client's "unbounded" is a `0` sentinel the getters hand back (ours answers `nil`), and
+    // whether the clamp binds only the drag pump (what we do) or every size write. Neither changes
+    // the surface below.
+    for (name, upper) in [("MinResize", false), ("MaxResize", true)] {
+        m.set(
+            format!("Set{name}"),
+            lua.create_function(move |lua, args: MultiValue| {
+                let mut it = args.into_iter();
+                let this = match it.next() {
+                    Some(Value::Table(t)) => t,
+                    _ => return Err(mlua::Error::runtime("expected a frame")),
+                };
+                let h = frame_handle_of(lua, &this)?;
+                // The pair is required. `lua_isnumber` accepts a numeric STRING too, which is why
+                // this reads the values through the same coercion the rest of the surface uses
+                // rather than demanding `Value::Number`.
+                let pair = (it.next(), it.next());
+                let num = |v: &Option<Value>| match v {
+                    Some(Value::Number(n)) => Some(*n as f32),
+                    Some(Value::Integer(i)) => Some(*i as f32),
+                    Some(Value::String(s)) => s.to_str().ok()?.parse::<f32>().ok(),
+                    _ => None,
+                };
+                let (Some(w), Some(hgt)) = (num(&pair.0), num(&pair.1)) else {
+                    let model = lua.app_data_ref::<Model>().expect("model");
+                    let who = model
+                        .arena
+                        .frame(h)
+                        .and_then(|f| f.name.clone())
+                        .unwrap_or_else(|| "<unnamed>".to_string());
+                    let verb = if upper {
+                        "SetMaxResize"
+                    } else {
+                        "SetMinResize"
+                    };
+                    let (a, b) = if upper {
+                        ("maxWidth", "maxHeight")
+                    } else {
+                        ("minWidth", "minHeight")
+                    };
+                    return Err(mlua::Error::runtime(format!(
+                        "Usage: {who}:{verb}({a}, {b})"
+                    )));
+                };
+                let mut model = lua.app_data_mut::<Model>().expect("model");
+                if let Some(f) = model.arena.frame_mut(h) {
+                    if upper {
+                        f.max_resize = Some((w, hgt));
+                    } else {
+                        f.min_resize = Some((w, hgt));
+                    }
+                }
+                Ok(())
+            })?,
+        )?;
+        m.set(
+            format!("Get{name}"),
+            lua.create_function(move |lua, this: Table| {
+                let h = frame_handle_of(lua, &this)?;
+                let model = lua.app_data_ref::<Model>().expect("model");
+                let bound =
+                    model
+                        .arena
+                        .frame(h)
+                        .and_then(|f| if upper { f.max_resize } else { f.min_resize });
+                Ok(match bound {
+                    Some((w, hgt)) => (Value::Number(f64::from(w)), Value::Number(f64::from(hgt))),
+                    None => (Value::Nil, Value::Nil),
+                })
+            })?,
+        )?;
+    }
+
     // SetUserPlaced(flag) / IsUserPlaced() — bit 0x1000 (`0x776a50`/`0x776b40`), the client's "the
     // user placed this frame; persist its position across sessions" bit, and the one setter of the
     // three that is GUARDED: `776adb: test ah,0x3` refuses unless the frame is movable OR
@@ -381,15 +468,31 @@ pub(crate) fn start_title_move(model: &mut Model, h: FrameHandle) -> bool {
     true
 }
 
-/// Pump an in-flight move to the cursor at `pos` — the engine half of `0x7655b0`, run from
-/// [`crate::script::UiScript::mouse_move`] beside [`crate::script::cursor::maybe_start_drag`] and,
-/// like it, BEFORE the hover-boundary early return (a frame dragged around underneath the cursor
-/// crosses no boundary at all, so a move parked behind that return would only advance when the
-/// cursor happened to leave the frame).
+/// Apply a frame's `SetMinResize`/`SetMaxResize` bounds to a proposed size.
 ///
-/// Applies `(pos − sample)` scaled into the frame's anchor offsets and re-centers the sample; a
-/// zero delta does nothing at all, and a frame that died mid-move ends the move rather than
-/// writing to a dead handle.
+/// **The one place the two open halves of the resize-bounds RE fold into.** Today: an unset bound
+/// is unbounded, the floor with no `SetMinResize` is the `1.0` this function inherited from the
+/// drag pump it was extracted from, and the *only* caller is [`advance_size`] — so a programmatic
+/// `SetWidth` past a bound is currently not clamped. wow-re is deriving whether the client clamps
+/// there too, and what its no-bound floor really is; both answers land here and nowhere else.
+///
+/// A `min` above a `max` resolves in `min`'s favour (the clamp order below), which is the only
+/// self-consistent reading of a contradiction and is also out with wow-re.
+fn clamp_resize(model: &Model, h: FrameHandle, w: f32, hgt: f32) -> (f32, f32) {
+    let (min, max) = model
+        .arena
+        .frame(h)
+        .map_or((None, None), |f| (f.min_resize, f.max_resize));
+    let mut w = w;
+    let mut hgt = hgt;
+    if let Some((mw, mh)) = max {
+        w = w.min(mw);
+        hgt = hgt.min(mh);
+    }
+    let (fw, fh) = min.unwrap_or((1.0, 1.0));
+    (w.max(fw), hgt.max(fh))
+}
+
 /// Pump an in-flight `StartSizing`: move the gripped edges to the cursor, leave the others.
 ///
 /// The mirror of [`advance_move`] — same sample-and-recentre, same dead-frame bail, same
@@ -409,9 +512,6 @@ pub(crate) fn advance_size(model: &mut Model, pos: (f32, f32)) {
     }
     let inv = 1.0 / eff_scale(model, sz.frame);
     let (dx, dy) = (dx * inv, dy * inv);
-    let Some(input) = model.layout_inputs.get_mut(&sz.frame) else {
-        return;
-    };
     // Width grows when the RIGHT grip goes right, or the LEFT grip goes left. Height likewise with
     // y-up: the TOP grip going up grows it, the BOTTOM grip going down grows it.
     let dw = if sz.right {
@@ -428,9 +528,21 @@ pub(crate) fn advance_size(model: &mut Model, pos: (f32, f32)) {
     } else {
         0.0
     };
-    let (w0, h0) = (input.width, input.height);
-    input.width = (input.width + dw).max(1.0);
-    input.height = (input.height + dh).max(1.0);
+    let Some((w0, h0)) = model
+        .layout_inputs
+        .get(&sz.frame)
+        .map(|i| (i.width, i.height))
+    else {
+        return;
+    };
+    // The frame's own `SetMinResize`/`SetMaxResize` bounds — read before the mutable borrow, and
+    // the only place they bind today (see `clamp_resize`).
+    let (new_w, new_h) = clamp_resize(model, sz.frame, w0 + dw, h0 + dh);
+    let Some(input) = model.layout_inputs.get_mut(&sz.frame) else {
+        return;
+    };
+    input.width = new_w;
+    input.height = new_h;
     let mut moved = input.width.to_bits() != w0.to_bits() || input.height.to_bits() != h0.to_bits();
     // The planted edge: a frame anchored by its LEFT that is gripped on the LEFT has to move too,
     // or the resize would push the right edge instead. Only the gripped axis shifts.
@@ -460,6 +572,15 @@ pub(crate) fn advance_size(model: &mut Model, pos: (f32, f32)) {
     model.sizing = Some(FrameSizing { sample: pos, ..sz });
 }
 
+/// Pump an in-flight move to the cursor at `pos` — the engine half of `0x7655b0`, run from
+/// [`crate::script::UiScript::mouse_move`] beside [`crate::script::cursor::maybe_start_drag`] and,
+/// like it, BEFORE the hover-boundary early return (a frame dragged around underneath the cursor
+/// crosses no boundary at all, so a move parked behind that return would only advance when the
+/// cursor happened to leave the frame).
+///
+/// Applies `(pos − sample)` scaled into the frame's anchor offsets and re-centers the sample; a
+/// zero delta does nothing at all, and a frame that died mid-move ends the move rather than
+/// writing to a dead handle.
 pub(crate) fn advance_move(model: &mut Model, pos: (f32, f32)) {
     let Some(mv) = model.moving else { return };
     if model.arena.frame(mv.frame).is_none() {
diff --git a/crates/benilla-ui/src/script/region_map.rs b/crates/benilla-ui/src/script/region_map.rs
new file mode 100644
index 00000000..58ea2bcc
--- /dev/null
+++ b/crates/benilla-ui/src/script/region_map.rs
@@ -0,0 +1,140 @@
+//! **The Region method map, reached by frames and regions alike** — the 19 names of the client's
+//! `0x87c9b8` table, each ONE callable that works on a Frame, a Texture or a FontString.
+//!
+//! ## The fact this exists for (byte-verified in `WoW.exe`, decision 1501)
+//!
+//! 1.12.1's widget inheritance is not a Lua metatable chain: every class owns a flat
+//! `{name, lua_CFunction}` `.data` table, and its lookup probes that table and, on a miss,
+//! **tail-calls exactly one base class's lookup** (wow-re
+//! `system/ui/scratch/widget-api-batch-benilla.md`):
+//!
+//! ```text
+//! Region   0x87c9b8 (19)  lookup 0x7a2ea0  → TERMINAL (root)
+//! ├─ Frame        0x878ec0 (68)  lookup 0x778590 → 0x7a2ea0
+//! ├─ Texture      0x87c128 (22)  lookup 0x79c620 → 0x7a2ea0
+//! └─ FontString   0x87c1d8 (32)  lookup 0x79ee20 → 0x7a2ea0
+//! ```
+//!
+//! Parsing the two tables out of the image directly, **`Frame ∩ Region = ∅`**: not one of the 19
+//! is re-registered by Frame, so every Frame-derived class reaches the *same* function a Texture
+//! does. `WorldFrame.GetHeight` **is** `0x7a2030`, byte-for-byte the function
+//! `someTexture:GetHeight()` resolves to.
+//!
+//! That is why this is not a curiosity. The idiom
+//!
+//! ```lua
+//! local _Height = WorldFrame.GetHeight     -- pull the method off ANY widget, once
+//! …
+//! local h = _Height(someTexture)           -- and apply it to ANY other
+//! ```
+//!
+//! is ordinary, correct 1.12 Lua. Quiver's `Api/Index.wow.lua` is built on it
+//! (`_Height = WorldFrame.GetHeight`, `_Width = WorldFrame.GetWidth`), and benilla raised
+//! `stale or invalid frame handle` on it, from inside the addon's `VARIABLES_LOADED` handler,
+//! **before** the handler's last line got to publish `Quiver.CastPetAction` — which is the whole
+//! of bug B267. One split method surface, one nil field, one dead addon.
+//!
+//! ## Why it is a bridge rather than a merge
+//!
+//! Our two implementations of each name are not redundant: a frame's size reads `layout_inputs`
+//! and divides its edges by `GetEffectiveScale`, a region's reads `region_data` and does not; a
+//! frame's `GetParent` can answer nil, a region's never can; a region's `GetPoint` resolves a
+//! `relativeTo` that may be a sibling *region*. Those differences are correct, and they are the
+//! same shape the reference has: `Region:GetHeight 0x7a2030` reads the receiver's layout
+//! sub-object and calls `[vtable+0x20]`, which `CSimpleFontString` **overrides**. One name, one
+//! entry point, per-kind behaviour behind it.
+//!
+//! So each of the 19 becomes one function that resolves the receiver *first* and then hands the
+//! whole argument list to the arm that owns that kind — and that single function is written into
+//! every method table the reference's chain would reach: the frame table, the region table, the
+//! Texture and FontString leaf tables, and the title region's narrower copy. Identity holds the
+//! way the binary's does — `WorldFrame.GetHeight == someTexture.GetHeight` is true here too.
+//!
+//! **Exactly the 19, and no more.** `Show`/`Hide`/`IsShown`/`IsVisible`/`SetAlpha`/`GetAlpha` look
+//! like they belong and do not: Frame and Texture each register their *own*, at different
+//! addresses (`texture-fontstring-method-split.md` §3), so `WorldFrame.Show(someTexture)` fails on
+//! the real client and must keep failing here. `SetSize` is in neither table — it is 1.12-absent
+//! and ours, so it stays where it is. The map is the unit.
+
+use mlua::{Function, Lua, MultiValue, Table, Value};
+
+use super::object::decode_id;
+use super::{
+    Model, REGION_MAP_METHODS, REG_FONTSTRING_METHODS, REG_FRAME_METHODS, REG_REGION_METHODS,
+    REG_TEXTURE_METHODS, REG_TITLE_METHODS,
+};
+
+/// Which side of the object model a wrapper's `T[0]` id names. Ids come from one counter
+/// ([`Model::next_id`]), so a region id can never be mistaken for a frame's.
+enum Side {
+    Frame,
+    Region,
+}
+
+/// `Err` when the table is not a widget wrapper at all (that error names the real problem and is
+/// worth keeping); `Ok(None)` when it *is* one whose widget no longer exists.
+fn side_of(lua: &Lua, this: &Table) -> mlua::Result<Option<Side>> {
+    let id = decode_id(this)?;
+    let model = lua.app_data_ref::<Model>().expect("model app_data");
+    Ok(if model.id_to_frame.contains_key(&id) {
+        Some(Side::Frame)
+    } else if model.id_to_region.contains_key(&id) {
+        Some(Side::Region)
+    } else {
+        None
+    })
+}
+
+/// Replace each of the 19 Region-map entries in every table the chain reaches with one shared
+/// function that dispatches on the receiver.
+///
+/// Runs **after** `region::install` (which is what builds the region, leaf and title tables) and
+/// after `install_frame_methods`; every table it names is already populated by then.
+pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
+    let frame: Table = lua.named_registry_value(REG_FRAME_METHODS)?;
+    let region: Table = lua.named_registry_value(REG_REGION_METHODS)?;
+    let leaves: Vec<Table> = [
+        REG_TEXTURE_METHODS,
+        REG_FONTSTRING_METHODS,
+        REG_TITLE_METHODS,
+    ]
+    .into_iter()
+    .map(|k| lua.named_registry_value::<Table>(k))
+    .collect::<mlua::Result<_>>()?;
+
+    for name in REGION_MAP_METHODS {
+        // Both arms must already exist. A missing one is not a thing to paper over with a
+        // one-sided shared function: the reference gives every widget all 19, so a gap on either
+        // side is a hole in the surface and says so here rather than at some addon's call site.
+        // (`GetNumPoints` was exactly that hole on the frame side until this module went in.)
+        let on_frame: Function = frame.get(name).map_err(|_| {
+            mlua::Error::runtime(format!("Region map: the FRAME table has no {name}"))
+        })?;
+        let on_region: Function = region.get(name).map_err(|_| {
+            mlua::Error::runtime(format!("Region map: the REGION table has no {name}"))
+        })?;
+        let shared = lua.create_function(move |lua, args: MultiValue| {
+            // The receiver is argument 1 on every one of the 19 — a method call always passes it,
+            // and a pulled-off `Api._Height(x)` call passes it as the only argument.
+            let Some(Value::Table(this)) = args.iter().next().cloned() else {
+                return Err(mlua::Error::runtime(
+                    "expected a frame or region as the first argument",
+                ));
+            };
+            match side_of(lua, &this)? {
+                Some(Side::Frame) => on_frame.call::<MultiValue>(args),
+                Some(Side::Region) => on_region.call::<MultiValue>(args),
+                // A wrapper whose widget is gone. Deliberately ONE message for both sides — at
+                // this point the receiver's kind is exactly what could not be established, and
+                // each side's old wording claimed it.
+                None => Err(mlua::Error::runtime("stale or invalid widget handle")),
+            }
+        })?;
+        frame.set(name, shared.clone())?;
+        region.set(name, shared.clone())?;
+        for leaf in &leaves {
+            leaf.set(name, shared.clone())?;
+        }
+    }
+    Ok(())
+}
diff --git a/crates/benilla-ui/src/script/tests/mod.rs b/crates/benilla-ui/src/script/tests/mod.rs
index 893d0b24..3be6c281 100644
--- a/crates/benilla-ui/src/script/tests/mod.rs
+++ b/crates/benilla-ui/src/script/tests/mod.rs
@@ -25,6 +25,7 @@ mod minimap;
 mod movable;
 mod object_model;
 mod reference_surface;
+mod region_map;
 mod regions;
 mod scrollframe;
 mod setparent;
diff --git a/crates/benilla-ui/src/script/tests/region_map.rs b/crates/benilla-ui/src/script/tests/region_map.rs
new file mode 100644
index 00000000..1e4bd6f3
--- /dev/null
+++ b/crates/benilla-ui/src/script/tests/region_map.rs
@@ -0,0 +1,173 @@
+//! **The Region map is ONE function per name, reached by frames and regions alike** — the
+//! [`crate::script::region_map`] law, and the regression guard for bug B267.
+//!
+//! Its header carries the byte evidence (`Frame ∩ Region = ∅`, parsed out of the two `.data`
+//! method tables). What is pinned here is the two things a reader of the code could not otherwise
+//! check: that the sharing is real *by identity*, and that it stops exactly at the 19.
+//!
+//! The reported symptom this file exists for: Quiver's `Api/Index.wow.lua` opens
+//! `_Height = WorldFrame.GetHeight`, applies it to a Texture and a FontString, and benilla raised
+//! `stale or invalid frame handle` — inside the addon's `VARIABLES_LOADED` handler, four lines
+//! before it published `Quiver.CastPetAction`. The addon's own field was nil at macro time because
+//! the handler never finished, which is what got filed.
+
+use crate::script::UiScript;
+
+/// A VM with one frame, one texture and one fontstring, each reachable by a global name.
+fn vm() -> UiScript {
+    let mut s = UiScript::new().unwrap();
+    s.set_screen_size(1024.0, 768.0);
+    s.run(
+        r#"
+        Host = CreateFrame("Frame", "Host")
+        Host:SetWidth(200) Host:SetHeight(120)
+        Host:SetPoint("CENTER", nil, "CENTER", 0, 0)
+        Tex = Host:CreateTexture("HostTex", "ARTWORK")
+        Tex:SetWidth(64) Tex:SetHeight(32)
+        Tex:SetPoint("TOPLEFT", Host, "TOPLEFT", 0, 0)
+        Str = Host:CreateFontString("HostStr", "OVERLAY")
+        Str:SetWidth(50) Str:SetHeight(10)
+        Str:SetPoint("BOTTOMRIGHT", Host, "BOTTOMRIGHT", 0, 0)
+        "#,
+    )
+    .unwrap();
+    s
+}
+
+/// Every one of the 19 is the **same Lua value** on a Frame, a Texture and a FontString.
+///
+/// Not a stand-in for the behaviour tests below: identity is what makes the pulled-off-method
+/// idiom work *for a method the test author never thought of*. In the client it holds because
+/// Frame's table does not carry any of the 19 and its lookup tail-calls Region's; here it holds
+/// because one function is written into every table that chain reaches.
+#[test]
+fn the_region_map_is_one_function_on_every_widget() {
+    let s = vm();
+    for m in crate::script::REGION_MAP_METHODS {
+        let same: bool = s
+            .eval(&format!(
+                "return Host.{m} == Tex.{m} and Tex.{m} == Str.{m} and Host.{m} ~= nil"
+            ))
+            .unwrap();
+        assert!(
+            same,
+            "{m} must be ONE function on frame, texture and string"
+        );
+    }
+}
+
+/// **The bug, reduced to its four lines.** A method pulled off a frame and applied to a region.
+#[test]
+fn a_method_pulled_off_a_frame_works_on_a_texture_and_a_fontstring() {
+    let s = vm();
+    // Quiver's own shape: `Api._Height = WorldFrame.GetHeight`, applied to `r.Icon` (a Texture)
+    // and `r.Label` (a FontString), from a table built at file scope.
+    let (th, sh): (f32, f32) = s
+        .eval(
+            r#"
+            local _Height = Host.GetHeight
+            return _Height(Tex), _Height(Str)
+            "#,
+        )
+        .unwrap();
+    assert_eq!((th, sh), (32.0, 10.0));
+
+    let (tw, sw): (f32, f32) = s
+        .eval(
+            r#"
+            local _Width = Host.GetWidth
+            return _Width(Tex), _Width(Str)
+            "#,
+        )
+        .unwrap();
+    assert_eq!((tw, sw), (64.0, 50.0));
+
+    // …and the setter half, which is the same split and would have been the next wall.
+    s.run("local _SetW = Host.SetWidth _SetW(Tex, 99)").unwrap();
+    assert_eq!(s.eval::<f32>("return Tex:GetWidth()").unwrap(), 99.0);
+}
+
+/// The other direction — a method pulled off a **region** and applied to a **frame**. Same one
+/// function, so this cannot be made to work by special-casing the reported direction.
+#[test]
+fn a_method_pulled_off_a_texture_works_on_a_frame() {
+    let s = vm();
+    let h: f32 = s.eval("local g = Tex.GetHeight return g(Host)").unwrap();
+    assert_eq!(h, 120.0);
+    let name: String = s.eval("local n = Str.GetName return n(Host)").unwrap();
+    assert_eq!(name, "Host");
+    let kind: String = s
+        .eval("local t = Tex.GetObjectType return t(Host)")
+        .unwrap();
+    assert_eq!(kind, "Frame");
+}
+
+/// Each receiver keeps its OWN behaviour behind the shared name — the per-kind arms are not
+/// collapsed into one. `GetObjectType` is the cleanest witness (three different answers), and
+/// `GetParent` is the one whose two arms genuinely differ (a region's owner is never nil).
+#[test]
+fn one_name_still_dispatches_per_kind() {
+    let s = vm();
+    let (f, t, g): (String, String, String) = s
+        .eval("return Host:GetObjectType(), Tex:GetObjectType(), Str:GetObjectType()")
+        .unwrap();
+    assert_eq!(
+        (f.as_str(), t.as_str(), g.as_str()),
+        ("Frame", "Texture", "FontString")
+    );
+    // The region arm answers its OWNER; the frame arm answers nil for a parentless top frame.
+    let owner: String = s.eval("return Tex:GetParent():GetName()").unwrap();
+    assert_eq!(owner, "Host");
+    assert!(s.eval::<bool>("return Host:GetParent() == nil").unwrap());
+}
+
+/// `GetNumPoints` — on the Region map, so **every** widget answers it. The frame arm did not
+/// exist until the map was collapsed to one implementation; the region arm shipped alone.
+#[test]
+fn get_num_points_answers_on_a_frame_too() {
+    let s = vm();
+    assert_eq!(s.eval::<i64>("return Host:GetNumPoints()").unwrap(), 1);
+    assert_eq!(s.eval::<i64>("return Tex:GetNumPoints()").unwrap(), 1);
+    s.run("Host:SetPoint(\"TOPLEFT\", nil, \"TOPLEFT\", 0, 0)")
+        .unwrap();
+    assert_eq!(s.eval::<i64>("return Host:GetNumPoints()").unwrap(), 2);
+    s.run("Host:ClearAllPoints()").unwrap();
+    assert_eq!(s.eval::<i64>("return Host:GetNumPoints()").unwrap(), 0);
+}
+
+/// **The carve's other edge, and the control that keeps it honest.** These six look like they
+/// belong to the Region map and do not: Frame, Texture and FontString each register their *own*
+/// at different addresses (`texture-fontstring-method-split.md` §3 — Texture `SetAlpha 0x79b580`
+/// vs FontString `0x79cb70`, and Frame's own `0x79b...` twin). So `WorldFrame.Show(someTexture)`
+/// fails on the real client, and hoisting them here to make more addon code work would be the
+/// superset decision 1189 had to take back out.
+#[test]
+fn the_six_look_alikes_are_not_shared() {
+    let s = vm();
+    for m in [
+        "Show",
+        "Hide",
+        "IsShown",
+        "IsVisible",
+        "SetAlpha",
+        "GetAlpha",
+    ] {
+        let shared: bool = s.eval(&format!("return Host.{m} == Tex.{m}")).unwrap();
+        assert!(
+            !shared,
+            "{m} is registered per class in 1.12 and must NOT be hoisted onto the Region map"
+        );
+    }
+}
+
+/// A receiver that is not a widget at all raises, and says *why* — the bridge resolves the
+/// receiver before either arm runs, so this error must not be flattened into a generic one.
+#[test]
+fn a_non_widget_receiver_raises_and_names_the_reason() {
+    let s = vm();
+    let err = s
+        .eval::<f32>("return Host.GetHeight({})")
+        .unwrap_err()
+        .to_string();
+    assert!(err.contains("T[0] identity"), "unexpected error: {err}");
+}
diff --git a/crates/benilla-ui/src/widget/mod.rs b/crates/benilla-ui/src/widget/mod.rs
index 80b117e8..725937af 100644
--- a/crates/benilla-ui/src/widget/mod.rs
+++ b/crates/benilla-ui/src/widget/mod.rs
@@ -283,6 +283,21 @@ pub struct Frame {
     /// `StartSizing` half of the same family. Default false. benilla stores and reports the flag;
     /// no resize *drag* is built (`StopMovingOrSizing` already covers the stop side of both).
     pub resizable: bool,
+    /// `SetMinResize` / `SetMaxResize` — the interactive-resize bounds (`0x776020` / `0x7762a0`,
+    /// with `GetMinResize 0x775f20` / `GetMaxResize 0x7761a0`; all four on the Frame method table
+    /// `0x878ec0`). `None` = that bound was never set, i.e. unbounded on both axes.
+    ///
+    /// A window kit's opening lines are `SetResizable(true)` + these two, and without them a
+    /// `StartSizing` drag has nothing to stop it — Quiver's `SideEffectMakeMoveable` calls
+    /// `SetMinResize` on every module frame it builds and died on the nil method (part of B267).
+    ///
+    /// **The sentinel and the enforcement points are out with wow-re** (`0` may be the client's
+    /// "unbounded", and whether the clamp binds only the drag pump or every size write is the
+    /// load-bearing half). Until that lands, `None` is unbounded and only the drag pump clamps —
+    /// `script::object::movable::clamp_resize` is the single place either answer folds into.
+    pub min_resize: Option<(f32, f32)>,
+    /// The upper twin of [`Frame::min_resize`] — see its doc.
+    pub max_resize: Option<(f32, f32)>,
     /// `SetUserPlaced` — the client's "the user placed this frame; persist its position across
     /// sessions" bit. Default false. Stored and readable (`IsUserPlaced`); **nothing consumes it
     /// yet** — persisting a frame's position belongs with the layout cache, not with the drag that
@@ -578,6 +593,10 @@ impl WidgetArena {
             // it, at the level it was created with.
             movable: false,
             resizable: false,
+            // No frame is born with resize bounds: both are opt-in, and a frame nobody bounded
+            // resizes freely (see the field docs — the client's own sentinel is out with wow-re).
+            min_resize: None,
+            max_resize: None,
             user_placed: false,
             toplevel: false,
             scale,
diff --git a/crates/benilla-world/src/static_gx/bake.rs b/crates/benilla-world/src/static_gx/bake.rs
index 5214f99f..9664c117 100644
--- a/crates/benilla-world/src/static_gx/bake.rs
+++ b/crates/benilla-world/src/static_gx/bake.rs
@@ -34,6 +34,9 @@ pub(super) fn flush_static_gx(mut gx: ResMut<StaticGx>, mut meshes: ResMut<Asset
             gx.declined_logged = d;
         }
     }
+    // The reveal gate's "publish what you have" (see [`StaticGx::flush_now`]): consumed here, so
+    // one request bakes one flush's worth of dirty regions and the windows resume next frame.
+    let now = std::mem::take(&mut gx.flush_now);
     let StaticGx {
         cells,
         wmos,
@@ -42,7 +45,7 @@ pub(super) fn flush_static_gx(mut gx: ResMut<StaticGx>, mut meshes: ResMut<Asset
         ..
     } = &mut *gx;
     for (&cell, state) in cells.iter_mut() {
-        if !bake_due(state, world.cells.contains_key(&cell), frame) {
+        if !bake_due(state, world.cells.contains_key(&cell), frame, now) {
             continue;
         }
         state.dirty = false;
@@ -68,7 +71,7 @@ pub(super) fn flush_static_gx(mut gx: ResMut<StaticGx>, mut meshes: ResMut<Asset
         world.cells.insert(cell, std::sync::Arc::new(baked));
     }
     for (&instance, state) in wmos.iter_mut() {
-        if !bake_due(state, world.wmos.contains_key(&instance), frame) {
+        if !bake_due(state, world.wmos.contains_key(&instance), frame, now) {
             continue;
         }
         state.dirty = false;
@@ -99,7 +102,7 @@ pub(super) fn flush_static_gx(mut gx: ResMut<StaticGx>, mut meshes: ResMut<Asset
     // grain — the sort keeps runs set-homogeneous, and the published draw carries the
     // region's set list beside the per-set bounds `bake_cell` accumulated into `groups`.
     for (&instance, state) in props.iter_mut() {
-        if !bake_due(state, world.props.contains_key(&instance), frame) {
+        if !bake_due(state, world.props.contains_key(&instance), frame, now) {
             continue;
         }
         state.dirty = false;
@@ -126,15 +129,21 @@ pub(super) fn flush_static_gx(mut gx: ResMut<StaticGx>, mut meshes: ResMut<Asset
     }
 }
 
-/// Is this region's bake due? A FIRST bake waits only the short window (fast appearance); a
+/// Is this region's bake due? `now` is the reveal gate's request ([`StaticGx::flush_now`]) and
+/// overrides every window — the arrival burst it batches is known to be over.
+///
+/// Otherwise: a FIRST bake waits only the short window (fast appearance); a
 /// re-bake of a published region waits for the LONG quiet window (B3, decision 1432 — the
 /// admission trickle arrives spaced wider than the short window, so B2 re-baked cells once
 /// per arrival for minutes; 1431's cost map priced it), with the age cap so a never-quiet
 /// region still consolidates.
-fn bake_due(state: &super::GxCell, published: bool, frame: u32) -> bool {
+fn bake_due(state: &super::GxCell, published: bool, frame: u32, now: bool) -> bool {
     if !state.dirty {
         return false;
     }
+    if now {
+        return true;
+    }
     let window = if published {
         REBAKE_FRAMES
     } else {
@@ -349,27 +358,49 @@ mod tests {
     #[test]
     fn the_bake_waits_short_first_and_long_after() {
         let mut state = super::super::GxCell::default();
-        assert!(!bake_due(&state, false, 100), "clean cells are never due");
+        assert!(
+            !bake_due(&state, false, 100, false),
+            "clean cells are never due"
+        );
         state.dirty = true;
         state.dirty_since = 0;
         state.last_change = 0;
-        assert!(!bake_due(&state, false, IDLE_FRAMES - 1));
+        assert!(!bake_due(&state, false, IDLE_FRAMES - 1, false));
         assert!(
-            bake_due(&state, false, IDLE_FRAMES),
+            bake_due(&state, false, IDLE_FRAMES, false),
             "first bake: short window"
         );
         assert!(
-            !bake_due(&state, true, IDLE_FRAMES),
+            !bake_due(&state, true, IDLE_FRAMES, false),
             "published: short is not enough"
         );
-        assert!(!bake_due(&state, true, REBAKE_FRAMES - 1));
+        assert!(!bake_due(&state, true, REBAKE_FRAMES - 1, false));
         assert!(
-            bake_due(&state, true, REBAKE_FRAMES),
+            bake_due(&state, true, REBAKE_FRAMES, false),
             "published: long window"
         );
+        // The reveal gate's request overrides every window: a load that has finished arriving
+        // publishes what it holds instead of waiting out the quiet timer (decision 1498).
+        state.last_change = IDLE_FRAMES;
+        assert!(
+            !bake_due(&state, false, IDLE_FRAMES, false),
+            "still quiet-timing"
+        );
+        assert!(
+            bake_due(&state, false, IDLE_FRAMES, true),
+            "flush_now: due now"
+        );
+        assert!(bake_due(&state, true, IDLE_FRAMES, true), "…published too");
+        state.dirty = false;
+        assert!(
+            !bake_due(&state, false, IDLE_FRAMES, true),
+            "flush_now still bakes nothing that is not dirty"
+        );
+        state.dirty = true;
+        state.last_change = 0;
         // A cell that keeps changing (never quiet) still consolidates at the age cap.
         state.last_change = MAX_DIRTY_FRAMES;
-        assert!(bake_due(&state, true, MAX_DIRTY_FRAMES));
+        assert!(bake_due(&state, true, MAX_DIRTY_FRAMES, false));
     }
 
     /// A quiet cell bakes: one recentred mesh whose draws sort by (bucket, texture), each
diff --git a/crates/benilla-world/src/static_gx/mod.rs b/crates/benilla-world/src/static_gx/mod.rs
index 69640e5c..9a8f407a 100644
--- a/crates/benilla-world/src/static_gx/mod.rs
+++ b/crates/benilla-world/src/static_gx/mod.rs
@@ -55,10 +55,13 @@
 //! the aniso-8 samplers, and the two-sided normal law (the entity shader's `select` UNDOES a
 //! bevy negation this pipeline never had — copying it flipped every back-facing canopy card).
 //!
-//! **Known B1 gaps, deliberate** (B2+ owns them): no `presentable()` coupling — an unbaked
-//! cell can show a hole for a beat on a cold arrival where the merge publishes
-//! `merge_pending` into the reveal cover (1419); dev-instrument identity (inspector/WOW_PICK
-//! name nothing — the weld/merge trade, one side table if missed).
+//! **Known B1 gaps** (B2+ owns them): dev-instrument identity (inspector/WOW_PICK name nothing
+//! — the weld/merge trade, one side table if missed). The other one B1 left open — no
+//! `presentable()` coupling, so an unbaked region shows a hole for a beat on a cold arrival
+//! where the merge publishes `merge_pending` into the reveal cover (1419) — is **CLOSED by
+//! 1498**: [`StaticGx::undrawn_regions`] is that coupling, and [`StaticGx::flush_now`] is why
+//! it costs the load no extra frames. It was not a beat: it was the director's report of
+//! teleporting into a Stormwind with no Stormwind in it.
 //!
 //! **B3 (decision 1432): the churn 1431 priced is paid.** Texture arrays are ONE SHARED POOL
 //! across every cell and region (dedup by asset id; `pool.rs` owns the design note), layer
@@ -438,6 +441,9 @@ pub struct StaticGx {
     /// Lifetime exile-event counters (spawns, re-admits, gone-despawns) — the census line's
     /// churn instrument.
     fade_events: [u32; 3],
+    /// [`StaticGx::flush_now`]'s request: the next flush ignores every quiet window. Consumed
+    /// (cleared) by that flush.
+    flush_now: bool,
 }
 
 /// The divert hook's per-call facts (everything is in scope at `assemble.rs`'s gate).
@@ -544,6 +550,81 @@ pub struct GxWmoBatch {
 }
 
 impl StaticGx {
+    /// **Collected geometry that draws nothing yet** — regions holding items whose bake has not
+    /// published (a first bake still inside its quiet window, [`IDLE_FRAMES`]).
+    ///
+    /// A retained region is a *hole in the frame* between the divert and its first publish: the
+    /// entity path no longer draws that geometry (slice 2 moved WMO group geometry here
+    /// wholesale), so a spawned building whose region has not baked is a building that is not on
+    /// screen. The reveal gate ([`crate::terrain_stream::WorldLoadProgress`]) reads this, which
+    /// is why it is published as a fact rather than left an internal of the bake.
+    ///
+    /// A *re-bake* of an already-published region is deliberately NOT counted: that region keeps
+    /// drawing its previous bake meanwhile, so it is content on screen, not a hole.
+    pub(crate) fn undrawn_regions(&self) -> usize {
+        let world = &self.world;
+        let cells = self
+            .cells
+            .iter()
+            .filter(|(k, s)| s.dirty && !s.items.is_empty() && !world.cells.contains_key(*k))
+            .count();
+        let wmos = self
+            .wmos
+            .iter()
+            .filter(|(k, s)| s.dirty && !s.items.is_empty() && !world.wmos.contains_key(*k))
+            .count();
+        let props = self
+            .props
+            .iter()
+            .filter(|(k, s)| s.dirty && !s.items.is_empty() && !world.props.contains_key(*k))
+            .count();
+        cells + wmos + props
+    }
+
+    /// The WMO lane's headline numbers for an instrument: regions **collected**, regions
+    /// **published** (baked, so drawable at all), and regions the cull **selected** this frame.
+    /// Collected-but-unpublished is the reveal hole [`Self::undrawn_regions`] counts; published
+    /// minus selected is ordinary culling.
+    pub fn wmo_census(&self) -> (usize, usize, usize) {
+        (
+            self.wmos.len(),
+            self.world.wmos.len(),
+            self.world.visible_wmos.len(),
+        )
+    }
+
+    /// What this frame's scene walk actually **selected to draw** — doodad/prop draw entries,
+    /// WMO regions selected, and the admitted group bits summed across them. The companion to
+    /// [`Self::wmo_census`]: that one says what geometry EXISTS and is drawable, this one says
+    /// how much of it the cull let through. A frame where everything is published and almost
+    /// nothing is selected is a visibility fault, not a residency one — the distinction the
+    /// reveal audit could not make.
+    pub fn draw_census(&self) -> (usize, usize, usize) {
+        let groups = self
+            .world
+            .visible_wmos
+            .iter()
+            .map(|(_, bits)| bits.iter().filter(|b| **b).count())
+            .sum();
+        (
+            self.world.visible.len(),
+            self.world.visible_wmos.len(),
+            groups,
+        )
+    }
+
+    /// **Bake every dirty region on the next flush, quiet window or not** — what the reveal gate
+    /// asks for once nothing more is arriving.
+    ///
+    /// The quiet windows ([`IDLE_FRAMES`]/[`REBAKE_FRAMES`]) exist to batch an *arrival trickle*
+    /// during play. The end of a load is not a trickle: the streamer knows the burst is over
+    /// (every wanted tile spawned, every focus placement up, the collider queue quiet), and
+    /// waiting another 15 frames there is 15 frames of a city that has spawned and cannot draw.
+    /// So the end of the burst says "publish what you have" instead of arming another timer.
+    pub(crate) fn flush_now(&mut self) {
+        self.flush_now = true;
+    }
+
     /// Take one eligible batch instead of spawning it (or merging it). Returns `false` — and
     /// tallies why — when the batch's facts fall outside the prototype's lane; the caller then
     /// falls through to the ordinary path, exactly like a refused merge divert.
@@ -882,6 +963,27 @@ mod tests {
     use super::testkit::{batch, tri};
     use super::*;
 
+    /// A diverted batch is collected geometry that draws NOTHING until its region bakes — the
+    /// reveal hole [`StaticGx::undrawn_regions`] exists to publish, and the fact the reveal gate
+    /// keys on (decision 1498). Publishing the region clears it; a re-bake of a published region
+    /// is not a hole, because the previous bake is still on screen.
+    #[test]
+    fn a_collected_region_is_undrawn_until_it_publishes() {
+        let mut gx = StaticGx::default();
+        let g = tri([0.0; 3]);
+        assert_eq!(
+            gx.undrawn_regions(),
+            0,
+            "nothing collected, nothing pending"
+        );
+        assert!(gx.divert(batch(&g, Vec3::ZERO, None, ModelBlend::Opaque)));
+        assert_eq!(gx.undrawn_regions(), 1, "diverted, unbaked — a hole");
+        // What the bake does when it publishes a region: clears `dirty`.
+        let cell = *gx.cells.keys().next().unwrap();
+        gx.cells.get_mut(&cell).unwrap().dirty = false;
+        assert_eq!(gx.undrawn_regions(), 0, "baked — on screen");
+    }
+
     /// The collector refuses exactly the recorded exclusion families — and says so in the
     /// census — while an eligible batch diverts (1429's no-silent-caps note).
     #[test]
diff --git a/crates/benilla-world/src/terrain_stream.rs b/crates/benilla-world/src/terrain_stream.rs
index ae0fb5cf..b80db97e 100644
--- a/crates/benilla-world/src/terrain_stream.rs
+++ b/crates/benilla-world/src/terrain_stream.rs
@@ -99,6 +99,12 @@ pub struct TerrainStreamer {
     /// WMO-only map that one building is the whole world, so there is nothing else to stream.
     /// Cleared on map change, which also releases the placement.
     global_wmo: bool,
+    /// [`ViewFocus::paced`] as of last frame — so the residency latch can re-arm on the EDGE into
+    /// a load rather than on the level. A viewer with no avatar publishes `paced: false` forever
+    /// (`ViewFocus::camera`), and re-arming on the level would leave that viewer walking its focus
+    /// neighbourhood's every placement every frame for the rest of the run — the settled-work scan
+    /// the latch exists to stop.
+    was_paced: bool,
 }
 
 /// The placement id the map-global WMO is registered under. A WMO-only map authors **no** ADT tiles
@@ -234,6 +240,16 @@ pub struct WorldLoadProgress {
     pub merge_pending: usize,
     /// Focus-neighbourhood placements not yet spawned (the wait instrument's term).
     pub placements_pending: usize,
+    /// Retained-pass regions collected but not yet drawable (`StaticGx::undrawn_regions`) —
+    /// geometry that has *spawned* and still draws nothing.
+    ///
+    /// Since slice 2 (1429/1430) a WMO's group geometry leaves the entity path for the retained
+    /// pass, so "the placement spawned" stopped meaning "the building is on screen": between the
+    /// divert and its first bake the region is a hole. The reveal used to be gated on the spawn
+    /// alone and therefore lifted up to `IDLE_FRAMES` before the buildings could draw — a city of
+    /// bare ground for a quarter second. Same conservative semantics as the collider and merge
+    /// backlogs beside it.
+    pub gx_pending: usize,
     /// **Which tile these facts are about** — the focus tile the streamer computed this frame.
     /// `None` until the streamer first runs (and again after `release_world`). The settle release
     /// compares it against the tile under the avatar's own feet and refuses the resident release on
@@ -271,7 +287,10 @@ impl WorldLoadProgress {
     /// The world at the focus is presentable — the scene term plus a quiet collider queue. What
     /// both consumers (the screen clear here, the settle release in the streamer) key on.
     pub fn presentable(&self) -> bool {
-        self.scene_ready && self.colliders_pending == 0 && self.merge_pending == 0
+        self.scene_ready
+            && self.colliders_pending == 0
+            && self.merge_pending == 0
+            && self.gx_pending == 0
     }
 }
 
@@ -944,6 +963,8 @@ fn stream_terrain(
     // "ready to reveal" means the buildings and trees around you exist, not just bare terrain. A
     // focus tile that doesn't exist (map edge) counts as resident so we never get stuck waiting
     // for ground that isn't there.
+    // The pacing edge, read and advanced once per frame (see [`TerrainStreamer::was_paced`]).
+    let was_paced = std::mem::replace(&mut state.was_paced, focus.paced);
     if let Some(p) = load_progress.as_mut() {
         p.focus_tile = Some((cx, cy));
         // Resident = the focus tile is furnished — judged from the DESIRED set, not from the
@@ -982,6 +1003,18 @@ fn stream_terrain(
         if !p.focus_resident {
             p.complete = false;
         }
+        // A **snap** re-arms it too, even onto ground that is already resident. `paced` is false
+        // exactly through entry, a teleport and a world swap (the game writes it from the settle
+        // hold), and a near teleport — `.tele` across a city, a summon — lands on furnished ground
+        // whose *buildings* may still be arriving. Without this the latch answers a fresh
+        // destination with the departure's converged numbers: `scene_ready` reads true because it
+        // was true where we left, and both consumers (the cover, the settle release) are told a
+        // world is presentable that nobody has looked at yet.
+        //
+        // On the EDGE into the load, not on the level — see [`TerrainStreamer::was_paced`].
+        if was_paced && !focus.paced {
+            p.complete = false;
+        }
         if !p.complete {
             // "Spawned" means FURNISHED (root + every cell): the furnisher is uncapped while the
             // cover is up, so this costs entry nothing — but it keeps a reveal from ever showing a
@@ -1037,6 +1070,27 @@ fn stream_terrain(
             }
             p.complete = p.scene_ready && p.is_ready();
         }
+        // The retained pass's own residency (1429's lane): geometry that has spawned and cannot
+        // draw yet is a hole in the reveal exactly like an unattached collider is a hole in the
+        // floor. Published every frame — one map walk, no per-item work — because both consumers
+        // read `presentable()` and neither can see the bake.
+        p.gx_pending = staticgx
+            .as_deref()
+            .map_or(0, crate::static_gx::StaticGx::undrawn_regions);
+        // …and once nothing else is outstanding, the burst is over by definition: ask the pass to
+        // publish what it holds instead of letting the quiet window add its own 15 frames to the
+        // end of every load. Gated on the load itself (`!paced` — entry, a teleport, a world
+        // swap), so steady-state play keeps the batching the windows exist for.
+        if !focus.paced
+            && p.gx_pending > 0
+            && p.scene_ready
+            && p.colliders_pending == 0
+            && p.merge_pending == 0
+        {
+            if let Some(gx) = staticgx.as_deref_mut() {
+                gx.flush_now();
+            }
+        }
         // Residency is *published* here and read by the mover's post-snap hold one stage later
         // (`player::release_post_snap_hold`). The streamer is still the only authority on which
         // map the colliders under the avatar belong to — it just states the fact now instead of
diff --git a/crates/benilla-world/src/view.rs b/crates/benilla-world/src/view.rs
index 98f84cd2..c7a2c3cd 100644
--- a/crates/benilla-world/src/view.rs
+++ b/crates/benilla-world/src/view.rs
@@ -182,10 +182,140 @@ pub const CAM_NEAR: f32 = 1.0 / 9.0;
 /// [`crate::sun`]'s projection note); naming it here just stops the consumers drifting apart.
 pub const CAM_FOVY: f32 = std::f32::consts::FRAC_PI_4;
 
+/// **The world camera's world pose, made current before anything in `Update` reads it** — the
+/// set every `Update`-stage viewer authority must order after.
+///
+/// Bevy propagates `GlobalTransform` in `PostUpdate`. For the whole of `Update`, therefore, a
+/// camera's `GlobalTransform` is the pose it had **last** frame, while its `Transform` — written
+/// by the controller in [`crate::schedule::WorldStage::Input`] — is this frame's. Walking, the two
+/// differ by centimetres and nothing shows. On the frame a teleport snaps they differ by the whole
+/// jump, and an authority that decides *what may draw* off the stale one gates a frame drawn from
+/// the new pose with a verdict about the old place (decision 1503).
+#[derive(SystemSet, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct CameraPoseSet;
+
+/// Copy the world camera's `Transform` into its `GlobalTransform` (see [`CameraPoseSet`]).
+///
+/// **Root cameras only.** The world camera is spawned unparented (both the fallback and the real
+/// one), and for a root the propagation Bevy will run in `PostUpdate` is exactly this copy — so
+/// this makes the same value available earlier and `PostUpdate` recomputes it identically. A
+/// camera that ever acquires a parent keeps Bevy's propagated value and its old one-frame lag,
+/// which is no worse than before and never silently wrong: the pose it reports is a real pose the
+/// camera had, just not this frame's.
+///
+/// Written through `set_if_neq` so a still camera does not flag `Changed<GlobalTransform>` every
+/// frame for the consumers that key on it.
+/// The root world cameras and their two transforms — see [`publish_camera_pose`].
+type RootCameraPose<'w, 's> =
+    Query<'w, 's, (&'static Transform, &'static mut GlobalTransform), RootCamera>;
+/// A world camera Bevy will propagate as a root (no parent to inherit from).
+type RootCamera = (With<WorldCamera>, Without<ChildOf>);
+
+pub(crate) fn publish_camera_pose(mut cam: RootCameraPose) {
+    for (t, mut g) in &mut cam {
+        g.set_if_neq(GlobalTransform::from(*t));
+    }
+}
+
+/// The view lane's plugin — today, [`publish_camera_pose`] and its ordering contract.
+pub(crate) struct ViewPlugin;
+
+impl Plugin for ViewPlugin {
+    fn build(&self, app: &mut App) {
+        plugin(app);
+    }
+}
+
+pub(crate) fn plugin(app: &mut App) {
+    app.add_systems(
+        Update,
+        publish_camera_pose
+            .in_set(CameraPoseSet)
+            // After the controller that writes the camera's `Transform`
+            // ([`crate::schedule::WorldStage::Input`]) — the point of the whole system is to
+            // publish the pose the controller just chose, not the one before it.
+            .after(crate::schedule::WorldStage::Input),
+    );
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use bevy::ecs::system::RunSystemOnce;
 
+    /// The contract of [`CameraPoseSet`]: a system ordered after it, in the same `Update`, reads
+    /// the pose the controller wrote **this** frame — not the one Bevy will propagate at the end
+    /// of it. Written as the frame it fixes: move the camera the way a teleport snap does, and
+    /// assert the downstream authority sees the destination.
+    #[test]
+    fn a_reader_after_the_pose_set_sees_this_frames_camera() {
+        #[derive(Resource, Default)]
+        struct Seen(Vec3);
+
+        fn snap_the_camera(mut cam: Query<&mut Transform, With<WorldCamera>>) {
+            for mut t in &mut cam {
+                t.translation = Vec3::new(500.0, 0.0, 0.0);
+            }
+        }
+        fn read_the_pose(cam: Query<&GlobalTransform, With<WorldCamera>>, mut seen: ResMut<Seen>) {
+            for g in &cam {
+                seen.0 = g.translation();
+            }
+        }
+
+        let mut app = App::new();
+        app.init_resource::<Seen>();
+        app.configure_sets(Update, crate::schedule::WorldStage::Input);
+        app.add_systems(
+            Update,
+            snap_the_camera.in_set(crate::schedule::WorldStage::Input),
+        );
+        plugin(&mut app);
+        app.add_systems(Update, read_the_pose.after(CameraPoseSet));
+        app.world_mut().spawn((
+            WorldCamera,
+            Transform::default(),
+            GlobalTransform::default(),
+        ));
+
+        app.update();
+        assert_eq!(
+            app.world().resource::<Seen>().0,
+            Vec3::new(500.0, 0.0, 0.0),
+            "an Update-stage viewer authority must see the snapped pose, not the frame-old one"
+        );
+    }
+
+    /// A **parented** camera is left to Bevy's propagation: a plain copy of a child's local
+    /// `Transform` would be a wrong pose, which is worse than a frame-old right one.
+    #[test]
+    fn a_parented_camera_is_left_alone() {
+        let mut app = App::new();
+        plugin(&mut app);
+        let parent = app.world_mut().spawn(Transform::default()).id();
+        let child = app
+            .world_mut()
+            .spawn((
+                WorldCamera,
+                Transform::from_xyz(7.0, 0.0, 0.0),
+                GlobalTransform::default(),
+            ))
+            .id();
+        app.world_mut().entity_mut(parent).add_child(child);
+
+        app.world_mut()
+            .run_system_once(publish_camera_pose)
+            .unwrap();
+        assert_eq!(
+            app.world()
+                .entity(child)
+                .get::<GlobalTransform>()
+                .unwrap()
+                .translation(),
+            Vec3::ZERO,
+            "the child's local transform is not a world pose"
+        );
+    }
     /// The wall is planar depth along camera-forward, measured to the sphere's nearest point.
     #[test]
     fn planar_depth_of_the_nearest_point() {
diff --git a/crates/benilla-world/src/wmo_portal/mod.rs b/crates/benilla-world/src/wmo_portal/mod.rs
index 637779b9..d8cc0c93 100644
--- a/crates/benilla-world/src/wmo_portal/mod.rs
+++ b/crates/benilla-world/src/wmo_portal/mod.rs
@@ -293,7 +293,13 @@ impl Plugin for WmoPortalPlugin {
                 track_area_interior,
                 track_unit_interiors,
             )
-                .in_set(WmoPvsSet),
+                .in_set(WmoPvsSet)
+                // **On this frame's camera pose, not last frame's** (decision 1503). The flood,
+                // the interior claim and the exterior windows all key on the eye, and every one of
+                // them decides what the frame is allowed to draw. Unordered, this set could even
+                // run before the controller had moved the camera at all; ordered here it answers
+                // about the eye the frame will be rendered from.
+                .after(crate::view::CameraPoseSet),
         );
     }
 }
@@ -323,6 +329,8 @@ fn compute_wmo_pvs(
     };
     let clip_from_world = proj.get_clip_from_view() * cam_t.to_matrix().inverse();
     let eye_world = cam_t.translation();
+    // Publish the pose this authority ran on (see [`WmoCullProbe::eye`]).
+    probe.eye = eye_world;
     // The terrain leg of the seed's down-ray, sampled once for the camera's column: the client casts the
     // same segment at the ground and drops the WMO hit when the ground is nearer (`FUN_006821f0`).
     let terrain = terrain_height_under(&streamer, &adt_tiles, eye_world);
diff --git a/crates/benilla-world/src/wmo_portal/probe.rs b/crates/benilla-world/src/wmo_portal/probe.rs
index 90f4bfd4..96b09e65 100644
--- a/crates/benilla-world/src/wmo_portal/probe.rs
+++ b/crates/benilla-world/src/wmo_portal/probe.rs
@@ -18,6 +18,11 @@ use super::{
 pub struct WmoCullProbe {
     /// Set by the panel's dump button; the next compute writes the trace file and clears it.
     pub dump_requested: bool,
+    /// **The eye the PVS, the interior claim and the exterior windows were computed from** —
+    /// the visibility authority's own pose, recorded so an instrument can compare it against the
+    /// pose the frame actually draws from. Ordinary movement makes the two identical to within a
+    /// centimetre; a snap is where they can disagree by the whole teleport.
+    pub eye: Vec3,
 }
 
 /// Where the dump button writes its trace — under `target/` so it never lands in the repo.
diff --git a/crates/benilla-world/src/world_census.rs b/crates/benilla-world/src/world_census.rs
index d8d07e66..bcdea2e7 100644
--- a/crates/benilla-world/src/world_census.rs
+++ b/crates/benilla-world/src/world_census.rs
@@ -50,6 +50,8 @@ pub struct WorldCensus<'w, 's> {
     claim: Option<Res<'w, CameraInteriorClaim>>,
     windows: Option<Res<'w, ExteriorWindows>>,
     verdict: Option<Res<'w, ExteriorCullVerdict>>,
+    /// The visibility authority's own pose (see [`CensusReport::pvs_eye`]).
+    cull_probe: Option<Res<'w, crate::wmo_portal::WmoCullProbe>>,
     /// Which backdrop is drawing — the gradient dome, or a building's own MOSB sky
     /// ([`crate::wmo_sky`]). Optional for the same reason as the portal terms above.
     skybox: Option<Res<'w, crate::wmo_sky::CameraWmoSkybox>>,
@@ -103,6 +105,12 @@ pub struct CensusReport {
     pub room: Option<String>,
     /// `"unrestricted"`, or the number of window sub-frusta. `None` with [`CensusReport::room`].
     pub windows: Option<String>,
+    /// **The eye the portal authority computed [`Self::room`], [`Self::windows`] and every group's
+    /// PVS from.** Not necessarily the eye this frame draws from: the authority runs in `Update`
+    /// off the camera's propagated transform, so it is answering about wherever the camera was
+    /// when that transform was last written. Walking makes the difference a centimetre; a
+    /// teleport makes it the whole jump, and this is the column that says so.
+    pub pvs_eye: Option<Vec3>,
     /// The backdrop actually drawing: `"dome"` for the `Light.dbc` gradient, else the WMO skybox
     /// model a building's PVS asked for. `None` when the WMO-sky lane is not installed.
     ///
@@ -263,6 +271,7 @@ impl WorldCensus<'_, '_> {
             particles,
             room,
             windows,
+            pvs_eye: self.cull_probe.as_deref().map(|p| p.eye),
             sky,
             ribbons: self.ribbons.as_deref().map(|r| (r.trails, r.drawn)),
             cull: self.verdict.as_deref().map(|v| CullTerms {
diff --git a/crates/benilla-world/src/world_plugins.rs b/crates/benilla-world/src/world_plugins.rs
index 1ff5f2d4..ae564528 100644
--- a/crates/benilla-world/src/world_plugins.rs
+++ b/crates/benilla-world/src/world_plugins.rs
@@ -177,6 +177,10 @@ impl PluginGroup for WorldPlugins {
             // streamer fills its volume registry).
             .add(crate::interior::InteriorPlugin)
             .add(crate::entity_shade::EntityShadePlugin)
+            // The world camera's pose, published before the `Update`-stage viewer authorities
+            // below read it (decision 1503) — without it they answer about where the camera was
+            // last frame, which on a teleport frame is the place we just left.
+            .add(crate::view::ViewPlugin)
             // WMO portal visibility: per-frame, decides which of a building's groups are reachable
             // through portals from the camera's group, so the Stormwind cathedral culls from the
             // Trade District. Only computes the PVS; the `Visibility` authority