diff --git a/crates/benilla-app/src/chat_bubble.rs b/crates/benilla-app/src/chat_bubble.rs
index 1ccbf48a..9307bbfd 100644
--- a/crates/benilla-app/src/chat_bubble.rs
+++ b/crates/benilla-app/src/chat_bubble.rs
@@ -25,17 +25,13 @@ 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::{BubbleState, Outline, UiScript};
 
 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::ui_text::{measure_text, FontSpec, UiFontAtlas};
 use crate::vplates::{device_snap, gx_px, plate_basis, text_px, VPlateSet, VPlates};
-use benilla_assets::{AssetSet, WorldAssets};
 use benilla_world::view::WorldCamera;
 
 /// The two bubble CVars (registrar `0x603280`), booting at the reference's defaults.
@@ -90,10 +86,9 @@ 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 bubble art (`0x4b0940`) moved with the drawing: it now lives on the widgets
+// (`benilla_ui::script::chat_bubble`), where the UI pass resolves and tiles it like any other
+// frame's, half-texel bleed inset included.
 
 /// The 0.7 yd lift over the anchor height (`[0x7ffd7c]`).
 const LIFT: f32 = 0.7;
@@ -110,20 +105,6 @@ 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;
@@ -213,14 +194,6 @@ fn sanitize(text: &str) -> String {
     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 {
@@ -292,43 +265,6 @@ struct Bubbles(HashMap<u64, Bubble>);
 #[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.
 #[allow(clippy::type_complexity)] // one Bevy system's full input set
@@ -342,8 +278,6 @@ fn drive_bubbles(
     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.
@@ -351,6 +285,12 @@ fn drive_bubbles(
     // SuperWoW's `ChatBubbleRange` (`docs/ADDON_COMPAT.md`): `range_sq` replaces `MAX_DIST_SQ` at
     // both range gates below.
     cfg: Res<BubbleConfig>,
+    // The widgets (`benilla_ui::script::chat_bubble`): this system decides what is on screen and
+    // hands the result over, exactly as `vplates.rs` does for the plates.
+    script: Option<NonSendMut<UiScript>>,
+    // The seam, to divide out: everything below is window px and the widget layer takes FrameXML
+    // units. The same conversion the plate geometry makes.
+    ui_scale: Res<crate::ui_script::UiScaleCvar>,
 ) {
     active.0.clear();
     let now = time.elapsed_secs();
@@ -413,13 +353,11 @@ fn drive_bubbles(
             },
         );
     }
-    if bubbles.0.is_empty() {
-        return;
-    }
+    // No early return on an empty set: the widget layer still has to hear it, or last frame's
+    // bubbles stay on screen. Everything below runs over an empty map for nothing.
 
-    // ── Tick + draw ─────────────────────────────────────────────────────────────────────────
+    // ── Tick + hand over ─────────────────────────────────────────────────────────────────────────
     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();
@@ -451,8 +389,8 @@ fn drive_bubbles(
         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 {
+        // No camera or atlas: lifetimes tick, nothing is laid out.
+        let (Some((cam, cam_pose)), true) = (cam, atlas.is_some()) else {
             continue;
         };
         // The anchor (`0x4b0c30`), from this frame's `Transform` and constants only. A seat behind
@@ -487,29 +425,22 @@ fn drive_bubbles(
     // 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
-    };
-    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),
-        );
+    // The widget layer hears about every frame, bubbles or none: an empty feed is what retires
+    // the last of them. A VM-less harness still ticks the lifetimes above.
+    let Some(mut script) = script else { return };
+    let mut states: Vec<BubbleState> = Vec::with_capacity(pending.len());
+    if let (Some((_, cam_pose)), Some(atlas)) = (cam, atlas.as_deref_mut()) {
+        let seam = window.single().map_or(1.0, |w| {
+            crate::ui_script::seam_scale(w.height(), ui_scale.0)
+        });
+        for p in &pending {
+            let Some(b) = bubbles.0.get(&p.guid) else {
+                continue; // despawned between the tick and the hand-over
+            };
+            states.push(bubble_state(atlas, b, p, scale, seam, trace, cam_pose));
+        }
     }
+    script.sync_chat_bubbles(&states);
 }
 
 /// Farthest camera distance first, so the index is the frame level. Ties break on guid, as the
@@ -535,33 +466,27 @@ struct Pending {
     unit_pos: Vec3,
 }
 
-/// Append one bubble's draw list: the backdrop pieces, the tail and the wrapped, centered text.
-fn draw_bubble(
+/// One bubble's widget state: the text measurement that decides its size, the seat it hangs from,
+/// and the border unit — in FrameXML units, which is what `benilla_ui::script::chat_bubble` takes.
+///
+/// Every number here was computed for the quad lane before the widgets existed, in the same order
+/// and from the same law; what changed is where it lands. The measurement stays here because the
+/// *frame* has to be sized to the text, and the widget layer has no measurer of its own.
+fn bubble_state(
     atlas: &mut UiFontAtlas,
-    quads: &mut UiQuads,
-    art: &BubbleArt,
     b: &Bubble,
-    seat: Vec2,
-    viewport: Vec2,
+    p: &Pending,
     scale: f32,
+    seam: 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);
+) -> BubbleState {
+    let basis = plate_basis(p.viewport);
+    let border = border_px(p.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
@@ -575,94 +500,21 @@ fn draw_bubble(
     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);
+    drop(e);
     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 seat is snapped in window px, before the seam divides out, so the border art still blits
+    // 1:1 — the deviation [`seat_origin`] documents, kept now that the layout resolves the rect.
+    let origin = seat_origin(p.seat, w, scale);
 
-    // 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) {
-        // 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
+            "bubble-trace: viewport={:?} seat=({:.1},{:.1}) size=({w:.1}x{h:.1}) \
+             border={border:.1} alpha={:.2} text={:?}",
+            p.viewport, origin.x, origin.y, b.alpha, b.text
         );
     }
     // The jitter decomposition (`WOW_MOVE_TRACE` tag `bub`): `anchor=` and `pos=` differ by a
@@ -675,30 +527,47 @@ fn draw_bubble(
             &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,
+                 seat=({:.2},{:.2}) scale={scale:.2}",
+                p.entity.index(),
+                p.viewport.x,
+                p.viewport.y,
+                p.anchor.x,
+                p.anchor.y,
+                p.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,
+                p.unit_pos.x,
+                p.unit_pos.y,
+                p.unit_pos.z,
+                p.seat.x,
+                p.seat.y,
+                origin.x,
+                origin.y,
             ),
         );
     }
-    quads.overlays.append(&mut text_quads);
+
+    BubbleState {
+        key: p.guid,
+        // The bubble's own bottom centre, y flipped into FrameXML's bottom-up space: the same
+        // conversion `vplates.rs` makes for a plate's top centre.
+        seat: (
+            (origin.x + w * 0.5) / seam,
+            (p.viewport.y - origin.y) / seam,
+        ),
+        width: w / seam,
+        height: h / seam,
+        text: b.text.clone(),
+        color: b.color,
+        alpha: b.alpha,
+        border: border / seam,
+        font_height: px / seam,
+        wrap_width: box_w / seam,
+    }
 }
 
 /// The bubble stage; [`crate::nameplates`] orders after it to read [`BubblesActive`].
@@ -734,13 +603,16 @@ 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.
+            // After the V-plate drive, whose verdict the spawn gate reads, and **before the
+            // paint**: this system now writes widgets instead of quads, and
+            // `ui_script::extract::paint_script` has to see this frame's bubbles to draw them this
+            // frame. It used to sit inside `UiQuadAppend`, which is the window *after* the paint —
+            // right for an appender, a frame late for a feed.
             .add_systems(
                 Update,
                 drive_bubbles
                     .after(VPlateSet)
-                    .in_set(UiQuadAppend)
+                    .before(crate::ui_script::UiPaint)
                     .in_set(BubbleSet),
             );
     }
@@ -941,28 +813,11 @@ mod tests {
         );
     }
 
-    /// 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");
-        }
-    }
+    // The two z-band tests that used to live here are gone with the band: a bubble's paint order
+    // inside itself is now the widget layer's (the backdrop under the regions, the text in the
+    // Overlay layer over the tail in Artwork), and its order against the other bubbles and the
+    // V-plates is frame levels — `benilla_ui::script::chat_bubble` owns both, and the sort test
+    // below still pins the rank this file hands over.
 
     /// Farthest camera distance first, guid breaking an exact tie.
     #[test]
