From b49856c5cbccffbb0c59faf6ffda9b85d81716a8 Mon Sep 17 00:00:00 2001
From: grom <grom@gromgosh.gg>
Date: Sun, 1 Nov 2026 21:15:55 -0700
Subject: [PATCH] ui: texture masks, the later-era texture dials, and the pools
 a canvas map needs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The mask pair is the one that matters and nothing can stand in for it. 1.12 has
no texture masking at all — its single masked thing is the minimap disc, cut
engine-side — and no idiom reaches the same end, because the point is that a
rectangular texture draws as a non-rectangular shape. A seamless world map is
that operation and nothing else: a zone's art is a rectangle of parchment and
the map wants it cut to the zone's coastline.

It was affordable because the render pass already had the slot. `UiQuad::mask`
is a screen-anchored alpha mask built for the minimap's fixed circle with tiles
panning under it, which is exactly `AddMaskTexture`'s semantics — the mask is
another region with its own anchors, and the subject keeps the fragments its
alpha covers at that place. So this is plumbing, not a new material.

One mask per quad, said rather than hidden: widening it is a second texture
binding and a second uniform on every UI quad in the client. The list is kept
whole, because the order decides the winner — first added, which for a stitched
map is the land mask. Two traps are pinned by tests: a mask region is skipped at
extract rather than marked hidden, since its rect is what it covers; and a mask
whose art is missing drops the mask, not the quad, because zero coverage would
blank the art it was meant to shape.

`Texture:SetRotation` was nearly free — the renderer has carried the angle since
the minimap arrow, so this is the Lua setter for it. `SetDesaturation` is the
fractional form of 1.12's own flag, rounded onto the one flag this renderer has,
with the getter answering the caller's own number. The tile pair is applied: the
host computes the repeat count once the art has loaded.

`SetPropagateKeyboardInput` is stored, not applied: 1.12 already always
propagates, so there is no swallow mode for false to select. `EditBox:HasFocus`
publishes a fact this client already tracks and never exposed.

Corpus: 85 ok / 1 fail, roster and digest unchanged. The 12 data-half reds are
byte-identical to HEAD's.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SgstFWtn1RxEJ5kVrpgYwn
---
 .../benilla-app/src/ui_script/extract/mod.rs  | 132 +++++++++-
 .../src/script/compat/classic_api/frame.rs    |  98 ++++++++
 .../src/script/compat/classic_api/misc.rs     |  91 +++++++
 .../src/script/compat/classic_api/pools.rs    |  72 +++++-
 crates/benilla-ui/src/script/editbox.rs       |  10 +-
 crates/benilla-ui/src/script/extract.rs       |  19 ++
 crates/benilla-ui/src/script/mod.rs           |  16 +-
 crates/benilla-ui/src/script/model.rs         |   5 +
 crates/benilla-ui/src/script/region/paint.rs  | 142 +++++++++++
 .../src/script/tests/reference_surface.rs     |  26 ++
 crates/benilla-ui/src/script/tests/regions.rs | 231 +++++++++++++++++-
 .../src/script/tests/widget_surface.rs        | 106 ++++++++
 crates/benilla-ui/src/script/types.rs         |  50 +++-
 docs/ADDON_COMPAT.md                          |   1 +
 14 files changed, 983 insertions(+), 16 deletions(-)

diff --git a/crates/benilla-app/src/ui_script/extract/mod.rs b/crates/benilla-app/src/ui_script/extract/mod.rs
index d5c0edef..456f6d52 100644
--- a/crates/benilla-app/src/ui_script/extract/mod.rs
+++ b/crates/benilla-app/src/ui_script/extract/mod.rs
@@ -1319,6 +1319,8 @@ fn convert_entry(
             portrait_unit,
             rotation,
             desaturated,
+            mask,
+            tile,
         } => {
             // A live unit portrait (`SetPortraitTexture(region, unit)`): the model bake, or the
             // reference's 2D TemporaryPortrait while the model streams; no entry yet draws nothing.
@@ -1382,8 +1384,15 @@ fn convert_entry(
                 Some(TexCoords::Corners(corners)) => UvRect::from_corners(corners),
                 None => UvRect::FULL,
             };
-            // A slice past the texture tiles (`BonusActionBarFrame.lua:173`), on that axis alone.
-            let wrap = tiling_axes(&uv);
+            // A slice past the texture tiles (`BonusActionBarFrame.lua:173`), on that axis alone;
+            // `SetHorizTile`/`SetVertTile` ask for the same wrap without naming a count, so they
+            // join it here and the count is computed below, once the art's texel size is known.
+            let explicit_uv = tex_coords.is_some();
+            let mut uv = uv;
+            let wrap = {
+                let (h, v) = tiling_axes(&uv);
+                (h || (tile.0 && !explicit_uv), v || (tile.1 && !explicit_uv))
+            };
             let handle = match (path.as_deref(), assets.as_mut()) {
                 (Some(p), Some(a)) => {
                     let resolved = if p == benilla_ui::script::nameplate::BORDER_TEXTURE {
@@ -1426,6 +1435,36 @@ fn convert_entry(
                 }
                 _ => None,
             };
+            // `SetHorizTile`/`SetVertTile`'s repeat count: the region's own span over the art's,
+            // which is what "tile at its native size" means. Taken here because the texel size is
+            // only known once the art has loaded. A missing image, a zero-texel axis or an
+            // explicit `SetTexCoord` leaves the mapping alone.
+            if (tile.0 || tile.1) && !explicit_uv {
+                if let Some(sz) = handle
+                    .as_ref()
+                    .and_then(|h| images.get(h))
+                    .map(|img| img.texture_descriptor.size)
+                {
+                    let repeats = |span: f32, texels: u32| {
+                        if texels > 0 {
+                            span / texels as f32
+                        } else {
+                            1.0
+                        }
+                    };
+                    let u = if tile.0 {
+                        repeats(rect.width(), sz.width)
+                    } else {
+                        1.0
+                    };
+                    let v = if tile.1 {
+                        repeats(rect.height(), sz.height)
+                    } else {
+                        1.0
+                    };
+                    uv = UvRect::from_tex_coords([0.0, u, 0.0, v]);
+                }
+            }
             // A crop's magnified edge would filter in the neighbouring atlas cell.
             let uv_clamp = handle
                 .as_ref()
@@ -1447,6 +1486,18 @@ fn convert_entry(
                 // `SetRotation` is counter-clockwise-positive, `UiQuad::rotation` clockwise.
                 rotation: -rotation,
                 desaturated,
+                // `AddMaskTexture`: the mask's own art and rect, converted to screen space the
+                // same way as `rect`. A mask whose art the archives lack drops the mask, not the
+                // quad — a missing cut-out shows the whole rectangle, which is the same thing the
+                // caller sees when it never had a mask to add.
+                mask: mask.and_then(|m| {
+                    let art = assets.as_mut()?.sprite_texture(&m.path, images)?;
+                    let r = m.rect;
+                    Some(crate::ui_pass::UiQuadMask {
+                        texture: art,
+                        rect: Rect::new(r.left * s, h - r.top * s, r.right * s, h - r.bottom * s),
+                    })
+                }),
                 ..default()
             });
         }
@@ -1831,6 +1882,83 @@ mod clip_plumb_tests {
         );
     }
 
+    /// A mask whose art the archives lack drops the **mask**, not the quad.
+    ///
+    /// Worth pinning because the other reading is tempting and wrong: a mask that cannot load is
+    /// zero coverage, and honouring that would erase the art it was meant to shape — a stitched
+    /// map would go blank wherever a generated mask was missing, which reads as the map's own art
+    /// failing. Showing the whole rectangle is what the caller sees when it never had a mask.
+    ///
+    /// Runs with no `WorldAssets` at all, which is the same path a missing file takes: the quad is
+    /// a pathless solid so it still draws, and the mask asks for art and gets none.
+    #[test]
+    fn a_mask_whose_art_is_missing_drops_the_mask_and_keeps_the_quad() {
+        let script = UiScript::new().unwrap();
+        script
+            .run(
+                r#"
+            local f = CreateFrame("Frame", "MaskPlumb")
+            f:SetPoint("TOPLEFT", 0, 0)
+            f:SetWidth(50); f:SetHeight(50)
+            local m = f:CreateTexture(nil, "ARTWORK")
+            m:SetTexture(0, 0, 1)
+            m:SetAllPoints()
+            local cut = f:CreateMaskTexture(nil, "ARTWORK")
+            cut:SetTexture("Interface\\AddOns\\NoSuch\\mask")
+            cut:SetAllPoints()
+            m:AddMaskTexture(cut)
+        "#,
+            )
+            .unwrap();
+
+        let mut app = App::new();
+        app.insert_non_send_resource(script);
+        app.init_resource::<UiQuads>();
+        app.init_resource::<crate::ui_script::UiPassState>();
+        app.init_resource::<Assets<Image>>();
+        app.init_resource::<PortraitImages>();
+        app.init_resource::<crate::portrait::BoothPanes>();
+        app.init_resource::<crate::portrait::PaneBakeSizes>();
+        app.init_resource::<crate::portrait::PanePositions>();
+        app.init_resource::<crate::portrait::UnitPaneBooths>();
+        app.init_resource::<crate::ui_models::UiModelTiles>();
+        app.init_resource::<crate::minimap::MinimapWidget>();
+        app.init_resource::<crate::ui_script::UiFrameCost>();
+        app.init_resource::<crate::ui_script::UiCostWanted>();
+        app.init_resource::<Time>();
+        app.init_resource::<Time<Real>>();
+        app.init_resource::<crate::ui_script::UiClock>();
+        app.init_resource::<crate::ui_script::UiScaleCvar>();
+        app.world_mut().spawn((
+            Window {
+                resolution: UVec2::new(1024, 768).into(),
+                ..default()
+            },
+            PrimaryWindow,
+        ));
+        app.add_systems(Update, (tick_script, paint_script).chain());
+        app.update();
+
+        let quads = &app.world().resource::<UiQuads>().quads;
+        let marker: &UiQuad = quads
+            .iter()
+            .find(|q| q.color[2] == 1.0 && q.color[0] == 0.0)
+            .expect("the solid still draws");
+        assert!(
+            marker.mask.is_none(),
+            "a mask with no art is no mask, not an empty one"
+        );
+        // And the mask region itself emitted nothing: one quad for the frame slot, one for the
+        // solid, and none for the cut-out.
+        assert_eq!(
+            quads
+                .iter()
+                .filter(|q| q.color[2] == 1.0 && q.color[0] == 0.0)
+                .count(),
+            1
+        );
+    }
+
     #[test]
     fn an_unclipped_texture_quad_carries_no_clip() {
         let script = UiScript::new().unwrap();
diff --git a/crates/benilla-ui/src/script/compat/classic_api/frame.rs b/crates/benilla-ui/src/script/compat/classic_api/frame.rs
index b1b66e01..8d7f550c 100644
--- a/crates/benilla-ui/src/script/compat/classic_api/frame.rs
+++ b/crates/benilla-ui/src/script/compat/classic_api/frame.rs
@@ -261,6 +261,104 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
         })?,
     )?;
 
