Document the CC, immunity and DR design

Records why the three identities are separate, the DBC mechanic table each
[cc:type] now follows, and which DR pools the immunity safeguard may act on.

Every vMaNGOS and nampower claim behind the preceding four commits is cited
to the source line that establishes it, so the next person to touch this can
check the premises instead of re-deriving them: the DRTYPE_ALL set is three
stun pools and nothing else, Charge and Intercept are the only triggered
stuns forced into the controlled pool, and SPELL_MISS puts the spell ID in
arg3.

Also notes the mouseover learning gap as designed behavior rather than a bug,
since the failure on the other side is permanent bad SavedVariables data.

.github/workflows/release.yml

@@ -18,6 +18,6 @@ jobs:
           fetch-depth: 0
 
       - name: Package and release to GitHub
-        uses: BigWigsMods/packager@v2
+        uses: brues-code/packager@vCAPI
         env:
           GITHUB_OAUTH: ${{ secrets.GITHUB_TOKEN }}

.luarc.json

@@ -0,0 +1,22 @@
+{
+  "runtime": {
+    "version": "Lua 5.1"
+  },
+  "diagnostics": {
+    "disable": ["deprecated"],
+    "globals": [
+      "this",
+      "event",
+      "arg",
+      "arg1",
+      "arg2",
+      "arg3",
+      "arg4",
+      "arg5",
+      "arg6",
+      "arg7",
+      "arg8",
+      "arg9"
+    ]
+  }
+}

.pkgmeta

@@ -0,0 +1,4 @@
+package-as: SuperCleveRoidMacros
+
+ignore:
+  - .luarc.json

ClassicAPI.lua

@@ -3,9 +3,17 @@
 
     ClassicAPI is a client mod (sibling to Nampower/SuperWoW) that backports the
     modern C_* API into the 1.12.1 Lua environment. It is a HARD REQUIREMENT of
