diff --git a/crates/benilla-app/assets/ui/ScriptLogFrame.xml b/crates/benilla-app/assets/ui/ScriptLogFrame.xml
index 9a2abc30..13fd9dcc 100644
--- a/crates/benilla-app/assets/ui/ScriptLogFrame.xml
+++ b/crates/benilla-app/assets/ui/ScriptLogFrame.xml
@@ -232,8 +232,9 @@
         </Scripts>
     </Button>
 
-    <Frame name="BenillaScriptLogFrame" hidden="true">
-        <!-- The standard left-slot panel size. No <Anchors>: ShowUIPanel seats it. -->
+    <Frame name="BenillaScriptLogFrame" parent="UIParent" hidden="true">
+        <!-- The standard left-slot panel size. No <Anchors>: ShowUIPanel seats it. Under UIParent,
+             as the stock panels are, so it takes the UI scale with them. -->
         <Size><AbsDimension x="384" y="512"/></Size>
         <Layers>
             <Layer level="BACKGROUND">
diff --git a/crates/benilla-app/src/capture/fixtures.rs b/crates/benilla-app/src/capture/fixtures.rs
index 6ae24160..f5965a3c 100644
--- a/crates/benilla-app/src/capture/fixtures.rs
+++ b/crates/benilla-app/src/capture/fixtures.rs
@@ -1358,15 +1358,23 @@ pub(super) fn seed_ui_fixture(
                 warn!("capture: ui-chat-tabhover select failed: {e}");
             }
             script.resolve();
