buffs: cancel by spellID instead of GetPlayerBuff slot index

`GetPlayerBuff(PLAYER_BUFF_START_ID + this.id, filter)` assumes the
visual index pfUI shows matches the engine's slot order. When that
mismapping happens — most easily reproduced by stacking buffs that
share a slot family — right-clicking one buff cancels another.

`C_Spell.CancelSpellByID(spellID)` ships CMSG_CANCEL_AURA keyed to the
spell, not a slot, so it's immune to whatever order the slot table is
in. Cache `spellId` on the button at refresh time in buff.lua; in the
unitframes/buffwatch handlers fetch the aura fresh via
`C_UnitAuras.GetAuraDataByIndex` at click time.

Fixes #10.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -4,16 +4,18 @@ about: Report a bug or issue with pfUI
 title: "[Bug Description] "
 labels: bug
 assignees: ''
+
 ---
 
 <!-- Please fill out ALL fields below. Issues without this info may be closed. -->
 
-**pfUI Branch:**
-- [ ] Master
-- [ ] experiment
+**pfUI Version:**
+
+**Your ClassicAPI Version:**
+
+**Your Nampower Version:**
+
 
-**Your Nampower Version:** (e.g. latest, or specific commit/date)
-<!-- Skip if using Compat branch -->
 
 **Other Addons installed:**
 <!-- List any other addons you are using, or "none" -->
@@ -45,4 +47,3 @@ Paste error log here
 ## Screenshot / Video
 <!-- Attach a screenshot or video showing the issue. This is REQUIRED. -->
 <!-- Drag & drop images here or paste a link -->
-

.github/ISSUE_TEMPLATE/feature_request.md

@@ -4,6 +4,7 @@ about: Suggest a new feature or improvement for pfUI
 title: "[Feature] "
 labels: enhancement
 assignees: ''
+
 ---
 
 ## Feature Description
@@ -20,4 +21,3 @@ assignees: ''
 
 ## Examples
 <!-- If possible, show examples from other addons or screenshots/mockups of how it could look -->
-

.github/workflows/release.yml

@@ -23,7 +23,7 @@ jobs:
           IFS=. read -r MAJOR MINOR PATCH <<<"$LATEST"
           PACKED=$((MAJOR * 10000 + MINOR * 100 + PATCH))
           echo "Pinning PFUI_CLASSIC_API_LATEST to $LATEST ($PACKED)"
-          sed -i "s/^\([[:space:]]*\)local PFUI_CLASSIC_API_LATEST  = [0-9]*/\1local PFUI_CLASSIC_API_LATEST  = $PACKED/" pfUI.lua
+          sed -i "s/^\([[:space:]]*\)local PFUI_CLASSIC_API_LATEST  = .*/\1local PFUI_CLASSIC_API_LATEST  = $PACKED/" pfUI.lua
           grep 'local PFUI_CLASSIC_API_' pfUI.lua
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.pkgmeta

@@ -1 +0,0 @@
-manual-changelog: CHANGELOG.md

CHANGELOG.md

@@ -1,11 +0,0 @@
-- Hard dependency on [ClassicAPI](https://github.com/brues-code/ClassicAPI) — modern `C_*` namespaces and engine polyfills (focus, nameplates, GUIDs).
-- TBC/Wrath/expansion plumbing removed; vanilla 1.12 + Turtle WoW only.
-- Nameplate overhaul — GUID-keyed caches, per-tick allocation cuts, name-collision filtering, configurable name text position.
-- Unit auras rebuilt on `C_UnitAuras` — replaces the old tooltip-scraping aura tracker with structured engine data, so buff/debuff durations, stack counts, and source attribution are accurate without polling.
-- Equipment manager — new backport of Blizzard's gear-set UI, integrated into the character pane. Save, swap, and edit sets without a third-party addon.
-- Bag sorting — new built-in feature (previously pfUI only deferred to third-party sorters).
-- `/focus` and `/clearfocus` moved to ClassicAPI; `/focusname` retained in pfUI.
-- questitem refactored onto `C_QuestLog`.
-- `updatenotify` isolated to its own `pfUI-brues` addon-message prefix so we don't share traffic with upstream pfUI installs.
-
-See full commit history at https://github.com/brues-code/pfUI/commits/master for details.

api/api.lua

@@ -193,10 +193,7 @@ end
 -- name         [string]        The localized name of the buff.
 -- return:      [bool]          true if unit has buff otherwise "nil"
 function pfUI.api.UnitHasBuff(unit, name)
-  for _, aura in ipairs(C_UnitAuras.GetUnitAuras(unit, "HELPFUL")) do
-    if aura.name == name then return true end
-  end
-  return nil
+  return C_UnitAuras.GetAuraDataBySpellName(unit, name, "HELPFUL") ~= nil or nil
 end
 
 -- [ GetUnbuffedRoster ]
@@ -211,7 +208,7 @@ function pfUI.api.GetUnbuffedRoster(name)
     end
   end
 
-  if UnitInRaid("player") then
+  if IsInRaid() then
     for i=1,40 do check("raid"..i) end
   else
     check("player")
@@ -488,7 +485,7 @@ end
 -- 'msg'        [string]          the message to send
 function pfUI.api.SendChatMessageWide(msg)
   local channel = "SAY"
-  if UnitInRaid("player") then
+  if IsInRaid() then
     if ( IsRaidLeader() or IsRaidOfficer() ) then
       channel = "RAID_WARNING"
     else

api/config.lua

@@ -714,6 +714,7 @@ function pfUI:LoadConfig()
   pfUI:UpdateConfig("castbar",    "player",      "txtleftoffy",      "0")
   pfUI:UpdateConfig("castbar",    "player",      "showlag",          "0")
   pfUI:UpdateConfig("castbar",    "player",      "showrank",         "0")
+  pfUI:UpdateConfig("castbar",    "player",      "mergetradeskill",  "1")
   pfUI:UpdateConfig("castbar",    "player",      "txtrightoffx",     "0")
   pfUI:UpdateConfig("castbar",    "player",      "txtrightoffy",     "0")
   pfUI:UpdateConfig("castbar",    "target",      "hide_pfui",        "0")
@@ -747,6 +748,7 @@ function pfUI:LoadConfig()
   pfUI:UpdateConfig("tooltip",    nil,           "cursoroffset",     "20")
   pfUI:UpdateConfig("tooltip",    nil,           "extguild",         "1")
   pfUI:UpdateConfig("tooltip",    nil,           "itemid",           "0")
+  pfUI:UpdateConfig("tooltip",    nil,           "movespeed",        "0")
   pfUI:UpdateConfig("tooltip",    nil,           "alpha",            "0.8")
   pfUI:UpdateConfig("tooltip",    nil,           "alwaysperc",       "0")
   pfUI:UpdateConfig("tooltip",    "compare",     "basestats",        "1")
@@ -817,7 +819,7 @@ function pfUI:LoadConfig()
   pfUI:UpdateConfig("nameplates", nil,           "selfdebuff",       "0")
   pfUI:UpdateConfig("nameplates", nil,           "showdebuffs_hostile",  "1")
   pfUI:UpdateConfig("nameplates", nil,           "showdebuffs_friendly", "0")
-  pfUI:UpdateConfig("nameplates", nil,           "guessdebuffs",     "1")
+  pfUI:UpdateConfig("nameplates", nil,           "owndebuffs",       "0")
   pfUI:UpdateConfig("nameplates", nil,           "clickthrough",     "0")
   pfUI:UpdateConfig("nameplates", nil,           "rightclick",       "1")
   pfUI:UpdateConfig("nameplates", nil,           "clickthreshold",   "0.5")
@@ -1386,5 +1388,17 @@ function pfUI:MigrateConfig()
     end
   end
 
-  pfUI_config.version = pfUI.version.string
+  -- Stamp the version we've migrated to. Dev / git-cloned builds carry
+  -- "@project-version@" in the toc, which pfUI.lua normalizes to "dev" —
+  -- writing that here would have checkversion() parse it back as 0/0/0 on
+  -- the next /reload and re-fire every migration block, clobbering user
+  -- toggles (notably the >3.6.1 buff migration that rewrites
+  -- buffs.{buffs,debuffs,weapons} from the deprecated global.hide{,w}buff
+  -- knobs). Stamp a far-future sentinel instead so checkversion() can't
+  -- flip true again on subsequent loads.
+  if pfUI.version.string == "dev" then
+    pfUI_config.version = "999.999.999"
+  else
+    pfUI_config.version = pfUI.version.string
+  end
 end

api/unitframes.lua

@@ -73,8 +73,8 @@ end
 
 local function BuffOnClick()
   if this:GetParent().label == "player" then
-    local bid = GetPlayerBuff(PLAYER_BUFF_START_ID + this.id, "HELPFUL")
-    if bid >= 0 then CancelPlayerBuff(bid) end
+    local aura = C_UnitAuras.GetAuraDataByIndex("player", this.id, "HELPFUL")
+    if aura and aura.spellId then C_Spell.CancelSpellByID(aura.spellId) end
   end
 end
 
@@ -87,13 +87,16 @@ local function DebuffOnEnter()
   if this:GetParent().label ~= "player" then
     local parent = this:GetParent()
 
-    -- For "only own debuffs" mode: find the REAL slot by matching spell name AND caster
-    if parent.config and parent.config.selfdebuff == "1" and libdebuff then
-      local ownDebuffName = libdebuff:UnitOwnDebuff(unitstr, this.id)
-      if ownDebuffName then
+    -- selfdebuff filters the displayed list to player-cast harmful auras, but
+    -- SetUnitAura's index has to be into the engine's full HARMFUL list. Look
+    -- up the displayed aura via the PLAYER filter, then scan engine slots for
+    -- one whose name + sourceGUID match.
+    if parent.config and parent.config.selfdebuff == "1" then
+      local ownAura = C_UnitAuras.GetAuraDataByIndex(unitstr, this.id, "HARMFUL|PLAYER")
+      if ownAura then
         for gameSlot = 1, 16 do
-          local gameName, _, _, _, _, _, _, gameCaster = libdebuff:UnitDebuff(unitstr, gameSlot)
-          if gameName == ownDebuffName and gameCaster == "player" then
+          local check = C_UnitAuras.GetDebuffDataByIndex(unitstr, gameSlot)
+          if check and check.name == ownAura.name and check.sourceGUID == ownAura.sourceGUID then
             GameTooltip:SetUnitAura(unitstr, gameSlot, "HARMFUL")
             return
           end
@@ -111,8 +114,8 @@ end
 
 local function DebuffOnClick()
   if this:GetParent().label == "player" then
-    local bid = GetPlayerBuff(PLAYER_BUFF_START_ID + this.id, "HARMFUL")
-    if bid >= 0 then CancelPlayerBuff(bid) end
+    local aura = C_UnitAuras.GetAuraDataByIndex("player", this.id, "HARMFUL")
+    if aura and aura.spellId then C_Spell.CancelSpellByID(aura.spellId) end
   end
 end
 
@@ -302,12 +305,12 @@ function pfUI.uf:UpdateVisibility()
     local id = self.cache_raid
 
     -- always show self in raidframes
-    if not UnitInRaid("player") and GetNumPartyMembers() == 0 and C.unitframes.selfinraid == "1" and id == 1 then
+    if not IsInRaid() and IsInGroup() and C.unitframes.selfinraid == "1" and id == 1 then
       self.id = ""
       self.label = "player"
 
     -- use raidframes for groups
-    elseif not UnitInRaid("player") and GetNumPartyMembers() > 0 and C.unitframes.raidforgroup == "1" then
+    elseif not IsInRaid() and IsInGroup() and C.unitframes.raidforgroup == "1" then
       if id == 1 then
         self.id = ""
         self.label = "player"
@@ -344,12 +347,12 @@ function pfUI.uf:UpdateVisibility()
     -- frame shall not be visible
     visibility = "hide"
     self.visible = nil
-  elseif C["unitframes"]["group"]["hide_in_raid"] == "1" and self.label and strsub(self.label,0,5) == "party" and UnitInRaid("player") then
+  elseif C["unitframes"]["group"]["hide_in_raid"] == "1" and self.label and strsub(self.label,0,5) == "party" and IsInRaid() then
     -- hide group while in raid and option is set
     visibility = "hide"
     self.visible = nil
   elseif ( self.fname == "Group0" or self.fname == "PartyPet0" or self.fname == "Party0Target" )
-  and (GetNumPartyMembers() <= 0 or (C["unitframes"]["group"]["hide_in_raid"] == "1" and UnitInRaid("player"))) then
+  and (not IsInGroup() or (C["unitframes"]["group"]["hide_in_raid"] == "1" and IsInRaid())) then
      -- hide self in group if solo or hide in raid is set
      visibility = "hide"
      self.visible = nil
@@ -1770,7 +1773,7 @@ function pfUI.uf:RefreshIndicators(unit)
   local unitstr = unit.label .. unit.id
 
   if unit.leaderIcon then -- Leader Icon
-    if unit.config.leadericon == "1" and UnitIsPartyLeader(unitstr) and ( GetNumPartyMembers() > 0 or GetNumRaidMembers() > 0 ) then
+    if unit.config.leadericon == "1" and UnitIsPartyLeader(unitstr) and IsInGroup() then
       unit.leaderIcon:Show()
     else
       unit.leaderIcon:Hide()
@@ -1971,16 +1974,15 @@ function pfUI.uf:RefreshUnit(unit, component)
         invert_h * ((row+buffrow)*(multiply*default_border + unit.config.debuffsize + 1) + (multiply*default_border + 1)))
       end
 
-      local aura
-      if unit.label ~= "player" and selfdebuff == "1" then
-        _, _, texture, stacks, dtype = libdebuff:UnitOwnDebuff(unitstr, i)
+      -- selfdebuff narrows to player-cast harmful auras via the PLAYER filter.
+      -- Player-frame debuffs aren't gated on it (it'd hide most party-applied
+      -- effects on you).
+      local filter = (unit.label ~= "player" and selfdebuff == "1") and "HARMFUL|PLAYER" or "HARMFUL"
+      local aura = C_UnitAuras.GetAuraDataByIndex(unitstr, i, filter)
+      if aura then
+        texture, stacks, dtype = aura.icon, aura.applications, aura.dispelName
       else
-        aura = C_UnitAuras.GetDebuffDataByIndex(unitstr, i)
-        if aura then
-          texture, stacks, dtype = aura.icon, aura.applications, aura.dispelName
-        else
-          texture, stacks, dtype = nil, 0, nil
-        end
+        texture, stacks, dtype = nil, 0, nil
       end
 
       unit.debuffs[i].texture:SetTexture(texture)
@@ -1992,8 +1994,9 @@ function pfUI.uf:RefreshUnit(unit, component)
         unit.debuffs[i]:Show()
 
         if aura and aura.expirationTime > 0 then
-          -- Player path: real engine expirationTime. Cap start to now to keep pfUI's
-          -- cooldown text out of the 2^32-wraparound branch for talent-extended debuffs.
+          -- Cap start to now so talent-extended debuffs (expirationTime past
+          -- the dbc base duration) don't push start into the future and trip
+          -- CooldownFrame_SetTimer's 2^32-wraparound branch.
           local now = GetTime()
           local start = aura.expirationTime - aura.duration
           local duration = aura.duration
@@ -2003,16 +2006,6 @@ function pfUI.uf:RefreshUnit(unit, component)
           if duration > 0 then
             CooldownFrame_SetTimer(unit.debuffs[i].cd, start, duration, 1)
           end
-        elseif libdebuff and selfdebuff == "1" then
-          local _, _, _, _, _, duration, timeleft = libdebuff:UnitOwnDebuff(unitstr, i)
-          if duration and timeleft then
-            CooldownFrame_SetTimer(unit.debuffs[i].cd, GetTime() + timeleft - duration, duration, 1)
-          end
-        elseif libdebuff then
-          local _, _, _, _, _, duration, timeleft = libdebuff:UnitDebuff(unitstr, i)
-          if duration and timeleft then
-            CooldownFrame_SetTimer(unit.debuffs[i].cd, GetTime() + timeleft - duration, duration, 1)
-          end
         end
 
         if stacks > 1 then
@@ -2198,29 +2191,16 @@ function pfUI.uf:RefreshUnit(unit, component)
         end
       end
 
+      local debuffFilter = unit.config.selfdebuff == "1" and "HARMFUL|PLAYER" or "HARMFUL"
       for i=1,16 do -- scan for custom debuffs
-        local aura = C_UnitAuras.GetDebuffDataByIndex(unitstr, i)
+        local aura = C_UnitAuras.GetAuraDataByIndex(unitstr, i, debuffFilter)
         if aura then
-          local name = aura.name
-          local texture = aura.icon
           local timeleft = aura.expirationTime > 0 and (aura.expirationTime - GetTime()) or nil
-
-          -- libdebuff provides caster correlation + reconstructed timer for non-player units
-          if libdebuff then
-            if unit.config.selfdebuff == "1" then
-              name, _, texture, _, _, _, timeleft = libdebuff:UnitOwnDebuff(unitstr, i)
-            else
-              name, _, texture, _, _, _, timeleft = libdebuff:UnitDebuff(unitstr, i)
-            end
-          end
-
-          if name then
-            for _, filter in pairs(unit.indicator_custom) do
-              if filter == string.lower(name) then
-                pfUI.uf:AddIcon(unit, pos, texture, timeleft, aura.applications)
-                pos = pos + 1
-                break
-              end
+          for _, filter in pairs(unit.indicator_custom) do
+            if filter == string.lower(aura.name) then
+              pfUI.uf:AddIcon(unit, pos, aura.icon, timeleft, aura.applications)
+              pos = pos + 1
+              break
             end
           end
         end
@@ -2858,8 +2838,6 @@ function pfUI.uf:GetStatusValue(unit, pos)
   -- Use libhealth for mob health estimation (overrides Nampower/Standard)
   if pfUI.libhealth and pfUI.libhealth.enabled then
     rhp, rhpmax = pfUI.libhealth:GetUnitHealth(unitstr)
-  elseif unit.label == "target" and (MobHealth3 or MobHealthFrame) and MobHealth_GetTargetCurHP() then
-    rhp, rhpmax = MobHealth_GetTargetCurHP(), MobHealth_GetTargetMaxHP()
   end
 
   if config == "unit" then

compat/vanilla.lua

@@ -2,11 +2,6 @@
 setfenv(1, pfUI:GetEnvironment())
 
 -- [[ Constants ]]--