-    this addon, so the wrappers below call the API directly — no fallbacks. The
-    load-time requirement check (Core.lua) uses IsAvailable() to warn when the
-    DLL is missing; users who don't want ClassicAPI should run the upstream addon.
+    this addon (ClassicAPI v1.15.8+, which scoped GetMouseButtonClicked to the
+    click dispatch; v1.15.0 added frame:RegisterUnitEvent), so the
+    wrappers below call the API directly — no fallbacks. The load-time requirement
+    check (Core.lua) uses IsAvailable() to warn when the DLL is missing and
+    HasMinimumVersion() when it's too old; users who don't want ClassicAPI should
+    run the upstream addon.
+
+    The minimum is not advisory: Utility.lua calls frame:RegisterUnitEvent at file
+    scope, so an older ClassicAPI aborts that chunk and leaves most of the addon
+    undefined. Raise the Core.lua minimum in step with any new API adopted at file
+    scope.
 
     Detection: the global CLASSIC_API_VERSION is defined once the client has
     booted, encoded as X*10000 + Y*100 + Z for a vX.Y.Z tag (untagged dev builds
@@ -35,6 +43,14 @@ function API.GetVersionNumber()
     return CLASSIC_API_VERSION or 0
 end
 
+-- Returns the loaded version as major, minor, patch (0, 0, 0 if absent).
+function API.GetVersion()
+    local v = CLASSIC_API_VERSION or 0
+    local major = math.floor(v / 10000)
+    local minor = math.floor(v / 100) - major * 100
+    return major, minor, v - math.floor(v / 100) * 100
+end
+
 -- True if the ClassicAPI client mod is loaded at all.
 function API.IsAvailable()
     return CLASSIC_API_VERSION ~= nil
@@ -52,16 +68,17 @@ end
 -- C_UnitAuras
 --------------------------------------------------------------------------------
 
--- Scan a unit's auras (indexFn = C_UnitAuras.GetBuffDataByIndex or
--- GetDebuffDataByIndex) for one matching the dispel type. Vanilla descriptors
--- hold 32 helpful / 16 harmful slots; cap as a backstop.
-local function scanDispel(indexFn, unit, dispelType, wantAny)
+-- Scan one aura range of `unit` (filter = "HELPFUL" or "HARMFUL") for an aura
+-- matching the dispel type. Uses the positional C_UnitAuras.UnitAura (added in
+-- ClassicAPI v1.12.1, below this addon's minimum) -- no table allocated per slot, with
+-- dispelName as the 4th return. The filtered index self-terminates at the end of
+-- the range (nil name); 48 is a backstop over vanilla's 32 helpful / 16 harmful slots.
+local function scanDispel(unit, filter, dispelType, wantAny)
     local i = 1
     while i <= 48 do
-        local data = indexFn(unit, i)
-        if not data then return false end
-        local dn = data.dispelName
-        if dn and dn ~= "" and (wantAny or dn == dispelType) then
+        local name, _, _, dispelName = C_UnitAuras.UnitAura(unit, i, filter)
+        if not name then return false end
+        if dispelName and dispelName ~= "" and (wantAny or dispelName == dispelType) then
             return true
         end
         i = i + 1
@@ -76,10 +93,29 @@ end
 --               false -> scan debuffs (defensive cleanse, default)
 function API.UnitHasDispelType(unit, dispelType, helpful)
     if not unit or not UnitExists(unit) then return false end
-    local indexFn = helpful and C_UnitAuras.GetBuffDataByIndex
-        or C_UnitAuras.GetDebuffDataByIndex
+    local filter = helpful and "HELPFUL" or "HARMFUL"
     local wantAny = (dispelType == nil or dispelType == "any")
-    return scanDispel(indexFn, unit, dispelType, wantAny)
+    return scanDispel(unit, filter, dispelType, wantAny)
+end
+
+-- First matching aura on `unit` by spellID, or nil. With no filter it walks the
+-- whole aura array (helpful then harmful), so it finds a debuff even when it has
+-- overflowed into an NPC's buff slots -- no 16+32 slot scan, no UnitIsPlayer
+-- gate. filter ("HELPFUL"/"HARMFUL") restricts the search. Returns the modern
+-- AuraData (spellId, name, applications, duration, expirationTime, dispelName, ...).
+function API.GetUnitAuraBySpellID(unit, spellID, filter)
+    if not unit or not spellID then return nil end
+    return C_UnitAuras.GetUnitAuraBySpellID(unit, spellID, filter)
+end
+
+-- First matching aura on `unit` by spell NAME, or nil. Same whole-array search as
+-- GetUnitAuraBySpellID; the name is case-sensitive and locale-resolved, so pass it
+-- in the client's locale (what C_Spell.GetSpellName returns). filter
+-- ("HELPFUL"/"HARMFUL") restricts the search. Prefer the by-ID variant for
+-- portability where a spellID is known.
+function API.GetAuraDataBySpellName(unit, spellName, filter)
+    if not unit or not spellName or spellName == "" then return nil end
+    return C_UnitAuras.GetAuraDataBySpellName(unit, spellName, filter)
 end
 
 --------------------------------------------------------------------------------
@@ -155,6 +191,76 @@ function API.GetItemSetInfo(setID)
     return C_Item.GetItemSetInfo(setID)
 end
 
+--------------------------------------------------------------------------------
+-- Equipment Set
+--------------------------------------------------------------------------------
+
+-- True if the saved equipment set named `name` is currently equipped -- every
+-- resolvable item in its target slot (a missing bank-stored piece doesn't
+-- disqualify, matching C_EquipmentSet.GetEquipmentSetInfo's isEquipped). Name is
+-- an exact, case-sensitive match per GetEquipmentSetID. Returns false for an
+-- unknown name or a client without the EquipmentSet API. Powers [equipset]/
+-- [noequipset]; the swap side is the reclaimed /equipset command.
+function API.IsEquipmentSetEquipped(name)
+    if not name or name == "" then return false end
+    local setID = C_EquipmentSet.GetEquipmentSetID(name)
+    if not setID then return false end
+    local _, _, _, isEquipped = C_EquipmentSet.GetEquipmentSetInfo(setID)
+    return isEquipped and true or false
+end
+
+--------------------------------------------------------------------------------
+-- Weapon Enchant
+--------------------------------------------------------------------------------
+
+-- Temporary weapon-enchant state for a slot: "mh" (main), "oh" (off), or
+-- "ranged". Returns hasEnchant, expirationMs, charges, enchantID. The enchantID
+-- comes from ClassicAPI's modern C_Item.GetWeaponEnchantInfo 12-tuple (the
+-- vanilla global omits it), so [mhenchant] can tell WHICH imbue is applied, not
+-- just that one exists. Falls back to the vanilla 6-tuple global (enchantID nil,
+-- no ranged slot) when the C_Item version is unavailable.
+function API.GetWeaponEnchant(slot)
+    local hasM, mExp, mChg, mID, hasO, oExp, oChg, oID, hasR, rExp, rChg, rID =
+        C_Item.GetWeaponEnchantInfo()
+    if slot == "oh" then
+        return hasO, oExp, oChg, oID
+    elseif slot == "ranged" then
+        return hasR, rExp, rChg, rID
+    end
+    return hasM, mExp, mChg, mID
+end
+
+-- Localized name of an item-enchant ID (poison/oil/sharpening stone/permanent),
+-- read straight from SpellItemEnchantment.dbc via ClassicAPI -- or nil for an
+-- unknown id / a client without C_Item.GetEnchantInfo. Lets [mhenchant:Name]
+-- resolve the applied enchant's name without scraping the weapon tooltip.
+function API.GetEnchantName(enchantID)
+    if not enchantID or enchantID == 0 then return nil end
+    local info = C_Item.GetEnchantInfo(enchantID)
+    return info and info.name or nil
+end
+
+--------------------------------------------------------------------------------
+-- Loss Of Control
+--------------------------------------------------------------------------------
+
+-- Locked spell-school mask from an active SCHOOL_INTERRUPT (Counterspell / Kick /
+-- Pummel / Earth Shock lockout) on the player, or 0 when not kicked. Read from
+-- C_LossOfControl, which synthesizes the lockout from the server's own
+-- SMSG_SPELL_COOLDOWN packet -- a state no debuff scan can see. Also returns the
+-- seconds remaining (nil if ClassicAPI didn't observe the applying cast).
+-- Player-only (vanilla LoC is local-only).
+function API.GetSchoolLockout()
+    local n = C_LossOfControl.GetActiveLossOfControlDataCount() or 0
+    for i = 1, n do
+        local d = C_LossOfControl.GetActiveLossOfControlData(i)
+        if d and d.locType == "SCHOOL_INTERRUPT" then
+            return d.lockoutSchool or 0, d.timeRemaining
+        end
+    end
+    return 0, nil
+end
+
 --------------------------------------------------------------------------------
 -- Spell
 --------------------------------------------------------------------------------
@@ -168,6 +274,75 @@ function API.GetSpellMechanicByID(spellID)
     return C_Spell.GetSpellMechanicByID(spellID)
 end
 
+-- Per-effect SpellMechanic ids (Spell.dbc EffectMechanic[3]) as {m1, m2, m3},
+-- or nil for an invalid spell / 0 for an effect with no mechanic. Complements
+-- GetSpellMechanicByID, which only reads the spell-level Mechanic field: vanilla
+-- stores some mechanics on an effect instead (e.g. Rake's bleed is effect-level,
+-- so GetSpellMechanicByID returns 0 but this returns {0,15,0}). Nil-guarded so an
+-- older ClassicAPI build without the function degrades gracefully.
+function API.GetSpellEffectMechanics(spellID)
+    return C_Spell.GetSpellEffectMechanics(spellID)
+end
+
+-- Flat spell-damage bonus (spell power) for a magic school, as a number.
+-- school is 1-based: 1=Physical, 2=Holy, 3=Fire, 4=Nature, 5=Frost, 6=Shadow,
+-- 7=Arcane. Reads the same client field nampower's GetSpellPower does -- exact,
+-- with gear/enchants/buffs/talents/set bonuses baked in.
+function API.GetSpellBonusDamage(school)
+    return GetSpellBonusDamage(school)
+end
+
+-- Flat healing bonus (+healing), as a number. Vanilla has no healing-done field,
+-- so ClassicAPI derives it from gear/enchant/buff MOD_HEALING_DONE plus
+-- stat-conversion talents (e.g. Spiritual Guidance) -- exact, not a holy-damage
+-- proxy.
+function API.GetSpellBonusHealing()
+    return GetSpellBonusHealing()
+end
+
+-- Spell haste for `unit` as a percentage: 0 unhasted, positive when casts are
+-- sped up, negative while slowed (Curse of Tongues). 0 for a unit that doesn't
+-- resolve. Vanilla has no haste API at all -- ClassicAPI derives this from the
+-- UNIT_MOD_CAST_SPEED descriptor field the server folds into the cast time, so
+-- it's exact and needs no nampower GetUnitField dependency.
+function API.UnitSpellHaste(unit)
+    return UnitSpellHaste(unit)
+end
+
+--------------------------------------------------------------------------------
+-- Unit Health
+--------------------------------------------------------------------------------
+
+-- Health deficit (max - current) for `unit` in one call.
+function API.UnitHealthMissing(unit)
+    return UnitHealthMissing(unit)
+end
+
+--------------------------------------------------------------------------------
+-- Unit Power
+--------------------------------------------------------------------------------
+
+-- Current power for a specific Enum.PowerType (0=Mana, 1=Rage, 2=Focus,
+-- 3=Energy, 4=Happiness), or the unit's primary power when powerType is omitted.
+-- Display-divided (rage reads 0..100).
+function API.UnitPower(unit, powerType)
+    return UnitPower(unit, powerType)
+end
+
+function API.UnitPowerMax(unit, powerType)
+    return UnitPowerMax(unit, powerType)
+end
+
+-- Power deficit (max - current) for the type / primary power, in one call.
+function API.UnitPowerMissing(unit, powerType)
+    return UnitPowerMissing(unit, powerType)
+end
+
+-- Unit's primary power type as an integer (0=Mana .. 4=Happiness).
+function API.UnitPowerType(unit)
+    return UnitPowerType(unit)
+end
+
 --------------------------------------------------------------------------------
 -- State
 --------------------------------------------------------------------------------
@@ -182,6 +357,29 @@ function API.IsSwimming()
     return IsSwimming() and true or false
 end
 
+-- True if the player is currently mounted.
+function API.IsMounted()
+    return IsMounted() and true or false
+end
+
+-- True if the player is under a WMO roof (building, cave, instance interior).
+-- Live engine geometry query, not zone-based; nil (-> false) pre-world.
+function API.IsIndoors()
+    return IsIndoors() and true or false
+end
+
+-- True if the player is outdoors (open sky / not inside a WMO interior).
+-- Exact complement of IsIndoors for a resolvable player.
+function API.IsOutdoors()
+    return IsOutdoors() and true or false
+end
+
+-- Player's stand state: 0 = standing, non-zero = sitting/sleeping/kneeling/etc.
+-- (see UnitStandState). Player-only.
+function API.GetPlayerStandState()
+    return UnitStandState("player") or 0
+end
+
 --------------------------------------------------------------------------------
 -- Cursor
 --------------------------------------------------------------------------------

ComboPointTracker.lua

@@ -15,22 +15,34 @@ CleveRoids.ComboPointTracking = CleveRoids.ComboPointTracking or {}
 -- Structure: CleveRoids_ComboDurations[spellID][comboPoints] = duration
 CleveRoids_ComboDurations = CleveRoids_ComboDurations or {}
 
--- Storage for last Rip cast (for Carnage talent mechanic)
--- Carnage talent: When Ferocious Bite procs Carnage, it refreshes Rip and Rake to their original duration
--- Detection: When combo points don't drop to 0 after FB (they stay at 1 = Carnage proc)
--- Talent Position: Tab 2 (Feral Combat), Talent 17
--- Rank 1: 10% per CP, Rank 2: 20% per CP
-CleveRoids.lastRipCast = CleveRoids.lastRipCast or {
-    duration = nil,
-    targetGUID = nil,
-    timestamp = 0
-}
+-- Family membership without hardcoded rank lists. C_Spell.GetSpellName resolves
+-- ANY spellID from the client's Spell.dbc -- every rank (so no enumeration or
+-- spellbook scan) and TWoW's custom spells alike -- so "is this spellID a Rip?"
+-- is just a name match against one seed rank. seedNameCache memoizes the seed's
+-- localized name (locale-safe: derived from the ID, not a hardcoded string; a
+-- seed absent from the DBC, e.g. a TWoW spell on a stock client, resolves to nil
+-- and the set simply never matches -- which is correct, that spell can't be cast).
+local seedNameCache = {}
+local function SeedName(seedID)
+    local n = seedNameCache[seedID]
+    if n == nil then
+        n = C_Spell.GetSpellName(seedID) or false
+        seedNameCache[seedID] = n
+    end
+    return n or nil
+end
 
-CleveRoids.lastRakeCast = CleveRoids.lastRakeCast or {
-    duration = nil,
-    targetGUID = nil,
-    timestamp = 0
-}
+-- Stand-in for a hardcoded {spellID=true,...} rank set: t[spellID] is true iff
+-- spellID is any rank of the family seeded by seedID. Same read shape as the old
+-- tables, so every membership consumer (`X and X[id]`) keeps working unchanged.
+-- Only valid for membership tests -- these are not iterable (pairs() sees empty).
+local function RankSet(seedID)
+    return setmetatable({}, { __index = function(_, spellID)
+        if type(spellID) ~= "number" then return nil end
+        local name = SeedName(seedID)
+        return (name and C_Spell.GetSpellName(spellID) == name) and true or nil
+    end })
+end
 
 -- Define spells that scale with combo points by SPELL ID and their duration formulas
 -- Duration = base + (combo_points - 1) * increment
@@ -57,10 +69,8 @@ CleveRoids.ComboScalingSpellsByID = {
     [9896] = { base = 10, increment = 2, name = "Rip" },           -- Rank 6
 }
 
--- Ferocious Bite spell IDs (for Carnage talent mechanic)
--- Carnage talent: When FB procs Carnage, refreshes Rip and Rake back to their original duration
--- Proc detection: combo points stay at 1 after FB instead of dropping to 0
--- Talent Position: Tab 2 (Feral Combat), Talent 17
+-- Ferocious Bite spell IDs. A combo-point finisher, so the cast-time combo
+-- snapshot has to know it.
 CleveRoids.FerociousBiteSpellIDs = {
     [22557] = true,  -- Rank 1
     [22568] = true,  -- Rank 2
@@ -70,33 +80,6 @@ CleveRoids.FerociousBiteSpellIDs = {
     [31018] = true,  -- Rank 6
 }
 
--- Rip spell IDs (for Carnage talent - refreshed when Carnage procs)
-CleveRoids.RipSpellIDs = {
-    [1079] = true,   -- Rank 1
-    [9492] = true,   -- Rank 2
-    [9493] = true,   -- Rank 3
-    [9752] = true,   -- Rank 4
-    [9894] = true,   -- Rank 5
-    [9896] = true,   -- Rank 6
-}
-
--- Rake spell IDs (for Carnage talent - refreshed when Carnage procs)
-CleveRoids.RakeSpellIDs = {
-    [1822] = true,   -- Rank 1
-    [1823] = true,   -- Rank 2
-    [1824] = true,   -- Rank 3
-    [9904] = true,   -- Rank 4
-}
-
--- Pounce Bleed spell IDs (for immunity detection - bleed portion of Pounce)
--- Note: Pounce (cast) TRIGGERS a separate Pounce Bleed spell with different IDs
--- Cast IDs: 9005, 9823, 9827 → Trigger Bleed IDs: 9007, 9824, 9826
-CleveRoids.PounceBleedSpellIDs = {
-    [9007] = true,   -- Rank 1 (triggered by Pounce 9005)
-    [9824] = true,   -- Rank 2 (triggered by Pounce 9823)
-    [9826] = true,   -- Rank 3 (triggered by Pounce 9827)
-}
-
 -- Combined table for all bleed spells that need immunity detection
 -- Used when checking if a cast bleed failed to apply (indicates bleed immunity)
 -- NOTE: These are the DEBUFF spell IDs (what appears on target), not cast spell IDs
@@ -132,14 +115,9 @@ CleveRoids.PounceToBleedMapping = {
 -- When Molten Blast hits, it refreshes Flame Shock duration on the target
 -- Detection: Monitor combat log for Molten Blast damage, then refresh Flame Shock
 -- =============================================================================
-CleveRoids.MoltenBlastSpellIDs = {
-    [36916] = true,  -- Rank 1
-    [36917] = true,  -- Rank 2
-    [36918] = true,  -- Rank 3
-    [36919] = true,  -- Rank 4
-    [36920] = true,  -- Rank 5
-    [36921] = true,  -- Rank 6
-}
+-- TWoW custom; seed resolves on the TWoW client (nil/never-matches on stock,
+-- where Molten Blast can't be cast anyway).
+CleveRoids.MoltenBlastSpellIDs = RankSet(36916)
 
 CleveRoids.FlameShockSpellIDs = {
     [8050] = true,   -- Rank 1
@@ -154,12 +132,7 @@ CleveRoids.FlameShockSpellIDs = {
 -- WARLOCK: Conflagrate → Immolate Duration Reduction
 -- When Conflagrate is cast, it reduces Immolate duration by 3 seconds
 -- =============================================================================
-CleveRoids.ConflagrateSpellIDs = {
-    [17962] = true,  -- Rank 1
-    [18930] = true,  -- Rank 2
-    [18931] = true,  -- Rank 3
-    [18932] = true,  -- Rank 4
-}
+CleveRoids.ConflagrateSpellIDs = RankSet(17962)
 
 CleveRoids.ImmolateSpellIDs = {
     [348] = true,    -- Rank 1
@@ -172,17 +145,6 @@ CleveRoids.ImmolateSpellIDs = {
     [25309] = true,  -- Rank 8
 }
 
--- =============================================================================
--- WARLOCK: Dark Harvest Duration Acceleration (TWoW Custom)
--- Channeled spell that accelerates DoT tick rate by 30% while channeling
--- Complex tracking: debuff expires 30% faster while Dark Harvest is active
--- =============================================================================
-CleveRoids.DarkHarvestSpellIDs = {
-    [52550] = true,  -- Rank 1
-    [52551] = true,  -- Rank 2
-    [52552] = true,  -- Rank 3
-}
-
 -- =============================================================================
 -- DRUID: Rake Debuff Cap Boss Whitelist
 -- These bosses are likely to hit the 48 debuff cap, causing Rake to get pushed off
@@ -489,7 +451,7 @@ function CleveRoids.TrackComboPointCastByID(spellID, targetGUID)
             end
         else
             -- Second, check if name-based tracking has recent data for this spell
-            local spellName = GetSpellRecField(spellID, "name")
+            local spellName = C_Spell.GetSpellName(spellID)
             if spellName then
                 -- Remove rank info for comparison
                 local baseName = CleveRoids.StripRank(spellName)
@@ -548,26 +510,6 @@ function CleveRoids.TrackComboPointCastByID(spellID, targetGUID)
     return duration
 end
 
--- API function to get last tracked combo points for a spell
-function CleveRoids.GetLastComboPointsForSpell(spellName)
-    if CleveRoids.ComboPointTracking[spellName] then
-        return CleveRoids.ComboPointTracking[spellName].combo_points
-    elseif CleveRoids.spell_tracking[spellName] then
-        return CleveRoids.spell_tracking[spellName].last_combo_points
-    end
-    return nil
-end
-
--- API function to get last calculated duration for a spell
-function CleveRoids.GetLastDurationForSpell(spellName)
-    if CleveRoids.ComboPointTracking[spellName] then
-        return CleveRoids.ComboPointTracking[spellName].duration
-    elseif CleveRoids.spell_tracking[spellName] then
-        return CleveRoids.spell_tracking[spellName].last_duration
-    end
-    return nil
-end
-
 -- Utility function to display current combo tracking info
 function CleveRoids.ShowComboTracking()
     CleveRoids.Print("=== Combo Point Tracking ===")
@@ -683,7 +625,7 @@ if _G.UseAction then
         local spellName = nil
 
         if actionType == "SPELL" and actionID then
-            spellName = GetSpellRecField(actionID, "name")
+            spellName = C_Spell.GetSpellName(actionID)
         end
 
         if currentCP and currentCP > 0 then
@@ -772,7 +714,7 @@ function Extension.OnLoad()
     Extension.RegisterEvent("SPELLCAST_FAILED", "OnSpellcastFailed")
     Extension.RegisterEvent("SPELLCAST_INTERRUPTED", "OnSpellcastInterrupted")
     Extension.RegisterEvent("PLAYER_TARGET_CHANGED", "OnTargetChanged")
-    Extension.RegisterEvent("UNIT_AURA", "OnUnitAura")
+    Extension.RegisterUnitEvent("UNIT_AURA", "OnUnitAura", "target", "player")
     Extension.RegisterEvent("PLAYER_COMBO_POINTS", "OnComboPointsChanged")
 
     -- PERFORMANCE OPTIMIZATION: Removed OnUpdate polling for combo points
@@ -792,63 +734,14 @@ function Extension.OnTargetChanged()
     CleveRoids.UpdateComboPoints()
 end
 
+-- Registered as a unit event for target and player, so arg1 is always one of
+-- those two -- no token check needed.
 function Extension.OnUnitAura()
-    if arg1 == "target" or arg1 == "player" then
-        CleveRoids.UpdateComboPoints()
-    end
+    CleveRoids.UpdateComboPoints()
 end
 
 function Extension.OnComboPointsChanged()
     CleveRoids.UpdateComboPoints()
-
-    -- CARNAGE PROC DETECTION (Cursive-style)
-    -- When Ferocious Bite is used, combo points should drop to 0
-    -- If Carnage procs, combo points will be 1 instead (the Carnage-granted combo point)
-    -- Check: After Ferocious Bite (within 0.5s), if combo points > 0, Carnage procced
-    if CleveRoids.lastFerociousBiteTime and CleveRoids.lastFerociousBiteTargetGUID then
-        local timeSinceBite = GetTime() - CleveRoids.lastFerociousBiteTime
-        if timeSinceBite < 0.5 then
-            local currentCP = CleveRoids.GetComboPoints()
-            if currentCP > 0 then
-                -- Carnage procced! Combo points didn't drop to 0 (or rose back to 1)
-                if CleveRoids.debug then
-                    DEFAULT_CHAT_FRAME:AddMessage(
-                        string.format("|cffff00ff[Carnage]|r PROC DETECTED! CP=%d after Ferocious Bite (%.2fs ago)",
-                            currentCP, timeSinceBite)
-                    )
-                end
-
-                -- Apply the Carnage refresh to Rip and Rake
-                local targetGUID = CleveRoids.lastFerociousBiteTargetGUID
-                local targetName = CleveRoids.lastFerociousBiteTargetName or "Unknown"
-                local biteSpellID = CleveRoids.lastFerociousBiteSpellID
-
-                -- Call the Carnage refresh function in Utility.lua
-                if CleveRoids.libdebuff and CleveRoids.libdebuff.ApplyCarnageRefresh then
-                    CleveRoids.libdebuff.ApplyCarnageRefresh(targetGUID, targetName, biteSpellID)
-                end
-
-                -- Clear the tracking to prevent multiple refreshes
-                CleveRoids.lastFerociousBiteTime = nil
-                CleveRoids.lastFerociousBiteTargetGUID = nil
-                CleveRoids.lastFerociousBiteTargetName = nil
-                CleveRoids.lastFerociousBiteSpellID = nil
-            end
-        else
-            -- Time window expired, clear tracking
-            if CleveRoids.lastFerociousBiteTime then
-                if CleveRoids.debug then
-                    DEFAULT_CHAT_FRAME:AddMessage(
-                        string.format("|cffff00ff[Carnage]|r No proc - time window expired (%.2fs)", timeSinceBite)
-                    )
-                end
-                CleveRoids.lastFerociousBiteTime = nil
-                CleveRoids.lastFerociousBiteTargetGUID = nil
-                CleveRoids.lastFerociousBiteTargetName = nil
-                CleveRoids.lastFerociousBiteSpellID = nil
-            end
-        end
-    end
 end
 
 -- Event handlers

Compatibility/pfUI.lua

@@ -2,9 +2,10 @@ local _G = _G or getfenv(0)
 local CleveRoids = _G.CleveRoids or {}
 
 local Extension = CleveRoids.RegisterExtension("Compatibility_pfUI")
-Extension.RegisterEvent("ADDON_LOADED", "ADDON_LOADED")
-Extension.RegisterEvent("PLAYER_LOGIN", "PLAYER_LOGIN")
 Extension.Debug = false
+-- pfUI-loaded and player-login handlers are wired via ClassicAPI's EventUtil at
+-- the bottom of the file (ContinueOnAddOnLoaded fires immediately if pfUI already
+-- loaded, so no separate "we missed pfUI's ADDON_LOADED" fallback is needed).
 
 -- Track pfUI state
 Extension.pfUILoaded = false
@@ -21,19 +22,6 @@ function Extension.DLOG(msg)
     end
 end
 
-function Extension.FocusNameHook()
-    local hook = Extension.internal.memberHooks[CleveRoids]["GetFocusName"]
-    local target = hook.original()
-
-    if pfUI and pfUI.uf and pfUI.uf.focus and pfUI.uf.focus.unitname then
-        target = pfUI.uf.focus.unitname
-    end
-
-    --Extension.DLOG(target)
-
-    return target
-end
-
 -- Check if pfUI's macrotweak module is loaded
 function Extension.IsPfUIMacrotweakLoaded()
     if not pfUI then return false end
@@ -91,334 +79,6 @@ function Extension.HandleSendChatMessageHook()
     end
 end
 
--- Helper function to check for Carnage duration override
--- Returns override duration and timeleft if found, nil otherwise
-local function GetCarnageOverride(effect)
-    if not effect or not CleveRoids.carnageDurationOverrides then
-        return nil, nil
-    end
-
-    for spellID, override in pairs(CleveRoids.carnageDurationOverrides) do
-        local spellName = GetSpellRecField(spellID, "name")
-        if spellName then
-            local baseName = CleveRoids.StripRank(spellName)
-            if baseName == effect and override.timestamp and (GetTime() - override.timestamp) < 5 then
-                local timeleft = override.duration - (GetTime() - override.timestamp)
-                if timeleft < 0 then timeleft = 0 end
-                return override.duration, timeleft
-            end
-        end
-    end
-    return nil, nil
-end
-
--- Hook pfUI's libdebuff to use our combo-aware durations
--- NOTE: pfUI 7.6+ (GetUnitField edition) handles combo durations and Carnage internally.
--- We only inject when there's a mismatch between pfUI's data and ours.
-function Extension.HookPfUILibdebuff()
-    if not pfUI or not pfUI.api or not pfUI.api.libdebuff then
-        return false
-    end
-
-    local pflib = pfUI.api.libdebuff
-
-    -- Check if pfUI 7.6+ with GetUnitField-based libdebuff is active
-    -- If so, pfUI handles combo durations and Carnage internally - we only override on mismatch
-    local hasPfUI76 = CleveRoids.hasPfUI76
-
-    -- pfUI 7.6+ handles all durations internally - no hooks needed
-    if hasPfUI76 then
-        Extension.DLOG("Skipped all libdebuff hooks (pfUI 7.6+ handles internally)")
-        return false
-    end
-
-    -- Hook GetDuration if it exists
-    -- pfUI's GetDuration signature: function(effect, rank) where effect is spell NAME
-    if pflib.GetDuration and not Extension.pfLibDebuffHooked then
-        local originalGetDuration = pflib.GetDuration
-
-        pflib.GetDuration = function(self, effect, rank)
-            local pfuiDuration = originalGetDuration(self, effect, rank)
-
-            -- Check for Carnage duration overrides (only if pfUI doesn't have it)
-            local carnageDuration = GetCarnageOverride(effect)
-            if carnageDuration then
-                -- Only override if pfUI's duration is significantly different (>1s difference)
-                if not pfuiDuration or math.abs(carnageDuration - pfuiDuration) > 1 then
-                    if Extension.Debug then
-                        DEFAULT_CHAT_FRAME:AddMessage(
-                            string.format("|cff00aaff[pfUI Duration Override]|r %s: Carnage %.1fs (pfUI: %.1fs)",
-                                effect, carnageDuration, pfuiDuration or 0)
-                        )
-                    end
-                    return carnageDuration
-                end
-            end
-
-            -- Check name-based tracking for fresh combo casts (only if pfUI returned 0 or nil)
-            if (not pfuiDuration or pfuiDuration == 0) and CleveRoids.ComboPointTracking and CleveRoids.ComboPointTracking[effect] then
-                local tracking = CleveRoids.ComboPointTracking[effect]
-                if tracking.duration and tracking.confirmed and (GetTime() - tracking.cast_time) < 0.5 then
-                    if Extension.Debug then
-                        DEFAULT_CHAT_FRAME:AddMessage(
-                            string.format("|cff00aaff[pfUI Duration Override]|r %s: Combo tracking %.1fs (pfUI: %.1fs)",
-                                effect, tracking.duration, pfuiDuration or 0)
-                        )
-                    end
-                    return tracking.duration
-                end
-            end
-
-            return pfuiDuration
-        end
-
-        Extension.pfLibDebuffHooked = true
-        Extension.DLOG("Hooked pfUI.api.libdebuff.GetDuration (mismatch-only mode)")
-    end
-
-    -- Hook AddEffect if it exists (pre-7.6 only - 7.6+ returns early above)
-    if pflib.AddEffect and not Extension.pfLibAddEffectHooked then
-        local originalAddEffect = pflib.AddEffect
-
-        pflib.AddEffect = function(self, unit, unitlevel, effect, duration, caster)
-            -- RANK CHECKING: Preserve higher rank's remaining time if lower rank was cast
-            -- NOTE: 'unit' is a unit NAME (e.g., "Expert Training Dummy"), not a unit ID
-            -- Defensive: verify libdebuff is a table, not a function
-            if caster == "player" and type(CleveRoids.libdebuff) == "table" and duration and duration > 0 then
-                -- Try to find the GUID for this unit name
-                local unitGUID = nil
-
-                -- Check if this is the current target
-                if UnitName("target") == unit then
-                    unitGUID = CleveRoids.GetGUID("target")
-                end
-
-                -- If we couldn't match to current target, check guidToName mapping
-                if not unitGUID and CleveRoids.libdebuff.guidToName then
-                    for guid, name in pairs(CleveRoids.libdebuff.guidToName) do
-                        if name == unit then
-                            unitGUID = guid
-                            break
-                        end
-                    end
-                end
-
-                -- Check if a higher rank of this spell is already active
-                if unitGUID and CleveRoids.libdebuff.objects and CleveRoids.libdebuff.objects[unitGUID] then
-                    -- Find all spell IDs that match this effect name
-                    for spellID, rec in pairs(CleveRoids.libdebuff.objects[unitGUID]) do
-                        if rec and rec.start and rec.duration then
-                            -- Get spell name for this ID
-                            local spellName = GetSpellRecField(spellID, "name")
-                            if spellName then
-                                local baseName = CleveRoids.StripRank(spellName)
-                                if baseName == effect then
-                                    -- Same spell - check if still active
-                                    local remaining = rec.duration + rec.start - GetTime()
-                                    if remaining > 0 then
-                                        -- If incoming duration > remaining time, we're trying to add more time
-                                        -- This means either a refresh or lower rank cast - preserve existing timer
-                                        if duration > remaining then
-                                            if Extension.Debug then
-                                                DEFAULT_CHAT_FRAME:AddMessage(
-                                                    string.format("|cff00aaff[pfUI Rank Preserve]|r %s: Preserving timer (%.1fs remaining vs %.1fs incoming)",
-                                                        effect, remaining, duration)
-                                                )
-                                            end
-
-                                            -- Preserve the existing timer
-                                            duration = remaining
-                                        end
-                                        break
-                                    end
-                                end
-                            end
-                        end
-                    end
-                end
-            end
-
-            -- Check for Carnage duration overrides FIRST (highest priority)
-            local carnageDuration = GetCarnageOverride(effect)
-            if carnageDuration then
-                duration = duration or carnageDuration
-                caster = caster or "player"  -- Ensure caster is set for UnitOwnDebuff filtering
-            end
-
-            -- Check if this is a combo scaling spell by name
-            if not duration and CleveRoids.IsComboScalingSpell and CleveRoids.IsComboScalingSpell(effect) then
-                if CleveRoids.ComboPointTracking and CleveRoids.ComboPointTracking[effect] then
-                    local tracking = CleveRoids.ComboPointTracking[effect]
-                    if tracking.duration and tracking.confirmed and (GetTime() - tracking.cast_time) < 0.5 then
-                        duration = tracking.duration
-                        caster = caster or "player"
-                    end
-                end
-            end
-
-            return originalAddEffect(self, unit, unitlevel, effect, duration, caster)
-        end
-
-        Extension.pfLibAddEffectHooked = true
-        Extension.DLOG("Hooked pfUI.api.libdebuff.AddEffect")
-    end
-
-    -- Hook UnitDebuff to return Carnage override duration to display code
-    -- Only override when pfUI's duration differs significantly from ours
-    if pflib.UnitDebuff and not Extension.pfLibUnitDebuffHooked then
-        local originalUnitDebuff = pflib.UnitDebuff
-
-        pflib.UnitDebuff = function(self, unit, id)
-            local effect, rank, texture, stacks, dtype, duration, timeleft, caster = originalUnitDebuff(self, unit, id)
-
-            -- Only check Carnage override if pfUI returned data but duration might be wrong
-            if effect then
-                local carnageDuration, carnageTimeleft = GetCarnageOverride(effect)
-                if carnageDuration then
-                    -- Only override if there's a significant difference (>1s)
-                    if not duration or math.abs(carnageDuration - duration) > 1 then
-                        if Extension.Debug then
-                            DEFAULT_CHAT_FRAME:AddMessage(
-                                string.format("|cff00aaff[pfUI UnitDebuff Override]|r %s: Carnage %.1fs/%.1fs (pfUI: %.1fs/%.1fs)",
-                                    effect, carnageDuration, carnageTimeleft, duration or 0, timeleft or 0)
-                            )
-                        end
-                        duration = carnageDuration
-                        timeleft = carnageTimeleft
-                    end
-                end
-            end
-
-            return effect, rank, texture, stacks, dtype, duration, timeleft, caster
-        end
-
-        Extension.pfLibUnitDebuffHooked = true
-        Extension.DLOG("Hooked pfUI.api.libdebuff.UnitDebuff (mismatch-only mode)")
-    end
-
-    -- Hook UnitOwnDebuff to return Carnage override duration when selfdebuff is enabled
-    -- Only override when pfUI's duration differs significantly from ours
-    if pflib.UnitOwnDebuff and not Extension.pfLibUnitOwnDebuffHooked then
-        local originalUnitOwnDebuff = pflib.UnitOwnDebuff
-
-        pflib.UnitOwnDebuff = function(self, unit, id)
-            local effect, rank, texture, stacks, dtype, duration, timeleft, caster = originalUnitOwnDebuff(self, unit, id)
-
-            if effect then
-                local carnageDuration, carnageTimeleft = GetCarnageOverride(effect)
-                if carnageDuration then
-                    -- Only override if there's a significant difference (>1s)
-                    if not duration or math.abs(carnageDuration - duration) > 1 then
-                        if Extension.Debug then
-                            DEFAULT_CHAT_FRAME:AddMessage(
-                                string.format("|cff00aaff[pfUI UnitOwnDebuff Override]|r %s: Carnage %.1fs/%.1fs (pfUI: %.1fs/%.1fs)",
-                                    effect, carnageDuration, carnageTimeleft, duration or 0, timeleft or 0)
-                            )
-                        end
-                        duration = carnageDuration
-                        timeleft = carnageTimeleft
-                    end
-                end
-            -- If UnitOwnDebuff returned nil but we have a Carnage override, synthesize from UnitDebuff
-            -- This fallback is only needed for edge cases where pfUI doesn't track the debuff yet
-            elseif not effect and CleveRoids.carnageDurationOverrides then
-                -- Use pflib:UnitDebuff which includes our Carnage override hook
-                local baseEffect, baseRank, baseTex, baseStacks, baseDtype, baseDur, baseLeft, _ = pflib:UnitDebuff(unit, id)
-                if baseEffect then
-                    local carnageDuration2, carnageTimeleft2 = GetCarnageOverride(baseEffect)
-                    if carnageDuration2 then
-                        return baseEffect, baseRank, baseTex, baseStacks, baseDtype, carnageDuration2, carnageTimeleft2, "player"
-                    end
-                end
-            end
-
-            return effect, rank, texture, stacks, dtype, duration, timeleft, caster
-        end
-
-        Extension.pfLibUnitOwnDebuffHooked = true
-        Extension.DLOG("Hooked pfUI.api.libdebuff.UnitOwnDebuff (mismatch-only mode)")
-    end
-
-    return Extension.pfLibDebuffHooked or Extension.pfLibAddEffectHooked or Extension.pfLibUnitDebuffHooked or Extension.pfLibUnitOwnDebuffHooked
-end
-
--- Synchronize combo durations to pfUI's libdebuff objects
--- NOTE: pfUI 7.6+ handles combo durations internally - skip sync entirely
-function Extension.SyncComboDurationToPfUI(guid, spellID, duration)
-    if not pfUI or not pfUI.api or not pfUI.api.libdebuff then
-        return
-    end
-
-    -- pfUI 7.6+ handles all durations internally
-    if CleveRoids.hasPfUI76 then
-        return
-    end
-
-    -- Get unit name from GUID
-    local unitName = nil
-    local unitLevel = 0
-
-    -- Check if this is the current target
-    local targetGUID = CleveRoids.GetGUID("target")
-    if targetGUID == guid then
-        unitName = UnitName("target")
-        unitLevel = UnitLevel("target") or 0
-    end
-
-    -- If we couldn't find the unit, use GUID to name mapping from libdebuff
-    if not unitName and CleveRoids.libdebuff and CleveRoids.libdebuff.guidToName then
-        unitName = CleveRoids.libdebuff.guidToName[guid]
-        -- Default to level 0 if we don't have the unit targeted
-        unitLevel = 0
-    end
-
-    if not unitName then
-        if CleveRoids.debug then
-            DEFAULT_CHAT_FRAME:AddMessage("|cffff0000[pfUI Sync]|r Could not find unit name for GUID")
-        end
-        return
-    end
-
-    -- Get spell name from spell ID
-    local spellName = GetSpellRecField(spellID, "name")
-    if not spellName then
-        if CleveRoids.debug then
-            DEFAULT_CHAT_FRAME:AddMessage("|cffff0000[pfUI Sync]|r Could not find spell name for ID " .. spellID)
-        end
-        return
-    end
-
-    -- Remove rank from spell name to match pfUI's format
-    local effectName = CleveRoids.StripRank(spellName)
-
-    -- Update pfUI's stored debuff duration
-    local pflib = pfUI.api.libdebuff
-    if pflib.objects and pflib.objects[unitName] then
-        -- Try both the specific level and level 0 (fallback)
-        for _, level in ipairs({unitLevel, 0}) do
-            if pflib.objects[unitName][level] and pflib.objects[unitName][level][effectName] then
-                local old_duration = pflib.objects[unitName][level][effectName].duration
-                pflib.objects[unitName][level][effectName].duration = duration
-
-                if CleveRoids.debug then
-                    DEFAULT_CHAT_FRAME:AddMessage(
-                        string.format("|cff00ffaa[pfUI Sync]|r Updated %s on %s (L%d): %ds -> %ds",
-                            effectName, unitName, level, old_duration or 0, duration)
-                    )
-                end
-                return
-            end
-        end
-    end
-
-    if CleveRoids.debug then
-        DEFAULT_CHAT_FRAME:AddMessage(
-            string.format("|cffaaaa00[pfUI Sync]|r Effect not found in pfUI storage: %s on %s",
-                effectName, unitName)
-        )
-    end
-end
-
 -- Register action event handler for pfUI button updates
 function Extension.RegisterPfUIActionEventHandler()
     if not pfUI or Extension.actionHandlerRegistered then
@@ -428,7 +88,17 @@ function Extension.RegisterPfUIActionEventHandler()
     -- Register a handler that will be called whenever CleveRoids updates macro states
     if CleveRoids.RegisterActionEventHandler then
         Extension.DLOG("Registering pfUI action event handler")
-        CleveRoids.RegisterActionEventHandler(function(slot, event, ...)
+        -- Declared without `...` on purpose: in 1.12's Lua 5.0 a vararg function
+        -- allocates an `arg` table on every call, and this handler never read it.
+        -- That mattered because UpdateAllManagedCooldowns fans
+        -- ACTIONBAR_UPDATE_COOLDOWN out across every managed slot -- up to 120 calls
+        -- -- on each SPELL_UPDATE_COOLDOWN, which fires on every GCD and cooldown
+        -- tick. Those calls all allocated a table and then did nothing, because the
+        -- whole body only ever applied to ACTIONBAR_SLOT_CHANGED. Hence the early
+        -- return before any work.
+        CleveRoids.RegisterActionEventHandler(function(slot, event)
+            if event ~= "ACTIONBAR_SLOT_CHANGED" then return end
+
             local button = pfUI.bars and pfUI.bars.buttons and pfUI.bars.buttons[slot]
 
             if Extension.Debug then
@@ -440,23 +110,21 @@ function Extension.RegisterPfUIActionEventHandler()
                 ))
             end
 
-            -- For slot change events, do a full button update so the icon,
-            -- cooldown, and tooltip refresh through CleveRoids' hooked
-            -- GetActionTexture / GetActionCooldown / GameTooltip:SetAction.
+            -- Full button update so the icon, cooldown and tooltip refresh.
             -- pfUI's ButtonMacroScan defers to us for managed macros (leaves
-            -- spellslot nil), so its ButtonFullUpdate routes through those hooks
-            -- and follows the active conditional — no manual cooldown override
-            -- needed.
-            if event == "ACTIONBAR_SLOT_CHANGED" then
-                -- Mark the slot for update in pfUI's cache (processed next OnUpdate)
-                if pfUI.bars and pfUI.bars.update then
-                    pfUI.bars.update[slot] = true
-                end
+            -- spellslot nil), so ButtonFullUpdate reads the stock action-bar
+            -- functions -- which now resolve through the value we publish with
+            -- C_Macro.SetMacroDisplay, rather than the Lua overrides this addon
+            -- used to install.
 
-                -- Also directly call ButtonFullUpdate if the button exists
-                if button and pfUI.bars.ButtonFullUpdate then
-                    pfUI.bars.ButtonFullUpdate(button)
-                end
+            -- Mark the slot for update in pfUI's cache (processed next OnUpdate)
+            if pfUI.bars and pfUI.bars.update then
+                pfUI.bars.update[slot] = true
+            end
+
+            -- Also directly call ButtonFullUpdate if the button exists
+            if button and pfUI.bars.ButtonFullUpdate then
+                pfUI.bars.ButtonFullUpdate(button)
             end
         end)
 
@@ -473,9 +141,6 @@ function Extension.SetupCompatibility()
     if Extension.pfUILoaded then
         Extension.DLOG("pfUI detected")
 
-        -- Hook libdebuff for combo duration support
-        Extension.HookPfUILibdebuff()
-
         -- Register action event handler for button updates
         Extension.RegisterPfUIActionEventHandler()
 
@@ -630,16 +295,9 @@ function Extension.SetupPfUIEventHooks(lib)
         ev:UnregisterEvent("AURA_CAST_ON_OTHER")
         ev:UnregisterEvent("DEBUFF_ADDED_OTHER")
         ev:UnregisterEvent("DEBUFF_REMOVED_OTHER")
-        ev:UnregisterEvent("BUFF_ADDED_OTHER")
         ev:UnregisterEvent("BUFF_REMOVED_SELF")
         ev:UnregisterEvent("BUFF_REMOVED_OTHER")
 
-        -- pfUI 7.6+ also handles cast tracking internally
-        if lib.hasPfUI76 then
-            ev:UnregisterEvent("SPELL_START_OTHER")
-            ev:UnregisterEvent("SPELL_FAILED_OTHER")
-        end
-
         -- Keep registered: SPELL_START_SELF (channel duration capture before early return),
         -- UNIT_DIED (AllCasterAuraTracking + OverflowBuff cleanup), UNIT_CASTEVENT (SuperWoW),
         -- PLAYER_TARGET_CHANGED, UNIT_AURA (SeedUnit)
@@ -699,7 +357,6 @@ end
 
 function Extension.OnLoad()
     Extension.DLOG("Extension pfUI Loaded.")
-    Extension.HookMethod(CleveRoids, "GetFocusName", "FocusNameHook", true)
 
     -- Export extension for external access
     CleveRoids.Compatibility_pfUI = Extension
@@ -726,24 +383,23 @@ function Extension.OnLoad()
     SLASH_PFUICD1 = "/pfuicd"
 end
 
-function Extension.ADDON_LOADED()
-    -- Check if pfUI just loaded AND the global actually exists
-    -- (another addon could be named "pfUI" without being the real UI framework)
-    if arg1 == "pfUI" and pfUI then
-        Extension.pfUILoaded = true
-        -- pfUI modules load after ADDON_LOADED, so schedule a check
-        if CleveRoids.ScheduleTimer then
-            CleveRoids.ScheduleTimer(function()
-                Extension.SetupCompatibility()
-            end, 0.5)
-        end
+-- Fires once pfUI has loaded (immediately if it loaded before us, via EventUtil).
+function Extension.OnPfUILoaded()
+    -- Guard: only the real pfUI framework sets this global (another addon could be
+    -- named "pfUI" without being the UI framework).
+    if not pfUI then return end
+    Extension.pfUILoaded = true
+    -- pfUI's submodules initialize after its ADDON_LOADED, so defer the setup.
+    if CleveRoids.ScheduleTimer then
+        CleveRoids.ScheduleTimer(function()
+            Extension.SetupCompatibility()
+        end, 0.5)
     end
 end
 
-function Extension.PLAYER_LOGIN()
-    -- If pfUI loaded before SCRM (alphabetical order), ADDON_LOADED for pfUI was missed.
-    -- Re-run InitPfUIIntegration here to ensure lib.objects is linked correctly.
-    if pfUI and not CleveRoids.hasPfUI76 then
+function Extension.OnPlayerLogin()
+    -- Ensure lib.objects is linked correctly (InitPfUIIntegration is idempotent).
+    if pfUI then
         local lib = CleveRoids.libdebuff
         if lib and lib.InitPfUIIntegration then
             lib:InitPfUIIntegration()
@@ -775,9 +431,6 @@ function Extension.PLAYER_LOGIN()
     -- Print startup status only if pfUI global exists and compatibility was set up
     if Extension.pfUILoaded and pfUI then
         local statusMsg = "|cff00ff00[SCRM]|r pfUI compatibility loaded"
-        if CleveRoids.hasPfUI76 then
-            statusMsg = statusMsg .. " (7.6+ GUID cast tracking)"
-        end
         -- statusMsg = statusMsg .. ". Use /pfuicd for debug."
         DEFAULT_CHAT_FRAME:AddMessage(statusMsg)
         if not Extension.actionHandlerRegistered then
@@ -797,4 +450,10 @@ if not CleveRoids.ScheduleTimer then
     end
 end
 
+-- Wire handlers via ClassicAPI EventUtil (fires immediately if the event already
+-- happened, so load order relative to pfUI no longer matters). Registered here,
+-- after the handlers are defined, since ContinueOnAddOnLoaded may fire inline.
+EventUtil.ContinueOnAddOnLoaded("pfUI", Extension.OnPfUILoaded)
+EventUtil.ContinueOnPlayerLogin(Extension.OnPlayerLogin)
+
 _G["CleveRoids"] = CleveRoids

Console.lua

@@ -63,10 +63,24 @@ SlashCmdList.EQSLOT13 = CleveRoids.DoEquipTrinket1
 SLASH_EQSLOT141 = "/equip14"
 SlashCmdList.EQSLOT14 = CleveRoids.DoEquipTrinket2
 
+-- Reclaim ClassicAPI's /equipset (command name EQUIP_SET) so it supports
+-- conditionals. ClassicAPI registers the localized aliases against EQUIP_SET;
+-- swapping the handler keeps every alias and adds the conditional engine.
+if SlashCmdList.EQUIP_SET then
+    SlashCmdList.EQUIP_SET = CleveRoids.DoEquipSet
+else
+    SLASH_EQUIPSET1 = "/equipset"
+    SlashCmdList.EQUIPSET = CleveRoids.DoEquipSet
+end
+
 SLASH_UNSHIFT1 = "/unshift"
 
 SlashCmdList.UNSHIFT = CleveRoids.DoUnshift
 
+SLASH_CANCELFORM1 = "/cancelform"
+
+SlashCmdList.CANCELFORM = CleveRoids.DoCancelForm
+
 SLASH_UNQUEUE1 = "/unqueue"
 SlashCmdList.UNQUEUE = SpellStopCasting
 
@@ -116,6 +130,12 @@ local StopAttack = function(msg)
     CleveRoids.DeferStopAttack()
 end
 
+local StopChanneling = function(msg)
+    -- No Blizzard equivalent: 1.12 has SpellStopCasting (immediate) and nothing
+    -- that waits for the next channel tick, so this is nampower-only.
+    CleveRoids.StopChanneling()
+end
+
 -- Register slash commands and assign original handlers.
 -- These will be hooked immediately after.
 SLASH_STARTATTACK1 = "/startattack"
@@ -127,6 +147,9 @@ SlashCmdList.STOPATTACK = StopAttack
 SLASH_STOPCASTING1 = "/stopcasting"
 SlashCmdList.STOPCASTING = SpellStopCasting
 
+SLASH_STOPCHANNELING1 = "/stopchanneling"
+SlashCmdList.STOPCHANNELING = StopChanneling
+
 SLASH_CLEARTARGET1 = "/cleartarget"
 SlashCmdList.CLEARTARGET = ClearTarget
 
@@ -188,6 +211,21 @@ SlashCmdList.STOPCASTING = function(msg)
     end
 end
 
+-- /stopchanneling hook
+CleveRoids.Hooks.STOPCHANNELING_SlashCmd = SlashCmdList.STOPCHANNELING
+SlashCmdList.STOPCHANNELING = function(msg)
+    if CleveRoids.stopMacroFlag then return end
+    msg = msg or ""
+    if string.find(msg, "%[") then
+        -- If conditionals are present, let the function handle it.
+        -- It will only stop the channel if the conditions are met.
+        CleveRoids.DoConditionalStopChanneling(msg)
+    else
+        -- If no conditionals, run the original command.
+        CleveRoids.Hooks.STOPCHANNELING_SlashCmd(msg)
+    end
+end
+
 -- /unqueue hook
 CleveRoids.Hooks.UNQUEUE_SlashCmd = SlashCmdList.UNQUEUE
 SlashCmdList.UNQUEUE = function(msg)
@@ -320,14 +358,15 @@ SlashCmdList.RUNMACRO = function(msg)
     return CleveRoids.ExecuteMacroByName(CleveRoids.Trim(msg))
 end
 
--- Global RunMacro wrapper for user convenience (delegates to namespaced internal function)
--- This pattern ensures internal logic uses CleveRoids.ExecuteMacroByName and won't break
--- if another addon overwrites the global RunMacro
--- NOTE: When SuperMacro is also loaded, Compatibility/SuperMacro.lua redirects this to
--- SuperMacro_RunMacro so macros go through RunLine (where CRM commands are intercepted)
-function RunMacro(name)
-    return CleveRoids.ExecuteMacroByName(name)
-end
+-- The global RunMacro is installed by Core.lua, which loads before this file. Do not
+-- redefine it here: Core's hook accepts a macro index as well as a name (Blizzard's
+-- RunMacro takes either), delegates to SuperMacro when that is driving execution,
+-- falls back to the saved Blizzard original when a macro will not resolve, and clears
+-- the stop/skip flags at the start of a top-level run, which is what lets /stopmacro,
+-- /skipmacro and /firstaction work across parent/child macro boundaries. A plain
+-- name-only wrapper here silently replaced all of that.
+-- When SuperMacro is loaded, Compatibility/SuperMacro.lua redirects the global to
+-- SuperMacro_RunMacro so macros go through RunLine (where CRM commands are intercepted).
 
 SLASH_RETARGET1 = "/retarget"
 SlashCmdList.RETARGET = function(msg)

Extensions/CursiveCustomSpells.lua

@@ -209,8 +209,8 @@ local function InjectCustomSpells()
     local count = 0
     for spellID, data in pairs(CleveRoids.CustomCursiveSpells) do
         -- Get texture from GetSpellRecField + GetSpellIconTexture
-        local name = GetSpellRecField(spellID, "name")
-        local rank = GetSpellRecField(spellID, "rank")
+        local name = C_Spell.GetSpellName(spellID)
+        local rank = C_Spell.GetSpellSubtext(spellID)
         local texture = CleveRoids.libdebuff and CleveRoids.libdebuff:GetCachedIcon(spellID)
         if texture then
             -- Always update/add (in case Cursive reloaded and cleared them)
@@ -524,8 +524,8 @@ CleveRoids.HandleConsoleCommand = function(msg)
                 return
             end
 
-            local name = GetSpellRecField(spellID, "name")
-            local rank = GetSpellRecField(spellID, "rank")
+            local name = C_Spell.GetSpellName(spellID)
+            local rank = C_Spell.GetSpellSubtext(spellID)
             local texture = CleveRoids.libdebuff and CleveRoids.libdebuff:GetCachedIcon(spellID)
             if not name then
                 DEFAULT_CHAT_FRAME:AddMessage("|cffff0000Error:|r Spell ID " .. spellID .. " not found.")

Extensions/MacroErrorUI.lua

@@ -697,30 +697,9 @@ local function EnsureCondHighlightPool()
     end
 end
 
--- Test whether conditionals pass for a given command + alternative text.
--- Returns: true (passes), false (fails), nil (unconditional / no conditionals)
-local function TestConditionalPasses(cmd, alternative)
-    -- Strip ? tooltip hints (irrelevant for conditional evaluation)
-    if string.find(alternative, "?", 1, true) then
-        alternative = string.gsub(alternative, "%?", "")
-    end
-
-    local hasConditional = string.find(alternative, "%[") ~= nil
-
-    -- Dynamic commands: delegate to TestAction
-    if CleveRoids.dynamicCmds[cmd] then
-        local result = CleveRoids.TestAction(cmd, alternative)
-        if not hasConditional then
-            return nil  -- unconditional
-        end
-        return result ~= nil and result ~= false
-    end
-
-    -- Non-dynamic commands: parse and evaluate Keywords manually
-    if not hasConditional then
-        return nil  -- unconditional
-    end
-
+-- Evaluate one single-group clause of a non-dynamic command against Keywords.
+-- Returns: true (passes), false (fails), nil (could not parse)
+local function EvaluateNonDynamic(alternative)
     local ok, action, conditionals = pcall(CleveRoids.GetParsedMsg, alternative)
     if not ok or not conditionals then
         return nil
@@ -745,6 +724,43 @@ local function TestConditionalPasses(cmd, alternative)
     return passes
 end
 
+-- Test whether conditionals pass for a given command + alternative text.
+-- Returns: true (passes), false (fails), nil (unconditional / no conditionals)
+local function TestConditionalPasses(cmd, alternative)
+    -- Strip ? tooltip hints (irrelevant for conditional evaluation)
+    if string.find(alternative, "?", 1, true) then
+        alternative = string.gsub(alternative, "%?", "")
+    end
+
+    local hasConditional = string.find(alternative, "%[") ~= nil
+
+    -- Dynamic commands: delegate to TestAction
+    if CleveRoids.dynamicCmds[cmd] then
+        local result = CleveRoids.TestAction(cmd, alternative)
+        if not hasConditional then
+            return nil  -- unconditional
+        end
+        return result ~= nil and result ~= false
+    end
+
+    -- Non-dynamic commands: evaluate Keywords manually. `[a][b] X` passes when
+    -- any of its groups does.
+    if not hasConditional then
+        return nil  -- unconditional
+    end
+
+    local variants = CleveRoids.ExpandBracketGroups(alternative)
+    if not variants then
+        return EvaluateNonDynamic(alternative)
+    end
+    for i = 1, variants.n do
+        if EvaluateNonDynamic(variants[i]) then
+            return true
+        end
+    end
+    return false
+end
+
 -- Find character offset ranges for each semicolon-separated alternative.
 -- Returns array of { start, finish } pairs (1-based indices within argsText).
 local function FindAlternativeOffsets(argsText)
@@ -1164,7 +1180,7 @@ local function ReportAllMacroErrors()
 
     -- Collect body (syntax) errors per macro. Macro names are no longer
     -- restricted (slot/index-based identification), so no name checks here.
-    for i = 1, 36 do
+    for i = 1, CleveRoids.MAX_MACRO_SLOTS do
         local nameOk, name = pcall(GetMacroInfo, i)
         if nameOk and name and name ~= "" then
             local errors = {}
@@ -1391,12 +1407,6 @@ end
 -- Extension Entry Points
 -- ============================================================================
 
-function Extension.OnAddonLoaded()
-    if arg1 == "Blizzard_MacroUI" then
-        InstallHooks()
-    end
-end
-
 function Extension.OnLoad()
     -- Skip if macro checker is disabled
     if CleveRoidMacros and CleveRoidMacros.macrocheck == 0 then return end
@@ -1404,13 +1414,9 @@ function Extension.OnLoad()
     -- Skip if SuperMacro is loaded (detected at load time)
     if SuperMacroFrame ~= nil then return end
 
-    -- Listen for macro UI loading
-    Extension.RegisterEvent("ADDON_LOADED", "OnAddonLoaded")
-
-    -- If MacroFrame already exists (unlikely but safe), hook immediately
-    if MacroFrame and MacroFrameText then
-        InstallHooks()
-    end
+    -- Install once Blizzard's macro UI is available (fires immediately if already
+    -- loaded), replacing the ADDON_LOADED listener + manual "already loaded" check.
+    EventUtil.ContinueOnAddOnLoaded("Blizzard_MacroUI", InstallHooks)
 end
 
 _G["CleveRoids"] = CleveRoids

Extensions/MacroLengthWarn.lua

@@ -133,12 +133,6 @@ function Extension.OnMacroFrameLoad()
     end
 end
 
-function Extension.OnAddonLoaded()
-    if arg1 == "Blizzard_MacroUI" then
-        Extension.OnMacroFrameLoad()
-    end
-end
-
 function Extension.OnLoad()
     -- Schedule messages to show after UI is ready
     local function ShowMessages()
@@ -178,16 +172,11 @@ function Extension.OnLoad()
         end
     end
 
-    -- Listen for macro UI loading
-    Extension.RegisterEvent("ADDON_LOADED", "OnAddonLoaded")
+    -- Hook the macro UI once available (fires immediately if already loaded).
+    EventUtil.ContinueOnAddOnLoaded("Blizzard_MacroUI", Extension.OnMacroFrameLoad)
 
-    -- Also try to hook MacroFrame_SaveMacro if it already exists
-    if MacroFrame_SaveMacro then
-        Extension.OnMacroFrameLoad()
-    end
-
-    -- Register PLAYER_LOGIN to show status messages
-    Extension.RegisterEvent("PLAYER_LOGIN", "OnPlayerLogin")
+    -- Status messages on login (currently disabled inside OnPlayerLogin).
+    EventUtil.ContinueOnPlayerLogin(Extension.OnPlayerLogin)
 
     -- Store the message function for later
     Extension.ShowMessages = ShowMessages

Extensions/Mouseover/CT_RaidAssist.lua

@@ -6,7 +6,6 @@ local _G = _G or getfenv(0)
 local CleveRoids = _G.CleveRoids or {}
 
 local Extension = CleveRoids.RegisterExtension("CT_RaidAssist")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 function Extension.OnEnter()
 	local tempOptions = CT_RAMenu_Options["temp"]
@@ -48,15 +47,14 @@ function Extension.OnLeave()
     CleveRoids.ClearMouseoverFrom("native")
 end
 
-function Extension.OnLoad()
-    if arg1 ~= "CT_RaidAssist" then
-        return
-    end
+function Extension.OnLoad() end
 
+function Extension.OnAddOnLoad()
+	if not CT_RA_MemberFrame_OnEnter then return end
     Extension.Hook("CT_RA_MemberFrame_OnEnter", "OnEnter")
     Extension.HookMethod(_G["GameTooltip"], "Hide", "OnLeave")
     Extension.HookMethod(_G["GameTooltip"], "FadeOut", "OnLeave")
 
 end
 
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("CT_RaidAssist", Extension.OnAddOnLoad)

Extensions/Mouseover/CT_UnitFrames.lua

@@ -6,7 +6,6 @@ local _G = _G or getfenv(0)
 local CleveRoids = _G.CleveRoids or {}
 
 local Extension = CleveRoids.RegisterExtension("CT_UnitFrames")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 function Extension.SetHook(widget)
     local hookedOnEnter = widget:GetScript("OnEnter")
@@ -24,8 +23,10 @@ function Extension.SetHook(widget)
     end)
 end
 
-function Extension.OnLoad()
-    if arg1 ~= "CT_UnitFrames" or not CT_AssistFrame then
+function Extension.OnLoad() end
+
+function Extension.OnAddOnLoad()
+    if not CT_AssistFrame then
         return
     end
     CleveRoids.Print("CT_UnitFrames module loaded.")
@@ -36,4 +37,4 @@ function Extension.OnLoad()
     Extension.SetHook(CT_AssistFrame_Drag)
 end
 
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("CT_UnitFrames", Extension.OnAddOnLoad)

Extensions/Mouseover/Cursive.lua

@@ -9,7 +9,6 @@ local CleveRoids = _G.CleveRoids or {}
 CleveRoids.Hooks = CleveRoids.Hooks or {}
 
 local Extension = CleveRoids.RegisterExtension("CursiveMouseover")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 local hooked = false
 
@@ -66,21 +65,13 @@ local function HookCursiveUI()
 end
 
 function Extension.OnLoad()
-    -- Try to hook when Cursive loads
-    if arg1 == "Cursive" then
-        -- Delay slightly to ensure Cursive.ui is initialized
-        local frame = CreateFrame("Frame")
-        frame:SetScript("OnUpdate", function()
-            if HookCursiveUI() then
-                this:Hide()
-            end
-        end)
-    end
+    -- Delay slightly to ensure Cursive.ui is initialized
+    local frame = CreateFrame("Frame")
+    frame:SetScript("OnUpdate", function()
+        if HookCursiveUI() then
+            this:Hide()
+        end
+    end)
 end
 
--- Also try to hook immediately in case Cursive is already loaded
-if Cursive and Cursive.ui then
-    HookCursiveUI()
-end
-
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("Cursive", Extension.OnLoad)

Extensions/Mouseover/DiscordUnitFrames.lua

@@ -6,7 +6,6 @@ local _G = _G or getfenv(0)
 local CleveRoids = _G.CleveRoids or {}
 
 local Extension = CleveRoids.RegisterExtension("DiscordUnitFrames")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 function Extension.OnEnterFrame()
     CleveRoids.SetMouseoverFrom("duf", this.unit)
@@ -26,11 +25,10 @@ function Extension.OnLeaveElement()
     CleveRoids.ClearMouseoverFrom("native")
 end
 
-function Extension.OnLoad()
-    if arg1 ~= "DiscordUnitFrames" then
-        return
-    end
+function Extension.OnLoad() end
 
+function Extension.OnAddOnLoad()
+    if not DUF_UnitFrame_OnEnter then return end
     CleveRoids.ClearHooks()
     Extension.Hook("DUF_UnitFrame_OnEnter", "OnEnterFrame")
     Extension.Hook("DUF_UnitFrame_OnLeave", "OnLeaveFrame")
@@ -39,4 +37,4 @@ function Extension.OnLoad()
     Extension.Hook("DUF_Element_OnLeave", "OnLeaveElement")
 end
 
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("DiscordUnitFrames", Extension.OnAddOnLoad)

Extensions/Mouseover/Grid.lua

@@ -8,7 +8,6 @@ local CleveRoids = _G.CleveRoids or {}
 CleveRoids.Hooks = CleveRoids.Hooks or {}
 
 local Extension = CleveRoids.RegisterExtension("Grid")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 function Extension.OnEnter(unit)
     CleveRoids.SetMouseoverFrom("grid", unit)
@@ -19,11 +18,10 @@ function Extension.OnLeave()
     CleveRoids.ClearMouseoverFrom("native")
 end
 
-function Extension.OnLoad()
-    if arg1 ~= "Grid" then
-        return
-    end
+function Extension.OnLoad() end
 
+function Extension.OnAddOnLoad()
+	if not GridFrame then return end
     CleveRoids.Hooks.Grid = { CreateFrames = GridFrame.frameClass.prototype.CreateFrames}
     GridFrame.frameClass.prototype.CreateFrames = CleveRoids.GrdCreateFrames
 end
@@ -111,4 +109,4 @@ function CleveRoids:GrdCreateFrames()
 	ClickCastFrames[self.frame] = true
 end
 
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("Grid", Extension.OnAddOnLoad)

Extensions/Mouseover/NotGrid.lua

@@ -8,7 +8,6 @@ local CleveRoids = _G.CleveRoids or {}
 local CreateFrames = nil
 
 local Extension = CleveRoids.RegisterExtension("NotGrid")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 function Extension.OnEnter()
     CleveRoids.SetMouseoverFrom("ngrid", this.unit)
@@ -39,7 +38,9 @@ function CleveRoids:NotGrid_CreateFrames()
     end
 end
 
-function Extension.OnLoad()
+function Extension.OnLoad() end
+
+function Extension.OnAddOnLoad()
     -- NotGrid loads before CleveRoids, so if NotGrid is enabled, then it's global will exist.
     if not NotGrid then
         return
@@ -48,7 +49,6 @@ function Extension.OnLoad()
     CreateFrames = NotGrid.CreateFrames
     NotGrid.CreateFrames = CleveRoids.NotGrid_CreateFrames
 
-    Extension.UnregisterEvent("ADDON_LOADED", "Onload")
 end
 
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("NotGrid", Extension.OnAddOnLoad)

Extensions/Mouseover/PerfectRaid.lua

@@ -8,7 +8,6 @@ local CleveRoids = _G.CleveRoids or {}
 CleveRoids.Hooks = CleveRoids.Hooks or {}
 
 local Extension = CleveRoids.RegisterExtension("PerfectRaid")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 function Extension.OnEnter(unit)
     CleveRoids.SetMouseoverFrom("praid", unit)
@@ -19,11 +18,10 @@ function Extension.OnLeave()
     CleveRoids.ClearMouseoverFrom("native")
 end
 
-function Extension.OnLoad()
-    if arg1 ~= "PerfectRaid" then
-        return
-    end
+function Extension.OnLoad() end
 
+function Extension.OnAddOnLoad()
+    if not PerfectRaid then return end
     CleveRoids.Hooks.PerfectRaid = { CreateFrame = PerfectRaid.CreateFrame }
     PerfectRaid.CreateFrame = CleveRoids.PerfectRaidCreateFrame
 end
@@ -134,4 +132,4 @@ function CleveRoids.PerfectRaidCreateFrame(self, num)
 --]]
 end
 
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("PerfectRaid", Extension.OnAddOnLoad)

Extensions/Mouseover/ag_UnitFrames.lua

@@ -4,7 +4,6 @@ local CleveRoids = _G.CleveRoids or {}
 CleveRoids.Hooks = CleveRoids.Hooks or {}
 
 local Extension = CleveRoids.RegisterExtension("ag_UnitFrames")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 function Extension.OnEnter(unit)
     CleveRoids.SetMouseoverFrom("aguf", unit)
@@ -23,7 +22,6 @@ function Extension.OnLoad()
     CleveRoids.Hooks.ag_UnitFrames = { OnEnter = aUF.classes.aUFunit.prototype.OnEnter, OnLeave = aUF.classes.aUFunit.prototype.OnLeave}
     aUF.classes.aUFunit.prototype.OnEnter = CleveRoids.aUFOnEnter
     aUF.classes.aUFunit.prototype.OnLeave = CleveRoids.aUFOnLeave
-    Extension.UnregisterEvent("ADDON_LOADED", "Onload")
 end
 
 -- Taken from ag_UnitClass.lua
@@ -41,4 +39,4 @@ function CleveRoids:aUFOnLeave()
 end
 
 
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("ag_UnitFrames", Extension.OnLoad)

Extensions/Mouseover/pfUI.lua

@@ -8,6 +8,9 @@
   - Resolving a real UnitID when .unit isn't set
   - Properly hooking party group[0] (your own party slot) with a safe closure and defaulting to "player"
 ]]