@@ -983,8 +838,8 @@ mod tests {
             vec![2, 3, 7, 9],
             "farthest first; the 400-yd² pair ordered by guid"
         );
-        // The rank the draw uses is the frame level: the nearest speaker draws last.
-        assert!(level_z(0) < level_z(p.len() - 1));
+        // The index in this order IS the frame level the widget layer stamps (`2 + rank`), so the
+        // nearest speaker's bubble draws over the rest.
     }
 
     /// 16 px at 1024-wide 4:3 (width/64), damped past the plate knee.
diff --git a/crates/benilla-app/src/game_plugins.rs b/crates/benilla-app/src/game_plugins.rs
index 7c01fc2e..9fc6bc6d 100644
--- a/crates/benilla-app/src/game_plugins.rs
+++ b/crates/benilla-app/src/game_plugins.rs
@@ -1372,6 +1372,8 @@ pub(crate) mod schedule_tests {
          "`seen_generation` is a `VmMemo`: a new VM reads `None`, rebuilds and re-fires UPDATE_BINDINGS"),
         ("capture/probe_bg.rs", "bg_probe", Because::SelfHealing,
          "the battleground probe: dev-only (`WOW_PROBE_BG`, `cfg(feature = \"dev\")`) so it is not in a player build at all, and its `mem::take` is of its OWN pending-events string, not a queue anything else fills. Its one real VM dependency is the Lua event tap, which self-heals: `EVENT_DRAIN` returns a `<tap-gone>` sentinel when the tap's globals are missing — the case this window causes, since a tap installed in the boot VM is discarded when `mint_entry_vm` builds the interface — and the probe re-installs on the next frame"),