-CASTBAR_EVENT_CAST_DELAY = "SPELLCAST_DELAYED"
-CASTBAR_EVENT_CHANNEL_DELAY = "SPELLCAST_CHANNEL_UPDATE"
-CASTBAR_EVENT_CAST_START = "SPELLCAST_START"
-CASTBAR_EVENT_CHANNEL_START = "SPELLCAST_CHANNEL_START"
-
 EVENTS_MINIMAP_ZONE_UPDATE = {"PLAYER_ENTERING_WORLD", "MINIMAP_ZONE_CHANGED"}
 
 MICRO_BUTTONS = {

init/libs.xml

@@ -1,7 +1,6 @@
 <Ui xmlns="http://www.blizzard.com/wow/ui/">
   <Include file="..\libs\libtipscan.lua"/>
   <Include file="..\libs\libspell.lua"/>
-  <Include file="..\libs\libcast.lua"/>
   <Include file="..\libs\libdebuff.lua"/>
   <Include file="..\libs\librange.lua"/>
   <Include file="..\libs\libunitscan.lua"/>

libs/libcast.lua

@@ -1,571 +0,0 @@
--- load pfUI environment
-setfenv(1, pfUI:GetEnvironment())
-
---[[ libcast ]]--
--- A pfUI library that detects and saves all ongoing castbars of players, NPCs and enemies.
--- The library also includes spells that usually don't have a castbar like Multi-Shot and Aimed Shot.
--- This is exclusivly used for vanilla in order to provide pfGetChannelInfo and pfGetCastInfo functions.
---
--- External functions:
---   pfGetChannelInfo(unit)
---     Returns information on the spell currently cast by the specified unit.
---     Returns nil if no spell is being cast.
---
---     cast[String] - The name of the spell, or nil if no spell is being cast.
---     nameSubtext[String] - (DUMMY) The string describing the rank of the spell, e.g. "Rank 1".
---     text[String] - The name to be displayed.
---     texture[String] - The texture path associated with the spell.
---     startTime[Number] - Specifies when casting has begun, in milliseconds.
---     endTime[Number] - Specifies when casting will end, in milliseconds.
---     isTradeSkill[Boolean] - (DUMMY) Specifies if the cast is a tradeskill
---
---   pfGetCastInfo(unit)
---     Returns information on the spell currently channeled by the specified unit.
---     Returns nil if no spell is being channeled.
---
---     cast[String] - The name of the spell, or nil if no spell is being cast.
---     nameSubtext[String] - (DUMMY) The string describing the rank of the spell, e.g. "Rank 1".
---     text[String] - The name to be displayed.
---     texture[String] - The texture path associated with the spell.
---     startTime[Number] - Specifies when casting has begun, in milliseconds.
---     endTime[Number] - Specifies when casting will end, in milliseconds.
---     isTradeSkill[Boolean] - (DUMMY) Specifies if the cast is a tradeskill
---
--- Internal functions:
---   libcast:AddAction(mob, spell, channel)
---     Adds a spell to the database by using pfUI's spell database
---     to obtain durations and icons
---
---   libcast:RemoveAction(mob, spell)
---     Removes the castbar of a given mob, if `spell` is an interrupt.
---     spell can be set to "INTERRUPT" to force remove an action.
---
-
--- return instantly when another libcast is already active
-if pfUI.api.libcast then return end
-
-local lastcasttex, lastrank, _
-
-local libcast = CreateFrame("Frame", "pfEnemyCast")
-local player = UnitName("player")
-
-pfGetChannelInfo = function(unit)
-  -- convert to name if unitstring was given
-  local unitName = pfValidUnits[unit] and UnitName(unit) or unit
-  
-  -- Get GUID if Nampower is available
-  local guid = nil
-  
-  -- Check if unit itself is a GUID (starts with "0x")
-  if type(unit) == "string" and string.sub(unit, 1, 2) == "0x" then
-    guid = unit  -- unit IS the GUID
-  elseif pfValidUnits[unit] and UnitExists then
-    -- unit is a token like "target" - get GUID from it
-    local unitGuid = UnitGUID(unit)
-    guid = unitGuid
-  end
-  
-  -- For player: ALWAYS use libcast.db because it handles channel updates correctly
-  local isPlayer = unit == "player" or unitName == player
-  
-  if isPlayer then
-    local cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill
-    local db = libcast.db[player]
-
-    if db and db.cast and db.start + db.casttime / 1000 > GetTime() then
-      if not db.channel then return end
-      cast = db.cast
-      nameSubtext = db.rank
-      text = ""
-      texture = db.icon
-      startTime = db.start * 1000
-      endTime = startTime + db.casttime
-      isTradeSkill = nil
-    elseif db then
-      db.cast = nil
-      db.rank = nil
-      db.start = nil
-      db.casttime = nil
-      db.icon = nil
-      db.channel = nil
-    end
-
-    return cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill
-  end
-  
-  -- For non-player units: use libdebuff GUID-based tracking or libcast.db
-  -- Try GUID-based lookup first (from libdebuff's SPELL_START tracking)
-  local db = nil
-  if guid and pfUI.libdebuff_casts and pfUI.libdebuff_casts[guid] then
-    -- Use libdebuff's cast tracking (from SPELL_START_OTHER events)
-    local castData = pfUI.libdebuff_casts[guid]
-    if castData.event == "START" and castData.endTime and castData.endTime > GetTime() then
-      -- Convert libdebuff format to libcast format
-      db = {
-        cast = castData.spellName,
-        rank = nil,
-        start = castData.startTime,
-        casttime = castData.duration * 1000, -- Convert back to ms
-        icon = castData.icon,
-        channel = nil -- TODO: libdebuff should distinguish channel vs cast
-      }
-    end
-  end
-  
-  -- Fallback to name-based lookup (CHAT_MSG castbars)
-  -- Skip when GUID is available to avoid same-name mob bleed
-  if not db and not guid and libcast.db[unitName] then
-    db = libcast.db[unitName]
-  end
-  
-  -- Fallback to libcast.db for non-player units
-  local cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill
-
-  if db and db.cast and db.start + db.casttime / 1000 > GetTime() then
-    if not db.channel then return end
-    cast = db.cast
-    nameSubtext = db.rank
-    text = ""
-    texture = db.icon
-    startTime = db.start * 1000
-    endTime = startTime + db.casttime
-    isTradeSkill = nil
-  elseif db then
-    db.cast = nil
-    db.rank = nil
-    db.start = nil
-    db.casttime = nil
-    db.icon = nil
-    db.channel = nil
-  end
-
-  return cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill
-end
-
-pfGetCastInfo = function(unit)
-  -- convert to name if unitstring was given
-  local unitName = pfValidUnits[unit] and UnitName(unit) or unit
-  
-  -- Get GUID if Nampower is available
-  local guid = nil
-  
-  -- Check if unit itself is a GUID (starts with "0x")
-  if type(unit) == "string" and string.sub(unit, 1, 2) == "0x" then
-    guid = unit  -- unit IS the GUID
-  elseif pfValidUnits[unit] and UnitExists then
-    -- unit is a token like "target" - get GUID from it
-    local unitGuid = UnitGUID(unit)
-    guid = unitGuid
-  end
-  
-  -- For player: ALWAYS use libcast.db because it handles pushback correctly
-  local isPlayer = unit == "player" or unitName == player
-  
-  if isPlayer then
-    local cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill
-    local db = libcast.db[player]
-
-    if db and db.cast and db.start + db.casttime / 1000 > GetTime() then
-      if db.channel then return end
-      cast = db.cast
-      nameSubtext = db.rank or ""
-      text = ""
-      texture = db.icon
-      startTime = db.start * 1000
-      endTime = startTime + db.casttime
-      isTradeSkill = nil
-    elseif db then
-      db.cast = nil
-      db.rank = nil
-      db.start = nil
-      db.casttime = nil
-      db.icon = nil
-      db.channel = nil
-    end
-
-    return cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill
-  end
-  
-  -- For non-player units: use libdebuff GUID-based tracking or libcast.db
-  -- Try GUID-based lookup first (from libdebuff's SPELL_START tracking)
-  local db = nil
-  if guid and pfUI.libdebuff_casts and pfUI.libdebuff_casts[guid] then
-    -- Use libdebuff's cast tracking (from SPELL_START_OTHER events)
-    local castData = pfUI.libdebuff_casts[guid]
-    if castData.event == "START" and castData.endTime and castData.endTime > GetTime() then
-      -- Convert libdebuff format to libcast format
-      db = {
-        cast = castData.spellName,
-        rank = nil,
-        start = castData.startTime,
-        casttime = castData.duration * 1000, -- Convert back to ms
-        icon = castData.icon,
-        channel = nil -- TODO: libdebuff should distinguish channel vs cast
-      }
-    end
-  end
-  
-  -- Fallback to name-based lookup (CHAT_MSG castbars)
-  -- Skip when GUID is available to avoid same-name mob bleed
-  if not db and not guid and libcast.db[unitName] then
-    db = libcast.db[unitName]
-  end
-  
-  -- Fallback to libcast.db for non-player units
-  local cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill
-
-  if db and db.cast and db.start + db.casttime / 1000 > GetTime() then
-    if db.channel then return end
-    cast = db.cast
-    nameSubtext = db.rank or ""
-    text = ""
-    texture = db.icon
-    startTime = db.start * 1000
-    endTime = startTime + db.casttime
-    isTradeSkill = nil
-  elseif db then
-    db.cast = nil
-    db.rank = nil
-    db.start = nil
-    db.casttime = nil
-    db.icon = nil
-    db.channel = nil
-  end
-
-  return cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill
-end
-
-function libcast:AddAction(mob, spell, channel)
-  if not mob or not spell then return nil end
-
-  if L["spells"][spell] ~= nil then
-    local casttime = L["spells"][spell].t
-    local icon = L["spells"][spell].icon and string.format("%s%s", "Interface\\Icons\\", L["spells"][spell].icon) or nil
-
-    -- add cast action to the database
-    if not self.db[mob] then self.db[mob] = {} end
-    self.db[mob].cast = spell
-    self.db[mob].rank = nil
-    self.db[mob].start = GetTime()
-    self.db[mob].casttime = casttime
-    self.db[mob].icon = icon
-    self.db[mob].channel = channel
-
-    return true
-  end
-
-  return nil
-end
-
-function libcast:RemoveAction(mob, spell)
-  if self.db[mob] and ( L["interrupts"][spell] ~= nil or spell == "INTERRUPT" ) then
-
-    -- remove cast action to the database
-    self.db[mob].cast = nil
-    self.db[mob].rank = nil
-    self.db[mob].start = nil
-    self.db[mob].casttime = nil
-    self.db[mob].icon = nil
-    self.db[mob].channel = nil
-  end
-end
-
--- main data
-libcast.db = { [player] = {} }
-
--- environmental casts
-libcast:RegisterEvent("CHAT_MSG_SPELL_SELF_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_HOSTILEPLAYER_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_HOSTILEPLAYER_BUFF")
-libcast:RegisterEvent("CHAT_MSG_SPELL_FRIENDLYPLAYER_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_FRIENDLYPLAYER_BUFF")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_HOSTILEPLAYER_BUFFS")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_BUFFS")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_HOSTILEPLAYER_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_SELF_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PARTY_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PARTY_BUFF")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_PARTY_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_PARTY_BUFFS")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_CREATURE_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_CREATURE_BUFFS")
-libcast:RegisterEvent("CHAT_MSG_SPELL_CREATURE_VS_CREATURE_DAMAGE")
-libcast:RegisterEvent("CHAT_MSG_SPELL_CREATURE_VS_CREATURE_BUFF")
-
--- player spells
-libcast:RegisterEvent("SPELLCAST_START")
-libcast:RegisterEvent("SPELLCAST_STOP")
-libcast:RegisterEvent("SPELLCAST_FAILED")
-libcast:RegisterEvent("SPELLCAST_INTERRUPTED")
-libcast:RegisterEvent("SPELLCAST_DELAYED")
-libcast:RegisterEvent("SPELLCAST_CHANNEL_START")
-libcast:RegisterEvent("SPELLCAST_CHANNEL_STOP")
-libcast:RegisterEvent("SPELLCAST_CHANNEL_UPDATE")
-
-local mob, spell, icon, _
-local lastSpellId = nil  -- spellId cached from SPELL_START_SELF (Nampower)
-
-libcast:SetScript("OnEvent", function()
-  -- Fill database with player casts
-  if event == "SPELLCAST_START" then
-    -- Get icon via spellId cached from SPELL_START_SELF
-    icon = lastSpellId and C_Spell.GetSpellTexture(lastSpellId) or nil
-    -- fallback to L["spells"] / lastcasttex if no icon resolved
-    if not icon then
-      icon = L["spells"][arg1] and L["spells"][arg1].icon and string.format("%s%s", "Interface\\Icons\\", L["spells"][arg1].icon) or lastcasttex
-    end
-    lastSpellId = nil
-
-    this.db[player].cast = arg1
-    this.db[player].rank = lastrank
-    this.db[player].start = GetTime()
-    this.db[player].casttime = arg2
-    this.db[player].icon = icon
-    this.db[player].channel = nil
-    
-    if not L["spells"][arg1] or not L["spells"][arg1].icon or not L["spells"][arg1].t then
-      L["spells"][arg1] = L["spells"][arg1] or { }
-      L["spells"][arg1].icon = L["spells"][arg1].icon or icon
-      L["spells"][arg1].t = L["spells"][arg1].t or arg2
-    end
-    lastcasttex, lastrank = nil, nil
-  elseif event == "SPELLCAST_STOP" or event == "SPELLCAST_FAILED" or event == "SPELLCAST_INTERRUPTED" then
-    lastSpellId = nil
-    if this.db[player] and not this.db[player].channel then
-      -- remove cast action to the database
-      this.db[player].cast = nil
-      this.db[player].rank = nil
-      this.db[player].rank = nil
-      this.db[player].start = nil
-      this.db[player].casttime = nil
-      this.db[player].icon = nil
-      this.db[player].channel = nil
-    else
-      lastcasttex, lastrank = nil, nil
-    end
-  elseif event == "SPELLCAST_DELAYED" then
-    if this.db[player].cast then
-      -- Pushback: increase casttime instead of shifting start
-      -- arg1 is the delay amount in milliseconds
-      this.db[player].casttime = this.db[player].casttime + arg1
-    end
-  elseif event == "SPELLCAST_CHANNEL_START" then
-    -- add cast action to the database
-    this.db[player].cast = arg2
-    this.db[player].rank = lastrank
-    this.db[player].start = GetTime()
-    this.db[player].casttime = arg1
-    this.db[player].icon = L["spells"][arg2] and L["spells"][arg2].icon and string.format("%s%s", "Interface\\Icons\\", L["spells"][arg2].icon) or lastcasttex
-    this.db[player].channel = true
-    
-    lastcasttex, lastrank = nil, nil
-  elseif event == "SPELLCAST_CHANNEL_STOP" then
-    if this.db[player] and this.db[player].channel then
-      -- remove cast action to the database
-      this.db[player].cast = nil
-      this.db[player].rank = nil
-      this.db[player].start = nil
-      this.db[player].casttime = nil
-      this.db[player].icon = nil
-      this.db[player].channel = nil
-    end
-  elseif event == "SPELLCAST_CHANNEL_UPDATE" then
-    if this.db[player].cast then
-      this.db[player].start = -this.db[player].casttime/1000 + GetTime() + arg1/1000
-    end
-  -- Fill database with environmental casts
-  elseif arg1 then
-    -- (.+) begins to cast (.+).
-    mob, spell = cmatch(arg1, SPELLCASTOTHERSTART)
-    if libcast:AddAction(mob, spell) then return end
-
-    -- (.+) begins to perform (.+).
-    mob, spell = cmatch(arg1, SPELLPERFORMOTHERSTART)
-    if libcast:AddAction(mob, spell) then return end
-
-    -- (.+) gains (.+).
-    mob, spell = cmatch(arg1, AURAADDEDOTHERHELPFUL)
-    if libcast:RemoveAction(mob, spell) then return end
-
-    -- (.+) is afflicted by (.+).
-    mob, spell = cmatch(arg1, AURAADDEDOTHERHARMFUL)
-    if libcast:RemoveAction(mob, spell) then return end
-
-    -- Your (.+) hits (.+) for (%d+).
-    spell, mob = cmatch(arg1, SPELLLOGSELFOTHER)
-    if libcast:RemoveAction(mob, spell) then return end
-
-    -- Your (.+) crits (.+) for (%d+).
-    spell, mob = cmatch(arg1, SPELLLOGCRITSELFOTHER)
-    if libcast:RemoveAction(mob, spell) then return end
-
-    -- (.+)'s (.+) %a hits (.+) for (%d+).
-    _, spell, mob = cmatch(arg1, SPELLLOGOTHEROTHER)
-    if libcast:RemoveAction(mob, spell) then return end
-
-    -- (.+)'s (.+) %a crits (.+) for (%d+).
-    _, spell, mob = cmatch(arg1, SPELLLOGCRITOTHEROTHER)
-    if libcast:RemoveAction(mob, spell) then return end
-
-    -- You interrupt (.+)'s (.+).
-    mob, _ = cmatch(arg1, SPELLINTERRUPTSELFOTHER)
-    if libcast:RemoveAction(mob, "INTERRUPT") then return end
-
-    -- (.+) interrupts (.+)'s (.+).
-    _, mob, _ = cmatch(arg1, SPELLINTERRUPTOTHEROTHER)
-    if libcast:RemoveAction(mob, "INTERRUPT") then return end
-  end
-end)
-
---[[ Custom Casts
-  Enable Castbars for spells that don't have a castbar by default
-  (e.g Multi-Shot and Aimed Shot)
-]]--
-local aimedshot = L["customcast"]["AIMEDSHOT"]
-local multishot = L["customcast"]["MULTISHOT"]
-
--- Shot-timer haste lookup. Keyed by icon path because some of these buffs have
--- spell-ID variants across server flavors but stable icons. Berserking is the
--- variable Troll-racial calculation (more haste at lower HP); other entries are
--- flat duration multipliers.
-local SHOT_HASTE = {
-  ["Interface\\Icons\\Racial_Troll_Berserk"]       = "berserking",
-  ["Interface\\Icons\\Ability_Hunter_RunningShot"] = 1.4,
-  ["Interface\\Icons\\Ability_Warrior_InnerRage"]  = 1.3,
-  ["Interface\\Icons\\Inv_Trinket_Naxxramas04"]    = 1.2,
-}
-
-function libcast.ApplyShotHaste(duration)
-  for _, a in ipairs(C_UnitAuras.GetUnitAuras("player", "HELPFUL")) do
-    local mult = SHOT_HASTE[a.icon]
-    if mult == "berserking" then
-      local hp = UnitHealth("player") / UnitHealthMax("player")
-      local berserk = hp >= 0.40 and (1.30 - hp) / 3 or 0.3
-      duration = duration / (1 + berserk)
-    elseif mult then
-      duration = duration / mult
-    end
-  end
-  return duration
-end
-
-libcast.customcast = {}
-libcast.customcast[strlower(aimedshot)] = function(begin, duration)
-  if begin then
-    local duration = libcast.ApplyShotHaste(duration or 3000)
-
-    local _,_, lag = GetNetStats()
-    local start = GetTime() + lag/1000
-
-    -- add cast action to the database
-    libcast.db[player].cast = aimedshot
-    libcast.db[player].rank = lastrank
-    libcast.db[player].start = start
-    libcast.db[player].casttime = duration
-    libcast.db[player].icon = "Interface\\Icons\\Inv_spear_07"
-    libcast.db[player].channel = nil
-  else
-    -- remove cast action to the database
-    libcast.db[player].cast = nil
-    libcast.db[player].rank = nil
-    libcast.db[player].start = nil
-    libcast.db[player].casttime = nil
-    libcast.db[player].icon = nil
-    libcast.db[player].channel = nil
-  end
-end
-
-libcast.customcast[strlower(multishot)] = function(begin, duration)
-  if begin then
-    local duration = libcast.ApplyShotHaste(duration or 500)
-
-    local _,_, lag = GetNetStats()
-    local start = GetTime() + lag/1000
-
-    -- add cast action to the database
-    libcast.db[player].cast = multishot
-    libcast.db[player].rank = lastrank
-    libcast.db[player].start = start
-    libcast.db[player].casttime = duration
-    libcast.db[player].icon = "Interface\\Icons\\Ability_upgrademoonglaive"
-    libcast.db[player].channel = nil
-  else
-    -- remove cast action to the database
-    libcast.db[player].cast = nil
-    libcast.db[player].rank = nil
-    libcast.db[player].start = nil
-    libcast.db[player].casttime = nil
-    libcast.db[player].icon = nil
-    libcast.db[player].channel = nil
-  end
-end
-
-local function CastCustom(id, bookType, rawSpellName, rank, texture, castingTime)
-  if not id or not rawSpellName then return end -- ignore if the spell is not found
-  if not castingTime or castingTime == 0 then
-    -- instant-cast: clear lastcasttex so next cast doesn't inherit this icon
-    lastcasttex, lastrank = nil, nil
-    return
-  end
-
-  lastrank = rank
-  lastcasttex = texture
-
-  local func = libcast.customcast[strlower(rawSpellName)]
-  if not func then return end
-
-  if GetSpellCooldown(id, bookType) == 0 or pfGetCastInfo(player) then return end -- detect casting
-
-  func(true)
-end
-
-hooksecurefunc("UseContainerItem", function(id, index)
-  lastcasttex = GetContainerItemInfo(id, index)
-end)
-
-hooksecurefunc("CastSpell", function(id, bookType)
-  local cachedRawSpellName, cachedRank, cachedTexture, cachedCastingTime, _, _, cachedSpellId, cachedBookType = libspell.GetSpellInfo(id, bookType)
-
-  CastCustom(cachedSpellId, cachedBookType, cachedRawSpellName, cachedRank, cachedTexture, cachedCastingTime)
-end)
-
-hooksecurefunc("CastSpellByName", function(spellCasted, target)
-  local cachedRawSpellName, cachedRank, cachedTexture, cachedCastingTime, _, _, cachedSpellId, cachedBookType = libspell.GetSpellInfo(spellCasted)
-
-  CastCustom(cachedSpellId, cachedBookType, cachedRawSpellName, cachedRank, cachedTexture, cachedCastingTime)
-end)
-
-hooksecurefunc("UseAction", function(slot, target, button)
-  if not IsCurrentAction(slot) then return end
-
-  -- Resolve action slot → spellID (handles both spell and macro actions),
-  -- then resolve to spellbook slot for libspell. GetMacroSpell returns the
-  -- highest rank the player actually knows, so FindSpellBookSlotByID's
-  -- "spell must be in spellbook" requirement is satisfied.
-  local kind, id = GetActionInfo(slot)
-  local spellID
-  if kind == "spell" then
-    spellID = id
-  elseif kind == "macro" then
-    local _, _, sid = GetMacroSpell(id)
-    spellID = sid
-  end
-  if not spellID then return end
-
-  local sbSlot = FindSpellBookSlotByID(spellID)
-  if not sbSlot then return end
-
-  local cachedRawSpellName, cachedRank, cachedTexture, cachedCastingTime, _, _, cachedSpellId, cachedBookType = libspell.GetSpellInfo(sbSlot, BOOKTYPE_SPELL)
-
-  CastCustom(cachedSpellId, cachedBookType, cachedRawSpellName, cachedRank, cachedTexture, cachedCastingTime)
-end)
-
--- Cache spellId from SPELL_START_SELF so SPELLCAST_START can use it for icon lookup
-pfUI.libdebuff_spell_start_self_hooks = pfUI.libdebuff_spell_start_self_hooks or {}
-pfUI.libdebuff_spell_start_self_hooks["libcast_icon"] = function(spellId)
-  lastSpellId = spellId
-end
-
--- add libcast to pfUI API
-pfUI.api.libcast = libcast

libs/libdebuff.lua

@@ -11,9 +11,12 @@ setfenv(1, pfUI:GetEnvironment())
 -- This eliminates ~400 lines of error-prone shift logic while maintaining full
 -- multi-caster tracking support.
 --
---  libdebuff:UnitDebuff(unit, id)
---    Returns debuff informations on the given effect of the specified unit.
---    name, rank, texture, stacks, dtype, duration, timeleft, caster
+-- The public per-aura readers (UnitDebuff, UnitOwnDebuff) were retired in favor
+-- of ClassicAPI's C_UnitAuras (which now provides sourceUnit/sourceGUID and
+-- non-player expirationTime). What remains in libdebuff is the cast-event
+-- bookkeeping consumed by GetBestAuraCast / GetEnhancedDebuffs and the
+-- libdebuff_*_hooks broadcast surface (subscribers in actionbar / swingtimer
+-- / libtotem react to SPELL_GO and SPELL_FAILED).
 
 -- return instantly when another libdebuff is already active
 if pfUI.api.libdebuff then return end
@@ -142,8 +145,6 @@ local iconCache = pfUI.libdebuff_icon_cache
 
 -- Cast Tracking: [casterGuid] = {spellID, spellName, icon, startTime, duration, endTime}
 -- Shared with nameplates for cast-bar display
-pfUI.libdebuff_casts = pfUI.libdebuff_casts or {}
-pfUI.libdebuff_item_icons = pfUI.libdebuff_item_icons or {}  -- [casterGuid] = icon (persists across SPELL_GO)
 
 -- Cleveroids API: [targetGUID][spellID] = {start, duration, caster, stacks}
 pfUI.libdebuff_objects_guid = pfUI.libdebuff_objects_guid or {}
@@ -426,7 +427,7 @@ local function GetDebuffSlotMap(guid)
     local spellId = auras[auraSlot]
     if spellId and spellId > 0 then
       displaySlot = displaySlot + 1
-      local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+      local spellName = C_Spell.GetSpellName(spellId)
       local texture = libdebuff:GetSpellIcon(spellId)
       local stacks = (auraApps and auraApps[auraSlot] or 0) + 1
       local dtype = nil
@@ -787,219 +788,6 @@ function libdebuff:AddEffect(unit, unitlevel, effect, duration, caster, rank)
   lastspell = libdebuff.objects[unit][unitlevel][effect]
 end
 