+
+if pfPlayer and pfPlayer.GetAttribute and pfPlayer:GetAttribute('unit') == 'player' then return end
+
 local _G = _G or getfenv(0)
 local CleveRoids = _G.CleveRoids or {}
 
@@ -31,7 +34,6 @@ local function ResolvePfUnit(frame, fallbackName)
   name = strlower(name)
 
   local candidates = { "target", "targettarget", "player", "pet" }
-  local i
   for i = 1, 4 do
     table.insert(candidates, "party"..i)
     table.insert(candidates, "partypet"..i)
@@ -153,7 +155,6 @@ end
 function Extension.RegisterPartyScripts()
   if not pfUI or not pfUI.uf or not pfUI.uf.group then return end
 
-  local i
   for i = 0, 4 do
     local frame = pfUI.uf.group[i]
     if frame then
@@ -181,7 +182,6 @@ end
 function Extension.RegisterRaidScripts()
   if not pfUI or not pfUI.uf or not pfUI.uf.raid then return end
 
-  local i
   for i = 1, 40 do
     local frame = pfUI.uf.raid[i]
     if frame then
@@ -333,7 +333,6 @@ end
 function Extension.RegisterRaidMarkScripts()
   if not pfUI or not pfUI.raidmarkers or not pfUI.raidmarkers.rows then return end
 