+        ("chat_bubble.rs", "drive_bubbles", Because::SelfHealing,
+         "the one-shot is the bubble spawn QUEUE, and its product is app-side state (`Bubbles`), not a VM publish: a line that arrives before the interface exists still becomes a live bubble with its own lifetime, and the widget sync is idempotent per frame — it returns having done nothing while there is no `WorldFrame` and binds the same bubble on the first frame there is one, firing `CREATE_CHATBUBBLE` then. Gating the system instead would be worse: the queue would pile up and every held line would spawn at once, each with a fresh lifetime, when the UI came up"),
         ("death/mod.rs", "feed_death", Because::MemoLatched,
          "`feed.vm: VmMemo<DeathAnnounced>`: a fresh memo makes the first snapshot an edge and re-announces a held offer, confirm and corpse range"),
         ("screenshot.rs", "ask_for_captures", Because::FilledByVm,
diff --git a/crates/benilla-app/src/ui_pass.rs b/crates/benilla-app/src/ui_pass.rs
index 557c033e..f4fd9e9d 100644
--- a/crates/benilla-app/src/ui_pass.rs
+++ b/crates/benilla-app/src/ui_pass.rs
@@ -161,16 +161,15 @@ pub(crate) struct UiQuads {
 /// region sets `1 << 20`), so the whole lane paints under the player UI.
 pub(crate) mod overlay_z {
     /// Floating combat, XP and honor numbers, drawn by the client in the world scene under all UI.
+    ///
+    /// **The lane's only remaining tenant.** The chat bubbles used to hold a band above this one
+    /// (and the V-plates a band above that, as a ceiling for it): all three are widgets now —
+    /// plates in `vplates.rs`, bubbles in `chat_bubble.rs` — so their order comes from frame
+    /// strata and levels, where the reference's does. A band for one tenant is just 0, and the
+    /// bubbles' own ordering against the plates improved by the move: as frames they take levels
+    /// 2, 3, 4… over the plates' 1, which is the reference's own order, where the band layout had
+    /// them underneath.
     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/reference_ui.rs b/crates/benilla-app/src/ui_script/reference_ui.rs
index b26b56f6..81cc126c 100644
--- a/crates/benilla-app/src/ui_script/reference_ui.rs
+++ b/crates/benilla-app/src/ui_script/reference_ui.rs
@@ -2634,6 +2634,14 @@ mod tests {
                 "SuperWoW's own event, the one every cast-tracking addon on this realm registers; \
                  1.12 reports another unit's casts nowhere at all",
             ),
+            (
+                "CREATE_CHATBUBBLE",
+                "SuperWoW: a chat bubble appeared, `arg1` its frame — the third and last of its \
+                 events, and the one that could not honestly be fired until the bubbles were \
+                 widgets (`benilla-ui`'s `script/chat_bubble.rs`) rather than overlay quads. 1.12 \
+                 publishes no bubble edge at all: pfUI's own workaround is to re-scan the whole \
+                 bubble list the frame after every say, yell and monster line",
+            ),
             (
                 "RAW_COMBATLOG",
                 "SuperWoW: every combat-log line twice over — as the player reads it, and with \
diff --git a/crates/benilla-app/tests/ui_script_wall.rs b/crates/benilla-app/tests/ui_script_wall.rs
index 45eee7b8..110b8f59 100644
--- a/crates/benilla-app/tests/ui_script_wall.rs
+++ b/crates/benilla-app/tests/ui_script_wall.rs
@@ -54,7 +54,14 @@ fn family(rel: &str) -> Family {
 /// - `debug_panel/mod.rs` and `debug_panel/lighting_controls.rs` drive CVars through
 ///   `UiScript::set_cvar_engine`, the same queue Lua's `SetCVar` feeds, so the dev panel and the
 ///   interface cannot hold different values for one CVar.
-const CEILING: usize = 43;
+/// - `chat_bubble.rs` holds it because the chat bubbles **are widgets**, for the same reason
+///   `vplates.rs` — already in this census, and this file's exact twin — holds it for the
+///   V-plates: a bubble's *existence* is world state (the projection, the lifetime, the 20 yd
+///   re-test, the stacking sort) and its *presentation* is a frame pool, and one file knowing both
+///   is what keeps the two from disagreeing about a bubble. Moving it under `ui_` would satisfy
+///   the census and split a single-sourced feed in half; the alternative the wall offers — "feed a
+///   model value instead" — is precisely what it does, [`benilla_ui::script::BubbleState`].
+const CEILING: usize = 44;
 
 /// How far under [`CEILING`] the count may sit before the test asks for the ceiling to follow it.
 const SLACK: usize = 4;
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..185574fd
--- /dev/null
+++ b/crates/benilla-ui/src/script/chat_bubble.rs
@@ -0,0 +1,715 @@
+//! The chat bubbles as **widgets**: the reference's `CGChatBubbleFrame` (ctor `0x4b0940`), an
+//! anonymous `Frame` parented to the `WorldFrame` with a backdrop (`0x4b0a35` into `0x76a5d0`,
+//! which is `SetBackdrop`), one tail texture and one `FontString`.
+//!
+//! **Why this exists at all.** `benilla-app`'s `chat_bubble.rs` drew bubbles straight into the
+//! overlay quad lane: faithful on screen and invisible to Lua, which cost two addon-facing things
+//! at once. ClassicAPI's `C_ChatBubbles.GetAllChatBubbles` could only answer an empty list — pfUI
+//! walks that list, blanks each bubble's regions and draws its own backdrop and text over it
+//! (`modules/bubbles.lua:30-48`), so its whole bubble skin was dead — and SuperWoW's
+//! `CREATE_CHATBUBBLE` had no frame to carry, so it could not honestly be fired. One pool of real
+//! widgets closes both, and it is also what the reference has: its bubbles are `WorldFrame`
+//! children, which is how addons of the era found them before SuperWoW published the event.
+//!
+//! The app keeps everything a bubble's *existence* depends on — the spawn gate, the lifetime, the
+//! fade, the 20 yd re-test, the stacking sort and the text measurement that sizes the frame — and
+//! hands the result over as [`BubbleState`] per live bubble. This file owns the widgets alone, the
+//! same split [`super::nameplate`] already makes for the V-plates, and for the same reason: the
+//! engine decides what is on screen, the widget layer decides what Lua sees, and neither can
+//! disagree with the other about a bubble because there is one feed.
+//!
+//! **The pool is never shrunk or reordered**, as the plate pool is not: an addon that remembers
+//! "I have already skinned this frame" (pfUI's `if not f.frame then`) must keep being right about
+//! a frame it saw, and a compacted list would hand it a different bubble under the same identity.
+//!
+//! Two deviations worth naming, both in the direction of the reference:
+//! - The bubbles now sit at frame **levels 2, 3, 4…** over the V-plates at level 1, which is the
+//!   reference's own order (`0x4b12d5`-`0x4b1312`). The quad lane had them *under* the plates,
+//!   which was a deviation the band layout (`ui_pass::overlay_z`) carried in a comment.
+//! - The art is a **backdrop**, not regions, which is what `0x4b0a35` makes it. pfUI's skin
+//!   blanks whatever textures it finds in `GetRegions()` — it finds the tail, not the backdrop —
+//!   and then covers the plate with its own backdrop anchored 10 px outside the bubble on every
+//!   side, so the result reads as pfUI's bubble either way.
+
+use std::collections::HashMap;
+
+use crate::layout::{Anchor, Point};
+use crate::order::DrawLayer;
+use crate::script::backdrop::{Backdrop, Insets};
+use crate::widget::{FrameHandle, FrameKind, RegionHandle, RegionKind};
+
+use super::model::Model;
+use super::UiScript;
+use super::{JustifyH, JustifyV, ScriptValue};
+
+/// The bubble art (`0x4b0940`), the same three paths the quad lane drew.
+const BG_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Background";
+const EDGE_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Backdrop";
+const TAIL_TEXTURE: &str = "Interface\\Tooltips\\ChatBubble-Tail";
+/// `NAMEPLATE_FONT`: Friz Quadrata, the face the bubble text has always been shaped in.
+const BUBBLE_FONT: &str = "Fonts\\FRIZQT__.TTF";
+
+/// The first frame level a bubble takes (`0x4b12d5`: `2 + i` over the plates' 1).
+const FIRST_LEVEL: u16 = 2;
+
+/// One live bubble's whole per-frame state, in **FrameXML units** (the app divides the seam out,
+/// exactly as it does for a plate's geometry).
+///
+/// Everything here is decided by the app: this file writes it onto widgets and nothing more.
+#[derive(Clone, Debug, PartialEq)]
+pub struct BubbleState {
+    /// The speaker's GUID. A bubble stays bound to its speaker for its whole life, as the
+    /// reference's `[unit+0xe64]` does, so an addon can cache per bubble on it.
+    pub key: u64,
+    /// The bubble's **bottom centre**, from the `WorldFrame`'s BOTTOMLEFT: it hangs from the seat
+    /// and grows upward (`0x4b0c30`).
+    pub seat: (f32, f32),
+    /// The frame's size, the text layout plus the margin on each side.
+    pub width: f32,
+    pub height: f32,
+    /// The sanitized display text, as the window shows it.
+    pub text: String,
+    /// The chat-type colour, sRGB 0..1.
+    pub color: [f32; 3],
+    /// The fade (`0x4b0ea0`/`0x4b0ee0`), 0..1; the frame's own alpha, so an addon's child frames
+    /// fade with it.
+    pub alpha: f32,
+    /// The backdrop's edge size, which is also all four insets: the reference feeds one value to
+    /// both (`0x4b0a35`).
+    pub border: f32,
+    /// The `FontString`'s height, and the width it wraps at — the same numbers the app measured
+    /// the box with, so the region's own measure cannot disagree with the frame's size.
+    pub font_height: f32,
+    pub wrap_width: f32,
+}
+
+/// One pooled bubble's widgets.
+#[derive(Debug)]
+struct Bubble {
+    frame: FrameHandle,
+    /// The tail (`0x4b0af1`), a border-unit square hanging under the bubble's bottom centre.
+    tail: RegionHandle,
+    text: RegionHandle,
+    /// Last frame's state, so [`Bubble::drive`] writes only what moved; `None` while retired.
+    last: Option<BubbleState>,
+}
+
+impl Bubble {
+    fn key(&self) -> Option<u64> {
+        self.last.as_ref().map(|s| s.key)
+    }
+}
+
+/// The bubble pool, grown on demand and never shrunk or reordered (see the module header).
+#[derive(Debug, Default)]
+pub(crate) struct ChatBubbles {
+    bubbles: Vec<Bubble>,
+    /// Each live speaker's pool slot, the reference's `[unit+0xe64]`.
+    assigned: HashMap<u64, usize>,
+    /// Frame to pool slot, never removed: bubbles are recycled, never destroyed.
+    by_frame: HashMap<FrameHandle, usize>,
+}
+
+impl ChatBubbles {
+    /// Every live bubble's frame, in pool order: ClassicAPI's `C_ChatBubbles.GetAllChatBubbles`.
+    /// A retired slot has no state and is skipped, so the list is the bubbles actually on screen.
+    pub(crate) fn live(&self) -> Vec<FrameHandle> {
+        self.bubbles
+            .iter()
+            .filter_map(|b| b.key().map(|_| b.frame))
+            .collect()
+    }
+
+    /// Whether `frame` is one of the pool's, live or retired. For the text layout's world-seat
+    /// rule, which a bubble shares with a plate.
+    pub(crate) fn holds(&self, frame: FrameHandle) -> bool {
+        self.by_frame.contains_key(&frame)
+    }
+}
+
+/// What a sync owes once the model borrow is released: `OnShow`/`OnHide` for frames whose
+/// visibility flipped, and one `CREATE_CHATBUBBLE` per bubble that appeared. Queue-and-drain, for
+/// the reason every other queue here exists — a handler re-entering the VM must not run under a
+/// live [`Model`] borrow.
+#[derive(Default)]
+struct SyncEffects {
+    visibility: Vec<FrameHandle>,
+    /// `CREATE_CHATBUBBLE`, `arg1` the bubble's frame.
+    created: Vec<FrameHandle>,
+}
+
+impl UiScript {
+    /// Drive the pool from the app's per-frame feed, one entry per live bubble; a speaker with no
+    /// entry has its bubble retired (hidden, never destroyed).
+    ///
+    /// Retire before bind, so a bubble that just expired frees its slot for one appearing in the
+    /// same tick — the reference's one free list behaves that way, and the pool is the only thing
+    /// a bubble's identity rests on.
+    pub fn sync_chat_bubbles(&mut self, bubbles: &[BubbleState]) {
+        let effects = {
+            let lua = self.lua();
+            let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+            // No WorldFrame (no interface loaded) means no addon is walking an invented root, and
+            // the app's own draw is gone — so there is nothing to do and nothing to owe.
+            let Some(world) = model.arena.lookup("WorldFrame") else {
+                return;
+            };
+            sync(&mut model, world, bubbles)
+        };
+        self.fire_effects(effects);
+    }
+
+    /// Retire every live bubble: the app's early returns owe this, since a widget stays up until
+    /// something hides it. No `CREATE_CHATBUBBLE` has a removal twin — SuperWoW publishes none,
+    /// and an addon learns a bubble is gone the way it always has, from `IsShown()`.
+    pub fn retire_chat_bubbles(&mut self) {
+        let effects = {
+            let lua = self.lua();
+            let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+            let mut effects = SyncEffects::default();
+            model.chat_bubbles.assigned.clear();
+            for i in 0..model.chat_bubbles.bubbles.len() {
+                retire(&mut model, i, &mut effects);
+            }
+            effects
+        };
+        self.fire_effects(effects);
+    }
+
+    fn fire_effects(&mut self, effects: SyncEffects) {
+        let lua = self.lua();
+        super::event::fire_visibility_changes(lua, effects.visibility);
+        for frame in effects.created {
+            let id = lua
+                .app_data_mut::<Model>()
+                .expect("model app_data")
+                .frame_id(frame);
+            super::event::fire_global(lua, "CREATE_CHATBUBBLE", &[ScriptValue::Frame(id)]);
+        }
+    }
+}
+
+/// Bind, lay out and write the pool for this frame's feed.
+fn sync(model: &mut Model, world: FrameHandle, bubbles: &[BubbleState]) -> SyncEffects {
+    let mut effects = SyncEffects::default();
+
+    let gone: Vec<u64> = model
+        .chat_bubbles
+        .assigned
+        .keys()
+        .copied()
+        .filter(|k| !bubbles.iter().any(|b| b.key == *k))
+        .collect();
+    for key in gone {
+        if let Some(i) = model.chat_bubbles.assigned.remove(&key) {
+            retire(model, i, &mut effects);
+        }
+    }
+
+    for (rank, state) in bubbles.iter().enumerate() {
+        let slot = match model.chat_bubbles.assigned.get(&state.key) {
+            Some(&i) => i,
+            None => {
+                let free = (0..model.chat_bubbles.bubbles.len())
+                    .find(|i| model.chat_bubbles.bubbles[*i].last.is_none());
+                let i = free.unwrap_or_else(|| {
+                    let bubble = create(model, world);
+                    model.chat_bubbles.bubbles.push(bubble);
+                    model.chat_bubbles.bubbles.len() - 1
+                });
+                model.chat_bubbles.assigned.insert(state.key, i);
+                // Per **appearance**, not per pool slot ever built, which is the opposite of
+                // `NAME_PLATE_CREATED`'s rule and deliberate: what an addon wants from this event
+                // is "here is a bubble to skin or move, now", and a recycled frame has been
+                // re-anchored, re-sized and re-texted since it was last seen. pfUI's own guard
+                // (`if not f.frame then`) makes the repeat free for the skinning case.
+                effects.created.push(model.chat_bubbles.bubbles[i].frame);
+                i
+            }
+        };
+        // The stacking level: farthest-first rank, as the app sorted it (`0x4b1309`).
+        drive(model, slot, world, state, rank, &mut effects);
+    }
+    effects
+}
+
+/// Build one bubble: the Frame, its backdrop, the tail and the text.
+fn create(model: &mut Model, world: FrameHandle) -> Bubble {
+    // Anonymous and `WorldFrame`-parented, as the reference's is: bubble addons find it by walking
+    // the child list, so a name would be a surface the reference does not have.
+    let frame = model.arena.create(FrameKind::Frame, None, Some(world));
+    let strata = model
+        .arena
+        .frame(world)
+        .map(|f| f.strata)
+        .unwrap_or_default();
+    model.arena.set_frame_strata(frame, strata);
+
+    // The backdrop (`0x4b0a35` into `0x76a5d0`): one value feeds the edge size and all four
+    // insets. The sizes are written per frame in `drive`, since the border scales with the window.
+    model.backdrops.insert(
+        frame,
+        Backdrop {
+            bg_file: Some(BG_TEXTURE.to_string()),
+            edge_file: Some(EDGE_TEXTURE.to_string()),
+            tile: false,
+            tile_size: 0.0,
+            edge_size: 0.0,
+            insets: Insets::default(),
+            bg_color: [1.0; 4],
+            border_color: [1.0; 4],
+        },
+    );
+
+    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::Overlay, 0)
+        .expect("live bubble");
+    {
+        let data = model.region_data.entry(text).or_default();
+        data.font_path = Some(BUBBLE_FONT.to_string());
+        data.font_explicit.face = true;
+        data.justify.set_h(JustifyH::Center);
+        data.justify.set_v(JustifyV::Middle);
+    }
+
+    model
+        .chat_bubbles
+        .by_frame
+        .insert(frame, model.chat_bubbles.bubbles.len());
+
+    Bubble {
+        frame,
+        tail,
+        text,
+        last: None,
+    }
+}
+
+/// Hide a bubble and drop its state; the widgets stay, as the reference recycles rather than
+/// destroys.
+fn retire(model: &mut Model, i: usize, effects: &mut SyncEffects) {
+    let b = &mut model.chat_bubbles.bubbles[i];
+    if b.last.take().is_none() {
+        return;
+    }
+    let frame = b.frame;
+    effects
+        .visibility
+        .extend(model.arena.set_shown(frame, false));
+}
+
+/// Write one bubble's state, touching only what moved.
+fn drive(
+    model: &mut Model,
+    i: usize,
+    world: FrameHandle,
+    state: &BubbleState,
+    rank: usize,
+    effects: &mut SyncEffects,
+) {
+    let b = &model.chat_bubbles.bubbles[i];
+    let (frame, tail, text) = (b.frame, b.tail, b.text);
+    let last = b.last.clone();
+    let world_id = model.frame_id(world);
+    let frame_id = model.frame_id(frame);
+
+    // Re-seated whenever it moves. A fresh seat adds a graph edge, so it retargets; a moved offset
+    // keeps the edges, so the cheaper touch — the same split `nameplate::Plate::drive` makes.
+    if last.as_ref().is_none_or(|l| l.seat != state.seat) {
+        let fresh = model
+            .layout_inputs
+            .get(&frame)
+            .is_none_or(|i| i.anchors.is_empty());
+        let input = model.layout_inputs.entry(frame).or_default();
+        input.anchors = vec![Anchor::new(
+            Point::Bottom,
+            world_id,
+            Point::BottomLeft,
+            state.seat.0,
+            state.seat.1,
+        )];
+        if fresh {
+            model.touch_layout_retarget_frame(frame, &[], &[world_id]);
+        } else {
+            model.touch_layout_frame(frame);
+        }
+    }
+
+    if last
+        .as_ref()
+        .is_none_or(|l| l.width != state.width || l.height != state.height)
+    {
+        let input = model.layout_inputs.entry(frame).or_default();
+        input.width = state.width;
+        input.height = state.height;
+        model.touch_layout_frame(frame);
+    }
+
+    // The border scales with the window, so it rides the state rather than the creation.
+    if last.as_ref().is_none_or(|l| l.border != state.border) {
+        if let Some(bd) = model.backdrops.get_mut(&frame) {
+            bd.edge_size = state.border;
+            bd.insets = Insets {
+                left: state.border,
+                right: state.border,
+                top: state.border,
+                bottom: state.border,
+            };
+        }
+        // The tail (`0x4b0af1`): a border-unit square, its TOPRIGHT on the bubble's bottom centre
+        // lifted a quarter border, so it overlaps the frame's own bottom edge.
+        model.region_data.entry(tail).or_default().size = Some((state.border, state.border));
+        model.region_data.entry(tail).or_default().anchors = vec![Anchor::new(
+            Point::TopRight,
+            frame_id,
+            Point::Bottom,
+            0.0,
+            state.border * 0.25,
+        )];
+        model.touch_layout_region(tail);
+    }
+
+    if last
+        .as_ref()
+        .is_none_or(|l| l.font_height != state.font_height || l.wrap_width != state.wrap_width)
+    {
+        let data = model.region_data.entry(text).or_default();
+        data.font_height = Some(state.font_height);
+        data.font_explicit.height = true;
+        // A pinned width is what makes the FontString wrap (`MeasureRequest::wrap_width`), at the
+        // cap the app already measured the box against.
+        data.size = Some((state.wrap_width, 0.0));
+        data.anchors = vec![Anchor::new(
+            Point::Center,
+            frame_id,
+            Point::Center,
+            0.0,
+            0.0,
+        )];
+        model.touch_layout_region(text);
+    }
+
+    if last.as_ref().is_none_or(|l| l.text != state.text) {
+        model.region_data.entry(text).or_default().text = Some(state.text.clone());
+        model.touch_layout_region(text);
+    }
+    if last.as_ref().is_none_or(|l| l.color != state.color) {
+        model.region_data.entry(text).or_default().vertex_color =
+            Some([state.color[0], state.color[1], state.color[2], 1.0]);
+    }
+
+    if last.is_none() {
+        effects
+            .visibility
+            .extend(model.arena.set_shown(frame, true));
+    }
+    if last.as_ref().is_none_or(|l| l.alpha != state.alpha) {
+        model.arena.set_alpha(frame, state.alpha);
+    }
+
+    // Farthest first, levels stamped head to tail: the app hands them over in that order, so the
+    // rank IS the level. Over the V-plates' level 1, as the reference's are.
+    let level = FIRST_LEVEL.saturating_add(u16::try_from(rank).unwrap_or(u16::MAX - FIRST_LEVEL));
+    if last.is_none() || model.arena.frame(frame).is_some_and(|f| f.level != level) {
+        model.arena.set_frame_level(frame, level, true);
+    }
+
+    model.chat_bubbles.bubbles[i].last = Some(state.clone());
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::script::UiScript;
+
+    /// A bubble over a speaker, in the units the app hands over.
+    fn bubble(key: u64, text: &str) -> BubbleState {
+        BubbleState {
+            key,
+            seat: (400.0, 300.0),
+            width: 120.0,
+            height: 40.0,
+            text: text.to_string(),
+            color: [1.0, 1.0, 0.0],
+            alpha: 1.0,
+            border: 16.0,
+            font_height: 12.0,
+            wrap_width: 100.0,
+        }
+    }
+
+    /// The `WorldFrame` the pool hangs off, as `script/tests/nameplate.rs` builds it.
+    fn script() -> UiScript {
+        let mut s = UiScript::new().unwrap();
+        s.set_screen_size(1024.0, 768.0);
+        s.run(r#"WorldFrame = CreateFrame("WorldFrame", "WorldFrame") WorldFrame:SetAllPoints()"#)
+            .unwrap();
+        s.resolve();
+        s
+    }
+
+    /// **pfUI's own `ScanBubbles` loop, transcribed** (`modules/bubbles.lua:30-48`), which is the
+    /// whole reason this file exists: it walks `C_ChatBubbles.GetAllChatBubbles()`, blanks every
+    /// Texture it finds in the bubble's regions, keeps the `FontString` as `f.text`, and parents
+    /// its own frame to the bubble. Every one of those steps has to work on our widgets.
+    #[test]
+    fn pfuis_own_bubble_scan_finds_the_text_and_the_textures() {
+        let mut s = script();
+        s.sync_chat_bubbles(&[bubble(0x42, "Hail, traveller")]);
+        s.resolve();
+
+        assert_eq!(
+            s.eval::<i64>("return table.getn(C_ChatBubbles.GetAllChatBubbles())")
+                .unwrap(),
+            1,
+            "one live bubble, one frame — this answered an empty list before the pool existed"
+        );
+        s.run(
+            r#"
+            Found, Blanked, Parented = nil, 0, nil
+            for _, f in ipairs(C_ChatBubbles.GetAllChatBubbles()) do
+                local regions = {f:GetRegions()}
+                for _, object in pairs(regions) do
+                    if object:GetObjectType() == "Texture" then
+                        object:SetTexture('')
+                        Blanked = Blanked + 1
+                    elseif object:GetObjectType() == "FontString" then
+                        f.text = object
+                        PfBubbleText = object
+                    end
+                end
+                Found = f.text and f.text:GetText()
+                f.frame = CreateFrame("Frame", nil, f)
+                f.frame:SetAllPoints(f)
+                Parented = f.frame:GetParent() == f
+            end
+        "#,
+        )
+        .unwrap();
+        assert_eq!(
+            s.eval::<String>("return Found").unwrap(),
+            "Hail, traveller",
+            "the FontString carries the line, which is what pfUI re-fonts and re-colours"
+        );
+        assert_eq!(
+            s.eval::<i64>("return Blanked").unwrap(),
+            1,
+            "the tail is the one Texture region; the backdrop is a backdrop, as `0x4b0a35` makes \
+             it, and pfUI covers it with its own anchored 10 px outside the bubble"
+        );
+        assert!(
+            s.eval::<bool>("return Parented").unwrap(),
+            "an addon frame parents to the bubble, which is how it follows it and fades with it"
+        );
+        // The colour is the chat type's, and pfUI reads it off the string with `GetTextColor`
+        // before re-applying it to its own (`modules/bubbles.lua:22-24`).
+        assert_eq!(
+            s.eval::<(f64, f64, f64)>("local r, g, b = PfBubbleText:GetTextColor() return r, g, b")
+                .unwrap(),
+            (1.0, 1.0, 0.0),
+            "the chat-type colour, which is the thing pfUI carries over to its own string"
+        );
+        assert!(s.errors().is_empty(), "handler errors: {:?}", s.errors());
+    }
+
+    /// The whole chain, which is the claim that matters: a bubble handed over as state comes out
+    /// of the extract as **drawn quads** — the backdrop's own two art paths, the tail, and the
+    /// line in the chat type's colour at the em the app measured it with.
+    ///
+    /// Before the pool this art came off the overlay quad lane, so an extract carried none of it;
+    /// a test that only checked the widgets would pass with nothing on screen.
+    #[test]
+    fn a_bubble_reaches_the_extract_as_backdrop_tail_and_text() {
+        use crate::script::QuadContent;
+
+        let mut s = script();
+        s.sync_chat_bubbles(&[bubble(0x42, "Hail, traveller")]);
+        s.resolve();
+        let quads = s.extract();
+
+        let text = quads
+            .iter()
+            .find_map(|q| match &q.content {
+                QuadContent::Text {
+                    text: Some(t),
+                    color: Some(c),
+                    font_height,
+                    ..
+                } if t == "Hail, traveller" => Some((*c, *font_height)),
+                _ => None,
+            })
+            .expect("the bubble's line reaches the extract");
+        assert_eq!(
+            (text.0[0], text.0[1], text.0[2]),
+            (1.0, 1.0, 0.0),
+            "in the chat type's colour"
+        );
+        assert_eq!(
+            text.1,
+            Some(12.0),
+            "at the em the app measured the box with"
+        );
+
+        let backdrops: Vec<&str> = quads
+            .iter()
+            .filter_map(|q| match &q.content {
+                QuadContent::Backdrop { path, .. } => Some(path.as_str()),
+                _ => None,
+            })
+            .collect();
+        assert!(
+            backdrops.contains(&BG_TEXTURE) && backdrops.contains(&EDGE_TEXTURE),
+            "both halves of the reference's backdrop draw, got {backdrops:?}"
+        );
+        assert!(
+            quads.iter().any(|q| matches!(
+                &q.content,
+                QuadContent::Texture { path: Some(p), .. } if p == TAIL_TEXTURE
+            )),
+            "and the tail, which is a region rather than part of the backdrop"
+        );
+
+        // Nothing is left on screen once the speaker stops: the retire hides the frame, and a
+        // hidden frame emits no quads at all.
+        s.sync_chat_bubbles(&[]);
+        s.resolve();
+        assert!(
+            !s.extract().iter().any(|q| matches!(
+                &q.content,
+                QuadContent::Backdrop { path, .. } if path == BG_TEXTURE
+            )),
+            "a retired bubble draws nothing"
+        );
+    }
+
+    /// `CREATE_CHATBUBBLE` fires with the bubble's frame, per appearance — SuperWoW's third and
+    /// last event, which could not honestly be fired while there was no frame to carry.
+    #[test]
+    fn create_chatbubble_fires_with_the_frame_per_appearance() {
+        let mut s = script();
+        s.run(
+            r#"
+            N, Same = 0, nil
+            Spy = CreateFrame("Frame", "BenillaBubbleSpy")
+            Spy:SetScript("OnEvent", function()
+                N = N + 1
+                Same = arg1 == C_ChatBubbles.GetAllChatBubbles()[1]
+            end)
+            Spy:RegisterEvent("CREATE_CHATBUBBLE")
+        "#,
+        )
+        .unwrap();
+
+        s.sync_chat_bubbles(&[bubble(0x42, "one")]);
+        assert_eq!(s.eval::<i64>("return N").unwrap(), 1);
+        assert!(
+            s.eval::<bool>("return Same").unwrap(),
+            "arg1 is the frame, and the list already holds it when the handler runs"
+        );
+
+        // The same bubble, moved and re-texted: no second event, the frame is already theirs.
+        let mut moved = bubble(0x42, "one");
+        moved.seat = (401.0, 302.0);
+        s.sync_chat_bubbles(&[moved]);
+        assert_eq!(s.eval::<i64>("return N").unwrap(), 1);
+
+        // It expires, and a new speaker takes the recycled frame: that IS an appearance.
+        s.sync_chat_bubbles(&[]);
+        s.sync_chat_bubbles(&[bubble(0x99, "two")]);
+        assert_eq!(
+            s.eval::<i64>("return N").unwrap(),
+            2,
+            "per appearance, not per pool slot ever built: a recycled frame has been re-anchored \
+             and re-texted, so an addon has work to do on it again"
+        );
+        assert!(s.errors().is_empty(), "handler errors: {:?}", s.errors());
+    }
+
+    /// The pool recycles rather than destroys, keeps its order, and an expired bubble leaves the
+    /// list while its frame stays (hidden) for the next speaker.
+    #[test]
+    fn the_pool_recycles_and_keeps_its_order() {
+        let mut s = script();
+        s.sync_chat_bubbles(&[bubble(0x10, "a"), bubble(0x20, "b")]);
+        s.resolve();
+        let frames = |s: &UiScript| {
+            s.eval::<i64>("return table.getn(C_ChatBubbles.GetAllChatBubbles())")
+                .unwrap()
+        };
+        assert_eq!(frames(&s), 2);
+        // Both shown, at the levels the rank gives (2 and 3), over the V-plates' 1.
+        assert!(s
+            .eval::<bool>(
+                "local l = C_ChatBubbles.GetAllChatBubbles()
+                 return l[1]:IsShown() and l[2]:IsShown()
+                    and l[1]:GetFrameLevel() == 2 and l[2]:GetFrameLevel() == 3"
+            )
+            .unwrap());
+
+        // The first speaker stops talking: one bubble left, and the retired frame is hidden but
+        // still a `WorldFrame` child, as the reference recycles rather than destroys.
+        s.run("Kept = C_ChatBubbles.GetAllChatBubbles()[1]")
+            .unwrap();
+        s.sync_chat_bubbles(&[bubble(0x20, "b")]);
+        s.resolve();
+        assert_eq!(frames(&s), 1, "the retired slot leaves the list");
+        assert!(
+            !s.eval::<bool>("return Kept:IsShown()").unwrap(),
+            "and its frame is hidden rather than destroyed"
+        );
+        assert!(
+            s.eval::<bool>(r#"return Kept:GetParent() == WorldFrame"#)
+                .unwrap(),
+            "still a WorldFrame child: an addon that cached it keeps a live handle"
+        );
+        // A third speaker takes the free slot: the pool is two frames, not three.
+        s.sync_chat_bubbles(&[bubble(0x20, "b"), bubble(0x30, "c")]);
+        s.resolve();
+        assert_eq!(frames(&s), 2);
+        assert!(
+            s.eval::<bool>("return C_ChatBubbles.GetAllChatBubbles()[1] == Kept")
+                .unwrap(),
+            "the recycled frame is the one that was free, in its own pool position"
+        );
+        assert!(s.errors().is_empty(), "handler errors: {:?}", s.errors());
+    }
+
+    /// The widgets carry what the app measured: the frame's size, the fade as the frame's alpha
+    /// (so an addon's child frames fade with it) and the text's own wrap width.
+    #[test]
+    fn the_widgets_carry_the_apps_own_numbers() {
+        let mut s = script();
+        let mut b = bubble(0x42, "a longer line that wraps");
+        b.alpha = 0.5;
+        s.sync_chat_bubbles(&[b]);
+        s.resolve();
+        assert!(s
+            .eval::<bool>(
+                "local f = C_ChatBubbles.GetAllChatBubbles()[1]
+                 return f:GetWidth() == 120 and f:GetHeight() == 40 and f:GetAlpha() == 0.5"
+            )
+            .unwrap());
+        assert!(
+            s.eval::<bool>(
+                "local f = C_ChatBubbles.GetAllChatBubbles()[1]
+                 for _, r in pairs({f:GetRegions()}) do
+                     if r:GetObjectType() == \"FontString\" then
+                         return r:GetWidth() == 100
+                     end
+                 end
+                 return false"
+            )
+            .unwrap(),
+            "the FontString's pinned width is the wrap cap the app measured the box against — a \
+             pinned width is also what makes it wrap at all (`MeasureRequest::wrap_width`)"
+        );
+        assert!(s.errors().is_empty(), "handler errors: {:?}", s.errors());
+    }
+}
diff --git a/crates/benilla-ui/src/script/compat/classic_api/chat_bubbles.rs b/crates/benilla-ui/src/script/compat/classic_api/chat_bubbles.rs
index c66f7718..2ee9e99e 100644
--- a/crates/benilla-ui/src/script/compat/classic_api/chat_bubbles.rs
+++ b/crates/benilla-ui/src/script/compat/classic_api/chat_bubbles.rs
@@ -1,25 +1,21 @@
 //! ClassicAPI's `C_ChatBubbles`: the speech bubbles an addon wants to restyle.
 //!
-//! **Answers an empty list, and that is the truthful answer here, not a stub.** The function's
-//! contract is "hand me the bubble *frames*", so an addon can walk their regions and repaint
-//! them — pfUI's does exactly that, replacing each bubble's textures with its own backdrop and
-//! re-fonting the `FontString` it finds inside (`modules/bubbles.lua:30-48`). This client has no
-//! such frames to hand over: bubbles are drawn natively by `benilla-app`'s `chat_bubble.rs` as a
-//! 2-D world overlay, the same way the reference's own `CGChatBubbleFrame` is drawn — they are
-//! not Lua frames and have no regions a script can reach.
+//! **Answers the live bubbles.** The function's contract is "hand me the bubble *frames*", so an
+//! addon can walk their regions and repaint them — pfUI's does exactly that, blanking each
+//! bubble's textures and re-fonting the `FontString` it finds inside
+//! (`modules/bubbles.lua:30-48`). This file used to answer an empty list, truthfully, because the
+//! bubbles were drawn straight into the overlay quad lane and were not Lua frames at all; they
+//! are now a widget pool (`script/chat_bubble.rs`), which is also what the reference has.
 //!
-//! So the honest report is zero, and the consequence is that bubbles render in this client's own
-//! style rather than pfUI's. The alternative was leaving the namespace absent, which is strictly
-//! worse: `ipairs(nil)` raises, and the call sits in `ScanBubbles`, which pfUI runs the frame
-//! after **every** `CHAT_MSG_SAY`/`YELL`/`MONSTER_SAY`/`MONSTER_YELL` — so the absence raised on
-//! any NPC or player speaking within earshot, repeatedly, for a cosmetic feature.
-//!
-//! Making the native bubbles addressable from Lua is the real fix and is not built: it would mean
-//! giving each live bubble a frame with a texture and a `FontString`, kept in step with the
-//! native overlay's own spawn, stacking and expiry rules. `docs/ADDON_COMPAT.md` carries the row.
+//! Pool order, live bubbles only, a fresh table per call. The order is stable for a bubble's whole
+//! life, which is what an addon keying a cache on the frame needs; it is **not** the stacking
+//! order, which changes every frame with the camera (`chat_bubble::BubbleState`).
 
 use mlua::{Lua, Table};
 
+use crate::script::object::frame_wrapper;
+use crate::script::Model;
+
 pub(super) fn install(lua: &Lua) -> mlua::Result<Table> {
     let t = lua.create_table()?;
 
@@ -27,7 +23,21 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<Table> {
     // let a caller's own writes into it survive into the next caller's loop.
     t.set(
         "GetAllChatBubbles",
-        lua.create_function(|lua, ()| lua.create_table())?,
+        lua.create_function(|lua, ()| {
+            let live = {
+                let model = lua.app_data_ref::<Model>().expect("model app_data");
+                model.chat_bubbles.live()
+            };
+            let out = lua.create_table()?;
+            for (i, frame) in (1..).zip(live) {
+                let id = lua
+                    .app_data_mut::<Model>()
+                    .expect("model app_data")
+                    .frame_id(frame);
+                out.set(i, frame_wrapper(lua, id)?)?;
+            }
+            Ok(out)
+        })?,
     )?;
 
     Ok(t)
@@ -37,9 +47,13 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<Table> {
 mod tests {
     use crate::script::UiScript;
 
-    /// The shape the call site needs: `ipairs` over it must run zero times and not raise.
+    /// Nobody talking is an **empty list, not nothing**: `ipairs(nil)` raises, and the call sits
+    /// in pfUI's `ScanBubbles`, which it runs the frame after *every*
+    /// `CHAT_MSG_SAY`/`YELL`/`MONSTER_SAY`/`MONSTER_YELL` — so an absent namespace raised on any
+    /// NPC or player speaking within earshot, repeatedly, for a cosmetic feature. The live case,
+    /// and pfUI's own loop over it, are in `script/chat_bubble.rs`'s tests.
     #[test]
-    fn it_answers_an_empty_list_rather_than_nothing() {
+    fn a_silent_world_answers_an_empty_list_rather_than_nothing() {
         let s = UiScript::new().unwrap();
         assert_eq!(
             s.eval::<i64>("return table.getn(C_ChatBubbles.GetAllChatBubbles())")
diff --git a/crates/benilla-ui/src/script/extract.rs b/crates/benilla-ui/src/script/extract.rs
index 9148601a..7bee6240 100644
--- a/crates/benilla-ui/src/script/extract.rs
+++ b/crates/benilla-ui/src/script/extract.rs
@@ -349,9 +349,13 @@ impl UiScript {
                             shadow: data.font_shadow,
                             outline: data.outline,
                             alpha_gradient: data.alpha_gradient,
-                            // The owner's property: an addon's strings on a plate slide with it.
-                            world_seat: owner
-                                .is_some_and(|o| super::nameplate::is_world_seated(&model, o)),
+                            // The owner's property: an addon's strings on a plate or a chat
+                            // bubble slide with it. Both are world-seated — the app projects a
+                            // world anchor for each every frame — so both want the one snap.
+                            world_seat: owner.is_some_and(|o| {
+                                super::nameplate::is_world_seated(&model, o)
+                                    || model.chat_bubbles.holds(o)
+                            }),
                         }
                     } else {
                         // The draw gate is the texture slot, never the colour (`0x7706e0`: empty
diff --git a/crates/benilla-ui/src/script/mod.rs b/crates/benilla-ui/src/script/mod.rs
index 15b720d9..b500cdb1 100644
--- a/crates/benilla-ui/src/script/mod.rs
+++ b/crates/benilla-ui/src/script/mod.rs
@@ -34,6 +34,7 @@ mod camera_view;
 mod cast_events;
 mod channel;
 mod char_stats;
+pub mod chat_bubble;
 mod chat_misc;
 mod chat_send;
 mod chat_types;
@@ -186,6 +187,7 @@ pub use char_stats::{
     weapon_subclass_skill, BankBagSlots, InvSlotView, InventorySlots, ItemRawFields,
     UnitCombatStats, BANK_BAG_SLOT_COUNT, INVENTORY_SLOT_COUNT, SKILL_DEFENSE, SKILL_UNARMED,
 };
+pub use chat_bubble::BubbleState;
 pub use chat_misc::EmoteRequest;
 pub use chat_send::ChatSend;
 pub use chat_types::ChatTypeColor;
diff --git a/crates/benilla-ui/src/script/model.rs b/crates/benilla-ui/src/script/model.rs
index 2ce63254..a6b8dfbc 100644
--- a/crates/benilla-ui/src/script/model.rs
+++ b/crates/benilla-ui/src/script/model.rs
@@ -1453,6 +1453,9 @@ 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,
+    /// The chat-bubble widget pool (`super::chat_bubble`), driven by `benilla-app`'s
+    /// `chat_bubble.rs` feed. One pool for the session: bubbles are recycled, never destroyed.
+    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
@@ -2217,6 +2220,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/docs/ADDON_COMPAT.md b/docs/ADDON_COMPAT.md
index ef80f6ae..cf96a444 100644
--- a/docs/ADDON_COMPAT.md
+++ b/docs/ADDON_COMPAT.md
@@ -40,7 +40,7 @@ nothing behind it.
 | `UNIT_CASTEVENT` | done | `crates/benilla-app/src/superwow_events.rs`: a `CastEventFeed` queue the cast handlers push into, drained once per tick by one VM-holding system that fires the event — the pattern `ui_mirror.rs` already uses, and the only way across, since `spell/net.rs`'s `Lifecycle`/`Scene` bundles deliberately hold no `UiScript` (`game_plugins.rs`'s `every_vm_holder_in_update_declares_its_side_of_the_tick` gates that). Edges wired: `START` from `SMSG_SPELL_START` with its wire cast time as `arg5` (an instant raises none — its only edge is `CAST`, which is what the wiki's own START/CAST split means), `CAST` from `SMSG_SPELL_GO`, `FAIL` from `SMSG_SPELL_FAILED_OTHER`, `CHANNEL` from `MSG_CHANNEL_START` with its duration. GUIDs go out in the same 16-hex-digit spelling every other `compat/` surface uses, so `arg1`/`arg2` compare directly against a `UnitExists`/`UnitGUID` return. Not wired: `MAINHAND`/`OFFHAND` — benilla's melee-swing path raises no cast edge at all, so there is nothing to forward. `MSG_CHANNEL_START` names no caster (1.12 sends it for the local player's own channel only), so `CHANNEL`'s `arg1` is self and its `arg2` is 0 |
 | `RAW_COMBATLOG` | **done** | `ui_chat/frames.rs`'s `route` — the one funnel every combat line already passes on its way to a window and to `WoWCombatLog.txt`. Two arguments, as its one consumer in grom's corpus destructures them: the printed sentence, and the same sentence with each unit name spelled as its GUID (`PendingCombat::guid_fills`, composed a second time through the same `compose_line`, so the two can only ever differ in the name slots). Fired **before** the `CHAT_MSG_*`, which is what "raw" means upstream — it hooks the combat-log parse, ahead of the client's own formatting. Gated on `has_listener` — the gate nampower's combat-log family already uses — **or on SuperWoW's raw log being open**, since that file is the same `arg2` form written to disk; the composition is skipped under the same one test (`frames::wants_raw_form`), because a raid's log is tens of lines a second. A variant whose template says "you" keeps saying it, because that word is in the *template* and not in a fill — and its consumer depends on exactly that, reading the word and then asking `UnitExists("player")` for its own guid. **Why this row came first:** of SuperWoW's whole surface, it and `CombatLogAdd` are the only two names grom's addons call that this client lacked (`scripts/dll-surface.py --wanted`), and `SuperCleveRoidMacros/Utility.lua:10206` funnels **five** subsystems through this single event — immunity and resist learning, hidden-CC ("afflicted by") detection, debuff-duration learning off the GUID half, and the reactive-proc window that lights **Overpower** and **Revenge**. Its own comment there is why the last of those can come from nowhere else: "SPELL_GO only provides hit/miss COUNTS, not miss TYPES, so it cannot distinguish dodge (Overpower proc) from parry/block/resist". This does **not** by itself fix the Overpower complaint: that needs the dodged-*ability* sentence to be emitted at all, which is its own open item (`benilla-overpower-aura-spelldodged`) |
 | `CombatLogAdd("text" [, addToRawLog])` | **done** | `compat/superwow.rs` queues the line; `ui_chat/logging.rs`'s `sync_chat_logging` appends it to `WoWCombatLog.txt` through the same `record` every routed line uses, so it is stamped identically and one writer owns the file. **The second argument names a FILE**, not the event: `Logs\WoWRawCombatLog.txt` is its own literal in the DLL's string pool, a few strings on from `Logs\WoWCombatLog.txt`, and it is the GUID-form log — the same lines `RAW_COMBATLOG` carries as `arg2`. That corrects a first reading of the name ("also fire the event"), which was an inference from the name alone. Dropped while a log is closed, which is upstream's behaviour too. A non-string argument is ignored rather than raising: its one real caller is a debug-trace helper (`BigWigs/Plugins/MageTools.lua:761`) and a raise there would take the addon down for something the player cannot act on. **It is also a detection name**: `SpellRequests.lua:6` is `if CombatLogAdd then hasSuperWow = true`, which gates that whole module |
-| `CREATE_CHATBUBBLE` | **blocked, deliberately not fired** | the last of SuperWoW's three events, and the one that cannot be made good: its payload can only be the bubble, and this client's bubbles are not Lua frames — they are a 2-D world overlay (`chat_bubble.rs`), as the reference's own `CGChatBubbleFrame` is. The same wall `C_ChatBubbles.GetAllChatBubbles` hit, and firing it argless would be *worse* than silence (an addon reaching for `arg1`'s regions raises, once per bubble). See the manifest section below for what the one piece of work behind it would close. `SUPERWOW_COMBAT_LOG_EVENT`, which this row used to carry, is a ghost |
+| `CREATE_CHATBUBBLE` | **done** | the last of SuperWoW's three events, and it needed the bubbles to become **widgets** first: its payload can only be the bubble, and this client drew them straight into the overlay quad lane. `benilla-ui`'s `script/chat_bubble.rs` is now a pool of real frames — anonymous `WorldFrame` children with a backdrop, a tail texture and a `FontString`, which is what the reference's own `CGChatBubbleFrame` is — driven by the app's existing feed, the same split `vplates.rs` already makes for the plates. `arg1` is the frame, which is the only sensible payload and a reading rather than a measurement (the DLL publishes no usage string for an event). Fired **per appearance**, not per pool slot ever built, which is the opposite of `NAME_PLATE_CREATED`'s rule and deliberate: what an addon wants from this is "here is a bubble to skin or move, now", and a recycled frame has been re-anchored, re-sized and re-texted since it was last seen |
 | `NameplateRange` | done | one CVar, two readers: `nameplates.rs`'s `NameConfig::range_sq` (the overhead name — introduces a cull where the reference has none at all) and `vplates.rs`'s `VPlateMode::range_sq` (replaces the reference's own hardcoded 20 yd V-key-plate range). Default `80`, the top of the mod's documented 10-80 range — no shipped default is published, so this is the least-restrictive honest choice, not a confirmed number |
 | `ChatBubbleRange` | done | `chat_bubble.rs`'s `BubbleConfig::range_sq`, replacing the reference's hardcoded 20 yd. Default `20` (today's exact value) — no shipped default published for this one either, within the mod's documented 10-200 yd range |
 | `NameplateMotion` | **done, two of its four values** | the investigation this row asked for had an answer already in the tree: benilla *does* spread plates, with the reference's own SmartScreenRect solver (`crate::smart_rect`, bucket 0). So `0` ("Overlap") is that solver bypassed — the plate sits on its own projected point and nothing is claimed either, since a claim with no solve is half a spread — and `1` ("Default spread") is it, which is today's behaviour and the registered default. `2` ("Smart spread") and `3` ("Compact spread") are the mod's own alternative algorithms, unknowable from here, and **fall back to 1**: a documented silent-equal rather than a refused row, because the benign direction is plates that still do not overlap, and refusing would leave a player no way to turn the spread off at all. The four meanings come from SuperAPI's own panel (`SuperAPIOptions.lua:20-25`), the DLL publishing only the name. `NameplateVerticalSpacing`, which this row used to carry, is **not in the DLL's string pool at all** — another ghost |
@@ -108,15 +108,32 @@ that site can only subtract; the other reading would bubble creatures with the m
 which is a surprise no setting advertises. All four are welded to their struct literals in
 `cvars.rs`'s own defaults-mirror test, the `benilla-cvar-default-trap` discipline.
 
-**`CREATE_CHATBUBBLE` cannot be made good, and the reason is already written up elsewhere in this
-file.** Its payload can only be the bubble, and this client's bubbles are not Lua frames at all —
-they are a 2-D world overlay drawn by `chat_bubble.rs`, the same way the reference's own
-`CGChatBubbleFrame` is drawn. That is the identical wall `C_ChatBubbles.GetAllChatBubbles` hit, and
-it answers an empty list for it. Firing the event argless would be worse than not firing: an addon
-written against upstream would reach for `arg1`'s regions and raise, once per bubble. **The real
-item behind both** is making the native bubbles addressable from Lua — a frame with a texture and a
-`FontString` per live bubble, kept in step with the overlay's own spawn, stacking and expiry rules —
-and that one piece of work closes the event, the namespace and pfUI's bubble skinning together.
+**`CREATE_CHATBUBBLE` is done, and so is `C_ChatBubbles.GetAllChatBubbles`** — one piece of work
+closed both, plus pfUI's bubble skin. The wall was that a bubble's payload can only be the bubble
+and this client's bubbles were not Lua frames: they were drawn straight into the overlay quad lane,
+faithful on screen and unreachable from Lua. They are a **widget pool** now
+(`benilla-ui`'s `script/chat_bubble.rs`): anonymous `WorldFrame` children with a backdrop
+(`0x4b0a35` is `SetBackdrop`), a tail texture and a `FontString` — which is what the reference's own
+`CGChatBubbleFrame` is, and how addons of the era found bubbles before SuperWoW published the event.
+
+The app keeps everything a bubble's *existence* depends on — the spawn gate, the lifetime, the fade,
+the range re-test, the stacking sort and the text measurement that sizes the frame — and hands the
+result over per live bubble, the same split `vplates.rs` makes for the plates. Three things improved
+by the move rather than being preserved by it:
+
+- The bubbles now sit at frame **levels 2, 3, 4…** over the V-plates at level 1, which is the
+  reference's own order (`0x4b12d5`-`0x4b1312`); the quad band had them *underneath*, a deviation
+  `ui_pass::overlay_z` carried in a comment. That band is gone, and the lane is down to one tenant.
+- The art is loaded, tiled and bleed-inset by the UI pass like any other frame's, so
+  `chat_bubble.rs` no longer carries its own texture resource or its own half-texel inset.
+- The system moved **before** the paint. It had been inside `UiQuadAppend`, the window *after* the
+  extract — right for an appender, a frame late for a feed.
+
+**What a test had to prove, and does**: pfUI's own `ScanBubbles` loop, transcribed, finds the
+`FontString` with the line and its chat-type colour, blanks the one Texture region and parents its
+own frame to the bubble; and a bubble handed over as state comes out of the *extract* as drawn quads
+— both backdrop halves, the tail, and the text at the em the app measured the box with. A test that
+only checked the widgets would have passed with nothing on screen.
 
 And the CVars it registers, as names: `NameplateRange`, `NameplateMotion`, `ChatBubbleRange`,
 `ChatBubblesRaid`, `ChatBubblesBattleground`, `ChatBubblesWhisper`, `ChatBubblesCreatures`,
@@ -351,7 +368,7 @@ a loot roll"; it does not, because that module never runs.** The call path was n
 
 | Area | Status | Notes |
 |---|---|---|
-| `C_ChatBubbles.GetAllChatBubbles` | done, **empty list** | The one genuinely hot absence the sweep found, and reproducible: `pfUI.bubbles:ScanBubbles()` raised `attempt to index global 'C_ChatBubbles'`, and pfUI runs it the frame after **every** `CHAT_MSG_SAY`/`YELL`/`MONSTER_SAY`/`MONSTER_YELL` within earshot. Answers an empty list, which is the truthful count rather than a stub: bubbles here are drawn natively by `chat_bubble.rs` as a 2-D world overlay, exactly as the reference's own `CGChatBubbleFrame` is, so there are no Lua frames to hand over and no regions a script can repaint. The cost is that bubbles keep this client's look instead of pfUI's; making them addressable (a frame + texture + `FontString` per live bubble, kept in step with the native spawn/stack/expiry rules) is the real fix and is not built |
+| `C_ChatBubbles.GetAllChatBubbles` | **done, the live bubbles** | The one genuinely hot absence the sweep found, and reproducible: `pfUI.bubbles:ScanBubbles()` raised `attempt to index global 'C_ChatBubbles'`, and pfUI runs it the frame after **every** `CHAT_MSG_SAY`/`YELL`/`MONSTER_SAY`/`MONSTER_YELL` within earshot. It answered an *empty list* for a round — truthful, because bubbles were overlay quads with no Lua frame to hand over — and that row said making them addressable was "the real fix and is not built". It is built: `benilla-ui`'s `script/chat_bubble.rs` is a pool of real frames and this answers them in pool order, live ones only, a fresh table per call. The order is stable for a bubble's whole life, which is what an addon keying a cache on the frame needs, and is deliberately **not** the stacking order, which changes every frame with the camera. pfUI's own loop over it is transcribed as a test |
 | `C_Spell.GetSpellDispelType` | done | The other hot one: `libs/libdebuff.lua:379` calls it once per debuff while walking aura slots 33-48, so it runs for every debuff on every scanned unit — continuously, in combat, which is when the debuff display matters. Backed by widening [`SpellLookup`] with `Spell.dbc`'s `Dispel` column, the route this file already named for the `C_Spell` predicates; `SpellDisplay` carried it already, so nothing new had to be parsed. Answers the **raw id**, not `SpellDispelType.dbc`'s localized name, because the caller keys its own `dispelTypeMap` on the number and a name would make a localized realm answer something that table cannot match. `0` ("no dispel class") answers **nil**, which the call site's `if dispelId and dispelId > 0` already reads the same way. The book arm takes it from the probe alongside `reagents` — a spellbook slot carries neither column |
 | `Item:CreateFromItemLink` | done | Keyed on the id inside the link, which is the same object here: every `ItemMixin` getter reads a `C_Item.*ByID`, and a 1.12 link carries nothing per-item beyond the id — no bonus ids, no modifiers, no scaling — so the link and id forms cannot disagree about anything the mixin exposes. A link naming no item (nil, a spell or quest link, a malformed string) yields an **empty** item rather than raising, which is what the call site's own `if item and not item:IsItemEmpty()` expects. Built for correctness, not for a live error: its only caller is the loot-history module, which never runs |
 | `UnitSpellHaste` | done, **0** | 0 is the *answer*, not a stub: 1.12 has no haste stat anywhere — not a `UNIT_FIELD`, not an item mod, not a spell modifier — so every unit genuinely has 0% spell haste and the real DLL has nothing else to read either. pfUI's player module calls it unguarded into a `string.format("%.1f%%")` (`modules/player.lua:87`) whenever its haste readout is on, so the absence raised once per 0.25s tick and took the neighbouring "+N SP" line down with it |