--- ============================================================================
--- MAIN API: UnitDebuff (GetUnitField-based)
--- ============================================================================
-
-local cache = {}
-
-function libdebuff:UnitDebuff(unit, displaySlot)
-  local unitname = UnitName(unit)
-  local unitlevel = UnitLevel(unit)
-  local duration, timeleft = nil, -1
-  local rank = nil
-  local caster = nil
-  local effect = nil
-  local texture = nil
-  local stacks = 0
-  local dtype = nil
-
-  -- Nampower: Use GetUnitField for ALL debuff data (no Blizzard UnitDebuff needed)
-  if hasNampower and UnitGUID then
-    local guid = UnitGUID(unit)
-    if not guid then
-      -- Safety fallback: no GUID available (should not happen with Nampower)
-      local aura = C_UnitAuras.GetDebuffDataByIndex(unit, displaySlot)
-      if aura then
-        return aura.name, rank, aura.icon, aura.applications, aura.dispelName, duration, timeleft, caster
-      end
-      return effect, rank, texture, stacks, dtype, duration, timeleft, caster
-    end
-    
-    -- Get current slot map from GetUnitField (cached 50ms)
-    local slotMap = GetDebuffSlotMap(guid)
-    if not slotMap or not slotMap[displaySlot] then
-      return nil
-    end
-    
-    local slotData = slotMap[displaySlot]
-    effect = slotData.spellName
-    texture = slotData.texture
-    stacks = slotData.stacks
-    dtype = slotData.dtype
-    local auraSlot = slotData.auraSlot
-    
-    -- Get caster info for this slot
-    local slotCasterGuid, isOurs = GetSlotCaster(guid, auraSlot, effect)
-    
-    if isOurs then
-      -- OUR debuff - get timer from ownDebuffs
-      if ownDebuffs[guid] and ownDebuffs[guid][effect] then
-        local data = ownDebuffs[guid][effect]
-        local remaining = (data.startTime + data.duration) - GetTime()
-        if remaining > 0 then
-          duration = data.duration
-          timeleft = remaining
-          caster = "player"
-          rank = data.rank
-        elseif remaining > -1 then
-          -- Grace period - show 0 timeleft
-          duration = data.duration
-          timeleft = 0
-          caster = "player"
-          rank = data.rank
-        end
-      end
-    else
-      -- OTHER player's debuff - get timer from allAuraCasts
-      if slotCasterGuid and allAuraCasts[guid] and allAuraCasts[guid][effect] then
-        local data = allAuraCasts[guid][effect][slotCasterGuid]
-        if data then
-          local remaining = (data.startTime + data.duration) - GetTime()
-          if remaining > 0 and data.duration > 0 then
-            duration = data.duration
-            timeleft = remaining
-            caster = "other"
-            rank = data.rank
-          end
-        end
-      end
-      
-      -- Fallback: Search all casters if specific one not found
-      if not duration and allAuraCasts[guid] and allAuraCasts[guid][effect] then
-        for anyCasterGuid, data in pairs(allAuraCasts[guid][effect]) do
-          local remaining = (data.startTime + data.duration) - GetTime()
-          if remaining > 0 and data.duration > 0 then
-            duration = data.duration
-            timeleft = remaining
-            caster = "other"
-            rank = data.rank
-            break
-          end
-        end
-      end
-    end
-    
-    return effect, rank, texture, stacks, dtype, duration, timeleft, caster
-  end
-
-  -- ============================================================================
-  -- FALLBACK: Legacy (non-Nampower) system
-  -- ============================================================================
-
-  local aura = C_UnitAuras.GetDebuffDataByIndex(unit, displaySlot)
-  if aura then
-    texture = aura.icon
-    stacks = aura.applications
-    dtype = aura.dispelName
-    effect = aura.name
-  end
-
-
-  if effect and libdebuff.objects[unitname] then
-    for level, effects in pairs(libdebuff.objects[unitname]) do
-      if effects[effect] and effects[effect].duration then
-        local timeleft = effects[effect].start and
-          effects[effect].start + effects[effect].duration - GetTime()
-
-        if timeleft and timeleft > 0 then
-          return effect, effects[effect].rank, texture, stacks, dtype,
-            effects[effect].duration, timeleft, effects[effect].caster
-        end
-      end
-    end
-  end
-
-  return effect, rank, texture, stacks, dtype, duration, timeleft, caster
-end
-
--- ============================================================================
--- API: UnitOwnDebuff (only OUR debuffs)
--- ============================================================================
-
--- Pre-defined sort function for UnitOwnDebuff (avoids closure creation per call)
-local _ownDebuffSortFunc = function(a, b)
-  if a.data.startTime == b.data.startTime then
-    return a.spellName < b.spellName
-  end
-  return a.data.startTime < b.data.startTime
-end
-
-function libdebuff:UnitOwnDebuff(unit, id)
-  if hasNampower and UnitGUID then
-    local guid = UnitGUID(unit)
-    if guid and ownDebuffs[guid] then
-      -- Build sorted list of our active debuffs
-      local sortedDebuffs = {}
-      local now = GetTime()
-      
-      local toRemove = nil
-      for spellName, data in pairs(ownDebuffs[guid]) do
-        local timeleft = (data.startTime + data.duration) - now
-        if timeleft > 0 then
-          local count = table.getn(sortedDebuffs) + 1
-          sortedDebuffs[count] = {
-            spellName = spellName,
-            data = data,
-            timeleft = timeleft
-          }
-        elseif data.pending then
-          if timeleft < -2 then
-            toRemove = toRemove or {}
-            toRemove[spellName] = true
-          end
-        else
-          toRemove = toRemove or {}
-          toRemove[spellName] = true
-        end
-      end
-      if toRemove then
-        for spellName in pairs(toRemove) do
-          ownDebuffs[guid][spellName] = nil
-        end
-      end
-      
-      -- Sort by startTime (oldest first = lowest display slot)
-      -- If startTime is equal (e.g. after Carnage refresh), use spellName for stable sorting
-      table.sort(sortedDebuffs, _ownDebuffSortFunc)
-      
-      -- Return debuff at position 'id'
-      if sortedDebuffs[id] then
-        local entry = sortedDebuffs[id]
-        local texture = entry.data.texture or "Interface\\Icons\\INV_Misc_QuestionMark"
-        local displayTimeleft = entry.timeleft > 0 and entry.timeleft or 0
-        
-        -- Get dtype from SpellRec DBC via stored spellId
-        local entryDtype = nil
-        if entry.data.spellId and GetSpellRecField then
-          local dispelId = GetSpellRecField(entry.data.spellId, "dispel")
-          if dispelId and dispelId > 0 then
-            entryDtype = dispelTypeMap[dispelId]
-          end
-        end
-        
-        return entry.spellName, entry.data.rank, texture, 1, entryDtype, entry.data.duration, displayTimeleft, "player"
-      end
-    end
-    return nil
-  end
-  
-  -- Fallback: Iterate through all debuffs and filter
-  for k in pairs(cache) do cache[k] = nil end
-  local count = 1
-  for i=1,16 do
-    local effect, rank, texture, stacks, dtype, duration, timeleft, caster = libdebuff:UnitDebuff(unit, i)
-    if effect and not cache[effect] and caster and caster == "player" then
-      cache[effect] = true
-      if count == id then
-        return effect, rank, texture, stacks, dtype, duration, timeleft, caster
-      else
-        count = count + 1
-      end
-    end
-  end
-end
-
 -- ============================================================================
 -- API: GetBestAuraCast (for libpredict HoT tracking)
 -- ============================================================================
@@ -1144,12 +932,8 @@ if hasNampower then
           pfTarget.update_aura = true
         end
       end
-      
-      if pfUI.nameplates and pfUI.nameplates.OnAuraUpdate then
-        pfUI.nameplates:OnAuraUpdate(guid)
-      end
     end
-    
+
     carnageState = nil
     this:Hide()
   end)
@@ -1180,23 +964,19 @@ if hasNampower then
       return
       
     elseif event == "SPELLCAST_CHANNEL_STOP" then
-      -- Channel interrupted by player - clear ownDebuffs for the channeled spell immediately.
-      -- DEBUFF_REMOVED fires later (0.5-1s server lag), causing phantom debuff display.
-      -- We look up the active channel cast and pre-clear ownDebuffs for its target.
-      local myGuid = GetPlayerGUID()
-      local castData = myGuid and pfUI.libdebuff_casts[myGuid]
-      if castData and castData.event == "CHANNEL" and castData.spellName then
-        local spellName = castData.spellName
+      -- Channel interrupted by player - clear ownDebuffs for the channeled spell
+      -- via C_Spell.ChannelInfo. DEBUFF_REMOVED fires later (0.5-1s server lag),
+      -- causing phantom debuff display without this pre-clear.
+      local spellName = select(1, C_Spell.ChannelInfo())
+      if spellName then
         local targetGuid = UnitGUID and UnitGUID("target")
         if targetGuid and ownDebuffs[targetGuid] and ownDebuffs[targetGuid][spellName] then
           local data = ownDebuffs[targetGuid][spellName]
-          -- Only clear if the timer is still active (not already expired naturally)
           local remaining = (data.startTime + data.duration) - GetTime()
           if remaining > 0 then
             ownDebuffs[targetGuid][spellName] = nil
           end
         end
-        pfUI.libdebuff_casts[myGuid] = nil
       end
 
     elseif event == "PLAYER_ENTERING_WORLD" then
@@ -1218,48 +998,15 @@ if hasNampower then
       end
 
     elseif event == "SPELL_START_SELF" or event == "SPELL_START_OTHER" then
-      local itemId = arg1
       local spellId = arg2
       local casterGuid = arg3
-      local spellType = arg8 or 0  -- 0=Normal, 1=Channel, 2=Autorepeating
-      -- arg6=castTime, arg7=channel duration
-      -- prefer arg6 if present — some spells (e.g. Volley post-rework) still send
-      -- arg8=1 but now have a real cast time in arg6, so we only fall back to arg7
-      -- when arg6 is nil (true channels like Blizzard)
-      -- arg6=castTime (ms), arg7=channel duration (ms), arg8=spellType
-      -- For channels: arg6=0 (no cast time), arg7=duration, spellType=1
-      -- For normal casts: arg6=castTime, arg7=0, spellType=0
-      -- Note: "not arg6" is wrong in Lua since 0 is truthy - use arg6 == 0 or nil
+      -- arg6=castTime (ms), arg7=channel duration (ms). Prefer arg6 when set —
+      -- some spells (e.g. post-rework Volley) flag as channel via arg8 but ship a
+      -- real cast time in arg6, so we only fall back to arg7 for true channels
+      -- like Blizzard where arg6 is 0/nil.
       local castTime = (arg6 and arg6 > 0) and arg6 or arg7
-      local isChannel = spellType == 1 and (not arg6 or arg6 == 0)
-      
       if not casterGuid or not spellId then return end
 
-      local spellName = C_Spell.GetSpellName(spellId)
-      local icon = libdebuff:GetSpellIcon(spellId)
-      
-      -- Use item icon for item-triggered casts
-      if itemId and itemId > 0 then
-        icon = C_Item.GetItemIconByID(itemId) or icon
-        pfUI.libdebuff_item_icons[casterGuid] = {
-          icon = icon,
-          name = GetItemInfo(itemId),
-        }
-      else
-        pfUI.libdebuff_item_icons[casterGuid] = nil
-      end
-      
-      pfUI.libdebuff_casts[casterGuid] = {
-        spellID = spellId,
-        itemID = itemId and itemId > 0 and itemId or nil,
-        spellName = spellName,
-        icon = icon,
-        startTime = GetTime(),
-        duration = castTime and castTime / 1000 or 0,
-        endTime = castTime and (GetTime() + castTime / 1000) or nil,
-        event = isChannel and "CHANNEL" or "START"
-      }
-
       if event == "SPELL_START_SELF" and pfUI.libdebuff_spell_start_self_hooks then
         for _, fn in pairs(pfUI.libdebuff_spell_start_self_hooks) do
           fn(spellId, casterGuid, arg4, castTime)
@@ -1277,16 +1024,7 @@ if hasNampower then
       local targetGuid = arg4
       local numHit = arg6 or 0
       local numMissed = arg7 or 0
-      
-      -- Clear cast bar only if SPELL_GO matches the active cast
-      -- (Reactive procs like Frost Armor trigger SPELL_GO but shouldn't clear the castbar)
-      -- Don't clear channels on SPELL_GO - channels persist until duration expires or SPELL_FAILED
-      if casterGuid and pfUI.libdebuff_casts[casterGuid] then
-        if pfUI.libdebuff_casts[casterGuid].spellID == spellId and pfUI.libdebuff_casts[casterGuid].event ~= "CHANNEL" then
-          pfUI.libdebuff_casts[casterGuid] = nil
-        end
-      end
-      
+
       -- Fire registered SPELL_GO_SELF hooks BEFORE miss guard
       -- (Swingtimer needs to see ALL casts, even misses, for swing reset)
       if event == "SPELL_GO_SELF" and pfUI.libdebuff_spell_go_hooks then
@@ -1297,15 +1035,15 @@ if hasNampower then
 
       if numMissed > 0 or numHit == 0 then return end
 
-      local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
-      local spellRankString = GetSpellRecField and GetSpellRecField(spellId, "rank")
+      local spellName = C_Spell.GetSpellName(spellId)
       if not spellName then return end
-      
+      local spellRankString = C_Spell.GetSpellSubtext(spellId)
+
       local castRank = 0
       if spellRankString and spellRankString ~= "" then
         castRank = tonumber((string.gsub(spellRankString, "Rank ", ""))) or 0
       end
-      
+
       -- Store in pendingCasts for DEBUFF_ADDED correlation.
       -- If this cast is a downrank of an already active debuff, fire the downrank blocked hook
       -- so external addons (e.g. SuperCleveRoidMacros) don't need to re-implement this check.
@@ -1410,14 +1148,6 @@ if hasNampower then
 
     elseif event == "SPELL_FAILED_OTHER" then
       local casterGuid = arg1
-      local spellId = arg2
-
-      if casterGuid and pfUI.libdebuff_casts[casterGuid] then
-        -- Only clear if spellID matches to avoid clearing a cast that already moved on
-        if pfUI.libdebuff_casts[casterGuid].spellID == spellId then
-          pfUI.libdebuff_casts[casterGuid] = nil
-        end
-      end
       if pfUI.libdebuff_spell_failed_other_hooks then
         for _, fn in pairs(pfUI.libdebuff_spell_failed_other_hooks) do
           fn(casterGuid, arg2)
@@ -1479,7 +1209,7 @@ if hasNampower then
       if not spellId then return end
       if not targetGuid or targetGuid == "" or targetGuid == "0x0000000000000000" then return end
       
-      local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+      local spellName = C_Spell.GetSpellName(spellId)
       if not spellName then return end
       
       -- Deduplicate: Ignore if we processed this exact cast recently (within 100ms)
@@ -1635,11 +1365,6 @@ if hasNampower then
 
       end
       
-      -- Notify nameplates
-        if pfUI.nameplates and pfUI.nameplates.OnAuraUpdate then
-          pfUI.nameplates:OnAuraUpdate(targetGuid)
-        end
-        
         -- Notify unitframes of debuff updates (UNIT_AURA doesn't fire on refreshes!)
         -- Check player
         if UnitGUID("player") then
@@ -1744,7 +1469,7 @@ if hasNampower then
 
       -- Invalidate slot map cache for this GUID
       
-      local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+      local spellName = C_Spell.GetSpellName(spellId)
       if not spellName then return end
       
       if debugStats.enabled then
@@ -1857,11 +1582,7 @@ if hasNampower then
       
       -- Cleanup expired timers
       CleanupExpiredTimers(guid)
-      
-      -- Notify nameplates
-      if pfUI.nameplates and pfUI.nameplates.OnAuraUpdate then
-        pfUI.nameplates:OnAuraUpdate(guid)
-      end
+
       if pfUI.libdebuff_debuff_added_other_hooks then
         for _, fn in pairs(pfUI.libdebuff_debuff_added_other_hooks) do
           fn(arg1, arg2, arg3, arg4)
@@ -1878,9 +1599,9 @@ if hasNampower then
       local auraSlot = auraSlot_0based and (auraSlot_0based + 1) or nil
 
       -- Invalidate slot map cache for this GUID
-      
-      local spellName = (GetSpellRecField and GetSpellRecField(spellId, "name")) or "?"
-      
+
+      local spellName = C_Spell.GetSpellName(spellId) or "?"
+
       if debugStats.enabled then
         debugStats.debuff_removed = debugStats.debuff_removed + 1
         if IsCurrentTarget(guid) then
@@ -1888,13 +1609,13 @@ if hasNampower then
             GetDebugTimestamp(), displaySlot, auraSlot or -1, auraSlot_0based or -1, spellName))
         end
       end
-      
+
       -- If unit is dead, cleanup all
       if UnitIsDead and UnitIsDead(guid) then
         CleanupUnit(guid)
         return
       end
-      
+
       -- Get auraSlot from event parameter (Nampower 2.29+)
       -- Fallback to displayToAura mapping if not available
       local foundAuraSlot = auraSlot
@@ -1950,11 +1671,7 @@ if hasNampower then
       
       -- Cleanup expired timers
       CleanupExpiredTimers(guid)
-      
-      -- Notify nameplates
-      if pfUI.nameplates and pfUI.nameplates.OnAuraUpdate then
-        pfUI.nameplates:OnAuraUpdate(guid)
-      end
+
       if pfUI.libdebuff_debuff_removed_other_hooks then
         for _, fn in pairs(pfUI.libdebuff_debuff_removed_other_hooks) do
           fn(arg1, arg2, arg3, arg4)

libs/libpredict.lua

@@ -44,78 +44,13 @@ local healGuidToName = {} -- [casterGuid] = casterName, for SPELL_FAILED_OTHER c
 local ress_timers = {}    -- [target][sender] = expiry_timestamp (60s rez window)
 local RESS_TIMEOUT = 60   -- Vanilla: rez offer expires after 60s
 
-local PRAYER_OF_HEALING
-do -- Prayer of Healing
-  local locales = {
-    ["deDE"] = "Gebet der Heilung",
-    ["enUS"] = "Prayer of Healing",
-    ["esES"] = "Rezo de curación",
-    ["frFR"] = "Prière de soins",
-    ["koKR"] = "치유의 기원",
-    ["ruRU"] = "Молитва исцеления",
-    ["zhCN"] = "治疗祷言",
-  }
-
-  PRAYER_OF_HEALING = locales[GetLocale()] or locales["enUS"]
-end
-
-local REJUVENATION
-do -- Rejuvenation
-  local locales = {
-    ["deDE"] = "Verjüngung",
-    ["enUS"] = "Rejuvenation",
-    ["esES"] = "Rejuvenecimiento",
-    ["frFR"] = "Récupération",
-    ["koKR"] = "회복",
-    ["ruRU"] = "Омоложение",
-    ["zhCN"] = "回春术",
-  }
-
-  REJUVENATION = locales[GetLocale()] or locales["enUS"]
-end
-
-local RENEW
-do -- Renew
-  local locales = {
-    ["deDE"] = "Erneuerung",
-    ["enUS"] = "Renew",
-    ["esES"] = "Renovar",
-    ["frFR"] = "Rénovation",
-    ["koKR"] = "소생",
-    ["ruRU"] = "Обновление",
-    ["zhCN"] = "恢复",
-  }
-
-  RENEW = locales[GetLocale()] or locales["enUS"]
-end
-
-local REGROWTH
-do -- Regrowth
-  local locales = {
-    ["deDE"] = "Nachwachsen",
-    ["enUS"] = "Regrowth",
-    ["esES"] = "Recrecimiento",
-    ["frFR"] = "Rétablissement",
-    ["koKR"] = "재생",
-    ["ruRU"] = "Восстановление",
-    ["zhCN"] = "愈合",
-  }
-
-  REGROWTH = locales[GetLocale()] or locales["enUS"]
-end
-
-
--- Spell IDs for SPELL_GO_SELF callback (Nampower) - Instant HoT detection
-local SPELL_IDS = {
-  -- Rejuvenation (all ranks)
-  [774] = "Reju", [1058] = "Reju", [1430] = "Reju", [2090] = "Reju", [2091] = "Reju",
-  [3627] = "Reju", [8910] = "Reju", [9839] = "Reju", [9840] = "Reju", [9841] = "Reju",
-  [25299] = "Reju", [26981] = "Reju", [26982] = "Reju",
-  -- Renew (all ranks)
-  [139] = "Renew", [6074] = "Renew", [6075] = "Renew", [6076] = "Renew", [6077] = "Renew",
-  [6078] = "Renew", [10927] = "Renew", [10928] = "Renew", [10929] = "Renew", [25315] = "Renew",
-  [25221] = "Renew", [25222] = "Renew",
-}
+-- Localized spell names resolved once from canonical rank-1 spellIDs.
+-- Every rank shares the same name, so per-rank comparisons elsewhere can
+-- be done against these constants without per-locale or per-rank tables.
+local PRAYER_OF_HEALING = C_Spell.GetSpellName(596)   -- Prayer of Healing (Rank 1)
+local REJUVENATION      = C_Spell.GetSpellName(774)   -- Rejuvenation (Rank 1)
+local RENEW             = C_Spell.GetSpellName(139)   -- Renew (Rank 1)
+local REGROWTH          = C_Spell.GetSpellName(8936)  -- Regrowth (Rank 1)
 
 local libpredict = CreateFrame("Frame")
 libpredict:RegisterEvent("UNIT_HEALTH")
@@ -173,7 +108,7 @@ end
 
 local function isRezSpell(spellId)
   if not L["resurrections"] then return false end
-  local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+  local spellName = C_Spell.GetSpellName(spellId)
   return spellName and L["resurrections"][spellName]
 end
 
@@ -192,7 +127,7 @@ end)
 -- SPELL_START_SELF: own cast started (heals + rez)
 pfUI.libdebuff_spell_start_self_hooks = pfUI.libdebuff_spell_start_self_hooks or {}
 pfUI.libdebuff_spell_start_self_hooks["libpredict"] = function(spellId, casterGuid, targetGuid, castTime)
-  local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+  local spellName = C_Spell.GetSpellName(spellId)
   if not spellName then return end
 
   local pendingTarget = nil
