table: reset getn length counter in table.wipe

table.wipe nil'd every key via lua_next + rawset(nil) but left the
Lua 5.0 length counter untouched. In 5.0 a table's table.insert/getn
length lives out of band from its keys (a t.n field, else a weak
sizes[t] entry in the registry's LUA_SIZES table), so it survived the
clear. After a wipe, getn stayed at its old value and subsequent
table.insert appended past the wiped slots -- t[1] stayed nil. The
3.3.5 (Lua 5.1) twipe this was ported from has no getn legacy, which
is why the ported logic looked complete.

Fix: call luaL_setn(L, 1, 0) after the clear loop. Bound the engine's
luaL_setn (FUN_006f4ea0, verified against 5.0.2; located via
table.insert FUN_007fb6b0) as Game::Lua::SetN.

Repro before: table.insert(t,1); table.insert(t,2); table.wipe(t);
table.insert(t,3) -> getn 3, t[1] nil, t[3]=3.
After: getn 2, t[1]=3, t[2]=4. Verified in-game.

README.md

@@ -39,7 +39,7 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
 | [Gossip](docs/API.md#gossip) | `C_GossipInfo.CloseGossip`, `C_GossipInfo.GetActiveQuests`, `C_GossipInfo.GetAvailableQuests`, `C_GossipInfo.GetNumActiveQuests`, `C_GossipInfo.GetNumAvailableQuests`, `C_GossipInfo.GetNumOptions`, `C_GossipInfo.GetOptions`, `C_GossipInfo.GetText`, `C_GossipInfo.SelectActiveQuest`, `C_GossipInfo.SelectAvailableQuest`, `C_GossipInfo.SelectOption`, `C_GossipInfo.SelectOptionByIndex` |
 | [GameTooltip](docs/API.md#gametooltip) | `GameTooltip:GetGameObject`, `GameTooltip:GetItem`, `GameTooltip:GetOwner`, `GameTooltip:GetSpell`, `GameTooltip:GetUnitGUID`, `GameTooltip:HasGameObject`, `GameTooltip:HasItem`, `GameTooltip:HasSpell`, `GameTooltip:HasUnit`, `GameTooltip:IsEquippedItem`, `GameTooltip:SetEquipmentSet`, `GameTooltip:SetHyperlinkCompareItem`, `GameTooltip:SetInventoryItemByID`, `GameTooltip:SetItemByGUID`, `GameTooltip:SetItemByID`, `GameTooltip:SetSpellByID`, `GameTooltip:SetTalentByID`, `GameTooltip:SetUnitAura`, `OnTooltipSetItem` (script) |
 | [Hooks](docs/API.md#hooks) | `hooksecurefunc` |
-| [Input](docs/API.md#input) | `IsLeftAltKeyDown`, `IsLeftControlKeyDown`, `IsLeftShiftKeyDown`, `IsModifierKeyDown`, `IsMouseButtonDown`, `IsRightAltKeyDown`, `IsRightControlKeyDown`, `IsRightShiftKeyDown` |
+| [Input](docs/API.md#input) | `GetMouseButtonClicked`, `IsLeftAltKeyDown`, `IsLeftControlKeyDown`, `IsLeftShiftKeyDown`, `IsModifierKeyDown`, `IsMouseButtonDown`, `IsRightAltKeyDown`, `IsRightControlKeyDown`, `IsRightShiftKeyDown` |
 | [Instance](docs/API.md#instance) | `GetInstanceInfo` |
 | [Item](docs/API.md#item) | `C_Item.DoesItemExist`, `C_Item.DoesItemExistByID`, `C_Item.EquipItemByName`, `C_Item.GetCurrentItemLevel`, `C_Item.GetDetailedItemLevelInfo`, `C_Item.GetEnchantInfo`, `C_Item.GetItemCount`, `C_Item.GetItemFamily`, `C_Item.GetItemGUID`, `C_Item.GetItemIcon`, `C_Item.GetItemIconByID`, `C_Item.GetItemID`, `C_Item.GetItemInfoInstant`, `C_Item.GetItemInventorySlotInfo`, `C_Item.GetItemInventorySlotKey`, `C_Item.GetItemInventoryType`, `C_Item.GetItemInventoryTypeByID`, `C_Item.GetItemLink`, `C_Item.GetItemLocation`, `C_Item.GetItemMaxStackSize`, `C_Item.GetItemMaxStackSizeByID`, `C_Item.GetItemName`, `C_Item.GetItemNameByID`, `C_Item.GetItemQuality`, `C_Item.GetItemQualityByID`, `C_Item.GetItemSellPrice`, `C_Item.GetItemSellPriceByID`, `C_Item.GetItemSetID`, `C_Item.GetItemSetIDByID`, `C_Item.GetItemSetInfo`, `C_Item.GetItemSpell`, `C_Item.GetItemStatDelta`, `C_Item.GetItemStats`, `C_Item.GetItemSubClassInfo`, `C_Item.GetItemUniqueness`, `C_Item.GetItemUniquenessByID`, `C_Item.GetStackCount`, `C_Item.GetWeaponEnchantInfo`, `C_Item.IsBound`, `C_Item.IsEquippableItem`, `C_Item.IsEquippedItem`, `C_Item.IsItemDataCached`, `C_Item.IsItemDataCachedByID`, `C_Item.IsItemGUIDInInventory`, `C_Item.IsItemOpenable`, `C_Item.IsLocked`, `C_Item.LockItem`, `C_Item.LockItemByGUID`, `C_Item.UnlockAllItems`, `C_Item.UnlockItem`, `C_Item.RequestLoadItemData`, `C_Item.RequestLoadItemDataByID`, `C_Item.UseAtCursor`, `C_Item.UseAtUnit`, `C_Item.UseItemByName`, `GetAuctionItemID`, `GetAuctionSellItemID`, `GetAverageItemLevel`, `GetCraftReagentItemID`, `GetInboxItemID`, `GetInventoryItemDurability`, `GetInventoryItemID`, `GetInventoryItemsForSlot`, `GetInventoryItemRepairCost`, `GetItemIcon`, `GetLootRollItemID`, `GetLootSlotItemID`, `GetMerchantItemID`, `GetQuestItemID`, `GetQuestLogItemID`, `GetTradePlayerItemID`, `GetTradeSkillItemID`, `GetTradeSkillReagentItemID`, `GetTradeTargetItemID`, `OffhandHasWeapon` |
 | [Loot](docs/API.md#loot) | `C_Loot.GetNearbyLootableUnits`, `C_Loot.GetLastScanResults`, `C_Loot.IsScanInProgress`, `C_Loot.LootUnit`, `C_Loot.LootUnitItem`, `C_Loot.ScanNearbyLoot` |
@@ -54,7 +54,7 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
 | [PlayerInfo](docs/API.md#playerinfo) | `C_PlayerInfo.CanUseItem`, `C_PlayerInfo.GUIDIsCreature`, `C_PlayerInfo.GUIDIsGameObject`, `C_PlayerInfo.GUIDIsPet`, `C_PlayerInfo.GUIDIsPlayer` |
 | [Quest](docs/API.md#quest) | `C_QuestLog.GetNumQuestObjectives`, `C_QuestLog.GetQuestDetails`, `C_QuestLog.GetQuestIDForLogIndex`, `C_QuestLog.GetTitleForQuestID`, `C_QuestLog.IsOnQuest`, `C_QuestLog.IsQuestDataCachedByID`, `C_QuestLog.IsUnitOnQuest`, `C_QuestLog.RequestLoadQuestByID`, `GetQuestLogLeaderBoardID` |
 | [Screen](docs/API.md#screen) | `GetPhysicalScreenSize` |
-| [Spell](docs/API.md#spell) | `C_Spell.CancelSpellByID`, `C_Spell.CastAtCursor`, `C_Spell.CastAtUnit`, `C_Spell.CastingInfo`, `C_Spell.ChannelInfo`, `C_Spell.DoesSpellExist`, `C_Spell.GetSchoolString`, `C_Spell.GetSpellCooldown`, `C_Spell.GetSpellDescription`, `C_Spell.GetSpellInfo`, `C_Spell.GetSpellLink`, `C_Spell.GetSpellMechanicByID`, `C_Spell.GetSpellName`, `C_Spell.GetSpellPowerCost`, `C_Spell.GetSpellRadius`, `C_Spell.GetSpellReagents`, `C_Spell.GetSpellSubtext`, `C_Spell.GetSpellTexture`, `C_Spell.IsAutoAttackSpell`, `C_Spell.IsCurrentSpell`, `C_Spell.IsRangedAutoAttackSpell`, `C_Spell.IsSelfBuff`, `C_Spell.IsSpellHarmful`, `C_Spell.IsSpellHelpful`, `C_Spell.IsSpellPassive`, `C_Spell.IsSpellUsable`, `C_Spell.SpellHasRange`, `C_Spell.UnitCastingInfo`, `C_Spell.UnitChannelInfo`, `CancelSpellByName`, `CastSpellNoToggle`, `GetCraftSpellID`, `GetSpellInfo`, `GetSpellLink`, `GetSpellRadius`, `GetSpellSchool`, `IsHarmfulSpell`, `IsHelpfulSpell`, `IsPassiveSpell`, `IsPlayerSpell`, `IsSpellKnown`, `IsUsableSpell`, `SpellHasRange` |
+| [Spell](docs/API.md#spell) | `C_Spell.CancelSpellByID`, `C_Spell.CastAtCursor`, `C_Spell.CastAtUnit`, `C_Spell.CastingInfo`, `C_Spell.ChannelInfo`, `C_Spell.DoesSpellExist`, `C_Spell.GetSchoolString`, `C_Spell.GetSpellCooldown`, `C_Spell.GetSpellDescription`, `C_Spell.GetSpellInfo`, `C_Spell.GetSpellLevelInfo`, `C_Spell.GetSpellLink`, `C_Spell.GetSpellMechanicByID`, `C_Spell.GetSpellName`, `C_Spell.GetSpellPowerCost`, `C_Spell.GetSpellRadius`, `C_Spell.GetSpellReagents`, `C_Spell.GetSpellRequiredTargetLevel`, `C_Spell.GetSpellSubtext`, `C_Spell.GetSpellTexture`, `C_Spell.IsAutoAttackSpell`, `C_Spell.IsCurrentSpell`, `C_Spell.IsRangedAutoAttackSpell`, `C_Spell.IsSelfBuff`, `C_Spell.IsSpellHarmful`, `C_Spell.IsSpellHelpful`, `C_Spell.IsSpellPassive`, `C_Spell.IsSpellUsable`, `C_Spell.SpellHasRange`, `C_Spell.UnitCastingInfo`, `C_Spell.UnitChannelInfo`, `CancelSpellByName`, `CastSpellNoToggle`, `GetCraftSpellID`, `GetSpellInfo`, `GetSpellLink`, `GetSpellRadius`, `GetSpellRequiredTargetLevel`, `GetSpellSchool`, `IsHarmfulSpell`, `IsHelpfulSpell`, `IsPassiveSpell`, `IsPlayerSpell`, `IsSpellKnown`, `IsUsableSpell`, `SpellHasRange` |
 | [SpellBook](docs/API.md#spellbook) | `C_SpellBook.GetCurrentLevelSpells`, `C_SpellBook.GetSpellLevelLearned`, `C_SpellBook.GetSpellSkillLine`, `C_SpellBook.IsAutoAttackSpellBookItem`, `C_SpellBook.IsRangedAutoAttackSpellBookItem`, `FindSpellBookSlotByID` |
 | [State](docs/API.md#state) | `CancelShapeshiftForm`, `Dismount`, `GetMirrorTimerInfo`, `GetMirrorTimerProgress`, `GetShapeshiftFormID`, `IsAssistingRitual`, `IsFalling`, `IsInGroup`, `IsInRaid`, `IsLoggedIn`, `IsMounted`, `IsStealthed`, `IsSwimming` |
 | [Table](docs/API.md#table) | `table.wipe` |
@@ -62,7 +62,7 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
 | [Time](docs/API.md#time) | `C_DateAndTime.AdjustTimeByDays`, `C_DateAndTime.AdjustTimeByMinutes`, `C_DateAndTime.CompareCalendarTime`, `C_DateAndTime.GetCalendarTimeFromEpoch`, `C_DateAndTime.GetCurrentCalendarTime`, `C_DateAndTime.GetSecondsUntilDailyReset`, `C_DateAndTime.GetServerTimeLocal`, `C_Timer.After`, `C_Timer.NewTicker`, `C_Timer.NewTimer`, `GetServerTime` |
 | [TradeSkillUI](docs/API.md#tradeskillui) | `C_TradeSkillUI.GetTradeSkillListLink`, `C_TradeSkillUI.GetCraftListLink`, `C_TradeSkillUI.GetTradeSkillListRecipes` |
 | [UIColor](docs/API.md#uicolor) | `C_UIColor.GetColors` |
-| [Unit](docs/API.md#unit) | `GetUnitSpeed`, `UnitClassBase`, `UnitGUID`, `UnitInRange`, `UnitIsAFK`, `UnitIsDND`, `UnitIsFeignDeath`, `UnitIsInMyGuild`, `UnitIsMinion`, `UnitIsOtherPlayersPet`, `UnitIsPet`, `UnitIsPossessed`, `UnitPower`, `UnitPowerMax`, `UnitPowerType`, `UnitRaceBase`, `UnitStandState`, `UnitSubName`, `UnitTokenFromGUID` |
+| [Unit](docs/API.md#unit) | `GetUnitSpeed`, `UnitClassBase`, `UnitDistanceSquared`, `UnitGUID`, `UnitInRange`, `UnitIsAFK`, `UnitIsDND`, `UnitIsFeignDeath`, `UnitIsInMyGuild`, `UnitIsMinion`, `UnitIsOtherPlayersPet`, `UnitIsPet`, `UnitIsPossessed`, `UnitPower`, `UnitPowerMax`, `UnitPowerType`, `UnitRaceBase`, `UnitStandState`, `UnitSubName`, `UnitTokenFromGUID` |
 | [UnitAuras](docs/API.md#unitauras) | `C_UnitAuras.GetAuraDataByIndex`, `C_UnitAuras.GetAuraDataBySpellName`, `C_UnitAuras.GetAuraDispelTypeColor`, `C_UnitAuras.GetBuffDataByIndex`, `C_UnitAuras.GetDebuffDataByIndex`, `C_UnitAuras.GetPlayerAuraBySpellID`, `C_UnitAuras.GetUnitAuraBySpellID`, `C_UnitAuras.GetUnitAuras`, `C_UnitAuras.RegisterComboDuration` |
 | [VoiceChat](docs/API.md#voicechat) | `C_VoiceChat.GetTtsVoices`, `C_VoiceChat.GetRemoteTtsVoices`, `C_VoiceChat.SpeakText`, `C_VoiceChat.StopSpeakingText`, `C_TTSSettings.GetSpeechRate`, `C_TTSSettings.GetSpeechVolume`, `C_TTSSettings.GetSpeechVoiceID`, `C_TTSSettings.GetVoiceOptionName`, `C_TTSSettings.SetSpeechRate`, `C_TTSSettings.SetSpeechVolume`, `C_TTSSettings.SetVoiceOption`, `C_TTSSettings.SetVoiceOptionByName`, `C_TTSSettings.SetDefaultSettings`, `C_TTSSettings.RefreshVoices` |
 | [XMLUtil](docs/API.md#xmlutil) | `C_XMLUtil.DoesTemplateExist`, `C_XMLUtil.GetTemplateInfo`, `C_XMLUtil.GetTemplates` |

docs/API.md

@@ -194,6 +194,7 @@ build instructions.
   - [`IsLeftAltKeyDown()` / `IsRightAltKeyDown()`](#isleftaltkeydown--isrightaltkeydown)
   - [`IsModifierKeyDown()`](#ismodifierkeydown)
   - [`IsMouseButtonDown([button])`](#ismousebuttondownbutton)
+  - [`GetMouseButtonClicked()`](#getmousebuttonclicked)
 
 - [Instance](#instance)
   - [`GetInstanceInfo()`](#getinstanceinfo)
@@ -359,6 +360,8 @@ build instructions.
   - [`C_Spell.CancelSpellByID(spellID)` / `CancelSpellByName(name)`](#c_spellcancelspellbyidspellid--cancelspellbynamename)
   - [`C_Spell.UnitCastingInfo(unit)` / `C_Spell.CastingInfo()`](#c_spellunitcastinginfounit--c_spellcastinginfo)
   - [`C_Spell.UnitChannelInfo(unit)` / `C_Spell.ChannelInfo()`](#c_spellunitchannelinfounit--c_spellchannelinfo)
+  - [`C_Spell.GetSpellLevelInfo(spellID)`](#c_spellgetspelllevelinfospellid)
+  - [`GetSpellRequiredTargetLevel(spellID)`](#getspellrequiredtargetlevelspellid)
 
 - [SpellBook](#spellbook)
   - [`FindSpellBookSlotByID(spellID)`](#findspellbookslotbyidspellid)
@@ -426,6 +429,7 @@ build instructions.
   - [`UnitIsOtherPlayersPet(unit)`](#unitisotherplayerspetunit)
   - [`UnitStandState(unit)`](#unitstandstateunit)
   - [`UnitInRange(unit)`](#unitinrangeunit)
+  - [`UnitDistanceSquared(unit)`](#unitdistancesquaredunit)
   - [`UnitPower(unit [, powerType])` / `UnitPowerMax(unit [, powerType])`](#unitpowerunit--powertype--unitpowermaxunit--powertype)
   - [`UnitPowerType(unit)`](#unitpowertypeunit)
 
@@ -4294,6 +4298,38 @@ if IsMouseButtonDown("RightButton") then
 end
 ```
 
+### `GetMouseButtonClicked()`
+
+Returns the name of the button responsible for the mouse handler
+currently running (`"LeftButton"`, `"RightButton"`, `"MiddleButton"`,
+`"Button4"`, `"Button5"`), or `nil` when no click is being handled.
+
+Modern addons call this inside a mouse handler (`OnClick`,
+`OnMouseDown`, `OnMouseUp`, `OnDragStart`, …) to learn which button
+drove it — an alternative to reading vanilla's `arg1`, and readable
+from nested helper functions where `arg1` isn't in scope. The value
+is captured by the same `WH_GETMESSAGE` hook behind
+`GLOBAL_MOUSE_DOWN` / `GLOBAL_MOUSE_UP`, then evicted a couple of
+frames later so — matching the real API — it reads `nil` outside a
+handler rather than lingering as the last click forever.
+
+The button stays readable for the whole frame its click lands in (so
+multiple addons hooking the same `OnClick` all see it), and while a
+button is physically held (so `OnDragStart` reads it). It is a
+best-effort replica: WoW dispatches these handlers deferred from the
+OS message, so eviction is time-based (per-frame) rather than exactly
+bracketed around the handler as on retail. Values can therefore
+linger ~2 frames past a click — harmless, since it's only meaningful
+inside a mouse handler.
+
+```lua
+button:SetScript("OnClick", function()
+    if GetMouseButtonClicked() == "RightButton" then
+        -- right-click behavior
+    end
+end)
+```
+
 ## Instance
 
 ### `GetInstanceInfo()`
@@ -7034,12 +7070,18 @@ Three population sources feed the cache when fully enabled:
 Storage:
 
 - `WTF\Account\<account>\ClassicAPI.txt` — account-level settings
-  (`PersistentNameCacheEnabled`, `NameCacheScanEnabled`).
-- `WTF\Account\<account>\<realm>\ClassicAPI_NameCache.txt` —
-  per-realm cache. Tab-separated text, ~30 bytes/entry,
-  hand-editable. Shared across all characters on the same
-  account+realm (a 50-character bank alt's chat scraping doesn't
-  double the storage cost).
+  (`PersistentNameCacheEnabled`, `NameCacheScanEnabled`). The
+  opt-in toggles stay per-account.
+- `WTF\ClassicAPI\<realmList>\<realm>\ClassicAPI_NameCache.txt` —
+  per-realm cache, **shared across every account on the same
+  server**. Keyed by the realmlist address (unambiguous server
+  identity, can't collide across unrelated private servers) plus the
+  realm name — so alts on different accounts pool into one file
+  rather than each rebuilding their own. Tab-separated text,
+  ~30 bytes/entry, hand-editable. On first load with no shared file
+  yet, a pre-existing per-account cache
+  (`WTF\Account\<account>\<realm>\ClassicAPI_NameCache.txt`) is
+  migrated in automatically.
 
 ### `GetPlayerInfoByGUID(guid)`
 
@@ -8924,6 +8966,55 @@ otherwise it falls back to `name`/`displayName`/`textureID`/`spellID` with
 **`nil` times**. The player path is unchanged (full timing). Same
 placeholder fields as `C_Spell.UnitCastingInfo`.
 
+### `C_Spell.GetSpellLevelInfo(spellID)`
+
+Returns the raw `Spell.dbc` level fields for a spell:
+
+```
+spellLevel, baseLevel, maxLevel = C_Spell.GetSpellLevelInfo(spellID)
+```
+
+- `spellLevel` — the rank's effective level (drives the target-level rule
+  below and per-level scaling).
+- `baseLevel` — the spell's base level.
+- `maxLevel` — the level at which per-level scaling caps (`0` = no cap).
+
+Returns `nil` for an invalid / unpopulated spellID.
+
+```lua
+C_Spell.GetSpellLevelInfo(14752)   -- 30, 30, 40  (Divine Spirit Rank 1)
+C_Spell.GetSpellLevelInfo(14818)   -- 40, 40, 50  (Divine Spirit Rank 2)
+```
+
+### `GetSpellRequiredTargetLevel(spellID)`
+
+Also `C_Spell.GetSpellRequiredTargetLevel(spellID)`. Returns the minimum
+level a **target** must be for this exact spell (rank) to apply — e.g.
+Divine Spirit Rank 1 can only be cast on a target level **20 or higher**.
+Returns `0` when the spell has no such restriction, or `nil` for an
+invalid spellID.
+
+```lua
+GetSpellRequiredTargetLevel(14752)   -- 20   (Divine Spirit Rank 1)
+GetSpellRequiredTargetLevel(14818)   -- 30   (Divine Spirit Rank 2)
+GetSpellRequiredTargetLevel(1243)    -- 0    (Fortitude Rank 1)
+GetSpellRequiredTargetLevel(10060)   -- 0    (Power Infusion — single rank)
+GetSpellRequiredTargetLevel(133)     -- 0    (Fireball — damage, not a buff)
+```
+
+Mirrors the server's `SelectAuraRankForLevel` rule: a **ranked beneficial
+aura** is castable when `targetLevel + 10 >= spellLevel`, so the minimum
+target level is `spellLevel - 10`. The restriction is applied only when the
+spell is a ranked positive aura — `spellLevel > 10`, not passive, part of a
+rank chain, and applying an aura to a friendly/party/raid target (or an
+`APPLY_AREA_AURA_PARTY` effect). Below the minimum, the lowest rank fails
+with `SPELL_FAILED_LOWLEVEL`; higher ranks auto-downrank.
+
+> The explicit `MinTargetLevel` / `MaxTargetLevel` spell fields the server
+> also enforces are **server-only** columns — they aren't present in the
+> 1.12 client's `Spell.dbc`, so the `spellLevel` rule is the only
+> client-readable target-level mechanism.
+
 ## SpellBook
 
 Functions keyed on the player or pet **spellbook** (slot indices,
@@ -10160,6 +10251,44 @@ mouseover, etc.). For raid members in a different zone or otherwise
 not in the engine's sync window, the position virtual returns null
 and the function reports `(false, false)`.
 
+### `UnitDistanceSquared(unit)`
+
+Returns `(distanceSquared, checkedPosition)` — the **squared** world
+distance (yards²) from the player to `unit`, and a flag indicating
+whether both positions were available.
+
+```lua
+local distSq, checked = UnitDistanceSquared("target")
+if checked and distSq <= 30 * 30 then
+    -- target is within 30 yards
+end
+```
+
+| Return | Meaning |
+|--------|---------|
+| `distanceSquared` | Squared distance player→unit. `0` when `checkedPosition` is `false` (a placeholder — matches retail's "always a number" shape). |
+| `checkedPosition` | `true` when both positions were read. `false` when `unit`'s position isn't available (empty `partyN` slot, no target, raid member outside the sync window, etc.). |
+
+The value is **squared** on purpose: nearly all distance logic is a
+threshold compare (`distSq <= range * range`) or a nearest-unit sort,
+neither of which needs the square root — so retail exposes only the
+squared form (added 5.0.4) and never a plain `UnitDistance`. Take
+`math.sqrt(distanceSquared)` only when you need a yard number to show a
+human.
+
+Reads world positions via the `CGObject::GetPosition` vtable virtual
+(slot 5, offset `+0x14`) — the same path `UnitInRange` /
+`CheckInteractDistance` use. **Center-to-center**, not reach-aware (that
+edge-to-edge nicety is UnitXP_SP3's niche); the value equals what you'd
+compute from SuperWoW's `UnitPosition`, but it's self-contained (no
+sibling-DLL dependency, and no clash with SuperWoW's own `UnitPosition`,
+which is left untouched).
+
+> No self-quirk (unlike `UnitInRange`): `UnitDistanceSquared("player")`
+> returns a legitimate `(0, true)`. Because a real `0` (self, or two
+> exactly co-located units) is indistinguishable by value from the miss
+> placeholder, always branch on `checkedPosition`.
+
 ### `UnitClassBase(unit)`
 
 Returns `(classFile, classID)` — the locale-independent class

src/Game.cpp

@@ -56,7 +56,8 @@ namespace Lua {
     F(NewThread,   lua_newthread,   LUA_NEW_THREAD)   \
     F(Resume,      lua_resume,      LUA_RESUME)       \
     F(Yield,       lua_yield,       LUA_YIELD)        \
-    F(ArgError,    luaL_argerror,   LUAL_ARG_ERROR)
+    F(ArgError,    luaL_argerror,   LUAL_ARG_ERROR)   \
+    F(SetN,        luaL_setn,       LUAL_SETN)
 
 #define CLASSICAPI_BIND_LUA(Name, Typedef, Offset) \
     const Typedef##_t Name = reinterpret_cast<Typedef##_t>(Offsets::Offset);

src/Game.h

@@ -99,6 +99,7 @@ using lua_newthread_t = void *(__fastcall *)(void *L);
 using lua_resume_t = int(__fastcall *)(void *L, int nargs);
 using lua_yield_t = int(__fastcall *)(void *L, int nresults);
 using luaL_argerror_t = void(__fastcall *)(void *L, int narg, const char *msg);
+using luaL_setn_t = void(__fastcall *)(void *L, int t, int n);
 
 extern const lua_isnumber_t IsNumber;
 extern const lua_isstring_t IsString;
@@ -140,6 +141,7 @@ extern const lua_newthread_t NewThread;
 extern const lua_resume_t Resume;
 extern const lua_yield_t Yield;
 extern const luaL_argerror_t ArgError;
+extern const luaL_setn_t SetN;
 
 // Returns the global `lua_State *` (read on demand from the engine's global).
 // Callable outside a Lua callback, e.g. during LoadScriptFunctions setup.

src/Offsets.h

@@ -3476,6 +3476,17 @@ enum Offsets {
     // '%s' (%s)" (or "calling '%s' on bad self (%s)" for method-style
     // calls) and calls `lua_error`. Doesn't return.
     LUAL_ARG_ERROR = 0x6F4810,
+    // `luaL_setn(L, t, n)` — Lua 5.0 auxlib table-length setter
+    // (verified: `FUN_006f4ea0`, __fastcall L/ecx, t/edx, n/stack,
+    // RET 4). Matches 5.0.2 `luaL_setn`: sets `t.n = n` if a numeric
+    // `n` field exists, else `sizes[t] = n` in the registry's weak
+    // LUA_SIZES table. Found via `table.insert` (`FUN_007fb6b0`), which
+    // calls it to record the new length; `luaL_getn` is `FUN_006f5050`.
+    // Needed by `table.wipe` to reset the length after clearing keys —
+    // the length is out-of-band from the keys, so a `lua_next` +
+    // `rawset(nil)` clear leaves it stale and subsequent `table.insert`
+    // appends past the wiped slots.
+    LUAL_SETN = 0x6F4EA0,
     // `lua_iscfunction(L, idx)` — returns 1 if value is a function
     // closure with the `isC` byte set (`Closure.c.isC == 1`), 0
     // otherwise. Used by `coroutine.create` to reject C functions

src/aura/Data.cpp

@@ -492,6 +492,31 @@ void PushFromCache(void *L, const uint8_t *unit,
                c.casterGuid);
 }
 
+// Reconciles the `Aura::Source` cache against `unit`'s descriptor: when the
+// descriptor holds at least one raw aura the unit is in view and fully synced,
+// so it's authoritative — any cached entry for the unit whose spell isn't in
+// the array was removed while we couldn't see it (e.g. cancelled out of range,
+// so no OnAuraRemoved reached us) and must be dropped before the fallback
+// resurfaces it as a phantom (an enumerated aura whose SetUnitAura tooltip is
+// empty). Reads the RAW slots (not IsSlotPopulated): a spell that's present
+// but flag-hidden is still legitimately on the unit. Skips when the array is
+// empty — that can't be told apart from an out-of-range descriptor drop, and
+// reconciling then would wipe still-valid out-of-range entries.
+void ReconcileCache(const uint8_t *unit) {
+    if (unit == nullptr)
+        return;
+    uint32_t present[Offsets::UNIT_AURA_TOTAL];
+    int n = 0;
+    for (int slot = 0; slot < Offsets::UNIT_AURA_TOTAL; ++slot) {
+        const uint32_t id = ReadSpellID(unit, slot);
+        if (id != 0)
+            present[n++] = id;
+    }
+    if (n == 0)
+        return;
+    Aura::Source::EvictAbsent(UnitGuid(unit), present, n);
+}
+
 // True if `unit`'s descriptor currently exposes any visible aura in either
 // range. The cache fallback is only trustworthy when the descriptor has been
 // wholesale-cleared: the two states it exists for — rogue stealth and party
@@ -559,6 +584,7 @@ bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex,
                           Filter filter, bool playerOnly) {
     if (unit == nullptr)
         return false;
+    ReconcileCache(unit); // drop entries the (synced) descriptor contradicts
     if (DescriptorHasVisibleAura(unit))
         return false; // descriptor authoritative — see DescriptorHasVisibleAura
     // The descriptor held `descCount` matches; the caller already found fewer
@@ -589,6 +615,7 @@ void AppendCacheFallbacks(void *L, const uint8_t *unit, Filter filter,
                           bool playerOnly, int outerIdx, int &nextKey) {
     if (unit == nullptr)
         return;
+    ReconcileCache(unit); // drop entries the (synced) descriptor contradicts
     if (DescriptorHasVisibleAura(unit))
         return; // descriptor authoritative — see DescriptorHasVisibleAura
     const uint64_t guid = UnitGuid(unit);

src/aura/Source.cpp

@@ -325,10 +325,18 @@ const Game::HookAutoRegister _hookAuraStacks{
     reinterpret_cast<void **>(&g_origOnAuraStacksChanged)};
 
 // OnAuraRemoved — a descriptor aura slot went empty: the aura fell off, was
-// dispelled, or was replaced by a higher rank (the diff dispatcher fires
-// Removed(old) + Added(new)). Evict the cache entry so the fallback stops
-// surfacing it. Same ABI as OnAuraAdded (unit in ecx, slot + spellId on the
-// stack); `slot` is unused here — we evict by spellId.
+// dispelled, was cancelled by its owner, or was replaced by a higher rank
+// (the diff dispatcher fires Removed(old) + Added(new)). Evict the cache
+// entry so the descriptor-drop fallback stops surfacing it. Same ABI as
+// OnAuraAdded (unit in ecx, slot + spellId on the stack); `slot` is unused
+// here — we evict by spellId.
+//
+// Always evict, even for a death-persistent aura (flask, world buff) on a
+// dead unit: the server keeps those through death WITHOUT changing any
+// field, so death itself fires no OnAuraRemoved. Any removal we do receive
+// for one is therefore genuine — e.g. the owner cancelled the flask while
+// dead — and must clear the cache, or the fallback keeps surfacing a phantom
+// whose SetUnitAura tooltip is empty.
 using OnAuraRemoved_t = void(__fastcall *)(void *unit, void *edx, uint32_t slot,
                                            uint32_t spellId);
 OnAuraRemoved_t g_origOnAuraRemoved = nullptr;
@@ -361,6 +369,23 @@ bool Get(uint64_t unitGuid, uint32_t spellId, uint64_t *outCaster,
     return false;
 }
 
+void EvictAbsent(uint64_t unitGuid, const uint32_t *presentSpellIds, int count) {
+    if (unitGuid == 0 || presentSpellIds == nullptr || count <= 0)
+        return;
+    for (auto &e : g_cache) {
+        if (!e.used || e.targetGuid != unitGuid)
+            continue;
+        bool present = false;
+        for (int i = 0; i < count; ++i)
+            if (presentSpellIds[i] == e.spellId) {
+                present = true;
+                break;
+            }
+        if (!present)
+            e.used = false;
+    }
+}
+
 int Enumerate(uint64_t unitGuid, bool harmful, CachedAura *out, int maxOut) {
     if (unitGuid == 0 || out == nullptr || maxOut <= 0)
         return 0;

src/aura/Source.h

@@ -50,6 +50,18 @@ struct CachedAura {
     uint32_t durationMs;   // applied duration (incl. caster mods); 0 = none
 };
 
+// Evicts every cached entry for `unitGuid` whose spellId is NOT present in
+// `presentSpellIds[0..count)`. Used to reconcile the cache against a unit's
+// authoritative descriptor when it is back in view (a populated aura array
+// means the unit is fully synced): an entry the descriptor no longer lists
+// was removed while we couldn't observe it — e.g. a buff the owner cancelled
+// while out of our range, whose `OnAuraRemoved` we never received — so drop
+// it before the descriptor-drop fallback resurfaces it as a phantom. The
+// caller must only invoke this when the descriptor is populated (count > 0);
+// an empty array can't distinguish "out of range" from "genuinely buffless",
+// so reconciling then would wrongly wipe still-valid out-of-range entries.
+void EvictAbsent(uint64_t unitGuid, const uint32_t *presentSpellIds, int count);
+
 // Fills `out` with up to `maxOut` cached, non-expired auras on `unitGuid`
 // whose helpful/harmful classification matches `harmful`. Returns the count
 // written. The classification is recorded from the aura's descriptor slot at

src/input/GlobalMouse.cpp

@@ -24,6 +24,26 @@
 // as the events (single source of truth — events firing and the
 // state being readable happen at the same point in the pipeline).
 //
+// `GetMouseButtonClicked()` — the button name of the most recent
+// mouse button message (`"LeftButton"` / … / `"Button5"`), or nil
+// when no click is being handled. Modern addons call it inside a
+// mouse handler to learn which button drove it; the value is evicted
+// shortly after, so — like the real API — it reads nil outside a
+// handler rather than returning a stale last-click forever.
+//
+// Modern WoW backs this with a frame-manager field set right before a
+// mouse handler runs and cleared right after (verified in 3.3.5:
+// `GetMouseButtonClicked` pushes `[frameMgr + 0x1234]`, nil when that
+// field is null). We can't bracket the handler the same way here: the
+// `WH_GETMESSAGE` hook sees the button at message-dequeue, but WoW
+// dispatches the frame-script mouse handlers *deferred* (during the
+// frame update, not the message pump). So instead we capture the
+// button on the message and evict it from the per-frame `WorldTick`
+// once a couple of quiet ticks pass with no button held — the value
+// survives the whole frame its click lands in (so every handler,
+// including multiple addons hooking one `OnClick`, sees it) then
+// clears. A held button keeps it set so `OnDragStart` still reads it.
+//
 // Same `WH_GETMESSAGE` thread-message hook pattern as
 // [Input::Modifier](Modifier.cpp): we intercept the WM_*BUTTON*
 // messages on the engine's main thread *before* dispatch. The hook
@@ -33,6 +53,7 @@
 
 #include "Game.h"
 #include "event/Custom.h"
+#include "tick/WorldTick.h"
 
 #include <cstdint>
 #include <cstring>
@@ -59,6 +80,24 @@ constexpr uint32_t MASK_ANY_BUTTON = 0x1F;
 
 uint32_t g_mouseButtonMask = 0;
 
+// Name of the button from the most recent mouse-button message, or
+// nullptr when no click is being handled. Points at one of
+// DecodeButton's string literals (stable for the process lifetime),
+// so storing the pointer is safe. `lua_pushstring(L, nullptr)`
+// tail-jumps to pushnil, so a null here surfaces as nil to the Lua
+// caller with no extra branch. Set on each button message; evicted by
+// EvictTick (see the header note on GetMouseButtonClicked).
+const char *g_lastButton = nullptr;
+
+// Set true whenever g_lastButton is (re)assigned, so EvictTick can
+// tell a just-clicked frame from a quiet one. Number of consecutive
+// quiet ticks (no activity, nothing held) required before eviction —
+// >1 so a handler dispatched a frame after its message still reads
+// the button.
+bool g_buttonActivity = false;
+int g_quietTicks = 0;
+constexpr int kQuietTicksToEvict = 2;
+
 HHOOK g_msgHook = nullptr;
 
 // Maps WM_*BUTTON{DOWN,UP} → ("LeftButton"|..., isDown). Returns
@@ -101,6 +140,13 @@ void ProcessMouseMessage(UINT msg, WPARAM wParam) {
     if (name == nullptr)
         return;
 
+    // Capture for GetMouseButtonClicked on both press and release —
+    // during an OnClick / OnMouseUp handler the "clicked" button is the
+    // one just released, same as the press for a normal click.
+    g_lastButton = name;
+    g_buttonActivity = true;
+    g_quietTicks = 0;
+
     const int bitIdx = NameToBitIdx(name);
     if (bitIdx >= 0) {
         const uint32_t bit = 1u << bitIdx;
@@ -136,6 +182,39 @@ int __fastcall Script_IsMouseButtonDown(void *L) {
     return 1;
 }
 
+int __fastcall Script_GetMouseButtonClicked(void *L) {
+    // Null → pushnil (the engine's pushstring tail-jumps on NULL), so
+    // callers outside a mouse handler see nil, matching the modern API.
+    Game::Lua::PushString(L, g_lastButton);
+    return 1;
+}
+
+// Per-frame eviction of g_lastButton. Runs at the tail of each frame's
+// world tick. While a button is held we keep the value (drag handlers
+// still read it) and reset the quiet counter. A frame that saw a fresh
+// button message consumes its activity flag but doesn't yet evict —
+// that one-frame grace lets a handler dispatched the frame after its
+// message still read the button. Only after kQuietTicksToEvict ticks
+// with nothing held and no activity do we clear, so outside a click
+// GetMouseButtonClicked reads nil instead of a stale last-click.
+void EvictTick() {
+    if (g_lastButton == nullptr)
+        return;
+    if (g_mouseButtonMask != 0) {
+        g_quietTicks = 0;
+        return;
+    }
+    if (g_buttonActivity) {
+        g_buttonActivity = false;
+        g_quietTicks = 0;
+        return;
+    }
+    if (++g_quietTicks >= kQuietTicksToEvict) {
+        g_lastButton = nullptr;
+        g_quietTicks = 0;
+    }
+}
+
 LRESULT CALLBACK GetMsgHook(int code, WPARAM wParam, LPARAM lParam) {
     // Only process when the message is being removed from the queue
     // (`PM_REMOVE` / `GetMessage`); `PM_NOREMOVE` peeks would deliver
@@ -157,11 +236,14 @@ void InstallHook() {
 void RegisterLuaFunctions() {
     Game::Lua::RegisterGlobalFunction("IsMouseButtonDown",
                                       &Script_IsMouseButtonDown);
+    Game::Lua::RegisterGlobalFunction("GetMouseButtonClicked",
+                                      &Script_GetMouseButtonClicked);
     InstallHook();
 }
 
 const Event::Custom::AutoReserve _reserveDown{kDownEvent};
 const Event::Custom::AutoReserve _reserveUp{kUpEvent};
+const Tick::WorldTick::AutoSubscribe _evict{&EvictTick};
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
 
 } // namespace

src/player/NameCache.cpp

@@ -23,13 +23,19 @@
 //       parse callbacks, and the registry handles load/save so neither
 //       this module nor `Charlist::Order` clobbers the other's lines.
 //
-//   `WTF\Account\<acct>\<realm>\ClassicAPI_NameCache.txt`
-//       Per-realm cache contents. v2 format. One entry per line:
-//           `guidHi  guidLo  classID  raceID  sex  name`
+//   `WTF\ClassicAPI\<realmList>\<realm>\ClassicAPI_NameCache.txt`
+//       Per-realm cache contents, SHARED across every account on the
+//       same server. Keyed by realmlist address (unambiguous server
+//       identity — can't collide across unrelated private servers) plus
+//       the realm name, rather than by account, so alts on different
+//       accounts pool into one file. Not under `Account\`, so we create
+//       the directory tree ourselves. v4 format. One entry per line:
+//           `name  guid  classID  raceID  sex`
 //       (fields tab-separated). Loaded once the realm name is
-//       available post-login. Saved when (a) a recent write hasn't
-//       been flushed AND (b) at least 30 seconds have elapsed since
-//       the prior save, OR (c) DLL teardown / `Flush()` is called.
+//       available post-login (migrating a pre-existing per-account file
+//       in on first load). Saved when (a) a recent write hasn't been
+//       flushed AND (b) at least 30 seconds have elapsed since the prior
+//       save, OR (c) DLL teardown / `Flush()` is called.
 //
 // Population sources:
 //   1. The engine's NameCache writer (`FUN_PLAYER_INFO_CACHE_WRITE`)
@@ -69,6 +75,7 @@
 #include <cstdlib>
 #include <cstring>
 #include <fstream>
+#include <istream>
 #include <ostream>
 #include <sstream>
 #include <string>
@@ -139,7 +146,57 @@ const char *ReadRealmName() {
 
 // ----- path resolution -----
 
+// realmList CVar value (the realmlist address, e.g.
+// "logon.turtle-wow.org") — the unambiguous server identity. Unlike the
+// friendly realm name it can't collide across unrelated private servers,
+// so it's the outer key for the shared cache path. Mirrors
+// `Security::CredStore`'s realm scoping.
+const char *ReadRealmList() {
+    using GetRealmList_t = const char *(__fastcall *)(int forceRefresh);
+    return reinterpret_cast<GetRealmList_t>(
+        static_cast<uintptr_t>(Offsets::FUN_CVAR_REALM_LIST))(0);
+}
+
+// Filesystem-safe path component. We create these directories ourselves
+// (WoW doesn't), so any character Windows rejects in a path — or that
+// could surprise, like the space/apostrophe in "N'Zoth" — becomes '_'.
+// Deterministic, so a realm always maps to the same folder.
+std::string SanitizeComponent(const char *s) {
+    std::string out;
+    for (const char *p = s; p != nullptr && *p; ++p) {
+        const char c = *p;
+        const bool safe = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
+                          (c >= '0' && c <= '9') || c == '.' || c == '-' ||
+                          c == '_';
+        out.push_back(safe ? c : '_');
+    }
+    return out;
+}
+
+// Shared, server-specific cache path:
+//   WTF\ClassicAPI\<realmList>\<realmName>\ClassicAPI_NameCache.txt
+// Not under Account\, so alts on different accounts of the same server
+// share one pool. Empty (defer) until both realmlist + realm are known.
 std::string CachePath() {
+    const char *realmList = ReadRealmList();
+    if (realmList == nullptr || realmList[0] == '\0')
+        return {};
+    const char *realm = ReadRealmName();
+    if (realm == nullptr || realm[0] == '\0')
+        return {};
+    std::string out = "WTF\\ClassicAPI\\";
+    out += SanitizeComponent(realmList);
+    out += '\\';
+    out += SanitizeComponent(realm);
+    out += "\\ClassicAPI_NameCache.txt";
+    return out;
+}
+
+// The pre-shared per-account path, used only to migrate an existing
+// cache into the shared location on first load. Built exactly as it was
+// written (raw account + realm, unsanitized) so it matches the file
+// sitting in WoW's own folders.
+std::string OldCachePath() {
     const char *account = ReadAccountName();
     if (account == nullptr || account[0] == '\0')
         return {};
@@ -154,6 +211,21 @@ std::string CachePath() {
     return out;
 }
 
+// Creates every parent directory of `filePath` (mkdir -p). WoW makes
+// `WTF\` but not `WTF\ClassicAPI\...`, and ofstream won't create
+// directories, so a save into a fresh realm folder would silently fail
+// without this. CreateDirectory on an existing dir no-ops.
+void EnsureParentDirs(const std::string &filePath) {
+    for (size_t pos = 0;;) {
+        const size_t slash = filePath.find('\\', pos);
+        if (slash == std::string::npos)
+            break; // remainder is the filename
+        if (slash > 0)
+            CreateDirectoryA(filePath.substr(0, slash).c_str(), nullptr);
+        pos = slash + 1;
+    }
+}
+
 // ----- account settings (registered with Settings::Account) -----
 
 void SettingsReset() {
@@ -259,21 +331,12 @@ bool Upsert(uint64_t guid, const std::string &name,
     return changed;
 }
 
-void LoadCacheIfNeeded() {
-    if (g_cacheLoaded)
-        return;
-    const std::string path = CachePath();
-    if (path.empty())
-        return; // pre-realm; retry on next call (g_cacheLoaded stays false)
-    g_cacheLoaded = true;
-
-    std::ifstream file(path);
-    if (!file.is_open())
-        return; // first run for this realm
-
-    // v4 format: `name\tguid\tclass\trace\tsex`. Name first since
-    // it's the primary key; GUID is a peripheral field carried for
-    // GUID-keyed lookups. Variable-width hex GUID (no leading zeros).
+// Parses v4 cache lines (`name\tguid\tclass\trace\tsex`) from `file`
+// into the store. Name first since it's the primary key; GUID is a
+// peripheral field carried for GUID-keyed lookups. Variable-width hex
+// GUID (no leading zeros). Shared by the normal load and the one-time
+// migration from the old per-account file.
+void LoadFromStream(std::istream &file) {
     std::string line;
     while (std::getline(file, line)) {
         while (!line.empty() && (line.back() == '\r' || line.back() == '\n'))
@@ -301,10 +364,42 @@ void LoadCacheIfNeeded() {
     }
 }
 
+void LoadCacheIfNeeded() {
+    if (g_cacheLoaded)
+        return;
+    const std::string path = CachePath();
+    if (path.empty())
+        return; // pre-realm; retry on next call (g_cacheLoaded stays false)
+    g_cacheLoaded = true;
+
+    std::ifstream file(path);
+    if (file.is_open()) {
+        LoadFromStream(file);
+        return;
+    }
+
+    // No shared file yet. One-time migration: seed from the old
+    // per-account file if it exists, then mark dirty so the next save
+    // writes the merged data into the shared path. Only when the shared
+    // file is absent — once it exists it's authoritative (a second
+    // account's old-only entries just repopulate via scan / SMSG).
+    const std::string oldPath = OldCachePath();
+    if (oldPath.empty())
+        return;
+    std::ifstream oldFile(oldPath);
+    if (oldFile.is_open()) {
+        LoadFromStream(oldFile);
+        g_dirty = true;
+    }
+}
+
 void SaveCache() {
     const std::string path = CachePath();
     if (path.empty())
         return;
+    // `WTF\ClassicAPI\<realmList>\<realm>\` isn't created by WoW — make
+    // the tree first, else the ofstream open below silently fails.
+    EnsureParentDirs(path);
     const std::string tmp = path + ".tmp";
     {
         std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
@@ -319,7 +414,7 @@ void SaveCache() {
         // sort/scan key when hand-editing. GUID is variable-width
         // hex — 1-8 digits for player GUIDs, up to 16 if a non-player
         // GUID ever lands here.
-        out << "# ClassicAPI name cache v4 (per-realm)\n";
+        out << "# ClassicAPI name cache v4 (per-realm, shared across accounts)\n";
         out << "# name\tguid\tclassID\traceID\tsex\n";
         for (const auto &kv : g_entries) {
             const std::string &name = kv.first;

src/spell/Level.cpp

@@ -117,6 +117,139 @@ bool SpellHiddenFromAutoLearn(int spellID) {
     return (attrEx2 & SPELL_ATTR_EX2_HIDE_FROM_AUTOLEARN) != 0;
 }
 
+// ---- Target-level gate for ranked beneficial auras ----------------------
+//
+// A ranked beneficial aura can't be applied to a target too low for the
+// rank — e.g. Divine Spirit Rank 1 (14752) requires the target to be level
+// >= 20. Server-enforced via `SpellMgr::SelectAuraRankForLevel`, whose rule
+// is: a ranked positive aura is castable when `targetLevel + 10 >=
+// spellLevel`, i.e. the minimum target level is `spellLevel - 10`. Below
+// it the lowest rank fails (SPELL_FAILED_LOWLEVEL); higher ranks auto-
+// downrank. The gate only applies to *ranked* *positive* *auras* — see
+// RequiredTargetLevel. Fully derivable from the client's Spell.dbc.
+//
+// (The explicit MinTargetLevel / MaxTargetLevel fields the server also
+// checks are NOT in the 1.12 client's Spell.dbc — server-only columns — so
+// the spellLevel rule is the only client-readable target-level mechanism.)
+
+constexpr int OFF_SPELL_MAX_LEVEL = 0x6C;         // uint32 (scaling cap level)
+constexpr int OFF_SPELL_SPELL_LEVEL = 0x74;       // uint32 (rank's effective level)
+constexpr int OFF_SPELL_EFFECT = 0xF4;            // uint32[3] effect type
+constexpr int OFF_SPELL_EFFECT_TARGET_A = 0x148;  // uint32[3] implicit target A
+constexpr int OFF_SPELL_RANK = 0x204;             // char*[9] localized rank text
+constexpr uint32_t SPELL_ATTR_PASSIVE = 0x40;                    // Attributes bit
+constexpr uint32_t SPELL_EFFECT_APPLY_AURA = 6;
+constexpr uint32_t SPELL_EFFECT_APPLY_AREA_AURA_PARTY = 35;
+
+int LocaleIndex() {
+    return *reinterpret_cast<const int *>(
+        static_cast<uintptr_t>(Offsets::VAR_LOCALE_INDEX));
+}
+
+// The friendly-target IDs the server's SelectAuraRankForLevel treats as
+// "positive" for rank selection: IsExplicitPositiveTarget (21/35/45/57/61)
+// plus IsAreaEffectPossitiveTarget (20/30/31/33/34/37/56/61). Narrower than
+// a general "is helpful" set — this is the exact gate the rank rule uses
+// (self-cast / pet targets don't count).
+bool IsPositiveRankTarget(uint32_t t) {
+    switch (t) {
+    case 21: // TARGET_UNIT_FRIEND
+    case 35: // TARGET_UNIT_PARTY
+    case 45: // TARGET_UNIT_FRIEND_CHAIN_HEAL
+    case 57: // TARGET_UNIT_RAID
+    case 61: // TARGET_UNIT_RAID_AND_CLASS
+    case 20: // TARGET_ENUM_UNITS_PARTY_WITHIN_CASTER_RANGE
+    case 30: // TARGET_ENUM_UNITS_FRIEND_AOE_AT_SRC_LOC
+    case 31: // TARGET_ENUM_UNITS_FRIEND_AOE_AT_DEST_LOC
+    case 33: // TARGET_ENUM_UNITS_PARTY_AOE_AT_SRC_LOC
+    case 34: // TARGET_ENUM_UNITS_PARTY_AOE_AT_DEST_LOC
+    case 37: // TARGET_UNIT_FRIEND_AND_PARTY
+    case 56: // TARGET_ENUM_UNITS_RAID_WITHIN_CASTER_RANGE
+        return true;
+    default:
+        return false;
+    }
+}
+
+// True if the record carries a localized "Rank N" string — the client's
+// marker for a spell in a ranked line (single-rank spells leave it empty).
+// Proxy for the server's `GetSpellRank(id) != 0`, verified against
+// single-rank buffs (Power Infusion / Innervate / Blessing of Kings, all
+// empty Rank and un-gated) vs ranked ones (Divine Spirit / Fortitude).
+bool HasRankString(const uint8_t *record) {
+    const char *rank = *reinterpret_cast<const char *const *>(
+        record + OFF_SPELL_RANK + LocaleIndex() * 4);
+    return rank != nullptr && *rank != '\0';
+}
+
+// Minimum target level required to apply this exact spell (rank), or 0 if
+// the spell isn't subject to the ranked-positive-aura target-level rule.
+int RequiredTargetLevel(const uint8_t *record) {
+    const int spellLevel =
+        *reinterpret_cast<const int *>(record + OFF_SPELL_SPELL_LEVEL);
+    if (spellLevel <= 10) // targetLevel + 10 >= spellLevel holds for any level
+        return 0;
+    const uint32_t attr =
+        *reinterpret_cast<const uint32_t *>(record + OFF_SPELL_RECORD_ATTRIBUTES);
+    if (attr & SPELL_ATTR_PASSIVE)
+        return 0;
+    if (!HasRankString(record)) // single-rank spell → not gated
+        return 0;
+
+    auto *effect = reinterpret_cast<const uint32_t *>(record + OFF_SPELL_EFFECT);
+    auto *targetA =
+        reinterpret_cast<const uint32_t *>(record + OFF_SPELL_EFFECT_TARGET_A);
+    bool positiveAura = false;
+    for (int i = 0; i < 3; ++i) {
+        if ((effect[i] == SPELL_EFFECT_APPLY_AURA &&
+             IsPositiveRankTarget(targetA[i])) ||
+            effect[i] == SPELL_EFFECT_APPLY_AREA_AURA_PARTY) {
+            positiveAura = true;
+            break;
+        }
+    }
+    if (!positiveAura)
+        return 0;
+    return spellLevel - 10;
+}
+
+int ArgSpellID(void *L) {
+    if (!Game::Lua::IsNumber(L, 1))
+        return 0;
+    return static_cast<int>(Game::Lua::ToNumber(L, 1));
+}
+
+// `C_Spell.GetSpellLevelInfo(spellID)` → spellLevel, baseLevel, maxLevel.
+// Raw Spell.dbc level fields: spellLevel (this rank's effective level),
+// baseLevel, maxLevel (level at which scaling caps). nil for an unknown
+// spellID.
+int __fastcall Script_GetSpellLevelInfo(void *L) {
+    const uint8_t *record = Spell::Lookup::RecordForID(ArgSpellID(L));
+    if (record == nullptr)
+        return 0;
+    Game::Lua::PushNumber(
+        L, static_cast<double>(
+               *reinterpret_cast<const int *>(record + OFF_SPELL_SPELL_LEVEL)));
+    Game::Lua::PushNumber(
+        L, static_cast<double>(
+               *reinterpret_cast<const int *>(record + Offsets::OFF_SPELL_RECORD_BASE_LEVEL)));
+    Game::Lua::PushNumber(
+        L, static_cast<double>(
+               *reinterpret_cast<const int *>(record + OFF_SPELL_MAX_LEVEL)));
+    return 3;
+}
+
+// `GetSpellRequiredTargetLevel(spellID)` → the minimum level a target must
+// be for this spell (rank) to apply (0 = no restriction). nil for an
+// unknown spellID. Ranked beneficial auras only; see RequiredTargetLevel.
+int __fastcall Script_GetSpellRequiredTargetLevel(void *L) {
+    const uint8_t *record = Spell::Lookup::RecordForID(ArgSpellID(L));
+    if (record == nullptr)
+        return 0;
+    Game::Lua::PushNumber(L, static_cast<double>(RequiredTargetLevel(record)));
+    return 1;
+}
+
 // `C_SpellBook.GetSpellLevelLearned(spellID)` — returns the level
 // at which a spell becomes available (the `BaseLevel` field in
 // Spell.dbc). Direct read off the record — no class/race filtering,
@@ -315,6 +448,12 @@ void RegisterLuaFunctions() {
                                       &Script_GetSpellLevelLearned);
     Game::Lua::RegisterTableFunction("C_SpellBook", "GetCurrentLevelSpells",
                                       &Script_GetCurrentLevelSpells);
+    Game::Lua::RegisterGlobalFunction("GetSpellRequiredTargetLevel",
+                                      &Script_GetSpellRequiredTargetLevel);
+    Game::Lua::RegisterTableFunction("C_Spell", "GetSpellLevelInfo",
+                                      &Script_GetSpellLevelInfo);
+    Game::Lua::RegisterTableFunction("C_Spell", "GetSpellRequiredTargetLevel",
+                                      &Script_GetSpellRequiredTargetLevel);
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/table/Wipe.cpp

@@ -29,6 +29,11 @@ namespace Table::Wipe {
 // guarantee holds in 1.12's Lua 5.0 (`luaH_next` at `0x006FA2A0`),
 // so the pattern ports verbatim.
 //
+// One divergence from the 3.3.5 source: 1.12's Lua 5.0 keeps a table's
+// `table.insert`/`getn` length out of band from its keys (see the
+// `luaL_setn` note below), so after the key-clear loop we must also
+// reset that counter — the 5.1 twipe had no such legacy to clear.
+//
 // Stack discipline matches 3.3.5 to the call:
 //   1. `lua_pushnil(L)`           — initial "no key" sentinel for next
 //   2. `lua_next(L, 1)`           — pops key, pushes (newKey, value)
@@ -51,6 +56,17 @@ static int __fastcall Script_table_wipe(void *L) {
         Game::Lua::RawSet(L, 1);     // t[key] = nil
     }
 
+    // Reset the Lua 5.0 length counter. In 5.0 a table's `table.insert`/
+    // `getn` length is stored OUT of band from its keys (in a `t.n`
+    // field or a weak `sizes[t]` registry entry), so the rawset(nil)
+    // loop above — which only clears keys — leaves it at its old value.
+    // Without this, `table.insert` after a wipe appends at
+    // `getn(t)+1`, past the now-nil slots, and `t[1]` stays nil. 5.1's
+    // wipe doesn't need this (no getn legacy), which is why the ported
+    // logic looked complete. `luaL_setn(L, 1, 0)` puts it back to 0 so
+    // inserts resume at `t[1]`.
+    Game::Lua::SetN(L, 1, 0);
+
     // The table is still at stack[1] and is the result we return.
     Game::Lua::SetTop(L, 1);
     return 1;

src/tooltip/CompareItem.cpp

@@ -126,8 +126,9 @@ int SlotsForInvType(int invType, int *out) {
 // English fallback labels, used when the client doesn't define the
 // modern `_G[key]` global-string (vanilla 1.12 largely doesn't). Phrasing
 // mirrors pfUI's eqcompare so the deltas read consistently on this
-// client. Percent stats keep a "%" suffix since the values are native
-// vanilla percentages.
+// client. Percent stats carry NO "%" here — `IsPercentStat` appends the
+// "%" to the value ("-5% Block"), so the unit is correct regardless of
+// which label (Blizzard `_SHORT` or this fallback) is used.
 struct KeyLabel {
     const char *key;
     const char *label;
@@ -149,25 +150,46 @@ constexpr KeyLabel kFallbackLabels[] = {
     {"RESISTANCE6_NAME", "Arcane Resistance"},
     {"ITEM_MOD_ATTACK_POWER_SHORT", "Attack Power"},
     {"ITEM_MOD_RANGED_ATTACK_POWER_SHORT", "Ranged Attack Power"},
-    {"ITEM_MOD_CRIT_MELEE_RATING", "Melee Crit %"},
-    {"ITEM_MOD_CRIT_RANGED_RATING", "Ranged Crit %"},
-    {"ITEM_MOD_HIT_MELEE_RATING", "Melee Hit %"},
-    {"ITEM_MOD_HIT_RANGED_RATING", "Ranged Hit %"},
-    {"ITEM_MOD_HIT_SPELL_RATING", "Spell Hit %"},
-    {"ITEM_MOD_CRIT_SPELL_RATING", "Spell Crit %"},
+    {"ITEM_MOD_CRIT_MELEE_RATING", "Melee Crit"},
+    {"ITEM_MOD_CRIT_RANGED_RATING", "Ranged Crit"},
+    {"ITEM_MOD_HIT_MELEE_RATING", "Melee Hit"},
+    {"ITEM_MOD_HIT_RANGED_RATING", "Ranged Hit"},
+    {"ITEM_MOD_HIT_SPELL_RATING", "Spell Hit"},
+    {"ITEM_MOD_CRIT_SPELL_RATING", "Spell Crit"},
     {"ITEM_MOD_SPELL_DAMAGE_DONE_SHORT", "Spell Damage"},
     {"ITEM_MOD_SPELL_HEALING_DONE_SHORT", "Spell Healing"},
     {"ITEM_MOD_MANA_REGENERATION", "Mana Regen"},
     {"ITEM_MOD_DEFENSE_SKILL_RATING", "Defense"},
-    {"ITEM_MOD_DODGE_RATING", "Dodge %"},
-    {"ITEM_MOD_PARRY_RATING", "Parry %"},
-    {"ITEM_MOD_BLOCK_RATING", "Block %"},
+    {"ITEM_MOD_DODGE_RATING", "Dodge"},
+    {"ITEM_MOD_PARRY_RATING", "Parry"},
+    {"ITEM_MOD_BLOCK_RATING", "Block"},
     {"ITEM_MOD_BLOCK_VALUE", "Block Value"},
     {"ITEM_MOD_DAMAGE_PER_SECOND_SHORT", "Damage Per Second"},
     {"ITEM_DELTA_DESCRIPTION",
      "If you replace this item, the following stat changes will occur:"},
 };
 
+// Percent-valued stat keys: the block/dodge/parry *chances* and the
+// crit/hit percentages. Vanilla stores these as native percentages (a
+// value of 5 means 5%), so the delta must read "-5% Block", not "-5
+// Block". The "%" is attached to the NUMBER rather than the label, so it
+// stays correct in every locale and requires no `_SHORT` change.
+// NB: ITEM_MOD_DEFENSE_SKILL_RATING (skill points) and
+// ITEM_MOD_BLOCK_VALUE (flat block amount) are NOT percentages.
+bool IsPercentStat(const char *key) {
+    static const char *const kPercent[] = {
+        "ITEM_MOD_CRIT_MELEE_RATING",  "ITEM_MOD_CRIT_RANGED_RATING",
+        "ITEM_MOD_CRIT_SPELL_RATING",  "ITEM_MOD_HIT_MELEE_RATING",
+        "ITEM_MOD_HIT_RANGED_RATING",  "ITEM_MOD_HIT_SPELL_RATING",
+        "ITEM_MOD_DODGE_RATING",       "ITEM_MOD_PARRY_RATING",
+        "ITEM_MOD_BLOCK_RATING",
+    };
+    for (const char *k : kPercent)
+        if (std::strcmp(k, key) == 0)
+            return true;
+    return false;
+}
+
 const char *FallbackLabel(const char *key) {
     for (const auto &e : kFallbackLabels)
         if (std::strcmp(e.key, key) == 0)
@@ -199,22 +221,63 @@ bool EndsWithShort(const char *key) {
     return n >= 6 && std::strcmp(key + n - 6, "_SHORT") == 0;
 }
 
-// Copies `_G[key]` into `out` iff it's a plain, non-empty, non-format
-// string. Direct globals-table access, no pcall. Returns whether it took.
-bool TryGlobalLabel(void *L, const char *key, char *out, int outSize) {
+// Raw `_G[key]` string fetch — no format-specifier filtering. Direct
+// globals-table access, no pcall. Returns whether a non-empty string was
+// copied into `out`.
+bool TryGlobalRaw(void *L, const char *key, char *out, int outSize) {
     const int saved = Game::Lua::GetTop(L);
     Game::Lua::PushString(L, key);
     Game::Lua::GetTable(L, Game::Lua::GLOBALS_INDEX);
     const char *g = (Game::Lua::Type(L, -1) == Game::Lua::TYPE_STRING)
                         ? Game::Lua::ToString(L, -1)
                         : nullptr;
-    const bool ok = (g != nullptr && *g != '\0' && !HasFormatSpecifier(g));
+    const bool ok = (g != nullptr && *g != '\0');
     if (ok)
         std::snprintf(out, outSize, "%s", g);
     Game::Lua::SetTop(L, saved);
     return ok;
 }
 
+// Copies `_G[key]` into `out` iff it's a plain, non-empty, non-format
+// string. Returns whether it took.
+bool TryGlobalLabel(void *L, const char *key, char *out, int outSize) {
+    char tmp[192];
+    if (!TryGlobalRaw(L, key, tmp, sizeof(tmp)) || HasFormatSpecifier(tmp))
+        return false;
+    std::snprintf(out, outSize, "%s", tmp);
+    return true;
+}
+
+// Formats a signed value token (e.g. "-5") as a localized percentage via
+// the PERCENTAGE_STRING global (typically "%s%%" → "-5%"). The locale
+// format is NEVER passed to snprintf — we substitute `num` into its first
+// conversion slot (`%s`/`%d`) by hand and collapse `%%` → `%`, so a
+// hostile or unexpected format can't misread the argument list. Falls back
+// to a plain "%" suffix when the global is absent.
+void FormatPercent(void *L, const char *num, char *out, int outSize) {
+    char fmt[64];
+    if (!TryGlobalRaw(L, "PERCENTAGE_STRING", fmt, sizeof(fmt))) {
+        std::snprintf(out, outSize, "%s%%", num);
+        return;
+    }
+    int o = 0;
+    bool inserted = false;
+    for (const char *p = fmt; *p != '\0' && o < outSize - 1; ++p) {
+        if (p[0] == '%' && p[1] == '%') { // literal percent
+            out[o++] = '%';
+            ++p;
+        } else if (p[0] == '%' && p[1] != '\0' && !inserted) { // value slot
+            for (const char *q = num; *q != '\0' && o < outSize - 1; ++q)
+                out[o++] = *q;
+            ++p; // consume the conversion letter (s / d)
+            inserted = true;
+        } else {
+            out[o++] = *p;
+        }
+    }
+    out[o] = '\0';
+}
+
 // Resolve a display label for a stat `key` into `out`, respecting
 // localization. The rating/regen tokens GetItemStats keys on
 // (`ITEM_MOD_CRIT_MELEE_RATING`, …) carry a "%s" *description* as their
@@ -285,7 +348,14 @@ void RenderDeltas(void *self, void *L, const Accum *acc, double dpsDelta) {
         if (v == 0)
             continue;
         LabelFor(L, acc[i].key, label, sizeof(label));
-        std::snprintf(line, sizeof(line), "%s%ld %s", v > 0 ? "+" : "", v, label);
+        char num[48];
+        std::snprintf(num, sizeof(num), "%s%ld", v > 0 ? "+" : "", v);
+        if (IsPercentStat(acc[i].key)) {
+            char pct[64];
+            FormatPercent(L, num, pct, sizeof(pct));
+            std::snprintf(num, sizeof(num), "%s", pct);
+        }
+        std::snprintf(line, sizeof(line), "%s %s", num, label);
         AddColoredLine(self, line, v > 0 ? kGain : kLoss);
     }
 }

src/unit/Range.cpp

@@ -8,11 +8,21 @@
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE. See the GNU General Public License for more details.
 
-// `UnitInRange(unit) → (inRange, checkedRange)` — 40-yard healing-
-// range check, modern's `UnitInRange` shape. Vanilla 1.12 doesn't
-// ship the function but has all the underlying machinery — the
-// same `GetPosition` virtual (vtable slot 5) `CheckInteractDistance`
-// uses, applied with a fixed 40-yard threshold.
+// Player↔unit proximity, modern's shape. Vanilla 1.12 ships neither
+// function but has all the underlying machinery — the object's
+// `GetPosition` virtual (vtable slot 5) `CheckInteractDistance` uses:
+//
+//   `UnitInRange(unit) → (inRange, checkedRange)` — 40-yard healing-
+//     range check (fixed threshold on the squared distance).
+//   `UnitDistanceSquared(unit) → (distanceSquared, checkedPosition)` —
+//     the raw squared world distance player→unit. Squared because
+//     nearly every consumer compares against a threshold (`distSq <=
+//     range*range`) or ranks by nearest, neither of which needs the
+//     sqrt; that's why retail exposes only the squared form (added
+//     5.0.4). Center-to-center — NOT reach-aware (that's UnitXP_SP3's
+//     niche); equivalent to computing it from SuperWoW `UnitPosition`,
+//     but self-contained (reads the position in C, no sibling-DLL
+//     dependency, no clash with SuperWoW's own `UnitPosition`).
 
 #include "Game.h"
 #include "unit/Position.h"
@@ -26,6 +36,24 @@ namespace {
 constexpr float kRangeYards = 40.0f;
 constexpr float kRangeYardsSq = kRangeYards * kRangeYards;
 
+// Squared world distance from the player to `token`'s unit. Returns true
+// and writes *outSq on success; false when either position is unavailable
+// (unresolved / absent token, or an object with no known position yet —
+// e.g. a party member outside the client's sync range). This false is
+// exactly the `checkedPosition = false` case retail flags.
+bool PlayerToUnitDistSq(const char *token, float *outSq) {
+    float unitPos[3] = {};
+    float playerPos[3] = {};
+    if (!Unit::Position::ReadToken(token, unitPos) ||
+        !Unit::Position::ReadToken("player", playerPos))
+        return false;
+    const float dx = unitPos[0] - playerPos[0];
+    const float dy = unitPos[1] - playerPos[1];
+    const float dz = unitPos[2] - playerPos[2];
+    *outSq = dx * dx + dy * dy + dz * dz;
+    return true;
+}
+
 int __fastcall Script_UnitInRange(void *L) {
     if (!Game::Lua::IsString(L, 1)) {
         Game::Lua::Error(L, "Usage: UnitInRange(\"unit\")");
@@ -44,27 +72,47 @@ int __fastcall Script_UnitInRange(void *L) {
         return 2;
     }
 
-    float unitPos[3] = {};
-    float playerPos[3] = {};
-    if (!Unit::Position::ReadToken(token, unitPos) ||
-        !Unit::Position::ReadToken("player", playerPos)) {
+    float distSq = 0.0f;
+    if (!PlayerToUnitDistSq(token, &distSq)) {
         Game::Lua::PushBool(L, false);
         Game::Lua::PushBool(L, false);
         return 2;
     }
 
-    const float dx = unitPos[0] - playerPos[0];
-    const float dy = unitPos[1] - playerPos[1];
-    const float dz = unitPos[2] - playerPos[2];
-    const float distSq = dx * dx + dy * dy + dz * dz;
-
     Game::Lua::PushBool(L, distSq <= kRangeYardsSq);
     Game::Lua::PushBool(L, true);
     return 2;
 }
 
+// `UnitDistanceSquared("unit") → (distanceSquared, checkedPosition)`.
+// Unlike UnitInRange there's no self-quirk: `UnitDistanceSquared("player")`
+// is a legitimate `(0, true)`. On a position miss returns `(0, false)` —
+// matching retail's "always a number" shape; consumers must branch on
+// `checkedPosition`, since a real `0` (self, or exactly co-located units)
+// is indistinguishable from the miss placeholder by value alone.
+int __fastcall Script_UnitDistanceSquared(void *L) {
+    if (!Game::Lua::IsString(L, 1)) {
+        Game::Lua::Error(L, "Usage: UnitDistanceSquared(\"unit\")");
+        return 0;
+    }
+    const char *token = Game::Lua::ToString(L, 1);
+
+    float distSq = 0.0f;
+    if (!PlayerToUnitDistSq(token, &distSq)) {
+        Game::Lua::PushNumber(L, 0.0);
+        Game::Lua::PushBool(L, false);
+        return 2;
+    }
+
+    Game::Lua::PushNumber(L, static_cast<double>(distSq));
+    Game::Lua::PushBool(L, true);
+    return 2;
+}
+
 void RegisterLuaFunctions() {
     Game::Lua::RegisterGlobalFunction("UnitInRange", &Script_UnitInRange);
+    Game::Lua::RegisterGlobalFunction("UnitDistanceSquared",
+                                      &Script_UnitDistanceSquared);
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};