+    // `CreateMaskTexture(name, layer, template, subLayer)`: a Texture that shapes other regions
+    // through `Texture:AddMaskTexture` and never draws itself (`region/paint.rs` has the pair, and
+    // `RegionData::is_mask` the skip).
+    //
+    // 1.12 has no masking and therefore no mask region. It is built because a seamless map is
+    // nothing but masking — a zone's rectangular parchment cut to the zone's coastline — and
+    // because the method is called **unguarded** where it is used (`Map/Close.lua:159` builds the
+    // continent land mask before any texture can ask for it).
+    //
+    // Built over the stock `CreateTexture` on this same table rather than beside it, so a mask is
+    // an ordinary Texture in every other respect: the callers set its art, size and anchors with
+    // the ordinary methods, and its *rect* is what the mask covers. `subLayer` is accepted and
+    // ignored for the same reason the draw layer is read at all — a mask is never drawn, so
+    // neither places it.
+    m.set(
+        "CreateMaskTexture",
+        lua.create_function(
+            |lua, (this, name, layer, template, _sub): (Table, Value, Value, Value, Value)| {
+                let create: mlua::Function = this.get("CreateTexture")?;
+                let wrapper: Table = create.call((this, name, layer, template))?;
+                let rh = crate::script::region::region_handle_of(lua, &wrapper)?;
+                let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+                model.region_data.entry(rh).or_default().is_mask = true;
+                Ok(wrapper)
+            },
+        )?,
+    )?;
+
+    // `EditBox:HasFocus()` and `EditBox:SetCursorPosition(n)`, both **beyond 1.12**: its EditBox
+    // table has `SetFocus`/`ClearFocus` and no getter, and no cursor setter at all
+    // (`script/editbox/methods.rs` says so where the getter would be), so an addon of that era
+    // keeps its own flag and never moves the caret from Lua.
+    //
+    // Both are built because both are called unguarded on this install's own libraries' widgets:
+    // `HasFocus` decides whether a dropped autocomplete list closes (`Map/Nav.lua:374`, inside an
+    // `OnEditFocusLost` callback, so a nil method raises every time a search box loses focus), and
+    // `SetCursorPosition(0)` scrolls a long read-only link box back to its start after
+    // `HighlightText` (`Map/News.lua:282`).
+    //
+    // `HasFocus` is the one focus owner (`Model::focused_editbox`), which is the fact 1.12 already
+    // tracks — it just never published it. `SetCursorPosition` lands through the same clamp and
+    // UTF-8 snap `HighlightText` uses, with the selection collapsed to the caret, which is what
+    // the later-era method does.
+    {
+        let e: Table = lua.named_registry_value(crate::script::editbox::REG_EDITBOX_METHODS)?;
+        e.set(
+            "HasFocus",
+            lua.create_function(|lua, this: Table| {
+                let h = frame_handle_of(lua, &this)?;
+                let model = lua.app_data_ref::<Model>().expect("model app_data");
+                Ok(crate::script::binding_abi::flag(
+                    model.focused_editbox == Some(h),
+                ))
+            })?,
+        )?;
+        e.set(
+            "SetCursorPosition",
+            lua.create_function(|lua, (this, pos): (Table, Option<i64>)| {
+                let h = frame_handle_of(lua, &this)?;
+                let pos = pos.unwrap_or(0);
+                crate::script::editbox::set_cursor_position(lua, h, pos);
+                Ok(())
+            })?,
+        )?;
+    }
+
+    // `SetPropagateKeyboardInput(on)` / `GetPropagateKeyboardInput()`: 4.x's switch for whether a
+    // frame with an `OnKeyDown` handler lets the key reach the next frame and the keybinding
+    // system, or swallows it.
+    //
+    // **Stored, not applied**, and the reason is that 1.12's answer is "always propagate": its
+    // key routing hands a `WorldFrame` key to the binding system regardless of what any frame's
+    // handler did, so there is no swallow mode here for `false` to select. Honouring it would mean
+    // building that mode, and refusing it costs a caller its whole key path — the one here arms an
+    // invisible catcher frame and flips the flag inside its own handler
+    // (`Map/Sketch.lua:579-585`), so a nil method raises in a key handler, once per keypress.
+    // The pair round-trips, so a caller reading back what it wrote gets its own answer, and
+    // `true` — the value every caller ends up on — is what this client does anyway.
+    m.set(
+        "SetPropagateKeyboardInput",
+        lua.create_function(|lua, (this, on): (Table, Option<Value>)| {
+            let h = frame_handle_of(lua, &this)?;
+            let on = !matches!(on, None | Some(Value::Nil) | Some(Value::Boolean(false)));
+            let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+            model.propagate_keyboard.insert(h, on);
+            Ok(())
+        })?,
+    )?;
+    m.set(
+        "GetPropagateKeyboardInput",
+        lua.create_function(|lua, this: Table| {
+            let h = frame_handle_of(lua, &this)?;
+            let model = lua.app_data_ref::<Model>().expect("model app_data");
+            let on = model.propagate_keyboard.get(&h).copied().unwrap_or(true);
+            Ok(crate::script::binding_abi::flag(on))
+        })?,
+    )?;
+
     // `IsEventRegistered(event)`: 1 or nil, the 1.12 predicate shape. A frame in all-events mode
     // (`RegisterAllEvents`) answers 1 for anything, since that is what it will receive.
     m.set(
diff --git a/crates/benilla-ui/src/script/compat/classic_api/misc.rs b/crates/benilla-ui/src/script/compat/classic_api/misc.rs
index 4ee500cd..9ceaa8c1 100644
--- a/crates/benilla-ui/src/script/compat/classic_api/misc.rs
+++ b/crates/benilla-ui/src/script/compat/classic_api/misc.rs
@@ -112,6 +112,97 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
     // secure-template system at all, so nothing here is ever locked down.
     g.set("InCombatLockdown", lua.create_function(|_, ()| Ok(false))?)?;
 
+    // `Ambiguate(fullName, context)`: 4.x's cross-realm name shortener, which strips a
+    // `Name-Realm` suffix when the context says the realm is implied.
+    //
+    // **The identity function on the part that matters**, and that is the answer rather than a
+    // stub: 1.12 has no connected realms and no cross-realm names, so a unit name here never
+    // carries a realm and there is nothing to strip. The `-Realm` split is still applied, because
+    // a *custom* realm can hand out a hyphenated name and the caller's whole purpose is to get the
+    // short one; `"none"` is the context every caller in the corpus passes and it means "always
+    // strip", which is what this does unconditionally. A nil name answers nil, as upstream does.
+    g.set(
+        "Ambiguate",
+        lua.create_function(|_, (name, _context): (Option<String>, Option<String>)| {
+            Ok(name.map(|n| match n.split_once('-') {
+                Some((short, _realm)) if !short.is_empty() => short.to_string(),
+                _ => n,
+            }))
+        })?,
+    )?;
+
+    // `IsModifiedClick(action)`: whether the modifiers held match the binding for one of the
+    // named click actions (`CHATLINK`, `SELFCAST`, `COMPAREITEMS`, …).
+    //
+    // 1.12 has the *bindings* — they are `SetModifiedClick`/`GetModifiedClick` over a handful of
+    // CVar-backed rows, and its own FrameXML reads them with `GetModifiedClick("CHATLINK")` then
+    // tests the key itself — but it registers no predicate that does both steps. So this is the
+    // composition of two verbs this client already answers, not new state: the bound modifier
+    // name for the action, then that modifier's own key test.
+    //
+    // An unknown action answers false rather than raising: every caller guards the name
+    // (`Map/Nav.lua:161` is `IsModifiedClick and IsModifiedClick("CHATLINK")`) and a raise inside
+    // a click handler would take the click's whole path with it.
+    g.set(
+        "IsModifiedClick",
+        lua.create_function(|lua, action: Option<String>| {
+            let Some(action) = action else {
+                return Ok(false);
+            };
+            let g = lua.globals();
+            let get: Option<mlua::Function> = g.get("GetModifiedClick")?;
+            let Some(get) = get else {
+                return Ok(false);
+            };
+            let bound: Option<String> = get.call(action.as_str())?;
+            let Some(bound) = bound else {
+                return Ok(false);
+            };
+            let down = |name: &str| -> mlua::Result<bool> {
+                let f: Option<mlua::Function> = g.get(name)?;
+                Ok(match f {
+                    Some(f) => !matches!(f.call::<Value>(())?, Value::Nil | Value::Boolean(false)),
+                    None => false,
+                })
+            };
+            Ok(match bound.to_ascii_uppercase().as_str() {
+                "SHIFT" => down("IsShiftKeyDown")?,
+                "CTRL" => down("IsControlKeyDown")?,
+                "ALT" => down("IsAltKeyDown")?,
+                // `NONE`, and anything the table does not spell: no modifier is required, so a
+                // plain click already is the modified click.
+                "NONE" => true,
+                _ => false,
+            })
+        })?,
+    )?;
+
+    // `GetQuestDifficultyColor(level)`: 2.x's rename of 1.12's own `GetDifficultyColor`, which is
+    // FrameXML's (`reference/1.12-globals.tsv` files it under `framexml`) and so is loaded off the
+    // player's chain after this. Registered as a **forwarder** rather than a copy of the table, so
+    // the colours are whatever that file says and the two spellings cannot drift; a VM with no
+    // FrameXML answers nil, which is what the name did before.
+    g.set(
+        "GetQuestDifficultyColor",
+        lua.create_function(|lua, level: Value| {
+            let f: Option<mlua::Function> = lua.globals().get("GetDifficultyColor")?;
+            match f {
+                Some(f) => f.call::<Value>(level),
+                None => Ok(Value::Nil),
+            }
+        })?,
+    )?;
+
+    // `GetUnitSpeed(unit)`: 3.x's current, running and swim speeds in yards per second.
+    //
+    // **Not built**, and the reason is that answering would be inventing the number: 1.12 sends no
+    // speed field for any unit — `MOVEMENTFLAG`s and the server's speed packets are not in this
+    // client's unit model at all — so the only honest answer is the absent one. Its single caller
+    // here already reads it that way, gated on `if GetUnitSpeed then` and falling back to a
+    // distance-over-time estimate of its own (`Map/Extras.lua:418`), which is a better number than
+    // anything this could make up. Listed in `docs/ADDON_COMPAT.md` rather than registered,
+    // because a registered `0` would read as "standing still" forever.
+
     Ok(())
 }
 