@@ -255,7 +190,7 @@ pfUI.libdebuff_spell_start_self_hooks["libpredict"] = function(spellId, casterGu
       -- selfcast (ALT) = player, otherwise = current target
       -- Use this to find the correct group to heal
       local pohTarget = target or player
-      if GetNumRaidMembers() > 0 then
+      if IsInRaid() then
         -- Raid: find pohTarget's subgroup and heal only those members
         -- (Turtle WoW changed PoH to heal the target's group, not the caster's group)
         local targetGroup
@@ -319,7 +254,7 @@ end
 -- SPELL_GO_SELF: own cast landed (HealStop + Regrowth timer)
 pfUI.libdebuff_spell_go_hooks["libpredict_sender"] = function(spellId)
   libpredict:HealStop(player)
-  local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+  local spellName = C_Spell.GetSpellName(spellId)
   if spellName == REGROWTH then
     local now = pfUI.uf.now or GetTime()
     if libpredict.sender.regrowth_timer then
@@ -337,7 +272,7 @@ end
 -- Signature: fn(spellId, casterGuid, targetGuid, castTime)
 pfUI.libdebuff_spell_start_other_hooks = pfUI.libdebuff_spell_start_other_hooks or {}
 pfUI.libdebuff_spell_start_other_hooks["libpredict"] = function(spellId, casterGuid, targetGuid, castTime)
-  local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+  local spellName = C_Spell.GetSpellName(spellId)
   if not spellName then return end
 
   local casterName = resolveNameFromGuid(casterGuid)
@@ -364,7 +299,7 @@ pfUI.libdebuff_spell_start_other_hooks["libpredict"] = function(spellId, casterG
 
   -- Prayer of Healing: heal entire subgroup of the target
   if spellName == PRAYER_OF_HEALING then
-    if GetNumRaidMembers() > 0 then
+    if IsInRaid() then
       local targetGroup
       for i = 1, GetNumRaidMembers() do
         local rname, _, subgroup = GetRaidRosterInfo(i)
@@ -404,8 +339,13 @@ end
 -- Signature: fn(spellId, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 pfUI.libdebuff_spell_go_hooks = pfUI.libdebuff_spell_go_hooks or {}
 pfUI.libdebuff_spell_go_hooks["libpredict"] = function(spellId, a1, a2, a3, a4, a5, a6, a7)
-  -- Instant HoTs
-  local hotType = SPELL_IDS[spellId]
+  -- Instant HoTs — classify by name (rank-independent) instead of a
+  -- hardcoded per-rank ID table.
+  local spellName = C_Spell.GetSpellName(spellId)
+  local hotType
+  if spellName == REJUVENATION then hotType = "Reju"
+  elseif spellName == RENEW then hotType = "Renew"
+  end
   if hotType then
     local targetGuid = a4
     local targetName = resolveNameFromGuid(targetGuid)
@@ -426,9 +366,9 @@ pfUI.libdebuff_spell_go_hooks["libpredict"] = function(spellId, a1, a2, a3, a4,
       local rankStr = tostring(rank)
       if libpredict.sender and libpredict.sender.SendHealCommMsg then
         libpredict.sender:SendHealCommMsg(hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/")
-      elseif GetNumRaidMembers() > 0 then
+      elseif IsInRaid() then
         SendAddonMessage("HealComm", hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/", "RAID")
-      elseif GetNumPartyMembers() > 0 then
+      elseif IsInGroup() then
         SendAddonMessage("HealComm", hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/", "PARTY")
       end
     end
@@ -546,30 +486,47 @@ function libpredict:ParseComm(sender, msg)
           rank = tonumber(rankStr)
         end
       end
-    elseif select and pfGetCastInfo then
+    elseif select then
       -- latest healcomm
       msgtype = tonumber(string.sub(msg, 1, 3))
       if not msgtype then return end
 
+      -- Resolve sender's name to a group unit token so C_Spell can query
+      -- the cast. Group rosters are tiny (44 slots max) so the walk is cheap
+      -- relative to the cost of receiving a HealComm message.
+      local function senderUnit()
+        if UnitName("player") == sender then return "player" end
+        for i = 1, GetNumPartyMembers() do
+          if UnitName("party"..i) == sender then return "party"..i end
+        end
+        for i = 1, GetNumRaidMembers() do
+          if UnitName("raid"..i) == sender then return "raid"..i end
+        end
+      end
+
       if msgtype == 0 then
         msgtype = "Heal"
         heal = tonumber(string.sub(msg, 4, 8))
         target = string.sub(msg,9, -1)
 
-        local starttime = select(5, pfGetCastInfo(sender))
-        local endtime = select(6, pfGetCastInfo(sender))
-        if not starttime or not endtime then return end
-        time = endtime - starttime
+        local unit = senderUnit()
+        if not unit then return end
+        local startMs = select(4, C_Spell.UnitCastingInfo(unit))
+        local endMs = select(5, C_Spell.UnitCastingInfo(unit))
+        if not startMs or not endMs then return end
+        time = (endMs - startMs) / 1000
       elseif msgtype == 1 then
         msgtype = "Stop"
       elseif msgtype == 2 then
         msgtype = "Heal"
         heal = tonumber(string.sub(msg,4, 8))
         target = {strsplit(":", string.sub(msg,9, -1))}
-        local starttime = select(5, pfGetCastInfo(sender))
-        local endtime = select(6, pfGetCastInfo(sender))
-        if not starttime or not endtime then return end
-        time = endtime - starttime
+        local unit = senderUnit()
+        if not unit then return end
+        local startMs = select(4, C_Spell.UnitCastingInfo(unit))
+        local endMs = select(5, C_Spell.UnitCastingInfo(unit))
+        if not startMs or not endMs then return end
+        time = (endMs - startMs) / 1000
       end
     end
   end
@@ -944,16 +901,6 @@ local INSTANT_HOT_COOLDOWN = 1.0  -- 1 Sekunde Cooldown (GCD ist 1.5s)
 -- Pending HoTs Queue - wird nach Delay verifiziert
 local pendingHots = {}
 
--- Helper: check if buff is present on unit
-local function UnitHasBuff(unit, buffName)
-  for i = 1, 32 do
-    local name = UnitBuff(unit, i)
-    if not name then break end
-    if name == buffName then return true end
-  end
-  return false
-end
-
 -- Gather Data by User Actions
 hooksecurefunc("CastSpell", function(id, bookType)
   if not libpredict.sender.enabled then return end
@@ -1012,8 +959,6 @@ hooksecurefunc("CastSpellByName", function(effect, target)
   if not libpredict.sender.enabled then return end
   local effect, rank = libspell.GetSpellInfo(effect)
   if not effect then return end
-  local mouseover = pfUI and pfUI.uf and pfUI.uf.mouseover and pfUI.uf.mouseover.unit
-  mouseover = mouseover and UnitCanAssist("player", mouseover) and UnitName(mouseover)
 
   local default = UnitName("target") and UnitCanAssist("player", "target") and UnitName("target") or UnitName("player")
 
@@ -1032,13 +977,13 @@ hooksecurefunc("CastSpellByName", function(effect, target)
   if not libpredict.sender.current_cast then
     spell_queue[1] = effect
     spell_queue[2] = effect.. ( rank or "" )
-    spell_queue[3] = target or mouseover or default
+    spell_queue[3] = target or default
   end
   
   -- Instant HoTs: libdebuff/Nampower via GetHotDuration, hook method as fallback
   
   if effect == REJUVENATION then
-    local hotTarget = target or mouseover or default
+    local hotTarget = target or default
     local now = pfUI.uf.now or GetTime()
     local key = "Reju" .. hotTarget
     
@@ -1055,7 +1000,7 @@ hooksecurefunc("CastSpellByName", function(effect, target)
     local rankStr = rankNum and tostring(rankNum) or "0"
     libpredict.sender:SendHealCommMsg("Reju/"..hotTarget.."/"..rejuvDuration.."/"..rankStr.."/")
   elseif effect == RENEW then
-    local hotTarget = target or mouseover or default
+    local hotTarget = target or default
     local now = pfUI.uf.now or GetTime()
     local key = "Renew" .. hotTarget
     
@@ -1138,10 +1083,10 @@ libpredict.sender = CreateFrame("Frame", "pfPredictionSender", UIParent)
 libpredict.sender.enabled = true
 libpredict.sender.SendHealCommMsg = function(self, msg)
   -- Smart channel selection: Only send to relevant channel to avoid duplicates
-  if GetNumRaidMembers() > 0 then
+  if IsInRaid() then
     -- In raid: Only send to RAID (includes all raid members)
     SendAddonMessage("HealComm", msg, "RAID")
-  elseif GetNumPartyMembers() > 0 then
+  elseif IsInGroup() then
     -- In party: Only send to PARTY
     SendAddonMessage("HealComm", msg, "PARTY")
   end
@@ -1150,10 +1095,10 @@ libpredict.sender.SendHealCommMsg = function(self, msg)
 end
 libpredict.sender.SendResCommMsg = function(self, msg)
   -- Smart channel selection: Only send to relevant channel to avoid duplicates
-  if GetNumRaidMembers() > 0 then
+  if IsInRaid() then
     -- In raid: Only send to RAID (includes all raid members)
     SendAddonMessage("CTRA", msg, "RAID")
-  elseif GetNumPartyMembers() > 0 then
+  elseif IsInGroup() then
     -- In party: Only send to PARTY
     SendAddonMessage("CTRA", msg, "PARTY")
   end
@@ -1229,7 +1174,7 @@ libpredict.sender:SetScript("OnEvent", function()
     local amount  = arg4
     local isCrit  = arg5 == 1
     local isPeriodic = arg6 == 1
-    local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+    local spellName = C_Spell.GetSpellName(spellId)
     if spellName and spell_queue[1] == spellName then
       UpdateCache(spell_queue[2], amount, isCrit)
     end
@@ -1249,9 +1194,9 @@ libpredict.sender:SetScript("OnEvent", function()
     local casterName = resolveNameFromGuid(casterGuid)
     if not casterName or casterName == player then return end  -- own heals handled by SPELL_HEAL_BY_SELF
 
-    local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
+    local spellName = C_Spell.GetSpellName(spellId)
     if not spellName then return end
-    local rankStr = GetSpellRecField and GetSpellRecField(spellId, "rank") or ""
+    local rankStr = C_Spell.GetSpellSubtext(spellId)
     local spellKey = spellName .. (rankStr or "")
 
     foreignCache[casterName] = foreignCache[casterName] or {}

modules/afkcam.lua

@@ -151,9 +151,7 @@ pfUI:RegisterModule("afkcam", function ()
   delay:SetScript("OnUpdate", function()
     if ( this.tick or 0) > GetTime() then return else this.tick = GetTime() + 1 end
 
-    local name = UnitName("player")
-    local cast = pfGetCastInfo(name)
-    if not cast then cast = pfGetChannelInfo(name) end
+    local cast = C_Spell.UnitCastingInfo("player") or C_Spell.UnitChannelInfo("player")
     if not this.delay then this.delay = 0 end
 
     if cast then

modules/buff.lua

@@ -60,6 +60,7 @@ pfUI:RegisterModule("buff", function ()
       buff.mode = buff.btype
       buff.expirationTime = aura.expirationTime
       buff.stackCount = aura.applications
+      buff.spellId = aura.spellId
       buff.texture:SetTexture(aura.icon)
 
       if buff.btype == "HARMFUL" then
@@ -146,9 +147,8 @@ pfUI:RegisterModule("buff", function ()
         CancelItemTempEnchantment(1)
       elseif CancelItemTempEnchantment and this.mode and this.mode == "OFFHAND" then
         CancelItemTempEnchantment(2)
-      else
-        local bid = GetPlayerBuff(PLAYER_BUFF_START_ID + this.id, this.btype)
-        if bid >= 0 then CancelPlayerBuff(bid) end
+      elseif this.spellId then
+        C_Spell.CancelSpellByID(this.spellId)
       end
     end)
 

modules/buffwatch.lua

@@ -74,18 +74,11 @@ pfUI:RegisterModule("buffwatch", function ()
   end
 
   local function GetBuffData(unit, id, type, selfdebuff)
-    if unit == "player" then
-      local aura = C_UnitAuras.GetAuraDataByIndex("player", id, type)
-      if not aura then return end
-      local remaining = aura.expirationTime > 0 and (aura.expirationTime - GetTime()) or 0
-      return remaining, aura.icon, aura.name, aura.applications
-    elseif libdebuff and selfdebuff then
-      local name, _, texture, stacks, _, _, timeleft = libdebuff:UnitOwnDebuff(unit, id)
-      return timeleft, texture, name, stacks
-    elseif libdebuff then
-      local name, _, texture, stacks, _, _, timeleft = libdebuff:UnitDebuff(unit, id)
-      return timeleft, texture, name, stacks
-    end
+    local filter = (selfdebuff and type == "HARMFUL") and "HARMFUL|PLAYER" or type
+    local aura = C_UnitAuras.GetAuraDataByIndex(unit, id, filter)
+    if not aura then return end
+    local remaining = aura.expirationTime > 0 and (aura.expirationTime - GetTime()) or 0
+    return remaining, aura.icon, aura.name, aura.applications
   end
 
   local function StatusBarOnClick()
@@ -106,8 +99,8 @@ pfUI:RegisterModule("buffwatch", function ()
         DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now blacklisted."])
       end
     elseif this.parent.unit == "player" then
-      local bid = GetPlayerBuff(PLAYER_BUFF_START_ID + this.id, this.type)
-      if bid >= 0 then CancelPlayerBuff(bid) end
+      local aura = C_UnitAuras.GetAuraDataByIndex("player", this.id, this.type)
+      if aura and aura.spellId then C_Spell.CancelSpellByID(aura.spellId) end
     end
   end
 
@@ -117,15 +110,17 @@ pfUI:RegisterModule("buffwatch", function ()
     if this.unit == "player" then
       GameTooltip:SetUnitAura("player", this.id, this.type)
     elseif this.type == "HARMFUL" then
-      -- For "only own debuffs" mode: find the REAL slot by matching spell name AND caster
+      -- selfdebuff filters the displayed list to player-cast harmful auras, but
+      -- SetUnitAura's index has to be into the engine's full HARMFUL list. Look
+      -- up the displayed aura via the PLAYER filter, then scan engine slots for
+      -- one whose name + sourceGUID match.
       local config = this.parent and this.parent.config
-      if config and config.selfdebuff == "1" and libdebuff then
-        local ownDebuffName = libdebuff:UnitOwnDebuff(this.unit, this.id)
-        if ownDebuffName then
-          -- Search through all game slots to find OUR debuff with matching name
+      if config and config.selfdebuff == "1" then
+        local ownAura = C_UnitAuras.GetAuraDataByIndex(this.unit, this.id, "HARMFUL|PLAYER")
+        if ownAura then
           for gameSlot = 1, 16 do
-            local gameName, _, _, _, _, _, _, gameCaster = libdebuff:UnitDebuff(this.unit, gameSlot)
-            if gameName == ownDebuffName and gameCaster == "player" then
+            local check = C_UnitAuras.GetDebuffDataByIndex(this.unit, gameSlot)
+            if check and check.name == ownAura.name and check.sourceGUID == ownAura.sourceGUID then
               GameTooltip:SetUnitAura(this.unit, gameSlot, "HARMFUL")
               break
             end

modules/castbar.lua

@@ -16,6 +16,141 @@ pfUI:RegisterModule("castbar", function ()
     end
   end
 
+  -- Clear cast state on the bar. Shows the bar full for one frame, then
+  -- OnUpdate fades it out.
+  local function ClearBar(cb)
+    cb.startTime, cb.endTime, cb.isChannel = nil, nil, nil
+    cb.activeName, cb.spellID = nil, nil
+    cb.isTradeskill = nil
+    cb.tradeskillTotal, cb.tradeskillCompleted, cb.tradeskillSpellID = nil, nil, nil
+    cb.tradeskillSingleMs, cb.currentCraftStart = nil, nil
+    cb.lastMax = nil
+    cb.delay = 0
+    cb.bar:SetMinMaxValues(1, 100)
+    cb.bar:SetValue(100)
+    if cb.bar.spark then cb.bar.spark:Hide() end
+    cb.fadeout = 1
+  end
+
+  -- "Spellname (N)" label for an active tradeskill merge — N is the number
+  -- of crafts remaining. Falls back to the bare spell name when ≤1 left.
+  local function UpdateTradeskillLabel(cb)
+    if not cb.tradeskillTotal or not cb.activeName or not cb.showname then return end
+    local remaining = cb.tradeskillTotal - (cb.tradeskillCompleted or 0)
+    if remaining > 1 then
+      cb.bar.left:SetText(string.format("%s (%d)", cb.activeName, remaining))
+    else
+      cb.bar.left:SetText(cb.activeName)
+    end
+  end
+
+  -- Stretch the bar to span all queued crafts (Quartz-style merge): the bar
+  -- fills continuously across the chain instead of resetting per craft.
+  -- Also arms the per-craft spark — a thin marker that crosses the bar once
+  -- per craft (so it moves N× faster than the main fill on an N-stack).
+  local function EnterTradeskillMerge(cb, startMs, endMs, count)
+    cb.tradeskillTotal = count
+    cb.tradeskillCompleted = 0
+    cb.tradeskillSpellID = cb.spellID
+    local single = endMs - startMs
+    cb.tradeskillSingleMs = single
+    cb.currentCraftStart = startMs
+    local mergedEnd = startMs + single * count
+    cb.endTime = mergedEnd
+    local duration = (mergedEnd - startMs) / 1000
+    cb.bar:SetMinMaxValues(0, duration)
+    cb.lastMax = duration
+    if cb.bar.spark then cb.bar.spark:Show() end
+    UpdateTradeskillLabel(cb)
+  end
+
+  -- Mark the start of craft 2..N within an active merge (called from the
+  -- SPELLCAST_START / SPELL_START_SELF handlers). Resets the per-craft
+  -- spark to the left edge of the bar.
+  local function StartTradeskillCraft(cb)
+    cb.currentCraftStart = GetTime() * 1000
+    UpdateTradeskillLabel(cb)
+  end
+
+  -- Stamp the bar with cast data and render text/icon/lag once. OnUpdate
+  -- then animates the fill from this state without touching C_Spell.
+  local function StampBar(cb, name, tex, startMs, endMs, spellID, isChannel, delayMs, isTradeskill)
+    cb.startTime = startMs
+    cb.endTime = endMs
+    cb.isChannel = isChannel
+    cb.spellID = spellID
+    cb.activeName = name
+    cb.isTradeskill = isTradeskill
+    cb.delay = (delayMs or 0) / 1000
+    cb:SetAlpha(1)
+    cb.fadeout = nil
+
+    cb.bar:SetStatusBarColor(strsplit(",", C.appearance.castbar[isChannel and "channelcolor" or "castbarcolor"]))
+
+    local rank = ""
+    if spellID and GetSpellRecField then
+      rank = GetSpellRecField(spellID, "rank") or ""
+    end
+    local spellname = (cb.showname and name) and (name .. " ") or ""
+    local rankstr = (cb.showrank and rank ~= "") and string.format("|cffaaffcc[%s]|r", rank) or ""
+    cb.bar.left:SetText(spellname .. rankstr)
+
+    if tex and cb.showicon then
+      local size = cb:GetHeight()
+      cb.icon:Show()
+      cb.icon:SetHeight(size)
+      cb.icon:SetWidth(size)
+      cb.icon.texture:SetTexture(tex)
+      cb.bar:SetPoint("TOPLEFT", cb.icon, "TOPRIGHT", cb.spacing, 0)
+    else
+      cb.bar:SetPoint("TOPLEFT", cb, 0, 0)
+      cb.icon:Hide()
+    end
+
+    local duration = (endMs - startMs) / 1000
+    if cb.showlag then
+      local _, _, lag = GetNetStats()
+      cb.bar.lag:SetWidth(math.min(cb:GetWidth(), cb:GetWidth() / duration * (lag/1000)))
+      cb.bar.lag:Show()
+    else
+      cb.bar.lag:Hide()
+    end
+
+    cb.bar:SetMinMaxValues(0, duration)
+    cb.lastMax = duration
+  end
+
+  -- One-shot poll: read C_Spell for the bar's unit, stamp or clear. Called
+  -- from event handlers (cast start, target/focus change), never per-frame.
+  local function RefreshBar(cb)
+    local query = cb.unitstr ~= "" and cb.unitstr or cb.unitname
+    if not query or (cb.unitstr ~= "" and not UnitExists(cb.unitstr)) then
+      ClearBar(cb)
+      return
+    end
+    local name, _, tex, startMs, endMs, isTradeskill, _, _, spellID, _, delayMs = C_Spell.UnitCastingInfo(query)
+    local isChan
+    if not name then
+      name, _, tex, startMs, endMs, _, _, spellID = C_Spell.UnitChannelInfo(query)
+      isChan = true
+    end
+    -- Synthetic fallback for abilities the engine treats as instant-cast but
+    -- that have a meaningful wait window (e.g. Turtle WoW Steady Shot on the
+    -- ranged-swing queue). Per-unit table populated by module-side hooks.
+    if not name and pfUI.synthetic_casts and pfUI.synthetic_casts[query] then
+      local s = pfUI.synthetic_casts[query]
+      if s.endMs > GetTime() * 1000 then
+        name, tex, startMs, endMs, spellID = s.name, s.icon, s.startMs, s.endMs, s.spellID
+        isChan = nil
+      end
+    end
+    if name and startMs and endMs then
+      StampBar(cb, name, tex, startMs, endMs, spellID, isChan, delayMs, isTradeskill)
+    else
+      ClearBar(cb)
+    end
+  end
+
   local function CreateCastbar(name, parent, unitstr, unitname)
     local cb = CreateFrame("Frame", name, parent or UIParent)
 
@@ -76,238 +211,234 @@ pfUI:RegisterModule("castbar", function ()
     cb.bar.lag:SetPoint("BOTTOMRIGHT", cb.bar, "BOTTOMRIGHT", 0, 0)
     cb.bar.lag:SetTexture(1,.2,.2,.2)
 
-    -- OnUpdate script with throttle for performance optimization
+    -- Per-craft progress spark for tradeskill merge — a thin vertical line
+    -- that crosses the bar once per craft in the chain (so on a 5-stack it
+    -- moves 5x faster than the main fill). Position is updated by OnUpdate
+    -- while a merge is active; hidden otherwise.
+    cb.bar.spark = cb.bar:CreateTexture(nil, "OVERLAY")
+    cb.bar.spark:SetTexture(1, 1, 1, 0.8)
+    cb.bar.spark:SetWidth(2)
+    cb.bar.spark:SetPoint("TOP", cb.bar, "TOPLEFT", 0, 0)
+    cb.bar.spark:SetPoint("BOTTOM", cb.bar, "BOTTOMLEFT", 0, 0)
+    cb.bar.spark:Hide()
+
+    -- OnUpdate animates the bar fill and fades it out on completion. All
+    -- state transitions (cast start/stop/interrupt, channel start/stop,
+    -- pushback) come from the event handler below — we never poll C_Spell
+    -- here.
     cb:SetScript("OnUpdate", function()
-      -- Throttle for performance
       if (this.tick or 0) > GetTime() then return end
-      this.tick = GetTime() + 0.020 -- ~50 FPS for smooth castbar
+      this.tick = GetTime() + 0.020 -- ~50 FPS
 
       if this.drag and this.drag:IsShown() then
         this:SetAlpha(1)
         return
       end
 
-      if not UnitExists(this.unitstr) then
-        this:SetAlpha(0)
-      end
-
       if this.fadeout and this:GetAlpha() > 0 then
-        if this:GetAlpha() == 0 then
-          this.fadeout = nil
-        end
-
-        this:SetAlpha(this:GetAlpha()-0.05)
+        this:SetAlpha(this:GetAlpha() - 0.05)
+        if this:GetAlpha() <= 0 then this.fadeout = nil end
+        return
       end
 
-      local channel = nil
-      local query = this.unitstr ~= "" and this.unitstr or this.unitname
-      if not query then return end
+      if not this.endTime then return end
 
-      -- Check if we have a GUID-based focus (Turtle WoW native GUID)
-      local focusGuid = nil
-      if this.unitstr and string.find(this.unitstr, "^0x") then
-        focusGuid = this.unitstr
-      elseif this.unitstr and this.unitstr == "player" and UnitGUID then
-        focusGuid = UnitGUID("player")
-      elseif this.unitstr and this.unitstr ~= "player" then
-        local guid = UnitGUID(this.unitstr)
-        if guid then focusGuid = guid end
-      end
-      this.focusGuid = focusGuid
-
-      -- Try libdebuff_casts first for GUID-based units (works with Turtle GUID + Nampower events)
-      local cast, nameSubtext, text, texture, startTime, endTime
-      local castBlocked = false
-      if focusGuid and pfUI.libdebuff_casts and pfUI.libdebuff_casts[focusGuid] then
-        local castData = pfUI.libdebuff_casts[focusGuid]
-        if castData.event == "CAST" or castData.event == "FAIL" then
-          castBlocked = true
-          pfUI.libdebuff_casts[focusGuid] = nil
-        elseif (castData.event == "START" or castData.event == "CHANNEL") and castData.endTime and castData.endTime > GetTime() then
-          cast = castData.spellName
-          texture = castData.icon
-          startTime = castData.startTime * 1000
-          endTime = castData.endTime * 1000
-          -- Try to get rank from spell DB via spellID (nameSubtext is not stored in libdebuff_casts)
-          if castData.spellID and GetSpellRecField then
-            nameSubtext = GetSpellRecField(castData.spellID, "rank") or ""
-          else
-            nameSubtext = ""
-          end
-          if castData.event == "CHANNEL" then
-            channel = cast
-          end
-        end
+      -- Non-player bars: if the unit disappears (target died / detarget),
+      -- drop the bar immediately.
+      if this.unitstr ~= "" and this.unitstr ~= "player" and not UnitExists(this.unitstr) then
+        ClearBar(this)
+        return
       end
 
-      local useLibcastForPlayer = this.unitstr == "player"
-
-      -- For player: use player name to query libcast.db directly
-      if not cast and useLibcastForPlayer then
-        query = UnitName("player")
+      local now = GetTime()
+      local endSec = this.endTime / 1000
+      if now >= endSec then
+        ClearBar(this)
+        return
       end
 
-      -- Fallback: pfGetCastInfo only when no focusGuid (Nampower not available for this unit).
-      -- If we have a focusGuid, libdebuff is authoritative - don't fall back to libcast
-      -- even if no cast is active (prevents false positives e.g. spellbook clicks on CD spells).
-      if not cast and not castBlocked and not focusGuid and pfGetCastInfo then
-        cast, nameSubtext, text, texture, startTime, endTime, isTradeSkill = pfGetCastInfo(query)
+      local startSec = this.startTime / 1000
+      local max = endSec - startSec
+      local cur = this.isChannel and (endSec - now) or (now - startSec)
+      if cur > max then cur = max end
+      if cur < 0 then cur = 0 end
+
+      this.bar:SetValue(cur)
+
+      -- Per-craft spark for a tradeskill merge: position by (now - current
+      -- craft's start) / single-craft duration, clamped to [0, 1]. Snaps back
+      -- to the left edge each time StartTradeskillCraft fires for craft N+1.
+      if this.tradeskillTotal and this.tradeskillSingleMs and this.currentCraftStart then
+        local craftElapsed = now * 1000 - this.currentCraftStart
+        local p = craftElapsed / this.tradeskillSingleMs
+        if p < 0 then p = 0 elseif p > 1 then p = 1 end
+        local x = p * this.bar:GetWidth() - 1
+        this.bar.spark:ClearAllPoints()
+        this.bar.spark:SetPoint("TOP", this.bar, "TOPLEFT", x, 0)
+        this.bar.spark:SetPoint("BOTTOM", this.bar, "BOTTOMLEFT", x, 0)
       end
 
-      if not cast and not castBlocked and not focusGuid and pfGetChannelInfo then
-        channel, nameSubtext, text, texture, startTime, endTime, isTradeSkill = pfGetChannelInfo(this.unitstr or this.unitname)
-        cast = channel
-      end
-
-      if cast then
-        local duration = endTime - startTime
-        local max = duration / 1000
-        local cur = GetTime() - startTime / 1000
-
-        this:SetAlpha(1)
-
-        local spellname = this.showname and cast and cast .. " " or ""
-        local rank = this.showrank and nameSubtext and nameSubtext ~= "" and string.format("|cffaaffcc[%s]|r", nameSubtext) or ""
-
-        if this.endTime ~= endTime then
-          this.bar:SetStatusBarColor(strsplit(",", C.appearance.castbar[(channel and "channelcolor" or "castbarcolor")]))
-          this.bar.left:SetText(spellname .. rank)
-          this.fadeout = nil
-          this.endTime = endTime
-
-          -- set texture
-          if texture and this.showicon then
-            local size = this:GetHeight()
-            this.icon:Show()
-            this.icon:SetHeight(size)
-            this.icon:SetWidth(size)
-            
-            -- Override with item icon from libdebuff_casts or persistent item icon cache
-            local useTexture = texture
-            local useItemName = nil
-            if pfUI.libdebuff_casts or pfUI.libdebuff_item_icons then
-              local castGuid = nil
-              if this.unitstr and UnitExists then
-                local guid = UnitGUID(this.unitstr)
-                castGuid = guid
-              end
-              if castGuid then
-                -- First check active cast data
-                if pfUI.libdebuff_casts and pfUI.libdebuff_casts[castGuid] and pfUI.libdebuff_casts[castGuid].itemID then
-                  useTexture = pfUI.libdebuff_casts[castGuid].icon or texture
-                -- Fallback to persistent item icon cache
-                elseif pfUI.libdebuff_item_icons and pfUI.libdebuff_item_icons[castGuid] then
-                  useTexture = pfUI.libdebuff_item_icons[castGuid].icon or texture
-                  useItemName = pfUI.libdebuff_item_icons[castGuid].name
-                end
-              end
-            end
-            
-            this.icon.texture:SetTexture(useTexture)
-            this.bar:SetPoint("TOPLEFT", this.icon, "TOPRIGHT", this.spacing, 0)
-            
-            -- Override spell name with item name for item-triggered casts
-            if useItemName and this.showname then
-              this.bar.left:SetText(useItemName .. " " .. rank)
-            end
-          else
-            this.bar:SetPoint("TOPLEFT", this, 0, 0)
-            this.icon:Hide()
-          end
-
-          if this.showlag then
-            local _, _, lag = GetNetStats()
-            local width = this:GetWidth() / (duration/1000) * (lag/1000)
-            this.bar.lag:SetWidth(math.min(this:GetWidth(), width))
-          else
-            this.bar.lag:Hide()
-          end
+      if this.showtimer then
+        if (this.delay or 0) > 0 then
+          local prefix = "|cffffaaaa" .. (this.isChannel and "-" or "+") .. FormatCastbarTime(this.delay) .. " |r "
+          this.bar.right:SetText(prefix .. FormatCastbarTime(cur) .. " / " .. FormatCastbarTime(max))
+        else
+          this.bar.right:SetText(FormatCastbarTime(cur) .. " / " .. FormatCastbarTime(max))
         end
-
-        local newMax = duration / 1000
-        if this.lastMax ~= newMax then
-          this.bar:SetMinMaxValues(0, newMax)
-          this.lastMax = newMax
-        end
-
-        if channel then
-          cur = max + startTime/1000 - GetTime()
-        end
-
-        cur = cur > max and max or cur
-        cur = cur < 0 and 0 or cur
-
-        this.bar:SetValue(cur)
-
-        if this.showtimer then
-          if this.delay and this.delay > 0 then
-            local delay = "|cffffaaaa" .. (channel and "-" or "+") .. FormatCastbarTime(this.delay) .. " |r "
-            this.bar.right:SetText(delay .. FormatCastbarTime(cur) .. " / " .. FormatCastbarTime(max))
-          else
-            this.bar.right:SetText(FormatCastbarTime(cur) .. " / " .. FormatCastbarTime(max))
-          end
-        end
-
-        this.fadeout = nil
-      else
-        this.bar:SetMinMaxValues(1,100)
-        this.bar:SetValue(100)
-        this.lastMax = nil
-        this.fadeout = 1
-        this.delay = 0
-        this.itemIconApplied = nil
       end
     end)
 
-    -- register for spell delay
-    -- Prefer Nampower's SPELL_DELAYED_SELF (gives casterGuid + delayMs directly).
-    -- Fall back to vanilla SPELLCAST_DELAYED if Nampower is not available.
-    local playerarg = nil
-    local function ApplyPushback(delayMs)
-      if not delayMs or delayMs <= 0 or not this.endTime then return end
-      this.delay = (this.delay or 0) + delayMs / 1000
-      this.endTime = this.endTime + delayMs
-      local focusGuid = this.focusGuid
-      if focusGuid and pfUI.libdebuff_casts and pfUI.libdebuff_casts[focusGuid] then
-        pfUI.libdebuff_casts[focusGuid].endTime = this.endTime / 1000
+    -- Cast lifecycle events. Player bars react to vanilla SPELLCAST_*; non-
+    -- player bars also react to Nampower SPELL_*_OTHER (gated by the
+    -- NP_EnableSpell{Start,Go}Events CVars, enabled by libdebuff) plus the
+    -- retarget event. Player events also feed non-player bars for the
+    -- target=self case.
+    cb:RegisterEvent("SPELLCAST_START")
+    cb:RegisterEvent("SPELLCAST_STOP")
+    cb:RegisterEvent("SPELLCAST_FAILED")
+    cb:RegisterEvent("SPELLCAST_INTERRUPTED")
+    cb:RegisterEvent("SPELLCAST_CHANNEL_START")
+    cb:RegisterEvent("SPELLCAST_CHANNEL_STOP")
+    cb:RegisterEvent("SPELLCAST_CHANNEL_UPDATE")
+    cb:RegisterEvent("SPELL_DELAYED_SELF")
+    -- Chained same-spell recasts never run the client cast path (the 1.12
+    -- engine short-circuits at spellID == current-cast), so vanilla
+    -- SPELLCAST_START never fires for them. nampower's SPELL_START_SELF
+    -- (server-driven) is the only signal that shows them.
+    cb:RegisterEvent("SPELL_START_SELF")
+    if unitstr == "player" then
+      cb:RegisterEvent("SPELL_GO_SELF")
+    end
+    if unitstr ~= "player" and unitstr ~= "" then
+      cb:RegisterEvent("SPELL_START_OTHER")
+      cb:RegisterEvent("SPELL_FAILED_OTHER")
+      if unitstr == "target" then
+        cb:RegisterEvent("PLAYER_TARGET_CHANGED")
+      elseif unitstr == "focus" then
+        cb:RegisterEvent("PLAYER_FOCUS_CHANGED")
       end
     end
 
-    cb:RegisterEvent("SPELL_DELAYED_SELF")
-    cb:RegisterEvent(CASTBAR_EVENT_CAST_DELAY)
-    cb:RegisterEvent(CASTBAR_EVENT_CHANNEL_DELAY)
-    cb:RegisterEvent(CASTBAR_EVENT_CAST_START)
-    cb:RegisterEvent(CASTBAR_EVENT_CHANNEL_START)
     cb:SetScript("OnEvent", function()
-      if this.unitstr and not UnitIsUnit(this.unitstr, "player") then return end
+      local unit = this.unitstr
 
-      if event == "SPELL_DELAYED_SELF" then
-        -- arg1=casterGuid, arg2=delayMs (Nampower, most accurate)
-        ApplyPushback(arg2)
-
-      elseif event == CASTBAR_EVENT_CAST_DELAY then
-        -- SPELLCAST_DELAYED fallback intentionally removed - addon requires Nampower.
-        -- Cast pushback is handled by SPELL_DELAYED_SELF above.
+      if event == "PLAYER_TARGET_CHANGED" or event == "PLAYER_FOCUS_CHANGED" then
+        RefreshBar(this)
         return
+      end
 
-      elseif event == CASTBAR_EVENT_CHANNEL_DELAY then
-        -- SPELLCAST_CHANNEL_UPDATE fires when a channel is pushed back by damage.
-        -- arg1 = new remaining time in ms. Channel ends sooner = newEndTime < this.endTime.
-        if not this.endTime or not arg1 then return end
-        local newEndTime = GetTime() * 1000 + arg1
-        local diff = this.endTime - newEndTime  -- positive = time lost to pushback
-        if diff > 50 then
-          this.delay = (this.delay or 0) + diff / 1000
-          this.endTime = newEndTime
-          local focusGuid = this.focusGuid
-          if focusGuid and pfUI.libdebuff_casts and pfUI.libdebuff_casts[focusGuid] then
-            pfUI.libdebuff_casts[focusGuid].endTime = newEndTime / 1000
+      if event == "SPELL_START_OTHER" then
+        -- arg3=casterGuid. Defer one frame so ClassicAPI's UnitChannelInfo
+        -- can see the engine's +0x228 broadcast for remote-unit channels
+        -- (the cohook+packet handler runs in the same frame; the broadcast
+        -- propagates after).
+        if arg3 == UnitGUID(unit) then
+          local target = this
+          RunNextFrame(function() RefreshBar(target) end)
+        end
+        return
+      end
+
+      if event == "SPELL_FAILED_OTHER" then
+        if arg1 == UnitGUID(unit) then ClearBar(this) end
+        return
+      end
+
+      -- Vanilla SPELLCAST_* + SPELL_DELAYED_SELF fire only for the local
+      -- player. Non-player bars handle them only when their unit currently
+      -- resolves to the player (target=self / focus=self).
+      if not UnitIsUnit(unit, 'player') then return end
+
+      if event == "SPELLCAST_START" or event == "SPELLCAST_CHANNEL_START" then
+        if this.tradeskillTotal then
+          -- Mid-chain craft N+1 of N. Keep the merged bar; resync the spark
+          -- to the new craft's start and refresh the "(N)" count label.
+          StartTradeskillCraft(this)
+        else
+          RefreshBar(this)
+          if this.isTradeskill and (this.pendingTradeskillCount or 0) > 1
+              and C.castbar.player.mergetradeskill == "1" then
+            EnterTradeskillMerge(this, this.startTime, this.endTime, this.pendingTradeskillCount)
+          end
+          this.pendingTradeskillCount = nil
+        end
+      elseif event == "SPELL_START_SELF" then
+        -- Catches chained same-spell recasts (no SPELLCAST_START fires) —
+        -- including tradeskill chaining where craft 2..N reuse one spell.
+        -- Defer one frame so ClassicAPI's SMSG_SPELL_START co-hook has
+        -- stamped g_cast before we poll, regardless of co-hook order.
+        if this.tradeskillTotal then
+          StartTradeskillCraft(this)
+        else
+          local target = this
+          RunNextFrame(function()
+            -- Re-check: SPELL_START_SELF (nampower co-hook) fires before vanilla
+            -- SPELLCAST_START on the same packet, so SPELLCAST_START may have
+            -- entered merge in this same frame. Don't restamp over it.
+            if target.tradeskillTotal then
+              StartTradeskillCraft(target)
+              return
+            end
+            RefreshBar(target)
+            if target.unitstr == "player" and target.isTradeskill
+                and (target.pendingTradeskillCount or 0) > 1
+                and C.castbar.player.mergetradeskill == "1" then
+              EnterTradeskillMerge(target, target.startTime, target.endTime, target.pendingTradeskillCount)
+            end
+            target.pendingTradeskillCount = nil
+          end)
+        end
+      elseif event == "SPELLCAST_CHANNEL_STOP" then
+        -- A channel's stop can arrive after a following cast already claimed
+        -- the bar (channel->cast transition); only clear if a channel is
+        -- actually being shown, so it doesn't wipe an active cast bar.
+        if this.isChannel then ClearBar(this) end
+      elseif event == "SPELLCAST_STOP" then
+        -- During a tradeskill chain, SPELL_GO_SELF already counted this craft
+        -- and either cleared the bar (chain done) or kept it running. Only a
+        -- non-merge cast clears here.
+        if not this.tradeskillTotal then ClearBar(this) end
+      elseif event == "SPELLCAST_FAILED" or event == "SPELLCAST_INTERRUPTED" then
+        ClearBar(this)
+      elseif event == "SPELL_GO_SELF" then
+        -- arg2 = spellId. In a tradeskill merge, count each successful craft
+        -- and clear when the chain is done.
+        if this.tradeskillTotal and arg2 == this.tradeskillSpellID then
+          this.tradeskillCompleted = (this.tradeskillCompleted or 0) + 1
+          if this.tradeskillCompleted >= this.tradeskillTotal then
+            ClearBar(this)
+          else
+            UpdateTradeskillLabel(this)
           end
         end
-
-      elseif event == CASTBAR_EVENT_CAST_START or event == CASTBAR_EVENT_CHANNEL_START then
-        playerarg = true
-        this.delay = 0
+      elseif event == "SPELL_DELAYED_SELF" then
+        -- Cast pushback. nampower's event carries the delay (arg2); apply it
+        -- locally rather than re-polling, so the bar doesn't depend on
+        -- ClassicAPI's SMSG_SPELL_DELAYED co-hook having bumped g_cast before
+        -- this fires (co-hook order vs nampower is not guaranteed).
+        if not this.endTime or not arg2 then return end
+        local delayMs = tonumber(arg2) or 0
+        if delayMs > 0 then
+          this.delay = (this.delay or 0) + delayMs / 1000
+          this.endTime = this.endTime + delayMs
+          local newDuration = (this.endTime - this.startTime) / 1000
+          this.bar:SetMinMaxValues(0, newDuration)
+          this.lastMax = newDuration
+        end
+      elseif event == "SPELLCAST_CHANNEL_UPDATE" then
+        -- Channel pushback. ClassicAPI doesn't track channel delay in
+        -- g_channel, so we adjust endTime + delay locally and resize the
+        -- bar so OnUpdate animates against the new total.
+        if not this.endTime or not arg1 then return end
+        local newEndMs = GetTime() * 1000 + arg1
+        local diff = this.endTime - newEndMs
+        if diff > 50 then
+          this.delay = (this.delay or 0) + diff / 1000
+          this.endTime = newEndMs
+          local newDuration = (this.endTime - this.startTime) / 1000
+          this.bar:SetMinMaxValues(0, newDuration)
+          this.lastMax = newDuration
+        end
       end
     end)
 
@@ -350,6 +481,17 @@ pfUI:RegisterModule("castbar", function ()
     end
 
     UpdateMovable(pfUI.castbar.player)
+
+    -- Tradeskill merge: hook DoTradeSkill so the player castbar knows the
+    -- requested count before the first SPELLCAST_START fires. Always-on hook
+    -- (the config knob is read at event time so toggling takes effect on the
+    -- next craft without a /reload). DoTradeSkill is synchronous; the server
+    -- roundtrip to SPELLCAST_START gives us plenty of time after this hook.
+    hooksecurefunc("DoTradeSkill", function(index, num)
+      if pfUI.castbar.player then
+        pfUI.castbar.player.pendingTradeskillCount = tonumber(num) or 1
+      end
+    end)
   end
 
   -- [[ pfTargetCastbar ]] --

modules/feigndeath.lua

@@ -1,29 +1,10 @@
 pfUI:RegisterModule("feigndeath", function ()
-  local cache = { }
-  local scanner = libtipscan:GetScanner("feigndeath")
-  local healthbar = scanner:GetChildren()
-
-  local cache_update = CreateFrame("Frame")
-  cache_update:RegisterEvent("UNIT_HEALTH")
-  cache_update:RegisterEvent("PLAYER_TARGET_CHANGED")
-  cache_update:SetScript("OnEvent", function()
-    if event == "PLAYER_TARGET_CHANGED" and UnitIsDead("target") then
-      scanner:SetUnit("target")
-      cache[UnitName("target")] = healthbar:GetValue()
-    elseif event == "UNIT_HEALTH" and UnitIsDead(arg1) and UnitName(arg1) then
-      scanner:SetUnit(arg1)
-      cache[UnitName(arg1)] = healthbar:GetValue()
-    elseif event == "UNIT_HEALTH" and UnitName(arg1) then
-      cache[UnitName(arg1)] = nil
-    end
-  end)
-
   local oldUnitHealth = UnitHealth
-  function UnitHealth(arg)
-    if UnitIsDead(arg) and cache[UnitName(arg)] then
-      return cache[UnitName(arg)]
-    else
-      return oldUnitHealth(arg)
+  function UnitHealth(unit)
+    if UnitIsFeignDeath(unit) then
+      local hp = GetUnitField(unit, "health")
+      if hp and hp > 0 then return hp end
     end
+    return oldUnitHealth(unit)
   end
 end)

modules/gui.lua

@@ -2380,11 +2380,7 @@ pfUI:RegisterModule("gui", function ()
 
         if c == "player" then
           CreateConfig(nil, T["Player SP/Haste Display"], nil, nil, "header")
-          CreateConfig(nil, T["Haste Display"], C.unitframes[c], "display_haste", "dropdown", {
-            "0:"..T["None"],
-            "1:"..T["Haste (cast speed increase)"],
-            "2:"..T["Effective Haste (Haste * cast time reduction)"], -- Only affects mages/warlocks I believe
-          })
+          CreateConfig(nil, T["Haste Display"], C.unitframes[c], "display_haste", "checkbox")
           CreateConfig(nil, T["Haste Display Color"], C.unitframes[c], "display_haste_color", "color")
           CreateConfig(nil, T["Display Spell Power"], C.unitframes[c], "display_spellpower", "checkbox")
           CreateConfig(nil, T["Use Custom Spell Power Color (unchecked = biggest school color)"], C.unitframes[c], "display_sp_color_override", "checkbox")
@@ -2749,6 +2745,7 @@ pfUI:RegisterModule("gui", function ()
       CreateConfig(nil, T["Enable Extended Guild Information"], C.tooltip, "extguild", "checkbox")
       CreateConfig(nil, T["Always Show Health In Percent"], C.tooltip, "alwaysperc", "checkbox")
       CreateConfig(nil, T["Show Item IDs"], C.tooltip, "itemid", "checkbox")
+      CreateConfig(nil, T["Show Movement Speed"], C.tooltip, "movespeed", "checkbox")
       CreateConfig(nil, T["Custom Transparency"], C.tooltip, "alpha")
       CreateConfig(nil, T["Status Bar Texture"], C.tooltip.statusbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture)
       CreateConfig(nil, T["Compare Item Base Stats"], C.tooltip.compare, "basestats", "checkbox")
@@ -2776,6 +2773,7 @@ pfUI:RegisterModule("gui", function ()
       CreateConfig(nil, T["Left Text Y Offset"], C.castbar.player, "txtleftoffy")
       CreateConfig(nil, T["Show Lag"], C.castbar.player, "showlag", "checkbox")
       CreateConfig(nil, T["Show Rank"], C.castbar.player, "showrank", "checkbox")
+      CreateConfig(nil, T["Merge Tradeskill Casts"], C.castbar.player, "mergetradeskill", "checkbox")
       CreateConfig(nil, T["Right Text X Offset"], C.castbar.player, "txtrightoffx")
       CreateConfig(nil, T["Right Text Y Offset"], C.castbar.player, "txtrightoffy")
 
@@ -2895,10 +2893,10 @@ pfUI:RegisterModule("gui", function ()
       CreateConfig(U["nameplates"], T["Enable Debuffs"], C.nameplates, "showdebuffs", "checkbox")
       CreateConfig(U["nameplates"], T["Show Debuffs on Hostile"], C.nameplates, "showdebuffs_hostile", "checkbox")
       CreateConfig(U["nameplates"], T["Show Debuffs on Friendly"], C.nameplates, "showdebuffs_friendly", "checkbox")
+      CreateConfig(U["nameplates"], T["Only Show Your Debuffs"], C.nameplates, "owndebuffs", "checkbox")
       CreateConfig(U["nameplates"], T["Debuff Position"], C.nameplates.debuffs, "position", "dropdown", pfUI.gui.dropdowns.debuffposition)
       CreateConfig(U["nameplates"], T["Debuff Icon Offset"], C.nameplates, "debuffoffset")
       CreateConfig(U["nameplates"], T["Debuff Icon Size"], C.nameplates, "debuffsize")
-      CreateConfig(U["nameplates"], T["Estimate Debuffs"], C.nameplates, "guessdebuffs", "checkbox")
       CreateConfig(U["nameplates"], T["Show Debuff Stacks"], C.nameplates.debuffs, "showstacks", "checkbox")
       CreateConfig(U["nameplates"], T["Enable Debuff Timers"], C.nameplates, "debufftimers", "checkbox")
       CreateConfig(U["nameplates"], T["Show Timer Text"], C.nameplates, "debufftext", "checkbox")

modules/innervatecall.lua

@@ -39,11 +39,11 @@ pfUI:RegisterModule("innervatecall", function ()
       return "BATTLEGROUND"
     end
 
-    if GetNumRaidMembers() > 0 then
+    if IsInRaid() then
       return "RAID"
     end
 
-    if GetNumPartyMembers() > 0 then
+    if IsInGroup() then
       return "PARTY"
     end
 

modules/loot.lua

@@ -323,7 +323,7 @@ pfUI:RegisterModule("loot", function ()
   end
 
   function pfUI.loot:InitGroupDropDown()
-    local inRaid = UnitInRaid("player")
+    local inRaid = IsInRaid()
     if UIDROPDOWNMENU_MENU_LEVEL == 1 then
       if ( inRaid ) then
         pfUI.loot:BuildRaidMenu(UIDROPDOWNMENU_MENU_LEVEL)

modules/mapcolors.lua

@@ -50,7 +50,7 @@ pfUI:RegisterModule("mapcolors", function ()
   end
 
   local function UpdateUnitFrames(unit_button_name)
-    if GetNumRaidMembers() > 0 then
+    if IsInRaid() then
       for i=1, MAX_RAID_MEMBERS do
         local frame_name = unit_button_name.."Raid"..i
         local frame = _G[frame_name]
@@ -68,7 +68,7 @@ pfUI:RegisterModule("mapcolors", function ()
           end
         end
       end
-    elseif GetNumPartyMembers() > 0 then
+    elseif IsInGroup() then
       for i=1, MAX_PARTY_MEMBERS do
         local frame_name = unit_button_name.."Party"..i
         local frame = _G[frame_name]

modules/mouseover.lua

@@ -1,39 +1,6 @@
 pfUI:RegisterModule("mouseover", function ()
-  pfUI.uf.mouseover = CreateFrame("Frame", "pfMouseOver", UIParent)
-
-  -- Prepare a list of units that can be used via SpellTargetUnit
-  local st_units = { [1] = "player", [2] = "target", [3] = "mouseover" }
-  for i=1, MAX_PARTY_MEMBERS do table.insert(st_units, "party"..i) end
-  for i=1, MAX_RAID_MEMBERS do table.insert(st_units, "raid"..i) end
-
-  -- Try to find a valid (friendly) unitstring that can be used for
-  -- SpellTargetUnit(unit) to avoid another target switch
-  local function GetUnitString(unit)
-    for index, unitstr in pairs(st_units) do
-      if UnitIsUnit(unit, unitstr) then
-        return unitstr
-      end
-    end
-
-    return nil
-  end
-
-  -- Same as CastSpellByName but with disabled AutoSelfCast
-  local function NoSelfCast(spell, onself)
-    local cvar_selfcast = GetCVar("AutoSelfCast")
-
-    if cvar_selfcast ~= "0" then
-      SetCVar("AutoSelfCast", "0")
-      pcall(CastSpellByName, spell, onself)
-      SetCVar("AutoSelfCast", cvar_selfcast)
-    else
-      CastSpellByName(spell, onself)
-    end
-  end
-
   _G.SLASH_PFCAST1, _G.SLASH_PFCAST2 = "/pfcast", "/pfmouse"
   function SlashCmdList.PFCAST(msg)
-    local restore_target = true
     local func = pfUI.api.TryMemoizedFuncLoadstringForSpellCasts(msg)
     local unit = "mouseover"
 
@@ -50,51 +17,18 @@ pfUI:RegisterModule("mouseover", function ()
       end
     end
 
-    -- Nampower: CastSpellByName supports a second unit parameter directly.
-    -- unit is already resolved to "mouseover", "target" or "player" at this point.
-    if not func and GetNampowerVersion then
+    -- Spell-name path: Nampower's CastSpellByName takes a second unit
+    -- parameter directly, no target swap dance required.
+    if not func then
       CastSpellByName(msg, unit)
       return
     end
 
-    -- If target and mouseover are friendly units, we can't use spell target as it
-    -- would cast on the target instead of the mouseover. However, if the mouseover
-    -- is friendly and the target is not, we can try to obtain the best unitstring
-    -- for the later SpellTargetUnit() call.
-    local unitstr = not UnitCanAssist("player", "target") and UnitCanAssist("player", unit) and GetUnitString(unit)
-
-    if UnitIsUnit("target", unit) or (not func and unitstr) then
-      -- no target change required, we can either use spell target
-      -- or the unit is already our current target.
-      restore_target = false
-    else
-      -- The spelltarget can't be used here, we need to switch
-      -- and restore the target during spell cast
-      TargetUnit(unit)
-    end
-
-    if func then
-      func()
-    else
-      -- write temporary unit name
-      pfUI.uf.mouseover.unit = unit
-
-      -- cast without self cast cvar setting
-      -- to allow spells to use spelltarget
-      NoSelfCast(msg)
-
-      -- set spell target to unitstring (or selfcast)
-      if SpellIsTargeting() then SpellTargetUnit(unitstr or "player") end
-
-      -- clean up spell target in error case
-      if SpellIsTargeting() then SpellStopTargeting() end
-
-      -- remove temporary mouseover unit
-      pfUI.uf.mouseover.unit = nil
-    end
-
-    if restore_target then
-      TargetLastTarget()
-    end
+    -- Macro path: switch target so the macro's spell calls land on `unit`,
+    -- then restore.
+    local restore_target = not UnitIsUnit("target", unit)
+    if restore_target then TargetUnit(unit) end
+    func()
+    if restore_target then TargetLastTarget() end
   end
 end)

modules/nameplates.lua

@@ -3,8 +3,6 @@ pfUI:RegisterModule("nameplates", function ()
   pcall(SetCVar, "ShowVKeyCastbar", 0)
 
   -- Local function references for performance
-  local pfGetCastInfo = pfGetCastInfo    -- provided by libcast for vanilla
-  local pfGetChannelInfo = pfGetChannelInfo  -- provided by libcast for vanilla
   local GetTime = GetTime
   local UnitExists = UnitExists
   local UnitName = UnitName
@@ -65,9 +63,30 @@ pfUI:RegisterModule("nameplates", function ()
 
   local raidGuidCache = {}  -- guid -> name (rebuilt on RAID_ROSTER_UPDATE/PARTY_MEMBERS_CHANGED)
   
-  -- Helper function to safely access libdebuff cast data
+  -- Resolve a plate GUID to its cast/channel info via C_Spell. Returns a
+  -- compact struct (spellName / icon / startTime / endTime / duration /
+  -- isChannel) or nil when the unit isn't casting / the GUID can't map to a
+  -- live token.
   local function GetCastInfo(guid)
-    return pfUI.libdebuff_casts and pfUI.libdebuff_casts[guid]
+    if not guid then return nil end
+    local unit = UnitTokenFromGUID(guid)
+    if not unit then return nil end
+    local name, _, texture, startMs, endMs, _, _, _, spellID = C_Spell.UnitCastingInfo(unit)
+    local isChannel
+    if not name then
+      name, _, texture, startMs, endMs, _, _, spellID = C_Spell.UnitChannelInfo(unit)
+      isChannel = true
+    end
+    if not name or not startMs or not endMs then return nil end
+    return {
+      spellName = name,
+      spellID   = spellID,
+      icon      = texture,
+      startTime = startMs / 1000,
+      endTime   = endMs / 1000,
+      duration  = (endMs - startMs) / 1000,
+      isChannel = isChannel,
+    }
   end
   
   local guidTargetTokenCache = {}  -- guid -> "<guid>target" interned string
@@ -78,36 +97,6 @@ pfUI:RegisterModule("nameplates", function ()
   local threatMemory = {}   -- guid -> true if mob had player targeted
   local debuffSeen = {}     -- reusable table for debuff tracking (avoid GC churn)
 
-  -- PERF: Module-level IterDebuffs callback to avoid closure allocation per call
-  local _iterDebuffCount = 0
-  local function iterDebuffCallback(auraSlot, spellId, effect, texture, stacks, dtype, duration, timeleft)
-    if not texture or string.find(texture, "QuestionMark") then return end
-    _iterDebuffCount = _iterDebuffCount + 1
-    if _iterDebuffCount > 16 then return end
-    local b = debuffDisplayBuf[_iterDebuffCount]
-    b.effect, b.texture, b.stacks, b.dtype, b.duration, b.timeleft = effect, texture, stacks, dtype, duration, timeleft
-  end
-
-  -- PERF: Module-level IterDebuffs callback for PlateCacheDebuffs — same
-  -- rationale; PlateCacheDebuffs runs per visible plate per throttled tick.
-  local _pcdSelf, _pcdNow, _pcdId
-  local function iterPlateCacheDebuffsCallback(auraSlot, spellId, effect, texture, stacks, dtype, duration, timeleft)
-    if not effect or not texture then return end
-    _pcdId = _pcdId + 1
-    if _pcdId > 16 then return end
-    local stop = (timeleft and timeleft > 0) and (_pcdNow + timeleft) or nil
-    local start = stop and (stop - (duration or 0)) or _pcdNow
-    local cache = _pcdSelf.debuffcache[_pcdId] or {}
-    cache.effect = effect
-    cache.texture = texture
-    cache.stacks = stacks
-    cache.duration = duration or 0
-    cache.start = start
-    cache.stop = stop
-    cache.empty = nil
-    _pcdSelf.debuffcache[_pcdId] = cache
-  end
-
   -- PERF: visiblePlateCount maintained event-driven (NAME_PLATE_UNIT_ADDED/_REMOVED)
   local visiblePlateCount = 0
 
@@ -134,6 +123,7 @@ pfUI:RegisterModule("nameplates", function ()
     cfg.showdebuffs = C.nameplates["showdebuffs"] == "1"
     cfg.showdebuffs_hostile = C.nameplates["showdebuffs_hostile"] == "1"
     cfg.showdebuffs_friendly = C.nameplates["showdebuffs_friendly"] == "1"
+    cfg.owndebuffs = C.nameplates["owndebuffs"] == "1"
     cfg.targetzoom = C.nameplates.targetzoom == "1"
     cfg.zoomval = (tonumber(C.nameplates.targetzoomval) or 0.4) + 1
     cfg.width = tonumber(C.nameplates.width) or 120
@@ -274,15 +264,6 @@ pfUI:RegisterModule("nameplates", function ()
     return
   end
 
-  local function wipe(table)
-    if type(table) ~= "table" then
-      return
-    end
-    for k in pairs(table) do
-      table[k] = nil
-    end
-  end
-
   local function DisableObject(object)
     if not object then return end
     if not object.GetObjectType then return end
@@ -400,60 +381,6 @@ pfUI:RegisterModule("nameplates", function ()
     end
   end
 
-  local function PlateCacheDebuffs(self, unitstr, verify)
-    if not self.debuffcache then self.debuffcache = {} end
-    if not libdebuff then return end
-
-    local now = GetTime()
-
-    -- Clear existing cache slots
-    for id = 1, 16 do
-      if self.debuffcache[id] then
-        self.debuffcache[id].empty = true
-      end
-    end
-
-    -- Use IterDebuffs if Nampower available, else fall back to slot loop
-    if unitstr and libdebuff.IterDebuffs and UnitGUID then
-      _pcdSelf, _pcdNow, _pcdId = self, now, 0
-      libdebuff:IterDebuffs(unitstr, iterPlateCacheDebuffsCallback)
-    else
-      for id = 1, 16 do
-        local effect, _, texture, stacks, _, duration, timeleft
-        effect, _, texture, stacks, _, duration, timeleft = libdebuff:UnitDebuff(unitstr, id)
-        if effect and timeleft and timeleft > 0 then
-          local start = now - ( (duration or 0) - ( timeleft or 0) )
-          local stop = now + timeleft
-          self.debuffcache[id] = self.debuffcache[id] or {}
-          self.debuffcache[id].effect = effect
-          self.debuffcache[id].texture = texture
-          self.debuffcache[id].stacks = stacks
-          self.debuffcache[id].duration = duration or 0
-          self.debuffcache[id].start = start
-          self.debuffcache[id].stop = stop
-          self.debuffcache[id].empty = nil
-        end
-      end
-    end
-
-    self.verify = verify
-  end
-
-  local function PlateUnitDebuff(self, id)
-    -- break on unknown data
-    if not self.debuffcache then return end
-    if not self.debuffcache[id] then return end
-    if not self.debuffcache[id].stop then return end
-
-    -- break on timeout debuffs
-    if self.debuffcache[id].empty then return end
-    if self.debuffcache[id].stop < GetTime() then return end
-
-    -- return cached debuff
-    local c = self.debuffcache[id]
-    return c.effect, c.rank, c.texture, c.stacks, c.dtype, c.duration, (c.stop - GetTime())
-  end
-
   local function CreateDebuffIcon(plate, index)
     plate.debuffs[index] = CreateFrame("Frame", plate.platename.."Debuff"..index, plate)
     plate.debuffs[index]:Hide()
@@ -549,32 +476,9 @@ nameplates:RegisterEvent("NAME_PLATE_UNIT_ADDED")
 nameplates:RegisterEvent("NAME_PLATE_UNIT_REMOVED")
 if GetUnitField then
   nameplates:RegisterEvent("UNIT_FLAGS_GUID")
+  nameplates:RegisterEvent("UNIT_AURA_GUID")
 end
   
-  -- Cast tracking handled by libdebuff (SPELL_START/GO/FAILED events)
-  -- No local event registration needed
-
-  -- Callback from libdebuff when auras change (GUID-based, event-driven)
-  nameplates.OnAuraUpdate = function(self, guid)
-    if not guid then return end
-    
-    -- GUID is actual GUID (0xF13000...) from Nampower events
-    local plate = C_NamePlate.GetNamePlateForGUID(guid)
-    if plate and plate.nameplate then
-      -- Mark nameplate for aura update in next OnUpdate cycle
-      plate.nameplate.auraUpdate = true
-    end
-  end
-
-  -- Hook into libdebuff timer signal (fires when slotTimers written or cleared)
-  pfUI.libdebuff_on_unit_updated = pfUI.libdebuff_on_unit_updated or {}
-  table.insert(pfUI.libdebuff_on_unit_updated, function(guid)
-    local plate = C_NamePlate.GetNamePlateForGUID(guid)
-    if plate and plate.nameplate then
-      plate.nameplate.auraUpdate = true
-    end
-  end)
-
   nameplates:SetScript("OnEvent", function()
     -- Stop event handling during logout to prevent crash 132
     if event == "PLAYER_LOGOUT" then
@@ -665,10 +569,6 @@ end
         if threatMemory[guid] then threatMemory[guid] = nil end
         if guidTargetTokenCache[guid] then guidTargetTokenCache[guid] = nil end
         if combatColorCache[guid] then combatColorCache[guid] = nil end
-        local castInfo = GetCastInfo(guid)
-        if castInfo and castInfo.endTime and castInfo.endTime < GetTime() then
-          if pfUI.libdebuff_casts then pfUI.libdebuff_casts[guid] = nil end
-        end
         local plate = C_NamePlate.GetNamePlateForUnit(arg1)
         if plate and plate.nameplate and plate.nameplate.cachedGuid == guid then
           plate.nameplate.cachedGuid = nil
@@ -683,6 +583,17 @@ end
         plate.nameplate.eventcache = true
       end
 
+    elseif event == "UNIT_AURA_GUID" then
+      -- Nampower: fires when a unit's aura set changes (add/remove/modify).
+      -- arg1 = guid. Flag the matching plate so OnUpdate triggers a fresh
+      -- C_UnitAuras read on the next tick instead of waiting on the 0.5s
+      -- throttle — covers expirations, dispels, refreshes, and stack changes
+      -- in one event.
+      local plate = C_NamePlate.GetNamePlateForGUID(arg1)
+      if plate and plate.nameplate then
+        plate.nameplate.auraUpdate = true
+      end
+
     elseif event == "PLAYER_TARGET_CHANGED" then
       -- Flag target plate for update via GUID registry
       local targetGuid = UnitGUID("target")
@@ -773,8 +684,6 @@ end
     nameplate:EnableMouse(0)
     nameplate.parent = parent
     nameplate.cache = {}
-    nameplate.UnitDebuff = PlateUnitDebuff
-    nameplate.CacheDebuffs = PlateCacheDebuffs
     nameplate.original = {}
 
     -- create shortcuts for all known elements and disable them
@@ -1028,10 +937,15 @@ end
     -- name — name alone misses pool reuse between same-named units (e.g. plate
     -- held a player "Ironforge Guard" and is now reassigned to the NPC by the
     -- same name), which would leak a stale "PLAYER" hint into GetUnitInfo.
+    -- Wipe the whole cache table: the PERF gates below ("only update X when
+    -- X changed") would otherwise skip bar/color/text updates when the new
+    -- unit happens to share a cached value with the previous occupant
+    -- (e.g., both at 60% HP percentage on plate pool reuse → bar stays at
+    -- the old fill until the new mob actually changes HP).
     if plate.cache.name ~= name or plate.cache.guid ~= plate.cachedGuid then
+      table.wipe(plate.cache)
       plate.cache.name = name
       plate.cache.guid = plate.cachedGuid
-      plate.cache.player = nil
       plate.cdCache = nil  -- new unit, reset spell-keyed timer cache
       plate.name:SetText(GetNameString(name))
     end
@@ -1078,12 +992,6 @@ end
     -- remove unitstr on unit name mismatch
     if unitstr and UnitName(unitstr) ~= name then unitstr = nil end
 
-    -- use mobhealth values if addon is running
-    if (MobHealth3 or MobHealthFrame) and target and name == UnitName('target') and MobHealth_GetTargetCurHP() then
-      hp = MobHealth_GetTargetCurHP() > 0 and MobHealth_GetTargetCurHP() or hp
-      hpmax = MobHealth_GetTargetMaxHP() > 0 and MobHealth_GetTargetMaxHP() or hpmax
-    end
-
     -- always make sure to keep plate visible
     plate:Show()
 
@@ -1278,47 +1186,27 @@ end
     local isFriendly = unittype == "FRIENDLY_PLAYER" or unittype == "FRIENDLY_NPC"
     local showDebuffsForType = cfg.showdebuffs and (isFriendly and cfg.showdebuffs_friendly or (not isFriendly and cfg.showdebuffs_hostile))
     if showDebuffsForType then
-      -- PERF: Cache verify string - only allocate new string when name/level actually changes
-      if name ~= plate.cachedVerifyName or level ~= plate.cachedVerifyLevel then
-        plate.cachedVerifyName = name
-        plate.cachedVerifyLevel = level
-        plate.cachedVerify = (name or "") .. ":" .. (level or "")
-      end
-      local verify = plate.cachedVerify
-
-      -- update cached debuffs
-      if C.nameplates["guessdebuffs"] == "1" and unitstr then
-        plate:CacheDebuffs(unitstr, verify)
-      end
-
-      -- update all debuff icons
-      -- Use IterDebuffs when Nampower available to avoid blind 16-slot loop
-      -- debuffDisplayBuf is a module-level reusable buffer (no GC churn)
+      -- Pull debuffs from C_UnitAuras (HARMFUL range). owndebuffs adds the
+      -- PLAYER filter token so only auras whose caster GUID matches the local
+      -- player come through. debuffDisplayBuf is a module-level reusable
+      -- buffer (no GC churn).
       local debuffCount = 0
-      for i = 1, 16 do debuffDisplayBuf[i].effect = nil end  -- clear previous
-      if unitstr and libdebuff and libdebuff.IterDebuffs and UnitGUID then
-
-        _iterDebuffCount = 0
-        libdebuff:IterDebuffs(unitstr, iterDebuffCallback)
-        debuffCount = _iterDebuffCount
-      elseif unitstr and libdebuff then
-        for i = 1, 16 do
-          local effect, rank, texture, stacks, dtype, duration, timeleft
-          effect, rank, texture, stacks, dtype, duration, timeleft = libdebuff:UnitDebuff(unitstr, i)
-          if effect then
-            debuffCount = debuffCount + 1
-            local b = debuffDisplayBuf[debuffCount]
-            b.effect, b.texture, b.stacks, b.dtype, b.duration, b.timeleft = effect, texture, stacks, dtype, duration, timeleft
-          end
-        end
-      elseif plate.verify == verify then
-        for i = 1, 16 do
-          local effect, rank, texture, stacks, dtype, duration, timeleft = plate:UnitDebuff(i)
-          if effect then
-            debuffCount = debuffCount + 1
-            local b = debuffDisplayBuf[debuffCount]
-            b.effect, b.texture, b.stacks, b.dtype, b.duration, b.timeleft = effect, texture, stacks, dtype, duration, timeleft
-          end
+      for i = 1, 16 do debuffDisplayBuf[i].effect = nil end
+      if unitstr then
+        local filter = cfg.owndebuffs and "HARMFUL|PLAYER" or "HARMFUL"
+        local auras = C_UnitAuras.GetUnitAuras(unitstr, filter)
+        local now = GetTime()
+        for _, aura in ipairs(auras) do
+          if debuffCount >= 16 then break end
+          debuffCount = debuffCount + 1
+          local timeleft = (aura.expirationTime and aura.expirationTime > 0) and (aura.expirationTime - now) or nil
+          local b = debuffDisplayBuf[debuffCount]
+          b.effect = aura.name
+          b.texture = aura.icon
+          b.stacks = aura.applications
+          b.dtype = aura.dispelName
+          b.duration = aura.duration
+          b.timeleft = timeleft
         end
       end
       for i = 1, 16 do
@@ -1346,8 +1234,15 @@ end
           end
 
           if duration and timeleft and cfg.debufftimers then
+            -- C_UnitAuras returns the Spell.dbc base duration, which talents
+            -- can extend past — Shadow Affinity bumps SW:P from 18s to 24s,
+            -- so a fresh cast has timeleft > duration and `now + timeleft -
+            -- duration` lands in the future, which CooldownFrame_SetTimer
+            -- treats as "not yet started" (no swirl). Widen to whichever is
+            -- larger so start <= now.
+            local effDuration = duration > timeleft and duration or timeleft
             plate.cdCache = plate.cdCache or {}
-            local newStart = GetTime() + timeleft - duration
+            local newStart = GetTime() + timeleft - effDuration
             local slotCache = plate.cdCache[index]
             local cachedStart = slotCache and slotCache.effect == effect and slotCache.start
             local cd = plate.debuffs[index].cd
@@ -1361,7 +1256,7 @@ end
                 cd.cachedText = cfg.debufftext
                 cd.configCached = true
               end
-              CooldownFrame_SetTimer(cd, newStart, duration, 1)
+              CooldownFrame_SetTimer(cd, newStart, effDuration, 1)
               plate.cdCache[index] = plate.cdCache[index] or {}
               plate.cdCache[index].effect = effect
               plate.cdCache[index].start = newStart
@@ -1415,9 +1310,7 @@ end
     local isCastingNonTarget = not target and nameplate.castbar and nameplate.castbar:IsShown()
     if not isCastingNonTarget and not target and cfg.showcastbar and nameplate.cachedGuid then
       local castInfo = GetCastInfo(nameplate.cachedGuid)
-      if castInfo and castInfo.spellID and castInfo.endTime and castInfo.endTime > now then
-        isCastingNonTarget = true
-      elseif pfGetCastInfo and nameplate.castUpdate then
+      if castInfo and castInfo.endTime > now then
         isCastingNonTarget = true
       end
     end
@@ -1588,17 +1481,6 @@ end
       update = true
     end
 
-    -- PERF: scan for debuff timeouts using indexed access instead of pairs()
-    if nameplate.debuffcache then
-      for id = 1, 16 do
-        local data = nameplate.debuffcache[id]
-        if data and ( not data.stop or data.stop < now ) and not data.empty then
-          data.empty = true
-          update = true
-        end
-      end
-    end
-
     -- use timer based updates
     if not nameplate.tick or nameplate.tick < now then
       update = true
@@ -1716,94 +1598,40 @@ end
   -- Shared castbar update logic (used by both dedicated frame and central loop)
   nameplates.UpdateCastbar = function(nameplate, now)
     if not nameplate or not nameplate.castbar then return end
-    local unitstr = nameplate.cachedGuid
-    local castInfo = unitstr and GetCastInfo(unitstr)
+    local castInfo = GetCastInfo(nameplate.cachedGuid)
+    if not castInfo or castInfo.endTime < now then
+      nameplate.castbar.isShown = nil
+      nameplate.castbar.lastEndTime = nil
+      nameplate.castbar:Hide()
+      return
+    end
 
-    if castInfo and castInfo.spellID then
-      if castInfo.startTime + castInfo.duration < now then
-        wipe(castInfo)
-        nameplate.castbar:Hide()
-      elseif castInfo.event == "CAST" or castInfo.event == "FAIL" then
-        wipe(castInfo)
-        nameplate.castbar:Hide()
-      else
-        -- Only update min/max, color and icon once per cast (when endTime changes)
-        local isChannel = castInfo.event == "CHANNEL"
-        local duration = castInfo.endTime - castInfo.startTime
-        if nameplate.castbar.lastEndTime ~= castInfo.endTime then
-          nameplate.castbar.lastEndTime = castInfo.endTime
-          nameplate.castbar.lastTextTick = nil
-          -- Use relative 0..duration range (same as castbar.lua) to avoid
-          -- floating-point precision loss with large absolute timestamps
-          nameplate.castbar:SetMinMaxValues(0, duration)
-          nameplate.castbar:SetStatusBarColor(strsplit(",", C.appearance.castbar[(isChannel and "channelcolor" or "castbarcolor")]))
-          if castInfo.icon then
-            nameplate.castbar.icon.tex:SetTexture(castInfo.icon)
-            nameplate.castbar.icon.tex:SetTexCoord(.1,.9,.1,.9)
-          end
-          if cfg.spellname then
-            nameplate.castbar.spell:SetText(castInfo.spellName)
-          else
-            nameplate.castbar.spell:SetText("")
-          end
-        end
-        local barValue
-        if isChannel then
-          barValue = castInfo.endTime - now
-        else
-          barValue = now - castInfo.startTime
-        end
-        barValue = barValue < 0 and 0 or barValue
-        barValue = barValue > duration and duration or barValue
-        nameplate.castbar:SetValue(barValue)
-        SetCastbarText(nameplate.castbar, castInfo.endTime - now)
-        if not nameplate.castbar.isShown then nameplate.castbar.isShown = true; nameplate.castbar:Show() end
+    local isChannel = castInfo.isChannel
+    local duration = castInfo.duration
+    if nameplate.castbar.lastEndTime ~= castInfo.endTime then
+      nameplate.castbar.lastEndTime = castInfo.endTime
+      nameplate.castbar.lastTextTick = nil
+      -- Relative 0..duration range to avoid float precision loss with large
+      -- absolute timestamps.
+      nameplate.castbar:SetMinMaxValues(0, duration)
+      nameplate.castbar:SetStatusBarColor(strsplit(",", C.appearance.castbar[(isChannel and "channelcolor" or "castbarcolor")]))
+      if castInfo.icon then
+        nameplate.castbar.icon.tex:SetTexture(castInfo.icon)
+        nameplate.castbar.icon.tex:SetTexCoord(.1,.9,.1,.9)
       end
-    else
-      -- libcast fallback (vanilla without Nampower)
-      if unitstr and pfGetCastInfo then
-        local cast, _, _, texture, startTime, endTime = pfGetCastInfo(unitstr)
-        local channel
-        if not cast then
-          channel, _, _, texture, startTime, endTime = pfGetChannelInfo(unitstr)
-        end
-        if cast or channel then
-          local effect = cast or channel
-          local duration = endTime - startTime
-          local max = duration / 1000
-          local cur = now - startTime / 1000
-          if channel then cur = max + startTime / 1000 - now end
-          if cur < 0 then cur = 0 end
-          if cur > max then cur = max end
-          if nameplate.castbar.lastEndTime ~= endTime then
-            nameplate.castbar.lastEndTime = endTime
-            nameplate.castbar.lastTextTick = nil
-            nameplate.castbar:SetMinMaxValues(0, max)
-            nameplate.castbar:SetStatusBarColor(strsplit(",", C.appearance.castbar[(channel and "channelcolor" or "castbarcolor")]))
-            if texture then
-              nameplate.castbar.icon.tex:SetTexture(texture)
-              nameplate.castbar.icon.tex:SetTexCoord(.1, .9, .1, .9)
-            end
-            if cfg.spellname then
-              nameplate.castbar.spell:SetText(effect)
-            else
-              nameplate.castbar.spell:SetText("")
-            end
-          end
-          nameplate.castbar:SetValue(cur)
-          SetCastbarText(nameplate.castbar, channel and cur or (max - cur))
-          if not nameplate.castbar.isShown then nameplate.castbar.isShown = true; nameplate.castbar:Show() end
-        else
-          nameplate.castbar.isShown = nil
-          nameplate.castbar.lastEndTime = nil
-          nameplate.castbar:Hide()
-        end
+      if cfg.spellname then
+        nameplate.castbar.spell:SetText(castInfo.spellName)
       else
-        nameplate.castbar.isShown = nil
-        nameplate.castbar.lastEndTime = nil
-        nameplate.castbar:Hide()
+        nameplate.castbar.spell:SetText("")
       end
     end
+
+    local barValue = isChannel and (castInfo.endTime - now) or (now - castInfo.startTime)
+    if barValue < 0 then barValue = 0 end
+    if barValue > duration then barValue = duration end
+    nameplate.castbar:SetValue(barValue)
+    SetCastbarText(nameplate.castbar, castInfo.endTime - now)
+    if not nameplate.castbar.isShown then nameplate.castbar.isShown = true; nameplate.castbar:Show() end
   end
 
   -- Dedicated frame that updates ONLY the target plate castbar.

modules/player.lua

@@ -38,38 +38,6 @@ pfUI:RegisterModule("player", function ()
   playerFrame.myclass = myclass
   playerFrame.isSpellCaster = myclass ~= "WARRIOR" and myclass ~= "ROGUE" and myclass ~= "HUNTER"
 
-  -- Compute class-based casting speed modifier and cache on the frame.
-  -- This is re-evaluated on LEARNED_SPELL_IN_TAB (with 1s delay) so talent changes are handled.
-  -- Not sure if there are any other effects that give % cast reduction time
-  local function UpdatePlayerModCastingTime()
-    playerFrame.modCastingTime = 1
-    if myclass == "MAGE" then
-      local _, _, _, _, acceleratedArcana = GetTalentInfo(1, 16)
-      if acceleratedArcana and acceleratedArcana > 0 then
-        playerFrame.modCastingTime = 0.95
-      end
-    elseif myclass == "WARLOCK" then
-      local _, _, _, _, rapidDeter = GetTalentInfo(1, 14)
-      if rapidDeter and rapidDeter > 0 then
-        playerFrame.modCastingTime = 1 - (rapidDeter * 0.03)
-      end
-    end
-  end
-
-  local talentFrame = CreateFrame("Frame")
-  talentFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
-  talentFrame:RegisterEvent("LEARNED_SPELL_IN_TAB")
-  talentFrame:SetScript("OnEvent", function()
-    -- Delay 1s for both PLAYER_ENTERING_WORLD and LEARNED_SPELL_IN_TAB
-    local checkAt = GetTime() + 1
-    talentFrame:SetScript("OnUpdate", function()
-      if GetTime() >= checkAt then
-        talentFrame:SetScript("OnUpdate", nil)
-        UpdatePlayerModCastingTime()
-      end
-    end)
-  end)
-
   -- Convert "r,g,b,a" config color string to a 6-char hex string, or nil if unset
   local function cfgColorToHex(colorStr)
     if not colorStr or colorStr == "" then return nil end
@@ -98,26 +66,25 @@ pfUI:RegisterModule("player", function ()
     if not cfg then
       return
     end
-    local hasteMode = cfg.display_haste  -- "0"=none, "1"=modCastSpeed, "2"=modCastSpeed*modCastingTime
+    -- display_haste: "0"=hidden, "1"=show modCastSpeed (gear haste). Talent-
+    -- side cast-time reductions show up in the actual cast bar via
+    -- C_Spell.UnitCastingInfo; double-folding them into this overlay was
+    -- mixing two different concepts into one number.
+    local showHaste = cfg.display_haste == "1"
     local showSP = cfg.display_spellpower == "1"
 
     local isSpellCaster = playerFrame.isSpellCaster
-    if (hasteMode == "0" or not isSpellCaster) and not showSP then
+    if (not showHaste or not isSpellCaster) and not showSP then
       playerFrame.infoTopCenterText:SetText("")
       return
     end
 
     local haste = GetUnitField("player", "modCastSpeed")
-    local modCastingTime = playerFrame.modCastingTime or 1
     local text = ""
 
-    if isSpellCaster and haste then
+    if showHaste and isSpellCaster and haste then
       local hasteHex = cfgColorToHex(cfg.display_haste_color) or "FFFFFF"
-      if hasteMode == "1" then
-        text = string.format("|cff%s%.1f%%|r", hasteHex, (1 / haste - 1) * 100)
-      elseif hasteMode == "2" then
-        text = string.format("|cff%s%.1f%%|r", hasteHex, (1 / (haste * modCastingTime) - 1) * 100)
-      end
+      text = string.format("|cff%s%.1f%%|r", hasteHex, (1 / haste - 1) * 100)
     end
 
     if showSP and isSpellCaster then
@@ -151,21 +118,21 @@ pfUI:RegisterModule("player", function ()
   end
 
   -- Add throttle to player frame OnUpdate
+  -- Throttle the unit frame's existing OnUpdate to ~20 FPS so the per-frame
+  -- work stays cheap.
   if pfUI.uf.player:GetScript("OnUpdate") then
     local originalOnUpdate = pfUI.uf.player:GetScript("OnUpdate")
     pfUI.uf.player:SetScript("OnUpdate", function()
-      if (this.throttleTick or 0) > GetTime() then
-        return
-      end
-      this.throttleTick = GetTime() + 0.05  -- Default: 20 FPS
+      if (this.throttleTick or 0) > GetTime() then return end
+      this.throttleTick = GetTime() + 0.05
       originalOnUpdate()
-      if (this.infoTextTick or 0) <= GetTime() then
-        this.infoTextTick = GetTime() + 0.25 -- Don't need to update haste/SP text as often
-        UpdateInfoText()
-      end
     end)
   end
 
+  -- Haste / spell-power overlay text — refreshes 4×/sec on its own ticker,
+  -- independent of the unit frame's OnUpdate cadence.
+  C_Timer.NewTicker(0.25, UpdateInfoText)
+
   -- Replace default's RESET_INSTANCES button with an always working one
   UnitPopupButtons["RESET_INSTANCES_FIX"] = { text = RESET_INSTANCES, dist = 0 }
   for id, text in pairs(UnitPopupMenus["SELF"]) do

modules/raid.lua

@@ -106,7 +106,7 @@ pfUI:RegisterModule("raid", function ()
     this.pendingUpdate = nil
 
     -- don't proceed without raid
-    if not UnitInRaid("player") then return end
+    if not IsInRaid() then return end
 
     -- clear all existing frames
     for i=1, maxraid do SetRaidIndex(pfUI.uf.raid[i], 0) end

modules/superwow.lua

@@ -23,6 +23,13 @@ SlashCmdList["PFDLLSTATUS"] = function()
     chat:AddMessage("  |cffff0000Nampower|r: Not detected")
   end
 
+  -- ClassicAPI
+  if CLASSIC_API_VERSION then
+    chat:AddMessage("  |cff00ff00ClassicAPI|r: v" .. CLASSIC_API_VERSION)
+  else
+    chat:AddMessage("  |cffff0000ClassicAPI|r: Not detected")
+  end
+
   -- Check if castbar exists for indicator positioning
   if pfUI.castbar and pfUI.castbar.player then
     chat:AddMessage("  |cff00ff00Castbar|r: Available for indicator anchoring")
@@ -174,102 +181,4 @@ pfUI:RegisterModule("superwow", function ()
     end
   end
 
-  -- Enhance libcast with SuperWoW data for NPCs and other players
-  -- Player casts use SPELLCAST_* events for proper pushback handling
-  local supercast = CreateFrame("Frame")
-  local playerGuid = nil
-
-  supercast:RegisterEvent("PLAYER_ENTERING_WORLD")
-  supercast:RegisterEvent("UNIT_CASTEVENT")
-  supercast:RegisterEvent("PLAYER_LOGOUT")
-  supercast:SetScript("OnEvent", function()
-    -- Handle shutdown to prevent crash 132
-    if event == "PLAYER_LOGOUT" then
-      this:UnregisterAllEvents()
-      this:SetScript("OnEvent", nil)
-      return
-    end
-
-    if event == "PLAYER_ENTERING_WORLD" then
-      -- Cache player GUID
-      if UnitExists then
-        local guid = UnitGUID("player")
-        playerGuid = guid
-      end
-      return
-    end
-
-    local guid = arg1
-    local isPlayer = guid == playerGuid
-    
-    -- For non-player units: disable combat parsing events (one-time init)
-    if not isPlayer and not supercast.init then
-      -- disable combat parsing events in superwow mode (for non-player units)
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_SELF_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_HOSTILEPLAYER_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_HOSTILEPLAYER_BUFF")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_FRIENDLYPLAYER_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_FRIENDLYPLAYER_BUFF")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_HOSTILEPLAYER_BUFFS")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_BUFFS")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_HOSTILEPLAYER_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_SELF_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PARTY_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PARTY_BUFF")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_PARTY_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_PARTY_BUFFS")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_CREATURE_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_PERIODIC_CREATURE_BUFFS")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_CREATURE_VS_CREATURE_DAMAGE")
-      libcast:UnregisterEvent("CHAT_MSG_SPELL_CREATURE_VS_CREATURE_BUFF")
-      supercast.init = true
-    end
-
-    if arg3 == "START" or arg3 == "CAST" or arg3 == "CHANNEL" then
-      local target = arg2
-      local event_type = arg3
-      local spell_id = arg4
-      local timer = arg5
-
-      local spell = C_Spell.GetSpellName(spell_id) or UNKNOWN
-      local icon = C_Spell.GetSpellTexture(spell_id) or "Interface\\Icons\\INV_Misc_QuestionMark"
-
-      -- skip on buff procs during cast
-      if event_type == "CAST" then
-        if not libcast.db[guid] or libcast.db[guid].cast ~= spell then
-          -- ignore casts without 'START' event, while there is already another cast.
-          -- those events can be for example a frost shield proc while casting frostbolt.
-          -- we want to keep the cast itself, so we simply skip those.
-          return
-        end
-      end
-
-      -- For player: store in libcast.db[playerName] so pushback tracking works
-      -- For others: store by GUID
-      local dbKey = isPlayer and UnitName("player") or guid
-      
-      -- add cast action to the database
-      if not libcast.db[dbKey] then libcast.db[dbKey] = {} end
-      libcast.db[dbKey].cast = spell
-      libcast.db[dbKey].rank = nil
-      libcast.db[dbKey].start = GetTime()
-      libcast.db[dbKey].casttime = timer or 0
-      libcast.db[dbKey].icon = icon
-      libcast.db[dbKey].channel = event_type == "CHANNEL" or false
-    elseif arg3 == "FAIL" then
-      -- For player: use playerName, for others: use GUID
-      local dbKey = isPlayer and UnitName("player") or guid
-      
-      -- delete all cast entries
-      if libcast.db[dbKey] then
-        libcast.db[dbKey].cast = nil
-        libcast.db[dbKey].rank = nil
-        libcast.db[dbKey].start = nil
-        libcast.db[dbKey].casttime = nil
-        libcast.db[dbKey].icon = nil
-        libcast.db[dbKey].channel = nil
-      end
-    end
-  end)
 end)

modules/swingtimer.lua

@@ -10,6 +10,11 @@ pfUI:RegisterModule("swingtimer", function ()
   local ON_SWING_QUEUED       = 0
   local ON_SWING_QUEUE_POPPED = 1
 
+  -- Spell.dbc bits used to mirror server-side swing-reset rules.
+  local FLAG_AUTOATTACK  = tonumber("0x08",   16)  -- SPELL_INTERRUPT_FLAG_AUTOATTACK
+  local ATTR_KEEP_SWINGS = tonumber("0x20000", 16) -- SPELL_ATTR_EX2_NOT_RESET_AUTO_ACTIONS
+  local ATTR_ON_NEXT_SWING = tonumber("0x04", 16)  -- SPELL_ATTR_ON_NEXT_SWING
+
   -- Consolidate state into a table to avoid Lua 5.0 upvalue limit (32 max)
   local S = {
     mhTimer = 0, mhTimerMax = 1,
@@ -32,51 +37,26 @@ pfUI:RegisterModule("swingtimer", function ()
     onSwingCache = {},
   }
 
-  -- Ranged spell IDs
-  local RANGED_SPELLIDS = {
-    [75]   = true,  -- Auto Shot (Hunter)
-    [2764] = true,  -- Throw (Warrior/Rogue)
-  }
+  -- Wand "Shoot" runs on the ranged bar but is INDEPENDENT of the melee
+  -- swing clock — casters melee-weave between mainhand swings and wand
+  -- fires, both timers tick concurrently. Every other ranged-auto-attack
+  -- (Hunter Auto Shot, any future auto-repeat ranged spell) replaces MH.
+  local WAND_SHOOT_SPELLID = 5019
+  local THROW_SPELLID      = 2764  -- one-shot ranged, not auto-repeat
 
-  -- Spells that DELAY the swing timer by their cast duration but do NOT reset it.
-  -- Slam: vanilla behavior on Turtle WoW - delays swing, does not reset.
-  -- Hammer of Wrath: Turtle WoW changed behavior - does not reset swing timer.
-  local swingDelaySpells = {
-    [1464] = true, [8820] = true, [11604] = true, [11605] = true,  -- Slam R1-R4
-    [24275] = true, [24274] = true, [24239] = true,                -- Hammer of Wrath R1-R3
-  }
-
-  -- SPELL_ATTR_ON_NEXT_SWING (bit 2, value 4): spell replaces next auto-attack swing.
+  -- ATTR_ON_NEXT_SWING: spell replaces next auto-attack swing.
   -- Covers Raptor Strike, Maul, Mongoose Bite, Holy Strike, etc. automatically.
-  local ATTR_ON_NEXT_SWING = 4
   local function IsOnSwingSpell(spellId)
     if S.onSwingCache[spellId] ~= nil then return S.onSwingCache[spellId] end
-    local rec = GetSpellRec(spellId)
-    local result = rec and bit.band(rec.attributes, ATTR_ON_NEXT_SWING) ~= 0 or false
+    local attr = GetSpellRecField(spellId, "attributes") or 0
+    local result = bit.band(attr, ATTR_ON_NEXT_SWING) ~= 0
     S.onSwingCache[spellId] = result
     return result
   end
 
-  -- Heroic Strike spell IDs (all ranks)
-  local hsSpellIDs = {
-    [78] = true, [284] = true, [285] = true, [1608] = true,
-    [11564] = true, [11565] = true, [11566] = true, [11567] = true,
-  }
-
-  -- Cleave spell IDs (all ranks)
-  local cleaveSpellIDs = {
-    [845] = true, [7369] = true, [11608] = true, [11609] = true,
-    [20569] = true,
-    }
-
-  -- Maul spell IDs (all ranks 1 to 7)
-    local maulSpellIDs  = {
-        [6807] = true,
-        [6808] = true,
-        [6809] = true,
-        [8972] = true,
-     [9745] = true, [9880] = true, [9881] = true,
-    }
+  -- HS / Cleave / Maul are detected dynamically via IsOnSwingSpell (the
+  -- SPELL_ATTR_ON_NEXT_SWING bit) + name comparison against the rank-1
+  -- canonical names cached below — no per-rank ID maintenance.
 
   -- Read config
   local sw_width     = tonumber(C.unitframes.swingtimerwidth) or 200
@@ -355,14 +335,17 @@ pfUI:RegisterModule("swingtimer", function ()
     pfUI.swingtimer:Show()
   end
 
-  -- Reset ranged countdown
-  local function ResetRanged()
+  -- Reset ranged countdown. replaceMH=true (Hunter Auto Shot, Throw) stops
+  -- the melee swing clock while ranged ticks; replaceMH=false (wand Shoot)
+  -- leaves it running for melee weaving.
+  local function ResetRanged(replaceMH)
     if not sw_showranged then return end
     UpdateWeaponSpeeds()
     if S.raSpeed <= 0 then return end
-    -- Ranged replaces MH bar
-    S.mhActive = false
-    pfUI.swingtimer.mainhand:Hide()
+    if replaceMH then
+      S.mhActive = false
+      pfUI.swingtimer.mainhand:Hide()
+    end
     S.raTimerMax = S.raSpeed
     S.raTimer    = S.raSpeed
     S.raActive   = true
@@ -406,11 +389,35 @@ pfUI:RegisterModule("swingtimer", function ()
     pfUI.swingtimer:Hide()
   end
 
-  -- HS/Cleave helpers. Canonical rank-1 spellIDs resolve to the localized
-  -- spell name once, so the per-slot comparison is locale-independent without
-  -- per-rank hardcoding (every rank of Heroic Strike returns the same name).
-  local HS_NAME = C_Spell.GetSpellName(78)       -- Heroic Strike (Rank 1)
-  local CLEAVE_NAME = C_Spell.GetSpellName(845)  -- Cleave (Rank 1)
+  -- HS/Cleave/Maul helpers. Canonical rank-1 spellIDs resolve to the
+  -- localized spell name once, so per-spell classification is rank- and
+  -- locale-independent without per-rank ID hardcoding (every rank of
+  -- Heroic Strike etc. returns the same name).
+  local HS_NAME     = C_Spell.GetSpellName(78)    -- Heroic Strike (Rank 1)
+  local CLEAVE_NAME = C_Spell.GetSpellName(845)   -- Cleave (Rank 1)
+  local MAUL_NAME   = C_Spell.GetSpellName(6807)  -- Maul (Rank 1)
+
+  -- Classify an on-next-swing spell as "hs" / "cleave" / "maul" / nil.
+  -- IsOnSwingSpell gates the family (ATTR_ON_NEXT_SWING bit 0x04) so
+  -- unrelated spells return nil cheaply.
+  local function ClassifyOnSwingSpell(spellId)
+    if not IsOnSwingSpell(spellId) then return nil end
+    local name = C_Spell.GetSpellName(spellId)
+    if name == HS_NAME then return "hs"
+    elseif name == CLEAVE_NAME then return "cleave"
+    elseif name == MAUL_NAME then return "maul"
+    end
+  end
+
+  -- Set the queue flags from a ClassifyOnSwingSpell result. nil = no-op
+  -- (preserves prior flag state when the queued spell isn't one we
+  -- color-code, matching the legacy table-lookup behavior).
+  local function SetQueuedKind(kind)
+    if not kind then return end
+    S.hsQueued     = (kind == "hs")
+    S.cleaveQueued = (kind == "cleave")
+    S.maulQueued   = (kind == "maul")
+  end
 
   local function RebuildQueueSlotCache()
     if not S.isWarrior or not sw_hsqueue or S.useSpellQueueEvent then return end
@@ -694,11 +701,17 @@ pfUI:RegisterModule("swingtimer", function ()
   local spellStartFrame = CreateFrame("Frame")
   spellStartFrame:RegisterEvent("SPELL_START_SELF")
   spellStartFrame:SetScript("OnEvent", function()
-    if arg1 and arg1 > 0 then
-      S.pendingCastSpellId = arg1
-      -- Slam (and other delay-only spells): freeze the swing timer during cast
-      -- so it pauses instead of ticking down and expiring mid-cast
-      if swingDelaySpells[arg1] and S.mhActive then
+    if not (arg1 and arg1 > 0) then return end
+    S.pendingCastSpellId = arg1
+    -- Freeze the swing timer for cast-time spells that DON'T reset auto-
+    -- attack on completion (Slam, Hammer of Wrath on Turtle, etc.) — those
+    -- let the swing resume from where it paused. Detect dynamically via the
+    -- absent AUTOATTACK interrupt flag (8); spells with that bit reset on
+    -- SPELL_GO_SELF so freezing isn't necessary. Subsumes the old hardcoded
+    -- swingDelaySpells list (no list maintenance for new Slam-style spells).
+    if S.mhActive then
+      local iflags = GetSpellRecField(arg1, "interruptFlags") or 0
+      if bit.band(iflags, FLAG_AUTOATTACK) == 0 then
         S.mhFrozenAt = GetTime()
       end
     end
@@ -718,52 +731,57 @@ pfUI:RegisterModule("swingtimer", function ()
   -- SPELL_GO hook via libdebuff
   pfUI.libdebuff_spell_go_hooks = pfUI.libdebuff_spell_go_hooks or {}
   pfUI.libdebuff_spell_go_hooks["swingtimer"] = function(spellId)
-    if RANGED_SPELLIDS[spellId] then
-      ResetRanged()
+    -- C_Spell.IsRangedAutoAttackSpell catches both Auto Shot (75) and
+    -- wand Shoot (5019) via Spell.dbc's AUTO_REPEAT attribute (covers
+    -- any future auto-repeat ranged spell automatically). Wand is the
+    -- one independent of the MH swing — everything else replaces it.
+    -- Throw isn't auto-repeat (single-shot) so it's handled explicitly.
+    if C_Spell.IsRangedAutoAttackSpell(spellId) then
+      ResetRanged(spellId ~= WAND_SHOOT_SPELLID)
       return
-    elseif swingDelaySpells[spellId] then
-      -- Swing-delay spells (Slam, Hammer of Wrath on Turtle WoW):
-      -- Delay the swing timer by cast duration, do NOT reset it.
-      if S.mhFrozenAt then
-        local castDuration = GetTime() - S.mhFrozenAt
-        S.mhTimer = S.mhTimer + castDuration
-        S.mhTimerMax = S.mhTimerMax + castDuration
-        S.mhFrozenAt = nil
-      end
-      S.pendingCastSpellId = nil
+    elseif spellId == THROW_SPELLID then
+      ResetRanged(true)
       return
-    elseif hsSpellIDs[spellId] or cleaveSpellIDs[spellId] or maulSpellIDs[spellId] or IsOnSwingSpell(spellId) then
-      S.hsQueued = false; S.cleaveQueued = false
-      S.maulQueued = false
-      ResetMH()
-    elseif cleaveSpellIDs[spellId] then
-      S.hsQueued = false; S.cleaveQueued = false
+    elseif IsOnSwingSpell(spellId) then
+      -- On-next-swing ability (HS / Cleave / Maul / Raptor Strike / etc.)
+      -- — the swing fires as the spell consumes it. Drop the queued color.
+      S.hsQueued = false; S.cleaveQueued = false; S.maulQueued = false
       ResetMH()
     else
-      -- Any spell with interruptFlags > 0 resets the swing timer
-      -- (Moonfire, Faerie Fire, Wrath, Starfire etc. - NOT Insect Swarm which has flags=0)
-      local _rec = GetSpellRec(spellId)
-      if _rec and _rec.interruptFlags and _rec.interruptFlags > 0 then
+      -- Mirror the server rule for "does this spell reset the auto-attack
+      -- swing" (Spell::IsMeleeAttackResetSpell in Turtle's core):
+      --   InterruptFlags has SPELL_INTERRUPT_FLAG_AUTOATTACK (0x08)
+      --   AND AttributesEx2 lacks NOT_RESET_AUTO_ACTIONS (0x20000).
+      -- If neither path resets and we're holding a frozen-swing-during-cast
+      -- (mhFrozenAt set by SPELL_START_SELF for non-AUTOATTACK spells), this
+      -- is a Slam-style cast — push the timer forward by the cast duration
+      -- so the bar resumes from where it paused.
+      local iflags = GetSpellRecField(spellId, "interruptFlags") or 0
+      if bit.band(iflags, FLAG_AUTOATTACK) ~= 0
+          and bit.band(GetSpellRecField(spellId, "attributesEx2") or 0, ATTR_KEEP_SWINGS) == 0 then
         if S.mhActive and S.mhSpeed > 0 then
           UpdateWeaponSpeeds()
           S.mhTimerMax = S.mhSpeed
           S.mhTimer    = S.mhSpeed
         end
+        if S.ohActive and S.ohSpeed > 0 then
+          S.ohTimerMax = S.ohSpeed
+          S.ohTimer    = S.ohSpeed
+        end
+      elseif S.mhFrozenAt then
+        local castDuration = GetTime() - S.mhFrozenAt
+        S.mhTimer = S.mhTimer + castDuration
+        S.mhTimerMax = S.mhTimerMax + castDuration
+        S.mhFrozenAt = nil
       end
     end
     S.pendingCastSpellId = nil
   end
 
-  -- SPELL_CAST_EVENT hook: HS/Cleave queue tracking
+  -- SPELL_CAST_EVENT hook: HS/Cleave/Maul queue tracking
   pfUI.libdebuff_spell_cast_hooks = pfUI.libdebuff_spell_cast_hooks or {}
   pfUI.libdebuff_spell_cast_hooks["swingtimer"] = function(success, spellId)
-    if hsSpellIDs[spellId] then
-      S.hsQueued = true; S.cleaveQueued = false; S.maulQueued = false
-    elseif cleaveSpellIDs[spellId] then
-      S.cleaveQueued = true; S.hsQueued = false; S.maulQueued = false
-    elseif maulSpellIDs[spellId] then
-      S.maulQueued = true; S.hsQueued = false; S.cleaveQueued = false
-    end
+    SetQueuedKind(ClassifyOnSwingSpell(spellId))
   end
 
 
@@ -847,13 +865,7 @@ pfUI:RegisterModule("swingtimer", function ()
       local spellId   = arg2 or 0
       if eventCode == ON_SWING_QUEUED then
         S.useSpellQueueEvent = true
-        if hsSpellIDs[spellId] then
-          S.hsQueued = true; S.cleaveQueued = false; S.maulQueued = false
-        elseif cleaveSpellIDs[spellId] then
-          S.cleaveQueued = true; S.hsQueued = false; S.maulQueued = false
-        elseif maulSpellIDs[spellId] then
-          S.maulQueued = true; S.hsQueued = false; S.cleaveQueued = false
-        end
+        SetQueuedKind(ClassifyOnSwingSpell(spellId))
       elseif eventCode == ON_SWING_QUEUE_POPPED then
         S.hsQueued = false; S.cleaveQueued = false; S.maulQueued = false
       end

modules/thirdparty-vanilla.lua

@@ -1182,7 +1182,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
       -- use pfUI frames to draw healComm predictions
       local pfHookHealCommSendAddonMessage = HealComm.SendAddonMessage
       function HealComm.SendAddonMessage(this, msg)
-        if not UnitInRaid("player") and GetNumPartyMembers() < 1 then
+        if not IsInGroup() then
           libpredict:ParseChatMessage(UnitName("player"), msg, "HealComm")
         end
         pfHookHealCommSendAddonMessage(this, msg)

modules/tooltip.lua

@@ -146,14 +146,6 @@ pfUI:RegisterModule("tooltip", function ()
       rhp, rhpmax = hp, hpmax
     elseif pfUI.libhealth and pfUI.libhealth.enabled then
       rhp, rhpmax, estimated = pfUI.libhealth:GetUnitHealthByName(this.name, this.level, tonumber(hp), tonumber(hpmax))
-    elseif MobHealthFrame then
-      local index = (this.name or "") .. ":" .. (this.level or "")
-      local ppp = MobHealth_PPP(index)
-      if perc and ppp and ppp > 0 and not UnitIsUnit("mouseover", "pet") then
-        rhp = round(hp * ppp)
-        rhpmax = round(100 * ppp)
-        estimated = true
-      end
     end
 
     if C.tooltip.alwaysperc == "0" and ( estimated or hpmax > 100 or round(hpmax/100*hp) ~= hp ) then
@@ -241,6 +233,14 @@ pfUI:RegisterModule("tooltip", function ()
         end
       end
 
+      if C.tooltip.movespeed == "1" then
+        local currentSpeed = GetUnitSpeed(unit)
+        if currentSpeed and currentSpeed > 0 then
+          local pct = floor(currentSpeed / 7 * 100 + 0.5)
+          GameTooltip:AddLine(T["Speed"] .. ": " .. pct .. "%", 0.7, 0.7, 1)
+        end
+      end
+
       if hp and hpm then
         if hp >= 1000 then hp = round(hp / 1000, 1) .. "k" end
         if hpm >= 1000 then hpm = round(hpm / 1000, 1) .. "k" end

modules/turtle-wow.lua

@@ -47,7 +47,7 @@ pfUI:RegisterModule("turtle-wow", function ()
     -- Check if pfUI is handling group or raid for the current situation
     local function pfUIHandlesGroupOrRaid()
       local disabled = C["disabled"] or {}
-      if GetNumRaidMembers() > 0 then
+      if IsInRaid() then
         if not C.unitframes.raid then return false end
         -- Hide Turtle frames if: pfUI raid module is active, OR player disabled visibility
         if disabled["raid"] == "1" then
@@ -312,42 +312,41 @@ pfUI:RegisterModule("turtle-wow", function ()
     end
   end)
 
-  -- add Trueshot recognition to to custom castbars.
-  if not libcast.customcast["steadyshot"] then
-    -- add trueshot to pfUI's custom casts
-    local player = UnitName("player")
+  -- Synthetic Steady Shot cast bar. The engine treats Steady Shot as
+  -- instant, but the arrow doesn't actually fire until the next ranged
+  -- swing (~1.4s baseline). Drive a synthetic entry off Nampower's
+  -- SPELL_QUEUE_EVENT so hunters see a tickdown matching the swing wait.
+  -- castbar.lua reads pfUI.synthetic_casts[unit] as a fallback when
+  -- C_Spell.UnitCastingInfo returns nil.
+  pfUI_locale["enUS"]["customcast"]["TRUESHOT"] = "Steady Shot"
+  pfUI_locale["zhCN"]["customcast"]["TRUESHOT"] = "稳固射击"
+  pfUI.synthetic_casts = pfUI.synthetic_casts or {}
 
-    -- add locales
-    pfUI_locale["enUS"]["customcast"]["TRUESHOT"] = "Steady Shot"
-    pfUI_locale["zhCN"]["customcast"]["TRUESHOT"] = "稳固射击"
-    local trueshot = L["customcast"]["TRUESHOT"] or ""
+  local steadyShotName = L["customcast"]["TRUESHOT"]
+  local STEADY_SHOT_ICON = "Interface\\Icons\\Ability_hunter_steadyshot"
+  local STEADY_SHOT_DURATION_MS = 1400  -- not haste-scaled; close enough for the visual cue
+  local ON_SWING_QUEUED, ON_SWING_QUEUE_POPPED = 0, 1
 
-    libcast.customcast[strlower(trueshot)] = function(begin, duration)
-      if begin then
-        -- cast time is 1sec, however it takes 1.4sec to fire in average
-        local duration = libcast.ApplyShotHaste(duration or 1400)
-
-        local _,_, lag = GetNetStats()
-        local start = GetTime() + lag/1000
-
-        -- add cast action to the database
-        libcast.db[player].cast = trueshot
-        libcast.db[player].rank = lastrank
-        libcast.db[player].start = start
-        libcast.db[player].casttime = duration
-        libcast.db[player].icon = "Interface\\Icons\\Ability_hunter_steadyshot"
-        libcast.db[player].channel = nil
-      else
-        -- remove cast action to the database
-        libcast.db[player].cast = nil
-        libcast.db[player].rank = nil
-        libcast.db[player].start = nil
-        libcast.db[player].casttime = nil
-        libcast.db[player].icon = nil
-        libcast.db[player].channel = nil
-      end
+  local steadyShot = CreateFrame("Frame")
+  steadyShot:RegisterEvent("SPELL_QUEUE_EVENT")
+  steadyShot:SetScript("OnEvent", function()
+    if event ~= "SPELL_QUEUE_EVENT" then return end
+    local eventCode, spellId = arg1, arg2
+    if eventCode ~= ON_SWING_QUEUED and eventCode ~= ON_SWING_QUEUE_POPPED then return end
+    if C_Spell.GetSpellName(spellId) ~= steadyShotName then return end
+    if eventCode == ON_SWING_QUEUED then
+      local now = GetTime() * 1000
+      pfUI.synthetic_casts["player"] = {
+        name    = steadyShotName,
+        icon    = STEADY_SHOT_ICON,
+        startMs = now,
+        endMs   = now + STEADY_SHOT_DURATION_MS,
+        spellID = spellId,
+      }
+    else
+      pfUI.synthetic_casts["player"] = nil
     end
-  end
+  end)
 
   -- add skin to twow's talent inspect frame
   if pfUI.skin["Inspect"] and pfUI_config["disabled"]["skin_Inspect"] ~= "1" then

modules/xpbar.lua

@@ -1,18 +1,31 @@
 pfUI:RegisterModule("xpbar", function ()
   local rawborder, default_border = GetBorderSize()
-  local parse_faction = SanitizePattern(FACTION_STANDING_INCREASED)
 
   -- Rested-XP gain tracking constants
   local REST_WINDOW = 300    -- seconds of sliding-window samples for rate calc
-  
+
   local REST_CAP_MUL = 1.5   -- target rested cap = UnitXPMax * 1.5
   if IsTurtleWoW() then
     REST_CAP_MUL = 1.13
   end
 
+  -- Resolve the faction to display: the explicitly remembered one (last to
+  -- gain rep) if set, else the player's watched faction. Returns the same
+  -- 5-tuple GetFactionInfo's relevant slots produced.
+  local function GetRepDisplay(factionID)
+    if factionID then
+      local name, _, standingID, barMin, barMax, barValue = GetFactionInfoByID(factionID)
+      if name then return name, standingID, barMin, barMax, barValue end
+    end
+    local w = C_Reputation.GetWatchedFactionData()
+    if w then
+      return w.name, w.reaction, w.currentReactionThreshold, w.nextReactionThreshold, w.currentStanding
+    end
+  end
+
   local data = CreateFrame("Frame", "pfExperienceBarData", UIParent)
   data.rest_samples = {}
-  data:RegisterEvent("CHAT_MSG_COMBAT_FACTION_CHANGE")
+  data:RegisterEvent("FACTION_STANDING_CHANGED")
   data:RegisterEvent("PLAYER_ENTERING_WORLD")
   data:RegisterEvent("PLAYER_LEVEL_UP")
   data:RegisterEvent("UPDATE_EXHAUSTION")
@@ -35,16 +48,17 @@ pfUI:RegisterModule("xpbar", function ()
       while this.rest_samples[1] and (now - this.rest_samples[1][1]) > REST_WINDOW do
         table.remove(this.rest_samples, 1)
       end
-    elseif event == "CHAT_MSG_COMBAT_FACTION_CHANGE" then
-      local _,_, faction, amount = string.find(arg1, parse_faction)
-      this.faction = faction or this.faction
+    elseif event == "FACTION_STANDING_CHANGED" then
+      -- arg1=factionID, arg2=newStanding, arg3=repGained — no chat-string
+      -- parsing, no locale dependency.
+      this.factionID = arg1
     elseif event == "UPDATE_FACTION" then
       -- drop the auto-tracked faction when the user changes the watched one
       local watched = C_Reputation.GetWatchedFactionData()
-      local watchedName = watched and watched.name or nil
-      if watchedName ~= this.watched then
-        this.watched = watchedName
-        this.faction = nil
+      local watchedID = watched and watched.factionID or nil
+      if watchedID ~= this.watchedID then
+        this.watchedID = watchedID
+        this.factionID = nil
       end
     end
   end)
@@ -132,24 +146,21 @@ local function OnEnter(self)
     table.insert(lines, { T["XP"], "|cffffffff" .. xp .. " / " .. xpmax .. " (" .. xp_perc .. "%)" })
     table.insert(lines, { T["Remaining"], "|cffffffff" .. remaining .. " (" .. remaining_perc .. "%)" })
   elseif mode == "REP" then
-    for i=1, 99 do
-      local name, description, standingID, barMin, barMax, barValue, atWarWith, canToggleAtWar, isHeader, isCollapsed, isWatched = GetFactionInfo(i)
-      if ( isWatched and not self.faction ) or ( self.faction and name == self.faction) then
-        barMax = barMax - barMin
-        barValue = barValue - barMin
+    local name, standingID, barMin, barMax, barValue = GetRepDisplay(self.factionID)
+    if name then
+      barMax = barMax - barMin
+      barValue = barValue - barMin
 
-        local color = FACTION_BAR_COLORS[standingID]
-        if color then
-          color = rgbhex(color.r + .3, color.g + .3, color.b + .3)
-        else
-          color = rgbhex(.5, .5, .5)
-        end
-
-        table.insert(lines, { "|cff555555" .. T["Reputation"], "" })
-        table.insert(lines, { color .. name .. " (" .. GetText("FACTION_STANDING_LABEL"..standingID, gender) .. ")"})
-        table.insert(lines, { barValue .. " / " .. barMax .. " (" .. round(barValue / barMax * 100) .. "%)" })
-        break
+      local color = FACTION_BAR_COLORS[standingID]
+      if color then
+        color = rgbhex(color.r + .3, color.g + .3, color.b + .3)
+      else
+        color = rgbhex(.5, .5, .5)
       end
+
+      table.insert(lines, { "|cff555555" .. T["Reputation"], "" })
+      table.insert(lines, { color .. name .. " (" .. GetText("FACTION_STANDING_LABEL"..standingID, gender) .. ")"})
+      table.insert(lines, { barValue .. " / " .. barMax .. " (" .. round(barValue / barMax * 100) .. "%)" })
     end
   end
 
@@ -195,10 +206,10 @@ end
     -- set either experience, reputation or flex-rep handler
     local mode = self.display
     if self.display == "XPFLEX" then
-      self.faction = data.faction or nil
+      self.factionID = data.factionID or nil
       mode = UnitLevel("player") < MAX_PLAYER_LEVEL and "XP" or "REP"
     elseif self.display == "FLEX" then
-      self.faction = data.faction or nil
+      self.factionID = data.factionID or nil
       mode = "REP"
     end
 
@@ -208,7 +219,7 @@ end
     end
 
     -- skip on events of no interest
-    if mode == "XP" and ( event == "CHAT_MSG_COMBAT_FACTION_CHANGE" or event == "UPDATE_FACTION" ) then return end
+    if mode == "XP" and ( event == "FACTION_STANDING_CHANGED" or event == "UPDATE_FACTION" ) then return end
     if mode == "REP" and ( event == "PLAYER_XP_UPDATE" or event == "UPDATE_EXHAUSTION" ) then return end
 
     if mode == "XP" then
@@ -254,33 +265,31 @@ end
     elseif mode == "REP" then
       self.restedbar:Hide()
 
-      for i=1, 99 do
-        local name, description, standingID, barMin, barMax, barValue, atWarWith, canToggleAtWar, isHeader, isCollapsed, isWatched = GetFactionInfo(i)
-        if ( isWatched and not self.faction ) or ( self.faction and name == self.faction) then
-          self.enabled = true
-          self:SetAlpha(1)
+      local name, standingID, barMin, barMax, barValue = GetRepDisplay(self.factionID)
+      if name then
+        self.enabled = true
+        self:SetAlpha(1)
 
-          barMax = barMax - barMin
-          barValue = barValue - barMin
+        barMax = barMax - barMin
+        barValue = barValue - barMin
 
-          self.bar:SetMinMaxValues(0, barMax)
-          self.bar:SetValue(barValue)
+        self.bar:SetMinMaxValues(0, barMax)
+        self.bar:SetValue(barValue)
 
-          local color = FACTION_BAR_COLORS[standingID]
-          if color then
-            self.bar:SetStatusBarColor((color.r + .5) * .5, (color.g + .5) * .5, (color.b + .5) * .5, 1)
-          else
-            self.bar:SetStatusBarColor(.5,.5,.5,1)
-          end
-
-          local text = "%s: %s%% (%s)"
-          local perc = round(barValue / barMax * 100)
-          local standing = GetText("FACTION_STANDING_LABEL"..standingID, gender)
-          self.bar.text:SetText(string.format(text, name, perc, standing))
-
-          self.tick = GetTime() + self.timeout
-          return
+        local color = FACTION_BAR_COLORS[standingID]
+        if color then
+          self.bar:SetStatusBarColor((color.r + .5) * .5, (color.g + .5) * .5, (color.b + .5) * .5, 1)
+        else
+          self.bar:SetStatusBarColor(.5,.5,.5,1)
         end
+
+        local text = "%s: %s%% (%s)"
+        local perc = round(barValue / barMax * 100)
+        local standing = GetText("FACTION_STANDING_LABEL"..standingID, gender)
+        self.bar.text:SetText(string.format(text, name, perc, standing))
+
+        self.tick = GetTime() + self.timeout
+        return
       end
     end
 
@@ -361,7 +370,7 @@ end
     -- auto hide
     b:EnableMouse(true)
 
-    b:RegisterEvent("CHAT_MSG_COMBAT_FACTION_CHANGE")
+    b:RegisterEvent("FACTION_STANDING_CHANGED")
     b:RegisterEvent("UNIT_PET")
     b:RegisterEvent("UNIT_LEVEL")
     b:RegisterEvent("UNIT_PET_EXPERIENCE")

pfUI.lua

@@ -27,8 +27,8 @@ do
   -- ClassicAPI dependency check.
   -- pfUI relies pervasively on the modern C_* / SuperWoW / nameplate / focus
   -- API surface that ClassicAPI polyfills, so presence is required.
-  local PFUI_CLASSIC_API_MIN     = 10403  -- (X*10000 + Y*100 + Z)
-  local PFUI_CLASSIC_API_LATEST  = 99999999
+  local PFUI_CLASSIC_API_MIN     = 10503  -- (X*10000 + Y*100 + Z)
+  local PFUI_CLASSIC_API_LATEST  = PFUI_CLASSIC_API_MIN
   local PFUI_CLASSIC_API_WEBSITE = "https://github.com/brues-code/ClassicAPI"
   local PFUI_CLASSIC_API_LATEST_URL = PFUI_CLASSIC_API_WEBSITE .. "/releases/latest"
   local function FormatVersion(packed)

skins/blizzard/character.lua

@@ -2,25 +2,13 @@ pfUI:RegisterSkin("Character", function ()
   local rawborder, border = GetBorderSize()
   local bpad = rawborder > 1 and border - GetPerfectPixel() or GetPerfectPixel()
 
-  -- Compatibility
-  if PlayerTitleDropDown then -- tbc, wotlk
-    -- Character Tab
-    SkinDropDown(PlayerTitleDropDown)
-    PlayerTitleDropDown:SetPoint("TOP", CharacterLevelText, "BOTTOM", 0, -2)
-    PlayerTitleDropDownText:SetPoint("LEFT", PlayerTitleDropDown.backdrop, "LEFT", 6, 2)
-    SkinDropDown(PlayerStatFrameLeftDropDown)
-    SkinDropDown(PlayerStatFrameRightDropDown)
+  -- Honor Tab
+  StripTextures(HonorFrame)
+  StripTextures(ArenaFrame)
 
-    -- Honor Tab
-    StripTextures(PVPFrame)
-  else -- vanilla
-    -- Honor Tab
-    StripTextures(HonorFrame)
-
-    HonorFrameProgressBar:SetStatusBarTexture(pfUI.media["img:bar"])
-    CreateBackdrop(HonorFrameProgressBar)
-    HonorFrameProgressBar:SetHeight(24)
-  end
+  HonorFrameProgressBar:SetStatusBarTexture(pfUI.media["img:bar"])
+  CreateBackdrop(HonorFrameProgressBar)
+  HonorFrameProgressBar:SetHeight(24)
 
   local magicResTextureCords = {
     {0.21875, 0.78125, 0.25, 0.3203125},
@@ -148,22 +136,19 @@ pfUI:RegisterSkin("Character", function ()
       end
     end
 
-    HookScript(CharacterFrame, "OnShow", function()
+    hooksecurefunc("CharacterFrame_OnShow", function()
       RefreshCharacterSlots()
       RefreshPetPosition()
+    end)
 
-      if not this.hooked then
-        hooksecurefunc("PaperDollItemSlotButton_Update", function()
-          -- update only character slots!
-          if string.find(this:GetName(), "^Character.-Slot$") then
-            RefreshCharacterSlot(this)
-          end
-        end)
-        hooksecurefunc("PetTab_Update", RefreshPetPosition)
-        this.hooked = true
+    hooksecurefunc("PaperDollItemSlotButton_Update", function()
+      if this:GetParent() == PaperDollFrame then
+        RefreshCharacterSlot(this)
       end
     end)
 
+    hooksecurefunc("PetTab_Update", RefreshPetPosition)
+
     StripTextures(PaperDollFrame)
     StripTextures(CharacterAttributesFrame)
     StripTextures(CharacterResistanceFrame)