diff --git a/crates/benilla-app/src/chat_bubble.rs b/crates/benilla-app/src/chat_bubble.rs
index 1a91b740..71565963 100644
--- a/crates/benilla-app/src/chat_bubble.rs
+++ b/crates/benilla-app/src/chat_bubble.rs
@@ -1,13 +1,19 @@
-//! Chat bubbles, `CGChatBubbleFrame`: the speech bubble a chat line spawns over the speaker, a
-//! 2-D overlay like the V-plate ([`crate::vplates`]).
+//! Chat bubbles, `CGChatBubbleFrame`: the speech bubble a chat line spawns over the speaker. This
+//! file owns the world side (gate, lifetime, fade, anchor, projection, stacking order, sizes); the
+//! widgets, real `WorldFrame` children an addon can skin, live in
+//! [`benilla_ui::script::chat_bubble`].
 //!
 //! - Spawn (`0x608ac0`, from the `SMSG_MESSAGECHAT` display path): the sender resolves to a live
 //!   unit, its CVar is on, the text is non-empty, the unit carries no V-plate (`0x608adc`; a live
 //!   bubble in turn hides the overhead name, [`BubblesActive`]), and the local player is within
 //!   20 yd (3-D). Self is not excluded. A new line replaces the old bubble, never queues.
-//! - Anchor (`0x4b0c30`): unit z + height × model scale + 0.7, bottom-seated, growing upward. The
-//!   height is the Stand sequence box's Z extent from the model header (`0x711a20`), not the posed
-//!   attachment the overhead name reads (`0x608640`), latched once per chat line.
+//! - Lifetime and fade (`0x4b0c30`): a 250 ms fade in, the line's [`duration_ms`], a 250 ms fade
+//!   out, then the frame goes back to the pool. Out of range, or with the speaker not drawn in the
+//!   last render ([`speaker_drawn`]), it fades out and hides, and fades back in on return.
+//! - Anchor (`0x4b0c30`): unit z + height × model scale + 0.7, the text's BOTTOM on the projected
+//!   point (`0x4b157a`), growing upward. The height is the Stand sequence box's Z extent from the
+//!   model header (`0x711a20`), not the posed attachment the overhead name reads (`0x608640`),
+//!   latched once per chat line.
 //! - Stacking (`0x4b1060`): every frame the bubbles sort farthest-first by camera distance and
 //!   take frame levels 2, 3, 4…, so whole cards stack with the nearest speaker's on top.
 //!
@@ -17,25 +23,20 @@
 //! Deviation: sizes ride the plates' damped diagonal basis ([`plate_basis`]), not the unbounded
 //! reference law, so bubble text and plate text keep one em at every window size.
 //!
-//! Not built: the reference also fades a bubble whose speaker's model data is not resident or whose
-//! scene-entity flag is clear (`0x7103d0`/`0x6704c0`); only distance is re-tested here.
+//! Not built: the reference also ends a bubble whose speaker's model data is not resident
+//! (`0x7103d0`); here a speaker with no model yet only counts as not drawn.
 
 use std::collections::HashMap;
 
 use bevy::ecs::entity::EntityHashSet;
 use bevy::prelude::*;
 
-use benilla_ui::layout::Rect as GxRect;
-use benilla_ui::script::{inset_atlas_bleed, pieces, Backdrop, Insets};
-use benilla_ui::script::{JustifyH, JustifyV, Outline};
+use benilla_ui::script::{BubbleGeometry, BubbleState};
 
 use crate::entities::StandBoxHeight;
 use crate::net::{Embodied, Guid, NetEntity, SelfGuid};
 use crate::ui_chat::{default_color, ChatEventKind};
-use crate::ui_pass::{overlay_z, UiQuad, UiQuadAppend, UiQuads, UvRect};
-use crate::ui_text::{layout_text_quads, measure_text, FontSpec, Justify, TextSeat, UiFontAtlas};
-use crate::vplates::{device_snap, gx_px, plate_basis, text_px, VPlateSet, VPlates};
-use benilla_assets::{AssetSet, WorldAssets};
+use crate::vplates::{gx_px, plate_basis, text_px, VPlateSet, VPlates};
 use benilla_world::view::WorldCamera;
 
 /// The two bubble CVars (registrar `0x603280`), booting at the reference's defaults.
@@ -56,40 +57,22 @@ impl Default for BubbleConfig {
     }
 }
 
-/// The bubble art (`0x4b0940`).
-const BG_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Background";
-const EDGE_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Backdrop";
-const TAIL_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Tail";
-
 /// The 0.7 yd lift over the anchor height (`[0x7ffd7c]`).
 const LIFT: f32 = 0.7;
-/// The spawn and per-frame range gate, 20 yd squared (`[0x806798]`, the plates' too).
+/// The range gate, 20 yd squared (`[0x806798]`, the plates' too): a spawn passes at or under it
+/// (`0x608ba0`), a live bubble stays in range only under it (`0x4b0cd2`).
 const MAX_DIST_SQ: f32 = 400.0;
-/// The 250 ms linear fade, in and out (`0x4b0ea0`/`0x4b0ee0`).
-const FADE_SECS: f32 = 0.25;
-/// `NAMEPLATE_FONT` at 0.01 gx, the plate name's em.
+/// The linear fade, in and out, in ms (`0x4b0d3e`, `0x4b0d78`).
+const FADE_MS: u64 = 250;
+/// `NAMEPLATE_FONT` at 0.01 gx (`0x4b0b21`), the plate name's em.
 const TEXT_H: f32 = 0.01;
-/// The body margin around the text layout, all four sides (`0x3c23d70a`).
+/// The frame's margin around the text, all four sides (`0x3c23d70a`).
 const MARGIN: f32 = 0.01;
 /// The text wrap hard cap, gx (`[0x80679c]` = 0.2).
 const WRAP_W: f32 = 0.2;
 /// The border unit (edge size, insets, tail side): 16/1024 of the screen width.
 const BORDER_FRAC: f32 = 16.0 / 1024.0;
 