-  local i
   for i = 1, 8 do
     local row = pfUI.raidmarkers.rows[i]
     if row then

Extensions/Mouseover/sRaidFrames.lua

@@ -6,7 +6,6 @@ local _G = _G or getfenv(0)
 local CleveRoids = _G.CleveRoids or {}
 
 local Extension = CleveRoids.RegisterExtension("sRaidFrames")
-Extension.RegisterEvent("ADDON_LOADED", "OnLoad")
 
 function Extension:OnEnter(frame)
     CleveRoids.SetMouseoverFrom("sraid", frame.unit)
@@ -17,14 +16,13 @@ function Extension.OnLeave()
     CleveRoids.ClearMouseoverFrom("native")
 end
 
-function Extension.OnLoad()
-    if arg1 ~= "sRaidFrames" then
-        return
-    end
+function Extension.OnLoad() end
 
+function Extension.OnAddOnLoad()
+    if not sRaidFrames then return end
     Extension.HookMethod(sRaidFrames, "UnitTooltip", "OnEnter")
     Extension.HookMethod(_G["GameTooltip"], "Hide", "OnLeave")
     Extension.HookMethod(_G["GameTooltip"], "FadeOut", "OnLeave")
 end
 
-_G["CleveRoids"] = CleveRoids
+EventUtil.ContinueOnAddOnLoaded("sRaidFrames", Extension.OnAddOnLoad)