+            // Each in the root's units the cursor is fed in: the frame's own times its scale.
             let expr = match mode.as_str() {
-                "2" | "3" => "return ChatFrame2Tab:GetCenter()",
+                "2" | "3" => {
+                    "local x, y = ChatFrame2Tab:GetCenter() \
+                        local k = ChatFrame2Tab:GetEffectiveScale() return x * k, y * k"
+                }
                 "0" => {
-                    "return (ChatFrame2:GetLeft() + ChatFrame2:GetRight()) / 2, \
-                        (ChatFrame2:GetBottom() + ChatFrame2:GetTop()) / 2"
+                    "local k = ChatFrame2:GetEffectiveScale() \
+                        return (ChatFrame2:GetLeft() + ChatFrame2:GetRight()) / 2 * k, \
+                        (ChatFrame2:GetBottom() + ChatFrame2:GetTop()) / 2 * k"
                 }
                 // 9: park far away, so the dock conceals itself.
                 "9" => "return 2000, 2000",
-                _ => "return ChatFrame1Tab:GetCenter()",
+                _ => {
+                    "local x, y = ChatFrame1Tab:GetCenter() \
+                        local k = ChatFrame1Tab:GetEffectiveScale() return x * k, y * k"
+                }
             };
             let centre: Result<(f32, f32), _> = script.eval(expr);
             match centre {
diff --git a/crates/benilla-app/src/capture/probes/act.rs b/crates/benilla-app/src/capture/probes/act.rs
index bfad967f..ddc4ea14 100644
--- a/crates/benilla-app/src/capture/probes/act.rs
+++ b/crates/benilla-app/src/capture/probes/act.rs
@@ -550,13 +550,13 @@ struct ProbeDrag {
     to: (f32, f32),
 }
 
-/// A frame's centre from its live `GetLeft`/`GetRight`/`GetTop`/`GetBottom`, in the space
-/// [`crate::ui_script::input`] feeds the cursor in.
+/// A frame's centre from its live `GetLeft`/`GetRight`/`GetTop`/`GetBottom`, times its effective
+/// scale: the edges answer in the frame's own units, the cursor is fed in the root's.
 fn frame_centre(script: &benilla_ui::script::UiScript, name: &str) -> Option<(f32, f32)> {
     let read = |edge: &str| {
         script
             .eval::<f32>(&format!(
-                "local f = getglobal(\"{name}\") return f and f:Get{edge}()"
+                "local f = getglobal(\"{name}\") return f and f:Get{edge}() * f:GetEffectiveScale()"
             ))
             .ok()
     };
diff --git a/crates/benilla-app/src/chat_bubble.rs b/crates/benilla-app/src/chat_bubble.rs
index 2ad3a8f7..1a91b740 100644
--- a/crates/benilla-app/src/chat_bubble.rs
+++ b/crates/benilla-app/src/chat_bubble.rs
@@ -553,7 +553,7 @@ fn draw_bubble(
         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) {
+    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],
diff --git a/crates/benilla-app/src/minimap/blips/mod.rs b/crates/benilla-app/src/minimap/blips/mod.rs
index 4d5bf2ce..463d8595 100644
--- a/crates/benilla-app/src/minimap/blips/mod.rs
+++ b/crates/benilla-app/src/minimap/blips/mod.rs
@@ -160,7 +160,6 @@ pub(super) type BlipInputs<'w, 's> = (
     Query<'w, 's, &'static GlobalTransform, With<NetEntity>>,
     Query<'w, 's, &'static Window, With<PrimaryWindow>>,
     ResMut<'w, MinimapBlipHover>,
-    Res<'w, crate::ui_script::UiScaleCvar>,
     Res<'w, crate::ui_party::GroupState>,
     TrackedCandidates<'w, 's>,
     Query<'w, 's, (&'static ObjectStore, &'static Guid), With<SelfPlayer>>,
@@ -200,11 +199,11 @@ pub(super) struct BlipCtx {
     pub(super) wz: f32,
     /// The cursor in the quads' y-down logical px.
     pub(super) cursor: Option<Vec2>,
-    /// The cursor in y-up UI space; the reference seats the blip tooltip at the cursor, its exact
-    /// offset untraced.
+    /// The cursor in the y-up root units; the reference seats the blip tooltip at the cursor, its
+    /// exact offset untraced.
     pub(super) cursor_ui: Option<Vec2>,
-    /// Window px per UI unit: everything else here is window px, while Lua
-    /// ([`Minimap:PingLocation`](super::ping)) speaks UI units.
+    /// Window px per root unit: everything else here is window px, while Lua
+    /// ([`Minimap:PingLocation`](super::ping)) hands root units.
     pub(super) seam: f32,
 }
 
diff --git a/crates/benilla-app/src/minimap/mod.rs b/crates/benilla-app/src/minimap/mod.rs
index 10f72ccf..c3909946 100644
--- a/crates/benilla-app/src/minimap/mod.rs
+++ b/crates/benilla-app/src/minimap/mod.rs
@@ -351,7 +351,6 @@ fn emit_minimap(
         unit_pos,
         window,
         mut blip_hover,
-        ui_scale,
         group,
         tracked,
         self_store,
@@ -621,7 +620,7 @@ fn emit_minimap(
         }
         let win = window.iter().next();
         let cursor = win.and_then(|w| w.cursor_position());
-        let seam = win.map_or(1.0, |w| crate::ui_script::seam_scale(w.height(), ui_scale.0));
+        let seam = win.map_or(1.0, |w| crate::ui_script::seam_scale(w.height()));
         // The pan origin snapped to a half-logical-pixel grid: every blip offset and rim bearing
         // derives from `wx`/`wy`, so the layer steps together instead of rewriting the batch mesh
         // every frame while walking. Blip world positions stay exact.
@@ -637,11 +636,11 @@ fn emit_minimap(
             wy: (wy / q).round() * q,
             wz: wow[2],
             cursor,
-            // The cursor in UI space (y-up, ÷ the seam scale): the tooltip anchor resolves in
-            // 768-virtual units, not window px.
+            // The cursor in the root's units (y-up, ÷ the seam scale): the tooltip anchor resolves
+            // in them, not window px.
             cursor_ui: cursor
                 .zip(win)
-                .map(|(c, w)| Vec2::new(c.x / seam, (w.height() - c.y) / seam)),
+                .map(|(c, w)| crate::ui_script::window_to_ui(w.height(), c)),
             seam,
         }
     });
diff --git a/crates/benilla-app/src/minimap/ping.rs b/crates/benilla-app/src/minimap/ping.rs
index c218c756..bf4e6ba2 100644
--- a/crates/benilla-app/src/minimap/ping.rs
+++ b/crates/benilla-app/src/minimap/ping.rs
@@ -5,9 +5,10 @@
 //! [`drive_minimap_ping`] republishes against the live view radius, so the marker follows the pan
 //! and the zoom with no second copy to fall out of step.
 //!
-//! - In: the stock `Minimap_OnClick` calls `Minimap:PingLocation(dx, dy)` in UI units from the
-//!   centre; the renderer converts it with the geometry of the frame it draws: UI units × the seam
-//!   scale = window px, ÷ `px_per_yd` = yards.
+//! - In: the stock `Minimap_OnClick` calls `Minimap:PingLocation(dx, dy)` in the minimap's units
+//!   from the centre, which the engine hands over in root units; the renderer converts them with
+//!   the geometry of the frame it draws: root units × the seam scale = window px, ÷ `px_per_yd` =
+//!   yards.
 //! - Across: our ping sends `MSG_MINIMAP_PING` (raw world floats, relayed to the rest of the group
 //!   only, `GroupHandler.cpp:384-391`); a member's seats the same way. A ping seats locally at
 //!   click time, so a solo ping works.
@@ -59,8 +60,8 @@ impl MinimapPing {
     }
 }
 
-/// A `Minimap:PingLocation(x, y)` click to the world point it names: `ui` is centre-relative UI
-/// units (x right, y up), `seam` window px per UI unit ([`crate::ui_script::seam_scale`]), `ctx`
+/// A `Minimap:PingLocation(x, y)` click to the world point it names: `ui` is centre-relative root
+/// units (x right, y up), `seam` window px per root unit ([`crate::ui_script::seam_scale`]), `ctx`
 /// the map as drawn this frame. The inverse of [`BlipCtx::offset`]: screen right is −WoW y, screen
 /// up +WoW x. `None` outside the disc, the stock test (`Minimap.lua:135`) in yards.
 fn click_to_world(ctx: &BlipCtx, ui: (f32, f32), seam: f32) -> Option<(f32, f32)> {
@@ -193,13 +194,13 @@ mod tests {
         }
     }
 
-    /// The click is in UI units and `px_per_yd` in window px: at 0.9 uiScale on a 1080p window the
-    /// seam is ≈1.27, and a conversion that skips it seats every ping ≈27 % too far out.
+    /// The click is in root units and `px_per_yd` in window px: on a 1080p window the seam is
+    /// ≈1.41, and a conversion that skips it seats every ping ≈41 % too far out.
     #[test]
     fn a_click_converts_through_the_seam_scale() {
         let c = ctx();
-        let seam = 1080.0 / 768.0 * 0.9; // the shipped default at 1080p
-                                         // 20 UI units right → 20·seam px → yards west (−y).
+        let seam = 1080.0 / 768.0;
+        // 20 root units right → 20·seam px → yards west (−y).
         let (x, y) = click_to_world(&c, (20.0, 0.0), seam).expect("inside the disc");
         let expect_yd = 20.0 * seam / c.px_per_yd;
         assert!((x - 0.0).abs() < 1e-3, "no northing from a due-east click");
diff --git a/crates/benilla-app/src/perf/hud.rs b/crates/benilla-app/src/perf/hud.rs
index ec59c09b..d963a0a0 100644
--- a/crates/benilla-app/src/perf/hud.rs
+++ b/crates/benilla-app/src/perf/hud.rs
@@ -113,9 +113,9 @@ pub(super) fn refresh_hud_snapshot(
 /// clear). The always-up world-state readout (`WorldStateAlwaysUpFrame`, stock
 /// `WorldStateFrame.xml`) shares the band, and the dev pill is the one that yields.
 ///
-/// The layout answers in UI units, a screen `768/uiScale` units tall whatever the window, while
-/// the pill draws in window px, so the chunk returns a fraction of the screen and the caller
-/// scales it by the window height. Reading an edge settles the layout, one graph solve at most.
+/// The layout answers in `UIParent`'s units, a screen `768/uiScale` units tall whatever the
+/// window, while the pill draws in window px, so the chunk returns a fraction of the screen and the
+/// caller scales it by the window height. Reading an edge settles the layout, one graph solve at most.
 pub(crate) fn top_centre_claimed(script: &UiScript, win_h: f32) -> f32 {
     // `WorldStateAlwaysUpFrame` is always shown; the readout occupies its `AlwaysUpFrame<n>` rows,
     // built on demand and hidden when empty, so the claim is the lowest shown row's bottom.
diff --git a/crates/benilla-app/src/ui_script/extract/mod.rs b/crates/benilla-app/src/ui_script/extract/mod.rs
index 972afda4..4fb1ef09 100644
--- a/crates/benilla-app/src/ui_script/extract/mod.rs
+++ b/crates/benilla-app/src/ui_script/extract/mod.rs
@@ -425,7 +425,11 @@ pub(super) fn tick_script(
     mut last_seam: Local<f32>,
     // The `scale_factor` measures were last answered under; 0 until the first frame.
     mut last_dpi: Local<f32>,
-    ui_scale: Res<super::UiScaleCvar>,
+    // The dial, `UIParent`'s scale in the VM, and the automatic scale's last display.
+    (ui_scale, mut auto_cache): (
+        Res<super::UiScaleCvar>,
+        Option<ResMut<super::UiAutoScaleCache>>,
+    ),
     mut ui_cost: ResMut<super::UiFrameCost>,
     mut pass: ResMut<super::UiPassState>,
 ) {
@@ -442,9 +446,9 @@ pub(super) fn tick_script(
     };
     let (w, h) = (window.width(), window.height());
     // The client's UI space is 768 units tall at every aspect (`f(screenH) = 768`, `0x41ad10`; the
-    // caret's `H_px/192`, `0x77b8c0`), `768/uiScale` with the dial. The VM lives in it: quads
-    // scale ×s out, and the mouse and the measures ÷s in.
-    let s = super::seam_scale(h, ui_scale.0);
+    // caret's `H_px/192`, `0x77b8c0`), the dial being `UIParent`'s scale inside it. The VM lives in
+    // it: quads scale ×s out, and the mouse and the measures ÷s in.
+    let s = super::seam_scale(h);
     // A moved seam scale or DPI stales every text metric the engine caches: integer-stepped
     // advances do not rescale, and the size snap moves a string's width by several percent,
     // enough for the ellipsis to eat fitting text. A monitor hop moves the DPI alone.
@@ -486,8 +490,17 @@ pub(super) fn tick_script(
     {
         let _span = bevy::log::info_span!("ui_script: tick").entered();
         let resized = script.set_screen_size(w / s, if h > 0.0 { h / s } else { 768.0 });
-        // A resize re-runs what the interface computed from the old screen size.
+        // A display change re-applies the UI scale (`0x492e90`), whose narrow-aspect cap follows
+        // the window; a moved dial applies once, as its CVar callback does (`0x490770`).
         if resized {
+            let display = (w.round() as u32, h.round() as u32);
+            let mut none = None;
+            let cache = auto_cache.as_deref_mut().map_or(&mut none, |c| &mut c.0);
+            script.apply_ui_scale(display, cache);
+        }
+        let rescaled = script.set_ui_scale(ui_scale.0);
+        // Either re-runs what the interface computed from the old `GetScreenHeight()`.
+        if resized || rescaled {
             super::manifest::on_screen_resized(&script);
         }
         script.tick(time.delta_secs());
@@ -1713,9 +1726,10 @@ mod clip_plumb_tests {
         );
     }
 
-    /// At dial 0.5 the VM sees a 2048×1536 screen, and every window-px rect halves.
+    /// The dial is `UIParent`'s scale, so a ScrollFrame with no parent keeps its px rect and clip
+    /// at dial 0.5: the root stays 768 units tall.
     #[test]
-    fn the_uiscale_dial_scales_the_extracted_rects() {
+    fn the_uiscale_dial_leaves_a_parentless_frame_alone() {
         let mut app = app_with_scrolled_marker();
         app.insert_resource(crate::ui_script::UiScaleCvar(0.5));
         app.update();
@@ -1726,12 +1740,10 @@ mod clip_plumb_tests {
             .find(|q| q.color[0] == 1.0 && q.color[1] == 0.0 && q.color[2] == 0.0)
             .expect("the colored marker quad extracted");
 
-        // WoW space: top 1536 − 100 = 1436, bottom 1236, right 300; ×0.5 is y-up px 618..718,
-        // and y-down through the 768 window the top is 50 and the bottom 150.
         assert_eq!(
             marker.clip,
-            Some(Rect::new(0.0, 50.0, 150.0, 150.0)),
-            "dial 0.5 halves the px rect and re-hangs the frame from the taller virtual top"
+            Some(Rect::new(0.0, 100.0, 300.0, 300.0)),
+            "dial 0.5 moves nothing outside UIParent"
         );
     }
 
diff --git a/crates/benilla-app/src/ui_script/extract/text.rs b/crates/benilla-app/src/ui_script/extract/text.rs
index 00d95d38..e7bd9312 100644
--- a/crates/benilla-app/src/ui_script/extract/text.rs
+++ b/crates/benilla-app/src/ui_script/extract/text.rs
@@ -40,10 +40,11 @@ pub(super) struct TextHost<'a> {
     /// The focused editbox's text UI, unfiltered: [`emit`] matches it to this quad by `target`.
     pub ebox: Option<&'a EditBoxTextUi>,
     pub screen_h: f32,
-    /// The seam scale `windowH/768 × uiScale`, for the unit-space inputs; rects arrive in px.
+    /// The seam scale `windowH/768`, for the root-unit inputs; rects arrive in px.
     pub scale: f32,
     /// The frame's effective scale, already in the rect: glyph size and shadow offset ride it, as
-    /// the 1.12 client's text rides `SetScale`; the editbox x-offsets arrive in screen UI units.
+    /// the 1.12 client's text rides `SetScale` and the UI scale; the editbox x-offsets arrive in
+    /// root units.
     pub font_scale: f32,
     /// Captures pin the caret on for deterministic pixels; live, the engine's blink decides.
     pub caret_pinned: bool,
@@ -387,7 +388,7 @@ mod tests {
         assert_eq!(band_clip_slack(Some(2.0)), 3.0);
     }
 
-    /// `1.0546875` is the seam scale of a 1600×900 window at uiScale 0.9.
+    /// `1.0546875` is a 1600×900 window's seam times the 0.9 UI scale.
     #[test]
     fn a_shadow_offset_is_a_whole_pixel_and_never_vanishes() {
         assert_eq!(shadow_offset_px(1.0), 1.0);
diff --git a/crates/benilla-app/src/ui_script/input.rs b/crates/benilla-app/src/ui_script/input.rs
index dd1b5801..2a296cc6 100644
--- a/crates/benilla-app/src/ui_script/input.rs
+++ b/crates/benilla-app/src/ui_script/input.rs
@@ -94,8 +94,6 @@ pub(super) fn feed_ui_input(
     ),
     // The characters the active layout makes, which name a key for a keyboard frame.
     layout: Res<crate::bindings::LayoutNames>,
-    // The uiScale dial folded into the seam scale.
-    ui_scale: Res<super::UiScaleCvar>,
 ) {
     let (keyboard, keys, capture, clipboard) = (&mut kbd.0, &kbd.1, &mut kbd.2, &mut kbd.3);
     let world_pick = pointer.world_pick();
@@ -139,10 +137,8 @@ pub(super) fn feed_ui_input(
         .or_else(crate::target::hover_probe_point)
         .filter(|_| !synthetic)
     {
-        // The window cursor is logical px, y-down from the top left; the UI is y-up in 768-high
-        // units under uiScale: flip through the window height, then undo the extract seam's scale.
-        let s = super::seam_scale(window.height(), ui_scale.0);
-        let (x, y) = (cursor.x / s, (window.height() - cursor.y) / s);
+        // The window cursor in the root's y-up 768-high units, as `GetCursorPosition` answers it.
+        let Vec2 { x, y } = super::window_to_ui(window.height(), cursor);
         // `WOW_HIT_COST=1` meters this call's per-frame hit-test rebuild, one line a second.
         static HIT_COST: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
         let metering =
diff --git a/crates/benilla-app/src/ui_script/lifecycle.rs b/crates/benilla-app/src/ui_script/lifecycle.rs
index 7e1a52aa..d91c92bb 100644
--- a/crates/benilla-app/src/ui_script/lifecycle.rs
+++ b/crates/benilla-app/src/ui_script/lifecycle.rs
@@ -230,26 +230,22 @@ pub(crate) fn run_pending_entry_load(world: &mut World) {
     );
 }
 
-/// Seat the VM's screen size and text measurer for the load, under the current window and
-/// `uiScale`: the load-edge half of [`super::extract::tick_script`]'s per-frame pair. A fresh VM
-/// answers 1024×768 until then, and a value computed once at load keeps it: stock
-/// `WorldMapFrame_OnLoad` sizes the full-screen `BlackoutWorld` from `GetScreenWidth()` and
-/// `GetScreenHeight()` and never again (`WorldMapFrame.lua:19-28`). With no atlas yet (it bakes on
-/// the first `Update`) the per-frame pass seats the measurer.
+/// Seat the VM's screen size and text measurer for the load, under the current window: the
+/// load-edge half of [`super::extract::tick_script`]'s per-frame pair. A fresh VM answers 1024×768
+/// until then, and a value computed once at load keeps it: stock `WorldMapFrame_OnLoad` sizes the
+/// full-screen `BlackoutWorld` from `GetScreenWidth()` and `GetScreenHeight()` and never again
+/// (`WorldMapFrame.lua:19-28`), which answer the root while `UIParent` is still at scale 1. With no
+/// atlas yet (it bakes on the first `Update`) the per-frame pass seats the measurer.
 fn seat_raster_seam_for_load(world: &mut World, script: &mut UiScript) {
-    let ui_scale = world
-        .get_resource::<super::UiScaleCvar>()
-        .map_or(1.0, |c| c.0);
     let (w, h) = {
         let mut q = world.query_filtered::<&Window, With<bevy::window::PrimaryWindow>>();
         q.single(world)
             .map_or((0.0, 0.0), |win| (win.width(), win.height()))
     };
-    let s = super::seam_scale(h, ui_scale);
+    let s = super::seam_scale(h);
     if w > 0.0 && h > 0.0 {
-        // The VM lives in 768-tall virtual space, so logical size over the seam scale is its
-        // screen. No `UIParent_ManageFramePositions` here, unlike `tick_script`: nothing is laid
-        // out yet.
+        // The VM lives in a 768-tall root, so logical size over the seam scale is its screen. No
+        // `UIParent_ManageFramePositions` here, unlike `tick_script`: nothing is laid out yet.
         script.set_screen_size(w / s, h / s);
     }
     let Some(atlas) = world.get_resource::<crate::ui_text::UiFontAtlas>() else {
@@ -387,6 +383,9 @@ fn load_ingame_ui_seated(world: &mut World, seat: LoadSeat) {
     // text width, `UIPanelTemplates.xml:370-373`), which answers 0 with no measurer.
     seat_raster_seam_for_load(world, &mut script);
     // Read out of the world first: the bracket below borrows `world` for the chat-cache restore.
+    let ui_scale = world
+        .get_resource::<super::UiScaleCvar>()
+        .map_or(1.0, |c| c.0);
     let zoom = {
         let z = world.resource::<crate::minimap::MinimapZoom>();
         (z.outdoor, z.inside)
@@ -421,6 +420,21 @@ fn load_ingame_ui_seated(world: &mut World, seat: LoadSeat) {
             |script| crate::vplates::seat_legacy_settings(script, &legacy_plates),
             |script| {
                 crate::ui_chat::restore_chat_looks(world, script);
+                // The UI scale lands on `UIParent` once the files, the addons and
+                // `VARIABLES_LOADED` are done, after the chat reader (`0x4900d6`) and before the
+                // `PLAYER_LOGIN` arm (`0x49011d`), through the display handler (`0x49010e` →
+                // `0x492e90`). So every `OnLoad` sees `UIParent` at scale 1 and the root's size.
+                let display = {
+                    let mut q =
+                        world.query_filtered::<&Window, With<bevy::window::PrimaryWindow>>();
+                    q.single(world).map_or((0, 0), |w| {
+                        (w.width().round() as u32, w.height().round() as u32)
+                    })
+                };
+                let mut none = None;
+                let mut cache = world.get_resource_mut::<super::UiAutoScaleCache>();
+                let cache = cache.as_deref_mut().map_or(&mut none, |c| &mut c.0);
+                script.seat_ui_scale(ui_scale, display, cache);
             },
         );
     });
@@ -766,10 +780,10 @@ pub(crate) fn finish_ui_load(script: &mut UiScript) {
 
 /// [`finish_ui_load`] with its two host seams. `host_settings` runs between the saved-variables
 /// chunk and `VARIABLES_LOADED`, carrying over a setting `config.toml` held before it moved into
-/// the saved variables. `between` is the chat-cache restore's `UPDATE_CHAT_WINDOWS` +
-/// `UPDATE_CHAT_COLOR` burst, after `VARIABLES_LOADED` and before the `PLAYER_LOGIN` arm (so
-/// before the event too), where the reference registers its reader
-/// (`0x4900d6` → `0x498a20`). On a fresh login the reference's cache (`0x5afe50`) defers that
+/// the saved variables. `between` runs after `VARIABLES_LOADED` and before the `PLAYER_LOGIN` arm
+/// (so before the event too): the chat-cache restore's `UPDATE_CHAT_WINDOWS` +
+/// `UPDATE_CHAT_COLOR` burst, where the reference registers its reader (`0x4900d6` → `0x498a20`),
+/// then the UI scale (`0x49010e`). On a fresh login the reference's cache (`0x5afe50`) defers that
 /// reader until the server's account data reconciles (`0x5afa42`/`0x5afd01`), after `UI_Init` has
 /// returned. Either way a `VARIABLES_LOADED` handler sees the boot chat colours, not the file's.
 pub(crate) fn finish_ui_load_with(
diff --git a/crates/benilla-app/src/ui_script/manifest.rs b/crates/benilla-app/src/ui_script/manifest.rs
index 269d5f59..3a1da8b8 100644
--- a/crates/benilla-app/src/ui_script/manifest.rs
+++ b/crates/benilla-app/src/ui_script/manifest.rs
@@ -68,13 +68,13 @@ pub(super) fn apply_buff_durations(script: &UiScript) -> Result<(), String> {
         .map_err(|e| e.to_string())
 }
 
-/// What a screen-size change re-runs, from `extract::tick_script`'s resize arm: anchors follow the
-/// screen, but not a size or seat computed from the old one. The managed pass re-wraps the open
-/// bags, whose columns `updateContainerFrameAnchors` lays out by `GetScreenHeight()`.
+/// What a screen-size or UI-scale change re-runs, from `extract::tick_script`: anchors follow the
+/// screen, but not a size or seat computed from the old `GetScreenHeight()`. The managed pass
+/// re-wraps the open bags, whose columns `updateContainerFrameAnchors` lays out by it.
 /// Deviation: [`FULLSCREEN_QUADS_RESEAT`] re-sizes the full-screen quads, which the stock files
-/// size only in their OnLoads, because a resize or `uiScale` change here keeps the loaded UI and
-/// the blackout would stop short of the new screen. Host-side, not in the layer: it adapts the
-/// engine's resizable window, and changes nothing the stock UI does at a fixed size.
+/// size only in their OnLoads, because a resize here keeps the loaded UI and the blackout would
+/// stop short of the new screen. Host-side, not in the layer: it adapts the engine's resizable
+/// window, and changes nothing the stock UI does at a fixed size.
 pub(super) fn on_screen_resized(script: &UiScript) {
     let _ = script.run("if UIParent_ManageFramePositions then UIParent_ManageFramePositions() end");
     if let Err(e) = script.run(FULLSCREEN_QUADS_RESEAT) {
@@ -85,11 +85,14 @@ pub(super) fn on_screen_resized(script: &UiScript) {
 /// The sizing arithmetic of `WorldMapFrame_OnLoad` (`WorldMapFrame.lua:19-28`) and
 /// `CinematicFrame_OnLoad` (`CinematicFrame.lua:6-21`), each existence-guarded: the glue screens
 /// have neither. Below 4:3 the bars go back to `CinematicFrame.xml`'s declared 1024 x 128, where
-/// the stock OnLoad leaves them.
+/// the stock OnLoad leaves them. The OnLoads read the screen root's size, `UIParent` being still at
+/// scale 1 then, and their frames hang off the root, so this re-reads the root:
+/// `GetScreenWidth()` times `UIParent`'s scale.
 const FULLSCREEN_QUADS_RESEAT: &str = r#"
+local rootScale = UIParent and UIParent:GetEffectiveScale() or 1
 if BlackoutWorld then
-    local width = GetScreenWidth()
-    local height = GetScreenHeight()
+    local width = GetScreenWidth() * rootScale
+    local height = GetScreenHeight() * rootScale
     if ( width / height < 4 / 3 ) then
         width = width * 1.25
         height = height * 1.25
@@ -98,8 +101,8 @@ if BlackoutWorld then
     BlackoutWorld:SetHeight( height )
 end
 if UpperBlackBar and LowerBlackBar then
-    local width = GetScreenWidth()
-    local height = GetScreenHeight()
+    local width = GetScreenWidth() * rootScale
+    local height = GetScreenHeight() * rootScale
     local barWidth, blackBarHeight = 1024, 128
     if ( width / height > 4 / 3 ) then
         local desiredHeight = width / 2
diff --git a/crates/benilla-app/src/ui_script/mod.rs b/crates/benilla-app/src/ui_script/mod.rs
index 05383a58..2b01b917 100644
--- a/crates/benilla-app/src/ui_script/mod.rs
+++ b/crates/benilla-app/src/ui_script/mod.rs
@@ -1,8 +1,9 @@
 //! The UI-engine bridge: hosts [`benilla_ui::script::UiScript`] and feeds its
 //! [`extract`](benilla_ui::script::UiScript::extract) output into the quad pass
 //! ([`crate::ui_pass::UiQuads`]) every frame. The script side is WoW UI space (y-up, origin
-//! bottom-left, a screen `768/uiScale` units tall); [`seam_scale`] carries quads ×s out and the
-//! mouse ÷s in, and extraction flips to y-down window px.
+//! bottom-left, a screen root 768 units tall at scale 1); [`seam_scale`] carries quads ×s out and
+//! the mouse ÷s in, and extraction flips to y-down window px. The UI scale is `UIParent`'s own
+//! frame scale inside the VM ([`UiScaleCvar`]), never part of the seam.
 
 use bevy::prelude::*;
 
@@ -199,8 +200,10 @@ pub(crate) fn run_or_warn(script: &benilla_ui::script::UiScript, chunk: &str) {
     }
 }
 
-/// The reference's `uiScale` CVar: the VM's screen is `768/uiScale` units tall, so
-/// `uiScale = 768/screenH` is pixel-perfect. Tests pin the `Default` 1.0.
+/// The reference's `uiScale` CVar, which the VM makes `UIParent`'s own scale
+/// ([`UiScript::set_ui_scale`]): the screen root stays 768 units tall, so `uiScale = 768/screenH`
+/// is pixel-perfect inside `UIParent`, and a frame outside it is not scaled. Tests pin the
+/// `Default` 1.0.
 #[derive(Resource)]
 pub(crate) struct UiScaleCvar(pub(crate) f32);
 
@@ -213,8 +216,17 @@ impl Default for UiScaleCvar {
 /// The shipped `uiScale`. Deviation: a flat 0.9, because 1.0 reads oversized. With `useUiScale`
 /// off, its default (`0x8430c0`), the reference sets `max(768/H, 0.9)` above 768 px tall and 1.0
 /// at or below (`0x492f70`, on a mode set and from `0x4908ad`), so the two agree from ~853 px up.
+/// benilla never reads `useUiScale`: this CVar always applies to `UIParent` alone, as with it on.
+/// A change goes through the CVar callback (`0x490770`: the narrow-aspect cap, the 0.64 floor);
+/// the load and a display change through the display handler's ON leg (`0x492e90`: the cap, and
+/// below 0.64 the automatic scale `0x492f70` instead of the floor).
 pub(crate) const DEFAULT_UI_SCALE: f32 = 0.9;
 
+/// The display the reference's automatic UI scale last ran for (`0x492f70`'s `[0xb4e304]` and
+/// `[0xb4e308]`), which outlives every UI: the display handler skips a display it already ran for.
+#[derive(Resource, Default)]
+pub(crate) struct UiAutoScaleCache(pub(crate) Option<(u32, u32)>);
+
 /// `WOW_UI_SCALE=` if set, clamped to the dial's range, else [`DEFAULT_UI_SCALE`].
 fn default_ui_scale() -> f32 {
     std::env::var("WOW_UI_SCALE")
@@ -224,16 +236,24 @@ fn default_ui_scale() -> f32 {
         .unwrap_or(DEFAULT_UI_SCALE)
 }
 
-/// The seam scale `s`, window px per UI unit (`windowH/768 × uiScale`), used at every crossing of
-/// the VM boundary; identity for a degenerate window (h ≤ 0, before winit).
-pub(crate) fn seam_scale(window_h: f32, ui_scale: f32) -> f32 {
+/// The seam scale `s`, window px per screen-root unit (`windowH/768`: the root is 768 units tall at
+/// every aspect, `0x41ad10`), used at every crossing of the VM boundary; identity for a degenerate
+/// window (h ≤ 0, before winit). The UI scale is not in it: it is `UIParent`'s, inside the VM.
+pub(crate) fn seam_scale(window_h: f32) -> f32 {
     if window_h > 0.0 {
-        window_h / 768.0 * ui_scale
+        window_h / 768.0
     } else {
         1.0
     }
 }
 
+/// A window cursor (logical px, y-down from the top left) in the VM's root units, y up: what the
+/// pointer feed hands the engine and `GetCursorPosition` answers (`0x48b820`, no scale divided out).
+pub(crate) fn window_to_ui(window_h: f32, cursor: Vec2) -> Vec2 {
+    let s = seam_scale(window_h);
+    Vec2::new(cursor.x / s, (window_h - cursor.y) / s)
+}
+
 /// The Lua UI host (a `NonSend` resource: an mlua VM is `!Send`) and its per-frame passes.
 pub(crate) struct UiScriptPlugin;
 
@@ -263,6 +283,7 @@ impl Plugin for UiScriptPlugin {
         // The quit root runs in `Last`: the close button's `AppExit` is written in `PostUpdate`.
         crate::shutdown::on_app_exit(app, shutdown_on_exit.into_configs());
         app.insert_resource(UiScaleCvar(default_ui_scale()))
+            .init_resource::<UiAutoScaleCache>()
             .init_resource::<UiFrameCost>()
             .init_resource::<crate::bindings::WheelNotches>()
             .init_resource::<UiCostWanted>()
@@ -706,6 +727,9 @@ mod chat_resize_tests;
 #[cfg(test)]
 mod dropdown_tests;
 
+#[cfg(test)]
+mod ui_scale_tests;
+
 #[cfg(test)]
 mod action_bar_tests;
 
@@ -986,19 +1010,26 @@ mod world_map_tests;
 
 #[cfg(test)]
 mod seam_scale_tests {
-    use super::seam_scale;
+    use super::{seam_scale, window_to_ui};
+    use bevy::math::Vec2;
 
     #[test]
-    fn seam_scale_is_the_768_base_times_the_dial() {
+    fn seam_scale_is_the_768_tall_root() {
         // Identity at the design height, proportional elsewhere.
-        assert_eq!(seam_scale(768.0, 1.0), 1.0);
-        assert_eq!(seam_scale(1536.0, 1.0), 2.0);
-        // The dial multiplies it.
-        assert_eq!(seam_scale(768.0, 0.9), 0.9);
-        // The reference's pixel-perfect setting: uiScale = 768/screenH → 1 px per UI unit.
-        assert!((seam_scale(1080.0, 768.0 / 1080.0) - 1.0).abs() < 1e-6);
+        assert_eq!(seam_scale(768.0), 1.0);
+        assert_eq!(seam_scale(1536.0), 2.0);
         // A degenerate (pre-winit) window is identity, never a division blow-up.
-        assert_eq!(seam_scale(0.0, 0.9), 1.0);
+        assert_eq!(seam_scale(0.0), 1.0);
+    }
+
+    /// `GetCursorPosition` answers root units whatever the dial: the bottom of a 1080-tall window
+    /// is 0 and its top 768, its middle column `768·a/2`.
+    #[test]
+    fn the_cursor_reaches_the_vm_in_root_units() {
+        let at = window_to_ui(1080.0, Vec2::new(960.0, 108.0));
+        assert!((at.x - 960.0 * 768.0 / 1080.0).abs() < 1e-3, "{at}");
+        assert!((at.y - 972.0 * 768.0 / 1080.0).abs() < 1e-3, "{at}");
+        assert_eq!(window_to_ui(1080.0, Vec2::new(0.0, 1080.0)), Vec2::ZERO);
     }
 }
 
diff --git a/crates/benilla-app/src/ui_script/ui_scale_tests.rs b/crates/benilla-app/src/ui_script/ui_scale_tests.rs
new file mode 100644
index 00000000..f38e9942
--- /dev/null
+++ b/crates/benilla-app/src/ui_script/ui_scale_tests.rs
@@ -0,0 +1,272 @@
+//! The UI scale through the real UI pass: `uiScale` is `UIParent`'s own frame scale (`0x494550`
+//! calls `0x76ac10` on the frame named `"UIParent"`), and the screen root under it keeps scale 1
+//! and is 768 units tall, so a frame outside `UIParent` is not scaled by it.
+
+use bevy::prelude::*;
+use bevy::window::PrimaryWindow;
+
+use benilla_ui::script::UiScript;
+
+use super::extract::{paint_script, tick_script};
+use crate::portrait::PortraitImages;
+use crate::ui_pass::{UiQuad, UiQuads};
+
+/// A `UIParent` filling the root with a red 100-unit square inside it, 10 units in from its top
+/// left, and a green 100-unit square at the root's bottom left with no parent.
+const TREE: &str = r#"
+    local ui = CreateFrame("Frame", "UIParent")
+    ui:SetPoint("BOTTOMLEFT", 0, 0)
+    ui:SetPoint("TOPRIGHT", 0, 0)
+    local inside = CreateFrame("Frame", "Inside", UIParent)
+    inside:SetPoint("TOPLEFT", 10, -10)
+    inside:SetWidth(100); inside:SetHeight(100)
+    local red = inside:CreateTexture(nil, "ARTWORK")
+    red:SetTexture(1, 0, 0)
+    red:SetAllPoints()
+    local outside = CreateFrame("Frame", "Outside")
+    outside:SetPoint("BOTTOMLEFT", 0, 0)
+    outside:SetWidth(100); outside:SetHeight(100)
+    local green = outside:CreateTexture(nil, "ARTWORK")
+    green:SetTexture(0, 1, 0)
+    green:SetAllPoints()
+"#;
+
+/// Both halves of the UI pass over [`TREE`] on a `w`×`h` window, the dial at `ui_scale`.
+fn app(w: u32, h: u32, ui_scale: f32) -> App {
+    let script = UiScript::new().unwrap();
+    script.run(TREE).unwrap();
+    let mut app = App::new();
+    app.insert_non_send_resource(script);
+    app.init_resource::<UiQuads>();
+    app.init_resource::<super::UiPassState>();
+    app.init_resource::<Assets<Image>>();
+    app.init_resource::<PortraitImages>();
+    app.init_resource::<crate::portrait::BoothPanes>();
+    app.init_resource::<crate::ui_models::UiModelTiles>();
+    app.init_resource::<crate::minimap::MinimapWidget>();
+    app.init_resource::<super::UiFrameCost>();
+    app.init_resource::<super::UiCostWanted>();
+    app.init_resource::<Time>();
+    app.init_resource::<Time<Real>>();
+    app.init_resource::<super::UiClock>();
+    app.insert_resource(super::UiScaleCvar(ui_scale));
+    app.world_mut().spawn((
+        Window {
+            resolution: UVec2::new(w, h).into(),
+            ..default()
+        },
+        PrimaryWindow,
+    ));
+    app.add_systems(Update, (tick_script, paint_script).chain());
+    app.update();
+    app
+}
+
+fn eval(app: &App, chunk: &str) -> f64 {
+    app.world()
+        .non_send_resource::<UiScript>()
+        .eval::<f64>(chunk)
+        .unwrap()
+}
+
+/// The window-px rect of the quad tinted `rgb`, y-down.
+fn quad(app: &App, rgb: [f32; 3]) -> Rect {
+    let quads = &app.world().resource::<UiQuads>().quads;
+    let q: &UiQuad = quads
+        .iter()
+        .find(|q| q.color[..3] == rgb)
+        .expect("the marker quad extracted");
+    q.rect
+}
+
+fn close(a: f32, b: f32) -> bool {
+    (a - b).abs() < 1e-3
+}
+
+fn rect_close(got: Rect, want: Rect) -> bool {
+    close(got.min.x, want.min.x)
+        && close(got.min.y, want.min.y)
+        && close(got.max.x, want.max.x)
+        && close(got.max.y, want.max.y)
+}
+
+/// `UIParent:GetScale()` and `GetEffectiveScale()` answer the UI scale: it is `UIParent`'s own
+/// scale, set through the worker Lua's `SetScale` reaches (`0x494550` → `0x76ac10`).
+#[test]
+fn uiparent_answers_the_ui_scale() {
+    let app = app(1024, 768, 0.9);
+    assert!(close(eval(&app, "return UIParent:GetScale()") as f32, 0.9));
+    assert!(close(
+        eval(&app, "return UIParent:GetEffectiveScale()") as f32,
+        0.9
+    ));
+    assert!(close(
+        eval(&app, "return Inside:GetEffectiveScale()") as f32,
+        0.9
+    ));
+    assert_eq!(eval(&app, "return Outside:GetEffectiveScale()"), 1.0);
+}
+
+/// `GetScreenWidth`/`GetScreenHeight` (`0x48b480`/`0x48b4d0`) divide the 768-tall root by
+/// `UIParent`'s scale (`0x494590`), so they answer in `UIParent`'s units.
+#[test]
+fn the_screen_size_answers_in_uiparent_units() {
+    let app = app(1024, 768, 0.9);
+    assert!(close(
+        eval(&app, "return GetScreenHeight()") as f32,
+        768.0 / 0.9
+    ));
+    assert!(close(
+        eval(&app, "return GetScreenWidth()") as f32,
+        1024.0 / 0.9
+    ));
+}
+
+/// A frame with no parent hangs off the root, which keeps scale 1: one unit is `windowH/768` px
+/// whatever the dial says.
+#[test]
+fn a_parentless_frame_is_not_scaled_by_the_ui_scale() {
+    let app = app(1280, 1024, 0.9);
+    let s = 1024.0 / 768.0;
+    let got = quad(&app, [0.0, 1.0, 0.0]);
+    assert!(
+        rect_close(got, Rect::new(0.0, 1024.0 - 100.0 * s, 100.0 * s, 1024.0)),
+        "got {got:?}"
+    );
+}
+
+/// Inside `UIParent` nothing moves: the dial scales the subtree exactly as it scaled the seam.
+#[test]
+fn a_frame_inside_uiparent_lands_where_the_dial_put_it() {
+    let app = app(1280, 1024, 0.9);
+    let s = 1024.0 / 768.0 * 0.9;
+    let got = quad(&app, [1.0, 0.0, 0.0]);
+    assert!(
+        rect_close(got, Rect::new(10.0 * s, 10.0 * s, 110.0 * s, 110.0 * s)),
+        "got {got:?}"
+    );
+}
+
+/// Whether `frame` is `UIParent` or hangs below it.
+fn under_ui_parent(s: &UiScript, frame: benilla_ui::widget::FrameHandle) -> bool {
+    let mut at = Some(frame);
+    while let Some(h) = at {
+        if s.frame_name(h).as_deref() == Some("UIParent") {
+            return true;
+        }
+        at = s.frame_parent(h);
+    }
+    false
+}
+
+/// The whole stock interface, every frame shown: scaling `UIParent` by `S` in the 768-tall root
+/// must place every quad of its subtree, and every hit, exactly where enlarging the root by `1/S`
+/// with `UIParent` at scale 1 placed them, the seam having been the old home of the UI scale. A
+/// frame-local length the engine forgets to scale (a border, an inset, a thumb) shows up here.
+#[test]
+fn the_stock_interface_inside_uiparent_is_unmoved_by_where_the_scale_lives() {
+    let _data = benilla_formats::wow_data_or_skip!();
+    const S: f32 = 0.9;
+    let (w, h) = (768.0 * 16.0 / 9.0, 768.0);
+    let mut script = UiScript::new().expect("VM");
+    script.set_screen_size(w, h);
+    let failures = super::load_default_ui(&script);
+    assert!(
+        failures.is_empty(),
+        "default UI failed to load: {failures:?}"
+    );
+    // Every frame shown, its parents first, so the most geometry the stock files declare draws.
+    script
+        .run(
+            r#"
+            local f = EnumerateFrames()
+            while f do
+                pcall(f.Show, f)
+                f = EnumerateFrames(f)
+            end
+            "#,
+        )
+        .unwrap();
+    let _ = script.take_errors();
+
+    // The old home: a root `1/S` larger, `UIParent` at scale 1.
+    script.set_screen_size(w / S, h / S);
+    script.run("UIParent:SetScale(1)").unwrap();
+    script.resolve();
+    let old = script.extract();
+    let grid: Vec<(f32, f32)> = (0..=40)
+        .flat_map(|i| (0..=24).map(move |j| (w * i as f32 / 40.0, h * j as f32 / 24.0)))
+        .collect();
+    let old_hits: Vec<_> = grid
+        .iter()
+        .map(|&(x, y)| script.hit_test_frame(x / S, y / S))
+        .collect();
+
+    // The reference's: a 768-tall root, `UIParent` at scale `S`.
+    script.set_screen_size(w, h);
+    assert!(script.set_ui_scale(S));
+    script.resolve();
+    let new = script.extract();
+    let new_hits: Vec<_> = grid
+        .iter()
+        .map(|&(x, y)| script.hit_test_frame(x, y))
+        .collect();
+
+    assert_eq!(old.len(), new.len(), "the same quads draw");
+    let close = |a: f32, b: f32| (a - b).abs() < 0.02;
+    let mut moved = Vec::new();
+    for (a, b) in old.iter().zip(&new) {
+        assert_eq!(a.target, b.target, "the same paint order");
+        let Some(frame) = script.target_frame(b.target) else {
+            continue;
+        };
+        if !under_ui_parent(&script, frame) {
+            continue;
+        }
+        let same_rect = match (a.rect, b.rect) {
+            (Some(ra), Some(rb)) => {
+                close(ra.left * S, rb.left)
+                    && close(ra.right * S, rb.right)
+                    && close(ra.top * S, rb.top)
+                    && close(ra.bottom * S, rb.bottom)
+            }
+            (None, None) => true,
+            _ => false,
+        };
+        if !same_rect || !close(a.scale * S, b.scale) {
+            moved.push(format!(
+                "{:?} {:?}: {:?}×{S} vs {:?}",
+                script.target_owner_name(b.target),
+                std::mem::discriminant(&b.content),
+                a.rect,
+                b.rect
+            ));
+        }
+    }
+    assert!(
+        moved.is_empty(),
+        "{} quads inside UIParent moved, first: {:#?}",
+        moved.len(),
+        &moved[..moved.len().min(20)]
+    );
+
+    let inside = |hit: Option<benilla_ui::widget::FrameHandle>| {
+        hit.is_none_or(|h| under_ui_parent(&script, h))
+    };
+    let mut rehit = Vec::new();
+    for ((&at, a), b) in grid.iter().zip(&old_hits).zip(&new_hits) {
+        if inside(*a) && inside(*b) && a != b {
+            rehit.push(format!(
+                "{at:?}: {:?} vs {:?}",
+                a.and_then(|h| script.frame_name(h)),
+                b.and_then(|h| script.frame_name(h))
+            ));
+        }
+    }
+    assert!(
+        rehit.is_empty(),
+        "{} hits inside UIParent changed, first: {:#?}",
+        rehit.len(),
+        &rehit[..rehit.len().min(20)]
+    );
+}
diff --git a/crates/benilla-app/src/ui_text/mod.rs b/crates/benilla-app/src/ui_text/mod.rs
index ede81d20..4eaff0dd 100644
--- a/crates/benilla-app/src/ui_text/mod.rs
+++ b/crates/benilla-app/src/ui_text/mod.rs
@@ -52,11 +52,12 @@ pub(crate) fn fontstring_em(height: Option<f32>) -> Option<f32> {
     height.map(|h| h.min(FONTSTRING_EM_CAP))
 }
 
-/// The drawn pixel height of a UI FontString times the seam scale `s = windowH/768 × uiScale`
-/// (`crate::ui_script::seam_scale`), under the reference's two size regimes (getter `0x7727b0`):
-/// one-to-one, the default, draws the raster size ([`FONTSTRING_EM_CAP`] applied in units), and a
-/// `SetTextHeight` size (`text_height`) draws uncapped, the reference magnifying the raster to it
-/// (`0x771600` clears bit `0x200`; the drawn em is `round(size/768·deviceH)`).
+/// The drawn pixel height of a UI FontString at `s`, the seam scale `windowH/768`
+/// (`crate::ui_script::seam_scale`) times the owner's effective scale, the UI scale included,
+/// under the reference's two size regimes (getter `0x7727b0`): one-to-one, the default, draws the
+/// raster size ([`FONTSTRING_EM_CAP`] applied in units), and a `SetTextHeight` size
+/// (`text_height`) draws uncapped, the reference magnifying the raster to it (`0x771600` clears bit
+/// `0x200`; the drawn em is `round(size/768·deviceH)`).
 pub(crate) fn drawn_px(font_height: Option<f32>, text_height: Option<f32>, s: f32) -> Option<f32> {
     match text_height {
         Some(t) => Some(t * s),
diff --git a/crates/benilla-app/src/ui_tooltip/mod.rs b/crates/benilla-app/src/ui_tooltip/mod.rs
index 1293341c..16df94a9 100644
--- a/crates/benilla-app/src/ui_tooltip/mod.rs
+++ b/crates/benilla-app/src/ui_tooltip/mod.rs
@@ -114,8 +114,6 @@ fn drive_mouseover_tooltip(
     go_inputs: crate::target::lock::GoLockInputs,
     // The known-spell set the resolver's SKILL arm scans.
     player_actions: Res<crate::ui_action::PlayerActions>,
-    // The cursor seat crosses the VM seam: the anchor below is UI units, not px.
-    ui_scale: Res<crate::ui_script::UiScaleCvar>,
     mut memo: HoverMemo,
     // `ChrClasses.dbc` field 16, `UnitHasRelicSlot`'s input, and the form table the creature type
     // reads.
@@ -229,15 +227,17 @@ fn drive_mouseover_tooltip(
                 .templates
                 .get(guid)
                 .is_some_and(|t| t.floating_tooltip);
-        // Window px to the VM's y-up UI units, as the input seam converts.
+        // Window px to the VM's y-up root units, as the input seam converts.
         let cursor_ui = cursor_seated
             .then(|| {
                 window.iter().next().and_then(|w| {
-                    let s = crate::ui_script::seam_scale(w.height(), ui_scale.0);
                     // The hover probe's aim stands in for a missing cursor; a real pointer wins.
                     w.cursor_position()
                         .or_else(crate::target::hover_probe_point)
-                        .map(|c| (c.x / s, (w.height() - c.y) / s))
+                        .map(|c| {
+                            let at = crate::ui_script::window_to_ui(w.height(), c);
+                            (at.x, at.y)
+                        })
                 })
             })
             .flatten();
diff --git a/crates/benilla-app/src/ui_tooltip/tests.rs b/crates/benilla-app/src/ui_tooltip/tests.rs
index 41906606..8d9534e4 100644
--- a/crates/benilla-app/src/ui_tooltip/tests.rs
+++ b/crates/benilla-app/src/ui_tooltip/tests.rs
@@ -882,7 +882,6 @@ fn mouseover_app() -> (App, Entity, Entity) {
     let mut app = App::new();
     let (tx, _rx) = crossbeam_channel::unbounded();
     app.insert_resource(NetCommands(tx))
-        .insert_resource(crate::ui_script::UiScaleCvar(1.0))
         .init_resource::<Hovered>()
         .init_resource::<HoveredObject>()
         .init_resource::<NameCache>()
diff --git a/crates/benilla-app/src/ui_world_map.rs b/crates/benilla-app/src/ui_world_map.rs
index 63a6e28b..7782f0f8 100644
--- a/crates/benilla-app/src/ui_world_map.rs
+++ b/crates/benilla-app/src/ui_world_map.rs
@@ -710,7 +710,6 @@ fn dev_map_jump(
     buttons: Res<ButtonInput<MouseButton>>,
     keys: Res<ButtonInput<KeyCode>>,
     windows: Query<&Window, With<bevy::window::PrimaryWindow>>,
-    ui_scale: Res<crate::ui_script::UiScaleCvar>,
     script: Option<NonSendMut<UiScript>>,
     data: Option<Res<WorldMapUiData>>,
     net: Res<crate::net::NetCommands>,
@@ -729,10 +728,9 @@ fn dev_map_jump(
     let Some(cursor) = window.cursor_position() else {
         return;
     };
-    // Window px (y-down) to the VM's y-up 768-unit space, as the pointer feed converts them.
-    let s = crate::ui_script::seam_scale(window.height(), ui_scale.0);
-    let Some((u, v)) = script.world_map_uv_at(cursor.x / s, (window.height() - cursor.y) / s)
-    else {
+    // Window px (y-down) to the VM's y-up root units, as the pointer feed converts them.
+    let at = crate::ui_script::window_to_ui(window.height(), cursor);
+    let Some((u, v)) = script.world_map_uv_at(at.x, at.y) else {
         return;
     };
     let (c, z, direct) = script.world_map_selection();
diff --git a/crates/benilla-app/src/vplates.rs b/crates/benilla-app/src/vplates.rs
index 7608acca..057bac0c 100644
--- a/crates/benilla-app/src/vplates.rs
+++ b/crates/benilla-app/src/vplates.rs
@@ -308,7 +308,6 @@ fn drive_vplates(
     net_commands: Res<NetCommands>,
     // `None` in a run with no UI VM.
     script: Option<NonSendMut<benilla_ui::script::UiScript>>,
-    ui_scale: Res<crate::ui_script::UiScaleCvar>,
     anchor_q: (
         Query<&BoneAttach>,
         Query<&benilla_world::rig_anim::RigPose>,
@@ -374,10 +373,8 @@ fn drive_vplates(
 
     let (pw, ph) = (gx(PLATE_W), gx(PLATE_H));
     let scale = window.map_or(1.0, |w| w.scale_factor());
-    // Everything below is in window px, divided by this once for the widget layer's units.
-    let seam = window.map_or(1.0, |w| {
-        crate::ui_script::seam_scale(w.height(), ui_scale.0)
-    });
+    // Everything below is in window px, divided by this once for the widget layer's root units.
+    let seam = window.map_or(1.0, |w| crate::ui_script::seam_scale(w.height()));
     let mut states: Vec<PlateState> = Vec::new();
 
     // Plates seat in squared-distance order from the gx point (0.4, 0.3), Y mirrored from the
@@ -541,9 +538,8 @@ fn drive_vplates(
         }
         // ── The plate's state, handed to the widget layer ──
         //
-        // The reference's plates sit outside the uiScale cascade, but benilla folds uiScale into
-        // one global seam, so dividing by it here keeps plate pixels uiScale-blind.
-        // The raid-target index is 1-based here, 0-based for the atlas cell.
+        // The plates hang off `WorldFrame`, outside `UIParent`'s scale, so root units are their
+        // own. The raid-target index is 1-based here, 0-based for the atlas cell.
         let mark = group.raid_target_index(guid.0);
         let x_units = (plate.min.x + plate.max.x) * 0.5 / seam;
         let y_units = (viewport.y - plate.min.y) / seam;
diff --git a/crates/benilla-ui/src/script/backdrop.rs b/crates/benilla-ui/src/script/backdrop.rs
index 41c94743..78ab70d8 100644
--- a/crates/benilla-ui/src/script/backdrop.rs
+++ b/crates/benilla-ui/src/script/backdrop.rs
@@ -123,18 +123,25 @@ 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`). Geometry `0x77e8d0`, UVs `0x77f0c0`.
-pub fn pieces(frame: Rect, bd: &Backdrop) -> Vec<BackdropPiece> {
+/// The pieces are textures anchored and sized in the frame's own units, so the layout multiplies
+/// their geometry by the frame's effective `scale` (`0x76ac90`), as it does any region's. The
+/// texcoord repeats are not: `0x77f0c0` divides the scaled rect by the stored, unscaled
+/// `edgeSize` and `tileSize` (`0x77f101 fdiv [esi+0x48]`, `0x77f195`), so a scaled frame's edge
+/// and background repeat the art more or less often than at scale 1.
+pub fn pieces(frame: Rect, bd: &Backdrop, scale: f32) -> Vec<BackdropPiece> {
     let mut out = Vec::with_capacity(9);
-    let e = bd.edge_size;
+    let e = bd.edge_size * scale;
+    // The texcoord divisor, unscaled.
+    let e_uv = bd.edge_size;
     let (l, r, b, t) = (frame.left, frame.right, frame.bottom, frame.top);
 
     // ── The background piece ──
     if bd.has_bg() {
         let (il, ir, it, ib) = (
-            bd.insets.left,
-            bd.insets.right,
-            bd.insets.top,
-            bd.insets.bottom,
+            bd.insets.left * scale,
+            bd.insets.right * scale,
+            bd.insets.top * scale,
+            bd.insets.bottom * scale,
         );
         // The four anchors, y-up. Bottom-right takes the top inset, as the reference does
         // (`0x77e9ae` loads `+0x50`, top, not `+0x54`); invisible when the two are equal.
@@ -146,7 +153,11 @@ pub fn pieces(frame: Rect, bd: &Backdrop) -> Vec<BackdropPiece> {
         ];
         // Untiled, no `SetTexCoord` runs and the background stretches over `[0,1]` (`0x77f0c0`).
         let uvs = if bd.tile {
-            let period = if bd.tile_size != 0.0 { bd.tile_size } else { e };
+            let period = if bd.tile_size != 0.0 {
+                bd.tile_size
+            } else {
+                e_uv
+            };
             let bg_w = (r - ir) - (l + il);
             let bg_h = (t - it) - (b + ib);
             let (wt, ht) = (bg_w / period, bg_h / period);
@@ -165,8 +176,8 @@ pub fn pieces(frame: Rect, bd: &Backdrop) -> Vec<BackdropPiece> {
     // ── The 8 border pieces ──
     if bd.has_border() {
         // Edge strips tile `run` periods between the corners, 0 below two edges (`0x77f0c0`).
-        let w_run = ((r - l) / e - 2.0).max(0.0);
-        let h_run = ((t - b) / e - 2.0).max(0.0);
+        let w_run = ((r - l) / e_uv - 2.0).max(0.0);
+        let h_run = ((t - b) / e_uv - 2.0).max(0.0);
 
         let mut edge = |x0: f32, x1: f32, y0: f32, y1: f32, uvs: [[f32; 2]; 4]| {
             out.push(BackdropPiece {
@@ -311,7 +322,7 @@ mod tests {
     fn piece_geometry_200x100_edge16_inset5() {
         let frame = Rect::new(0.0, 0.0, 100.0, 200.0);
         let bd = tooltip_backdrop(16.0, 5.0);
-        let ps = pieces(frame, &bd);
+        let ps = pieces(frame, &bd, 1.0);
         assert_eq!(ps.len(), 9);
 
         // Symmetric insets hide the bottom-right quirk.
@@ -365,7 +376,7 @@ mod tests {
             },
             ..tooltip_backdrop(16.0, 0.0)
         };
-        let bg = pieces(frame, &bd)[0];
+        let bg = pieces(frame, &bd, 1.0)[0];
         assert_eq!(bg.corners[3], [3.0, 9.0]);
         // BR takes the top inset, 7, not the bottom's 9.
         assert_eq!(bg.corners[2], [196.0, 7.0]);
@@ -378,7 +389,7 @@ mod tests {
         // 20/16 - 2 = -0.75.
         let frame = Rect::new(0.0, 0.0, 20.0, 20.0);
         let bd = tooltip_backdrop(16.0, 5.0);
-        let ps = pieces(frame, &bd);
+        let ps = pieces(frame, &bd, 1.0);
         let left = ps[1]; // LEFT edge
         assert_eq!(left.uvs[3][1], 0.0, "h_run clamped to 0"); // BL v
         let top = ps[3]; // TOP edge
@@ -388,16 +399,34 @@ mod tests {
     #[test]
     fn presence_gates_pieces() {
         let frame = Rect::new(0.0, 0.0, 100.0, 100.0);
-        assert!(pieces(frame, &Backdrop::default()).is_empty());
+        assert!(pieces(frame, &Backdrop::default(), 1.0).is_empty());
         let bg_only = Backdrop {
             bg_file: Some("bg".into()),
             ..Default::default()
         };
-        assert_eq!(pieces(frame, &bg_only).len(), 1);
+        assert_eq!(pieces(frame, &bg_only, 1.0).len(), 1);
         let border_only = Backdrop {
             edge_file: Some("edge".into()),
             ..Default::default()
         };
-        assert_eq!(pieces(frame, &border_only).len(), 8);
+        assert_eq!(pieces(frame, &border_only, 1.0).len(), 8);
+    }
+
+    /// A half-scale frame: the geometry halves, but `0x77f0c0` divides the scaled rect by the
+    /// unscaled sizes, so a 100-wide (on screen) edge repeats `100/16 - 2` times and the 96-wide
+    /// background `96/16` times.
+    #[test]
+    fn a_scaled_frames_texcoords_repeat_by_the_unscaled_sizes() {
+        let frame = Rect::new(0.0, 0.0, 50.0, 100.0);
+        let bd = tooltip_backdrop(16.0, 4.0);
+        let ps = pieces(frame, &bd, 0.5);
+        let bg = ps[0];
+        assert_eq!(bg.corners[0], [2.0, 48.0], "inset 4 units, 2 on screen");
+        assert_eq!(bg.uvs[2], [6.0, 46.0 / 16.0]);
+        // TOP, slice 2, rotated: `u` holds the run.
+        let top = ps[3];
+        assert_eq!(top.corners[0][1], 50.0);
+        assert_eq!(top.corners[2][1], 42.0, "8 thick on screen");
+        assert_eq!(top.uvs[0][1], 100.0 / 16.0 - 2.0);
     }
 }
diff --git a/crates/benilla-ui/src/script/colorselect.rs b/crates/benilla-ui/src/script/colorselect.rs
index 8217a82b..71bbd2e0 100644
--- a/crates/benilla-ui/src/script/colorselect.rs
+++ b/crates/benilla-ui/src/script/colorselect.rs
@@ -798,6 +798,20 @@ mod tests {
         }
     }
 
+    /// The markers are textures of the picker, sized in its units, so a half-scale picker draws
+    /// them at half size: 5 and 24 on screen.
+    #[test]
+    fn the_markers_scale_with_the_picker() {
+        let mut s = picker();
+        s.run("TestPicker:SetScale(0.5); TestPicker:SetColorRGB(1, 0, 0)")
+            .unwrap();
+        s.resolve();
+        let wheel = marker_rect(&s, 5.0).expect("the wheel marker, 10 units at half scale");
+        assert!((wheel.top - wheel.bottom - 5.0).abs() < 0.01, "{wheel:?}");
+        let value = marker_rect(&s, 24.0).expect("the value marker, 48 units at half scale");
+        assert!((value.top - value.bottom - 7.0).abs() < 0.01, "{value:?}");
+    }
+
     /// The extracted rect of the marker `width` wide: the two share one BLP and differ by size, 10
     /// for the wheel's and 48 for the strip's.
     fn marker_rect(s: &UiScript, width: f32) -> Option<crate::layout::Rect> {
diff --git a/crates/benilla-ui/src/script/editbox/flush.rs b/crates/benilla-ui/src/script/editbox/flush.rs
index 06427294..87dfbe20 100644
--- a/crates/benilla-ui/src/script/editbox/flush.rs
+++ b/crates/benilla-ui/src/script/editbox/flush.rs
@@ -64,7 +64,7 @@ fn caret(lua: &Lua, h: FrameHandle) -> bool {
     placed
 }
 
-/// `OnCursorChanged(x, y, w, h)` (`0x77de1b`, in UI units via `0x77dd5f`), `x` the caret's advance
+/// `OnCursorChanged(x, y, w, h)` (`0x77de1b`, in the box's own units via `0x77dd5f`), `x` the caret's advance
 /// along its line, `y` minus the row index times the row pitch, `w` the constant 4.0 and `h` the
 /// line height. The arguments are computed only for a box with the script (`0x77dd8c`), from the
 /// box's advance table, which the installed font engine measures here when the text or font
@@ -103,6 +103,14 @@ fn cursor_changed(lua: &Lua, h: FrameHandle) -> bool {
     let Some((x, y, pitch)) = args else {
         return false;
     };
+    // The advance table is in root units (measured at the box's scale, divided by the seam
+    // alone); the handler gets the box's own, the reference dividing by its effective scale
+    // (`0x77db23 fdiv [esi+0x7c]`).
+    let k = {
+        let model = lua.app_data_ref::<Model>().expect("model app_data");
+        crate::script::object::eff_scale(&model, h)
+    };
+    let (x, y, pitch) = (x / k, y / k, pitch / k);
     if let Err(e) = event::fire_widget_handler(
         lua,
         id,
diff --git a/crates/benilla-ui/src/script/editbox/flush_tests.rs b/crates/benilla-ui/src/script/editbox/flush_tests.rs
index 268c7ac7..43fe6c9e 100644
--- a/crates/benilla-ui/src/script/editbox/flush_tests.rs
+++ b/crates/benilla-ui/src/script/editbox/flush_tests.rs
@@ -509,3 +509,49 @@ fn on_cursor_changed_reports_the_first_row_at_plus_zero() {
     );
     assert!(s.errors().is_empty(), "{:?}", s.errors());
 }
+
+/// [`Mono`] as the host answers a scaled box: glyphs 7 and lines 14 in the box's own units, the
+/// table in root units (measured at the box's scale, divided by the seam alone).
+struct ScaledMono;
+
+impl TextMeasure for ScaledMono {
+    fn measure(&mut self, req: &MeasureRequest) -> (f32, f32, f32) {
+        Mono.measure(req)
+    }
+
+    fn editbox_advances(
+        &mut self,
+        req: &EditBoxAdvanceRequest,
+    ) -> Option<(Vec<f32>, Vec<usize>, f32)> {
+        let (cum, rows, pitch) = Mono.editbox_advances(req)?;
+        let k = req.scale;
+        Some((cum.into_iter().map(|a| a * k).collect(), rows, pitch * k))
+    }
+}
+
+/// `OnCursorChanged` answers in the box's own units: the reference divides by its effective scale
+/// (`0x77db23 fdiv [esi+0x7c]`), so a half-scale box reports what a full-scale one does.
+#[test]
+fn on_cursor_changed_answers_in_the_boxs_own_units() {
+    let mut s = script();
+    s.set_text_measurer(Box::new(ScaledMono));
+    logged_box(&mut s);
+    s.run(
+        r#"
+        E:SetScale(0.5)
+        E:SetScript("OnCursorChanged", function()
+            table.insert(LOG, format("cursor@%g,%g,%g", arg1, arg2, arg4))
+        end)
+        E:SetMultiLine(true)
+        E:SetText("abc\nd")
+    "#,
+    )
+    .unwrap();
+    s.tick(0.016);
+    assert_eq!(
+        take_log(&s),
+        "early update cursor@7,-14,14 text:abc\nd late",
+        "one glyph along the second row, a row pitch down, one pitch tall"
+    );
+    assert!(s.errors().is_empty(), "{:?}", s.errors());
+}
diff --git a/crates/benilla-ui/src/script/extract.rs b/crates/benilla-ui/src/script/extract.rs
index a8e6a946..dd55f163 100644
--- a/crates/benilla-ui/src/script/extract.rs
+++ b/crates/benilla-ui/src/script/extract.rs
@@ -130,9 +130,10 @@ impl UiScript {
                         owner_frame.map(|f| &f.kind_state)
                     {
                         if sl.thumb == Some(rh) {
-                            // The thumb's own `CSimpleTexture::GetWidth`/`GetHeight`, as the drag
-                            // reads them (`slider::thumb_extent`), not its authored `<Size>`.
-                            let tsize = super::region::virtual_span(&model, rh);
+                            // The thumb's own `CSimpleTexture::GetWidth`/`GetHeight` at the
+                            // slider's scale, as the drag reads them (`slider::thumb_extent`), not
+                            // its authored `<Size>`.
+                            let tsize = super::region::screen_span(&model, rh);
                             rect = rect
                                 .map(|r| slider::thumb_rect(r, tsize, sl.vertical, sl.fraction()));
                             thumb_fill = true;
@@ -145,7 +146,13 @@ impl UiScript {
                     if let Some(crate::widget::KindState::ColorSelect(cs)) =
                         owner_frame.map(|f| &f.kind_state)
                     {
-                        let tsize = model.region_data.get(&rh).and_then(|d| d.size);
+                        // The markers' authored size, in the picker's units.
+                        let scale = owner_frame.map_or(1.0, |f| f.effective_scale);
+                        let tsize = model
+                            .region_data
+                            .get(&rh)
+                            .and_then(|d| d.size)
+                            .map(|(w, h)| (w * scale, h * scale));
                         if cs.wheel_thumb == Some(rh) {
                             rect = cs
                                 .wheel
diff --git a/crates/benilla-ui/src/script/layout.rs b/crates/benilla-ui/src/script/layout.rs
index cd35cfff..23115462 100644
--- a/crates/benilla-ui/src/script/layout.rs
+++ b/crates/benilla-ui/src/script/layout.rs
@@ -1239,7 +1239,8 @@ impl UiScript {
         let Some(bd) = model.backdrops.get(&fh) else {
             return;
         };
-        for piece in backdrop::pieces(fr, bd) {
+        let scale = crate::script::object::eff_scale(model, fh);
+        for piece in backdrop::pieces(fr, bd, scale) {
             // The piece's screen bounding box: the render is axis-aligned, so the reference's slant
             // under unequal top and bottom insets is not drawn (stock insets are symmetric).
             let xs = piece.corners.map(|c| c[0]);
diff --git a/crates/benilla-ui/src/script/minimap.rs b/crates/benilla-ui/src/script/minimap.rs
index c43a4169..0504afa1 100644
--- a/crates/benilla-ui/src/script/minimap.rs
+++ b/crates/benilla-ui/src/script/minimap.rs
@@ -114,13 +114,16 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     )?;
     m.set(
         "PingLocation",
-        // Centre-relative offsets in UI units, x right and y up, parked for the app to resolve in
-        // the frame it draws the map; one pending click, not one per widget.
+        // Centre-relative offsets in the minimap's own units, x right and y up, which the
+        // reference reads against the widget's own size (`0x4eeca0`); parked in screen units, its
+        // effective scale applied, for the app to resolve in the frame it draws the map. One
+        // pending click, not one per widget.
         lua.create_function(|lua, (this, x, y): (Table, f32, f32)| {
             with_minimap(lua, &this, |_| ())?;
-            lua.app_data_mut::<Model>()
-                .expect("model app_data")
-                .minimap_ping_request = Some((x, y));
+            let h = frame_handle_of(lua, &this)?;
+            let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+            let s = super::object::eff_scale(&model, h);
+            model.minimap_ping_request = Some((x * s, y * s));
             Ok(())
         })?,
     )?;
diff --git a/crates/benilla-ui/src/script/mod.rs b/crates/benilla-ui/src/script/mod.rs
index cb085436..99753ab5 100644
--- a/crates/benilla-ui/src/script/mod.rs
+++ b/crates/benilla-ui/src/script/mod.rs
@@ -130,6 +130,7 @@ mod tooltip_item;
 mod tooltip_spell;
 mod tooltip_unit;
 mod ui_errors;
+mod ui_scale;
 pub use tooltip_unit::TooltipTint;
 mod trade;
 mod tradeskill;
@@ -724,7 +725,8 @@ impl UiScript {
         self.model_mut().minimap_ping = ping;
     }
 
-    /// Drain a `Minimap:PingLocation(x, y)`: centre-relative offsets in UI units, x right, y up.
+    /// Drain a `Minimap:PingLocation(x, y)`: centre-relative offsets in the screen root's units,
+    /// x right, y up.
     pub fn take_minimap_ping_request(&mut self) -> Option<(f32, f32)> {
         self.model_mut().minimap_ping_request.take()
     }
diff --git a/crates/benilla-ui/src/script/model.rs b/crates/benilla-ui/src/script/model.rs
index e3b460a9..1a05d2ea 100644
--- a/crates/benilla-ui/src/script/model.rs
+++ b/crates/benilla-ui/src/script/model.rs
@@ -228,8 +228,11 @@ pub(crate) struct Model {
     pub(crate) diagnostics: super::diagnostics::DiagnosticLog,
     /// Non-fatal warnings for the host, such as a dropped `inherits=` template.
     pub(crate) warnings: Vec<String>,
-    /// The screen-root rect (`[bottom, left, top, right]`), the anchor base for top-level frames.
+    /// The screen-root rect (`[bottom, left, top, right]`), the anchor base for top-level frames:
+    /// 768 tall at scale 1, whatever the UI scale ([`super::ui_scale`]).
     pub(crate) screen: Rect,
+    /// The host's `uiScale`, which [`super::UiScript::apply_ui_scale`] makes `UIParent`'s scale.
+    pub(crate) ui_scale_request: Option<f32>,
 
     /// Each unit token's state as pushed this frame, keyed lowercased because 1.12's resolver
     /// (`0x515970`) matches with `SStrCmpI`: read it only through `unit`, where the fold lives.
@@ -919,8 +922,9 @@ pub(crate) struct Model {
     /// The last cursor position in UI space (logical px, y-up), behind `GetCursorPosition()`.
     pub(crate) cursor_pos: (f32, f32),
 
-    /// A `Minimap:PingLocation(x, y)`, drained the same frame: centre-relative offsets in UI units,
-    /// `GetCursorPosition`'s space, not the window pixels of the app's minimap geometry.
+    /// A `Minimap:PingLocation(x, y)`, drained the same frame: centre-relative offsets in the screen
+    /// root's units, `GetCursorPosition`'s space, not the window pixels of the app's minimap
+    /// geometry.
     pub(crate) minimap_ping_request: Option<(f32, f32)>,
     /// The ping's offsets as fractions of the minimap's side, updated by the app every frame.
     /// `GetPingPosition()` always answers both, from statics never cleared (`0x4eefd0`).
@@ -1106,6 +1110,7 @@ impl Model {
             warnings: Vec::new(),
             // 1024x768 until the host calls `set_screen_size`; y-up `[bottom, left, top, right]`.
             screen: Rect::new(0.0, 0.0, 768.0, 1024.0),
+            ui_scale_request: None,
             units_by_lower: HashMap::new(),
             units_by_guid: HashMap::new(),
             player_auras: Vec::new(),
@@ -1498,6 +1503,19 @@ impl Model {
         id
     }
 
+    /// `CSimpleFrame::SetScale` (`0x76ac10`): store `h`'s own scale, cascade the effective scale
+    /// down its subtree, and re-lay out and re-measure on a change, since the owner's effective
+    /// scale is in every descendant FontString's measure key. Lua `SetScale` and the UI scale
+    /// ([`super::ui_scale`]) both come here, as both reach `0x76ac10` in the reference.
+    pub(crate) fn set_frame_scale(&mut self, h: FrameHandle, scale: f32) {
+        let changed = self.arena.frame(h).is_some_and(|f| f.scale != scale);
+        self.arena.set_scale(h, scale);
+        if changed {
+            self.touch_layout();
+            self.touch_measure_all();
+        }
+    }
+
     /// A layout write that names no node. The resolve's tooltip pre-pass must not call this, or
     /// the gate never closes; a missed call is caught by `WOW_LAYOUT_VERIFY`.
     pub(crate) fn touch_layout(&mut self) {
diff --git a/crates/benilla-ui/src/script/object.rs b/crates/benilla-ui/src/script/object.rs
index efe7cf8c..de67176f 100644
--- a/crates/benilla-ui/src/script/object.rs
+++ b/crates/benilla-ui/src/script/object.rs
@@ -352,19 +352,20 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     let create_frame = lua.create_function(create_frame)?;
     lua.globals().set("CreateFrame", create_frame)?;
 
-    // `GetScreenWidth`/`GetScreenHeight`: the screen root's size in UI units.
+    // `GetScreenWidth`/`GetScreenHeight` (`0x48b480`/`0x48b4d0`): the screen root's size divided by
+    // `UIParent`'s scale (`GetUiScale`, `0x494590`), so they answer in `UIParent`'s units.
     lua.globals().set(
         "GetScreenWidth",
         lua.create_function(|lua, ()| {
             let model = lua.app_data_ref::<Model>().expect("model");
-            Ok(model.screen.width())
+            Ok(model.screen.width() / super::ui_scale::ui_parent_scale(&model))
         })?,
     )?;
     lua.globals().set(
         "GetScreenHeight",
         lua.create_function(|lua, ()| {
             let model = lua.app_data_ref::<Model>().expect("model");
-            Ok(model.screen.height())
+            Ok(model.screen.height() / super::ui_scale::ui_parent_scale(&model))
         })?,
     )?;
 
@@ -396,16 +397,6 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
         })?,
     )?;
 
-    // `GetCursorPosition()`: the last cursor position the host fed, in screen UI units, y up, as
-    // the reference returns it; a caller in a scaled frame divides by its `GetEffectiveScale()`.
-    lua.globals().set(
-        "GetCursorPosition",
-        lua.create_function(|lua, ()| {
-            let model = lua.app_data_ref::<Model>().expect("model");
-            Ok(model.cursor_pos)
-        })?,
-    )?;
-
     // The modifier keys the app feeds each frame before any mouse event
     // ([`UiScript::set_modifiers`]), answered 1 or nil as in 1.12, never a boolean: an addon
     // testing `IsShiftKeyDown() == 1` (`ColorPickerPlus.lua:121`) reads `true` as not held.
diff --git a/crates/benilla-ui/src/script/object/frame_state.rs b/crates/benilla-ui/src/script/object/frame_state.rs
index c54f5e32..ae8f00bc 100644
--- a/crates/benilla-ui/src/script/object/frame_state.rs
+++ b/crates/benilla-ui/src/script/object/frame_state.rs
@@ -414,14 +414,9 @@ pub(super) fn install(lua: &Lua, m: &Table) -> mlua::Result<()> {
         "SetScale",
         lua.create_function(|lua, (this, scale): (Table, f32)| {
             let h = frame_handle_of(lua, &this)?;
-            let mut model = lua.app_data_mut::<Model>().expect("model");
-            let changed = model.arena.frame(h).is_some_and(|f| f.scale != scale);
-            model.arena.set_scale(h, scale);
-            if changed {
-                model.touch_layout();
-                // The owner's effective scale is in every descendant FontString's measure key.
-                model.touch_measure_all();
-            }
+            lua.app_data_mut::<Model>()
+                .expect("model")
+                .set_frame_scale(h, scale);
             Ok(())
         })?,
     )?;
diff --git a/crates/benilla-ui/src/script/object/layout_methods.rs b/crates/benilla-ui/src/script/object/layout_methods.rs
index b646c2fe..89525a82 100644
--- a/crates/benilla-ui/src/script/object/layout_methods.rs
+++ b/crates/benilla-ui/src/script/object/layout_methods.rs
@@ -197,11 +197,9 @@ pub(super) fn install(lua: &Lua, m: &Table) -> mlua::Result<()> {
         })
     })?;
 
-    // GetEffectiveScale(): parent scale times own scale, from a root of 1: `uiScale` is applied at
-    // the raster seam (a screen `768/uiScale` units tall), so every coordinate Lua sees,
-    // `GetCursorPosition()` included, is already in UI units. The reference instead makes
-    // `uiScale` `UIParent`'s own scale (`0x494550` calls `SetScale`), so there
-    // `UIParent:GetEffectiveScale()` answers it.
+    // GetEffectiveScale(): parent scale times own scale (`0x76ac90`), from a root of 1. The UI
+    // scale is `UIParent`'s own (`0x494550`), so `UIParent:GetEffectiveScale()` answers it and a
+    // frame outside `UIParent` does not carry it.
     m.set(
         "GetEffectiveScale",
         lua.create_function(|lua, this: Table| {
diff --git a/crates/benilla-ui/src/script/pointer.rs b/crates/benilla-ui/src/script/pointer.rs
index 3239e0af..4de32da4 100644
--- a/crates/benilla-ui/src/script/pointer.rs
+++ b/crates/benilla-ui/src/script/pointer.rs
@@ -22,8 +22,9 @@ use super::{button, cursor, editbox, event, Model, UiScript};
 /// each release only has to hit the frame.
 pub(super) const DOUBLE_CLICK_SECS: f64 = 0.300;
 
-/// Install `GetCursorPosition()` and `GetMouseFocus()`. The cursor is in UI units, as 1.12
-/// answers it; the engine's y-up UI space is 1:1 logical pixels, so no scale factor applies.
+/// Install `GetCursorPosition()` and `GetMouseFocus()`. The cursor (`0x48b820`) answers in the
+/// screen root's units, y up, with no scale divided out: a caller divides by its frame's
+/// `GetEffectiveScale()`, which carries the UI scale inside `UIParent`.
 pub(super) fn install(lua: &mlua::Lua) -> mlua::Result<()> {
     lua.globals().set(
         "GetCursorPosition",
@@ -107,7 +108,7 @@ impl UiScript {
                 // tested, so the reticle is placed through it.
                 && !model.nameplates.vetoes(fh)
                 && model.resolved.get(&fh).is_some_and(|r| {
-                    point_in_rect(inset_rect(*r, model.arena.hit_rect_insets(fh)), x, y)
+                    point_in_rect(hit_rect(&model, fh, *r), x, y)
                 })
                 && effective_clip(&model, &scroll_sources, fh)
                     .is_none_or(|c| point_in_rect(c, x, y))
@@ -124,9 +125,10 @@ impl UiScript {
             // The wheel flag alone: the wheel index is separate from the mouse's, so the wheel
             // passes a frame that only takes the mouse, as a scroll pane's chrome does.
             model.arena.is_mouse_wheel_enabled(fh)
-                && model.resolved.get(&fh).is_some_and(|r| {
-                    point_in_rect(inset_rect(*r, model.arena.hit_rect_insets(fh)), x, y)
-                })
+                && model
+                    .resolved
+                    .get(&fh)
+                    .is_some_and(|r| point_in_rect(hit_rect(&model, fh, *r), x, y))
                 && effective_clip(&model, &scroll_sources, fh)
                     .is_none_or(|c| point_in_rect(c, x, y))
         })?;
@@ -628,9 +630,12 @@ pub(super) fn point_in_rect(r: Rect, x: f32, y: f32) -> bool {
     x >= r.left && x <= r.right && y >= r.bottom && y <= r.top
 }
 
-/// A frame's mouse rect: its resolved rect shrunk by its `[left, right, top, bottom]` hit-rect
-/// insets (y-up); an over-shrunk rect collapses to empty rather than inverting.
-fn inset_rect(r: Rect, [left, right, top, bottom]: [f32; 4]) -> Rect {
+/// A frame's mouse rect (`0x76b580`): its resolved rect shrunk by its `[left, right, top, bottom]`
+/// hit-rect insets times its effective scale (y-up), the insets being in the frame's own units; an
+/// over-shrunk rect collapses to empty rather than inverting.
+fn hit_rect(model: &Model, fh: FrameHandle, r: Rect) -> Rect {
+    let s = super::object::eff_scale(model, fh);
+    let [left, right, top, bottom] = model.arena.hit_rect_insets(fh).map(|i| i * s);
     Rect {
         left: r.left + left,
         right: (r.right - right).max(r.left + left),
diff --git a/crates/benilla-ui/src/script/region.rs b/crates/benilla-ui/src/script/region.rs
index 0b9b2e3a..0b6a01c5 100644
--- a/crates/benilla-ui/src/script/region.rs
+++ b/crates/benilla-ui/src/script/region.rs
@@ -684,3 +684,15 @@ pub(super) fn virtual_span(model: &Model, rh: RegionHandle) -> (f32, f32) {
         _ => (aw, ah),
     }
 }
+
+/// [`virtual_span`] on screen: the region's own units times its owner's effective scale, as the
+/// layout sizes a region (`0x76ac90`). For the parts the engine seats itself, with no anchors: a
+/// slider's thumb, a colour picker's markers.
+pub(super) fn screen_span(model: &Model, rh: RegionHandle) -> (f32, f32) {
+    let (w, h) = virtual_span(model, rh);
+    let s = model
+        .arena
+        .region(rh)
+        .map_or(1.0, |r| super::object::eff_scale(model, r.owner));
+    (w * s, h * s)
+}
diff --git a/crates/benilla-ui/src/script/slider.rs b/crates/benilla-ui/src/script/slider.rs
index ac2a4299..3edd671c 100644
--- a/crates/benilla-ui/src/script/slider.rs
+++ b/crates/benilla-ui/src/script/slider.rs
@@ -263,8 +263,9 @@ pub(super) fn thumb_rect(r: Rect, thumb_size: (f32, f32), vertical: bool, fracti
 
 /// The thumb region's own width and height, as `0x789ba0` reads them through the texture's
 /// geometry slots (`[vtable+0x1c]`/`+0x20`, `0x770720`/`0x770790`): the authored span, else the
-/// art's texel span, else 0. `None` without a thumb region: `0x789ba0` gates the value math on
-/// `+0x328`, so a thumbless slider captures a press but never moves.
+/// art's texel span, else 0, in the slider's units, unscaled, though the track it is subtracted
+/// from is the scaled rect (`0x789bd4`–`0x789bfe`). `None` without a thumb region: `0x789ba0`
+/// gates the value math on `+0x328`, so a thumbless slider captures a press but never moves.
 fn thumb_extent(model: &Model, thumb: Option<crate::widget::RegionHandle>) -> Option<(f32, f32)> {
     Some(super::region::virtual_span(model, thumb?))
 }
@@ -303,18 +304,36 @@ pub(super) fn begin_drag(
         });
         return None;
     };
-    let trect = thumb_rect(r, size, vertical, fraction);
+    // The thumb as drawn, at the slider's scale, decides whether the press is on it.
+    let drawn = thumb.map_or(size, |t| super::region::screen_span(model, t));
+    let trect = thumb_rect(r, drawn, vertical, fraction);
     let on_thumb = point_in_rect(trect, x, y);
     // Distances from the track's leading edge, where the thumb sits at `min`: `top - y` on a
     // vertical track in this y-up arena, `x - left` on a horizontal one.
-    let (cursor, thumb_lead, thumb_len) = if vertical {
-        (r.top - y, r.top - trect.top, trect.top - trect.bottom)
+    let (cursor, thumb_lead, drawn_len, own_len) = if vertical {
+        (
+            r.top - y,
+            r.top - trect.top,
+            trect.top - trect.bottom,
+            size.1,
+        )
     } else {
-        (x - r.left, trect.left - r.left, trect.right - trect.left)
+        (
+            x - r.left,
+            trect.left - r.left,
+            trect.right - trect.left,
+            size.0,
+        )
+    };
+    // Off the thumb the cursor takes its centre, half its own unscaled length (`0x789bf5`).
+    let grab_offset = if on_thumb {
+        slider_grab(cursor, thumb_lead, drawn_len)
+    } else {
+        own_len * 0.5
     };
     model.slider_drag = Some(SliderDrag {
         slider: h,
-        grab_offset: slider_grab(cursor, thumb_lead, thumb_len),
+        grab_offset,
     });
     if on_thumb {
         return None; // no value change from the grab itself
diff --git a/crates/benilla-ui/src/script/tests/backdrop.rs b/crates/benilla-ui/src/script/tests/backdrop.rs
index 5a4a8d1d..31442e89 100644
--- a/crates/benilla-ui/src/script/tests/backdrop.rs
+++ b/crates/benilla-ui/src/script/tests/backdrop.rs
@@ -216,3 +216,48 @@ fn backdrop_colors_coerce_rgb_but_default_alpha_opaque() {
     // Stored as a byte: 0.5 reads back as 128/255.
     assert_eq!(a, 128.0 / 255.0);
 }
+
+/// The pieces are textures anchored and sized in the frame's own units (`0x77e8d0`), so the layout
+/// scales them by its effective scale like any region: a half-scale frame's border is half as
+/// thick and its background inset half as deep.
+#[test]
+fn a_scaled_frames_backdrop_scales_with_it() {
+    let mut s = script();
+    s.set_screen_size(800.0, 600.0);
+    s.run(
+        r#"
+        local f = CreateFrame("Frame", "Half")
+        f:SetScale(0.5)
+        f:SetPoint("TOPLEFT", nil, "TOPLEFT", 100, -100)
+        f:SetWidth(200); f:SetHeight(100)
+        f:SetBackdrop({
+            bgFile = "bg", edgeFile = "edge", tile = false, edgeSize = 16,
+            insets = { left = 4, right = 4, top = 4, bottom = 4 },
+        })
+    "#,
+    )
+    .unwrap();
+    s.resolve();
+    let rects: Vec<crate::layout::Rect> = s
+        .extract()
+        .into_iter()
+        .filter(|q| matches!(q.content, QuadContent::Backdrop { .. }))
+        .map(|q| q.rect.expect("piece rect"))
+        .collect();
+    assert_eq!(rects.len(), 9);
+    // The frame on screen: left 50, top 550, 100 × 50.
+    let bg = rects[0];
+    assert_eq!(
+        (bg.left, bg.right, bg.bottom, bg.top),
+        (52.0, 148.0, 502.0, 548.0),
+        "the insets are 4 units of a half-scale frame"
+    );
+    // Every border piece is 16 units, 8 on screen, thick.
+    for r in &rects[1..] {
+        assert_eq!(
+            r.width().min(r.height()),
+            8.0,
+            "a border piece {r:?} is edgeSize units of a half-scale frame"
+        );
+    }
+}
diff --git a/crates/benilla-ui/src/script/tests/input.rs b/crates/benilla-ui/src/script/tests/input.rs
index 8eb98547..10c54512 100644
--- a/crates/benilla-ui/src/script/tests/input.rs
+++ b/crates/benilla-ui/src/script/tests/input.rs
@@ -253,6 +253,27 @@ fn hit_rect_insets_shrink_the_mouse_rect_only() {
     assert!(s.errors().is_empty(), "{:?}", s.errors());
 }
 
+/// The hit rect is the rect less each inset times the frame's effective scale (`0x76b580`), so a
+/// half-scale frame's 20-unit header is 10 on screen.
+#[test]
+fn hit_rect_insets_scale_with_the_frame() {
+    let mut s = script();
+    s.set_screen_size(800.0, 600.0);
+    s.run(
+        r#"
+        local a = CreateFrame("Frame", "HalfHit")
+        a:SetScale(0.5)
+        a:SetPoint("BOTTOMLEFT", 0, 0); a:SetWidth(100); a:SetHeight(100); a:EnableMouse(true)
+        a:SetHitRectInsets(0, 0, 20, 0)
+    "#,
+    )
+    .unwrap();
+    s.resolve();
+    // On screen the frame is 50 × 50 from the origin, its header the top 10.
+    assert!(s.hit_test(25.0, 45.0).is_none(), "inside the scaled header");
+    assert!(s.hit_test(25.0, 38.0).is_some(), "below the scaled header");
+}
+
 #[test]
 fn hit_rect_insets_default_to_zero() {
     let mut s = script();
diff --git a/crates/benilla-ui/src/script/tests/minimap.rs b/crates/benilla-ui/src/script/tests/minimap.rs
index 87e4dcb0..32892495 100644
--- a/crates/benilla-ui/src/script/tests/minimap.rs
+++ b/crates/benilla-ui/src/script/tests/minimap.rs
@@ -282,3 +282,18 @@ fn frame_effective_alpha_reads_the_shown_frames_alpha() {
         "hidden through the parent"
     );
 }
+
+/// `Minimap_OnClick` divides the cursor by the minimap's effective scale and hands
+/// `PingLocation` offsets in the minimap's own units; the reference reads them against the
+/// widget's own size (`0x4eeca0`), so they reach the host scaled back to screen units.
+#[test]
+fn ping_location_reaches_the_host_in_screen_units() {
+    let mut s = UiScript::new().unwrap();
+    s.run(
+        r#"m = CreateFrame("Minimap", "HalfMinimap")
+           m:SetScale(0.5)
+           m:PingLocation(10, -20)"#,
+    )
+    .unwrap();
+    assert_eq!(s.take_minimap_ping_request(), Some((5.0, -10.0)));
+}
diff --git a/crates/benilla-ui/src/script/tests/slider.rs b/crates/benilla-ui/src/script/tests/slider.rs
index 078cad81..b8bf675f 100644
--- a/crates/benilla-ui/src/script/tests/slider.rs
+++ b/crates/benilla-ui/src/script/tests/slider.rs
@@ -628,3 +628,37 @@ fn a_step_before_any_range_is_the_whole_call() {
     let (min, max): (f32, f32) = s.eval("return SlNoRange:GetMinMaxValues()").unwrap();
     assert_eq!((min, max), (0.0, 0.0), "no range was pushed");
 }
+
+/// The thumb is a texture of the slider, sized in its units, so it draws at the slider's
+/// effective scale; the drag reads its unscaled size against the scaled track, as the bytes do.
+#[test]
+fn a_scaled_sliders_thumb_scales_with_it() {
+    let mut s = script();
+    s.set_screen_size(1024.0, 768.0);
+    s.run(
+        r#"
+        local sl = CreateFrame("Slider", "SlHalf")
+        sl:SetScale(0.5)
+        -- The render test's scrollbar at half scale: on screen 8 wide, 50 tall, from (50, 50).
+        sl:SetPoint("BOTTOMLEFT", nil, "BOTTOMLEFT", 100, 100)
+        sl:SetWidth(16); sl:SetHeight(100)
+        sl:SetThumbTexture("Interface\\Buttons\\UI-ScrollBar-Knob")
+        local t = sl:GetThumbTexture()
+        t:SetWidth(16); t:SetHeight(16)
+        sl:SetMinMaxValues(0, 100)
+        sl:SetValue(0)
+    "#,
+    )
+    .unwrap();
+    s.resolve();
+    assert_eq!(
+        thumb_rect(&s.extract(), "Knob"),
+        (50.0, 58.0, 92.0, 100.0),
+        "a 16-unit thumb of a half-scale slider is 8 on screen, flush at the track top"
+    );
+    // The drag (`0x789ba0`) takes the thumb's own unscaled 16 from the scaled 50-tall track: a
+    // press 40 below the track top is (40 - 8) of the 34 travel.
+    s.mouse_button(54.0, 60.0, "LeftButton", true);
+    let v = s.eval::<f64>("return SlHalf:GetValue()").unwrap();
+    assert!((v - 100.0 * 32.0 / 34.0).abs() < 1e-3, "value {v}");
+}
diff --git a/crates/benilla-ui/src/script/tests/tooltip_unit.rs b/crates/benilla-ui/src/script/tests/tooltip_unit.rs
index 867ba62a..900b99a2 100644
--- a/crates/benilla-ui/src/script/tests/tooltip_unit.rs
+++ b/crates/benilla-ui/src/script/tests/tooltip_unit.rs
@@ -679,3 +679,48 @@ fn minimap_blip_tooltip_shows_and_fades() {
         .unwrap();
     assert!(s.take_errors().is_empty());
 }
+
+/// A cursor-seated plate sits on the cursor under the UI scale: the cursor is in root units and
+/// the anchor offset in the tooltip's own, so the cursor arm divides by its effective scale
+/// (`0x530b20`).
+#[test]
+fn a_cursor_seated_plate_lands_on_the_cursor_under_the_ui_scale() {
+    let mut s = script();
+    s.set_screen_size(800.0, 600.0);
+    s.run(
+        r#"
+        local up = CreateFrame("Frame", "UIParent")
+        up:SetPoint("BOTTOMLEFT", 0, 0); up:SetPoint("TOPRIGHT", 0, 0)
+        CreateFrame("GameTooltip", "GameTooltip", UIParent)
+    "#,
+    )
+    .unwrap();
+    assert!(s.set_ui_scale(0.9));
+    let at = |s: &mut crate::script::UiScript| -> (f64, f64) {
+        let answers: Vec<(u32, f32, f32, u64)> = s
+            .fontstrings_needing_measure()
+            .iter()
+            .map(|r| (r.id, 80.0, 10.0, r.key))
+            .collect();
+        s.set_measured_text_unwrapped(&answers);
+        s.resolve();
+        s.eval::<(f64, f64)>(
+            "local k = GameTooltip:GetEffectiveScale() \
+             local x = GameTooltip:GetCenter() \
+             return x * k, GameTooltip:GetBottom() * k",
+        )
+        .unwrap()
+    };
+    assert!(s.minimap_tooltip("Stormwind", 400.0, 300.0, false));
+    let (x, y) = at(&mut s);
+    assert!(
+        (x - 400.0).abs() < 1e-3 && (y - 300.0).abs() < 1e-3,
+        "({x}, {y})"
+    );
+    s.world_tooltip_move(200.0, 100.0);
+    let (x, y) = at(&mut s);
+    assert!(
+        (x - 200.0).abs() < 1e-3 && (y - 100.0).abs() < 1e-3,
+        "({x}, {y})"
+    );
+}
diff --git a/crates/benilla-ui/src/script/tooltip_unit.rs b/crates/benilla-ui/src/script/tooltip_unit.rs
index fe74f1ae..381d1c72 100644
--- a/crates/benilla-ui/src/script/tooltip_unit.rs
+++ b/crates/benilla-ui/src/script/tooltip_unit.rs
@@ -350,8 +350,8 @@ impl super::UiScript {
                 if let Ok(t) = tip_mut(&mut model, h) {
                     t.owner = Some(root);
                 }
+                let new = cursor_anchor_at(&model, h, root_id, ui_x, ui_y);
                 let input = model.layout_inputs.entry(h).or_default();
-                let new = Anchor::new(Point::Bottom, root_id, Point::BottomLeft, ui_x, ui_y);
                 let same = input.anchors.len() == 1
                     && super::object::anchor_bits_eq(&input.anchors[0], &new);
                 if !same {
@@ -440,10 +440,10 @@ impl super::UiScript {
         {
             let mut model = self.model_mut();
             clear_content(&mut model, h);
-            let input = model.layout_inputs.entry(h).or_default();
             // Anchor only: the frame's own clamp flag (`Frame::clamped_to_screen`, G flags bit 4)
             // slides a plate near the window edge back on screen.
-            let new = Anchor::new(Point::Bottom, root_id, Point::BottomLeft, ui_x, ui_y);
+            let new = cursor_anchor_at(&model, h, root_id, ui_x, ui_y);
+            let input = model.layout_inputs.entry(h).or_default();
             // Compare-then-touch, so a still cursor does not dirty the layout.
             let same =
                 input.anchors.len() == 1 && super::object::anchor_bits_eq(&input.anchors[0], &new);
@@ -497,8 +497,8 @@ impl super::UiScript {
             return;
         }
         let root_id = model.frame_id(root);
+        let new = cursor_anchor_at(&model, h, root_id, ui_x, ui_y);
         let input = model.layout_inputs.entry(h).or_default();
-        let new = Anchor::new(Point::Bottom, root_id, Point::BottomLeft, ui_x, ui_y);
         // Compare-then-touch: this runs on every pointer event.
         let same =
             input.anchors.len() == 1 && super::object::anchor_bits_eq(&input.anchors[0], &new);
@@ -559,3 +559,17 @@ pub(super) fn install_methods(lua: &Lua, m: &Table) -> mlua::Result<()> {
     )?;
     Ok(())
 }
+
+/// The plate's BOTTOM on the cursor: `(ui_x, ui_y)` is in the screen root's units, and an anchor
+/// offset is in the tooltip's own, so it is divided by the tooltip's effective scale, the UI scale
+/// included, as the cursor arm `0x530b20` does ([`super::tooltip`]'s `cursor_anchor`).
+fn cursor_anchor_at(model: &Model, h: FrameHandle, root_id: u32, ui_x: f32, ui_y: f32) -> Anchor {
+    let s = super::object::eff_scale(model, h);
+    Anchor::new(
+        Point::Bottom,
+        root_id,
+        Point::BottomLeft,
+        ui_x / s,
+        ui_y / s,
+    )
+}
diff --git a/crates/benilla-ui/src/script/ui_scale.rs b/crates/benilla-ui/src/script/ui_scale.rs
new file mode 100644
index 00000000..d1ddb62e
--- /dev/null
+++ b/crates/benilla-ui/src/script/ui_scale.rs
@@ -0,0 +1,221 @@
+//! The UI scale: `UIParent`'s own frame scale, never the screen's. The screen root keeps scale 1
+//! and is 768 units tall at every window size; `uiScale` reaches only `UIParent`'s subtree,
+//! through the worker Lua's `SetScale` calls (`0x494550` → `0x76ac10` on the frame named
+//! `"UIParent"`, looked up at `0x49006a`), so a frame with no parent, or under `WorldFrame`, draws
+//! at scale 1.
+
+use super::{Model, UiScript};
+
+/// `SetUiScale`'s floor (`0x494550`: `[0x804584]`, below which `0x494563` stores 0.64).
+pub(crate) const UI_SCALE_FLOOR: f32 = 0.64;
+
+/// `GetUiScale` (`0x494590`): `UIParent`'s effective scale (`[UIParent+0x7c]`), else 1.0 when there
+/// is no `UIParent`. `GetScreenWidth`/`GetScreenHeight` (`0x48b480`/`0x48b4d0`) divide the root by
+/// it, and nothing else reads it. A zero scale reads 1, as the reference's writer `0x768360`
+/// refuses one.
+pub(crate) fn ui_parent_scale(model: &Model) -> f32 {
+    model
+        .arena
+        .lookup("UIParent")
+        .map_or(1.0, |h| super::object::eff_scale(model, h))
+}
+
+/// The cap both `uiScale` legs apply before the sink (`0x490770`, and the display handler's ON leg
+/// `0x492e90`): below a 4:3 aspect `a` the value is capped at `0.75·a` (`a·3 ≥ 4` skips the cap, so
+/// 4:3 itself is never capped).
+pub(crate) fn capped_ui_scale(ui_scale: f32, aspect: f32) -> f32 {
+    if aspect * 3.0 < 4.0 {
+        ui_scale.min(aspect * 0.75)
+    } else {
+        ui_scale
+    }
+}
+
+/// `SetUiScale`'s floor (`0x494550`): above [`UI_SCALE_FLOOR`] the value stands, else (NaN
+/// included) the floor.
+pub(crate) fn floored_ui_scale(v: f32) -> f32 {
+    if v > UI_SCALE_FLOOR {
+        v
+    } else {
+        UI_SCALE_FLOOR
+    }
+}
+
+/// What the CVar callback applies (`0x490770` → `0x494550`): capped, then floored.
+pub(crate) fn effective_ui_scale(ui_scale: f32, aspect: f32) -> f32 {
+    floored_ui_scale(capped_ui_scale(ui_scale, aspect))
+}
+
+/// The automatic scale `0x492f70` computes for a `w`×`h` display: 1.0, or `768/h` above 768 tall
+/// (`0x492fbc cmp esi,0x300`), under the same narrow-aspect cap, then raised to 0.9 unless above it
+/// (`0x493005`–`0x493012`).
+pub(crate) fn auto_ui_scale(w: u32, h: u32) -> f32 {
+    let mut v = if h > 768 { 768.0 / h as f32 } else { 1.0 };
+    if h > 0 {
+        v = capped_ui_scale(v, w as f32 / h as f32);
+    }
+    if v > 0.9 {
+        v
+    } else {
+        0.9
+    }
+}
+
+impl UiScript {
+    /// The host's `uiScale`, compared first like [`Self::set_screen_size`]: a new value applies at
+    /// once through the CVar's change callback (`0x490770`: capped, floored at 0.64), and `true`
+    /// says it reached a `UIParent`. The same value again does nothing, so an addon's own
+    /// `UIParent:SetScale` holds until the next change.
+    pub fn set_ui_scale(&mut self, ui_scale: f32) -> bool {
+        let applied = {
+            let mut model = self.model_mut();
+            if model.ui_scale_request == Some(ui_scale) {
+                return false;
+            }
+            model.ui_scale_request = Some(ui_scale);
+            let aspect = model.screen.width() / model.screen.height();
+            model
+                .arena
+                .lookup("UIParent")
+                .map(|h| (h, effective_ui_scale(ui_scale, aspect)))
+        };
+        let Some((ui_parent, v)) = applied else {
+            return false;
+        };
+        self.model_mut().set_frame_scale(ui_parent, v);
+        true
+    }
+
+    /// Record `ui_scale` without applying it, then apply it through the display handler, as the UI
+    /// load does once its files and `VARIABLES_LOADED` are done (`0x49010e` → `0x492e90`): the
+    /// CVar's own callback found no `UIParent` when it fired at registration.
+    pub fn seat_ui_scale(
+        &mut self,
+        ui_scale: f32,
+        display: (u32, u32),
+        auto_cache: &mut Option<(u32, u32)>,
+    ) -> bool {
+        self.model_mut().ui_scale_request = Some(ui_scale);
+        self.apply_ui_scale(display, auto_cache)
+    }
+
+    /// The display handler `0x492e90` on the last [`Self::set_ui_scale`], for the load and a
+    /// display change. Its ON leg caps the value and hands it to the sink only at 0.64 or more
+    /// (`0x492efd fcomp [0x804584]; test ah,1; jne 0x492f4a`); below, it falls to the automatic
+    /// scale `0x492f70(w, h, force = 0)` ([`auto_ui_scale`]), which does nothing at all when the
+    /// display is the one it last ran for (`auto_cache`, the reference's `[0xb4e304]`/`[0xb4e308]`,
+    /// which outlive the UI). `display` is the window in logical px, the host's unit for the
+    /// reference's device size. `true` when a scale reached `UIParent`.
+    pub fn apply_ui_scale(
+        &mut self,
+        display: (u32, u32),
+        auto_cache: &mut Option<(u32, u32)>,
+    ) -> bool {
+        let applied = {
+            let model = self.model_ref();
+            let Some(ui_scale) = model.ui_scale_request else {
+                return false;
+            };
+            let aspect = model.screen.width() / model.screen.height();
+            let v = capped_ui_scale(ui_scale, aspect);
+            let v = if v >= UI_SCALE_FLOOR {
+                v
+            } else {
+                let (w, h) = display;
+                if w > 0 && h > 0 && *auto_cache == Some(display) {
+                    return false;
+                }
+                *auto_cache = Some(display);
+                floored_ui_scale(auto_ui_scale(w, h))
+            };
+            model.arena.lookup("UIParent").map(|h| (h, v))
+        };
+        let Some((ui_parent, v)) = applied else {
+            return false;
+        };
+        self.model_mut().set_frame_scale(ui_parent, v);
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_callback_ladder_caps_below_four_thirds_and_floors_at_the_sink() {
+        // 4:3 and wider: the dial as set.
+        assert_eq!(effective_ui_scale(0.9, 4.0 / 3.0), 0.9);
+        assert_eq!(effective_ui_scale(0.9, 16.0 / 9.0), 0.9);
+        assert_eq!(effective_ui_scale(1.2, 16.0 / 9.0), 1.2);
+        // 5:4 caps a full dial at 0.9375 and leaves 0.9 alone.
+        assert_eq!(effective_ui_scale(1.0, 1.25), 0.9375);
+        assert_eq!(effective_ui_scale(0.9, 1.25), 0.9);
+        // The floor, on both sides of it.
+        assert_eq!(effective_ui_scale(0.5, 16.0 / 9.0), UI_SCALE_FLOOR);
+        assert_eq!(effective_ui_scale(0.65, 16.0 / 9.0), 0.65);
+        // A square window caps at 0.75, a narrow one bottoms out at the floor.
+        assert_eq!(effective_ui_scale(0.9, 1.0), 0.75);
+        assert_eq!(effective_ui_scale(0.9, 0.5), UI_SCALE_FLOOR);
+    }
+
+    #[test]
+    fn the_scale_lands_on_uiparent_alone_and_only_on_a_change() {
+        let mut s = UiScript::new().unwrap();
+        s.set_screen_size(1024.0, 768.0);
+        assert!(!s.set_ui_scale(0.9), "no UIParent yet: nothing to scale");
+        s.run(r#"CreateFrame("Frame", "UIParent") CreateFrame("Frame", "Loose")"#)
+            .unwrap();
+        assert!(!s.set_ui_scale(0.9), "the same value is no change");
+        assert!(
+            s.apply_ui_scale((1024, 768), &mut None),
+            "the load edge applies what was set"
+        );
+        assert_eq!(s.eval::<f32>("return UIParent:GetScale()").unwrap(), 0.9);
+        assert_eq!(s.eval::<f32>("return Loose:GetScale()").unwrap(), 1.0);
+        // An addon's own scale holds until the dial moves.
+        s.run("UIParent:SetScale(0.7)").unwrap();
+        assert!(!s.set_ui_scale(0.9));
+        assert_eq!(s.eval::<f32>("return UIParent:GetScale()").unwrap(), 0.7);
+        assert!(s.set_ui_scale(0.8));
+        assert_eq!(s.eval::<f32>("return UIParent:GetScale()").unwrap(), 0.8);
+    }
+
+    /// The automatic scale (`0x492f70`): 1.0 up to 768 tall, `768/h` above it, never under 0.9.
+    #[test]
+    fn the_auto_scale_follows_the_height_and_stops_at_nine_tenths() {
+        assert_eq!(auto_ui_scale(1024, 768), 1.0);
+        assert_eq!(auto_ui_scale(1280, 800), 0.96);
+        assert_eq!(auto_ui_scale(1920, 1080), 0.9);
+        // A tall narrow display: capped, then raised to 0.9.
+        assert_eq!(auto_ui_scale(600, 700), 0.9);
+    }
+
+    /// The display handler (`0x492e90`) never floors: a dial capped below 0.64 falls to the
+    /// automatic scale, which skips a display it already ran for; the CVar callback (`0x490770`)
+    /// floors instead.
+    #[test]
+    fn below_the_floor_the_display_handler_falls_to_the_auto_scale() {
+        let mut s = UiScript::new().unwrap();
+        s.set_screen_size(1024.0, 768.0);
+        s.run(r#"CreateFrame("Frame", "UIParent")"#).unwrap();
+        let scale = |s: &UiScript| s.eval::<f32>("return UIParent:GetScale()").unwrap();
+        let mut cache = None;
+        assert!(s.seat_ui_scale(0.5, (1280, 800), &mut cache));
+        assert_eq!(scale(&s), 0.96, "the load took the auto scale for 1280×800");
+        assert_eq!(cache, Some((1280, 800)));
+        // The same display again: the auto path does nothing at all.
+        s.run("UIParent:SetScale(0.7)").unwrap();
+        assert!(!s.apply_ui_scale((1280, 800), &mut cache));
+        assert_eq!(scale(&s), 0.7);
+        // A new display runs it.
+        assert!(s.apply_ui_scale((1920, 1080), &mut cache));
+        assert_eq!(scale(&s), 0.9);
+        // The CVar callback floors.
+        assert!(s.set_ui_scale(0.55));
+        assert_eq!(scale(&s), UI_SCALE_FLOOR);
+        // At the floor or above, the display handler hands the value to the sink.
+        assert!(s.seat_ui_scale(0.8, (1920, 1080), &mut cache));
+        assert_eq!(scale(&s), 0.8);
+    }
+}