-/// Paint order inside one bubble's level: the tail covers the bottom edge piece and the text draws
-/// last, as the reference's batch drains textures before font strings (`0x76fb00`).
-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`, farthest first: the reference's per-frame
-/// `SetFrameLevel(2 + i)` walk (`0x4b12d5`-`0x4b1312`), one level per bubble, under the V-plates.
-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
-}
-
 /// The CVar gating this kind's bubble (`0x608b0d`); `None` for a kind that does not bubble.
 fn bubble_cvar(kind: ChatEventKind, cfg: &BubbleConfig) -> Option<bool> {
     use ChatEventKind as K;
@@ -100,87 +83,73 @@ fn bubble_cvar(kind: ChatEventKind, cfg: &BubbleConfig) -> Option<bool> {
     }
 }
 
-/// The word count (`0x4b1810`): maximal runs of characters other than space and tab.
-fn word_count(text: &str) -> u32 {
-    let mut words = 0u32;
-    let mut in_word = false;
-    for b in text.bytes() {
-        let sep = b == b' ' || b == b'\t';
-        if !sep && !in_word {
-            words += 1;
-        }
-        in_word = !sep;
-    }
-    words
-}
-
-/// The lifetime (`0x4b1810`): `base + perWord·(words−1)` ms, 2750/750 for others and 1500/500
-/// for the local player.
-fn duration_secs(words: u32, is_self: bool) -> f32 {
-    if words == 0 {
-        return 0.0;
+/// The lifetime in ms (`0x4b1810`) over the displayed text: the base, plus the per-word step for
+/// each space or tab that ends a word, 2750/750 for others and 1500/500 for the local player. An
+/// empty text lasts 0; separators alone, the base.
+fn duration_ms(text: &str, is_self: bool) -> u64 {
+    if text.is_empty() {
+        return 0;
     }
     let (base, per) = if is_self { (1500, 500) } else { (2750, 750) };
-    (base + per * (words - 1)) as f32 / 1000.0
+    let mut ms = base;
+    // Starts as if after a separator, so a leading run adds nothing.
+    let mut after_sep = true;
+    for b in text.bytes() {
+        let sep = b == b' ' || b == b'\t';
+        if sep && !after_sep {
+            ms += per;
+        }
+        after_sep = sep;
+    }
+    ms
 }
 
-/// Bubble text is plain, coloured only by chat type: colour escapes and hyperlink wrappers strip
-/// (their display text stays), and `||` stays escaped for the glyph layout's markup parser.
+/// The bubble's copy of the line (`0x4b1600`, into a 0x800-byte buffer): `||` stays escaped for the
+/// text's markup parser; any other `|` jumps to the next `[`, or ends the text if there is none;
+/// from there the brackets drop, and a `|h` then a `|r` right after the `]` skip. So a link shows
+/// its bare name and a colour code with no link after it cuts the line short.
 fn sanitize(text: &str) -> String {
+    const BUF: usize = 0x800 - 1;
     let b = text.as_bytes();
-    let mut out = String::with_capacity(text.len());
+    let mut out: Vec<u8> = Vec::with_capacity(b.len());
     let mut i = 0;
-    while i < b.len() {
+    while i < b.len() && out.len() < BUF {
         if b[i] != b'|' {
-            // Copy the whole non-escape run at once (UTF-8 safe: '|' is single-byte).
-            let start = i;
-            while i < b.len() && b[i] != b'|' {
-                i += 1;
-            }
-            out.push_str(&text[start..i]);
+            out.push(b[i]);
+            i += 1;
             continue;
         }
-        match b.get(i + 1) {
-            Some(b'|') => {
-                out.push_str("||");
-                i += 2;
-            }
-            Some(b'c') | Some(b'C') if i + 10 <= b.len() => i += 10,
-            Some(b'r') | Some(b'R') => i += 2,
-            Some(b'H') => {
-                // Skip the opener through its `|h`; the closing `|h` drops in the arm below.
-                i += 2;
-                while i < b.len() && !(b[i] == b'|' && b.get(i + 1) == Some(&b'h')) {
+        if b.get(i + 1) == Some(&b'|') {
+            out.extend_from_slice(b"||");
+            i += 2;
+            continue;
+        }
+        let Some(open) = b[i..].iter().position(|&c| c == b'[') else {
+            break;
+        };
+        i += open;
+        while i < b.len() {
+            match b[i] {
+                b'[' => i += 1,
+                b']' => {
+                    i += 1;
+                    for skip in [b"|h", b"|r"] {
+                        if b[i..].starts_with(skip) {
+                            i += 2;
+                        }
+                    }
+                    break;
+                }
+                c => {
+                    out.push(c);
                     i += 1;
                 }
-                i += 2;
-            }
-            Some(b'h') => i += 2,
-            // A dangling or unknown escape renders as a literal pipe.
-            _ => {
-                out.push_str("||");
-                i += 1;
             }
         }
     }
-    out
-}
-
-/// The bleed inset for one border piece; zero texels (no patch chain) leaves the UVs alone.
-fn pieces_inset(uvs: [[f32; 2]; 4], texels: Vec2) -> [[f32; 2]; 4] {
-    if texels.x <= 0.0 || texels.y <= 0.0 {
-        return uvs;
-    }
-    inset_atlas_bleed(uvs, texels.x, texels.y)
-}
-
-/// The frame's bottom-left origin, bottom-center on the seat. Deviation: snapped onto the device
-/// pixel grid ([`device_snap`]) so the border art blits 1:1; the reference seats it fractionally.
-fn seat_origin(seat: Vec2, w: f32, scale: f32) -> Vec2 {
-    Vec2::new(
-        device_snap(seat.x - w * 0.5, scale),
-        device_snap(seat.y, scale),
-    )
+    out.truncate(BUF);
+    // Cut only at ASCII bytes, so whole characters, but for the buffer cap.
+    String::from_utf8_lossy(&out).into_owned()
 }
 
 /// The border unit in logical px: 16/1024 of the screen width, in the damped size basis.
@@ -221,69 +190,161 @@ impl BubbleQueue {
     }
 }
 
+/// `[bubble+0x320]` bit 1: fading in.
+const FADING_IN: u8 = 0x1;
+/// Bit 2: fading out.
+const FADING_OUT: u8 = 0x2;
+/// Bit 4: the fade out is the last, at the end of the line's life.
+const FINAL: u8 = 0x4;
+
+/// A bubble's fade (`0x4b0ea0`, `0x4b0ee0`, the middle of `0x4b0c30`): the flags, the fade's start
+/// time, the frame's alpha byte and its shown bit.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Fade {
+    flags: u8,
+    /// `[bubble+0x33c]`, the current fade's start.
+    since: u64,
+    /// The frame's alpha byte (`+0xc8`); a new frame starts opaque.
+    alpha: u8,
+    /// The own-shown bit (`+0xd0`).
+    shown: bool,
+}
+
+impl Fade {
+    /// A line's start (`0x4b17da`, then `0x4b17f7`): the flags reset, then the fade in. The alpha
+    /// is a new frame's (`0x7690d2`); a reused frame keeps what its last fade left, which this
+    /// does not track, and which matters only to a line whose first frame fades out.
+    fn spawn(now: u64) -> Self {
+        let mut f = Fade {
+            flags: 0,
+            since: now,
+            alpha: 255,
+            shown: true,
+        };
+        f.fade_in(now);
+        f
+    }
+
+    /// `0x4b0ea0`: unless fading in or on the last fade out, start fading in and show.
+    fn fade_in(&mut self, now: u64) {
+        if self.flags & (FADING_IN | FINAL) != 0 {
+            return;
+        }
+        self.flags = (self.flags & !FADING_OUT) | FADING_IN;
+        self.since = now;
+        self.shown = true;
+    }
+
+    /// `0x4b0ee0`: unless on the last fade out, mark it final if asked, and start fading out
+    /// unless already.
+    fn fade_out(&mut self, now: u64, last: bool) {
+        if self.flags & FINAL != 0 {
+            return;
+        }
+        if last {
+            self.flags |= FINAL;
+        }
+        if self.flags & FADING_OUT == 0 {
+            self.flags = (self.flags & !FADING_IN) | FADING_OUT;
+            self.since = now;
+        }
+    }
+
+    /// One frame of `0x4b0c30` past its residency gates; `false` when the last fade out ends and
+    /// the bubble goes back to the pool.
+    fn tick(&mut self, now: u64, in_range: bool, born: u64, duration: u64) -> bool {
+        if !in_range {
+            if self.alpha != 0 {
+                self.fade_out(now, false);
+            }
+        } else if self.alpha != 255 {
+            self.fade_in(now);
+        }
+        if self.flags & FADING_OUT == 0 && now.saturating_sub(born) > duration + FADE_MS {
+            self.fade_out(now, true);
+        }
+        // `elapsed · 255 / 250`, truncated (`0x4b0d5b`-`0x4b0d68`).
+        let ramp = |e: u64| (e * 255 / FADE_MS) as u8;
+        let e = now.saturating_sub(self.since);
+        if self.flags & FADING_IN != 0 {
+            if e > FADE_MS {
+                self.alpha = 255;
+                self.flags &= !FADING_IN;
+            } else {
+                self.alpha = ramp(e);
+            }
+        } else if self.flags & FADING_OUT != 0 {
+            if e > FADE_MS {
+                if self.flags & FINAL != 0 {
+                    return false;
+                }
+                // An out-of-range fade ends hidden (`0x4b0d95`).
+                self.flags &= !(FADING_OUT | FINAL);
+                self.shown = false;
+            } else {
+                self.alpha = 255 - ramp(e);
+            }
+        }
+        true
+    }
+}
+
 /// One live bubble: the `CGChatBubbleFrame` and its `CGUnit+0xe64` handle.
 struct Bubble {
+    /// This line's number, which tells the widget layer a replacement from a repeat.
+    line: u64,
     /// The [`sanitize`]d display text.
     text: String,
     /// The chat-type colour (the 94-entry table), sRGB 0..1.
     color: [f32; 3],
-    /// `Time::elapsed_secs` at spawn.
-    born: f32,
-    /// The steady window after the fade-in ([`duration_secs`]).
-    duration: f32,
+    /// The spawn time in ms (`[bubble+0x338]`).
+    born: u64,
+    /// The steady window after the fade-in ([`duration_ms`], `[bubble+0x340]`).
+    duration: u64,
     /// Stand-box height × model scale, latched at spawn as the reference does (`bubble+0x354`).
     lift: f32,
-    /// Fade alpha 0..1, ramped toward the eligibility verdict.
-    alpha: f32,
+    fade: Fade,
 }
 
-/// The live bubbles by speaker guid, at most one per unit.
+/// Whether the speaker was drawn in the last render: the reference's scene-node test `0x6704c0`
+/// (`node && [node+0x94] == 0`, read at `0x4b0cab`). Every frame sets `[node+0x94]` on every node
+/// in the scene list `[0xca7d70]` (`0x698a07`) and clears it only for a node that passes the
+/// frustum test `0x682ef0` and the horizon test `0x686000` (`0x6833dd`-`0x6833ec`, and
+/// `0x68359b`-`0x6835aa` in WMO groups). Here it is any of the unit's meshes passing last frame's
+/// visibility check; benilla has no horizon cull yet, so that is the frustum verdict alone.
+fn speaker_drawn(
+    unit: Entity,
+    children: &Query<&Children>,
+    meshes: &Query<&ViewVisibility, With<Mesh3d>>,
+) -> bool {
+    children
+        .get(unit)
+        .is_ok_and(|kids| kids.iter().any(|c| meshes.get(c).is_ok_and(|v| v.get())))
+}
+
+/// The live bubbles by speaker guid, at most one per unit, and the next line's number.
 #[derive(Resource, Default)]
-struct Bubbles(HashMap<u64, Bubble>);
+struct Bubbles {
+    live: HashMap<u64, Bubble>,
+    next_line: u64,
+}
+
+/// This frame's live bubbles for the widget layer, farthest from the camera first, and the sizes
+/// the window gives them; `None` with no viewport to lay out against. [`crate::ui_chat::bubbles`]
+/// hands them to the VM.
+#[derive(Resource, Default)]
+pub(crate) struct BubbleFeed {
+    pub(crate) geometry: Option<BubbleGeometry>,
+    pub(crate) states: Vec<BubbleState>,
+}
 
 /// Units with a live bubble this frame, whose overhead name is suppressed (`+0xe64` ≠ 0).
 #[derive(Resource, Default)]
 pub(crate) struct BubblesActive(pub(crate) EntityHashSet);
 
-/// The bubble art, loaded at boot. The edge strip tiles UVs past 1 (repeat); bg and tail clamp.
-#[derive(Resource)]
-struct BubbleArt {
-    bg: Handle<Image>,
-    edge: Handle<Image>,
-    tail: Handle<Image>,
-    /// The edge atlas's size in texels, for the half-texel bleed inset.
-    edge_texels: Vec2,
-}
-
-fn load_bubble_art(
-    mut commands: Commands,
-    assets: Option<ResMut<WorldAssets>>,
-    mut images: ResMut<Assets<Image>>,
-) {
-    let Some(mut assets) = assets else {
-        return; // no game data (a bare test app); `drive_bubbles` tolerates the missing art
-    };
-    let bg = assets.sprite_texture(BG_TEXTURE, &mut images);
-    let edge = assets.sprite_texture_tiled(EDGE_TEXTURE, &mut images);
-    let tail = assets.sprite_texture(TAIL_TEXTURE, &mut images);
-    let (Some(bg), Some(edge), Some(tail)) = (bg, edge, tail) else {
-        warn!("chat_bubble: bubble art missing from the patch chain — bubbles will not draw");
-        return;
-    };
-    let edge_texels = images.get(&edge).map_or(Vec2::ZERO, |i| {
-        let s = i.texture_descriptor.size;
-        Vec2::new(s.width as f32, s.height as f32)
-    });
-    commands.insert_resource(BubbleArt {
-        bg,
-        edge,
-        tail,
-        edge_texels,
-    });
-}
-
-/// Every frame: drain the queue through the spawn gate (`0x608ac0`), ramp each bubble's fade
-/// against its lifetime and the 20 yd re-test (`0x4b0c30`), publish [`BubblesActive`], and draw.
+/// Every frame: drain the queue through the spawn gate (`0x608ac0`), run each bubble's fade against
+/// its lifetime and the 20 yd re-test (`0x4b0c30`), publish [`BubblesActive`], and lay out the
+/// live set for the widget layer ([`BubbleFeed`]), farthest from the camera first.
 #[allow(clippy::type_complexity)] // one Bevy system's full input set
 fn drive_bubbles(
     mut queue: ResMut<BubbleQueue>,
@@ -294,17 +355,17 @@ fn drive_bubbles(
     units: Query<(Entity, &Guid, &Transform), With<NetEntity>>,
     self_q: Query<&Transform, With<Embodied>>,
     camera: Query<(&Camera, &Transform), With<WorldCamera>>,
-    mut atlas: Option<ResMut<UiFontAtlas>>,
-    mut quads: ResMut<UiQuads>,
-    art: Option<Res<BubbleArt>>,
     heights: Query<&StandBoxHeight>,
     time: Res<Time>,
-    // The device scale, for the seat's pixel snap.
     window: Query<&Window, With<bevy::window::PrimaryWindow>>,
+    mut feed: ResMut<BubbleFeed>,
+    // The speakers' meshes and their last-frame visibility, for [`speaker_drawn`].
+    drawn: (Query<&Children>, Query<&ViewVisibility, With<Mesh3d>>),
 ) {
     active.0.clear();
-    let now = time.elapsed_secs();
-    let step = time.delta_secs() / FADE_SECS;
+    feed.states.clear();
+    feed.geometry = None;
+    let now = time.elapsed().as_millis() as u64;
     let self_tf = self_q.single().ok();
     // The typed sender lookup (`0x468460`), a linear scan of the small streamed set.
     let find = |guid: u64| units.iter().find(|(_, g, _)| g.0 == guid);
@@ -317,11 +378,11 @@ fn drive_bubbles(
         }
     };
     for (guid, kind, raw) in queue.0.drain(..) {
-        let text = sanitize(&raw);
-        let words = word_count(&text);
-        if words == 0 {
+        // The raw line, not its display copy (`0x608af6`): a line of separators or of a bare
+        // colour code still bubbles.
+        if raw.is_empty() {
             refuse("empty-text", guid);
-            continue; // no words, no lifetime, no bubble
+            continue;
         }
         let Some((entity, _, tf)) = find(guid) else {
             refuse("sender-not-a-live-unit", guid);
@@ -341,15 +402,20 @@ fn drive_bubbles(
             refuse(&format!("out-of-range dist={:.1}yd", d2.sqrt()), guid);
             continue;
         }
+        let text = sanitize(&raw);
         let is_self = self_guid.0 == Some(guid);
         let c = default_color(kind);
         // The one-time height query (`0x4b0e38` calling `0x711a20`, scaled by `[unit+0x90]`). A
         // model with no bounds reads 0 and the bubble sits 0.7 above the feet, as in the reference.
         let lift = heights.get(entity).map_or(0.0, |h| h.0) * tf.scale.y;
-        // Replace, never queue (`0x608c00`): the fresh bubble fades in from 0.
-        bubbles.0.insert(
+        let line = bubbles.next_line;
+        bubbles.next_line += 1;
+        // Replace, never queue (`0x608bb4`): the old line's frame goes back to the pool.
+        bubbles.live.insert(
             guid,
             Bubble {
+                line,
+                duration: duration_ms(&text, is_self),
                 text,
                 color: [
                     f32::from(c[0]) / 255.0,
@@ -357,298 +423,145 @@ fn drive_bubbles(
                     f32::from(c[2]) / 255.0,
                 ],
                 born: now,
-                duration: duration_secs(words, is_self),
                 lift,
-                alpha: 0.0,
+                fade: Fade::spawn(now),
             },
         );
     }
-    if bubbles.0.is_empty() {
-        return;
-    }
 
-    // ── Tick + draw ─────────────────────────────────────────────────────────────────────────
+    // ── The per-frame pass (`0x4b1060` → `0x4b0c30`) ────────────────────────────────────────
+    // A speaker gone (`0x4b117e`), or no local player (`0x4b0c40`), ends the bubble at once.
+    // A speaker not drawn in the last render takes the out-of-range leg (`0x4b0cb2` →
+    // `0x4b0cd7`): its bubble fades out and hides, and comes back when the speaker is drawn again.
+    bubbles.live.retain(|guid, b| {
+        let (Some((entity, _, tf)), Some(s)) = (find(*guid), self_tf) else {
+            return false;
+        };
+        let in_range = speaker_drawn(entity, &drawn.0, &drawn.1)
+            && (tf.translation - s.translation).length_squared() < MAX_DIST_SQ;
+        b.fade.tick(now, in_range, b.born, b.duration)
+    });
+
     let cam = camera.single().ok();
-    let art = art.as_deref();
-    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, and its bubble with it
-            continue;
-        };
-        if now >= b.born + b.duration + FADE_SECS {
-            // The permanent fade-out (`0x4b0ee0(1)`); at 0 the frame recycles.
-            b.alpha -= step;
-            if b.alpha <= 0.0 {
-                dead.push(*guid);
-                continue;
-            }
-        } else {
-            // The 20 yd gate, re-tested every frame: out of range fades out, back in fades in.
-            let eligible = self_tf
-                .is_some_and(|s| (tf.translation - s.translation).length_squared() <= MAX_DIST_SQ);
-            b.alpha = if eligible {
-                (b.alpha + step).min(1.0)
-            } else {
-                (b.alpha - step).max(0.0)
-            };
-        }
-        // The name stays suppressed while the bubble exists, faded or not (`+0xe64` ≠ 0).
-        active.0.insert(entity);
-        if b.alpha <= 0.0 {
-            continue;
-        }
-        // No camera, atlas or art: lifetimes tick, nothing draws.
-        let (Some((cam, cam_pose)), true) = (cam, atlas.is_some() && art.is_some()) else {
-            continue;
-        };
-        // The anchor (`0x4b0c30`), from this frame's `Transform` and constants only. A seat behind
-        // the camera draws nothing and keeps its state.
-        let seat_world = tf.translation + Vec3::Y * (b.lift + LIFT);
-        let cam_tf = GlobalTransform::from(*cam_pose);
-        let Ok(seat) = cam.world_to_viewport(&cam_tf, seat_world) else {
-            refuse("not-on-screen (behind the camera)", *guid);
-            continue;
-        };
-        let Some(viewport) = cam.logical_viewport_size() else {
-            refuse("no-viewport", *guid);
-            continue;
-        };
-        // Drawn after the sort: a bubble's level depends on the whole live set ([`level_z`]).
-        pending.push(Pending {
-            guid: *guid,
-            entity,
-            seat,
-            viewport,
-            // The sort key (`0x4b1251`-`0x4b12c0`): the camera's distance, not the player's.
-            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);
-    }
+    let window = window.single().ok();
+    // The order is the frame levels (`0x4b1360`, stamped `0x4b12d5`-`0x4b1312`): the camera's
+    // distance to the speaker, farthest first. The reference re-sorts only when the camera moved
+    // or a line spawned (`0x4b10a5`-`0x4b10d3`, `0x4b11c7`); this sorts every frame, so a speaker
+    // moving under a still camera can re-stack here and not there.
+    let mut order: Vec<(u64, f32)> = bubbles
+        .live
+        .keys()
+        .filter_map(|guid| {
+            let (entity, _, tf) = find(*guid)?;
+            active.0.insert(entity);
+            let d2 = cam.map_or(0.0, |(_, pose)| {
+                pose.translation.distance_squared(tf.translation)
+            });
+            Some((*guid, d2))
+        })
+        .collect();
+    stack_sort(&mut order);
 
-    // ── The frame-level pass (`0x4b12d5`–`0x4b1312`) ─────────────────────────────────────────
-    // Sorted farthest first (`0x4b1360`), levels stamped head to tail (`0x4b1309`). The reference
-    // re-sorts only on a change; sorting every frame gives the same list.
-    stack_sort(&mut pending);
-    let (Some((_, cam_pose)), Some(atlas), Some(art)) = (cam, atlas.as_deref_mut(), art) else {
-        return; // the tick's same gate kept `pending` empty
+    // Sizes from the camera's viewport, else the window's; with neither there is nothing to lay
+    // out against.
+    let viewport = cam
+        .and_then(|(c, _)| c.logical_viewport_size())
+        .or_else(|| window.map(|w| Vec2::new(w.width(), w.height())));
+    let Some(viewport) = viewport.filter(|v| v.x > 0.0 && v.y > 0.0) else {
+        return;
     };
-    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,
-            p.seat,
-            p.viewport,
-            scale,
-            trace,
-            p.entity,
-            p.anchor,
-            p.unit_pos,
-            cam_pose,
-            level_z(rank),
-        );
-    }
+    // Everything below is in window px, divided by the seam once for the `WorldFrame`'s units.
+    let seam = window.map_or(1.0, |w| crate::ui_script::seam_scale(w.height()));
+    let scale = window.map_or(1.0, Window::scale_factor);
+    let basis = plate_basis(viewport);
+    feed.geometry = Some(BubbleGeometry {
+        border: border_px(viewport, basis) / seam,
+        margin: gx_px(MARGIN, basis) / seam,
+        wrap_cap: gx_px(WRAP_W, basis) / seam,
+        text_height: text_px(TEXT_H, basis) / seam,
+        device_px: seam * scale,
+    });
+    feed.states = order
+        .iter()
+        .filter_map(|(guid, _)| {
+            let b = bubbles.live.get(guid)?;
+            let (entity, _, tf) = find(*guid)?;
+            // The anchor (`0x4b0c30`), from this frame's `Transform` and the latched lift.
+            let anchor = tf.translation + Vec3::Y * (b.lift + LIFT);
+            let seat = cam.and_then(|(c, pose)| {
+                c.world_to_viewport(&GlobalTransform::from(*pose), anchor)
+                    .ok()
+                    .map(|p| (pose, p))
+            });
+            if benilla_assets::trace::enabled_for("bub") {
+                trace_seat(entity, anchor, tf.translation, seat, viewport, scale);
+            }
+            Some(BubbleState {
+                key: *guid,
+                line: b.line,
+                text: b.text.clone(),
+                colour: b.color,
+                shown: b.fade.shown,
+                alpha: f32::from(b.fade.alpha) / 255.0,
+                seat: match seat {
+                    Some((_, p)) => (p.x / seam, (viewport.y - p.y) / seam),
+                    // Short of the near plane (behind the camera) the projection writes no point
+                    // (`0x483f7a`) and the placement ignores its verdict, seating the zeroed one
+                    // (`0x4b14e4`): the text's BOTTOM on the screen's bottom-left corner. Bevy's
+                    // reverse-Z projection reports such a point as past either plane. Such a
+                    // speaker is not drawn, so the bubble is shown here only while its fade out
+                    // runs, at most 250 ms from the alpha it had, which a fresh line has at 255.
+                    None => (0.0, 0.0),
+                },
+            })
+        })
+        .collect();
+}
+
+/// The jitter decomposition (`WOW_MOVE_TRACE` tag `bub`): `anchor=` and `pos=` differ by a latched
+/// constant on Y only, so a wobble between them is a defect.
+fn trace_seat(
+    entity: Entity,
+    anchor: Vec3,
+    pos: Vec3,
+    seat: Option<(&Transform, Vec2)>,
+    viewport: Vec2,
+    scale: f32,
+) {
+    let (cp, cf, scr) = match seat {
+        Some((pose, p)) => (pose.translation, *pose.forward(), p),
+        None => (Vec3::NAN, Vec3::NAN, Vec2::NAN),
+    };
+    benilla_assets::trace::line(
+        "bub",
+        &format!(
+            "e={} vp=({:.0},{:.0}) anchor=[{:.4},{:.4},{:.4}] cam=[{:.4},{:.4},{:.4}] \
+             fwd=[{:.4},{:.4},{:.4}] pos=[{:.4},{:.4},{:.4}] scr=({:.3},{:.3}) scale={scale:.2}",
+            entity.index(),
+            viewport.x,
+            viewport.y,
+            anchor.x,
+            anchor.y,
+            anchor.z,
+            cp.x,
+            cp.y,
+            cp.z,
+            cf.x,
+            cf.y,
+            cf.z,
+            pos.x,
+            pos.y,
+            pos.z,
+            scr.x,
+            scr.y,
+        ),
+    );
 }
 
 /// Farthest camera distance first, so the index is the frame level. Ties break on guid, as the
 /// reference keeps its order across an exact tie and a `HashMap` walk cannot.
-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 projected bubble awaiting the frame-level sort.
-struct Pending {
-    guid: u64,
-    entity: Entity,
-    seat: Vec2,
-    viewport: Vec2,
-    /// |camera − speaker|², the reference's sort key (`[bubble+0x350]`).
-    cam_dist_sq: f32,
-    /// The world seat and the speaker's position, for the `bub` trace.
-    anchor: Vec3,
-    unit_pos: Vec3,
-}
-
-/// Append one bubble's draw list: the backdrop pieces, the tail and the wrapped, centered text.
-fn draw_bubble(
-    atlas: &mut UiFontAtlas,
-    quads: &mut UiQuads,
-    art: &BubbleArt,
-    b: &Bubble,
-    seat: Vec2,
-    viewport: Vec2,
-    scale: f32,
-    trace: bool,
-    // The `bub` trace's inputs.
-    entity: Entity,
-    anchor: Vec3,
-    unit_pos: Vec3,
-    cam_pose: &Transform,
-    // This bubble's frame level as a z base.
-    z: u64,
-) {
-    let basis = plate_basis(viewport);
-    let border = border_px(viewport, basis);
-    let margin = gx_px(MARGIN, basis);
-
-    // Shaped at the exact window-derived em, so the glyphs are never a rescaled bitmap.
-    let px = text_px(TEXT_H, basis);
-    if px <= 0.0 {
-        return;
-    }
-    let mut e = atlas.lock();
-    let spec = FontSpec {
-        path: None, // `NAMEPLATE_FONT`: Friz Quadrata, the engine's default face
-        height: Some(px),
-        outline: Outline::None,
-        alpha_gradient: None,
-    };
-    // The wrap law (`0x4b1600`): wider than 0.2 gx wraps at the cap, else max(width, 2 borders).
-    let cap = gx_px(WRAP_W, basis);
-    let floor = 2.0 * border;
-    let (line_w, _) = measure_text(&mut e, &b.text, None, spec);
-    let box_w = if line_w > cap { cap } else { line_w.max(floor) };
-    let (_, box_h) = measure_text(&mut e, &b.text, Some(box_w), spec);
-    let (text_w, text_h) = (box_w.ceil(), box_h.ceil());
-
-    // The frame hugs the text layout plus the margin, bottom-center on the seat, growing upward.
-    let w = text_w + 2.0 * margin;
-    let h = text_h + 2.0 * margin;
-    let origin = seat_origin(seat, w, scale);
-    let (left, bottom) = (origin.x, origin.y);
-    let frame = Rect::new(left, bottom - h, left + w, bottom);
-    let alpha = b.alpha;
-
-    // The backdrop (`0x4b0a35` into `0x76a5d0`): one value feeds the four insets and both
-    // edge-size fields. `pieces` is y-up, so y negates across the seam.
-    let bd = Backdrop {
-        bg_file: Some(BG_TEXTURE.to_string()),
-        edge_file: Some(EDGE_TEXTURE.to_string()),
-        tile: false,
-        tile_size: 0.0,
-        edge_size: border,
-        insets: Insets {
-            left: border,
-            right: border,
-            top: border,
-            bottom: border,
-        },
-        bg_color: [1.0; 4],
-        border_color: [1.0; 4],
-    };
-    let up = GxRect::new(-frame.max.y, frame.min.x, -frame.min.y, frame.max.x);
-    for p in pieces(up, &bd, 1.0) {
-        // Equal insets keep every piece axis-aligned: a y-down rect from its TL and BR corners.
-        let rect = Rect::new(
-            p.corners[0][0],
-            -p.corners[0][1],
-            p.corners[2][0],
-            -p.corners[2][1],
-        );
-        // The border pieces share one 256×32 atlas: without the half-texel inset, bilinear blends
-        // in the neighbour's column, white at alpha 0 beside the top slice, a pale line.
-        let uvs = if p.is_bg {
-            p.uvs
-        } else {
-            pieces_inset(p.uvs, art.edge_texels)
-        };
-        quads.overlays.push(UiQuad {
-            rect,
-            z_key: z + if p.is_bg { Z_BG } else { Z_EDGE },
-            texture: Some(if p.is_bg {
-                art.bg.clone()
-            } else {
-                art.edge.clone()
-            }),
-            uv: UvRect::from_corners(uvs),
-            color: [1.0, 1.0, 1.0, alpha],
-            ..default()
-        });
-    }
-    // The tail (`0x4b0af1`): a border-unit square, TOPRIGHT on the bottom lifted border/4.
-    let tail_top = frame.max.y - border * 0.25;
-    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 + Z_TAIL,
-        texture: Some(art.tail.clone()),
-        uv: UvRect::FULL,
-        color: [1.0, 1.0, 1.0, alpha],
-        ..default()
-    });
-    // The text, centered in the margin box and wrapped at the cap.
-    let center = Vec2::new(cx, (frame.min.y + frame.max.y) * 0.5);
-    let mut text_quads = layout_text_quads(
-        &mut e,
-        &b.text,
-        Rect::from_center_size(center, Vec2::new(box_w, box_h)),
-        [b.color[0], b.color[1], b.color[2], alpha],
-        Justify {
-            h: JustifyH::Center,
-            v: JustifyV::Middle,
-        },
-        z + Z_TEXT,
-        spec,
-        // Exact, so the text stays rigid against the device-snapped frame.
-        TextSeat::Exact,
-    );
-    drop(e);
-    if trace {
-        eprintln!(
-            "bubble-trace: viewport={viewport:?} frame=({:.1},{:.1})..({:.1},{:.1}) border={border:.1} alpha={alpha:.2} text={:?}",
-            frame.min.x, frame.min.y, frame.max.x, frame.max.y, b.text
-        );
-    }
-    // The jitter decomposition (`WOW_MOVE_TRACE` tag `bub`): `anchor=` and `pos=` differ by a
-    // latched constant on Y only, so a wobble between them is a defect. Not the eprintln above,
-    // whose unbuffered writes would distort frame pacing.
-    if benilla_assets::trace::enabled_for("bub") {
-        let (cp, cf) = (cam_pose.translation, cam_pose.forward());
-        benilla_assets::trace::line(
-            "bub",
-            &format!(
-                "e={} vp=({:.0},{:.0}) anchor=[{:.4},{:.4},{:.4}] cam=[{:.4},{:.4},{:.4}] \
-                 fwd=[{:.4},{:.4},{:.4}] pos=[{:.4},{:.4},{:.4}] scr=({:.3},{:.3}) \
-                 frame=({:.2},{:.2}) scale={scale:.2}",
-                entity.index(),
-                viewport.x,
-                viewport.y,
-                anchor.x,
-                anchor.y,
-                anchor.z,
-                cp.x,
-                cp.y,
-                cp.z,
-                cf.x,
-                cf.y,
-                cf.z,
-                unit_pos.x,
-                unit_pos.y,
-                unit_pos.z,
-                seat.x,
-                seat.y,
-                frame.min.x,
-                frame.max.y,
-            ),
-        );
-    }
-    quads.overlays.append(&mut text_quads);
+fn stack_sort(order: &mut [(u64, f32)]) {
+    order.sort_by(|a, b| b.1.total_cmp(&a.1).then(a.0.cmp(&b.0)));
 }
 
 /// The bubble stage; [`crate::nameplates`] orders after it to read [`BubblesActive`].
@@ -673,14 +586,18 @@ impl Plugin for ChatBubblePlugin {
             .init_resource::<BubbleConfig>()
             .init_resource::<Bubbles>()
             .init_resource::<BubblesActive>()
-            .add_systems(Startup, load_bubble_art.after(AssetSet::Open))
-            // After the V-plate drive, whose verdict the spawn gate reads.
+            .init_resource::<BubbleFeed>()
+            // After the V-plate drive, whose verdict the spawn gate reads, and before the script
+            // paint, so a bubble draws the frame it moves.
             .add_systems(
                 Update,
-                drive_bubbles
+                (
+                    drive_bubbles.in_set(BubbleSet),
+                    crate::ui_chat::bubbles::feed_bubbles,
+                )
+                    .chain()
                     .after(VPlateSet)
-                    .in_set(UiQuadAppend)
-                    .in_set(BubbleSet),
+                    .before(crate::ui_script::UiPaint),
             );
     }
 }
@@ -689,36 +606,203 @@ impl Plugin for ChatBubblePlugin {
 mod tests {
     use super::*;
 
-    /// Space and tab runs only, not Unicode whitespace.
+    /// `0x4b1810`: the base, plus the per-word step for each space or tab that ends a word; an
+    /// empty buffer lasts 0.
     #[test]
-    fn word_count_is_the_space_tab_run_law() {
-        assert_eq!(word_count(""), 0);
-        assert_eq!(word_count("   \t "), 0);
-        assert_eq!(word_count("hi"), 1);
-        assert_eq!(word_count("  hi   there\tfriend  "), 3);
-        assert_eq!(word_count("a\u{a0}b"), 1, "NBSP is not a separator");
+    fn duration_is_the_separator_count_law() {
+        assert_eq!(duration_ms("", false), 0);
+        assert_eq!(duration_ms("hi", false), 2750);
+        assert_eq!(duration_ms("hi there", false), 3500);
+        assert_eq!(
+            duration_ms("hi ", false),
+            3500,
+            "a trailing space ends a word"
+        );
+        assert_eq!(
+            duration_ms("hi  \t there", false),
+            3500,
+            "a run counts once"
+        );
+        assert_eq!(
+            duration_ms("   ", false),
+            2750,
+            "separators alone: the base"
+        );
+        assert_eq!(
+            duration_ms("a\u{a0}b", false),
+            2750,
+            "NBSP is not a separator"
+        );
+        assert_eq!(duration_ms("hi", true), 1500);
+        assert_eq!(duration_ms("a b c", true), 2500);
     }
 
+    /// The copy loop in `0x4b1600`: `||` stays escaped; any other `|` jumps to the next `[` (or
+    /// ends the text), the bracket pair drops and a closing `|h` then `|r` after it skip.
     #[test]
-    fn duration_matches_the_byte_law() {
-        assert_eq!(duration_secs(0, false), 0.0);
-        assert_eq!(duration_secs(1, false), 2.75);
-        assert_eq!(duration_secs(4, false), 5.0);
-        assert_eq!(duration_secs(1, true), 1.5);
-        assert_eq!(duration_secs(3, true), 2.5);
-    }
-
-    #[test]
-    fn sanitize_strips_escapes_keeps_display_text() {
+    fn sanitize_is_the_bubble_copy_loop() {
         assert_eq!(sanitize("hello"), "hello");
         assert_eq!(sanitize("a||b"), "a||b");
-        assert_eq!(sanitize("|cffff0000red|r plain"), "red plain");
         assert_eq!(
-            sanitize("look |Hitem:19019|h[Thunderfury]|h!"),
-            "look [Thunderfury]!"
+            sanitize("look |cffa335ee|Hitem:19019:0:0:0|h[Thunderfury]|h|r!"),
+            "look Thunderfury!"
+        );
+        assert_eq!(
+            sanitize("look |Hitem:19019|h[Thunderfury]|h now"),
+            "look Thunderfury now"
+        );
+        assert_eq!(
+            sanitize("|cffff0000red|r plain"),
+            "",
+            "no bracket: the text ends"
+        );
+        assert_eq!(sanitize("dangling |"), "dangling ");
+        assert_eq!(sanitize("[x] |y [z] w"), "[x] z w");
+    }
+
+    /// A line in range: 250 ms in, its lifetime, 250 ms out, then back to the pool; the ramp is
+    /// the truncated `elapsed · 255 / 250`.
+    #[test]
+    fn a_line_fades_in_holds_fades_out_and_ends() {
+        let (born, life) = (1000, 2750);
+        let mut f = Fade::spawn(born);
+        let at = |f: &mut Fade, t: u64| -> Option<(u8, bool)> {
+            f.tick(t, true, born, life).then_some((f.alpha, f.shown))
+        };
+        assert_eq!(at(&mut f, born), Some((0, true)));
+        assert_eq!(at(&mut f, born + 100), Some((102, true)));
+        assert_eq!(
+            at(&mut f, born + 250),
+            Some((255, true)),
+            "250 is still the ramp"
+        );
+        assert_eq!(at(&mut f, born + 251), Some((255, true)));
+        // The last fade starts once `now − born` passes the lifetime plus one fade.
+        assert_eq!(at(&mut f, born + life + 250), Some((255, true)));
+        assert_eq!(
+            at(&mut f, born + life + 251),
+            Some((255, true)),
+            "starts at 0 elapsed"
+        );
+        assert_eq!(at(&mut f, born + life + 351), Some((153, true)));
+        assert_eq!(at(&mut f, born + life + 501), Some((0, true)));
+        assert_eq!(
+            at(&mut f, born + life + 502),
+            None,
+            "the frame goes back to the pool"
+        );
+    }
+
+    /// Out of range a bubble fades out and hides but lives on; back in range it shows and fades
+    /// in, and turning back mid fade-out restarts the ramp from 0 (`0x4b0ea0`). Ticked every
+    /// 10 ms, as frames would.
+    #[test]
+    fn out_of_range_fades_to_hidden_and_back() {
+        let life = 60_000;
+        let mut f = Fade::spawn(0);
+        let run = |f: &mut Fade, from: u64, to: u64, in_range: bool| {
+            for t in (from..=to).step_by(10) {
+                assert!(f.tick(t, in_range, 0, life), "alive at {t}");
+            }
+        };
+        run(&mut f, 0, 300, true);
+        assert_eq!((f.alpha, f.shown), (255, true));
+        run(&mut f, 310, 600, false);
+        assert_eq!(
+            (f.alpha, f.shown, f.flags),
+            (0, false, 0),
+            "hidden, alive, no fade running"
+        );
+        run(&mut f, 610, 790, false);
+        assert!(!f.shown, "out of range it waits hidden");
+        run(&mut f, 800, 900, true);
+        assert_eq!((f.shown, f.flags), (true, FADING_IN));
+        assert_eq!(f.alpha, 102, "100 ms into the fade in");
+        run(&mut f, 910, 1200, true);
+        run(&mut f, 1210, 1310, false);
+        assert_eq!(f.alpha, 153, "100 ms into the fade out");
+        run(&mut f, 1320, 1320, true);
+        assert_eq!(f.alpha, 0, "the fade in starts over");
+    }
+
+    /// A speaker culled from the last render takes the out-of-range leg: the bubble fades out and
+    /// hides while the speaker is undrawn, and shows again once it is drawn (`0x4b0cab`).
+    #[test]
+    fn a_culled_speaker_fades_its_bubble_out_and_back() {
+        use benilla_protocol::EntityKind;
+        use bevy::camera::visibility::SetViewVisibility;
+        use std::time::Duration;
+
+        let mut app = App::new();
+        app.init_resource::<BubbleQueue>()
+            .init_resource::<BubbleConfig>()
+            .init_resource::<Bubbles>()
+            .init_resource::<BubblesActive>()
+            .init_resource::<BubbleFeed>()
+            .init_resource::<VPlates>()
+            .init_resource::<SelfGuid>()
+            .init_resource::<Time>()
+            .add_systems(Update, drive_bubbles);
+        let speaker = app
+            .world_mut()
+            .spawn((
+                NetEntity {
+                    kind: EntityKind::Unit,
+                    display_id: None,
+                    scale: 1.0,
+                },
+                Guid(7),
+                Transform::from_xyz(5.0, 0.0, 0.0),
+            ))
+            .id();
+        let body = app
+            .world_mut()
+            .spawn((Mesh3d::default(), ViewVisibility::HIDDEN, ChildOf(speaker)))
+            .id();
+        app.world_mut().spawn((Embodied, Transform::default()));
+        let set_drawn = |app: &mut App, drawn: bool| {
+            let w = app.world_mut();
+            if drawn {
+                w.get_mut::<ViewVisibility>(body).unwrap().set_visible();
+            } else {
+                w.entity_mut(body).insert(ViewVisibility::HIDDEN);
+            }
+        };
+        // Run frames 10 ms apart up to `to` ms, and read the bubble's fade.
+        let mut now = 0u64;
+        let mut run_to = |app: &mut App, to: u64| -> Option<(u8, bool)> {
+            while now < to {
+                now += 10;
+                app.world_mut()
+                    .resource_mut::<Time>()
+                    .advance_by(Duration::from_millis(10));
+                app.update();
+            }
+            let b = app.world().resource::<Bubbles>();
+            b.live.get(&7).map(|b| (b.fade.alpha, b.fade.shown))
+        };
+
+        set_drawn(&mut app, true);
+        let cfg = BubbleConfig::default();
+        app.world_mut().resource_mut::<BubbleQueue>().push(
+            &cfg,
+            7,
+            ChatEventKind::Say,
+            "one two three four five six seven eight",
+        );
+        assert_eq!(run_to(&mut app, 400), Some((255, true)), "drawn: faded in");
+        set_drawn(&mut app, false);
+        assert_eq!(
+            run_to(&mut app, 800),
+            Some((0, false)),
+            "culled in range: faded out and hidden, still alive"
+        );
+        set_drawn(&mut app, true);
+        assert_eq!(
+            run_to(&mut app, 1200),
+            Some((255, true)),
+            "drawn again: shown and faded back in"
         );
-        assert_eq!(sanitize("dangling |"), "dangling ||");
-        assert_eq!(sanitize("|x odd"), "||x odd");
     }
 
     /// Both switches on, since a kind whose switch is off cannot show whether the gate admits it.
@@ -775,99 +859,16 @@ mod tests {
         );
     }
 
-    /// A logical `round()` would step two physical pixels per axis at 2×.
-    #[test]
-    fn the_bubble_seat_snaps_on_the_device_grid() {
-        // 2×: the grid is every half logical pixel, and every snapped edge is a whole physical px.
-        for (seat_y, want) in [(10.0, 10.0), (10.2, 10.0), (10.3, 10.5), (10.6, 10.5)] {
-            let o = seat_origin(Vec2::new(100.0, seat_y), 40.0, 2.0);
-            assert_eq!(o.y, want, "seat y {seat_y} at 2×");
-            assert_eq!(
-                (o.y * 2.0).fract(),
-                0.0,
-                "{} is a whole physical pixel",
-                o.y
-            );
-        }
-        // The x half snaps the centered left edge (seat − w/2), where the border blit starts.
-        let o = seat_origin(Vec2::new(100.4, 0.0), 41.0, 2.0);
-        assert_eq!(o.x, 80.0);
-        assert_eq!(((100.4_f32 - 20.5) * 2.0).round() / 2.0, o.x);
-        // 1×: identical to a logical round().
-        assert_eq!(seat_origin(Vec2::new(0.0, 10.4), 0.0, 1.0).y, 10.0);
-        assert_eq!(seat_origin(Vec2::new(0.0, 10.6), 0.0, 1.0).y, 11.0);
-        // 1.5×, where a logical round() is never texel-aligned.
-        for v in [10.4, 10.9, 11.2] {
-            let o = seat_origin(Vec2::new(0.0, v), 0.0, 1.5);
-            assert_eq!(
-                (o.y * 1.5).fract(),
-                0.0,
-                "{v} at 1.5× is a whole physical px"
-            );
-        }
-    }
-
-    /// Over a continuous glide the snap displaces any one frame by at most half a device pixel.
-    #[test]
-    fn the_snap_adds_at_most_half_a_device_pixel_of_step() {
-        let scale = 2.0;
-        let mut worst: f32 = 0.0;
-        // A continuous glide across ~40 px at a fractional per-frame speed, like a run.
-        for i in 0..400 {
-            let seat = 137.317 + 0.1013 * i as f32;
-            let snapped = seat_origin(Vec2::new(0.0, seat), 0.0, scale).y;
-            worst = worst.max((snapped - seat).abs());
-        }
-        assert!(
-            worst <= 0.5 / scale + f32::EPSILON,
-            "snap displacement {worst} exceeds half a device pixel"
-        );
-    }
-
-    /// One contiguous band per bubble, ascending with rank, so no two bubbles interleave.
-    #[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");
-    }
-
-    /// However many bubbles are live, none reaches the V-plates above or the combat text 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");
-        }
-    }
-
     /// Farthest camera distance first, guid breaking an exact tie.
     #[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)];
+        let mut p = vec![(7, 25.0), (3, 400.0), (9, 1.0), (2, 400.0)];
         stack_sort(&mut p);
         assert_eq!(
-            p.iter().map(|q| q.guid).collect::<Vec<_>>(),
+            p.iter().map(|q| q.0).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));
     }
 
     /// 16 px at 1024-wide 4:3 (width/64), damped past the plate knee.
diff --git a/crates/benilla-app/src/ui_chat.rs b/crates/benilla-app/src/ui_chat.rs
index 3d3be2f8..81d9122b 100644
--- a/crates/benilla-app/src/ui_chat.rs
+++ b/crates/benilla-app/src/ui_chat.rs
@@ -14,6 +14,8 @@ mod ace_gate_tests;
 mod away;
 /// The world broadcasts: `SMSG_ZONE_UNDER_ATTACK`/`_DEFENSE_MESSAGE`/`_SERVER_MESSAGE`.
 mod broadcast;
+/// The chat bubbles' hand-off to their `WorldFrame` widgets.
+pub(crate) mod bubbles;
 mod channels;
 /// The combat log's chat lines: classification, chat type and each sentence's GlobalString key.
 pub(crate) mod combat;
diff --git a/crates/benilla-app/src/ui_chat/bubbles.rs b/crates/benilla-app/src/ui_chat/bubbles.rs
new file mode 100644
index 00000000..420985a5
--- /dev/null
+++ b/crates/benilla-app/src/ui_chat/bubbles.rs
@@ -0,0 +1,19 @@
+//! The chat bubbles' feed: this frame's live bubbles, gated, faded and seated by
+//! [`crate::chat_bubble`], handed to the widget layer, which keeps them as `WorldFrame` children.
+
+use bevy::prelude::*;
+
+use crate::chat_bubble::BubbleFeed;
+
+/// Every frame, after the bubble drive and before the script paint: write the live set into the
+/// VM's bubble pool, which hides and pools the frames of lines that ended.
+pub(crate) fn feed_bubbles(
+    feed: Res<BubbleFeed>,
+    // `None` in a run with no UI VM.
+    script: Option<NonSendMut<benilla_ui::script::UiScript>>,
+) {
+    let (Some(mut script), Some(geometry)) = (script, feed.geometry) else {
+        return;
+    };
+    script.sync_chat_bubbles(geometry, &feed.states);
+}
diff --git a/crates/benilla-app/src/ui_pass.rs b/crates/benilla-app/src/ui_pass.rs
index 902b347c..ebce61e7 100644
--- a/crates/benilla-app/src/ui_pass.rs
+++ b/crates/benilla-app/src/ui_pass.rs
@@ -162,15 +162,6 @@ pub(crate) struct UiQuads {
 pub(crate) mod overlay_z {
     /// Floating combat, XP and honor numbers, drawn by the client in the world scene under all UI.
     pub(crate) const WORLD_TEXT: u64 = 0;
-    /// The chat bubbles: one frame level per live bubble, farthest from the camera first.
-    pub(crate) const BUBBLE: u64 = 1 << 8;
-    /// Keys per bubble level: its bg, edge, tail and text.
-    pub(crate) const BUBBLE_STRIDE: u64 = 4;
-    /// The V-plates, over every bubble; a unit never shows both, so this orders only across units.
-    pub(crate) const VPLATE: u64 = 1 << 16;
-    /// The highest bubble level below [`VPLATE`], a guard rail far past any real count (a bubble
-    /// needs a speaker within 20 yd).
-    pub(crate) const BUBBLE_MAX_LEVEL: u64 = (VPLATE - BUBBLE) / BUBBLE_STRIDE - 1;
 }
 
 /// Clear the append lane at the top of the [`UiQuadAppend`] window, before every appender.
diff --git a/crates/benilla-app/src/ui_script/extract/mod.rs b/crates/benilla-app/src/ui_script/extract/mod.rs
index 24d50716..4237c9dd 100644
--- a/crates/benilla-app/src/ui_script/extract/mod.rs
+++ b/crates/benilla-app/src/ui_script/extract/mod.rs
@@ -114,8 +114,9 @@ pub(crate) fn tiling_axes(uv: &UvRect) -> (bool, bool) {
 }
 
 /// The [`UiQuad::uv_clamp`] window of an atlas crop, inset half a texel so a magnified cell does
-/// not filter in its neighbour. A tiling axis is left alone, as
-/// [`benilla_ui::script::inset_atlas_bleed`] does; a whole-texture axis needs no window.
+/// not filter in its neighbour (in `ChatBubble-Backdrop`, a white alpha-0 column: a pale line
+/// through the speech bubble). A tiling axis is left alone, or each period would land short and
+/// walk the art; a whole-texture axis needs no window.
 fn uv_clamp_window(uv: &UvRect, size: (u32, u32)) -> Option<[f32; 4]> {
     let mut out = [1.0, 1.0, 0.0, 0.0]; // both axes off: `min > max`
     let mut any = false;
diff --git a/crates/benilla-assets/src/world_assets/images.rs b/crates/benilla-assets/src/world_assets/images.rs
index 4ca61b1b..ed3ea7ae 100644
--- a/crates/benilla-assets/src/world_assets/images.rs
+++ b/crates/benilla-assets/src/world_assets/images.rs
@@ -294,7 +294,7 @@ pub fn portrait_image(width: u32, height: u32, mut rgba: Vec<u8>) -> Image {
 /// argument twice into the load descriptor (`0x770200`), read as U and V wrap but not traced to
 /// the sampler: an edge strip runs UVs `[0..N]` (N = frame side / edgeSize − 2) and a tiled
 /// background `[0..w/period]` (`0x77e8d0`, `0x77f0c0`). The edge strips are atlas crops kept off
-/// the image edge (`inset_atlas_bleed`), so their bounded axis does not bleed.
+/// the image edge by half a texel, so their bounded axis does not bleed.
 pub fn sprite_image_tiled(width: u32, height: u32, rgba: Vec<u8>) -> Image {
     sprite_image_wrapped(width, height, rgba, (true, true))
 }
diff --git a/crates/benilla-assets/src/world_assets/mod.rs b/crates/benilla-assets/src/world_assets/mod.rs
index 7ed4e42d..2bfed218 100644
--- a/crates/benilla-assets/src/world_assets/mod.rs
+++ b/crates/benilla-assets/src/world_assets/mod.rs
@@ -362,15 +362,6 @@ impl WorldAssets {
         made
     }
 
-    /// A UI sprite repeating on both axes, for a frame `Backdrop`'s tiled pieces (`0x77f0c0`).
-    pub fn sprite_texture_tiled(
-        &mut self,
-        path: &str,
-        images: &mut Assets<Image>,
-    ) -> Option<Handle<Image>> {
-        self.sprite_texture_wrapped(path, (true, true), images)
-    }
-
     /// A UI sprite repeating on the axes `wrap` names ([`sprite_image_wrapped`]).
     pub fn sprite_texture_wrapped(
         &mut self,
diff --git a/crates/benilla-ui/src/script/backdrop.rs b/crates/benilla-ui/src/script/backdrop.rs
index 2e7b2f9e..ba1c94e0 100644
--- a/crates/benilla-ui/src/script/backdrop.rs
+++ b/crates/benilla-ui/src/script/backdrop.rs
@@ -3,8 +3,7 @@
 //! Texture regions on the frame from it (`0x77e8d0`), the background on BACKGROUND and the eight
 //! border pieces on BORDER. They are ordinary regions: `GetRegions` returns them, the region draw
 //! path paints them, and every Texture verb works on them. The spec drives them: the colour
-//! setters tint them and a resize re-runs their texcoords (`0x77f0c0`). [`pieces`] is the same
-//! geometry as screen quads, for a backdrop the app draws itself (the chat bubble).
+//! setters tint them and a resize re-runs their texcoords (`0x77f0c0`).
 
 use std::collections::HashMap;
 
@@ -36,7 +35,7 @@ pub struct Backdrop {
     /// The 8-slice border texture (`+0x30`); none or empty builds no border.
     pub edge_file: Option<String>,
     /// Tile the background, else stretch it (`+0x40`).
-    pub tile: bool,
+    pub(crate) tile: bool,
     /// `tileSize` in logical px (`+0x4c`); 0 tiles at `edge_size` (`0x77f0c0`).
     pub tile_size: f32,
     /// `edgeSize` in logical px (`+0x48`): the border piece size and the edge tiling period.
@@ -77,17 +76,18 @@ impl Backdrop {
 /// One drawable piece, the background or one of the 8 border pieces: its corners, axis-aligned,
 /// and per-corner UVs, since the top and bottom edges are rotated 90° (`0x77f0c0`). Both arrays
 /// run `[TL, TR, BR, BL]`, y-up.
+#[cfg(test)]
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub struct BackdropPiece {
+pub(crate) struct BackdropPiece {
     /// Corner positions in screen px.
-    pub corners: [[f32; 2]; 4],
+    pub(crate) corners: [[f32; 2]; 4],
     /// Corner UVs in texture space.
-    pub uvs: [[f32; 2]; 4],
+    pub(crate) uvs: [[f32; 2]; 4],
     /// The texture needs repeat addressing. The corners stay in `[0,1]` but share the edge texture,
     /// so they carry `true` too and the border batches as one texture (`0x77e8d0`).
     pub tile: bool,
     /// Drawn with `bg_file` and `bg_color`, else with `edge_file` and `border_color`.
-    pub is_bg: bool,
+    pub(crate) is_bg: bool,
 }
 
 const SLICE: f32 = 0.125;
@@ -212,36 +212,8 @@ fn run_uvs(bd: &Backdrop, rect: Rect, scale: f32) -> (Option<Uvs>, [Uvs; 4]) {
     (bg, edges)
 }
 
-/// Pull a piece's UVs half a texel inward on every axis that does not tile, so bilinear
-/// magnification cannot sample the neighbouring slice of the shared border atlas (in
-/// `ChatBubble-Backdrop`, a white alpha-0 column: a pale line through the speech bubble). A tiling
-/// axis, a strip's `v` past 1, is left exact, or each period would land short and walk the art.
-#[must_use]
-pub fn inset_atlas_bleed(uvs: [[f32; 2]; 4], tex_w: f32, tex_h: f32) -> [[f32; 2]; 4] {
-    let mut out = uvs;
-    for (axis, tex) in [(0usize, tex_w), (1usize, tex_h)] {
-        if tex < 2.0 {
-            continue; // a 1-texel axis has no interior
-        }
-        let (lo, hi) = uvs.iter().fold((f32::MAX, f32::MIN), |(lo, hi), c| {
-            (lo.min(c[axis]), hi.max(c[axis]))
-        });
-        // A range of exactly 1, the corners' `v`, is bounded and gets the inset.
-        if hi - lo > 1.0 + f32::EPSILON {
-            continue;
-        }
-        let half = 0.5 / tex;
-        if hi - lo <= 2.0 * half {
-            continue; // degenerate: the inset would invert the range
-        }
-        for c in &mut out {
-            c[axis] += if c[axis] <= lo { half } else { -half };
-        }
-    }
-    out
-}
-
 /// Axis-aligned corners `[TL, TR, BR, BL]`, y-up.
+#[cfg(test)]
 fn aa_corners(x0: f32, x1: f32, y_bottom: f32, y_top: f32) -> [[f32; 2]; 4] {
     [
         [x0, y_top],    // TL
@@ -253,9 +225,11 @@ fn aa_corners(x0: f32, x1: f32, y_bottom: f32, y_top: f32) -> [[f32; 2]; 4] {
 
 /// The drawable pieces for a frame's resolved rect (y-up), in paint order: the background (layer
 /// `BACKGROUND`), then the 8 border pieces (layer `BORDER`), as the regions `install` builds
-/// would resolve and draw. Their geometry is in the frame's own units, so it is multiplied by the
-/// frame's effective `scale` (`0x76ac90`), as any region's is.
-pub fn pieces(frame: Rect, bd: &Backdrop, scale: f32) -> Vec<BackdropPiece> {
+/// would resolve and draw, the oracle the region tests check them against. Their geometry is in
+/// the frame's own units, so it is multiplied by the frame's effective `scale` (`0x76ac90`), as
+/// any region's is.
+#[cfg(test)]
+pub(crate) fn pieces(frame: Rect, bd: &Backdrop, scale: f32) -> Vec<BackdropPiece> {
     let mut out = Vec::with_capacity(9);
     let e = bd.edge_size * scale;
     let (l, r, b, t) = (frame.left, frame.right, frame.bottom, frame.top);
@@ -360,12 +334,7 @@ pub(crate) fn install(model: &mut Model, fh: FrameHandle, spec: Option<Backdrop>
         let rh = model
             .arena
             .create_region(fh, RegionKind::Texture, layer, 0)?;
-        let anchors = anchors
-            .into_iter()
-            .flatten()
-            .map(|(p, x, y)| Anchor::new(p, owner, p, x, y))
-            .collect();
-        let size = (size != (0.0, 0.0)).then_some(size);
+        let (anchors, size) = piece_geometry(owner, (anchors, size));
         model.region_data.insert(
             rh,
             RegionData {
@@ -412,6 +381,58 @@ pub(crate) fn install(model: &mut Model, fh: FrameHandle, spec: Option<Backdrop>
     }
 }
 
+/// A piece's anchors on frame `owner` and its explicit size, `None` where the anchors span both
+/// axes.
+fn piece_geometry(owner: u32, (anchors, size): PieceLayout) -> (Vec<Anchor>, Option<(f32, f32)>) {
+    let anchors = anchors
+        .into_iter()
+        .flatten()
+        .map(|(p, x, y)| Anchor::new(p, owner, p, x, y))
+        .collect();
+    (anchors, (size != (0.0, 0.0)).then_some(size))
+}
+
+/// Re-size an installed backdrop in place, its nine regions kept: the edge size, the tile period
+/// and the insets, each piece re-anchored as `0x77e8d0` would build it, then the texcoords re-run.
+/// No 1.12 call does this; the engine's chat bubbles take it on a window resize, where the
+/// reference's sizes are window-relative and never need it (`0x4b0940`).
+pub(crate) fn set_metrics(
+    model: &mut Model,
+    fh: FrameHandle,
+    edge_size: f32,
+    tile_size: f32,
+    insets: Insets,
+) {
+    let Some(inst) = model.backdrops.get_mut(&fh) else {
+        return;
+    };
+    if inst.spec.edge_size == edge_size
+        && inst.spec.tile_size == tile_size
+        && inst.spec.insets == insets
+    {
+        return;
+    }
+    inst.spec.edge_size = edge_size;
+    inst.spec.tile_size = tile_size;
+    inst.spec.insets = insets;
+    inst.ran_for = None;
+    let (spec, pieces) = (inst.spec.clone(), inst.pieces);
+    let owner = model.frame_id(fh);
+    let layouts = std::iter::once(bg_layout(&spec)).chain(EDGES.map(|e| edge_layout(e, edge_size)));
+    for (slot, layout) in pieces.into_iter().zip(layouts) {
+        let Some(d) = slot.and_then(|rh| model.region_data.get_mut(&rh)) else {
+            continue;
+        };
+        (d.anchors, d.size) = piece_geometry(owner, layout);
+    }
+    for rh in pieces.iter().flatten() {
+        model.touch_layout_region(*rh);
+    }
+    if let Some(rect) = model.resolved.get(&fh).copied() {
+        run_texcoords(model, fh, rect);
+    }
+}
+
 /// `0x77f0c0` for frame `fh` at `rect`, from `install`.
 fn run_texcoords(model: &mut Model, fh: FrameHandle, rect: Rect) {
     let scale = super::object::eff_scale(model, fh);
@@ -522,52 +543,6 @@ pub(crate) fn after_resolve(model: &mut Model) {
 mod tests {
     use super::*;
 
-    /// On the `ChatBubble-Backdrop` geometry: 256×32, eight 32-texel slices.
-    #[test]
-    fn the_bleed_inset_lands_on_texel_centres_and_spares_tiling() {
-        const W: f32 = 256.0;
-        const H: f32 = 32.0;
-        let half_u = 0.5 / W;
-
-        let corner = [[0.5, 0.0], [0.625, 0.0], [0.625, 1.0], [0.5, 1.0]];
-        let got = inset_atlas_bleed(corner, W, H);
-        // 128.5 and 159.5 are the centres of the slice's first and last texels.
-        let us: Vec<f32> = got.iter().map(|c| c[0] * W).collect();
-        assert!((us[0] - 128.5).abs() < 1e-3, "left u at {} texels", us[0]);
-        assert!((us[1] - 159.5).abs() < 1e-3, "right u at {} texels", us[1]);
-        let vs: Vec<f32> = got.iter().map(|c| c[1] * H).collect();
-        assert!((vs[0] - 0.5).abs() < 1e-3, "top v at {} texels", vs[0]);
-        assert!((vs[2] - 31.5).abs() < 1e-3, "bottom v at {} texels", vs[2]);
-
-        let strip = [[0.25, 8.0], [0.25, 0.0], [0.375, 0.0], [0.375, 8.0]];
-        let got = inset_atlas_bleed(strip, W, H);
-        for (g, s) in got.iter().zip(strip.iter()) {
-            assert_eq!(g[1], s[1], "the tiling axis must be bit-exact");
-        }
-        assert!((got[0][0] - (0.25 + half_u)).abs() < 1e-6);
-        assert!((got[2][0] - (0.375 - half_u)).abs() < 1e-6);
-
-        for i in 0u8..8 {
-            let (u0, u1) = (f32::from(i) * SLICE, f32::from(i + 1) * SLICE);
-            let piece = [[u0, 0.0], [u1, 0.0], [u1, 1.0], [u0, 1.0]];
-            for c in inset_atlas_bleed(piece, W, H) {
-                assert!(
-                    c[0] > u0 && c[0] < u1,
-                    "slice {i}: u {} escaped ({u0},{u1})",
-                    c[0]
-                );
-            }
-        }
-
-        assert_eq!(inset_atlas_bleed(corner, 0.0, 0.0), corner);
-        let sliver = [[0.0, 0.0], [0.001, 0.0], [0.001, 1.0], [0.0, 1.0]];
-        assert_eq!(
-            inset_atlas_bleed(sliver, W, H)[0][0],
-            0.0,
-            "too thin to inset"
-        );
-    }
-
     fn tooltip_backdrop(edge_size: f32, inset: f32) -> Backdrop {
         Backdrop {
             bg_file: Some("Interface\\Tooltips\\UI-Tooltip-Background".into()),
diff --git a/crates/benilla-ui/src/script/chat_bubble.rs b/crates/benilla-ui/src/script/chat_bubble.rs
new file mode 100644
index 00000000..39c8cebe
--- /dev/null
+++ b/crates/benilla-ui/src/script/chat_bubble.rs
@@ -0,0 +1,463 @@
+//! The chat bubble widgets: the reference's `CGChatBubbleFrame` (ctor `0x4b0940`), an anonymous
+//! `Frame` the pool `0x4b1870` builds with the `WorldFrame` as its parent (the spawn passes
+//! `[0xb4b2bc]`, `0x608bb9`), so it takes the `WorldFrame`'s stratum (`SetParent 0x76ab10`).
+//! Bubble addons (pfUI's `bubbles.lua`) find it in `WorldFrame:GetChildren()` by its first
+//! region's texture and read it positionally: eleven regions in creation order, the backdrop's
+//! background and eight border pieces (`0x4b0a35` → `0x77e8d0`), the tail (`0x4b0a57`) and the
+//! text (`0x4b0b14`).
+//!
+//! The app owns each line's lifetime, fade and seat ([`BubbleState`]); this layer owns the frames:
+//! it hands one out per line, takes it back when the line ends, and writes what moved.
+
+use std::collections::{HashMap, VecDeque};
+
+use crate::layout::{Anchor, Point};
+use crate::order::DrawLayer;
+use crate::widget::{FrameHandle, FrameKind, RegionHandle, RegionKind};
+
+use super::backdrop::{self, Backdrop, Insets};
+use super::model::Model;
+use super::UiScript;
+
+/// Region 1's art, the backdrop's background, and the path bubble addons identify a bubble by.
+pub const BG_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Background";
+/// Regions 2 to 9, the backdrop's eight border pieces.
+pub const EDGE_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Backdrop";
+/// Region 10, the tail.
+pub const TAIL_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Tail";
+
+/// The first frame level the per-frame pass stamps, farthest bubble first (`0x4b12de`).
+const FIRST_LEVEL: u16 = 2;
+
+/// The bubble geometry that follows from the window rather than the line, in the `WorldFrame`'s
+/// units. Written into a bubble when it changes, so an addon's own anchors survive between
+/// resizes.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct BubbleGeometry {
+    /// The border unit (`0x4b09d2`-`0x4b0a2f`): the backdrop's edge size, tile size and four
+    /// insets, the tail's side, and half the text's width floor.
+    pub border: f32,
+    /// The frame's margin around the text on all four sides (`0x4b0b6b`, `0x4b0b94`).
+    pub margin: f32,
+    /// The text's width cap, past which it wraps (`0x4b175d`).
+    pub wrap_cap: f32,
+    /// The text's font height (`0x4b0b21`).
+    pub text_height: f32,
+    /// Device pixels per unit, the grid the seat snaps to.
+    pub device_px: f32,
+}
+
+/// One live bubble's state for this frame, in the active list's order: farthest from the camera
+/// first, which is the frame level order.
+#[derive(Clone, Debug, PartialEq)]
+pub struct BubbleState {
+    /// The speaker's GUID: a speaker has at most one bubble (`[unit+0xe64]`).
+    pub key: u64,
+    /// The chat line, unique per spawn: a new value for a live key is a new line, which replaces
+    /// the bubble (`0x608bb4`, `0x608bbf`).
+    pub line: u64,
+    /// The display text, already through the bubble's escape strip.
+    pub text: String,
+    /// The chat type's colour (`0x49e990`).
+    pub colour: [f32; 3],
+    /// The own-shown bit: a line is shown when it spawns and while it fades, hidden when an
+    /// out-of-range fade ends (`0x4b0d9f`), shown again on the way back (`0x4b0ea0`).
+    pub shown: bool,
+    /// The fade's frame alpha (`0x4b0d4f`, `0x4b0dc3`).
+    pub alpha: f32,
+    /// The projected speaker point the text's BOTTOM sits on, from the `WorldFrame`'s
+    /// BOTTOMLEFT (`0x4b157a`).
+    pub seat: (f32, f32),
+}
+
+/// One pooled bubble's widgets, in the reference's creation order after the backdrop's nine.
+#[derive(Debug)]
+struct Bubble {
+    frame: FrameHandle,
+    tail: RegionHandle,
+    text: RegionHandle,
+    /// The `(key, line)` it shows; `None` in the free list.
+    line: Option<(u64, u64)>,
+    /// The own-shown bit as this layer last set it (`[frame+0xd0]`); a new frame is born shown by
+    /// `CSimpleFrame`'s ctor (`0x76934a`).
+    shown: bool,
+    /// The anchor offset last written, the change gate's cache (`[bubble+0x324]`, `+0x328`).
+    seat: Option<(f32, f32)>,
+    /// The geometry its sizes were written under.
+    laid_out: Option<BubbleGeometry>,
+}
+
+/// The bubble pool: grown on demand, never shrunk or reordered, so every bubble keeps its place in
+/// the `WorldFrame`'s child list for the session.
+#[derive(Debug, Default)]
+pub(crate) struct ChatBubbles {
+    bubbles: Vec<Bubble>,
+    /// The free list (`[0xb6f064]`): a finished bubble joins the tail (`0x4b15e5`-`0x4b15f7`) and a
+    /// new line takes the head (`0x4b1870`), so the bubble retired first is reused first.
+    free: VecDeque<usize>,
+    /// Each live speaker's pool slot, by [`BubbleState::key`].
+    assigned: HashMap<u64, usize>,
+    /// Frame to pool slot, never removed.
+    by_frame: HashMap<FrameHandle, usize>,
+    /// The active list (`[0xb6f038]`) as the last sync left it: the live slots, farthest first.
+    active: Vec<usize>,
+}
+
+impl UiScript {
+    /// Drive the pool from the app's live bubbles: end the lines that are gone, hand a frame to
+    /// each new one, then write each live bubble's level, alpha, visibility and seat.
+    pub fn sync_chat_bubbles(&mut self, geometry: BubbleGeometry, states: &[BubbleState]) {
+        let lua = self.lua();
+        // The font a new bubble takes: `FrameScript_GetText` on `NAMEPLATE_FONT` (`0x4b0b36` →
+        // `0x703bf0`), whose `_G[key]` arm (`0x703c12`) answers the global's string, else the
+        // shared "" a missing or non-string global gives, which sets no font.
+        let font = || match lua.globals().get::<mlua::Value>("NAMEPLATE_FONT") {
+            Ok(mlua::Value::String(s)) => Some(s.to_string_lossy()).filter(|s| !s.is_empty()),
+            _ => None,
+        };
+        let visibility = {
+            let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+            // No WorldFrame (no interface loaded), no bubbles: no addon walks an invented root.
+            let Some(world) = model.arena.lookup("WorldFrame") else {
+                return;
+            };
+            sync(&mut model, world, geometry, states, &font)
+        };
+        // Each a full transition with its handlers, in the order the sync issued them.
+        for (frame, shown) in visibility {
+            super::visibility::set_shown(lua, frame, shown);
+        }
+    }
+
+    /// How many bubble widgets the pool holds.
+    pub fn chat_bubble_pool_len(&self) -> usize {
+        let lua = self.lua();
+        let model = lua.app_data_ref::<Model>().expect("model app_data");
+        model.chat_bubbles.bubbles.len()
+    }
+}
+
+/// Whether `frame` is a pooled bubble.
+pub(super) fn is_bubble(model: &Model, frame: FrameHandle) -> bool {
+    model.chat_bubbles.by_frame.contains_key(&frame)
+}
+
+/// The per-frame drive; returns the `Show`/`Hide` calls to run, in order.
+fn sync(
+    model: &mut Model,
+    world: FrameHandle,
+    geometry: BubbleGeometry,
+    states: &[BubbleState],
+    font: &dyn Fn() -> Option<String>,
+) -> Vec<(FrameHandle, bool)> {
+    let mut visibility = Vec::new();
+
+    // Lines that ended, in the active list's order, farthest first, as the reference's walk
+    // (`0x4b1138`) meets and destroys them (`0x4b1186`, `0x4b11c0`), so they join the free list in
+    // that order, before any new line this frame looks for a frame.
+    let live = |key: u64, line: u64| states.iter().any(|s| s.key == key && s.line == line);
+    for i in std::mem::take(&mut model.chat_bubbles.active) {
+        if let Some((key, line)) = model.chat_bubbles.bubbles[i].line {
+            if !live(key, line) {
+                retire(model, i, &mut visibility);
+            }
+        }
+    }
+
+    let world_id = model.frame_id(world);
+    for (rank, state) in states.iter().enumerate() {
+        let slot = match model.chat_bubbles.assigned.get(&state.key) {
+            Some(&i) => i,
+            None => {
+                // A new line: the spawn's acquire (`0x4b1870`), then its text (`0x4b1600`).
+                let i = acquire(model, world, geometry, font);
+                model.chat_bubbles.assigned.insert(state.key, i);
+                if model.chat_bubbles.bubbles[i].laid_out != Some(geometry) {
+                    lay_out(model, i, geometry);
+                }
+                set_line(model, i, state, geometry, &mut visibility);
+                i
+            }
+        };
+        if model.chat_bubbles.bubbles[slot].laid_out != Some(geometry) {
+            lay_out(model, slot, geometry);
+            fit_width(model, slot, geometry);
+        }
+        drive(
+            model,
+            slot,
+            world_id,
+            rank,
+            state,
+            geometry,
+            &mut visibility,
+        );
+        model.chat_bubbles.active.push(slot);
+    }
+    visibility
+}
+
+/// Take a frame for a new line: the free list's head, else a new one at the pool's tail.
+fn acquire(
+    model: &mut Model,
+    world: FrameHandle,
+    geometry: BubbleGeometry,
+    font: &dyn Fn() -> Option<String>,
+) -> usize {
+    if let Some(i) = model.chat_bubbles.free.pop_front() {
+        return i;
+    }
+    let bubble = create(model, world, geometry, font());
+    let i = model.chat_bubbles.bubbles.len();
+    model.chat_bubbles.by_frame.insert(bubble.frame, i);
+    model.chat_bubbles.bubbles.push(bubble);
+    i
+}
+
+/// End a bubble's line (`0x4b1590`): clear its shown bit and hide it, then put it on the free
+/// list's tail. It keeps its parent and its place in the child list.
+fn retire(model: &mut Model, i: usize, visibility: &mut Vec<(FrameHandle, bool)>) {
+    let b = &mut model.chat_bubbles.bubbles[i];
+    let Some((key, _)) = b.line.take() else {
+        return;
+    };
+    if b.shown {
+        b.shown = false;
+        visibility.push((b.frame, false));
+    }
+    model.chat_bubbles.assigned.remove(&key);
+    model.chat_bubbles.free.push_back(i);
+}
+
+/// Build one bubble (`0x4b0940`): the Frame under the `WorldFrame`, the backdrop's nine regions,
+/// the tail, the text, and the frame's two anchors on the text.
+fn create(
+    model: &mut Model,
+    world: FrameHandle,
+    g: BubbleGeometry,
+    font: Option<String>,
+) -> Bubble {
+    // Anonymous: the pool passes no name.
+    let frame = model.arena.create(FrameKind::Frame, None, Some(world));
+    // `SetParent 0x76ab10`: the parent's stratum and its level plus one, until the first level
+    // stamp.
+    let (strata, level) = model
+        .arena
+        .frame(world)
+        .map(|f| (f.strata, f.level))
+        .unwrap_or_default();
+    model.arena.set_frame_strata(frame, strata);
+    model
+        .arena
+        .set_frame_level(frame, level.saturating_add(1), false);
+
+    // The backdrop first (`0x4b0a35` → `0x76a5d0`): edge mask 0xff and tile on (`0x4b09bf`,
+    // `0x4b09c6`), one border unit for the four insets (`0x4b09ec`-`0x4b09f5`), the edge size
+    // (`0x4b0a12`, `+0x48`) and the tile size (`0x4b0a2f`, `+0x4c`).
+    backdrop::install(
+        model,
+        frame,
+        Some(Backdrop {
+            bg_file: Some(BG_TEXTURE.to_string()),
+            edge_file: Some(EDGE_TEXTURE.to_string()),
+            tile: true,
+            tile_size: g.border,
+            edge_size: g.border,
+            insets: uniform(g.border),
+            ..Backdrop::default()
+        }),
+    );
+    // Then the tail on ARTWORK (`0x4b0a57`, layer 2) and the text on ARTWORK (`0x4b0b14`, layer 2).
+    let tail = model
+        .arena
+        .create_region(frame, RegionKind::Texture, DrawLayer::Artwork, 0)
+        .expect("live bubble");
+    model.region_data.entry(tail).or_default().texture = Some(TAIL_TEXTURE.to_string());
+    let text = model
+        .arena
+        .create_region(frame, RegionKind::FontString, DrawLayer::Artwork, 0)
+        .expect("live bubble");
+    // The `NAMEPLATE_FONT` global's font with no flags (`0x4b0b2b`-`0x4b0b42`): no outline, no
+    // shadow.
+    let data = model.region_data.entry(text).or_default();
+    data.font_path = font;
+    data.font_explicit.face = true;
+    model.touch_layout_frame(frame);
+    model.touch_layout_region(tail);
+    model.touch_layout_region(text);
+
+    Bubble {
+        frame,
+        tail,
+        text,
+        line: None,
+        shown: true,
+        seat: None,
+        laid_out: None,
+    }
+}
+
+fn uniform(v: f32) -> Insets {
+    Insets {
+        left: v,
+        right: v,
+        top: v,
+        bottom: v,
+    }
+}
+
+/// Write the window-derived sizes and anchors: the backdrop's unit, the tail (`0x4b0a7d`-
+/// `0x4b0af1`), the font height and the frame's margin anchors on the text.
+fn lay_out(model: &mut Model, i: usize, g: BubbleGeometry) {
+    let b = &model.chat_bubbles.bubbles[i];
+    let (frame, tail, text) = (b.frame, b.tail, b.text);
+    backdrop::set_metrics(model, frame, g.border, g.border, uniform(g.border));
+    let frame_id = model.frame_id(frame);
+    let text_id = model.region_id(text);
+
+    // A border-unit square, its TOPRIGHT on the frame's BOTTOM lifted a quarter unit.
+    let tail_data = model.region_data.entry(tail).or_default();
+    tail_data.size = Some((g.border, g.border));
+    tail_data.anchors = vec![Anchor::new(
+        Point::TopRight,
+        frame_id,
+        Point::Bottom,
+        0.0,
+        g.border / 4.0,
+    )];
+
+    model.region_data.entry(text).or_default().font_height = Some(g.text_height);
+    model.touch_measure(text);
+
+    // The frame hugs the text: TOPLEFT and BOTTOMRIGHT on the text's, out by the margin.
+    let input = model.layout_inputs.entry(frame).or_default();
+    input.anchors = vec![
+        Anchor::new(Point::TopLeft, text_id, Point::TopLeft, -g.margin, g.margin),
+        Anchor::new(
+            Point::BottomRight,
+            text_id,
+            Point::BottomRight,
+            g.margin,
+            -g.margin,
+        ),
+    ];
+    // Once per geometry change: each node it wrote re-derives.
+    model.touch_layout_frame(frame);
+    model.touch_layout_region(tail);
+    model.touch_layout_region(text);
+    model.chat_bubbles.bubbles[i].laid_out = Some(g);
+}
+
+/// Show a new line (`0x4b1600`): its text and colour, its width fitted, then `Show` through the
+/// fade-in's start (`0x4b17f7` → `0x4b0ea0` → vtable `+0x88`), which fires `OnShow` on a reused,
+/// hidden frame.
+fn set_line(
+    model: &mut Model,
+    i: usize,
+    state: &BubbleState,
+    g: BubbleGeometry,
+    visibility: &mut Vec<(FrameHandle, bool)>,
+) {
+    let b = &mut model.chat_bubbles.bubbles[i];
+    b.line = Some((state.key, state.line));
+    let (frame, text, was_shown) = (b.frame, b.text, b.shown);
+    b.shown = true;
+    let c = state.colour;
+    let data = model.region_data.entry(text).or_default();
+    data.text = Some(state.text.clone());
+    data.vertex_color = Some([c[0], c[1], c[2], 1.0]);
+    fit_width(model, i, g);
+    if !was_shown {
+        visibility.push((frame, true));
+    }
+}
+
+/// The width law (`0x4b16c5`-`0x4b1796`): with width and height cleared, the text's own width;
+/// past the cap the cap, so it wraps, else at least two border units. The height stays cleared,
+/// so it is the wrapped text's.
+fn fit_width(model: &mut Model, i: usize, g: BubbleGeometry) {
+    let text = model.chat_bubbles.bubbles[i].text;
+    if let Some(d) = model.region_data.get_mut(&text) {
+        d.size = None;
+    }
+    model.touch_measure(text);
+    super::measure::ensure_measured_in(model, text);
+    let natural = super::region::virtual_span(model, text).0;
+    let floor = 2.0 * g.border;
+    let width = if natural > g.wrap_cap {
+        g.wrap_cap
+    } else {
+        natural.max(floor)
+    };
+    if let Some(d) = model.region_data.get_mut(&text) {
+        d.size = Some((width, 0.0));
+    }
+    model.touch_measure(text);
+    model.touch_layout_region(text);
+}
+
+/// The per-frame write, each property only when it moved.
+fn drive(
+    model: &mut Model,
+    i: usize,
+    world_id: u32,
+    rank: usize,
+    state: &BubbleState,
+    g: BubbleGeometry,
+    visibility: &mut Vec<(FrameHandle, bool)>,
+) {
+    let b = &model.chat_bubbles.bubbles[i];
+    let (frame, text, shown, last_seat) = (b.frame, b.text, b.shown, b.seat);
+
+    // `0x76a4f0(2 + i, 0)` down the list: no carry to children (`0x4b1306`).
+    let level = u16::try_from(rank)
+        .unwrap_or(u16::MAX)
+        .saturating_add(FIRST_LEVEL);
+    model.arena.set_frame_level(frame, level, false);
+
+    if model
+        .arena
+        .frame(frame)
+        .is_some_and(|f| f.alpha != state.alpha)
+    {
+        model.arena.set_alpha(frame, state.alpha);
+    }
+    if shown != state.shown {
+        model.chat_bubbles.bubbles[i].shown = state.shown;
+        visibility.push((frame, state.shown));
+    }
+
+    // The seat (`0x4b14a0`): the text's BOTTOM on the `WorldFrame`'s BOTTOMLEFT, re-anchored only
+    // when the snapped point moved. Deviation: the frame's bottom-left origin is snapped onto the
+    // device grid so the border art blits 1:1; the reference ceils the anchor point itself onto
+    // it (`0x7666a0`, `0x766750`).
+    let width = model
+        .region_data
+        .get(&text)
+        .and_then(|d| d.size)
+        .map_or(0.0, |s| s.0)
+        + 2.0 * g.margin;
+    let snap = |v: f32| {
+        if g.device_px > 0.0 {
+            (v * g.device_px).round() / g.device_px
+        } else {
+            v
+        }
+    };
+    let seat = (
+        snap(state.seat.0 - width * 0.5) + width * 0.5,
+        snap(state.seat.1 - g.margin) + g.margin,
+    );
+    if last_seat != Some(seat) {
+        let data = model.region_data.entry(text).or_default();
+        data.anchors = vec![Anchor::new(
+            Point::Bottom,
+            world_id,
+            Point::BottomLeft,
+            seat.0,
+            seat.1,
+        )];
+        model.touch_layout_region(text);
+        model.chat_bubbles.bubbles[i].seat = Some(seat);
+    }
+}
diff --git a/crates/benilla-ui/src/script/measure.rs b/crates/benilla-ui/src/script/measure.rs
index 41eb46c1..fafde852 100644
--- a/crates/benilla-ui/src/script/measure.rs
+++ b/crates/benilla-ui/src/script/measure.rs
@@ -36,10 +36,15 @@ pub trait TextMeasure {
 /// one is left alone, so a per-frame poll does not re-measure.
 pub(super) fn ensure_measured(lua: &Lua, rh: RegionHandle) {
     let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+    ensure_measured_in(&mut model, rh);
+}
+
+/// [`ensure_measured`] on a borrowed model, for the engine's own widgets.
+pub(super) fn ensure_measured_in(model: &mut Model, rh: RegionHandle) {
     if model.measurer.is_none() {
         return;
     }
-    let Some(req) = super::layout::measure_request_for(&mut model, rh) else {
+    let Some(req) = super::layout::measure_request_for(model, rh) else {
         return; // not a FontString, no text, or already current
     };
     // Taken out and put back: the measurer needs `&mut self` while the model is borrowed, and it
diff --git a/crates/benilla-ui/src/script/mod.rs b/crates/benilla-ui/src/script/mod.rs
index f8ce7279..952df7da 100644
--- a/crates/benilla-ui/src/script/mod.rs
+++ b/crates/benilla-ui/src/script/mod.rs
@@ -34,6 +34,8 @@ mod calls;
 mod camera_view;
 mod channel;
 mod char_stats;
+pub mod chat_bubble;
+pub use chat_bubble::{BubbleGeometry, BubbleState};
 mod chat_misc;
 mod chat_send;
 mod chat_types;
@@ -158,7 +160,7 @@ pub use auction::{
     AuctionStartRequest, AuctionState, AuctionSubCategory, BIDDER, LIST, OWNER, SORT_KEYS,
 };
 pub use aura::{AuraState, TrackingState};
-pub use backdrop::{inset_atlas_bleed, pieces, Backdrop, BackdropPiece, Insets};
+pub use backdrop::{Backdrop, Insets};
 pub use bank::BankState;
 pub use battlefield_positions::{BattlefieldFlagView, BattlefieldPositionView};
 pub use battlefield_queue::{BattlefieldListView, BattlefieldMapInfo, BattlefieldQueueSlot};
diff --git a/crates/benilla-ui/src/script/model.rs b/crates/benilla-ui/src/script/model.rs
index 7fa11087..46ca7703 100644
--- a/crates/benilla-ui/src/script/model.rs
+++ b/crates/benilla-ui/src/script/model.rs
@@ -926,6 +926,8 @@ pub(crate) struct Model {
     pub(crate) worldmap: super::worldmap::WorldMapState,
     /// Nameplate `Button`s under `WorldFrame`, never shrunk, visible to `GetChildren()`.
     pub(crate) nameplates: super::nameplate::NamePlates,
+    /// Chat bubble `Frame`s under `WorldFrame`, pooled the same way.
+    pub(crate) chat_bubbles: super::chat_bubble::ChatBubbles,
     /// The world-state readout's rows, gated and resolved by the app.
     pub(crate) worldstate: super::worldstate::WorldStateUiState,
     /// Events bindings raise. Deviation: fired at the next tick, not synchronously as in the
@@ -1422,6 +1424,7 @@ impl Model {
             server_unix_time: None,
             worldmap: super::worldmap::WorldMapState::default(),
             nameplates: super::nameplate::NamePlates::default(),
+            chat_bubbles: super::chat_bubble::ChatBubbles::default(),
             worldstate: super::worldstate::WorldStateUiState::default(),
             pending_events: Vec::new(),
             cursor_pos: (0.0, 0.0),
diff --git a/crates/benilla-ui/src/script/nameplate.rs b/crates/benilla-ui/src/script/nameplate.rs
index 1b3b2816..c9b44565 100644
--- a/crates/benilla-ui/src/script/nameplate.rs
+++ b/crates/benilla-ui/src/script/nameplate.rs
@@ -760,11 +760,11 @@ fn font_string(model: &mut Model, frame: FrameHandle, justify_v: JustifyV) -> Re
     rh
 }
 
-/// Whether a text's owner is a plate. A plate's rect snaps to device pixels as it slides, and its
-/// text must follow that rect, not the UI's coarser grid, or it jumps. Asked of the frame so an
-/// addon's strings on the plate get it too; a string on the plate's health bar does not.
+/// Whether a text's owner is a plate or a chat bubble. Their rects snap to device pixels as they
+/// slide, and their text must follow that rect, not the UI's coarser grid, or it jumps. Asked of
+/// the frame so an addon's strings on one get it too; a string on the plate's health bar does not.
 pub(super) fn is_world_seated(model: &Model, frame: FrameHandle) -> bool {
-    model.nameplates.by_frame.contains_key(&frame)
+    model.nameplates.by_frame.contains_key(&frame) || super::chat_bubble::is_bubble(model, frame)
 }
 
 /// Whether this is the plate's own glow art on its ADD mode, which the quad walk
diff --git a/crates/benilla-ui/src/script/tests/backdrop.rs b/crates/benilla-ui/src/script/tests/backdrop.rs
index c10c04e7..08a398a3 100644
--- a/crates/benilla-ui/src/script/tests/backdrop.rs
+++ b/crates/benilla-ui/src/script/tests/backdrop.rs
@@ -2,6 +2,7 @@
 //! `0x77e5f0`, and its pieces, `0x77e8d0`).
 
 use super::common::script;
+use crate::script::backdrop::pieces;
 use crate::script::*;
 
 // SetBackdropColor tints only the bg, SetBackdropBorderColor the 8 border pieces.
diff --git a/crates/benilla-ui/src/script/tests/chat_bubble.rs b/crates/benilla-ui/src/script/tests/chat_bubble.rs
new file mode 100644
index 00000000..ca449c44
--- /dev/null
+++ b/crates/benilla-ui/src/script/tests/chat_bubble.rs
@@ -0,0 +1,472 @@
+//! The chat bubble ABI as a bubble addon reads it: pfUI's `modules/bubbles.lua` walks
+//! `WorldFrame:GetChildren()`, takes an unnamed child whose first region's texture is
+//! `ChatBubble-Background`, blanks every Texture, reads the FontString's text and colour, parents
+//! its own frame to the bubble with `SetAllPoints` and hooks `OnShow`.
+
+use crate::script::{
+    BubbleGeometry, BubbleState, MeasureRequest, QuadContent, TextMeasure, UiScript,
+};
+
+/// Each character `PER_CHAR` wide and each line `LINE_H` tall, wrapped greedily.
+struct BlockFont;
+
+const PER_CHAR: f32 = 6.0;
+const LINE_H: f32 = 13.0;
+
+impl TextMeasure for BlockFont {
+    fn measure(&mut self, req: &MeasureRequest) -> (f32, f32, f32) {
+        let natural = req.text.chars().count() as f32 * PER_CHAR;
+        match req.wrap_width {
+            Some(w) if w > 0.0 && natural > w => {
+                let rows = (natural / w).ceil();
+                (w, rows * LINE_H, natural)
+            }
+            _ => (natural, LINE_H, natural),
+        }
+    }
+}
+
+/// A VM with a `WorldFrame` to hang bubbles off and a font engine to measure their text.
+fn vm() -> UiScript {
+    let mut s = UiScript::new().unwrap();
+    s.set_screen_size(1024.0, 768.0);
+    s.set_text_measurer(Box::new(BlockFont));
+    s.run(r#"WorldFrame = CreateFrame("WorldFrame", "WorldFrame") WorldFrame:SetAllPoints()"#)
+        .unwrap();
+    s.resolve();
+    s
+}
+
+const BORDER: f32 = 16.0;
+const MARGIN: f32 = 13.0;
+
+fn geometry() -> BubbleGeometry {
+    BubbleGeometry {
+        border: BORDER,
+        margin: MARGIN,
+        wrap_cap: 256.0,
+        text_height: LINE_H,
+        device_px: 1.0,
+    }
+}
+
+fn say(key: u64, line: u64, text: &str) -> BubbleState {
+    BubbleState {
+        key,
+        line,
+        text: text.to_string(),
+        colour: [1.0, 1.0, 1.0],
+        shown: true,
+        alpha: 1.0,
+        seat: (500.0, 300.0),
+    }
+}
+
+/// Drive the bubbles and settle the layout, the way one app frame does.
+fn drive(s: &mut UiScript, states: &[BubbleState]) {
+    s.sync_chat_bubbles(geometry(), states);
+    s.resolve();
+}
+
+/// A say puts an anonymous `Frame` under the `WorldFrame`, in its stratum, shown.
+#[test]
+fn a_say_puts_an_anonymous_frame_in_the_worldframe_child_list() {
+    let mut s = vm();
+    assert_eq!(
+        s.eval::<i64>("return WorldFrame:GetNumChildren()").unwrap(),
+        0
+    );
+    drive(&mut s, &[say(7, 1, "Well met!")]);
+    assert_eq!(
+        s.eval::<i64>("return WorldFrame:GetNumChildren()").unwrap(),
+        1
+    );
+    assert!(s
+        .eval::<bool>(
+            r#"local b = WorldFrame:GetChildren()
+               return b:GetObjectType() == "Frame" and b:GetName() == nil
+                  and b:IsShown() == 1 and b:GetParent() == WorldFrame
+                  and b:GetFrameStrata() == WorldFrame:GetFrameStrata()
+                  and b:GetFrameLevel() == 2"#
+        )
+        .unwrap());
+}
+
+/// Eleven regions in creation order: the backdrop's background and eight border pieces
+/// (`0x4b0a35` → `0x77e8d0`), the tail (`0x4b0a57`), the text (`0x4b0b14`).
+#[test]
+fn the_eleven_regions_run_backdrop_then_tail_then_text() {
+    let mut s = vm();
+    drive(&mut s, &[say(7, 1, "Well met!")]);
+    let rows: Vec<String> = s
+        .eval::<Vec<String>>(
+            r#"local b = WorldFrame:GetChildren()
+               local out, regions = {}, { b:GetRegions() }
+               for i = 1, table.getn(regions) do
+                 local r = regions[i]
+                 local tex = r:GetObjectType() == "Texture" and (r:GetTexture() or "nil") or "-"
+                 table.insert(out, r:GetObjectType() .. " " .. r:GetDrawLayer() .. " " .. tex)
+               end
+               return out"#,
+        )
+        .unwrap();
+    let mut want =
+        vec!["Texture BACKGROUND Interface\\Tooltips\\ChatBubble-Background".to_string()];
+    want.extend(std::iter::repeat_n(
+        "Texture BORDER Interface\\Tooltips\\ChatBubble-Backdrop".to_string(),
+        8,
+    ));
+    want.push("Texture ARTWORK Interface\\Tooltips\\ChatBubble-Tail".to_string());
+    want.push("FontString ARTWORK -".to_string());
+    assert_eq!(rows, want);
+}
+
+/// `0x4b1600`: the line's text in its chat-type colour, wrapped at the cap and floored at two
+/// border units. The frame hugs the text by the margin (`0x4b0b6b`, `0x4b0b94`), the text's
+/// BOTTOM sits on the seat (`0x4b157a`), and the tail hangs TOPRIGHT from the frame's BOTTOM
+/// lifted a quarter border (`0x4b0af1`).
+#[test]
+fn the_text_is_the_line_in_its_colour_and_the_frame_hugs_it() {
+    let mut s = vm();
+    let mut yell = say(7, 1, "Well met!");
+    yell.colour = [1.0, 0.25, 0.25];
+    drive(&mut s, &[yell]);
+    let (text, r, g, b): (String, f32, f32, f32) = s
+        .eval(
+            r#"local regions = { (WorldFrame:GetChildren()):GetRegions() }
+               local fs = regions[11]
+               local r, g, b = fs:GetTextColor()
+               return fs:GetText(), r, g, b"#,
+        )
+        .unwrap();
+    assert_eq!(text, "Well met!");
+    assert_eq!((r, g, b), (1.0, 0.25, 0.25));
+
+    let rect = |s: &UiScript, what: &str| -> (f32, f32, f32, f32) {
+        s.eval(&format!(
+            "local b = WorldFrame:GetChildren() local regions = {{ b:GetRegions() }}
+             local o = {what}
+             return o:GetLeft(), o:GetBottom(), o:GetWidth(), o:GetHeight()"
+        ))
+        .unwrap()
+    };
+    // Nine characters, 54 wide: over the two-border floor and under the cap.
+    let fs = rect(&s, "regions[11]");
+    assert_eq!(
+        fs,
+        (473.0, 300.0, 54.0, LINE_H),
+        "the text's BOTTOM on the seat"
+    );
+    let frame = rect(&s, "b");
+    assert_eq!(
+        frame,
+        (460.0, 287.0, 54.0 + 2.0 * MARGIN, LINE_H + 2.0 * MARGIN),
+        "the margin on all four sides"
+    );
+    let tail = rect(&s, "regions[10]");
+    assert_eq!(
+        tail,
+        (
+            500.0 - BORDER,
+            287.0 + BORDER / 4.0 - BORDER,
+            BORDER,
+            BORDER
+        ),
+        "TOPRIGHT on the frame's BOTTOM, a quarter border up"
+    );
+
+    // Short text takes the floor, long text the cap and a second line.
+    drive(&mut s, &[say(7, 2, "hi")]);
+    assert_eq!(rect(&s, "regions[11]").2, 2.0 * BORDER);
+    let long = "x".repeat(50);
+    drive(&mut s, &[say(7, 3, &long)]);
+    let fs = rect(&s, "regions[11]");
+    assert_eq!((fs.2, fs.3), (256.0, 2.0 * LINE_H));
+
+    // The frame's left edge lands on the device grid, wherever the seat falls.
+    let mut off = say(7, 4, "Well met!");
+    off.seat = (500.3, 300.3);
+    s.sync_chat_bubbles(
+        BubbleGeometry {
+            device_px: 2.0,
+            ..geometry()
+        },
+        &[off],
+    );
+    s.resolve();
+    let frame = rect(&s, "b");
+    assert_eq!(
+        ((frame.0 * 2.0).fract(), (frame.1 * 2.0).fract()),
+        (0.0, 0.0)
+    );
+}
+
+/// pfUI's skin: blank every Texture, keep the text, cover the bubble with its own frame. Nothing
+/// of the stock art draws afterwards, and the blanking survives the bubble's reuse.
+#[test]
+fn a_pfui_skin_leaves_none_of_the_stock_art_drawn() {
+    let mut s = vm();
+    drive(&mut s, &[say(7, 1, "Well met!")]);
+    let stock = |s: &UiScript| -> Vec<String> {
+        s.extract()
+            .iter()
+            .filter_map(|q| match &q.content {
+                QuadContent::Texture { path: Some(p), .. } if p.contains("ChatBubble") => {
+                    Some(p.clone())
+                }
+                _ => None,
+            })
+            .collect()
+    };
+    assert_eq!(
+        stock(&s).len(),
+        10,
+        "the stock bubble draws its ten textures"
+    );
+
+    s.run(
+        r#"
+        function PfSkin()
+          local kids = { WorldFrame:GetChildren() }
+          for i = 1, table.getn(kids) do
+            local f = kids[i]
+            local first = not f:GetName() and f:GetRegions()
+            if first and first.GetTexture
+               and first:GetTexture() == "Interface\\Tooltips\\ChatBubble-Background"
+               and not f.pfSkin then
+              local regions = { f:GetRegions() }
+              for j = 1, table.getn(regions) do
+                local r = regions[j]
+                if r:GetObjectType() == "Texture" then r:SetTexture(nil)
+                elseif r:GetObjectType() == "FontString" then f.pfText = r end
+              end
+              f.pfSkin = CreateFrame("Frame", nil, f)
+              f.pfSkin:SetAllPoints(f)
+              PfRead = f.pfText:GetText()
+              PfR, PfG, PfB = f.pfText:GetTextColor()
+              f:SetScript("OnShow", function() PfShows = (PfShows or 0) + 1 end)
+            end
+          end
+        end
+        PfSkin()
+    "#,
+    )
+    .unwrap();
+    s.resolve();
+    assert_eq!(s.eval::<String>("return PfRead").unwrap(), "Well met!");
+    assert!(stock(&s).is_empty(), "every stock texture blanked");
+    assert!(
+        s.extract().iter().any(|q| matches!(
+            &q.content,
+            QuadContent::Text { text: Some(t), .. } if t == "Well met!"
+        )),
+        "the text still draws"
+    );
+    assert!(s
+        .eval::<bool>(
+            r#"local b = WorldFrame:GetChildren()
+               return b.pfSkin:GetLeft() == b:GetLeft() and b.pfSkin:GetTop() == b:GetTop()
+                  and b.pfSkin:GetWidth() == b:GetWidth() and b.pfSkin:GetHeight() == b:GetHeight()"#
+        )
+        .unwrap());
+
+    // The line ends and a new one reuses the skinned bubble: OnShow fires, the art stays blank.
+    drive(&mut s, &[]);
+    drive(&mut s, &[say(9, 2, "Hail.")]);
+    assert_eq!(s.eval::<i64>("return PfShows").unwrap(), 1);
+    assert!(
+        stock(&s).is_empty(),
+        "a reused bubble keeps the skin's blanking"
+    );
+}
+
+/// The pool (`0x4b1870`): a finished bubble is hidden (`0x4b1590`), keeps its place in the child
+/// list and its parent, and the next line takes the oldest retired one back, firing `OnShow`
+/// (`0x4b0ea0`'s `Show`).
+#[test]
+fn a_bubble_is_reused_never_reparented_and_hidden_when_done() {
+    let mut s = vm();
+    drive(&mut s, &[say(1, 1, "one"), say(2, 1, "two")]);
+    s.run(
+        r#"Shows, Hides = {}, {}
+           local a, b = WorldFrame:GetChildren()
+           a.mark, b.mark = "A", "B"
+           for _, f in ipairs({ a, b }) do
+             local f = f
+             f:SetScript("OnShow", function() table.insert(Shows, f.mark) end)
+             f:SetScript("OnHide", function() table.insert(Hides, f.mark) end)
+           end"#,
+    )
+    .unwrap();
+
+    // The first line ends, then the second: each frame hides, keeps its parent and its slot.
+    drive(&mut s, &[say(2, 1, "two")]);
+    drive(&mut s, &[]);
+    assert!(s
+        .eval::<bool>(
+            r#"local a, b = WorldFrame:GetChildren()
+               return WorldFrame:GetNumChildren() == 2 and a.mark == "A" and b.mark == "B"
+                  and not a:IsShown() and not b:IsShown()
+                  and a:GetParent() == WorldFrame and b:GetParent() == WorldFrame
+                  and Hides[1] == "A" and Hides[2] == "B""#
+        )
+        .unwrap());
+
+    // A new line takes the bubble retired first, and its OnShow fires.
+    drive(&mut s, &[say(3, 1, "three")]);
+    assert!(s
+        .eval::<bool>(
+            r#"local a, b = WorldFrame:GetChildren()
+               local regions = { a:GetRegions() }
+               return a:IsShown() == 1 and not b:IsShown() and Shows[1] == "A"
+                  and regions[11]:GetText() == "three""#
+        )
+        .unwrap());
+    assert_eq!(
+        s.chat_bubble_pool_len(),
+        2,
+        "no frame was made for the reuse"
+    );
+
+    // A new line from the same speaker replaces the bubble: its frame goes to the free list's
+    // tail and the line takes the head, here the frame retired before it (`0x608bb4`, `0x608bbf`).
+    drive(&mut s, &[say(3, 2, "again")]);
+    assert!(s
+        .eval::<bool>(
+            r#"local a, b = WorldFrame:GetChildren()
+               return Hides[3] == "A" and Shows[2] == "B" and not a:IsShown()"#
+        )
+        .unwrap());
+
+    // Out of range the fade ends hidden; back in range it shows again (`0x4b0d9f`, `0x4b0ea0`).
+    let mut away = say(3, 2, "again");
+    away.shown = false;
+    drive(&mut s, &[away]);
+    assert!(s
+        .eval::<bool>(
+            r#"local _, b = WorldFrame:GetChildren() return not b:IsShown() and Hides[4] == "B""#
+        )
+        .unwrap());
+    drive(&mut s, &[say(3, 2, "again")]);
+    assert!(s
+        .eval::<bool>(
+            r#"local _, b = WorldFrame:GetChildren() return b:IsShown() == 1 and Shows[3] == "B""#
+        )
+        .unwrap());
+    assert_eq!(s.chat_bubble_pool_len(), 2);
+}
+
+/// The per-frame pass (`0x4b12d5`-`0x4b1312`): levels 2, 3, … down the list, farthest first,
+/// without carrying children (`0x76a4f0(level, 0)`); the fade is the frame's own alpha.
+#[test]
+fn bubbles_take_levels_from_two_in_list_order_and_their_fade_alpha() {
+    let mut s = vm();
+    let mut near = say(1, 1, "near");
+    near.alpha = 0.5;
+    drive(&mut s, &[say(2, 1, "far"), near.clone()]);
+    let levels = |s: &UiScript| -> (i64, i64) {
+        s.eval(
+            r#"local far, near = WorldFrame:GetChildren()
+               return far:GetFrameLevel(), near:GetFrameLevel()"#,
+        )
+        .unwrap()
+    };
+    assert_eq!(levels(&s), (2, 3));
+    assert_eq!(
+        s.eval::<f32>("local _, near = WorldFrame:GetChildren() return near:GetAlpha()")
+            .unwrap(),
+        0.5
+    );
+    drive(&mut s, &[near, say(2, 1, "far")]);
+    assert_eq!(
+        levels(&s),
+        (3, 2),
+        "the order is the app's, re-stamped every frame"
+    );
+}
+
+/// The text slides with the seat on the device grid, so it skips the UI grid snap, as a plate's.
+#[test]
+fn the_bubble_text_carries_the_world_seat() {
+    let mut s = vm();
+    drive(&mut s, &[say(7, 1, "Well met!")]);
+    assert!(s.extract().iter().any(|q| matches!(
+        &q.content,
+        QuadContent::Text { text: Some(t), world_seat: true, .. } if t == "Well met!"
+    )));
+}
+
+/// A window resize re-sizes a live bubble in place: the backdrop's unit, the tail, the margin and
+/// the width floor follow, and its eleven regions stay the same objects.
+#[test]
+fn a_resize_re_sizes_the_live_bubble_in_place() {
+    let mut s = vm();
+    drive(&mut s, &[say(7, 1, "hi")]);
+    s.run(r#"local r = { (WorldFrame:GetChildren()):GetRegions() } First, Tail = r[1], r[10]"#)
+        .unwrap();
+    let wider = BubbleGeometry {
+        border: 20.0,
+        margin: 15.0,
+        ..geometry()
+    };
+    s.sync_chat_bubbles(wider, &[say(7, 1, "hi")]);
+    s.resolve();
+    let (same, frame_w, tail_w, edge_w): (bool, f32, f32, f32) = s
+        .eval(
+            r#"local b = WorldFrame:GetChildren() local r = { b:GetRegions() }
+               return r[1] == First and r[10] == Tail, b:GetWidth(), r[10]:GetWidth(),
+                      r[6]:GetWidth()"#,
+        )
+        .unwrap();
+    assert!(same, "the regions are kept, not rebuilt");
+    assert_eq!(frame_w, 2.0 * 20.0 + 2.0 * 15.0, "the new floor and margin");
+    assert_eq!(tail_w, 20.0);
+    assert_eq!(edge_w, 20.0, "the corner piece takes the new edge size");
+}
+
+/// Lines that end together go back to the pool in the active list's order, farthest first, as
+/// the reference's walk destroys them (`0x4b1138`); the next line takes the first of them.
+#[test]
+fn ended_lines_retire_farthest_first() {
+    let mut s = vm();
+    // Pooled A then B, but B is the farther, so first in the list.
+    drive(&mut s, &[say(1, 1, "a")]);
+    drive(&mut s, &[say(2, 1, "b"), say(1, 1, "a")]);
+    s.run(r#"local a, b = WorldFrame:GetChildren() a.mark, b.mark = "A", "B""#)
+        .unwrap();
+    drive(&mut s, &[]);
+    drive(&mut s, &[say(3, 1, "c")]);
+    assert_eq!(
+        s.eval::<String>(
+            r#"local a, b = WorldFrame:GetChildren()
+               if a:IsShown() then return a.mark end return b.mark"#
+        )
+        .unwrap(),
+        "B",
+        "the farther bubble retired first, so it is reused first"
+    );
+}
+
+/// The text's font is the `NAMEPLATE_FONT` global's, read when the bubble is built (`0x4b0b36` →
+/// `0x703bf0`); no global, no font.
+#[test]
+fn the_text_takes_the_nameplate_font_global() {
+    let mut s = vm();
+    s.run(r#"NAMEPLATE_FONT = "Fonts\\ARIALN.TTF""#).unwrap();
+    drive(&mut s, &[say(1, 1, "a")]);
+    assert_eq!(
+        s.eval::<String>(
+            "local r = { (WorldFrame:GetChildren()):GetRegions() } return (r[11]:GetFont())"
+        )
+        .unwrap(),
+        "Fonts\\ARIALN.TTF"
+    );
+
+    let mut bare = vm();
+    drive(&mut bare, &[say(1, 1, "a")]);
+    assert!(bare
+        .eval::<bool>(
+            "local r = { (WorldFrame:GetChildren()):GetRegions() } return r[11]:GetFont() == nil"
+        )
+        .unwrap());
+}
diff --git a/crates/benilla-ui/src/script/tests/mod.rs b/crates/benilla-ui/src/script/tests/mod.rs
index dab3dee1..8f348cce 100644
--- a/crates/benilla-ui/src/script/tests/mod.rs
+++ b/crates/benilla-ui/src/script/tests/mod.rs
@@ -9,6 +9,7 @@ mod backdrop;
 mod button;
 mod capture;
 mod channel;
+mod chat_bubble;
 mod common;
 mod cooldown;
 mod create_frame_template;
diff --git a/docs/MAP.md b/docs/MAP.md
index 92d23cfd..8238fdec 100644
--- a/docs/MAP.md
+++ b/docs/MAP.md
@@ -171,7 +171,6 @@
 - `WOW_BLOB_VIS_UID` — benilla-world/src/terrain_stream/merge.rs
 - `WOW_BOOTH_DUMP` — benilla-app/src/portrait/test_bake.rs
 - `WOW_BOOTH_LOG` — benilla-app/src/portrait/mod.rs
-- `WOW_BUBBLE_TRACE` — benilla-app/src/chat_bubble.rs
 - `WOW_CAM_CHANGED` — benilla-app/src/perf/mod.rs
 - `WOW_CAM_DUMP` — benilla-app/src/player/camera.rs
 - `WOW_CAPTURE` — benilla-app/src/capture/mod.rs, benilla-app/src/capture/scenarios.rs, benilla-app/src/char_select/addons.rs, benilla-app/src/cvars/mod.rs, benilla-app/src/lib.rs, benilla-app/src/local_state.rs, benilla-app/src/login/mod.rs, benilla-app/src/name_persist.rs, benilla-app/src/net.rs, benilla-app/src/player/camera_saved.rs, benilla-app/src/run_mode.rs, benilla-app/src/sound/mod.rs, benilla-app/src/ui_chat/settings.rs, benilla-app/src/ui_chat/tests.rs, benilla-app/src/ui_macro/tests.rs, benilla-app/src/ui_saved.rs, benilla-app/src/ui_script/addons.rs, benilla-app/src/ui_script/layer_tests.rs, benilla-app/src/ui_script/mod.rs, benilla-app/src/ui_script/world_entry_tests.rs, benilla-app/src/video.rs, benilla-world/src/bgwin.rs, benilla-world/src/clouds/mod.rs, benilla-world/src/dev_state.rs