Extensions/OverflowBuffFrame.lua

@@ -122,7 +122,7 @@ local function CreateIconButton(parent, index, iconTable)
         GameTooltip:SetOwner(btn, "ANCHOR_BOTTOMLEFT")
         local spellName
         if data.spellId then
-            spellName = GetSpellRecField and GetSpellRecField(data.spellId, "name") or ("Spell " .. data.spellId)
+            spellName = C_Spell.GetSpellName(data.spellId) or ("Spell " .. data.spellId)
         else
             spellName = data.displayName
         end
@@ -649,7 +649,7 @@ local function InjectTestTargetData()
     for i = 1, table.getn(TEST_TARGET_SPELL_IDS) do
         local spellId = TEST_TARGET_SPELL_IDS[i]
         local dur = targetDurations[i] or 60
-        local spellName = GetSpellRecField and GetSpellRecField(spellId, "name") or ("TestSpell" .. spellId)
+        local spellName = C_Spell.GetSpellName(spellId) or ("TestSpell" .. spellId)
         if not CleveRoids.AllCasterAuraTracking[targetGuid][spellName] then
             CleveRoids.AllCasterAuraTracking[targetGuid][spellName] = {}
         end

Extensions/Tooltip/Generic.lua

@@ -58,11 +58,7 @@ function CleveRoids.IndexSpells()
             bookType = CleveRoids.bookTypes[book]
             spells[bookType] = {}
         else
-            local cost, reagent = CleveRoids.GetSpellCost(i, bookType)
-            -- Fallback for known reagent spells if tooltip scan failed
-            if (not reagent or reagent == "") and CleveRoids.ReagentBySpell then
-                reagent = CleveRoids.ReagentBySpell[spellName]
-            end
+            local cost, reagent, reagentId = CleveRoids.GetSpellCost(i, bookType, spellId)
             if not spells[bookType][spellName] then
                 spells[bookType][spellName] = {
                     spellSlot = i,
@@ -71,7 +67,7 @@ function CleveRoids.IndexSpells()
                     bookType = bookType,
                     texture = texture,
                     cost = cost,
-                    reagent = reagent,
+                    reagentId = reagentId,
                 }
             end
             if spellRank and not spells[bookType][spellName][spellRank] then
@@ -83,7 +79,7 @@ function CleveRoids.IndexSpells()
                     bookType = bookType,
                     texture = texture,
                     cost = cost,
-                    reagent = reagent
+                    reagentId = reagentId,
                 }
                 spells[bookType][spellName].highest = spells[bookType][spellName][spellRank]
             end
@@ -94,6 +90,13 @@ function CleveRoids.IndexSpells()
 
             if reagent then
                 CleveRoids.countedItemTypes[reagent] = true
+            elseif reagentId and Item then
+                Item:CreateFromItemID(reagentId):ContinueOnItemLoad(function()
+                    local loadedName = C_Item.GetItemNameByID(reagentId)
+                    if loadedName and loadedName ~= "" then
+                        CleveRoids.countedItemTypes[loadedName] = true
+                    end
+                end)
             end
         end
     end
@@ -153,53 +156,27 @@ end
 
 -- Lightweight equipment-only indexing for combat situations
 -- Updates existing cache rather than rebuilding it