diff --git a/crates/benilla-ui/src/script/compat/classic_api/pools.rs b/crates/benilla-ui/src/script/compat/classic_api/pools.rs
index 739ff09c..381b5e04 100644
--- a/crates/benilla-ui/src/script/compat/classic_api/pools.rs
+++ b/crates/benilla-ui/src/script/compat/classic_api/pools.rs
@@ -19,9 +19,9 @@
 //! is exactly how pfUI iterates it (`modules/tooltip.lua:228`). A "tidier" version storing objects
 //! as array values would break that loop silently.
 //!
-//! `CreateFramePool` and `CreateFontStringPool` are **not** built: nothing in the installed set
-//! calls either, and `docs/ADDON_COMPAT.md` records them as unbuilt rather than guessed at. They
-//! are the same mixin over a different factory, so adding one later is small.
+//! `CreateFramePool` and `CreateFontStringPool` are now built too, over the same mixin and their
+//! own factories — a canvas map pools a frame per pin and a FontString per label, and both call
+//! them at file scope the way pfUI calls `CreateTexturePool`.
 
 use mlua::Lua;
 
@@ -136,6 +136,72 @@ function CreateTexturePool(parent, layer, subLayer, textureTemplate, resetterFun
                 resetterFunc or TexturePool_HideAndClearAnchors)
     return pool
 end
+
+FramePoolMixin = CreateFromMixins(ObjectPoolMixin)
+
+-- Upstream names its frames `<parentName>-<frameType>-<n>`, which matters: a pooled frame has to
+-- be reachable by name for a template's own `$parent` children to resolve. An anonymous parent
+-- leaves the pooled frames anonymous too, which is also upstream's behaviour.
+local function FramePoolFactory(pool)
+    pool.numFrames = (pool.numFrames or 0) + 1
+    local name = nil
+    if pool.parent and pool.parent.GetName and pool.parent:GetName() then
+        name = pool.parent:GetName() .. "-" .. (pool.frameType or "Frame") .. "-" .. pool.numFrames
+    end
+    return CreateFrame(pool.frameType or "Frame", name, pool.parent, pool.frameTemplate)
+end
+
+function FramePoolMixin:OnLoad(frameType, parent, frameTemplate, resetterFunc, forbidden)
+    ObjectPoolMixin.OnLoad(self, FramePoolFactory, resetterFunc)
+    self.frameType = frameType
+    self.parent = parent
+    self.frameTemplate = frameTemplate
+    self.forbidden = forbidden
+end
+
+function FramePool_Hide(pool, frame)
+    frame:Hide()
+end
+
+function FramePool_HideAndClearAnchors(pool, frame)
+    frame:Hide()
+    frame:ClearAllPoints()
+end
+
+function CreateFramePool(frameType, parent, frameTemplate, resetterFunc, forbidden)
+    local pool = CreateFromMixins(FramePoolMixin)
+    pool:OnLoad(frameType or "Frame", parent, frameTemplate,
+                resetterFunc or FramePool_HideAndClearAnchors, forbidden)
+    return pool
+end
+
+FontStringPoolMixin = CreateFromMixins(ObjectPoolMixin)
+
+-- 1.12's `CreateFontString(name, layer, inherits)` takes no sub-layer either, so `subLayer` is
+-- kept on the pool and not passed, exactly as `TexturePoolFactory` above does.
+local function FontStringPoolFactory(pool)
+    return pool.parent:CreateFontString(nil, pool.layer, pool.fontStringTemplate)
+end
+
+function FontStringPoolMixin:OnLoad(parent, layer, subLayer, fontStringTemplate, resetterFunc)
+    ObjectPoolMixin.OnLoad(self, FontStringPoolFactory, resetterFunc)
+    self.parent = parent
+    self.layer = layer
+    self.subLayer = subLayer
+    self.fontStringTemplate = fontStringTemplate
+end
+
+function FontStringPool_HideAndClearAnchors(pool, fontString)
+    fontString:Hide()
+    fontString:ClearAllPoints()
+end
+
+function CreateFontStringPool(parent, layer, subLayer, fontStringTemplate, resetterFunc)
+    local pool = CreateFromMixins(FontStringPoolMixin)
+    pool:OnLoad(parent, layer, subLayer, fontStringTemplate or "",
+                resetterFunc or FontStringPool_HideAndClearAnchors)
+    return pool
+end
 "#;
 
 pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
diff --git a/crates/benilla-ui/src/script/editbox.rs b/crates/benilla-ui/src/script/editbox.rs
index 8a808f18..53768422 100644
--- a/crates/benilla-ui/src/script/editbox.rs
+++ b/crates/benilla-ui/src/script/editbox.rs
@@ -27,7 +27,7 @@ use crate::order::{self, DrawLayer, ZTarget};
 use crate::widget::{EditBoxState, FrameHandle, FrameKind, KindState, RegionHandle, RegionKind};
 
 /// Registry key of the EditBox method table (the MAXCSTACK discipline: Lua-side root, named key).
-pub(super) const REG_EDITBOX_METHODS: &str = "__benilla_editbox_methods";
+pub(in crate::script) const REG_EDITBOX_METHODS: &str = "__benilla_editbox_methods";
 
 // ─────────────────────────────────────────────────────────────────────────────────────────────
 // Public entry points
@@ -325,6 +325,14 @@ fn highlight_text(lua: &Lua, h: FrameHandle, start: i64, end: i64) {
     with_eb(lua, h, |eb| eb.highlight_text(start, end));
 }
 
+/// `EditBox:SetCursorPosition(n)`, the later-era caret setter
+/// ([`crate::script::compat`]'s surface row): the caret at character offset `n`, selection
+/// collapsed. Through [`EditBoxState::highlight_text`]'s own clamp and UTF-8 snap, with the two
+/// ends equal, so there is one definition of "where in this string can a caret sit".
+pub(in crate::script) fn set_cursor_position(lua: &Lua, h: FrameHandle, pos: i64) {
+    with_eb(lua, h, |eb| eb.highlight_text(pos, pos));
+}
+
 // ── text-region sync ─────────────────────────────────────────────────────────────────────────
 
 /// Write the display string into the text region; a `password` box shows one `*` per character.
diff --git a/crates/benilla-ui/src/script/extract.rs b/crates/benilla-ui/src/script/extract.rs
index 7bee6240..7ed09b6e 100644
--- a/crates/benilla-ui/src/script/extract.rs
+++ b/crates/benilla-ui/src/script/extract.rs
@@ -260,6 +260,13 @@ impl UiScript {
                     if data_ref.is_some_and(super::nameplate::is_unpainted_glow) {
                         continue;
                     }
+                    // A mask texture (`Frame:CreateMaskTexture`) shapes other regions and is never
+                    // drawn itself. It is still laid out and still resolves, because its rect is
+                    // what the mask covers — which is why this skip is here and not a `hidden`
+                    // flag: hiding it would take it out of the layout too.
+                    if data_ref.is_some_and(|d| d.is_mask) {
+                        continue;
+                    }
                     let mut data = data_ref.cloned().unwrap_or_default();
                     // One hop (region combine `0x772180`): the region's alpha times its owner's
                     // `effective_alpha`, which `SetAlpha 0x76a690` already carries down the tree.
@@ -380,6 +387,18 @@ impl UiScript {
                             // reference's is a texel block it would grey. No stock caller
                             // desaturates a solid.
                             desaturated: data.desaturated && has_path,
+                            // The first mask that has both art and a resolved rect. First, not
+                            // last: see `RegionData::masks` for why the order is the answer and
+                            // why there is one slot. A mask whose own anchors do not resolve is
+                            // walked past rather than taken as an empty rect, which would erase
+                            // the texture it was meant to shape.
+                            mask: data.masks.iter().find_map(|mh| {
+                                let path =
+                                    model.region_data.get(mh).and_then(|d| d.texture.clone())?;
+                                let rect = model.region_resolved.get(mh).copied()?;
+                                Some(super::TextureMask { path, rect })
+                            }),
+                            tile: data.tile,
                         }
                     };
                     // A region draws at its owner's scale: only frames carry one (`0x76ac90`).
