From eec1804d37cd6a689ff11cc2e4b52c1901cc756f Mon Sep 17 00:00:00 2001
From: Sam Sung <51686767+samwhosung@users.noreply.github.com>
Date: Mon, 12 Oct 2026 02:06:36 +0700
Subject: [PATCH] Chat bubbles are WorldFrame child frames, as in 1.12.1 (#925)

Chat bubbles were quads drawn straight into an overlay with no widget behind them, so `WorldFrame:GetChildren()` never returned them and bubble-skinning addons such as pfUI's found nothing.

In the reference, a bubble is an anonymous Frame under WorldFrame from a reused pool: eleven regions (the nine backdrop pieces, the tail, the text in the `NAMEPLATE_FONT` global), the text's bottom on the speaker's projected point, its own fade, and an OnShow on each reuse. It fades out and hides when the speaker is out of range or was not drawn last frame.

Bubbles are now built that way, fed by the app and drawn by the frame pass; the overlay path is gone. Item links show their bare names, and a speaker behind the camera fades out.

Tests cover the child, its regions, a pfUI-style skin, reuse and the fades.

Fixes #884

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/benilla-app/src/chat_bubble.rs         | 1111 +++++++++--------
 crates/benilla-app/src/ui_chat.rs             |    2 +
 crates/benilla-app/src/ui_chat/bubbles.rs     |   19 +
 crates/benilla-app/src/ui_pass.rs             |    9 -
 .../benilla-app/src/ui_script/extract/mod.rs  |    5 +-
 .../benilla-assets/src/world_assets/images.rs |    2 +-
 crates/benilla-assets/src/world_assets/mod.rs |    9 -
 crates/benilla-ui/src/script/backdrop.rs      |  157 +--
 crates/benilla-ui/src/script/chat_bubble.rs   |  463 +++++++
 crates/benilla-ui/src/script/measure.rs       |    7 +-
 crates/benilla-ui/src/script/mod.rs           |    4 +-
 crates/benilla-ui/src/script/model.rs         |    3 +
 crates/benilla-ui/src/script/nameplate.rs     |    8 +-
 .../benilla-ui/src/script/tests/backdrop.rs   |    1 +
 .../src/script/tests/chat_bubble.rs           |  472 +++++++
 crates/benilla-ui/src/script/tests/mod.rs     |    1 +
 docs/MAP.md                                   |    1 -
 17 files changed, 1600 insertions(+), 674 deletions(-)
 create mode 100644 crates/benilla-app/src/ui_chat/bubbles.rs
 create mode 100644 crates/benilla-ui/src/script/chat_bubble.rs
 create mode 100644 crates/benilla-ui/src/script/tests/chat_bubble.rs

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