-function CleveRoids.IndexEquippedItems()
-    local items = CleveRoids.Items or {}
-
-    for inventoryID = 1, 19 do
-        local itemID = GetInventoryItemID("player", inventoryID)
-        if itemID then
-            local name, link, _, _, itemType, itemSubType, _, _, texture = GetItemInfo(itemID)
-            if name then
-                local count = GetInventoryItemCount("player", inventoryID)
-                if not items[name] then
-                    items[name] = {
-                        inventoryID = inventoryID,
-                        id = itemID,
-                        name = name,
-                        count = count,
-                        texture = texture,
-                        link = link,
-                    }
-                    items[itemID] = name
-                    local lowerName = string.lower(name)
-                    if lowerName ~= name then
-                        items[lowerName] = name
-                    end
-                else
-                    -- Update existing entry with current equipment state
-                    items[name].inventoryID = inventoryID
-                    items[name].count = count
-                end
-            end
-        else
-            -- Slot is now empty - clear inventoryID from any item that was there
-            -- This is handled lazily by GetItem() fallback, so we skip expensive iteration
-        end
-    end
-
-    CleveRoids.lastGetItem = nil
-    CleveRoids.Items = items
-end
-
 -- PERFORMANCE: Index a single equipment slot instead of all 20
--- Use when we know exactly which slot changed (e.g., from EquipBagItem)
-function CleveRoids.IndexEquipSlot(inventoryID)
+-- Use when we know exactly which slot changed (e.g., from EquipBagItem or
+-- PLAYER_EQUIPMENT_CHANGED). hasCurrent is the event's arg2 (does the slot now
+-- hold an item); pass false to skip the API probe on a slot we know is empty.
+function CleveRoids.IndexEquipSlot(inventoryID, hasCurrent)
     if not inventoryID then return end
 
     local items = CleveRoids.Items or {}
-    local itemID = GetInventoryItemID("player", inventoryID)
 
+    -- Clear any stale inventoryID still pointing at this slot: the item that was
+    -- here is now unequipped or swapped out (its real location comes from the
+    -- paired BAG_UPDATE rebuild). Equip changes are user-paced, so this table
+    -- scan is off the hot path.
+    for _, entry in pairs(items) do
+        if type(entry) == "table" and entry.inventoryID == inventoryID then
+            entry.inventoryID = nil
+        end
+    end
+
+    -- hasCurrent == false (arg2) => slot is now empty, nothing to add.
+    local itemID = hasCurrent ~= false and GetInventoryItemID("player", inventoryID)
     if itemID then
         local name, itemLink, _, _, itemType, itemSubType, _, _, texture = GetItemInfo(itemID)
         if name then
@@ -261,6 +238,14 @@ function CleveRoids.IndexItems()
     local items = {}
     local NUM_BAG_SLOTS = NUM_BAG_SLOTS  -- Upvalue for bag constant
 