diff --git a/crates/benilla-ui/src/script/mod.rs b/crates/benilla-ui/src/script/mod.rs
index 84ebcdb2..06a40563 100644
--- a/crates/benilla-ui/src/script/mod.rs
+++ b/crates/benilla-ui/src/script/mod.rs
@@ -295,7 +295,7 @@ pub use trainer::{
 pub use types::{
     BlendMode, EditAction, EditBoxTextUi, EditOutcome, EditUnit, ExtractedQuad, FontObject,
     FontShadow, Gradient, JustifyH, JustifyV, LineMeasureRequest, MeasureRequest, Outline,
-    QuadContent, ScriptValue, TexCoords, UnitPaneSubject,
+    QuadContent, ScriptValue, TexCoords, TextureMask, UnitPaneSubject,
 };
 pub(crate) use types::{FontExplicit, MeasuredText, RegionData};
 pub use uimap::UiMapNode;
@@ -355,7 +355,7 @@ pub(crate) const REGION_LEAF_SHARED: [&str; 9] = [
 /// Texture-only, each in the client's Texture map (`0x87c128`): `GetVertexColor` though
 /// `SetVertexColor` is shared, and `SetGradientAlpha`, not FontString's `SetAlphaGradient`. 1.12
 /// has no Texture `SetSize` or `SetRotation` (PlayerModel's, `0x84f1fc`/`0x505f00`).
-pub(crate) const TEXTURE_ONLY_METHODS: [&str; 12] = [
+pub(crate) const TEXTURE_ONLY_METHODS: [&str; 22] = [
     "SetGradient",
     "SetGradientAlpha",
     "GetTexture",
@@ -368,6 +368,18 @@ pub(crate) const TEXTURE_ONLY_METHODS: [&str; 12] = [
     "GetTexCoordModifiesRect",
     "SetDesaturated",
     "GetVertexColor",
+    // Beyond 1.12, each with its `ALLOWED_BEYOND` row: the mask pair and the later-era
+    // `SetRotation`/`SetDesaturation`/tile getters and setters a canvas map is written against.
+    "AddMaskTexture",
+    "RemoveMaskTexture",
+    "SetRotation",
+    "GetRotation",
+    "SetDesaturation",
+    "GetDesaturation",
+    "SetHorizTile",
+    "GetHorizTile",
+    "SetVertTile",
+    "GetVertTile",
 ];
 
 /// FontString-only: the font, text, justify and shadow block and the string metrics.
diff --git a/crates/benilla-ui/src/script/model.rs b/crates/benilla-ui/src/script/model.rs
index d75de623..0c8cc488 100644
--- a/crates/benilla-ui/src/script/model.rs
+++ b/crates/benilla-ui/src/script/model.rs
@@ -1197,6 +1197,10 @@ pub(crate) struct Model {
     /// `RegisterForDrag` buttons per frame, compared case-insensitively. Nothing destroys a frame,
     /// so this, `scripts` and `frame_events` are never pruned; a destroy path must prune all three.
     pub(crate) drag_registered: HashMap<FrameHandle, HashSet<String>>,
+    /// `Frame:SetPropagateKeyboardInput` (`compat/classic_api/frame.rs`), per frame; absent is
+    /// `true`, which is what this client does unconditionally. **Stored, not applied** — 1.12 has
+    /// no swallow mode for `false` to select — so this exists so the getter answers the setter.
+    pub(crate) propagate_keyboard: HashMap<FrameHandle, bool>,
     /// The drag gesture, armed by a press on a drag-registered frame, started past the threshold.
     pub(crate) drag: Option<cursor::DragGesture>,
     /// The one `StartMoving()` in flight, the client's `root+0xcfc` slot, apart from `drag` as in
@@ -2198,6 +2202,7 @@ impl Model {
             container_autoequips: Vec::new(),
             bag_autostores: Vec::new(),
             drag_registered: HashMap::new(),
+            propagate_keyboard: HashMap::new(),
             drag: None,
             moving: None,
             sizing: None,
diff --git a/crates/benilla-ui/src/script/region/paint.rs b/crates/benilla-ui/src/script/region/paint.rs
index 11f412a9..af9210a4 100644
--- a/crates/benilla-ui/src/script/region/paint.rs
+++ b/crates/benilla-ui/src/script/region/paint.rs
@@ -293,6 +293,148 @@ pub(super) fn install(lua: &Lua, m: &Table) -> mlua::Result<()> {
         })?,
     )?;
 
+    // AddMaskTexture(mask) / RemoveMaskTexture(mask), Texture only, **beyond 1.12** (surface row
+    // in `script/tests/widget_surface.rs`): the later-era way to shape a texture by another
+    // region's alpha. 1.12 has no masking at all — its one masked thing is the minimap disc, cut
+    // engine-side — and nothing can stand in for it, because the whole point is that a
+    // *rectangular* texture draws as a non-rectangular shape.
+    //
+    // It is built rather than refused because a seamless world map is exactly that operation: a
+    // zone's art is a rectangle of parchment and the map wants it clipped to the zone's coastline,
+    // so without this every zone draws as an overlapping paper rectangle with its neighbours'
+    // oceans and labels showing through. OpenMapClassic's own changelog names the symptom ("no
+    // overlapping parchment rectangles / duplicated sea labels").
+    //
+    // The argument is the mask region itself, so the list stores handles and the resolved art and
+    // rect are read at extract time — a mask that moves or changes art moves the cut with it,
+    // which is what a panning map needs. A non-region argument is ignored rather than raised on:
+    // every caller is `if mask then tex:AddMaskTexture(mask) end`, and the masks here come from
+    // generated media that may simply not ship.
+    for (name, add) in [("AddMaskTexture", true), ("RemoveMaskTexture", false)] {
+        m.set(
+            name,
+            lua.create_function(move |lua, (this, mask): (Table, Value)| {
+                let rh = region_handle_of(lua, &this)?;
+                let Value::Table(t) = mask else {
+                    return Ok(());
+                };
+                let Ok(mh) = region_handle_of(lua, &t) else {
+                    return Ok(());
+                };
+                let mut model = lua.app_data_mut::<Model>().expect("model");
+                let d = model.region_data.entry(rh).or_default();
+                if add {
+                    if !d.masks.contains(&mh) {
+                        d.masks.push(mh);
+                    }
+                } else {
+                    d.masks.retain(|&h| h != mh);
+                }
+                Ok(())
+            })?,
+        )?;
+    }
+
+    // SetRotation(radians) / GetRotation(), Texture only, **beyond 1.12**: 1.12 registers
+    // `SetRotation` on PlayerModel alone (`0x84f1fc`), so a Texture there cannot turn. The
+    // renderer has carried `RegionData::rotation` since the minimap arrow, which is drawn by the
+    // host; this is the Lua setter for it, and the quad path already negates it for the pass's
+    // clockwise convention. Counterclockwise-positive, as the later-era method is.
+    m.set(
+        "SetRotation",
+        lua.create_function(|lua, (this, radians): (Table, Option<f32>)| {
+            let rh = region_handle_of(lua, &this)?;
+            let mut model = lua.app_data_mut::<Model>().expect("model");
+            // A non-finite angle would rotate the quad's corners to NaN and drop it silently.
+            let r = radians.filter(|r| r.is_finite()).unwrap_or(0.0);
+            model.region_data.entry(rh).or_default().rotation = r;
+            Ok(())
+        })?,
+    )?;
+    m.set(
+        "GetRotation",
+        lua.create_function(|lua, this: Table| {
+            let rh = region_handle_of(lua, &this)?;
+            let model = lua.app_data_ref::<Model>().expect("model");
+            Ok(model.region_data.get(&rh).map_or(0.0, |d| d.rotation))
+        })?,
+    )?;
+
+    // SetDesaturation(amount) / GetDesaturation(), Texture only, **beyond 1.12**: the later-era
+    // *fractional* form of `SetDesaturated` above, 0 full colour and 1 fully grey.
+    //
+    // This renderer greys all-or-nothing (one material flag, not a blend weight), so a fraction is
+    // taken as on past the midpoint. That is a real approximation and it is the honest one
+    // available: the alternative is refusing the method, and a caller's only use of it is to dim
+    // art it has already decided to dim — OpenMapClassic desaturates its minimap tiles by a fixed
+    // 0.5 so the painted map reads over them. The getter answers back what was set, not the
+    // rounded flag, so a caller reading its own value sees its own number.
+    m.set(
+        "SetDesaturation",
+        lua.create_function(|lua, (this, amount): (Table, Option<f32>)| {
+            let rh = region_handle_of(lua, &this)?;
+            let mut model = lua.app_data_mut::<Model>().expect("model");
+            let a = amount
+                .filter(|a| a.is_finite())
+                .unwrap_or(0.0)
+                .clamp(0.0, 1.0);
+            let d = model.region_data.entry(rh).or_default();
+            d.desaturation = a;
+            d.desaturated = a > 0.5;
+            Ok(())
+        })?,
+    )?;
+    m.set(
+        "GetDesaturation",
+        lua.create_function(|lua, this: Table| {
+            let rh = region_handle_of(lua, &this)?;
+            let model = lua.app_data_ref::<Model>().expect("model");
+            Ok(model.region_data.get(&rh).map_or(0.0, |d| d.desaturation))
+        })?,
+    )?;
+
+    // SetHorizTile/SetVertTile and their getters, Texture only, **beyond 1.12**: repeat the art
+    // across the region at its own texel size instead of stretching it to fit.
+    //
+    // 1.12 reaches the same end through `SetTexCoord(0, n, 0, 1)` — UVs past the texture, which is
+    // the idiom this renderer already keys its wrap mode on (`extract::tiling_axes`) — but it has
+    // no switch that says "however many times it takes", because that count depends on the art's
+    // texel size and 1.12's Lua is never told it. So the flag is carried and the host computes the
+    // count once the art has loaded. An explicit `SetTexCoord` wins, because it names the count.
+    for (name, vertical) in [("SetHorizTile", false), ("SetVertTile", true)] {
+        m.set(
+            name,
+            lua.create_function(move |lua, (this, on): (Table, Option<bool>)| {
+                let rh = region_handle_of(lua, &this)?;
+                let mut model = lua.app_data_mut::<Model>().expect("model");
+                let d = model.region_data.entry(rh).or_default();
+                let on = on.unwrap_or(false);
+                if vertical {
+                    d.tile.1 = on;
+                } else {
+                    d.tile.0 = on;
+                }
+                Ok(())
+            })?,
+        )?;
+    }
+    for (name, vertical) in [("GetHorizTile", false), ("GetVertTile", true)] {
+        m.set(
+            name,
+            lua.create_function(move |lua, this: Table| {
+                let rh = region_handle_of(lua, &this)?;
+                let model = lua.app_data_ref::<Model>().expect("model");
+                Ok(model.region_data.get(&rh).is_some_and(|d| {
+                    if vertical {
+                        d.tile.1
+                    } else {
+                        d.tile.0
+                    }
+                }))
+            })?,
+        )?;
+    }
+
     // GetTexture (`0x79ba70`), Texture only, answers one value: "Solid Texture" for the colour
     // form (`0x835708`), not nil, and a path cut at its last `.` (`0x79baf0`), even a dot in a
     // directory name, as the client cuts it.
diff --git a/crates/benilla-ui/src/script/tests/reference_surface.rs b/crates/benilla-ui/src/script/tests/reference_surface.rs
index 4b580c4f..4ed8d119 100644
--- a/crates/benilla-ui/src/script/tests/reference_surface.rs
+++ b/crates/benilla-ui/src/script/tests/reference_surface.rs
@@ -734,6 +734,32 @@ fn allowed_beyond_1_12() -> HashSet<&'static str> {
         // same reveal gate, published in the shape the canvas framework reads
         // (script/compat/classic_api/uimap.rs).
         "C_MapExplorationInfo",
+        // 4.x's cross-realm name shortener. 1.12 has no connected realms and no cross-realm
+        // names, so this is the identity on the part that matters; the `-Realm` split is still
+        // applied because a custom realm can hand out a hyphenated name and the caller's whole
+        // purpose is the short one. Called unguarded on a chat sender (`Map/Pins.lua:286`).
+        "Ambiguate",
+        // 2.x's rename of 1.12's own FrameXML `GetDifficultyColor`. Registered as a **forwarder**
+        // to that function rather than a copy of its table, so the colours are whatever the
+        // player's own chain says and the two spellings cannot drift.
+        "GetQuestDifficultyColor",
+        // 2.0's predicate over 1.12's own modified-click *bindings*: 1.12 has
+        // `GetModifiedClick`/`SetModifiedClick` and its FrameXML tests the key itself, but
+        // registers nothing that does both steps. So this composes two verbs this client already
+        // answers rather than adding state.
+        "IsModifiedClick",
+        // ClassicAPI's object pools, the frame and font-string halves beside the texture pool
+        // already here (`compat/classic_api/pools.rs`): a canvas map pools a frame per pin and a
+        // FontString per label, and calls both at file scope the way pfUI calls
+        // `CreateTexturePool`. The mixins and the default resetters are upstream's own names,
+        // which is what a caller passing `FramePool_HideAndClearAnchors` by name needs.
+        "CreateFramePool",
+        "FramePoolMixin",
+        "FramePool_Hide",
+        "FramePool_HideAndClearAnchors",
+        "CreateFontStringPool",
+        "FontStringPoolMixin",
+        "FontStringPool_HideAndClearAnchors",
         // The two argument *shapes* `C_Map`'s uiMapID members take. 1.12 passes coordinates as
         // loose numbers and has no vector or map-point object; a caller cannot call
         // `C_Map.SetUserWaypoint` or `C_Map.GetWorldPosFromMapPos` without them, and every call
diff --git a/crates/benilla-ui/src/script/tests/regions.rs b/crates/benilla-ui/src/script/tests/regions.rs
index f0e75f34..449b4a2d 100644
--- a/crates/benilla-ui/src/script/tests/regions.rs
+++ b/crates/benilla-ui/src/script/tests/regions.rs
@@ -856,13 +856,18 @@ fn the_two_region_leaves_answer_their_own_maps() {
         assert!(has(&s, "Tex", m), "a Texture answers {m}");
         assert!(!has(&s, "Str", m), "a FontString must NOT answer {m}");
     }
-    // `SetRotation` is 1.12's PlayerModel verb (`0x84f1fc`/`0x505f00`), in neither leaf map.
-    for leaf in ["Tex", "Str"] {
-        assert!(
-            !has(&s, leaf, "SetRotation"),
-            "SetRotation is not a region method"
-        );
-    }
+    // `SetRotation` is 1.12's PlayerModel verb (`0x84f1fc`/`0x505f00`) and no FontString's; the
+    // later-era Texture spelling is built and carries its own `ALLOWED_BEYOND` row
+    // (`compat/classic_api/frame.rs`'s surface list), so the split, not the absence, is the rule
+    // here: a Texture may turn and a FontString may not.
+    assert!(
+        has(&s, "Tex", "SetRotation"),
+        "a Texture answers SetRotation"
+    );
+    assert!(
+        !has(&s, "Str", "SetRotation"),
+        "a FontString must NOT answer SetRotation"
+    );
     // FontString-only.
     for m in [
         "SetText",
@@ -1530,3 +1535,215 @@ fn the_visibility_reading_includes_named_regions_and_their_owners_state() {
         "an owner that is hidden hides its regions"
     );
 }
+
+/// A mask shapes the texture it was added to and draws nothing of its own.
+///
+/// Both halves matter and both were easy to get wrong. The mask's *rect* is what it covers, so it
+/// has to stay in the layout — which is why it is skipped at extract rather than marked hidden —
+/// and the masked quad has to carry the mask's own resolved rect, not the texture's, or a panning
+/// tile would drag its cut-out along with it.
+#[test]
+fn a_mask_texture_shapes_its_subject_and_never_draws_itself() {
+    let mut s = script();
+    s.set_screen_size(800.0, 600.0);
+    s.run(
+        r#"
+        local f = CreateFrame("Frame", "MaskOwner")
+        f:SetPoint("BOTTOMLEFT", 0, 0)
+        f:SetWidth(200) f:SetHeight(100)
+        art = f:CreateTexture("MaskArt", "ARTWORK")
+        art:SetTexture("Interface\\WorldMap\\Elwynn\\Elwynn1")
+        art:SetAllPoints()
+        cut = f:CreateMaskTexture("MaskCut", "ARTWORK")
+        cut:SetTexture("Interface\\AddOns\\Thing\\land")
+        cut:SetPoint("BOTTOMLEFT", f, "BOTTOMLEFT", 10, 20)
+        cut:SetWidth(50) cut:SetHeight(40)
+    "#,
+    )
+    .unwrap();
+    s.resolve();
+
+    let textures = |s: &UiScript| -> Vec<(Option<String>, Option<crate::script::TextureMask>)> {
+        s.extract()
+            .iter()
+            .filter_map(|q| match &q.content {
+                QuadContent::Texture { path, mask, .. } => Some((path.clone(), mask.clone())),
+                _ => None,
+            })
+            .collect()
+    };
+
+    let before = textures(&s);
+    assert_eq!(
+        before.len(),
+        1,
+        "the mask is not drawn, so only the art emits a quad: {before:?}"
+    );
+    assert!(before[0].1.is_none(), "and it is unmasked until asked");
+
+    s.run("art:AddMaskTexture(cut)").unwrap();
+    let after = textures(&s);
+    assert_eq!(after.len(), 1, "still one quad");
+    let mask = after[0].1.clone().expect("the art now carries the mask");
+    assert_eq!(mask.path, "Interface\\AddOns\\Thing\\land");
+    // The mask's own rect, which is a quarter the width of the art it shapes.
+    assert!(
+        (mask.rect.left - 10.0).abs() < 0.01
+            && (mask.rect.bottom - 20.0).abs() < 0.01
+            && (mask.rect.right - 60.0).abs() < 0.01
+            && (mask.rect.top - 60.0).abs() < 0.01,
+        "the mask's resolved rect, not the texture's: {:?}",
+        mask.rect
+    );
+
+    s.run("art:RemoveMaskTexture(cut)").unwrap();
+    assert!(
+        textures(&s)[0].1.is_none(),
+        "removing it takes the cut off again"
+    );
+}
+
+/// `AddMaskTexture` keeps the list in call order and the **first** is the one applied, because
+/// that is the one that shapes the subject — a stitched map adds the zone's land mask first and
+/// its refinements after. A second add of the same mask is not a second entry.
+#[test]
+fn the_first_mask_added_is_the_one_applied() {
+    let mut s = script();
+    s.set_screen_size(800.0, 600.0);
+    s.run(
+        r#"
+        local f = CreateFrame("Frame", "TwoMaskOwner")
+        f:SetPoint("BOTTOMLEFT", 0, 0)
+        f:SetWidth(200) f:SetHeight(100)
+        art = f:CreateTexture(nil, "ARTWORK")
+        art:SetTexture("Interface\\WorldMap\\Elwynn\\Elwynn1")
+        art:SetAllPoints()
+        land = f:CreateMaskTexture(nil, "ARTWORK")
+        land:SetTexture("land") land:SetAllPoints()
+        hole = f:CreateMaskTexture(nil, "ARTWORK")
+        hole:SetTexture("hole") hole:SetAllPoints()
+        art:AddMaskTexture(land)
+        art:AddMaskTexture(hole)
+        art:AddMaskTexture(land)
+    "#,
+    )
+    .unwrap();
+    s.resolve();
+    let applied = s
+        .extract()
+        .iter()
+        .find_map(|q| match &q.content {
+            QuadContent::Texture {
+                path: Some(_),
+                mask: Some(m),
+                ..
+            } => Some(m.path.clone()),
+            _ => None,
+        })
+        .expect("the masked art");
+    assert_eq!(applied, "land", "first added wins");
+
+    // Taking the first off promotes the second, which is what a caller swapping a mask means.
+    s.run("art:RemoveMaskTexture(land)").unwrap();
+    let applied = s
+        .extract()
+        .iter()
+        .find_map(|q| match &q.content {
+            QuadContent::Texture {
+                path: Some(_),
+                mask: Some(m),
+                ..
+            } => Some(m.path.clone()),
+            _ => None,
+        })
+        .expect("still masked");
+    assert_eq!(applied, "hole");
+}
+
+/// A mask whose own anchors never resolve is walked past rather than taken as an empty rect: an
+/// empty mask erases the texture it was meant to shape, which looks like the art failing to load.
+#[test]
+fn an_unresolved_mask_is_walked_past_not_applied_as_nothing() {
+    let mut s = script();
+    s.set_screen_size(800.0, 600.0);
+    s.run(
+        r#"
+        local f = CreateFrame("Frame", "BadMaskOwner")
+        f:SetPoint("BOTTOMLEFT", 0, 0)
+        f:SetWidth(200) f:SetHeight(100)
+        art = f:CreateTexture(nil, "ARTWORK")
+        art:SetTexture("Interface\\WorldMap\\Elwynn\\Elwynn1")
+        art:SetAllPoints()
+        -- Art but no anchors: a region nobody placed, which never resolves.
+        orphan = f:CreateMaskTexture(nil, "ARTWORK")
+        orphan:SetTexture("orphan")
+        orphan:ClearAllPoints()
+        good = f:CreateMaskTexture(nil, "ARTWORK")
+        good:SetTexture("good") good:SetAllPoints()
+        art:AddMaskTexture(orphan)
+        art:AddMaskTexture(good)
+    "#,
+    )
+    .unwrap();
+    s.resolve();
+    let applied = s
+        .extract()
+        .iter()
+        .find_map(|q| match &q.content {
+            QuadContent::Texture {
+                path: Some(_),
+                mask,
+                ..
+            } => Some(mask.clone().map(|m| m.path)),
+            _ => None,
+        })
+        .expect("the art quad");
+    assert_eq!(
+        applied.as_deref(),
+        Some("good"),
+        "the unplaced mask is skipped and the next one applies"
+    );
+}
+
+/// The later-era `SetRotation`/`SetDesaturation` and the tile pair round-trip, and the fractional
+/// desaturation rounds onto the one material flag this renderer has.
+#[test]
+fn the_later_era_texture_dials_round_trip() {
+    let s = script();
+    s.run(
+        r#"
+        local f = CreateFrame("Frame", "DialOwner")
+        t = f:CreateTexture("DialArt", "ARTWORK")
+        t:SetTexture("Interface\\Icons\\Spell_Nature_Sleep")
+    "#,
+    )
+    .unwrap();
+    assert_eq!(s.eval::<f64>("return t:GetRotation()").unwrap(), 0.0);
+    s.run("t:SetRotation(1.5)").unwrap();
+    assert!((s.eval::<f64>("return t:GetRotation()").unwrap() - 1.5).abs() < 1e-6);
+    // A non-finite angle would send the quad's corners to NaN and drop it with no error.
+    s.run("t:SetRotation(0/0)").unwrap();
+    assert_eq!(s.eval::<f64>("return t:GetRotation()").unwrap(), 0.0);
+
+    assert_eq!(s.eval::<f64>("return t:GetDesaturation()").unwrap(), 0.0);
+    s.run("t:SetDesaturation(0.4)").unwrap();
+    assert!(
+        (s.eval::<f64>("return t:GetDesaturation()").unwrap() - 0.4).abs() < 1e-6,
+        "the getter answers the caller's own fraction"
+    );
+    assert!(
+        !desaturated(&s, "DialArt"),
+        "…and below the midpoint the one flag stays off"
+    );
+    s.run("t:SetDesaturation(0.8)").unwrap();
+    assert!(desaturated(&s, "DialArt"), "past it, on");
+
+    assert!(!s.eval::<bool>("return t:GetHorizTile()").unwrap());
+    assert!(!s.eval::<bool>("return t:GetVertTile()").unwrap());
+    s.run("t:SetHorizTile(true)").unwrap();
+    assert!(s.eval::<bool>("return t:GetHorizTile()").unwrap());
+    assert!(
+        !s.eval::<bool>("return t:GetVertTile()").unwrap(),
+        "one axis at a time"
+    );
+}
diff --git a/crates/benilla-ui/src/script/tests/widget_surface.rs b/crates/benilla-ui/src/script/tests/widget_surface.rs
index 95c56c1d..12c1ce13 100644
--- a/crates/benilla-ui/src/script/tests/widget_surface.rs
+++ b/crates/benilla-ui/src/script/tests/widget_surface.rs
@@ -405,6 +405,112 @@ const ALLOWED_BEYOND: &[(&str, &str, &str)] = &[
          the two spellings cannot drift. Ace3 calls it unguarded on every button it builds \
          (AceConfigDialog-3.0.lua:586)",
     ),
+    (
+        "AddMaskTexture",
+        "Texture",
+        "The map canvas: 1.12 has no texture masking at all, and nothing can stand in for it \
+         because the point is that a RECTANGULAR texture draws as a non-rectangular shape. A \
+         seamless world map is that operation and nothing else — a zone's parchment cut to the \
+         zone's coastline — so without it every zone draws as a paper rectangle over its \
+         neighbours' oceans and labels. Called unguarded where it is used: Map/Close.lua:162",
+    ),
+    (
+        "RemoveMaskTexture",
+        "Texture",
+        "The other half of AddMaskTexture, so a caller that swaps a mask can take the old one \
+         off; without it a re-masked tile keeps the first cut forever",
+    ),
+    (
+        "CreateMaskTexture",
+        "Button CheckButton ColorSelect DressUpModel EditBox Frame GameTooltip LootButton MessageFrame Minimap Model MovieFrame PlayerModel ScrollFrame ScrollingMessageFrame SimpleHTML Slider StatusBar TabardModel WorldFrame",
+        "The region AddMaskTexture takes: a Texture that shapes others and never draws itself. \
+         Built over the stock CreateTexture on the same table, so a mask is an ordinary Texture \
+         in every other respect. Map/Close.lua:159 builds one before any texture can ask for it",
+    ),
+    (
+        "SetRotation",
+        "Texture",
+        "1.12 registers SetRotation on PlayerModel alone (0x84f1fc), so a Texture there cannot \
+         turn. The renderer has carried the angle since the minimap arrow, which the host draws; \
+         this is the Lua setter for it. The map's own player arrow and its compass rail need it",
+    ),
+    (
+        "GetRotation",
+        "Texture",
+        "The read half of SetRotation, so the pair round-trips; 0 by default",
+    ),
+    (
+        "SetDesaturation",
+        "Texture",
+        "The later-era FRACTIONAL form of 1.12's own SetDesaturated. This renderer greys \
+         all-or-nothing (one material flag, not a blend weight), so a fraction is taken as on \
+         past the midpoint — an approximation, and the honest one available, since the only use \
+         of it in the corpus is dimming art the caller has already decided to dim \
+         (Map/Close.lua desaturates minimap tiles by a fixed amount so the painted map reads \
+         over them)",
+    ),
+    (
+        "GetDesaturation",
+        "Texture",
+        "The read half, answering the caller's own fraction rather than the rounded flag",
+    ),
+    (
+        "SetHorizTile",
+        "Texture",
+        "Repeat the art across the region at its own texel size. 1.12 reaches the same end with \
+         SetTexCoord(0, n, 0, 1) — UVs past the texture, which is the idiom this renderer keys \
+         its wrap mode on — but has no switch meaning 'however many times it takes', because \
+         that count is rect/texels and 1.12's Lua is never told the texel size. Applied: the \
+         host computes the count once the art has loaded, and an explicit SetTexCoord wins",
+    ),
+    (
+        "SetVertTile",
+        "Texture",
+        "As SetHorizTile, for the other axis",
+    ),
+    (
+        "GetHorizTile",
+        "Texture",
+        "The read half of SetHorizTile; false by default",
+    ),
+    (
+        "GetVertTile",
+        "Texture",
+        "The read half of SetVertTile; false by default",
+    ),
+    (
+        "HasFocus",
+        "EditBox",
+        "1.12's EditBox table has SetFocus and ClearFocus and no getter at all, so an addon of \
+         that era keeps its own flag. The fact is already tracked here (Model::focused_editbox, \
+         the client's own DAT_00cf4dc8) and was simply never published. Called unguarded inside \
+         an OnEditFocusLost callback (Map/Nav.lua:374), so a nil method raised every time a \
+         search box lost focus",
+    ),
+    (
+        "SetCursorPosition",
+        "EditBox",
+        "1.12 has no cursor setter at all — the caret moves only by typing, clicking or \
+         HighlightText. Lands through HighlightText's own clamp and UTF-8 snap with the selection \
+         collapsed, so there is one definition of where a caret may sit. Map/News.lua:282 calls \
+         it to scroll a long read-only link box back to its start",
+    ),
+    (
+        "SetPropagateKeyboardInput",
+        "Button CheckButton ColorSelect DressUpModel EditBox Frame GameTooltip LootButton MessageFrame Minimap Model MovieFrame PlayerModel ScrollFrame ScrollingMessageFrame SimpleHTML Slider StatusBar TabardModel WorldFrame",
+        "4.x's switch for whether a frame with an OnKeyDown handler lets the key reach the next \
+         frame and the binding system. STORED, NOT APPLIED, and the reason is that 1.12's answer \
+         is always-propagate: its key routing hands the key to the binding system regardless of \
+         what a handler did, so there is no swallow mode for false to select. Refusing it costs a \
+         caller its whole key path — Map/Sketch.lua:579 arms a catcher frame and flips the flag \
+         inside its own handler, so a nil method raises once per keypress",
+    ),
+    (
+        "GetPropagateKeyboardInput",
+        "Button CheckButton ColorSelect DressUpModel EditBox Frame GameTooltip LootButton MessageFrame Minimap Model MovieFrame PlayerModel ScrollFrame ScrollingMessageFrame SimpleHTML Slider StatusBar TabardModel WorldFrame",
+        "The read half, so the pair round-trips; true by default, which is what this client does \
+         unconditionally",
+    ),
     (
         "CanWordWrap",
         "FontString",
diff --git a/crates/benilla-ui/src/script/types.rs b/crates/benilla-ui/src/script/types.rs
index 23250e96..4981e7f6 100644
--- a/crates/benilla-ui/src/script/types.rs
+++ b/crates/benilla-ui/src/script/types.rs
@@ -168,6 +168,14 @@ pub enum QuadContent {
         /// `SetDesaturated`: the texel draws as its luminance, then is tinted by `color`, since
         /// `SetItemButtonDesaturated` passes a dim tint with the flag.
         desaturated: bool,
+        /// `Texture:AddMaskTexture`'s first mask, resolved: the mask art and the screen rect it
+        /// covers. `None` is unmasked, which every 1.12 texture is.
+        mask: Option<TextureMask>,
+        /// `SetHorizTile`/`SetVertTile`: sample with repeat addressing across the region at the
+        /// art's own texel size. Carried as a flag rather than as UVs because the repeat count is
+        /// `rect / texels` and the texel size is only known once the art has loaded, which is in
+        /// the host's half.
+        tile: (bool, bool),
     },
     /// A `ColorSelect`'s `<ColorWheelTexture>` disc, generated: the pixel at normalised offset
     /// `(nx, ny)` from the centre is `HSV(atan2(ny, nx)·180/π + 180, min(|n|, 1), 1)`, inverting
@@ -369,6 +377,22 @@ pub struct ExtractedQuad {
     pub scale: f32,
 }
 
+/// A resolved mask over a Texture quad (`Texture:AddMaskTexture`): the mask region's own art and
+/// the rect it occupies on screen, in the same y-up UI space as [`ExtractedQuad::rect`].
+///
+/// The mask is **screen-anchored**, not UV-anchored, because that is what the method means: the
+/// mask is another region with its own anchors, and the masked texture keeps only the fragments
+/// the mask's alpha covers at that place. A tile panning under a fixed cut-out masks correctly,
+/// which is the whole reason a stitched map uses one — a zone's rectangular art clipped to the
+/// zone's coastline.
+#[derive(Clone, Debug, PartialEq)]
+pub struct TextureMask {
+    /// The mask art's path; its **alpha** is the coverage.
+    pub path: String,
+    /// The mask's resolved rect, y-up UI space.
+    pub rect: crate::layout::Rect,
+}
+
 /// A two-stop linear gradient (`SetGradientAlpha`/`SetGradient`).
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Gradient {
@@ -438,6 +462,10 @@ pub(crate) struct RegionData {
     pub(crate) anchors: Vec<Anchor>,
     /// `SetDesaturated` (`0x79c1e0`): the renderer greys the texel, so the binding reports support.
     pub(crate) desaturated: bool,
+    /// The later-era `SetDesaturation`'s fraction, which [`Self::desaturated`] rounds for the one
+    /// material flag this renderer has. Kept so the getter answers the caller's own number rather
+    /// than the rounded flag.
+    pub(crate) desaturation: f32,
     /// `SetNonSpaceWrap`/`CanNonSpaceWrap` (`0x79e9f0`/`0x79ead0`), `None` on. Stored, not applied:
     /// the reference's flag `0x40` drives a mid-word wrap and the ellipsis fit count (`0x771ec0`).
     pub(crate) non_space_wrap: Option<bool>,
@@ -466,8 +494,28 @@ pub(crate) struct RegionData {
     /// `0x79c080`). Stored, not applied: there a set flag makes `SetTexCoord` re-derive the rect
     /// from the UV quad (`0x770462`); no stock or corpus code sets it.
     pub(crate) tex_coord_modifies_rect: bool,
-    /// Rotation about the centre, radians counterclockwise; always 0: 1.12 has no Texture setter.
+    /// Rotation about the centre, radians counterclockwise. 1.12 has no Texture setter; the
+    /// later-era `Texture:SetRotation` writes it (`compat/classic_api/frame.rs`'s surface row).
     pub(crate) rotation: f32,
+    /// `AddMaskTexture`'s masks in call order, `RemoveMaskTexture`'s removals taken out.
+    ///
+    /// **Only the first is drawn.** The render pass carries one mask slot per quad
+    /// ([`crate::script::TextureMask`]), and widening it is a second texture binding and a second
+    /// uniform on every UI quad in the client. The list is kept whole anyway, because the methods
+    /// have to round-trip for a caller that adds and removes, and because the *order* decides
+    /// which one wins — first added, which for a stitched map is the zone's land mask, the one
+    /// that shapes the coastline. A second mask is recorded and not applied.
+    pub(crate) masks: Vec<crate::widget::RegionHandle>,
+    /// A mask texture (`Frame:CreateMaskTexture`), which shapes other regions and never draws
+    /// itself. 1.12 has no such region kind, so this is a flag on an ordinary Texture rather than
+    /// a `RegionKind`: every other method on it behaves exactly as a Texture's, which is what the
+    /// callers do with it — they set its art, size and anchors and then hand it to
+    /// `AddMaskTexture`.
+    pub(crate) is_mask: bool,
+    /// `SetHorizTile`/`SetVertTile` (`GetHorizTile`/`GetVertTile` read them back). Applied: the
+    /// host repeats the art across the region at its own texel size when no explicit `SetTexCoord`
+    /// says otherwise.
+    pub(crate) tile: (bool, bool),
     /// The font object this FontString inherits (`FONTINSTANCE+0x028`, a FontString's `+0xd0`), a
     /// live link: its paint is copied below, and
     /// [`script::font::propagate`](super::font::propagate) repaints on a change.
diff --git a/docs/ADDON_COMPAT.md b/docs/ADDON_COMPAT.md
index 607bf9f5..d5d006f2 100644
--- a/docs/ADDON_COMPAT.md
+++ b/docs/ADDON_COMPAT.md
@@ -459,6 +459,7 @@ a loot roll"; it does not, because that module never runs.** The call path was n
 | `C_TaxiMap.GetTaxiNodesForMap` — **the flight-master layer** | done | `compat/classic_api/taxi_map.rs` over a new feed, `ui_taxi/map_nodes.rs`; supersedes this member in the "not built" row below, which stands for the rest of its list. The guard that row cites is exactly why it mattered: pfQuest *is* guarded, so the absence produced no error at all — `pfDatabase:SearchFlightNodes` returned an empty table, the user's "flight masters" option stayed ticked, and nothing was ever drawn. Same silent-by-construction shape as `C_Map.GetAreas` above, and the same consumer. This install's pfQuest has **deleted** its shipped `pfDB.meta.flight` table for this call (`db/meta.lua:181` is a stub whose comment says the data "always comes live from the client (ClassicAPI)"), so there is no fallback behind it. **The contract is half read off the DLL and half off the caller**, and the file says which is which: `C_TaxiMap`, `GetTaxiNodesForMap`, `nodeID`, `faction`, `reachable`, `state` and the `FlightPathFaction`/`FlightPathState` enum names are all in the bundled `ClassicAPI.dll`'s string pool; the `areaID`/`mapX`/`mapY` triple is **not** separately visible there (the pool holds one copy of each string and `C_Map.GetAreaTriggerInfo` already uses all three), so for those the authority is `SearchFlightNodes` itself — it reads all six fields, gates on `if show and node.areaID and node.mapX and node.mapY`, and feeds the pair into `pfMap:AddNode` as `meta.x`/`meta.y`, which `UpdateNodes` divides by 100, so they are **percentages of the zone rect**. Faction comes from the two `MountCreatureID` columns, which is the reference's own gate (the taxi window asks for the mount of the player's half, `0x4a2650`): one column filled is that faction, both is neutral. A row with **neither** is reported neutral rather than dropped, deliberately and with the reason in the code — OctoWoW ships custom flight points and a custom row with unfilled mount columns is still a flight master standing in the world, so a stray icon is the cheaper mistake than a missing feature; the seed logs that count so the choice stays visible. Zone and percentage come from `WorldMapUiData::zone_at`, which asks `map_proj::zone_uv` for containment rather than comparing rects itself, so a node is only ever attributed to a zone whose own map the window would place it inside; where rects nest (every city sits inside its parent zone) the **smallest** wins, because a flight master in Ironforge belongs on the Ironforge map, which is also the map the player is looking at while standing there. 1.12 has no verb that asks this question, so that choice is ours and is labelled as such. **Seeded before the interface loads**, beside the world-map catalog and after it (it reads those rects), and the deadline is tighter than file scope: pfQuest replays its saved tracking selections once on `PLAYER_ENTERING_WORLD` and then calls `this:UnregisterAllEvents()` (`database.lua:131-151`), so a push one frame later is a push after the only read and the layer stays empty for the session. **Not built, each for the same reason**: `GetTaxiRoute`, `GetTaxiPaths` and `GetTaxiPathWaypoints` are `TaxiPath`/`TaxiPathNode` data, which `ui_taxi/routing.rs` loads for the window's own route search and has never pushed into the VM, and nothing in the corpus calls them; `GetAllTaxiNodes` is in the pool with no caller to read its shape against, and guessing it would be inventing a contract rather than matching one. Also absent from each node, with the reason stated in the file: `reachable` and `state`, which are session facts the open window owns (`model.taxi`, which exists only while a flight master has the frame up) — answering `reachable = false` for all 60 nodes because no window is open would be a confident wrong answer, where an absent field is a truthful "this build does not say" |
 | `C_EncodingUtil` (8), `C_FriendList.SetFriendNotes`, `C_Item.GetCurrentItemLevel`, `C_Map.GetAreaTriggerInfo`, `C_SpellBook.GetSkillLineRank`, `C_TaxiMap.GetTaxiNodesForMap`, `C_Spell.IsSpellInRange`/`IsNextMeleeSpell`/`IsRangedAutoAttackSpell`/`ResetsMeleeSwing`, `C_Item.RequestLoadItemDataByID`, `C_LootHistory.*` | not built | Each either guarded by its caller (all of pfQuest's) or behind a user action not yet taken: `SetFriendNotes` on editing a friend note, `SerializeJSON` on sharing a config, `GetCurrentItemLevel` behind `if ShaguScore` (an addon not installed), the hunter range pair on a hunter's bar. None raises in ordinary play as installed |
 | `C_Map`'s uiMapID half (14 members), `C_MapExplorationInfo`, `Enum.UIMapType`, `CreateVector2D`, `UiMapPoint` — **the map graph** | done | `script/uimap.rs` builds the graph, `compat/classic_api/uimap.rs` publishes it; supersedes the "nine waypoint members, the layered-art trio, the four-member projection family" clause of the `C_Map.GetAreas`/`GetAreaTriggerInfo` row above. **What 1.12 withholds is not a getter, it is the tree.** Its map is addressed by a `(continent, zone)` pair of *dropdown indices* — a position in two lists, which moves when a zone is inserted — and it publishes no map's rectangle on any other map at all, because the window draws one zone at a time into a fixed 1002x668 frame and never needs to know where that zone sits. A seamless, pannable map is exactly that missing relation: one rectangle per map composed up to a common root. **Built from the realm's own catalog, which is the point.** OctoWoW's `WorldMapArea.dbc` carries 175 rows against stock 1.12's 51 — 124 added (`Alah'Thalas`, `Balor`, `Blackstone Isle`, `Gilneas`, `Grim Reaches`, `Icepoint`, `Lapidis Isle`, `Moonwhisper`, `Northwind`, `Tel'Abim`, `Thalassian Highlands`, the Timbermaw tunnels, Hyjal) and 49 of the shipped rows' world rects re-tuned, measured with `dbc_diff`. A graph transcribed from Classic Era would be the right shape describing a different world. No new DBC read: the graph is a pure function of the catalog `ui_world_map.rs` already pushes, rebuilt inside `set_world_map_catalog`/`set_world_map_direct_areas` so the two cannot disagree. **Era's ids are reused where the map is the same map**, keyed on the `WorldMapArea` **art folder** rather than the zone name, because the folder is the column a realm has no reason to touch — this realm spells Azshara's `Aszhara` and Hillsbrad's `Hilsbrad`, exactly as 1.12 does, while its localized names are the ordinary ones. That join is what lets an Era addon's own uiMapID-keyed data (level ranges, colour grading, flight paths) find this realm's zones. The ids are **read off the consumer's own data files**, which carry the zone name in a comment beside each (`Data/Levels.lua`, `Data/Grade.lua`, `Data/Tones.lua` give the 40 outdoor zones) plus its source constants for the sheet (`WORLD = 947`), the two continents (`CONT_OF = { [1415] = 0, [1414] = 1 }`) and three cities; the other three cities are the gap that contiguous block leaves. A row with no Era counterpart is minted at `100000 + areaID` — unique because `AreaTable` ids are, stable because the id is the realm's own, and clear of anything Era can add. **One realm quirk had to be handled and it is measurable:** this install's `WorldMapArea.dbc` carries a *third* `areaID == 0` row whose art folder is `World` — the world sheet's own row — and the reference's catalog walk (`0x4a5d00`, which selects continents by exactly that column) files it beside Kalimdor and Azeroth. `SetMapZoom(3, 0)` then `GetMapInfo()` answers `World`, and because the row carries `Map.dbc` id 0 its zone list is Eastern Kingdoms' own re-collected, so left in it is a phantom continent holding a second copy of all 39 Eastern Kingdoms zones. It is kept out of the graph rather than merged into the sheet, because its `loc` rect is in map 0's coordinate space while the sheet spans both continents. **Art is answered as paths, not fileIDs**: `GetMapArtLayerTextures` hands back `Interface\WorldMap\<folder>\<folder>N`, so the asset chain serves whichever copy wins — on this install the upscaled pack, `patch-M.mpq`, three copies deep. The 1002x668 / 256x256 layer geometry is the **logical** size, not the shipped pixel size, because the drawn fractions are normalized and a uniform upscale leaves them unchanged; that is the same invariance `map.rs`'s `art_scale` has to *correct* for, and only because `GetMapOverlays` publishes absolute pixels. `C_MapExplorationInfo.GetExploredMapTextures` is the same `WorldMapOverlay` rows and the same reveal gate the stock window draws (`WorldMapFrame.lua:107-160`), in the shape a canvas reads. **Not built, listed rather than stubbed**: `GetMapPosFromWorldPos` (an inverse search over every rect, no caller), `GetMapGroupID`/`GetMapLinksForMap`/`GetBountySetIDForMap` (about maps this client has no concept of) and `C_MapExplorationInfo.GetExploredAreaIDsAtPosition`. A member answering a plausible-looking nothing is worse than an absent one, which `if C_Map.X then` can see. **One harness gap closed with it**: `seat_a_session` now seats the player a world *position* and the per-frame map feed the live client pushes every frame, because every verb that answers *where* the player is reads the position rather than the zone name — with none answering, a map addon draws its art and no player arrow, which the survey's "drew something" column cannot tell from drawing nothing. Corpus roster unchanged by both: 85 ok / 1 fail, digest identical |
+| Texture masking, the later-era texture dials, `CreateMaskTexture`, `SetPropagateKeyboardInput`, `EditBox:HasFocus`/`SetCursorPosition`, the frame and font-string pools, `Ambiguate`, `IsModifiedClick`, `GetQuestDifficultyColor` — **what a canvas map draws with** | done | **The mask pair is the one that matters and the one nothing can stand in for.** 1.12 has no texture masking at all — its single masked thing is the minimap disc, cut engine-side — and no idiom reaches the same end, because the whole point is that a *rectangular* texture draws as a non-rectangular shape. A seamless world map is that operation and nothing else: a zone's art is a rectangle of parchment and the map wants it cut to the zone's coastline, so without it every zone draws as a paper rectangle over its neighbours' oceans and labels. The consumer's own changelog names the symptom ("no overlapping parchment rectangles / duplicated sea labels"), and it calls `AddMaskTexture` **unguarded** (`Map/Close.lua:162`). It was affordable because the render pass already had the slot: `UiQuad::mask` is a **screen-anchored** alpha mask, built for the minimap's fixed circle with tiles panning under it — which is exactly `AddMaskTexture`'s semantics, since the mask is another region with its own anchors and the subject keeps only the fragments its alpha covers *at that place*. So the work was plumbing, not a new material: `RegionData::masks` holds the handles, `extract` resolves the first that has both art and a resolved rect, and the host converts it through the same y-flip as the ScrollFrame clip. **One mask per quad, stated rather than hidden**: widening it is a second texture binding and a second uniform on every UI quad in the client. The list is kept whole anyway, because the methods must round-trip and because the *order* decides the winner — first added, which for a stitched map is the land mask, the one that shapes the coast. A second mask is recorded and not applied. Two traps are pinned by tests: a mask region is **skipped at extract rather than marked hidden**, because its rect is what it covers and hiding it would take it out of the layout too; and a mask whose art the archives lack drops the **mask**, not the quad — honouring zero coverage would blank the art it was meant to shape, which reads as the map's own art failing to load. **`SetRotation` on a Texture** was almost free: 1.12 registers it on PlayerModel alone (`0x84f1fc`) but the renderer has carried `RegionData::rotation` since the minimap arrow, so this is the Lua setter for an angle the quad path already negates for the pass's clockwise convention. The map's player arrow and compass rail need it. **`SetDesaturation`** is the fractional form of 1.12's own `SetDesaturated`, rounded onto the one material flag this renderer has (it greys all-or-nothing, not by weight) with the getter answering the caller's own fraction — an approximation, and the honest one, since the only corpus use is dimming art the caller has already decided to dim. **`SetHorizTile`/`SetVertTile` are applied, not stored**: 1.12 reaches the same end with `SetTexCoord(0, n, 0, 1)`, the idiom this renderer already keys its wrap mode on, but has no switch meaning "however many times it takes" because that count is `rect / texels` and 1.12's Lua is never told the texel size — so the flag rides across and the host computes the count once the art has loaded, with an explicit `SetTexCoord` winning. **`SetPropagateKeyboardInput` is stored, not applied**, and the reason is that 1.12's answer is already always-propagate: its key routing hands the key to the binding system regardless of what a handler did, so there is no swallow mode for `false` to select. Refusing it costs a caller its whole key path — `Map/Sketch.lua:579` arms a catcher frame and flips the flag *inside its own handler*, so a nil method raises once per keypress. **`EditBox:HasFocus` publishes a fact this client already tracks** (`Model::focused_editbox`, the reference's own `DAT_00cf4dc8`) and simply never exposed; it is called unguarded inside an `OnEditFocusLost` callback, so a nil method raised every time a search box lost focus. `SetCursorPosition` lands through `HighlightText`'s own clamp and UTF-8 snap with the selection collapsed, so there is one definition of where a caret may sit. **`CreateFramePool`/`CreateFontStringPool`** supersede the "not built: nothing calls either" note in `pools.rs` — a canvas map pools a frame per pin and a FontString per label, and calls both at file scope the way pfUI calls `CreateTexturePool`. Upstream's mixin and default-resetter names are kept, because a caller passing `FramePool_HideAndClearAnchors` **by name** needs them. The frame factory names its frames `<parent>-<type>-<n>` as upstream does, which matters: a pooled frame has to be reachable by name for a template's `$parent` children to resolve. **`IsModifiedClick` composes two verbs this client already answers** rather than adding state: 1.12 has the modified-click *bindings* (`GetModifiedClick`/`SetModifiedClick`) and its own FrameXML tests the key itself, but registers no predicate doing both steps. `GetQuestDifficultyColor` is a **forwarder** to 1.12's own FrameXML `GetDifficultyColor`, so the colours are the player's chain's and the two spellings cannot drift. `Ambiguate` is the identity on the part that matters — 1.12 has no connected realms, so a name here carries no realm — with the `-Realm` split still applied, because a custom realm can hand out a hyphenated name. **Three stay unbuilt, with reasons**: `GetUnitSpeed` (1.12 sends no speed field for any unit, so the only honest answer is the absent one — and its caller already falls back to a distance-over-time estimate of its own, which is a better number than anything this could invent), `GetAddOnMemoryUsage`/`UpdateAddOnMemoryUsage` (per-addon attribution needs a per-addon Lua allocator this VM does not have; both callers are guarded and print a debug line), and `Texture:SetAtlas`/`C_Texture.GetAtlasInfo` (1.12 ships no atlases, and every call site here is gated on `GetAtlasInfo` answering, so the absence *is* the working path). Corpus roster unchanged: 85 ok / 1 fail, digest identical; the 12 data-half reds are byte-identical to HEAD's |
 
 
 ## The offline UI-load harness — why 349 tests were failing, and what is fixed