+    -- Rebuilt each pass: itemIDs the player owns that GetItemInfo couldn't
+    -- resolve yet (cold cache under ClassicAPI's async warmup). The
+    -- GET_ITEM_INFO_RECEIVED handler consults this so it only re-indexes for
+    -- our own uncached items and ignores the flood of unrelated fills (quest
+    -- DB scans, AH, chat-link hovers, inspects) in O(1).
+    local pendingItemInfo = {}
+    CleveRoids.pendingItemInfo = pendingItemInfo
+
     -- PERFORMANCE: Local function references
     local GetContainerNumSlots = GetContainerNumSlots
     local GetContainerItemInfo = GetContainerItemInfo
@@ -304,6 +289,9 @@ function CleveRoids.IndexItems()
                         if lowerName ~= name then
                             items[lowerName] = name
                         end
+                    else
+                        -- Owned but not cached yet; wait for GET_ITEM_INFO_RECEIVED.
+                        pendingItemInfo[itemID] = true
                     end
                 end
             end
@@ -341,6 +329,9 @@ function CleveRoids.IndexItems()
                     if lowerName ~= name then
                         items[lowerName] = name
                     end
+                else
+                    -- Owned but not cached yet; wait for GET_ITEM_INFO_RECEIVED.
+                    pendingItemInfo[itemID] = true
                 end
             end
         end
@@ -375,9 +366,9 @@ function CleveRoids.GetActionButtonInfo(slot)
     if not actionType then return end
 
     if actionType == "spell" and id then
-        local rank = GetSpellRecField(id, "rank")
+        local rank = C_Spell.GetSpellSubtext(id)
         if rank == "" then rank = nil end
-        return "SPELL", id, GetSpellRecField(id, "name"), rank
+        return "SPELL", id, C_Spell.GetSpellName(id), rank
     elseif actionType == "item" and id then
         local item = CleveRoids.GetItem(id)
         return "ITEM", id, (item and item.name)
@@ -432,7 +423,9 @@ function CleveRoids.IndexActionSlot(slot)
             end
         end
     end
-    CleveRoids.TestForActiveAction(CleveRoids.GetAction(slot))
+    local actions = CleveRoids.GetAction(slot)
+    CleveRoids.TestForActiveAction(actions)
+    CleveRoids.PublishDisplay(actions)
     CleveRoids.SendEventForAction(slot, "ACTIONBAR_SLOT_CHANGED", slot)
 end
 
@@ -444,6 +437,27 @@ end
 
 function CleveRoids.GetSpell(text)
     text = CleveRoids.Trim(text)
+
+    -- Explicit "spell:<id>" form. If the player knows the spell, reuse its cached
+    -- spellbook entry (full cost/cooldown/usability). FindSpellBookSlotByID
+    -- (ClassicAPI) resolves per-rank IDs and pet spells natively and returns the
+    -- same bookType string CleveRoids.Spells is keyed by. If the spell is not in
+    -- either book, fall back to an id-only entry that SetAction renders via
+    -- SetSpellByID; cost=0 keeps the downstream active-action checks nil-safe.
+    local _, _, spellId = string.find(text, "^spell:(%d+)$")
+    if spellId then
+        spellId = tonumber(spellId)
+        local slot, book = FindSpellBookSlotByID(spellId)
+        if slot then
+            local name, rank = GetSpellInfo(slot, book)
+            local byName = name and CleveRoids.Spells[book] and CleveRoids.Spells[book][name]
+            if byName then
+                return (rank and rank ~= "" and byName[rank]) or byName.highest or byName
+            end
+        end
+        return { id = spellId, texture = C_Spell.GetSpellTexture(spellId) or CleveRoids.unknownTexture, cost = 0 }
+    end
+
     local rs, _, rank = string.find(text, "[^%s]%((Rank %d+)%)$")
     local name = rank and string.sub(text, 1, rs) or text
 
@@ -501,7 +515,7 @@ local function makeBagItem(bagID, slot, link, Items)
 
     local itemID = C_Container.GetContainerItemID(bagID, slot)
 
-    local name = C_Item.GetItemName(ItemLocation:CreateFromBagAndSlot(bagID, slot))
+    local name = C_Item.GetItemName({bagID = bagID, slotIndex = slot})
     local count = 0
     local texture, itemCount = GetContainerItemInfo(bagID, slot)
     if itemCount then count = itemCount end
@@ -531,6 +545,12 @@ end
 function CleveRoids.GetItem(text)
     if not text or text == "" then return end
 
+    -- Explicit "item:<id>" form: force resolution by item ID. Reuses the numeric
+    -- lookup below (equipped -> bags -> GetItemInfo), so location-aware tooltip
+    -- rendering (SetInventoryItem/SetBagItem) still applies when the player has it.
+    local _, _, prefixedId = string.find(text, "^item:(%d+)$")
+    if prefixedId then text = prefixedId end
+
     local Items = CleveRoids.Items
     local item = Items[text] or Items[tostring(text)]
     if not item then
@@ -747,20 +767,17 @@ function CleveRoids.FindItemQuick(text)
     for inv = 1, 19 do
         local link = GetInventoryItemLink("player", inv)
         if link then
-            local _, _, itemID = string_find(link, "item:(%d+)")
-            if itemID then
-                itemID = tonumber(itemID)
-                -- ID match: fast path
-                if qid and qid == itemID then
+            local itemID = GetInventoryItemID("player", inv)
+            -- ID match: fast path
+            if qid and qid == itemID then
+                return makeInventoryItem(inv, link, Items)
+            end
+            -- Name match: extract name from link (faster than GetItemInfo)
+            if qname then
+                local nm = GetNameFromLink(link)
+                if nm and string_lower(nm) == qname then
                     return makeInventoryItem(inv, link, Items)
                 end
-                -- Name match: extract name from link (faster than GetItemInfo)
-                if qname then
-                    local nm = GetNameFromLink(link)
-                    if nm and string_lower(nm) == qname then
-                        return makeInventoryItem(inv, link, Items)
-                    end
-                end
             end
         end
     end

ExtensionsManager.lua

@@ -66,6 +66,10 @@ function CleveRoids.RegisterExtension(name)
         CleveRoids.RegisterEvent(name, eventName, callbackName)
     end
 
+    extension.RegisterUnitEvent = function(eventName, callbackName, ...)
+        CleveRoids.RegisterUnitEvent(name, eventName, callbackName, unpack(arg))
+    end
+
     extension.Hook = function(functionName, callbackName, dontCallOriginal)
         CleveRoids.RegisterHook(name, functionName, callbackName, dontCallOriginal)
     end
@@ -146,6 +150,20 @@ function CleveRoids.RegisterEvent(extensionName, eventName, callbackName)
     extension.internal.frame:RegisterEvent(eventName)
 end
 
+-- Registers a callback for a UNIT_* event, filtered to the given unit tokens.
+-- The callback then only runs for those units: the client drops every other
+-- unit's copy, instead of all of them reaching Lua to be compared away. Use
+-- this over RegisterEvent whenever the handler starts by testing arg1.
+-- extensionName: The name of the extension trying to register the callback
+-- eventName: The UNIT_* event to register
+-- callbackName: The name of the callback that gets called when the event fires
+-- ...: the unit tokens to accept (e.g. "player", "target")
+function CleveRoids.RegisterUnitEvent(extensionName, eventName, callbackName, ...)
+    local extension = CleveRoids.Extensions[extensionName]
+    extension.internal.eventHandlers[eventName] = callbackName
+    extension.internal.frame:RegisterUnitEvent(eventName, unpack(arg))
+end
+
 -- Hooks the given function by it's name
 -- extensionName: The name of the extension trying to register the callback
 -- functionName: The name of the function that'll be hooked

Init.lua

@@ -19,12 +19,40 @@ CleveRoids.mouseOverResolvers  = {}
 CleveRoids.mouseoverUnit = CleveRoids.mouseoverUnit or nil
 CleveRoids.mouseOverUnit = nil
 
+-- Every macro slot the client can hold: 18 account-wide (1-18) followed by 18
+-- character-specific (19-36). This is the index space GetMacroInfo and
+-- C_Macro.SetMacroDisplay address, and it is fixed -- GetNumMacros() returns how
+-- many of each tab are *used*, which cannot be summed into a range, because the
+-- character block starts at 19 no matter how few account macros exist. Blizzard's
+-- own MAX_MACROS is no help either: it lives in the load-on-demand Blizzard_MacroUI
+-- and is nil until the player opens the macro window.
+CleveRoids.MAX_MACRO_SLOTS = 36
+
 -- Environment flags
 CleveRoids.hasSuperwow = SetAutoloot and true or false
 CleveRoids.hasTurtle   = (type(_G.TURTLE_WOW_VERSION) ~= "nil")
 CleveRoids.supported   = CleveRoids.hasTurtle
 
+-- ClassicAPI macro display (C_Macro.SetMacroDisplay): hand ClassicAPI the resolved
+-- action per macro instead of replacing the action-bar globals in Lua, so the icon,
+-- tooltip, cooldown sweep, range and usable state all come from the client -- including
+-- the drag cursor and the macro window grid, which Lua cannot reach.
+--
+-- ClassicAPI stands down from macro display entirely when it sees this addon loaded;
+-- ClassicAPIMacroDisplay is what tells it we drive it instead, and ReleaseDisplays
+-- clears it to hand every macro back. A fork that leaves the flag unset keeps the old
+-- behavior -- both must never drive the same buttons. It doubles as the internal
+-- "may we call C_Macro.SetMacroDisplay" guard, so the two can never disagree.
+--
+-- Feature-detect rather than version-check: SetMacroDisplay ships in ClassicAPI
+-- v1.15.0, below this addon's minimum, so a nil here means the client mod is
+-- missing outright -- the case Core.lua's requirement check warns about but
+-- keeps running.
+CleveRoids.ClassicAPIMacroDisplay =
+    (type(C_Macro) == "table" and C_Macro.SetMacroDisplay ~= nil) and true or false
+
 CleveRoids.ParsedMsg = {}
+CleveRoids.ExpandedGroups = {}
 CleveRoids.Items     = {}
 CleveRoids.Spells    = {}
 CleveRoids.PetSpells = {}
@@ -43,13 +71,11 @@ CleveRoids.unknownTexture = "Interface\\Icons\\INV_Misc_QuestionMark"
 
 CleveRoids.spell_tracking = {}
 
--- GUID-based cast tracking (populated by pfUI 7.6 or standalone SPELL_START events)
--- Format: [casterGuid] = {spellID, spellName, icon, startTime, duration, endTime}
+-- GUID-based cast tracking, populated from our own SPELL_START handlers and pruned
+-- in OnUpdate. Format: [casterGuid] = {spellID, spellName, icon, startTime, duration,
+-- endTime}
 CleveRoids.castTracking = {}
 
--- pfUI 7.6+ with Nampower 2.31.0+ detected (GUID-based cast tracking available)
-CleveRoids.hasPfUI76 = false
-
 -- Combo point tracking (initialized early for /cast hook)
 CleveRoids.lastComboPoints = 0
 CleveRoids.lastComboPointsTime = 0
@@ -124,6 +150,7 @@ CleveRoids.dynamicCmds = {
     ["/castpet"]      = true,
     ["/castsequence"] = true,
     ["/use"]          = true,
+    ["/feedpet"]      = true,
     ["/equip"]        = true,
     ["/equipmh"]      = true,
     ["/equipoh"]      = true,
@@ -186,11 +213,19 @@ CleveRoids.ignoreKeywords = {
     _operators    = true,  -- Metadata for AND/OR operator tracking
     _groups       = true,  -- Grouped conditional values for AND/OR evaluation
     multiscan     = true,  -- Processed before Keywords loop (target resolution)
-    mouseuse      = true,  -- Post-cast modifier: auto-click AOE targeting circle at cursor
     cursor        = true,  -- Modifier: place ground-target spell/item at cursor (CastAtCursor)
     stopattack    = true,  -- Post-cast modifier: stop autoattack after cast (CheapShot pattern)
 }
 
+-- Deprecated conditional names, rewritten to their current keyword in ParseMsg
+-- before anything downstream (evaluation, _groups) sees them. This is the path
+-- for renamed *modifiers* -- ignoreKeywords entries, which have no Keywords
+-- predicate that an alias could just point at the way [stl] does for [stealth].
+-- MacroErrorChecker also reads this table, so the old names stay valid syntax.
+CleveRoids.conditionalAliases = {
+    mouseuse = "cursor",  -- pre-ClassicAPI name, back when it clicked the AoE reticle
+}
+
 -- TODO: Localize?
 CleveRoids.countedItemTypes = {
     ["Consumable"]  = true,

MacroErrorChecker.lua

@@ -35,6 +35,14 @@ if CleveRoids.ignoreKeywords then
     end
 end
 
+-- Deprecated names still valid in macros; ParseMsg rewrites them to the current
+-- keyword, so they never reach Keywords/ignoreKeywords under their old name.
+if CleveRoids.conditionalAliases then
+    for alias, _ in pairs(CleveRoids.conditionalAliases) do
+        VALID_CONDITIONALS[alias] = true
+    end
+end
+
 -- Known valid commands
 local VALID_COMMANDS = {
     -- Core commands NOT registered via SlashCmdList (so not auto-discoverable):
@@ -498,6 +506,7 @@ local COMMANDS_NO_ACTION_NEEDED = {
     ["/startattack"] = true,
     ["/stopattack"] = true,
     ["/stopcasting"] = true,
+    ["/stopchanneling"] = true,
     ["/unqueue"] = true,
     ["/retarget"] = true,
     ["/stopmacro"] = true,
@@ -552,7 +561,6 @@ end
 local ERROR_TYPES = {
     INVALID_CONDITIONAL = "Invalid conditional",
     MISMATCHED_BRACKETS = "Mismatched brackets",
-    EMPTY_CONDITIONAL = "Empty conditional block",
     INVALID_OPERATOR = "Invalid operator",
     MISSING_ARGUMENT = "Missing argument",
     INVALID_COMMAND = "Unknown command",
@@ -651,6 +659,8 @@ local function validateConditional(conditional, args, action)
         combo = true,
         hp = true, myhp = true, rawhp = true, myrawhp = true,
         power = true, mypower = true, rawpower = true, myrawpower = true,
+        mana = true, mymana = true, rage = true, myrage = true,
+        energy = true, myenergy = true,
         hplost = true, myhplost = true,
         powerlost = true, mypowerlost = true,
         stat = true,
@@ -659,6 +669,7 @@ local function validateConditional(conditional, args, action)
         button = true,
         form = true, stance = true,
         level = true, mylevel = true,
+        myspellhaste = true,
         distance = true, nodistance = true,
         swingtimer = true, stimer = true,
         rangedtimer = true, rtimer = true,
@@ -678,6 +689,8 @@ local function validateConditional(conditional, args, action)
     -- Check operator syntax for numeric comparisons
     if args and type(args) == "string" then
         local hasHpOrPower = safeStringFind(baseCond, "hp") or safeStringFind(baseCond, "power") or
+                            safeStringFind(baseCond, "mana") or safeStringFind(baseCond, "energy") or
+                            safeStringFind(baseCond, "rage") or safeStringFind(baseCond, "haste") or
                             safeStringFind(baseCond, "combo") or baseCond == "stat"
         if hasHpOrPower then
             local hasOperator = safeStringFind(args, "[<>=~]+")
@@ -835,16 +848,19 @@ local function validateLine(line, lineNum)
                 actionPart = "/" .. actionPart  -- Add leading slash if missing after split
             end
 
-            -- Parse conditionals if present - use non-greedy match
-            local condStart = safeStringFind(actionPart, "%[")
+            -- Parse the leading run of [conditional] blocks, if any. `[a][b] X` is
+            -- Blizzard-style OR chaining: every block is validated, and the action
+            -- is what follows the last one.
+            local blocks = {}
             local condEnd = nil
-            local conditionBlock = nil
+            local condStart = safeStringFind(actionPart, "%[")
+            local len = safeStringLen(actionPart)
 
-            if condStart then
+            while condStart do
                 -- Find matching closing bracket
                 local depth = 0
                 local inQuotes = false
-                local len = safeStringLen(actionPart)
+                local closePos = nil
 
                 for i = condStart, len do
                     local char = safeStringSub(actionPart, i, i)
@@ -858,23 +874,30 @@ local function validateLine(line, lineNum)
                         elseif char == "]" then
                             depth = depth - 1
                             if depth == 0 then
-                                condEnd = i
-                                conditionBlock = safeStringSub(actionPart, condStart + 1, i - 1)
+                                closePos = i
                                 break
                             end
                         end
                     end
                 end
+                if not closePos then break end
+
+                table.insert(blocks, safeStringSub(actionPart, condStart + 1, closePos - 1))
+                condEnd = closePos
+
+                -- Another block directly after this one (whitespace allowed)?
+                local _, wsEnd = safeStringFind(actionPart, "^%s*", closePos + 1)
+                local nextPos = (wsEnd or closePos) + 1
+                if safeStringSub(actionPart, nextPos, nextPos) == "[" then
+                    condStart = nextPos
+                else
+                    condStart = nil
+                end
             end
 
-            if conditionBlock then
-                if safeTrim(conditionBlock) == "" then
-                    table.insert(localErrors, {
-                        type = ERROR_TYPES.EMPTY_CONDITIONAL,
-                        line = lineNum,
-                        message = "Empty conditional block []"
-                    })
-                else
+            for _, conditionBlock in ipairs(blocks) do
+                -- `[]` is the always-true group; nothing to validate
+                if safeTrim(conditionBlock) ~= "" then
                     -- Check for invalid @ target syntax
                     local _, _, target = safeStringFind(conditionBlock, "(@[^%s,]+)")
                     if target and not safeStringFind(target, "^@[a-z]+%d*") then
@@ -922,7 +945,9 @@ local function validateLine(line, lineNum)
                         end
                     end
                 end
+            end
 
+            if condEnd then
                 -- Check for action after conditionals
                 -- Extract the command from this action part
                 local _, _, cmdFromAction = safeStringFind(actionPart, "^(/[a-z]+%d*)")
@@ -1071,17 +1096,7 @@ function CleveRoids.ValidateAllMacros()
     local results = {}
     local totalErrors = 0
 
-    -- Account-wide macros are indexed from 1 up to GetNumMacros().
-    -- Character-specific macros occupy the slots immediately following the account-wide ones.
-    -- In Classic clients, the macro UI has 18 General (Account) slots and 18 Character-Specific slots.
-    local numAccountMacros = GetNumMacros()
-
-    -- The WoW API GetMacroInfo(index) supports indexing up to 36 (1-18 for General, 19-36 for Character)
-    -- in Classic clients, even though the total is GetNumMacros() + GetNumCharacterMacros() in Retail.
-    -- To ensure we check all 36 possible slots:
-    local totalSlots = 36
-
-    for i = 1, totalSlots do
+    for i = 1, CleveRoids.MAX_MACRO_SLOTS do
         local nameSuccess, name = pcall(GetMacroInfo, i)
 
         -- Check if GetMacroInfo returned a name (i.e., the slot is used)

NampowerAPI.lua

@@ -71,7 +71,6 @@
 
     Spell Miss Events (v2.31+):
     - SPELL_MISS_SELF / SPELL_MISS_OTHER - Spell miss/resist/immune/dodge/etc.
-    - GetSpellPower([mode]) - Player mod damage done for all 7 schools
 
     Aura Event State Parameter (v2.32+):
     - Buff/debuff events include 7th `state` parameter (0=added, 1=removed, 2=modified)
@@ -364,9 +363,8 @@ API.VERSION_REQUIREMENTS = {
     ["AuraDurationEvents"]      = { 2, 30, 0 },
     ["GetPlayerAuraDuration"]   = { 2, 30, 0, "GetPlayerAuraDuration" },
 
-    -- v2.31+ - Spell miss events and spell power query
+    -- v2.31+ - Spell miss events
     ["SpellMissEvents"]         = { 2, 31, 0 },  -- SPELL_MISS_SELF/OTHER events
-    ["GetSpellPower"]           = { 2, 31, 0, "GetSpellPower" },
 
     -- v2.32+ - Aura event state parameter and stack removal fix
     ["AuraEventState"]          = { 2, 32, 0 },
@@ -575,9 +573,8 @@ local function InitializeFeatures()
     f.hasAuraDurationEvents = API.HasFeature("AuraDurationEvents")
     f.hasGetPlayerAuraDuration = API.HasFeature("GetPlayerAuraDuration")
 
-    -- v2.31+ Spell miss events and spell power
+    -- v2.31+ Spell miss events
     f.hasSpellMissEvents = API.HasFeature("SpellMissEvents")
-    f.hasGetSpellPower = API.HasFeature("GetSpellPower")
 
     -- v2.32+ Aura event state parameter
     f.hasAuraEventState = API.HasFeature("AuraEventState")
@@ -1477,7 +1474,7 @@ end
 
 -- Get all equipped items for a unit
 -- Requires v2.18+ for native GetEquippedItems (with Lua fallback for player only)
--- Returns table with slot indices (0-18) as keys, item info tables as values
+-- Returns table with slot indices (1-19) as keys, item info tables as values
 function API.GetEquippedItems(unitToken)
     unitToken = unitToken or "player"
 
@@ -1492,8 +1489,8 @@ function API.GetEquippedItems(unitToken)
     end
 
     local items = {}
-    for slot = 0, 18 do
-        local itemId = CleveRoids.ClassicAPI.GetInventoryItemID("player", slot + 1)
+    for slot = 1, 19 do
+        local itemId = CleveRoids.ClassicAPI.GetInventoryItemID("player", slot)
         if itemId then
             items[slot] = {
                 itemId = itemId,
@@ -1521,7 +1518,7 @@ function API.GetEquippedItem(unitToken, slot)
         return nil
     end
 
-    local itemId = CleveRoids.ClassicAPI.GetInventoryItemID("player", slot + 1)  -- 1-indexed
+    local itemId = CleveRoids.ClassicAPI.GetInventoryItemID("player", slot)  -- both are 1-indexed
     if itemId then
         return {
             itemId = itemId,
@@ -1675,7 +1672,7 @@ function API.IsItemInSlot(itemIdOrName, inventorySlot)
 
     -- Use native v2.18 GetEquippedItem if available
     if GetEquippedItem then
-        local slotInfo = GetEquippedItem("player", inventorySlot - 1)  -- 0-indexed
+        local slotInfo = GetEquippedItem("player", inventorySlot) -- 1-indexed (1-19)
         if slotInfo and slotInfo.itemId then
             local checkId = tonumber(itemIdOrName)
             if checkId then
@@ -3387,15 +3384,6 @@ API.MISS_INFO = {
 -- SPELL POWER QUERY (v2.31+)
 --------------------------------------------------------------------------------
 
--- Get spell power for all 7 damage schools (v2.31+)
--- mode: optional mode parameter passed to GetSpellPower
--- Returns: physical, holy, fire, nature, frost, shadow, arcane (or nil if unavailable)
-function API.GetSpellPower(mode)
-    if not API.features.hasGetSpellPower or not _G.GetSpellPower then
-        return nil, nil, nil, nil, nil, nil, nil
-    end
-    return _G.GetSpellPower(mode)
-end
 
 -- Get duration of a spell in milliseconds (v2.38+)
 -- For channeling spells: returns the channel duration.
@@ -3504,32 +3492,5 @@ function API.GetUnitMaxHealth(unitToken)
     return UnitHealthMax(unitToken)
 end
 
--- powerType: nil=current, 0=mana, 1=rage, 2=focus, 3=energy
--- GetUnitField uses power1-power4 fields
-local POWER_FIELDS = { [0] = "power1", [1] = "power2", [2] = "power3", [3] = "power4" }
-local MAX_POWER_FIELDS = { [0] = "maxPower1", [1] = "maxPower2", [2] = "maxPower3", [3] = "maxPower4" }
-
-function API.GetUnitPower(unitToken, powerType)
-    if API.features.hasGetUnitField and GetUnitField and powerType then
-        local field = POWER_FIELDS[powerType]
-        if field then
-            local val = GetUnitField(unitToken, field)
-            if val then return val end
-        end
-    end
-    return UnitMana(unitToken)
-end
-
-function API.GetUnitMaxPower(unitToken, powerType)
-    if API.features.hasGetUnitField and GetUnitField and powerType then
-        local field = MAX_POWER_FIELDS[powerType]
-        if field then
-            local val = GetUnitField(unitToken, field)
-            if val then return val end
-        end
-    end
-    return UnitManaMax(unitToken)
-end
-
 -- Expose API globally for other addons
 _G.CleveRoidsNampowerAPI = API

README.md

@@ -10,7 +10,7 @@ Enhanced macro addon for World of Warcraft 1.12.1 (Vanilla/Turtle WoW) with dyna
 |-----|:--------:|---------|
 | [Nampower](https://github.com/brues-code/nampower/releases) (v3.0.0+) | ✅ | Spell queueing, DBC data, auto-attack events |
 | [UnitXP_SP3](https://codeberg.org/konaka/UnitXP_SP3/releases) | ✅ | Distance checks, `[multiscan]` enemy scanning |
-| [ClassicAPI](https://github.com/brues-code/ClassicAPI/releases) | ✅ | Modern `C_*` API: dispel-type conditionals (`[magic]`, `[curse]`, …), `[moving]` speed |
+| [ClassicAPI](https://github.com/brues-code/ClassicAPI/releases) (v1.15.8+) | ✅ | Modern `C_*` API: dispel-type conditionals (`[magic]`, `[curse]`, …), `[moving]` speed, unit-filtered events |
 
 ## Installation
 
@@ -27,6 +27,7 @@ Enhanced macro addon for World of Warcraft 1.12.1 (Vanilla/Turtle WoW) with dyna
 - **Arguments** use colon: `[mod:alt]`, `[hp:>50]`
 - **Negation** with `no` prefix: `[nobuff]`, `[nomod:alt]`
 - **Target** with `@`: `[@mouseover,help]`, `[@party1,hp:<50]`
+- **Fallback groups**, Blizzard-style: `[@mouseover,help][@focus,help][] Rejuvenation` tries each `[...]` in order and the first that passes casts the shared spell; `[]` always passes. Mixes freely with `;`
 - **Spell names** with spaces: `"Mark of the Wild"` or `Mark_of_the_Wild`
 
 **Multi-value logic:**
@@ -46,7 +47,7 @@ See the **[Wiki](https://github.com/brues-code/SuperCleveRoidMacros/wiki)** for
 
 - **[Quick Start](https://github.com/brues-code/SuperCleveRoidMacros/wiki/Quick-Start)** — Syntax, multi-value logic, comparisons, special prefixes
 - **[Slash Commands](https://github.com/brues-code/SuperCleveRoidMacros/wiki/Slash-Commands)** — All 35+ commands, priority macros, UnitXP scanning
-- **[Conditionals](https://github.com/brues-code/SuperCleveRoidMacros/wiki/Conditionals)** — 70+ conditionals (player & target), extended unit tokens, multiscan
+- **[Conditionals](https://github.com/brues-code/SuperCleveRoidMacros/wiki/Conditionals)** — 150+ conditionals (player & target), short aliases, extended unit tokens, multiscan
 - **[Reference Tables](https://github.com/brues-code/SuperCleveRoidMacros/wiki/Reference-Tables)** — CC types, damage schools, stat types, swing types
 - **[Features](https://github.com/brues-code/SuperCleveRoidMacros/wiki/Features)** — Debuff timers, combo tracking, talent modifiers, TWoW mechanics
 - **[Overflow Buff Frame](https://github.com/brues-code/SuperCleveRoidMacros/wiki/Overflow-Buff-Frame)** — Hidden buff display for 32+ buffs

SuperCleveRoidMacros.toc

@@ -5,6 +5,7 @@
 ## Version: @project-version@
 ## OptionalDeps: ClassicFocus, FocusFrame, pfUI, SuperMacro, Bongos_ActionBar, Cursive, XPerl, LunaUnitFrames, DragonflightReloaded, -Dragonflight3
 ## SavedVariables: CleveRoidMacros, CleveRoids_LearnedDurations, CleveRoids_AuraTextures, CleveRoids_ImmunityData, CleveRoids_ComboDurations, CleveRoids_SpellSchools
+## LoadSavedVariablesFirst: 1
 Localization.lua
 Init.lua
 NampowerAPI.lua

docs/CC-IMMUNITY-DR.md

@@ -0,0 +1,188 @@
+# CC, Learned Immunity and Diminishing Returns
+
+How SuperCleveRoidMacros classifies crowd control, what it learns about NPC
+immunity, and why diminishing returns only ever acts as a brake on that
+learning. Source citations are into `C:\Git\vmangos` and `C:\Git\nampower`.
+
+## Three identities, never conflated
+
+```text
+ccType          Exact DBC mechanic. Backs [cc:*] and CC landing verification.
+                Conditionals.lua, CleveRoids.CCMechanics
+
+immunityType    Exact DBC mechanic, recorded against an NPC name when a CC
+                spell comes back IMMUNE.
+                Utility.lua, MECHANIC_TO_IMMUNITY_TYPE / GetSpellImmunityType
+
+DR type         The real Vanilla diminishing-return pool. Internal only.
+                Utility.lua, GetSpellImmunityDRType
+```
+
+The first two are the same taxonomy used for different purposes; the third is
+a separate axis and is never exposed to macros. Folding any pair together is
+what produced the bugs this design replaces: a target that resisted Gouge got
+written down as stun-immune, and every later Kidney Shot was suppressed
+against a target that had never resisted one.
+
+## `[cc:*]` follows the DBC mechanic exactly
+
+One conditional, one mechanic. Several names may alias a single mechanic, but
+no name spans two:
+
+```text
+[cc:stun]      -> mechanic 12 only
+[cc:freeze]    -> mechanic 13 only
+[cc:knockout]  -> mechanic 14 only
+[cc:sap]       -> mechanic 30 only
+[cc:daze]      -> mechanic 27 only
+```
+
+Bare `[cc]` and `[cc:any]` still mean "any loss-of-control effect" and are
+driven by `CleveRoids.CCTypesLossOfControl`, which is deliberately independent
+of the per-mechanic table. An aggregate does not require redefining the parts.
+
+Current aliases:
+
+```text
+slow                                  -> snare
+disoriented                           -> disorient
+grip                                  -> fumble    (mechanic 6 is DBC Fumble)
+incap / incapacitate / incapacitated  -> knockout  (immunity input only)
+```
+
+Aliases exist so published macros keep working. They resolve to the canonical
+mechanic name before anything is stored, so SavedVariables only ever hold
+canonical keys.
+
+## Vanilla DBC mechanic taxonomy
+
+The identities SCRM names. Where a mechanic is named at all, it is named as
+itself:
+
+| DBC mechanic | ID | Canonical `ccType` |
+|---|---:|---|
+| Charm | 1 | `charm` |
+| Disoriented | 2 | `disorient` |
+| Disarm | 3 | `disarm` |
+| Distract | 4 | `distract` |
+| Fear | 5 | `fear` |
+| Fumble | 6 | `fumble` |
+| Root | 7 | `root` |
+| Pacify | 8 | `pacify` |
+| Silence | 9 | `silence` |
+| Sleep | 10 | `sleep` |
+| Snare | 11 | `snare` |
+| Stun | 12 | `stun` |
+| Freeze | 13 | `freeze` |
+| Knockout | 14 | `knockout` |
+| Bleed | 15 | `bleed` |
+| Polymorph | 17 | `polymorph` |
+| Banish | 18 | `banish` |
+| Shackle | 20 | `shackle` |
+| Turn | 23 | `turn` |
+| Horror | 24 | `horror` |
+| Interrupt | 26 | `interrupt` |
+| Daze | 27 | `daze` |
+| Sapped | 30 | `sap` |
+
+Mechanics 16, 19, 21, 22, 25, 28 and 29 (Bandage, Shield, Mount, Persuade,
+Invulnerability, Discovery, Immune Shield) are real DBC values but are not
+crowd control, so they get no conditional.
+
+## Diminishing returns
+
+DR matters here for exactly one reason: a target at DR level 4 returns
+`IMMUNE`, and that must not be recorded as permanent immunity. Nothing else in
+the addon consumes DR state, and there is no player-facing DR feature.
+
+### Only three pools can diminish a creature
+
+`GetDiminishingReturnsGroupType` in
+`vmangos/src/game/Spells/SpellEntry.h:52-79` returns `DRTYPE_ALL` for exactly
+three groups:
+
+```text
+DIMINISHING_CONTROL_STUN
+DIMINISHING_TRIGGER_STUN
+DIMINISHING_KIDNEYSHOT
+```
+
+Every other staged group — sleep, both roots, fear, Warlock fear, charm,
+polymorph, silence, disarm, Death Coil, freeze, banish, knockout — is
+`DRTYPE_PLAYER`, and `Unit.cpp:7881` applies those only when the victim is a
+player. So on an NPC target they can never generate a DR immunity, and they
+must never hold back immunity learning.
+
+This is why `GetSpellImmunityDRType` returns nil for everything that is not
+mechanic 12. It is not an approximation; it is the complete `DRTYPE_ALL` set.
+
+### Classifying a stun into its pool
+
+`SpellEntry::GetDiminishingReturnsGroup(bool triggered)`
+(`vmangos/src/game/Spells/SpellEntry.cpp:281-432`) resolves the pool, and the
+`triggered` argument means the runtime fact of whether an aura triggered the
+cast — this is not a pure DBC property. SCRM reconstructs it from nampower
+`SPELL_CAST_EVENT` correlation, which only fires for client-initiated casts:
+a spell ID with a recent `CleveRoids.pendingCasts` entry was cast deliberately,
+one without reached `SPELL_GO`/`SPELL_MISS` as a proc.
+
+```text
+Kidney Shot                    -> stun_kidneyshot
+Charge / Intercept stun        -> stun_control
+other mechanic-12, client cast -> stun_control
+other mechanic-12, proc        -> stun_trigger
+```
+
+Kidney Shot is matched on rogue family bit 21 (`0x00200000`,
+`SpellClassMask.h:228`) rather than a bare ID list, so custom ranks that keep
+their DBC family data still classify correctly. Charge (7922) and Intercept
+(20253, 20614, 20615) are internally triggered but explicitly returned as
+controlled stun by `SpellEntry.cpp:389-399`; they are the only such exceptions
+in 1.12.
+
+### Pools that exist but do not apply
+
+Recorded so nobody re-adds them to the safeguard. Knockout and Sap are
+distinct mechanics that share `DIMINISHING_KNOCKOUT`
+(`SpellEntry.cpp:424-425`), and Horror maps to `DIMINISHING_DEATHCOIL`
+(`SpellEntry.cpp:428-429`). Both are `DRTYPE_PLAYER`. `DIMINISHING_LIMITONLY`
+is a PvP duration cap rather than a staged pool, and `DIMINISHING_NONE` is not
+a pool at all.
+
+### The safeguard itself
+
+`recentCCHits[targetGUID][drType]` counts landed CC per DR pool, so the three
+stun pools keep separate histories. A hit more than `DR_RESET_WINDOW` (20s)
+after the previous one in that pool restarts the count at 1, matching the DR
+decay the skip check uses. Without that reset the counter only ever climbed,
+so three stuns on a target permanently disqualified it from ever teaching the
+addon anything again.
+
+An `IMMUNE` result is treated as DR, and discarded, only while the pool holds
+three or more hits inside the window. Otherwise it is learned.
+
+## nampower `SPELL_MISS` arguments
+
+`TriggerSpellMissEvent` (`nampower/spellevents.cpp:888-917`) signals both
+`SPELL_MISS_SELF` and `SPELL_MISS_OTHER` with the same layout:
+
+```text
+arg1 = casterGuid   arg2 = targetGuid   arg3 = spellId   arg4 = missInfo
+```
+
+`SPELL_MISS_SELF` carries `casterGuid` too, even though it is by definition
+the player — the event is chosen by comparing the caster to the active player
+GUID, not by changing the payload. Reading `arg1` as the spell ID hands a GUID
+string to the immunity recorder and silently loses every miss.
+
+## Known limitation: mouseover casts
+
+`ProcessSpellMissSelf` refuses to learn permanent immunity when it cannot
+resolve a queryable unit, because the temporary-immunity-buff check needs one
+— an NPC under Divine Shield must not be recorded as permanently immune. A CC
+cast at a mouseover that is not the current target can therefore return
+`IMMUNE` without being learned.
+
+This is the safeguard working as designed, not a known bug. Do not loosen it
+without a reproduction showing a real failure, since the failure mode on the
+other side is permanent bad data in `CleveRoids_ImmunityData`.

docs/CLASSICAPI-TODO.md

@@ -25,10 +25,23 @@ API references are line numbers into `C:\Git\ClassicAPI\docs\API.md`.
   `applications` (stacks), `duration`.
 - **Unlocks:** `[dispellable]` / `[curse]` / `[magic]` target conditionals and
   spellID-based (rank/locale-proof) aura matching.
-- **Caveat:** `expirationTime` is only populated for `unit=="player"`; it's `0`
-  for target/focus (vanilla server limitation). Target debuff *timers* still
-  need the existing libdebuff tracking — only presence/stacks/school/spellId
-  are reliable cross-unit.
+- **~~Caveat: `expirationTime` is player-only~~ — NO LONGER TRUE.** This note said
+  target/focus `expirationTime` was always `0`, so debuff *timers* had to stay on
+  libdebuff. ClassicAPI has since added the `Aura::Source` cache: for a non-player
+  unit `expirationTime` is reconstructed from the observed `SMSG_SPELL_GO`, and
+  `duration` is the **caster-modified** value (talent extensions like Improved
+  Shadow Word: Pain included). It also handles combo-point finisher scaling
+  automatically (Rupture at 4 CP reads 14s, no registration) and ships Carnage's
+  roll-gated Rip/Rake refresh in the DLL (`src/turtle/Carnage.cpp`, exposed as
+  `RegisterAuraDurationModifierByTrigger`).
+- **Real remaining caveats** (all best-effort, from `docs/API.md`):
+  - Only auras observed *after login* carry caster/timing; older ones report
+    `expirationTime` 0 and `sourceUnit` nil.
+  - Max-stack refresh is a blind spot: re-applying at max stacks (Shadow Weaving
+    5→5) emits no client-visible change, so the entry elapses and evicts.
+  - Out-of-range group members are spell-ID only, with `applications` always 1.
+- **Consequence:** most of libdebuff is now redundant — see
+  "libdebuff retirement" below.
 
 - **DONE (slice 1 — dispel-type conditionals):** added `ClassicAPI.lua`
   detection module (`CleveRoids.ClassicAPI`, mirrors NampowerAPI's
@@ -49,16 +62,15 @@ API references are line numbers into `C:\Git\ClassicAPI\docs\API.md`.
   - class-aware `[dispellable]` (only types this character can actually remove).
   - optional name filtering on the type keywords (e.g. `[magic:Polymorph]`).
 
-### 2. `C_Item.GetWeaponEnchantInfo()` — temp-enchant IDs
-- **API:** `API.md:7159` — returns 12-tuple including `enchantID` for main/off/ranged.
-- **Unlocks:** detect *which* temp enchant (poison/oil/sharpening stone) is
-  applied to a weapon, not just that one exists.
-- **Naming:** `[poison]` is now taken by the target dispel-type conditional
-  (slice 1 above). Use weapon-specific keywords for this — e.g.
-  `[mhenchant:<id>]` / `[ohenchant:<id>]` (or `[mhpoison:<id>]`/`[ohpoison:<id>]`),
-  not a bare `[poison]`.
-- Vanilla's global only reports presence; this is a genuinely new capability
-  (rogue/shaman/enhance).
+### 2. ~~`C_Item.GetWeaponEnchantInfo()` — temp-enchant IDs~~ — DONE
+- Shipped as `[mhenchant]` / `[ohenchant]` (+ `no` variants). Matches the applied
+  temp enchant by SpellItemEnchantment ID *or* localized name — the name path
+  resolves via `C_Item.GetEnchantInfo(id).name` (the ID→name table this doc
+  assumed we lacked), so no tooltip scan. Wrappers `ClassicAPI.GetWeaponEnchant`
+  / `GetEnchantName`; `ValidateWeaponImbue` now reads through the former.
+- Bare = any temp enchant; OR-lists supported (`[mhenchant:2823/Deadly_Poison]`).
+- Follow-up (optional): route `[mhimbue:Name]`'s match through `GetEnchantName`
+  too, retiring the green-text tooltip scan in `CheckWeaponImbueByName`.
 
 ### 3. `GetUnitSpeed(unit)` + `IsFalling()` / `IsSwimming()`
 - **API:** `API.md:8312`, `API.md:7629`.
@@ -151,11 +163,13 @@ Findings from the full Conditionals.lua audit. These look like ClassicAPI
 candidates but are **worse** than the current implementation — recorded so we
 don't re-investigate.
 
-- **Auras / `ValidateAura`** — `C_UnitAuras.expirationTime` is **player-only**
-  (`0` for every other unit). It cannot replace the nampower `GetUnitField`
-  batch read or the remote-duration tracking (libdebuff / overflow slots). The
-  dispel-*type* path already uses `C_UnitAuras` (that's the one thing it's good
-  for); aura *timing/stacks* on non-player units must stay on nampower/libdebuff.
+- ~~**Auras / `ValidateAura`** — `C_UnitAuras.expirationTime` is player-only~~ —
+  **STALE, do not trust this entry.** It was written before the `Aura::Source`
+  cache landed. Non-player `expirationTime`/`duration` now work (caster-modified,
+  talent extensions included), so this is no longer a reason to keep libdebuff's
+  remote-duration tracking. See Tier 1 §1 and "libdebuff retirement" for the
+  current picture and the real caveats. The nampower `GetUnitField` batch read is
+  a separate question and has not been re-examined.
 - **`GetCurrentShapeshiftIndex` form loop / `[stance]`·`[form]`** —
   `GetShapeshiftFormID()` returns the **DBC form id** (Cat=1, Bear=5,
   Shadowform=28…), NOT the 1-based **bar index** these conditionals compare
@@ -184,6 +198,39 @@ don't re-investigate.
   added `[focus]`/`[nofocus]`. `/focus` is provided by ClassicAPI's companion
   addon.
 
+## libdebuff retirement
+
+libdebuff exists because vanilla cannot report debuff durations on units other
+than the player. ClassicAPI's `Aura::Source` cache now does exactly that, so most
+of the library is redundant. This is a staged replacement, not a delete: measure
+first, then remove per group.
+
+Current footprint: 28 public `lib:` methods, ~726 internal references in
+`Utility.lua`, consumers in 8 files (`Conditionals.lua` 45, `Compatibility/pfUI.lua`
+39, `Core.lua` 9). Note pfUI did **not** delete its own libdebuff — v9.0.25 still
+ships ~1695 lines of it, re-based on `C_UnitAuras.GetAuraDataByIndex` /
+`GetAuraDataBySpellName`. "Re-base on C_UnitAuras", not "remove", is the precedent.
+
+**Group A — replaceable by `C_UnitAuras` (do these first):**
+`GetDuration`, `GetDebuffCaster`, `IsOurDebuff`, `UnitBuff`/`UnitDebuff`,
+`FindPlayerDebuff`/`FindPlayerBuff`, `GetAllDebuffsOnTarget`, `GetCachedIcon`,
+`ApplyCarnageRefresh`, and the Dark Harvest trio (`ApplyDarkHarvestStart`/`End`,
+`GetDarkHarvestReduction`, `GetTimeRemainingWithDarkHarvest`) — ClassicAPI ships
+Carnage refresh and Dark Harvest tick compression in the DLL.
+
+**Group B — no `C_UnitAuras` equivalent, keep:**
+`ShouldApplyDebuffRank`, `DidSpellFail`, `WasSpellReflected`, `DidTargetEvade`,
+`ProcessMissReason`, `IsPersonalDebuff`, `GetSpellRank`/`GetSpellBaseName`,
+`HasPendingCast`. These are miss/rank/learning logic, not aura state.
+
+**Gate before removing Group A:** confirm parity in-game on one spell where
+ClassicAPI does the hard part — Rip under Carnage. Compare
+`CleveRoids.libdebuff:GetDuration(spellID)` against
+`C_UnitAuras.GetUnitAuraBySpellID(unit, spellID).duration` and the derived
+remaining (`expirationTime - GetTime()`), on a target you have debuffed. If those
+agree across a Carnage proc, Group A can go. Watch the documented best-effort
+gaps: an aura cast before you logged in, and refresh-at-max-stacks.
+
 ## Marginal / optional follow-ups
 
 - **`[swimming]`** → `IsSwimming()` would drop the nampower-2.36 version gate +