diff --git a/Media/Bar.blp b/Media/Bar.blp
new file mode 100644
index 0000000..b0ae8b1
Binary files /dev/null and b/Media/Bar.blp differ
diff --git a/Media/BarBG.blp b/Media/BarBG.blp
new file mode 100644
index 0000000..b0ae8b1
Binary files /dev/null and b/Media/BarBG.blp differ
diff --git a/Media/Glow.blp b/Media/Glow.blp
new file mode 100644
index 0000000..1bffc0b
Binary files /dev/null and b/Media/Glow.blp differ
diff --git a/Media/ShadowBorder.blp b/Media/ShadowBorder.blp
new file mode 100644
index 0000000..1bffc0b
Binary files /dev/null and b/Media/ShadowBorder.blp differ
diff --git a/Media/Spark.blp b/Media/Spark.blp
new file mode 100644
index 0000000..2d7a8bc
Binary files /dev/null and b/Media/Spark.blp differ
diff --git a/ThreatPlates.toc b/ThreatPlates.toc
new file mode 100644
index 0000000..a5835b1
--- /dev/null
+++ b/ThreatPlates.toc
@@ -0,0 +1,16 @@
+----------------------------------------------------------------------
+-- ThreatPlates
+-- Threat percentage bars above nameplates
+-- Styled after Kui Nameplates
+-- Standalone - no dependencies required
+----------------------------------------------------------------------
+## Interface: 11200
+## Title: ThreatPlates
+## Title-zhCN: 威胁姓名板
+## Notes: Displays threat percentage bars above nameplates with Kui-style visuals
+## Notes-zhCN: 在姓名板上方显示威胁百分比条
+## Author: Relationship
+## Version: 2.3.2
+## SavedVariables: ThreatPlatesDB
+
+ThreatPlates.xml
diff --git a/ThreatPlates.xml b/ThreatPlates.xml
new file mode 100644
index 0000000..7b59c8b
--- /dev/null
+++ b/ThreatPlates.xml
@@ -0,0 +1,8 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/">
+    <Script file="ThreatPlates_Core.lua"/>
+    <Script file="ThreatPlates_Media.lua"/>
+    <Script file="ThreatPlates_ThreatEngine.lua"/>
+    <Script file="ThreatPlates_Threat.lua"/>
+    <Script file="ThreatPlates_Nameplates.lua"/>
+    <Script file="ThreatPlates_GUI.lua"/>
+</Ui>
diff --git a/ThreatPlates_Core.lua b/ThreatPlates_Core.lua
new file mode 100644
index 0000000..d3318fa
--- /dev/null
+++ b/ThreatPlates_Core.lua
@@ -0,0 +1,177 @@
+----------------------------------------------------------------------
+-- ThreatPlates_Core.lua
+-- Core addon initialization, saved variables, slash commands
+-- Compatible with WoW 1.12 (Vanilla / Turtle WoW / Octo WoW)
+----------------------------------------------------------------------
+
+-- Create the global addon object
+ThreatPlates = CreateFrame("Frame")
+
+local addon = ThreatPlates
+addon.MAJOR = 1
+addon.MINOR = 1
+
+-- Version string
+TP_VERSION = "2.3.1"
+TP_ADDON_NAME = "ThreatPlates"
+
+-- ==================================================================
+-- Default configuration
+-- ==================================================================
+local DEFAULT_CONFIG = {
+    enabled         = true,
+    showText        = true,
+    barHeight       = 6,
+    barAlpha        = 0.5,
+    barOffsetY      = 1,
+    barOffsetX      = -17.8,
+    barWidthScale   = 0.8,
+    fontSize        = 9,
+    fontOutline     = true,
+    smoothColors    = true,
+    showOnFriendly  = false,
+    showOnNeutral   = true,
+    showOnHostile   = true,
+    showSpark       = false,
+    showFillBG      = true,
+    fillAlpha       = 0.1,
+    glowEnabled     = false,
+    glowSize        = 3,
+    glowAsShadow    = true,
+    guiPos = {
+        point    = "CENTER",
+        relPoint = "CENTER",
+        x        = 0,
+        y        = 0,
+    },
+}
+
+-- ==================================================================
+-- Safe UnitGUID wrapper - UnitGUID does not exist in Vanilla 1.12
+-- Returns nil on vanilla clients, falls back to unit name
+-- ==================================================================
+function addon:SafeGUID(unit)
+    if UnitGUID then
+        local ok, guid = pcall(UnitGUID, unit)
+        if ok and guid then return guid end
+    end
+    return nil
+end
+
+-- ==================================================================
+-- Get a unique identifier for a unit (GUID or name)
+-- In vanilla 1.12, UnitGUID does not exist, so we use unit name
+-- ==================================================================
+function addon:GetUnitID(unit)
+    if not unit then return nil end
+    local guid = addon:SafeGUID(unit)
+    if guid then return guid end
+    local ok, name = pcall(UnitName, unit)
+    if ok and name then return name end
+    return nil
+end
+
+-- ==================================================================
+-- Print helper
+-- ==================================================================
+function addon:ui_print(msg)
+    if DEFAULT_CHAT_FRAME then
+        DEFAULT_CHAT_FRAME:AddMessage("|cffbb99ffThreatPlates|r " .. tostring(msg))
+    end
+end
+
+-- ==================================================================
+-- Deep copy utility
+-- ==================================================================
+local function DeepCopy(src)
+    if type(src) ~= "table" then return src end
+    local dst = {}
+    for k, v in pairs(src) do
+        if type(v) == "table" then
+            dst[k] = DeepCopy(v)
+        else
+            dst[k] = v
+        end
+    end
+    return dst
+end
+
+-- ==================================================================
+-- Event handling
+-- ==================================================================
+addon:RegisterEvent("ADDON_LOADED")
+addon:RegisterEvent("PLAYER_ENTERING_WORLD")
+
+addon:SetScript("OnEvent", function()
+    if event == "ADDON_LOADED" and arg1 == TP_ADDON_NAME then
+        -- Initialize saved variables with defaults
+        if not ThreatPlatesDB then
+            ThreatPlatesDB = DeepCopy(DEFAULT_CONFIG)
+        else
+            -- Merge in any missing keys from defaults
+            for k, v in pairs(DEFAULT_CONFIG) do
+                if ThreatPlatesDB[k] == nil then
+                    ThreatPlatesDB[k] = DeepCopy(v)
+                end
+            end
+        end
+
+        -- Ensure media textures
+        addon.Media.EnsureTextures()
+
+        -- Initialize modules
+        addon.ThreatEngine:Initialize()
+        addon.Threat:Initialize()
+        addon.Nameplates:Initialize()
+        addon.GUI:Initialize()
+
+        addon:ui_print("v" .. TP_VERSION .. " loaded! Type /tp for options.")
+
+    elseif event == "PLAYER_ENTERING_WORLD" then
+        -- Force a nameplate scan on entering world
+        if ThreatPlatesDB and ThreatPlatesDB.enabled then
+            addon.Nameplates:UpdateAll()
+        end
+    end
+end)
+
+-- ==================================================================
+-- Slash commands
+-- ==================================================================
+SLASH_THREATPLATES1 = "/threatplates"
+SLASH_THREATPLATES2 = "/tp"
+
+SlashCmdList["THREATPLATES"] = function(msg)
+    -- Trim whitespace and lowercase (vanilla-safe)
+    msg = msg or ""
+    msg = string.lower(msg)
+    -- Trim leading/trailing spaces
+    msg = string.gsub(msg, "^%s*(.-)%s*$", "%1")
+
+    if msg == "reset" then
+        ThreatPlatesDB = DeepCopy(DEFAULT_CONFIG)
+        addon:ui_print("Settings reset to defaults.")
+        addon.GUI:Refresh()
+    elseif msg == "toggle" then
+        ThreatPlatesDB.enabled = not ThreatPlatesDB.enabled
+        local state = ThreatPlatesDB.enabled and "|cff33ff99ON|r" or "|cffff3333OFF|r"
+        addon:ui_print("Threat bars " .. state)
+        addon.Nameplates:UpdateAll()
+    elseif msg == "threat" then
+        addon.ThreatEngine:DumpThreat()
+    elseif msg == "help" then
+        addon:ui_print("Commands:")
+        DEFAULT_CHAT_FRAME:AddMessage("  |cffbb99ff/tp|r - Open GUI")
+        DEFAULT_CHAT_FRAME:AddMessage("  |cffbb99ff/tp toggle|r - Toggle threat bars on/off")
+        DEFAULT_CHAT_FRAME:AddMessage("  |cffbb99ff/tp reset|r - Reset to defaults")
+        DEFAULT_CHAT_FRAME:AddMessage("  |cffbb99ff/tp threat|r - Dump threat table (debug)")
+        DEFAULT_CHAT_FRAME:AddMessage("  |cffbb99ff/tp help|r - Show this help")
+    else
+        addon.GUI:Toggle()
+    end
+end
+
+-- ==================================================================
+-- Expose DeepCopy on addon for other modules
+-- ==================================================================
+addon.DeepCopy = DeepCopy
diff --git a/ThreatPlates_GUI.lua b/ThreatPlates_GUI.lua
new file mode 100644
index 0000000..5f53b99
--- /dev/null
+++ b/ThreatPlates_GUI.lua
@@ -0,0 +1,499 @@
+----------------------------------------------------------------------
+-- ThreatPlates_GUI.lua
+-- Configuration GUI panel with scrolling support
+-- Styled after Kui Nameplates config: dark, minimal, clean
+-- Standalone - no Ace3 or external config library required
+-- Compatible with WoW 1.12 (Vanilla / Turtle WoW / Octo WoW)
+----------------------------------------------------------------------
+
+local addon = ThreatPlates
+
+addon.GUI = {}
+
+-- GUI frame reference
+local guiFrame = nil
+
+-- Kui-style colour constants for GUI
+local C = {
+    BG           = { 0.10, 0.10, 0.10, 0.95 },
+    BORDER       = { 0.30, 0.30, 0.30, 1.00 },
+    HEADER_BG    = { 0.15, 0.15, 0.15, 1.00 },
+    HEADER_TEXT  = { 0.75, 0.60, 1.00, 1.00 },  -- Kui purple
+    ACCENT       = { 0.30, 0.70, 1.00, 1.00 },  -- Kui blue
+    TEXT         = { 0.85, 0.85, 0.85, 1.00 },
+    TEXT_DIM      = { 0.55, 0.55, 0.55, 1.00 },
+    BUTTON_BG    = { 0.20, 0.20, 0.20, 1.00 },
+    BUTTON_HOVER = { 0.25, 0.25, 0.30, 1.00 },
+    BUTTON_TEXT   = { 0.90, 0.90, 0.90, 1.00 },
+    CHECK_ON     = { 0.30, 0.70, 1.00, 0.90 },
+    CHECK_OFF    = { 0.30, 0.30, 0.30, 0.80 },
+    SLIDER_BG    = { 0.15, 0.15, 0.15, 1.00 },
+    SLIDER_FILL  = { 0.30, 0.70, 1.00, 0.80 },
+    DIVIDER      = { 0.25, 0.25, 0.25, 0.60 },
+    SOLID        = "Interface\\Buttons\\WHITE8x8",
+}
+
+-- Layout
+local GUI_WIDTH  = 320
+local GUI_HEIGHT = 480
+local HEADER_H   = 30
+local MARGIN     = 14
+local FONT_NORMAL = "Fonts\\FRIZQT__.TTF"
+local FONT_SIZE   = 10
+
+-- Widget references for refresh
+local widgets = {}
+
+-- ==================================================================
+-- Helper: safely set backdrop on a frame
+-- ==================================================================
+local function SafeSetBackdrop(frame, backdropTbl)
+    if frame.SetBackdrop then
+        frame:SetBackdrop(backdropTbl)
+        return true
+    end
+    return false
+end
+
+-- ==================================================================
+-- Initialize GUI module
+-- ==================================================================
+function addon.GUI:Initialize()
+    -- Defer creation until first toggle
+end
+
+-- ==================================================================
+-- Create the main GUI frame (Kui-style dark panel with scroll)
+-- ==================================================================
+function addon.GUI:CreateFrame()
+    if guiFrame then return end
+
+    -- ==============================================================
+    -- Main window frame
+    -- ==============================================================
+    local f = CreateFrame("Frame", "ThreatPlatesGUI", UIParent)
+    f:SetWidth(GUI_WIDTH)
+    f:SetHeight(GUI_HEIGHT)
+    f:SetPoint("CENTER", UIParent, "CENTER", 0, 0)
+
+    SafeSetBackdrop(f, {
+        bgFile   = C.SOLID,
+        edgeFile = C.SOLID,
+        tile     = false, tileSize = 0,
+        edgeSize = 1,
+    })
+    f:SetBackdropColor(unpack(C.BG))
+    f:SetBackdropBorderColor(unpack(C.BORDER))
+    f:SetFrameStrata("DIALOG")
+    f:SetMovable(true)
+    f:EnableMouse(true)
+    f:RegisterForDrag("LeftButton")
+    f:SetScript("OnDragStart", function() this:StartMoving() end)
+    f:SetScript("OnDragStop", function()
+        this:StopMovingOrSizing()
+        local _, _, point, _, _, x, y = this:GetPoint()
+        ThreatPlatesDB.guiPos = { point = point, relPoint = point, x = x, y = y }
+    end)
+    f:Hide()
+
+    -- ==============================================================
+    -- Header bar (Kui purple accent)
+    -- ==============================================================
+    local header = CreateFrame("Frame", nil, f)
+    header:SetHeight(HEADER_H)
+    header:SetPoint("TOPLEFT", f, "TOPLEFT", 0, 0)
+    header:SetPoint("TOPRIGHT", f, "TOPRIGHT", 0, 0)
+    SafeSetBackdrop(header, {
+        bgFile   = C.SOLID,
+        edgeFile = C.SOLID,
+        tile     = false, tileSize = 0,
+        edgeSize = 1,
+    })
+    header:SetBackdropColor(unpack(C.HEADER_BG))
+    header:SetBackdropBorderColor(unpack(C.BORDER))
+    header:EnableMouse(true)
+    header:RegisterForDrag("LeftButton")
+    header:SetScript("OnDragStart", function() f:StartMoving() end)
+    header:SetScript("OnDragStop", function()
+        f:StopMovingOrSizing()
+        local _, _, point, _, _, x, y = f:GetPoint()
+        ThreatPlatesDB.guiPos = { point = point, relPoint = point, x = x, y = y }
+    end)
+
+    local headerText = header:CreateFontString(nil, "OVERLAY")
+    headerText:SetFont(FONT_NORMAL, 12, "OUTLINE")
+    headerText:SetPoint("CENTER", header, "CENTER", 0, 0)
+    headerText:SetTextColor(unpack(C.HEADER_TEXT))
+    headerText:SetText("ThreatPlates")
+
+    -- Close button
+    local closeBtn = CreateFrame("Button", nil, header)
+    closeBtn:SetWidth(24)
+    closeBtn:SetHeight(20)
+    closeBtn:SetPoint("RIGHT", header, "RIGHT", -4, 0)
+    closeBtn:SetNormalTexture(C.SOLID)
+    closeBtn:GetNormalTexture():SetVertexColor(0.4, 0.4, 0.4, 0.8)
+    closeBtn:SetHighlightTexture(C.SOLID)
+    closeBtn:GetHighlightTexture():SetVertexColor(0.6, 0.6, 0.6, 0.8)
+    closeBtn:SetPushedTexture(C.SOLID)
+    closeBtn:GetPushedTexture():SetVertexColor(0.3, 0.3, 0.3, 0.8)
+
+    local closeText = closeBtn:CreateFontString(nil, "OVERLAY")
+    closeText:SetFont(FONT_NORMAL, 10, "OUTLINE")
+    closeText:SetPoint("CENTER", closeBtn, "CENTER", 0, 0)
+    closeText:SetTextColor(1, 1, 1, 1)
+    closeText:SetText("X")
+    closeBtn:SetFontString(closeText)
+
+    closeBtn:SetScript("OnClick", function()
+        addon.GUI:Hide()
+    end)
+
+    -- ==============================================================
+    -- Scroll frame - allows content to scroll when it overflows
+    -- ==============================================================
+    -- The scroll frame sits below the header and fills the rest of the window
+    local scrollFrame = CreateFrame("ScrollFrame", "ThreatPlatesScrollFrame", f)
+    scrollFrame:SetPoint("TOPLEFT", f, "TOPLEFT", 0, -HEADER_H)
+    scrollFrame:SetPoint("TOPRIGHT", f, "TOPRIGHT", 0, -HEADER_H)
+    scrollFrame:SetPoint("BOTTOMLEFT", f, "BOTTOMLEFT", 0, 0)
+    scrollFrame:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", 0, 0)
+
+    -- Scroll bar (vertical)
+    local scrollBar = CreateFrame("Slider", "ThreatPlatesScrollBar", scrollFrame, "UIPanelScrollBarTemplate")
+    scrollBar:SetPoint("TOPRIGHT", f, "TOPRIGHT", -4, -HEADER_H - 8)
+    scrollBar:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", -4, 8)
+    scrollBar:SetWidth(16)
+    scrollBar:SetMinMaxValues(0, 1000)
+    scrollBar:SetValueStep(20)
+    scrollBar:SetValue(0)
+
+    -- Style the scrollbar thumb and background to Kui look
+    local scrollName = scrollBar:GetName()
+    local scrollThumb = getglobal(scrollName .. "ThumbTexture")
+    if scrollThumb then
+        scrollThumb:SetTexture(C.SOLID)
+        scrollThumb:SetVertexColor(unpack(C.ACCENT))
+    end
+
+    -- Scroll child - the actual content frame that holds all settings
+    local scrollChild = CreateFrame("Frame", "ThreatPlatesScrollChild", scrollFrame)
+    scrollChild:SetWidth(GUI_WIDTH - 30)  -- leave room for scrollbar
+    -- Height will be set after building content based on total y offset
+    scrollFrame:SetScrollChild(scrollChild)
+
+    -- Connect scrollbar to scrollframe
+    scrollBar:SetScript("OnValueChanged", function()
+        scrollFrame:SetVerticalScroll(this:GetValue())
+    end)
+
+    -- Mouse wheel scrolling on the main frame
+    f:EnableMouseWheel(true)
+    f:SetScript("OnMouseWheel", function()
+        local delta = arg1
+        local current = scrollBar:GetValue()
+        local step = 40
+        if delta > 0 then
+            scrollBar:SetValue(math.max(0, current - step))
+        else
+            scrollBar:SetValue(math.min(1000, current + step))
+        end
+    end)
+
+    f.scrollFrame = scrollFrame
+    f.scrollBar = scrollBar
+    f.scrollChild = scrollChild
+
+    -- Build settings into the scroll child
+    widgets = {}
+    local totalHeight = self:BuildSettings(scrollChild)
+
+    -- Set the scroll child height to the actual content height
+    scrollChild:SetHeight(totalHeight + MARGIN)
+
+    -- Update scrollbar max based on content vs visible area
+    local visibleH = GUI_HEIGHT - HEADER_H
+    if totalHeight + MARGIN > visibleH then
+        scrollBar:SetMinMaxValues(0, totalHeight + MARGIN - visibleH)
+    else
+        scrollBar:SetMinMaxValues(0, 0)
+        scrollBar:Hide()
+    end
+
+    -- Restore saved position
+    if ThreatPlatesDB and ThreatPlatesDB.guiPos then
+        local pos = ThreatPlatesDB.guiPos
+        if pos.point and pos.x and pos.y then
+            f:ClearAllPoints()
+            f:SetPoint(pos.point, UIParent, pos.relPoint or pos.point, pos.x, pos.y)
+        end
+    end
+
+    guiFrame = f
+end
+
+-- ==================================================================
+-- Build all settings controls
+-- Returns the total content height for scroll setup
+-- ==================================================================
+function addon.GUI:BuildSettings(parent)
+    local y = 0
+    local W = GUI_WIDTH - 30  -- account for scrollbar width
+
+    -- ==============================================================
+    -- Helper: Section label (Kui-style blue heading)
+    -- ==============================================================
+    local function SectionLabel(text)
+        local label = parent:CreateFontString(nil, "OVERLAY")
+        label:SetFont(FONT_NORMAL, FONT_SIZE + 1, "OUTLINE")
+        label:SetPoint("TOPLEFT", parent, "TOPLEFT", MARGIN, -y)
+        label:SetTextColor(unpack(C.ACCENT))
+        label:SetText(text)
+        y = y + 20
+
+        -- Divider line
+        local divider = parent:CreateTexture(nil, "ARTWORK")
+        divider:SetTexture(C.SOLID)
+        divider:SetVertexColor(unpack(C.DIVIDER))
+        divider:SetPoint("TOPLEFT", parent, "TOPLEFT", MARGIN, -y + 8)
+        divider:SetPoint("TOPRIGHT", parent, "TOPRIGHT", -MARGIN, -y + 8)
+        divider:SetHeight(1)
+        y = y + 4
+    end
+
+    -- ==============================================================
+    -- Helper: Checkbox (custom frame-based)
+    -- ==============================================================
+    local function CheckBox(labelText, configKey, description)
+        local btn = CreateFrame("Frame", nil, parent)
+        btn:SetWidth(18)
+        btn:SetHeight(18)
+        btn:SetPoint("TOPLEFT", parent, "TOPLEFT", MARGIN, -y)
+        btn:EnableMouse(true)
+
+        SafeSetBackdrop(btn, {
+            bgFile   = C.SOLID,
+            edgeFile = C.SOLID,
+            tile     = false, tileSize = 0,
+            edgeSize = 1,
+        })
+        btn:SetBackdropColor(unpack(C.CHECK_OFF))
+        btn:SetBackdropBorderColor(unpack(C.BORDER))
+
+        local check = btn:CreateTexture(nil, "ARTWORK")
+        check:SetTexture(C.SOLID)
+        check:SetPoint("TOPLEFT", btn, "TOPLEFT", 3, -3)
+        check:SetPoint("BOTTOMRIGHT", btn, "BOTTOMRIGHT", -3, 3)
+        check:SetVertexColor(unpack(C.CHECK_ON))
+        check:Hide()
+        btn.checkMark = check
+
+        btn.checked = false
+        if ThreatPlatesDB[configKey] then
+            btn.checked = true
+            check:Show()
+        end
+
+        btn:SetScript("OnMouseDown", function()
+            this.checked = not this.checked
+            ThreatPlatesDB[configKey] = this.checked
+            if this.checked then
+                this.checkMark:Show()
+            else
+                this.checkMark:Hide()
+            end
+            addon.Nameplates:RecreateAll()
+        end)
+
+        local label = parent:CreateFontString(nil, "OVERLAY")
+        label:SetFont(FONT_NORMAL, FONT_SIZE)
+        label:SetPoint("TOPLEFT", parent, "TOPLEFT", MARGIN + 24, -y + 1)
+        label:SetTextColor(unpack(C.TEXT))
+        label:SetText(labelText)
+
+        y = y + 18
+
+        if description then
+            local desc = parent:CreateFontString(nil, "OVERLAY")
+            desc:SetFont(FONT_NORMAL, FONT_SIZE - 2)
+            desc:SetPoint("TOPLEFT", parent, "TOPLEFT", MARGIN + 24, -y + 3)
+            desc:SetTextColor(unpack(C.TEXT_DIM))
+            desc:SetText(description)
+            y = y + 14
+        end
+
+        y = y + 4
+        widgets[configKey] = btn
+    end
+
+    -- ==============================================================
+    -- Helper: Slider (Kui-style flat slider)
+    -- ==============================================================
+    local function Slider(labelText, configKey, minVal, maxVal, step, suffix)
+        suffix = suffix or ""
+
+        local label = parent:CreateFontString(nil, "OVERLAY")
+        label:SetFont(FONT_NORMAL, FONT_SIZE)
+        label:SetPoint("TOPLEFT", parent, "TOPLEFT", MARGIN, -y)
+        label:SetTextColor(unpack(C.TEXT))
+        label:SetText(labelText)
+        y = y + 16
+
+        local slider = CreateFrame("Slider", "ThreatPlatesSlider_" .. configKey, parent, "OptionsSliderTemplate")
+        slider:SetWidth(W - 60)
+        slider:SetHeight(16)
+        slider:SetPoint("TOPLEFT", parent, "TOPLEFT", MARGIN, -y)
+        slider:SetOrientation("HORIZONTAL")
+        slider:SetMinMaxValues(minVal, maxVal)
+        slider:SetValueStep(step)
+        slider:SetValue(ThreatPlatesDB[configKey] or minVal)
+
+        local sliderName = slider:GetName()
+        local bgTexture = getglobal(sliderName .. "BG")
+        local fillTexture = getglobal(sliderName .. "Fill")
+        local thumbTexture = getglobal(sliderName .. "Thumb")
+
+        if bgTexture then
+            bgTexture:SetTexture(C.SOLID)
+            bgTexture:SetVertexColor(unpack(C.SLIDER_BG))
+        end
+        if fillTexture then
+            fillTexture:SetTexture(C.SOLID)
+            fillTexture:SetVertexColor(unpack(C.SLIDER_FILL))
+        end
+        if thumbTexture then
+            thumbTexture:SetTexture(C.SOLID)
+            thumbTexture:SetVertexColor(unpack(C.ACCENT))
+        end
+
+        local lowText = getglobal(sliderName .. "Low")
+        local highText = getglobal(sliderName .. "High")
+        if lowText then lowText:SetText("") end
+        if highText then highText:SetText("") end
+
+        local valText = parent:CreateFontString(nil, "OVERLAY")
+        valText:SetFont(FONT_NORMAL, FONT_SIZE - 1)
+        valText:SetPoint("LEFT", slider, "RIGHT", 6, 0)
+        valText:SetTextColor(unpack(C.ACCENT))
+        local curVal = ThreatPlatesDB[configKey] or minVal
+        if step < 1 then
+            valText:SetText(string.format("%.1f", curVal) .. suffix)
+        else
+            valText:SetText(math.floor(curVal + 0.5) .. suffix)
+        end
+
+        slider:SetScript("OnValueChanged", function()
+            local val = this:GetValue()
+            val = math.floor(val / step + 0.5) * step
+            ThreatPlatesDB[configKey] = val
+            if step < 1 then
+                valText:SetText(string.format("%.1f", val) .. suffix)
+            else
+                valText:SetText(math.floor(val + 0.5) .. suffix)
+            end
+            addon.Nameplates:RecreateAll()
+        end)
+
+        y = y + 24
+        widgets[configKey] = slider
+    end
+
+    -- ==============================================================
+    -- GENERAL SECTION
+    -- ==============================================================
+    SectionLabel("General")
+    CheckBox("Enable Threat Plates", "enabled", "Show threat bars above nameplates")
+    CheckBox("Show Threat Text", "showText", "Display percentage in the bar")
+    CheckBox("Smooth Colours", "smoothColors", "Gradient colour transition")
+
+    -- ==============================================================
+    -- APPEARANCE SECTION
+    -- ==============================================================
+    SectionLabel("Appearance")
+    Slider("Bar Height", "barHeight", 2, 20, 1, "px")
+    Slider("Bar Width Scale", "barWidthScale", 0.3, 1.0, 0.05, "")
+    Slider("Bar Offset Y", "barOffsetY", 0, 20, 1, "px")
+    Slider("Bar Offset X", "barOffsetX", -50, 50, 0.1, "px")
+    Slider("Bar Alpha", "barAlpha", 0.1, 1.0, 0.1, "")
+    Slider("Font Size", "fontSize", 6, 16, 1, "pt")
+    CheckBox("Font Outline", "fontOutline", "Outlined text for readability")
+
+    -- ==============================================================
+    -- KUI STYLE SECTION
+    -- ==============================================================
+    SectionLabel("Kui Style Effects")
+    CheckBox("Show Spark", "showSpark", "Bright edge on the bar's leading edge")
+    CheckBox("Show Fill Background", "showFillBG", "Dim ghost of bar colour behind the bar")
+    Slider("Fill Alpha", "fillAlpha", 0.05, 0.50, 0.05, "")
+    CheckBox("Enable Glow", "glowEnabled", "Border glow based on threat level")
+    CheckBox("Glow as Shadow", "glowAsShadow", "Subtle shadow instead of bright glow")
+    Slider("Glow Size", "glowSize", 1, 8, 1, "px")
+
+    -- ==============================================================
+    -- FILTER SECTION
+    -- ==============================================================
+    SectionLabel("Display Filters")
+    CheckBox("Show on Hostile", "showOnHostile", "Show threat bars on hostile units")
+    CheckBox("Show on Neutral", "showOnNeutral", "Show threat bars on neutral units")
+    CheckBox("Show on Friendly", "showOnFriendly", "Show threat bars on friendly units")
+
+    -- Return total content height for scroll setup
+    return y
+end
+
+-- ==================================================================
+-- Toggle GUI visibility
+-- ==================================================================
+function addon.GUI:Toggle()
+    if not guiFrame then
+        self:CreateFrame()
+    end
+
+    if guiFrame:IsVisible() then
+        self:Hide()
+    else
+        self:Show()
+    end
+end
+
+-- ==================================================================
+-- Show the GUI
+-- ==================================================================
+function addon.GUI:Show()
+    if not guiFrame then
+        self:CreateFrame()
+    end
+    guiFrame:Show()
+end
+
+-- ==================================================================
+-- Hide the GUI
+-- ==================================================================
+function addon.GUI:Hide()
+    if guiFrame then
+        guiFrame:Hide()
+    end
+end
+
+-- ==================================================================
+-- Refresh all GUI values from saved vars
+-- ==================================================================
+function addon.GUI:Refresh()
+    if not guiFrame then return end
+
+    for key, widget in pairs(widgets) do
+        -- Our custom checkbox (Frame with .checked field)
+        if widget.checked ~= nil then
+            local val = ThreatPlatesDB[key]
+            widget.checked = val
+            if val then
+                widget.checkMark:Show()
+            else
+                widget.checkMark:Hide()
+            end
+        -- Slider
+        elseif widget.SetValue then
+            widget:SetValue(ThreatPlatesDB[key])
+        end
+    end
+end
diff --git a/ThreatPlates_Media.lua b/ThreatPlates_Media.lua
new file mode 100644
index 0000000..00e8c36
--- /dev/null
+++ b/ThreatPlates_Media.lua
@@ -0,0 +1,120 @@
+----------------------------------------------------------------------
+-- ThreatPlates_Media.lua
+-- Embedded media textures and fonts
+-- Self-contained - generates textures procedurally, no external files
+----------------------------------------------------------------------
+
+local addon = ThreatPlates  -- Created in ThreatPlates_Core.lua (loaded first via XML)
+
+addon.Media = {}
+
+-- ==================================================================
+-- Procedural status bar texture (solid gradient)
+-- Generated at runtime via texture coordinates on Blizzard's shared
+-- gradient texture, matching Kui's clean flat bar style
+-- ==================================================================
+
+-- Use Blizzard's built-in solid textures as bar fill
+-- These are always available and produce the clean flat look
+addon.Media.BAR_TEXTURE     = "Interface\\AddOns\\ThreatPlates\\Media\\Bar"
+addon.Media.BG_TEXTURE      = "Interface\\AddOns\\ThreatPlates\\Media\\BarBG"
+addon.Media.SOLID_TEXTURE   = "Interface\\Buttons\\WHITE8x8"
+addon.Media.GLOW_TEXTURE    = "Interface\\AddOns\\ThreatPlates\\Media\\Glow"
+addon.Media.SPARK_TEXTURE   = "Interface\\AddOns\\ThreatPlates\\Media\\Spark"
+addon.Media.SHADOW_TEXTURE  = "Interface\\AddOns\\ThreatPlates\\Media\\ShadowBorder"
+
+-- Font paths - use WoW's built-in fonts for zero-dependency
+addon.Media.FONT_NORMAL     = "Fonts\\FRIZQT__.TTF"
+addon.Media.FONT_OUTLINE    = "Fonts\\FRIZQT__.TTF"
+
+-- Kui-style colour palette
+addon.Media.COLOURS = {
+    -- Threat gradient: green -> yellow -> orange -> red
+    THREAT_LOW    = { r = 0.33, g = 0.80, b = 0.33 },
+    THREAT_MEDIUM = { r = 1.00, g = 0.85, b = 0.00 },
+    THREAT_HIGH   = { r = 1.00, g = 0.50, b = 0.00 },
+    THREAT_AGGRO  = { r = 1.00, g = 0.10, b = 0.10 },
+
+    -- Kui-style background
+    BG_DARK       = { r = 0.06, g = 0.06, b = 0.06, a = 0.90 },
+
+    -- Kui-style border glow colours
+    GLOW_TARGET   = { r = 0.30, g = 0.70, b = 1.00, a = 0.60 },
+    GLOW_THREAT   = { r = 0.90, g = 0.00, b = 0.00, a = 0.60 },
+    GLOW_SHADOW   = { r = 0.00, g = 0.00, b = 0.00, a = 0.20 },
+
+    -- Text
+    TEXT_WHITE     = { r = 1.00, g = 1.00, b = 1.00 },
+    TEXT_SHADOW    = { r = 0.00, g = 0.00, b = 0.00, a = 1.00 },
+
+    -- GUI
+    GUI_BG        = { r = 0.10, g = 0.10, b = 0.10, a = 0.95 },
+    GUI_BORDER    = { r = 0.30, g = 0.30, b = 0.30, a = 1.00 },
+    GUI_HEADER    = { r = 0.15, g = 0.15, b = 0.15, a = 1.00 },
+    GUI_ACCENT    = { r = 0.30, g = 0.70, b = 1.00, a = 1.00 },
+}
+
+-- ==================================================================
+-- Helper: brighten a colour by a factor (Kui-style)
+-- ==================================================================
+function addon.Media.Brighten(factor, r, g, b, a)
+    factor = factor or 0.3
+    if type(r) == "table" then
+        r, g, b, a = unpack(r)
+    end
+    a = a or 1
+    return math.min(1, r + (1 - r) * factor),
+           math.min(1, g + (1 - g) * factor),
+           math.min(1, b + (1 - b) * factor),
+           a
+end
+
+-- ==================================================================
+-- Helper: get smooth interpolated threat colour
+-- ==================================================================
+function addon.Media.GetThreatColour(pct)
+    pct = tonumber(pct) or 0
+    pct = math.min(100, math.max(0, pct))
+
+    local c = addon.Media.COLOURS
+    local r, g, b
+
+    if pct < 50 then
+        local t = pct / 50
+        r = c.THREAT_LOW.r + (c.THREAT_MEDIUM.r - c.THREAT_LOW.r) * t
+        g = c.THREAT_LOW.g + (c.THREAT_MEDIUM.g - c.THREAT_LOW.g) * t
+        b = c.THREAT_LOW.b + (c.THREAT_MEDIUM.b - c.THREAT_LOW.b) * t
+    elseif pct < 80 then
+        local t = (pct - 50) / 30
+        r = c.THREAT_MEDIUM.r + (c.THREAT_HIGH.r - c.THREAT_MEDIUM.r) * t
+        g = c.THREAT_MEDIUM.g + (c.THREAT_HIGH.g - c.THREAT_MEDIUM.g) * t
+        b = c.THREAT_MEDIUM.b + (c.THREAT_HIGH.b - c.THREAT_MEDIUM.b) * t
+    else
+        local t = (pct - 80) / 20
+        t = math.min(1, math.max(0, t))
+        r = c.THREAT_HIGH.r + (c.THREAT_AGGRO.r - c.THREAT_HIGH.r) * t
+        g = c.THREAT_HIGH.g + (c.THREAT_AGGRO.g - c.THREAT_HIGH.g) * t
+        b = c.THREAT_HIGH.b + (c.THREAT_AGGRO.b - c.THREAT_HIGH.b) * t
+    end
+
+    return r, g, b
+end
+
+-- ==================================================================
+-- Generate media textures as file data (using solid fallback)
+-- These are created in the Media/ folder by the installer script
+-- but we also provide runtime fallback generation
+-- ==================================================================
+function addon.Media.EnsureTextures()
+    -- Ensure the media directory textures exist
+    -- For standalone deployment, we use Blizzard built-in textures
+    -- with vertex colouring to achieve the Kui look
+    --
+    -- The bar texture is handled via WHITE8x8 with vertex colour
+    -- This gives the same clean flat look as Kui's procedural bar
+
+    addon.Media.BAR_TEXTURE   = addon.Media.SOLID_TEXTURE
+    addon.Media.BG_TEXTURE    = addon.Media.SOLID_TEXTURE
+    addon.Media.GLOW_TEXTURE  = addon.Media.SOLID_TEXTURE
+    addon.Media.SPARK_TEXTURE = addon.Media.SOLID_TEXTURE
+end
diff --git a/ThreatPlates_Nameplates.lua b/ThreatPlates_Nameplates.lua
new file mode 100644
index 0000000..242b520
--- /dev/null
+++ b/ThreatPlates_Nameplates.lua
@@ -0,0 +1,1387 @@
+----------------------------------------------------------------------
+-- ThreatPlates_Nameplates.lua
+-- Nameplate scanning, hooking, and threat bar creation
+-- Creates Kui Nameplates-style threat bars above health bars
+-- Standalone for WoW 1.12 (Vanilla / Turtle WoW / Octo WoW)
+----------------------------------------------------------------------
+
+local addon = ThreatPlates
+
+addon.Nameplates = {}
+
+-- Plate registry: nameplate frame -> our data
+addon.Nameplates.plates = {}
+
+-- Known nameplates cache (to avoid re-scanning)
+local knownPlates = {}
+
+-- Solid texture path for all bar visuals
+local SOLID_TEXTURE = "Interface\\Buttons\\WHITE8x8"
+
+-- Font path
+local FONT_PATH = "Fonts\\FRIZQT__.TTF"
+
+-- ==================================================================
+-- Helpers for same-name mob handling
+-- ==================================================================
+
+local function GetPlateNameText(data, nameplate)
+    local name = nil
+
+    -- Try the stored FontString reference first
+    if data and data.nameFontString then
+        local ok, txt = pcall(data.nameFontString.GetText, data.nameFontString)
+        if ok and txt and strlen(txt) > 0 then
+            name = txt
+        end
+    end
+
+    -- Fallback: scan regions for FontString
+    if (not name or strlen(name) == 0) and nameplate then
+        local regions = { nameplate:GetRegions() }
+        local numRegions = table.getn(regions)
+        for j = 1, numRegions do
+            local region = regions[j]
+            if region then
+                local ok, objType = pcall(region.GetObjectType, region)
+                if ok and objType == "FontString" then
+                    local ok2, txt = pcall(region.GetText, region)
+                    if ok2 and txt and strlen(txt) > 0 and strlen(txt) < 60 then
+                        name = txt
+                        break
+                    end
+                end
+            end
+        end
+    end
+
+    return name
+end
+
+local function GetPlateHealthPercent(data)
+    if not data or not data.healthBar then return nil end
+
+    local okMinMax, minVal, maxVal = pcall(data.healthBar.GetMinMaxValues, data.healthBar)
+    local okValue, value = pcall(data.healthBar.GetValue, data.healthBar)
+
+    if not okMinMax or not okValue then return nil end
+    if not maxVal or maxVal <= minVal then return nil end
+
+    return ((value - minVal) / (maxVal - minVal)) * 100
+end
+
+local function GetUnitHealthPercent(unit)
+    if not unit or not UnitExists(unit) then return nil end
+
+    local okCur, cur = pcall(UnitHealth, unit)
+    local okMax, maxVal = pcall(UnitHealthMax, unit)
+
+    if not okCur or not okMax then return nil end
+    if not maxVal or maxVal <= 0 then return nil end
+
+    return (cur / maxVal) * 100
+end
+
+local function IsSameUnitToken(unitA, unitB)
+    if not unitA or not unitB then return false end
+    if unitA == unitB then return true end
+    if UnitIsUnit then
+        local ok, same = pcall(UnitIsUnit, unitA, unitB)
+        if ok and same then
+            return true
+        end
+    end
+    return false
+end
+
+-- ==================================================================
+-- Health-change based combat detection for nameplates.
+--
+-- In Vanilla 1.12, non-targeted mobs often have NO unit token.
+-- The only way to know they're in combat is by observing their
+-- nameplate health bar decreasing. If a mob's health is going
+-- down, it's in combat. If it's stable at 100%, it's idle.
+--
+-- This is the KEY technique that makes multi-mob threat display
+-- work without unit tokens, while still filtering idle same-name
+-- mobs (whose health stays at 100%).
+-- ==================================================================
+
+local function IsPlateInCombat(data)
+    if not data then return false end
+
+    -- Method 1: If we have a unit token, use the API directly
+    if data.unit and UnitExists(data.unit) then
+        local ok, inCombat = pcall(UnitAffectingCombat, data.unit)
+        if ok then
+            return inCombat
+        end
+    end
+
+    -- Method 2: Health-change detection.
+    -- If the plate's health bar has decreased since last check,
+    -- the mob is definitely in combat (taking damage).
+    -- We track previousHealth for comparison.
+    local currentHealth = GetPlateHealthPercent(data)
+
+    if currentHealth == nil then
+        -- Can't read health bar — assume not in combat
+        return false
+    end
+
+    -- If health is significantly below 100%, the mob has been damaged
+    -- and is almost certainly in combat.
+    if currentHealth < 98 then
+        return true
+    end
+
+    -- If health decreased since last check, the mob is taking damage
+    -- right now — definitely in combat.
+    if data.previousHealth and currentHealth < data.previousHealth - 0.5 then
+        return true
+    end
+
+    -- Health is near 100% and stable — likely idle.
+    -- Exception: a freshly body-pulled mob might be at full health
+    -- briefly. We handle this with a grace period in UpdateAllPlates.
+    return false
+end
+
+function addon.Nameplates:GetCandidateUnitsByName(name)
+    local candidates = {}
+    if not name then return candidates end
+
+    local unitTokens = { "target", "mouseover", "targettarget", "pet" }
+
+    for i = 1, 4 do
+        unitTokens[table.getn(unitTokens) + 1] = "party" .. i .. "target"
+        unitTokens[table.getn(unitTokens) + 1] = "party" .. i .. "targettarget"
+    end
+
+    for i = 1, 40 do
+        unitTokens[table.getn(unitTokens) + 1] = "raid" .. i .. "target"
+        unitTokens[table.getn(unitTokens) + 1] = "raid" .. i .. "targettarget"
+    end
+
+    for i = 1, table.getn(unitTokens) do
+        local unit = unitTokens[i]
+        local ok, exists = pcall(UnitExists, unit)
+        if ok and exists then
+            local ok2, uname = pcall(UnitName, unit)
+            if ok2 and uname and uname == name then
+                local duplicate = false
+                for j = 1, table.getn(candidates) do
+                    if IsSameUnitToken(candidates[j].unit, unit) then
+                        duplicate = true
+                        break
+                    end
+                end
+
+                if not duplicate then
+                    local okCombat, inCombat = pcall(UnitAffectingCombat, unit)
+                    local okAttack, canAttack = pcall(UnitCanAttack, "player", unit)
+                    candidates[table.getn(candidates) + 1] = {
+                        unit = unit,
+                        healthPct = GetUnitHealthPercent(unit),
+                        inCombat = okCombat and inCombat or false,
+                        canAttack = okAttack and canAttack or nil,
+                    }
+                end
+            end
+        end
+    end
+
+    return candidates
+end
+
+local function ScoreCandidateForPlate(data, candidate)
+    if not data or not candidate then return -999999 end
+
+    local score = 0
+    local platePct = GetPlateHealthPercent(data)
+
+    -- MANDATORY: If candidate is NOT in combat, heavily penalize.
+    -- This prevents idle same-name mobs from getting assigned
+    -- combat-unit tokens and showing incorrect threat bars.
+    if not candidate.inCombat then
+        score = score - 5000
+    end
+
+    -- Check if the plate's health bar is at 100% (likely idle mob)
+    -- A mob at full health that hasn't been damaged is very likely idle.
+    local plateLooksIdle = false
+    if platePct and platePct >= 99.5 then
+        plateLooksIdle = true
+    end
+
+    -- If plate looks idle but candidate is in combat, this is a
+    -- mismatch — the combat unit is probably a DIFFERENT mob with
+    -- the same name that has been damaged.
+    if plateLooksIdle and candidate.inCombat then
+        score = score - 3000
+    end
+
+    -- If plate looks damaged and candidate is in combat, great match
+    if not plateLooksIdle and candidate.inCombat then
+        score = score + 500
+    end
+
+    -- If plate looks idle and candidate is also idle, they might match
+    -- (but we'll still hide the bar later since idle = no threat)
+    if plateLooksIdle and not candidate.inCombat then
+        score = score + 50
+    end
+
+    -- Previous unit continuity bonus
+    if data._previousUnit and IsSameUnitToken(data._previousUnit, candidate.unit) then
+        score = score + 1000
+    end
+
+    -- Health percentage matching — the STRONGEST discriminator for
+    -- same-name mobs. If the plate shows 72% health and the unit
+    -- token reports 72% health, they're almost certainly the same mob.
+    if platePct and candidate.healthPct then
+        local diff = math.abs(platePct - candidate.healthPct)
+        score = score + math.max(0, 500 - (diff * 15))
+    end
+
+    -- CanAttack check
+    if candidate.canAttack == false then
+        score = score - 1000
+    end
+
+    return score
+end
+
+function addon.Nameplates:ResolveVisiblePlateUnits()
+    local platesByName = {}
+
+    for nameplate, data in pairs(self.plates) do
+        data._previousUnit = data.unit
+        data.unit = nil
+        data.guid = nil
+
+        if nameplate:IsVisible() then
+            local name = GetPlateNameText(data, nameplate)
+            if name and strlen(name) > 0 then
+                data.plateName = name
+                if not platesByName[name] then
+                    platesByName[name] = {}
+                end
+                platesByName[name][table.getn(platesByName[name]) + 1] = data
+            else
+                data.plateName = nil
+            end
+        else
+            data.plateName = nil
+        end
+    end
+
+    for name, plates in pairs(platesByName) do
+        local candidates = self:GetCandidateUnitsByName(name)
+        local plateCount = table.getn(plates)
+        local candidateCount = table.getn(candidates)
+
+        if plateCount == 1 and candidateCount == 1 then
+            local data = plates[1]
+            data.unit = candidates[1].unit
+            data.guid = addon:GetUnitID(candidates[1].unit)
+        elseif candidateCount > 0 then
+            local usedCandidates = {}
+
+            for assignStep = 1, plateCount do
+                local bestPlateIndex = nil
+                local bestCandidateIndex = nil
+                local bestScore = -999999
+
+                for plateIndex = 1, plateCount do
+                    local data = plates[plateIndex]
+                    if not data.unit then
+                        for candidateIndex = 1, candidateCount do
+                            if not usedCandidates[candidateIndex] then
+                                local score = ScoreCandidateForPlate(data, candidates[candidateIndex])
+                                if score > bestScore then
+                                    bestScore = score
+                                    bestPlateIndex = plateIndex
+                                    bestCandidateIndex = candidateIndex
+                                end
+                            end
+                        end
+                    end
+                end
+
+                if bestPlateIndex and bestCandidateIndex then
+                    local data = plates[bestPlateIndex]
+                    local candidate = candidates[bestCandidateIndex]
+                    data.unit = candidate.unit
+                    data.guid = addon:GetUnitID(candidate.unit)
+                    usedCandidates[bestCandidateIndex] = true
+                else
+                    break
+                end
+            end
+        end
+    end
+end
+
+-- ==================================================================
+-- Check if a WoW API function exists and is callable
+-- In Vanilla 1.12, many APIs like UnitThreatSituation do not exist
+-- ==================================================================
+local function APICheck(func)
+    if func then
+        local ok, _ = pcall(func)
+        return ok
+    end
+    return false
+end
+
+-- ==================================================================
+-- Initialize the nameplate module
+-- ==================================================================
+function addon.Nameplates:Initialize()
+    -- Set up the periodic nameplate scanner
+    self.scanner = CreateFrame("Frame", "ThreatPlatesScanner")
+    self.scanner.elapsed = 0
+    self.scanner:SetScript("OnUpdate", function()
+        this.elapsed = this.elapsed + arg1
+        if this.elapsed >= 0.5 then
+            this.elapsed = 0
+            addon.Nameplates:ScanForNameplates()
+        end
+    end)
+
+    -- Set up the periodic threat updater
+    self.updater = CreateFrame("Frame", "ThreatPlatesUpdater")
+    self.updater.elapsed = 0
+    self.updater:SetScript("OnUpdate", function()
+        this.elapsed = this.elapsed + arg1
+        if this.elapsed >= 0.3 then
+            this.elapsed = 0
+            addon.Nameplates:UpdateAllPlates()
+        end
+    end)
+
+    -- Initial scan
+    self:ScanForNameplates()
+end
+
+-- ==================================================================
+-- Scan for nameplates using the vanilla 1.12 WorldFrame method
+--
+-- In vanilla 1.12, nameplates are direct children of WorldFrame.
+-- A nameplate frame has this structure:
+--   - It is a direct child of WorldFrame
+--   - It contains a child Frame that has a StatusBar (the health bar)
+--   - The health bar's children include textures (the bar fill + bg)
+--   - The nameplate has FontString regions for the name text
+--   - Nameplates have characteristic dimensions (~110 wide, ~40 tall)
+--
+-- We detect them by looking for frames with a StatusBar child
+-- that also have FontString regions.
+-- ==================================================================
+function addon.Nameplates:ScanForNameplates()
+    local numChildren = WorldFrame:GetNumChildren()
+
+    -- Cache children table to avoid calling GetChildren repeatedly
+    local children = { WorldFrame:GetChildren() }
+
+    for i = 1, numChildren do
+        local nameplate = children[i]
+
+        if nameplate and not knownPlates[nameplate] then
+            -- Quick visibility filter - don't scan invisible frames
+            if nameplate:IsVisible() then
+                knownPlates[nameplate] = true
+
+                -- Check if this frame is a nameplate
+                local healthBar, nameText = self:IdentifyNameplate(nameplate)
+
+                if healthBar then
+                    self:AttachThreatBar(nameplate, healthBar, nameText)
+                end
+            else
+                -- Mark as known even if invisible; we'll handle
+                -- visibility in the update loop
+                knownPlates[nameplate] = true
+            end
+        end
+    end
+end
+
+-- ==================================================================
+-- Identify if a frame is a vanilla nameplate
+-- Returns: healthBar (StatusBar), nameText (FontString) or nil
+-- ==================================================================
+function addon.Nameplates:IdentifyNameplate(frame)
+    if not frame then return nil end
+    if not frame:IsVisible() then return nil end
+
+    -- Nameplates are not too large and not too small
+    local w = frame:GetWidth()
+    local h = frame:GetHeight()
+    if not w or not h then return nil end
+    if w < 50 or w > 200 then return nil end
+    if h < 10 or h > 100 then return nil end
+
+    local healthBar = nil
+    local nameText = nil
+
+    -- Scan children for StatusBar (health bar)
+    -- In vanilla, the health bar is usually the first child or
+    -- is nested inside a child frame
+    local kids = { frame:GetChildren() }
+    local numKids = table.getn(kids)
+    for j = 1, numKids do
+        local child = kids[j]
+        if child then
+            -- Check if this child IS a StatusBar
+            -- In vanilla 1.12, GetObjectType works on all frame types
+            local ok, objType = pcall(child.GetObjectType, child)
+            if ok and objType == "StatusBar" then
+                healthBar = child
+            else
+                -- The StatusBar might be nested one level deeper
+                -- (some nameplate implementations wrap the bar)
+                local grandKids = { child:GetChildren() }
+                local numGrandKids = table.getn(grandKids)
+                for k = 1, numGrandKids do
+                    local grandChild = grandKids[k]
+                    if grandChild then
+                        local ok2, objType2 = pcall(grandChild.GetObjectType, grandChild)
+                        if ok2 and objType2 == "StatusBar" then
+                            healthBar = grandChild
+                            break
+                        end
+                    end
+                end
+            end
+            if healthBar then break end
+        end
+    end
+
+    -- Scan regions for FontString (name text)
+    local regions = { frame:GetRegions() }
+    local numRegions = table.getn(regions)
+    for j = 1, numRegions do
+        local region = regions[j]
+        if region then
+            local ok, objType = pcall(region.GetObjectType, region)
+            if ok and objType == "FontString" then
+                -- This is a FontString - store as name text candidate
+                if not nameText then
+                    nameText = region
+                end
+            end
+        end
+    end
+
+    -- Must have at least a health bar to be a valid nameplate
+    if healthBar then
+        return healthBar, nameText
+    end
+
+    return nil
+end
+
+-- ==================================================================
+-- Create and attach a Kui-style threat bar to a nameplate
+-- ==================================================================
+function addon.Nameplates:AttachThreatBar(nameplate, healthBar, nameFontString)
+    if self.plates[nameplate] then return end
+    if not ThreatPlatesDB then return end
+
+    local db = ThreatPlatesDB
+
+    -- ==============================================================
+    -- Create the threat bar container frame
+    -- ==============================================================
+    local container = CreateFrame("Frame", nil, nameplate)
+    container:SetFrameLevel(nameplate:GetFrameLevel() + 10)
+
+    local barHeight = db.barHeight or 8
+    local offsetY = db.barOffsetY or 1
+    local offsetX = db.barOffsetX or -17.8
+    local widthScale = db.barWidthScale or 0.8
+
+    -- Position: anchored ABOVE the health bar, centered on it
+    -- widthScale controls how wide the bar is relative to the health bar
+    -- (1.0 = same width, 0.5 = half width, etc.)
+    local gap = 2 + offsetY  -- minimum 2px gap, plus user offset
+    local healthWidth = healthBar:GetWidth() or 100
+    local barWidth = math.floor(healthWidth * widthScale + 0.5)
+    -- Minimum width so the bar is always visible
+    if barWidth < 20 then barWidth = 20 end
+
+    container:ClearAllPoints()
+    container:SetPoint("BOTTOM", healthBar, "TOP", offsetX, gap)
+    container:SetWidth(barWidth)
+    container:SetHeight(barHeight + 2)
+
+    -- ==============================================================
+    -- Dark background (Kui-style)
+    -- ==============================================================
+    local bg = container:CreateTexture(nil, "BACKGROUND")
+    bg:SetTexture(SOLID_TEXTURE)
+    bg:SetVertexColor(0.06, 0.06, 0.06, 0.9)
+    bg:SetAllPoints(container)
+    container.bg = bg
+
+    -- ==============================================================
+    -- Shadow border (Kui-style, when enabled)
+    -- ==============================================================
+    if db.glowEnabled and db.glowAsShadow then
+        local glow = container:CreateTexture(nil, "BACKGROUND")
+        glow:SetTexture(SOLID_TEXTURE)
+        glow:SetVertexColor(0, 0, 0, 0.2)
+        local gs = db.glowSize or 3
+        glow:SetPoint("TOPLEFT", container, -gs, gs)
+        glow:SetPoint("BOTTOMRIGHT", container, gs, -gs)
+        container.glow = glow
+    end
+
+    -- ==============================================================
+    -- Threat status bar (inset 1px from container edges)
+    -- ==============================================================
+    local bar = CreateFrame("StatusBar", nil, container)
+    bar:SetFrameLevel(container:GetFrameLevel() + 1)
+    bar:SetStatusBarTexture(SOLID_TEXTURE)
+    bar:SetMinMaxValues(0, 100)
+    bar:ClearAllPoints()
+    bar:SetPoint("TOPLEFT", container, "TOPLEFT", 1, -1)
+    bar:SetPoint("BOTTOMRIGHT", container, "BOTTOMRIGHT", -1, 1)
+    bar:SetValue(0)
+    bar:SetStatusBarColor(0.33, 0.80, 0.33, db.barAlpha or 1)
+    container.bar = bar
+
+    -- ==============================================================
+    -- Fill background texture (dim colour behind the bar)
+    -- ==============================================================
+    if db.showFillBG then
+        local fill = bar:CreateTexture(nil, "BACKGROUND")
+        fill:SetTexture(SOLID_TEXTURE)
+        fill:SetAllPoints(bar)
+        fill:SetVertexColor(0.33, 0.80, 0.33)
+        fill:SetAlpha(db.fillAlpha or 0.2)
+        container.fill = fill
+    end
+
+    -- ==============================================================
+    -- Spark texture (bright leading edge)
+    -- ==============================================================
+    if db.showSpark then
+        local spark = bar:CreateTexture(nil, "ARTWORK")
+        spark:SetTexture(SOLID_TEXTURE)
+        spark:SetWidth(2)
+        spark:SetHeight(barHeight)
+        spark:SetVertexColor(1, 1, 1, 0.8)
+        spark:Hide()
+        container.spark = spark
+    end
+
+    -- ==============================================================
+    -- Threat text (outline font, centered in bar)
+    -- ==============================================================
+    if db.showText then
+        local text = bar:CreateFontString(nil, "OVERLAY")
+        local fSize = db.fontSize or 9
+        if db.fontOutline then
+            text:SetFont(FONT_PATH, fSize, "OUTLINE")
+        else
+            text:SetFont(FONT_PATH, fSize)
+        end
+        text:SetShadowColor(0, 0, 0, 1)
+        text:SetShadowOffset(1, -1)
+        text:SetPoint("CENTER", bar, "CENTER", 0, 0)
+        text:SetTextColor(1, 1, 1, 1)
+        text:SetJustifyH("CENTER")
+        text:SetJustifyV("MIDDLE")
+        text:SetText("")
+        container.text = text
+    end
+
+    -- ==============================================================
+    -- Threat glow (red glow for high threat)
+    -- ==============================================================
+    if db.glowEnabled then
+        local threatGlow = container:CreateTexture(nil, "BACKGROUND")
+        threatGlow:SetTexture(SOLID_TEXTURE)
+        local gs = db.glowSize or 3
+        threatGlow:SetPoint("TOPLEFT", container, -gs, gs)
+        threatGlow:SetPoint("BOTTOMRIGHT", container, gs, -gs)
+        threatGlow:SetVertexColor(0.9, 0, 0, 0)
+        threatGlow:Hide()
+        container.threatGlow = threatGlow
+    end
+
+    -- ==============================================================
+    -- Store the plate data
+    -- ==============================================================
+    local plateData = {
+        container      = container,
+        bar            = bar,
+        fill           = container.fill,
+        spark          = container.spark,
+        text           = container.text,
+        bg             = bg,
+        glow           = container.glow,
+        threatGlow     = container.threatGlow,
+        healthBar      = healthBar,
+        nameFontString = nameFontString,
+        nameplate      = nameplate,
+        unit           = nil,
+        guid           = nil,
+        lastPct        = 0,
+        plateName      = nil,
+        isUniqueName   = true,
+        lastThreatTime = nil,
+        -- Health tracking for combat detection without unit tokens.
+        -- These are updated every cycle in UpdateAllPlates.
+        previousHealth = nil,    -- health % from previous cycle
+        combatDetectedAt = nil,  -- timestamp when combat was first detected
+    }
+
+    self.plates[nameplate] = plateData
+
+    -- Show or hide based on visibility
+    if nameplate:IsVisible() then
+        self:OnNameplateShow(nameplate)
+    else
+        container:Hide()
+    end
+end
+
+-- ==================================================================
+-- Nameplate show handler
+-- ==================================================================
+function addon.Nameplates:OnNameplateShow(nameplate)
+    local data = self.plates[nameplate]
+    if not data then return end
+
+    self:ResolveNameplateName(nameplate)
+
+    if ThreatPlatesDB and ThreatPlatesDB.enabled then
+        data.container:Show()
+    else
+        data.container:Hide()
+    end
+end
+
+-- ==================================================================
+-- Read the name text from a nameplate
+-- ==================================================================
+function addon.Nameplates:ResolveNameplateName(nameplate)
+    local data = self.plates[nameplate]
+    if not data then return end
+
+    local name = GetPlateNameText(data, nameplate)
+
+    if name and strlen(name) > 0 then
+        data.plateName = name
+
+        -- Important for same-name mobs: only bind immediately if we can
+        -- resolve EXACTLY one visible unit token for this name. If there
+        -- are multiple candidates, defer assignment to ResolveVisiblePlateUnits.
+        local candidates = self:GetCandidateUnitsByName(name)
+        if table.getn(candidates) == 1 then
+            data.unit = candidates[1].unit
+            data.guid = addon:GetUnitID(candidates[1].unit)
+        else
+            data.unit = nil
+            data.guid = nil
+        end
+    else
+        data.plateName = nil
+        data.unit = nil
+        data.guid = nil
+    end
+end
+
+-- ==================================================================
+-- Find a unit token by its name
+-- ==================================================================
+function addon.Nameplates:FindUnitByName(name)
+    if not name then return nil end
+
+    -- Direct unit tokens (highest priority - these have full API access)
+    local quickUnits = { "target", "mouseover", "targettarget", "pet" }
+    for i = 1, table.getn(quickUnits) do
+        local unit = quickUnits[i]
+        local ok, exists = pcall(UnitExists, unit)
+        if ok and exists then
+            local ok2, uname = pcall(UnitName, unit)
+            if ok2 and uname and uname == name then
+                return unit
+            end
+        end
+    end
+
+    -- Party members' targets (gives us API access to mobs party members are targeting)
+    for i = 1, 4 do
+        local unit = "party" .. i .. "target"
+        local ok, exists = pcall(UnitExists, unit)
+        if ok and exists then
+            local ok2, uname = pcall(UnitName, unit)
+            if ok2 and uname and uname == name then
+                return unit
+            end
+        end
+    end
+
+    -- Party members' target-of-target (lets us see who a mob is targeting)
+    -- This is crucial for heuristic threat estimation in parties
+    for i = 1, 4 do
+        local unit = "party" .. i .. "targettarget"
+        local ok, exists = pcall(UnitExists, unit)
+        if ok and exists then
+            local ok2, uname = pcall(UnitName, unit)
+            if ok2 and uname and uname == name then
+                return unit
+            end
+        end
+    end
+
+    -- Raid member targets
+    for i = 1, 40 do
+        local unit = "raid" .. i .. "target"
+        local ok, exists = pcall(UnitExists, unit)
+        if ok and exists then
+            local ok2, uname = pcall(UnitName, unit)
+            if ok2 and uname and uname == name then
+                return unit
+            end
+        end
+    end
+
+    -- Raid member target-of-target
+    for i = 1, 40 do
+        local unit = "raid" .. i .. "targettarget"
+        local ok, exists = pcall(UnitExists, unit)
+        if ok and exists then
+            local ok2, uname = pcall(UnitName, unit)
+            if ok2 and uname and uname == name then
+                return unit
+            end
+        end
+    end
+
+    return nil
+end
+
+-- ==================================================================
+-- Update threat display for a specific unit
+-- ==================================================================
+function addon.Nameplates:UpdateThreatForUnit(unit, pct, situation)
+    if not ThreatPlatesDB or not ThreatPlatesDB.enabled then return end
+    if not unit or not UnitExists(unit) then return end
+
+    local realGuid = addon:SafeGUID(unit)
+
+    for nameplate, data in pairs(self.plates) do
+        local isMatch = false
+
+        -- In Vanilla, unit-name fallback is NOT unique for same-name mobs.
+        -- Therefore, match by exact unit token whenever possible.
+        if data.unit and UnitExists(data.unit) then
+            if IsSameUnitToken(data.unit, unit) then
+                isMatch = true
+            end
+        elseif realGuid and data.guid == realGuid then
+            -- GUID-based fallback is only safe on clients/servers that
+            -- actually expose UnitGUID.
+            isMatch = true
+        end
+
+        if isMatch then
+            self:ApplyThreatToPlate(data, pct, situation)
+        end
+    end
+end
+
+-- ==================================================================
+-- Apply threat values to a specific plate
+-- ==================================================================
+function addon.Nameplates:ApplyThreatToPlate(data, pct, situation)
+    if not data or not data.bar then return end
+    if not ThreatPlatesDB or not ThreatPlatesDB.enabled then
+        data.container:Hide()
+        return
+    end
+
+    -- Check visibility filters
+    if not self:ShouldShowOnPlate(data, situation) then
+        data.container:Hide()
+        return
+    end
+
+    -- FINAL SAFETY NET: If we have a unit token, verify the mob is
+    -- actually in combat. This catches any edge cases where the threat
+    -- system returned a non-zero percentage for an idle mob.
+    -- Without this check, healing threat split could still cause bars
+    -- to appear on nearby idle mobs that share a unit token.
+    if data.unit and UnitExists(data.unit) then
+        local ok, inCombat = pcall(UnitAffectingCombat, data.unit)
+        if ok and not inCombat then
+            data.container:Hide()
+            return
+        end
+    end
+
+    -- ADDITIONAL SAFETY NET for SAME-NAME mobs only:
+    -- If the nameplate health bar is at or near 100%, this is very
+    -- likely an idle mob that hasn't been attacked. A mob in active
+    -- combat with threat data should show damage on its health bar.
+    --
+    -- IMPORTANT: This check only applies when there are multiple
+    -- plates sharing the same name (same-name mobs). For UNIQUE-name
+    -- mobs (only one plate with this name visible), we rely on
+    -- IsPlateInCombat() which uses health-change detection, so this
+    -- full-health safety net is redundant and counterproductive.
+    --
+    -- The isUniqueName flag is set by UpdateAllPlates before calling
+    -- this function. If not set, default to false (apply safety net).
+    if not data.isUniqueName then
+        local plateHealthPct = GetPlateHealthPercent(data)
+        if plateHealthPct and plateHealthPct >= 99.5 then
+            -- Plate is at full/near-full health. Check if we have a
+            -- unit token in combat. If the unit token is valid and in
+            -- combat, it might be a freshly pulled mob — allow it.
+            -- Also allow if IsPlateInCombat detected a health decrease.
+            local unitInCombat = false
+            if data.unit and UnitExists(data.unit) then
+                local ok, inCombat = pcall(UnitAffectingCombat, data.unit)
+                if ok and inCombat then
+                    unitInCombat = true
+                end
+            end
+            -- Check health-change combat detection
+            local plateCombatDetected = IsPlateInCombat(data)
+            if not unitInCombat and not plateCombatDetected then
+                data.container:Hide()
+                return
+            end
+            -- Unit/plate appears in combat but at full health. This can
+            -- happen briefly after the first hit. Allow a short grace period.
+            if not data.lastThreatTime then
+                data.lastThreatTime = GetTime()
+            end
+            if GetTime() - data.lastThreatTime > 0.5 then
+                -- Showing a bar for 5+ seconds on a full-health
+                -- mob in combat. Likely a same-name mob mismatch.
+                data.container:Hide()
+                return
+            end
+        else
+            -- Mob is damaged, reset the grace period tracker
+            data.lastThreatTime = GetTime()
+        end
+    else
+        -- Unique-name mob: update the grace tracker but don't use
+        -- full-health as a reason to hide. ThreatEngine data for a
+        -- unique name is unambiguous.
+        data.lastThreatTime = GetTime()
+    end
+
+    -- If no threat percentage, hide the bar.
+    -- KEY FIX: Removed the old gate that required player to be in combat.
+    -- Now we only check if there's actual threat data to show. The combat
+    -- verification is done earlier in the pipeline (IsPlateInCombat,
+    -- GetThreatByName, etc.).
+    if pct == 0 then
+        data.container:Hide()
+        return
+    end
+
+    data.container:Show()
+
+    -- Smooth the percentage
+    local oldPct = data.lastPct or 0
+    local smoothPct
+    if pct == 0 then
+        smoothPct = 0
+    else
+        smoothPct = oldPct + (pct - oldPct) * 0.3
+    end
+    data.lastPct = smoothPct
+
+    smoothPct = math.min(100, math.max(0, smoothPct))
+    pct = math.min(100, math.max(0, pct))
+
+    -- Update bar value
+    data.bar:SetValue(smoothPct)
+
+    -- Update bar colour (smooth gradient)
+    local r, g, b = addon.Media.GetThreatColour(pct)
+    data.bar:SetStatusBarColor(r, g, b, ThreatPlatesDB.barAlpha or 1)
+
+    -- Update statusbar texture vertex colour
+    local tex = data.bar:GetStatusBarTexture()
+    if tex then
+        tex:SetVertexColor(r, g, b)
+    end
+
+    -- Update fill background
+    if data.fill then
+        data.fill:SetVertexColor(r, g, b)
+        data.fill:SetAlpha(ThreatPlatesDB.fillAlpha or 0.2)
+    end
+
+    -- Update spark
+    if data.spark then
+        if smoothPct > 0 and smoothPct < 100 then
+            -- Re-anchor spark to the leading edge of the bar fill
+            data.spark:ClearAllPoints()
+            if tex then
+                data.spark:SetPoint("TOP", tex, "TOPRIGHT", 0, 0)
+                data.spark:SetPoint("BOTTOM", tex, "BOTTOMRIGHT", 0, 0)
+            end
+            -- Brighten spark colour
+            local br = math.min(1, r + (1 - r) * 0.3)
+            local bg2 = math.min(1, g + (1 - g) * 0.3)
+            local bb = math.min(1, b + (1 - b) * 0.3)
+            data.spark:SetVertexColor(br, bg2, bb, 0.8)
+            data.spark:Show()
+        else
+            data.spark:Hide()
+        end
+    end
+
+    -- Update text
+    if data.text then
+        local displayPct = math.floor(pct + 0.5)
+        data.text:SetText(displayPct .. "%")
+
+        if pct >= 90 then
+            data.text:SetTextColor(1, 0.2, 0.2, 1)
+        elseif pct >= 60 then
+            data.text:SetTextColor(1, 0.9, 0.8, 1)
+        else
+            data.text:SetTextColor(1, 1, 1, 1)
+        end
+    end
+
+    -- Update threat glow
+    if data.threatGlow then
+        if pct >= 80 then
+            local intensity = (pct - 80) / 20
+            data.threatGlow:SetVertexColor(0.9, 0, 0, 0.6 * intensity)
+            data.threatGlow:Show()
+        else
+            data.threatGlow:Hide()
+        end
+    end
+end
+
+-- ==================================================================
+-- Should this plate show a threat bar based on settings?
+-- KEY CHANGE: Now shows threat bars for mobs attacking any group
+-- member, not just the player. This ensures ALL attacking mobs
+-- display threat percentages.
+-- ==================================================================
+function addon.Nameplates:ShouldShowOnPlate(data, situation)
+    if not ThreatPlatesDB then return false end
+    if not ThreatPlatesDB.enabled then return false end
+
+    local unit = data.unit
+    if not unit then
+        -- No unit token resolved. Check if the mob is attacking
+        -- a group member via mob target name heuristic.
+        -- This allows threat bars to appear on nameplates even
+        -- when we can't resolve a unit token.
+        if data.plateName then
+            -- Try to find who this mob is targeting
+            local foundUnit = self:FindUnitByName(data.plateName)
+            if foundUnit then
+                local ok_mt, mt = pcall(UnitName, foundUnit .. "target")
+                if ok_mt and mt then
+                    -- Mob is targeting someone in our group
+                    if mt == UnitName("player") or addon.Threat:IsPartyMember(mt) then
+                        return ThreatPlatesDB.showOnHostile
+                    end
+                end
+            end
+        end
+        return true
+    end
+
+    if not UnitExists(unit) then return false end
+
+    local reaction = UnitReaction(unit, "player")
+    if not reaction then return true end
+
+    if reaction <= 3 then
+        return ThreatPlatesDB.showOnHostile
+    elseif reaction == 4 then
+        return ThreatPlatesDB.showOnNeutral
+    else
+        return ThreatPlatesDB.showOnFriendly
+    end
+end
+
+-- ==================================================================
+-- Find a combat-verified unit token for a nameplate that has no
+-- resolved unit token. This is the same-name mob disambiguator.
+--
+-- Strategy:
+--   1. Find ALL unit tokens matching the plate's name
+--   2. Filter to only those that are in combat (UnitAffectingCombat)
+--   3. Score remaining candidates by health % match with the plate
+--   4. Return the best match, or nil if no combat unit found
+--
+-- Returns: unit token string, or nil
+-- ==================================================================
+function addon.Nameplates:FindCombatUnitForPlate(data)
+    if not data or not data.plateName then return nil end
+    if strlen(data.plateName) == 0 then return nil end
+
+    -- KEY FIX: Only require that someone in the group is in combat,
+    -- not necessarily the player. This allows finding combat units
+    -- for mobs attacking party/raid members.
+    if not addon.ThreatEngine:IsGroupInCombat() then return nil end
+
+    local name = data.plateName
+
+    -- Collect ALL unit tokens matching this name
+    local candidates = self:GetCandidateUnitsByName(name)
+    if table.getn(candidates) == 0 then return nil end
+
+    -- Get plate health percentage for matching
+    local plateHealthPct = GetPlateHealthPercent(data)
+
+    -- Score each candidate: we want a unit that is:
+    --   1. In combat (mandatory — idle mobs must never match)
+    --   2. Health % close to the plate's health bar
+    --   3. Hostile and attackable
+    local bestUnit = nil
+    local bestScore = -999999
+
+    for i = 1, table.getn(candidates) do
+        local c = candidates[i]
+
+        -- MANDATORY: Unit must be in combat
+        if c.inCombat then
+            local score = 0
+
+            -- Health % matching (most important discriminator)
+            if plateHealthPct and c.healthPct then
+                local diff = math.abs(plateHealthPct - c.healthPct)
+                -- Close health match = strong signal this is the right mob
+                score = score + math.max(0, 500 - (diff * 15))
+            end
+
+            -- Hostile/attackable bonus
+            if c.canAttack then
+                score = score + 50
+            end
+
+            if score > bestScore then
+                bestScore = score
+                bestUnit = c.unit
+            end
+        end
+    end
+
+    return bestUnit
+end
+
+-- ==================================================================
+-- Update all plates (called periodically)
+--
+-- DESIGN: Shows threat bars for ALL mobs in combat with the player
+-- or any group member, not just the targeted mob.
+--
+-- COMBAT DETECTION STRATEGY:
+--   In Vanilla 1.12, non-targeted mobs have NO unit tokens.
+--   We use THREE methods to detect if a mob is in combat:
+--     1. Unit token API (UnitAffectingCombat) — if we have a token
+--     2. Health decrease detection — if the plate's health bar is
+--        dropping, the mob is taking damage and is in combat
+--     3. ThreatEngine data — if we have threat data for this mob,
+--        someone in the group has hit it, so it's in combat
+--
+-- SAME-NAME MOB HANDLING:
+--   - UNIQUE-name mobs (only 1 plate with that name): ThreatEngine
+--     data is unambiguous. Can use it directly.
+--   - SAME-name mobs (multiple plates share a name): Must verify
+--     combat to avoid showing threat on idle same-name mobs.
+--     Health-change detection is the KEY discriminator — idle mobs
+--     stay at 100% health while combat mobs take damage.
+--
+-- This approach ensures:
+--   - All attacking mobs show threat bars (multi-mob requirement)
+--   - Idle same-name mobs don't get false threat bars
+--   - Mobs attacking party members show threat even when player
+--     isn't in combat
+-- ==================================================================
+function addon.Nameplates:UpdateAllPlates()
+    if not ThreatPlatesDB or not ThreatPlatesDB.enabled then
+        for nameplate, data in pairs(self.plates) do
+            data.container:Hide()
+        end
+        return
+    end
+
+    local now = GetTime()
+    local groupInCombat = addon.ThreatEngine:IsGroupInCombat()
+
+    -- Step 1: Count how many visible plates share each name.
+    -- This determines whether a name is unique or ambiguous.
+    local platesPerName = {}
+    for nameplate, data in pairs(self.plates) do
+        if nameplate:IsVisible() and data.plateName then
+            if not platesPerName[data.plateName] then
+                platesPerName[data.plateName] = 0
+            end
+            platesPerName[data.plateName] = platesPerName[data.plateName] + 1
+        end
+    end
+
+    -- Step 2: Resolve unit tokens for all visible plates.
+    -- ResolveVisiblePlateUnits handles same-name mob assignment via
+    -- health-matching and combat-status scoring.
+    self:ResolveVisiblePlateUnits()
+
+    -- Step 3: Update health tracking for combat detection.
+    -- Store current health for comparison next cycle.
+    -- This is done BEFORE the main update loop so IsPlateInCombat
+    -- can use the previous cycle's health for change detection.
+    for nameplate, data in pairs(self.plates) do
+        if nameplate:IsVisible() then
+            local currentHealth = GetPlateHealthPercent(data)
+            -- We'll update previousHealth AFTER the main loop,
+            -- so IsPlateInCombat can compare current vs previous.
+            data._currentHealth = currentHealth
+        end
+    end
+
+    -- Step 4: Update threat display for each visible plate.
+    for nameplate, data in pairs(self.plates) do
+        if nameplate:IsVisible() then
+            local isUniqueName = (platesPerName[data.plateName] or 1) <= 1
+            data.isUniqueName = isUniqueName
+
+            local plateInCombat = IsPlateInCombat(data)
+            local hasThreatData = data.plateName and addon.ThreatEngine:HasDataForTarget(data.plateName)
+
+            if data.unit and UnitExists(data.unit) then
+                -- We have a resolved unit token. Verify it's in combat.
+                local ok_combat, mobInCombat = pcall(UnitAffectingCombat, data.unit)
+                if ok_combat and not mobInCombat then
+                    -- Unit is NOT in combat — idle mob. Never show threat.
+                    data.container:Hide()
+                else
+                    -- Unit is in combat (or can't verify). Get threat.
+                    local pct, situation = addon.Threat:GetThreatPercent(data.unit)
+                    self:ApplyThreatToPlate(data, pct, situation or 0)
+                end
+            elseif isUniqueName and data.plateName then
+                -- UNIQUE-NAME MOB with no unit token:
+                -- This is the common case for non-targeted attacking mobs.
+                -- Since only ONE mob on screen has this name, ThreatEngine
+                -- data is unambiguous. Use health-based combat detection.
+
+                if plateInCombat then
+                    -- Mob is in combat (health dropping or below 100%).
+                    -- Record when we first detected combat for grace period.
+                    if not data.combatDetectedAt then
+                        data.combatDetectedAt = now
+                    end
+
+                    -- Try ThreatEngine data first
+                    local pct, sit = addon.Threat:GetThreatByName(data.plateName)
+                    if pct > 0 then
+                        self:ApplyThreatToPlate(data, pct, sit or 0)
+                    else
+                        -- No ThreatEngine data but mob IS in combat.
+                        -- This happens for body pulls, or when only
+                        -- a party member has hit the mob.
+                        --
+                        -- If a group member is in combat, show a default
+                        -- threat bar. The mob is fighting someone.
+                        if groupInCombat then
+                            self:ApplyThreatToPlate(data, 100, 3)
+                        else
+                            data.container:Hide()
+                        end
+                    end
+                elseif hasThreatData and groupInCombat then
+                    -- Plate looks idle (full health) but ThreatEngine has
+                    -- data and group is in combat. This can happen briefly
+                    -- after a mob is first hit (health bar hasn't updated)
+                    -- or for a mob being attacked by someone else.
+                    -- Give a grace period.
+                    if not data.combatDetectedAt then
+                        data.combatDetectedAt = now
+                    end
+                    if now - data.combatDetectedAt < 0.5 then
+                        local pct, sit = addon.Threat:GetThreatByName(data.plateName)
+                        if pct > 0 then
+                            self:ApplyThreatToPlate(data, pct, sit or 0)
+                        else
+                            self:ApplyThreatToPlate(data, 100, 3)
+                        end
+                    else
+                        -- Grace period expired and health still at 100%.
+                        -- This is likely an idle mob. Hide bar.
+                        data.combatDetectedAt = nil
+                        data.container:Hide()
+                    end
+                elseif groupInCombat then
+                    -- No health decrease, no ThreatEngine data, but group
+                    -- is in combat. Check if this mob is attacking a group
+                    -- member by looking for a unit token via party targets.
+                    --
+                    -- This catches the case of a body-pulled mob (at 100%
+                    -- health, no damage dealt to it yet, but actively
+                    -- attacking a group member).
+                    local mobAttackingGroup = false
+                    local foundUnit = self:FindUnitByName(data.plateName)
+                    if foundUnit then
+                        local ok_mt, mt = pcall(UnitName, foundUnit .. "target")
+                        if ok_mt and mt then
+                            if mt == UnitName("player") or addon.Threat:IsPartyMember(mt) then
+                                mobAttackingGroup = true
+                            end
+                        end
+                    end
+
+                    if mobAttackingGroup then
+                        -- Mob is confirmed attacking a group member!
+                        -- Show a high-threat bar.
+                        if not data.combatDetectedAt then
+                            data.combatDetectedAt = now
+                        end
+                        self:ApplyThreatToPlate(data, 100, 3)
+                    else
+                        -- Can't confirm mob is attacking anyone.
+                        -- It might be idle. Don't show bar.
+                        data.combatDetectedAt = nil
+                        data.container:Hide()
+                    end
+                else
+                    -- No combat detected, no threat data, group not in combat.
+                    data.combatDetectedAt = nil
+                    data.container:Hide()
+                end
+            elseif not isUniqueName and data.plateName then
+                -- SAME-NAME MOB with no unit token:
+                -- Multiple plates share this name. Must be careful.
+                -- Use health-based combat detection as the primary filter.
+
+                if plateInCombat then
+                    -- This specific plate's health is dropping — it's in combat.
+                    if not data.combatDetectedAt then
+                        data.combatDetectedAt = now
+                    end
+
+                    -- Try to find a combat-verified unit with matching health.
+                    local unit = self:FindCombatUnitForPlate(data)
+                    if unit then
+                        data.unit = unit
+                        data.guid = addon:GetUnitID(unit)
+                        local pct, situation = addon.Threat:GetThreatPercent(unit)
+                        self:ApplyThreatToPlate(data, pct, situation or 0)
+                    elseif hasThreatData then
+                        -- No matching unit token but ThreatEngine has data.
+                        -- For same-name mobs this is ambiguous, but the
+                        -- health-drop verification means THIS plate IS in
+                        -- combat, so it's safe to show ThreatEngine data.
+                        local pct, sit = addon.Threat:GetThreatByName(data.plateName)
+                        if pct > 0 then
+                            self:ApplyThreatToPlate(data, pct, sit or 0)
+                        else
+                            -- In combat but no threat data — mob is being
+                            -- attacked by someone we can't track.
+                            if groupInCombat then
+                                self:ApplyThreatToPlate(data, 100, 3)
+                            else
+                                data.container:Hide()
+                            end
+                        end
+                    else
+                        -- In combat (health dropping) but no ThreatEngine data.
+                        -- Show default high-threat bar.
+                        if groupInCombat then
+                            self:ApplyThreatToPlate(data, 100, 3)
+                        else
+                            data.container:Hide()
+                        end
+                    end
+                else
+                    -- Same-name plate at full health and stable — likely idle.
+                    -- But check if a unit token reveals this specific mob
+                    -- is attacking a group member (body pull scenario).
+                    if groupInCombat then
+                        local unit = self:FindCombatUnitForPlate(data)
+                        if unit then
+                            -- Found a combat-verified unit for this plate.
+                            data.unit = unit
+                            data.guid = addon:GetUnitID(unit)
+                            local pct, situation = addon.Threat:GetThreatPercent(unit)
+                            if pct > 0 then
+                                if not data.combatDetectedAt then
+                                    data.combatDetectedAt = now
+                                end
+                                self:ApplyThreatToPlate(data, pct, situation or 0)
+                            else
+                                data.combatDetectedAt = nil
+                                data.container:Hide()
+                            end
+                        else
+                            -- No combat unit found. Idle same-name mob.
+                            data.combatDetectedAt = nil
+                            data.container:Hide()
+                        end
+                    else
+                        data.combatDetectedAt = nil
+                        data.container:Hide()
+                    end
+                end
+            else
+                -- No plate name at all — can't determine anything.
+                data.container:Hide()
+            end
+        else
+            -- Plate not visible
+            data.combatDetectedAt = nil
+            data.container:Hide()
+        end
+    end
+
+    -- Step 5: Update previousHealth for next cycle's change detection.
+    for nameplate, data in pairs(self.plates) do
+        data.previousHealth = data._currentHealth
+        data._currentHealth = nil
+    end
+end
+
+-- ==================================================================
+-- Force update all (called on settings change)
+-- ==================================================================
+function addon.Nameplates:UpdateAll()
+    for nameplate, data in pairs(self.plates) do
+        if ThreatPlatesDB and ThreatPlatesDB.enabled then
+            data.container:Show()
+        else
+            data.container:Hide()
+        end
+    end
+    self:UpdateAllPlates()
+end
+
+-- ==================================================================
+-- Recreate all bars (called when visual settings change)
+-- ==================================================================
+function addon.Nameplates:RecreateAll()
+    for nameplate, data in pairs(self.plates) do
+        if data.container then
+            data.container:Hide()
+            data.container:SetParent(nil)
+        end
+        self.plates[nameplate] = nil
+    end
+    -- Don't clear knownPlates - we need to re-scan for new nameplates
+    -- But we do need to re-attach to known ones
+    knownPlates = {}
+    self:ScanForNameplates()
+end
diff --git a/ThreatPlates_Threat.lua b/ThreatPlates_Threat.lua
new file mode 100644
index 0000000..d64e53d
--- /dev/null
+++ b/ThreatPlates_Threat.lua
@@ -0,0 +1,828 @@
+----------------------------------------------------------------------
+-- ThreatPlates_Threat.lua
+-- Threat calculation bridge for WoW 1.12 (Vanilla API)
+-- Works with Turtle WoW / Octo WoW threat hooks
+-- Standalone - does not require Omen, KLHThreatMeter, or any lib
+--
+-- THREAT DATA SOURCES (in priority order):
+--   1. UnitDetailedThreatSituation (Turtle WoW server extension)
+--   2. GetThreatPercent API (custom server extension)
+--   3. UnitThreatSituation (partial API on some servers)
+--   4. ThreatEngine combat log parsing (precise per-1% values)
+--   5. Target-based heuristic (crude fallback for edge cases only)
+--
+-- The ThreatEngine (ThreatPlates_ThreatEngine.lua) parses combat log
+-- events using GlobalStrings pattern matching to calculate accurate
+-- absolute threat values per mob per player, then derives precise
+-- percentages as (playerThreat / topThreat) * 100.
+----------------------------------------------------------------------
+-- CHANGES (multi-mob threat display fix):
+--   * GetThreatPercent now checks ALL party/raid members' threat
+--     on each mob, not just the player's own threat
+--   * Added groupThreatCache: per-mob cache of best threat from
+--     any group member, so ALL attacking mobs show accurate %
+--   * Added ScanGroupThreat: iterates party/raid members against
+--     each visible hostile mob using native threat APIs
+--   * Added ThreatEngine group parsing: CHAT_MSG_SPELL_PARTY_*
+--     and CHAT_MSG_SPELL_FRIENDLYPLAYER_* events now tracked
+--   * Mobs attacking any group member now show threat bars,
+--     not just mobs attacking the player
+--   * Previous fixes preserved: UnitAffectingCombat checks,
+--     idle mob filtering, Vanilla 1.12 compatibility
+----------------------------------------------------------------------
+
+local addon = ThreatPlates
+
+addon.Threat = {}
+
+-- Cache for threat values per unit identifier (name-based in 1.12)
+local threatCache = {}
+
+-- Group-wide threat cache: groupThreatCache[mobUID] = {
+--   bestPct, bestSit, bestSource, mobTargetName, lastUpdate,
+--   playerPct, playerSit,
+--   sources = { [sourceName] = { pct, sit } }
+-- }
+-- This stores the BEST threat from ANY group member for each mob,
+-- so all attacking mobs show accurate percentages.
+local groupThreatCache = {}
+
+-- Player name cache
+local playerName = nil
+
+-- Party/raid member names cache: name -> unitToken
+local partyNames = {}
+
+-- Party/raid unit tokens cache (ordered list)
+local partyUnits = {}
+
+-- Update throttle (seconds)
+local THROTTLE = 0.2
+
+-- ==================================================================
+-- Safe API call helpers
+-- ==================================================================
+local function SafeCall2(func, a, b)
+    if not func then return nil end
+    local ok, r1 = pcall(func, a, b)
+    if ok then return r1 end
+    return nil
+end
+
+local function SafeCall5(func, a, b)
+    if not func then return nil, nil, nil, nil, nil end
+    local ok, r1, r2, r3, r4, r5 = pcall(func, a, b)
+    if ok then return r1, r2, r3, r4, r5 end
+    return nil, nil, nil, nil, nil
+end
+
+-- ==================================================================
+-- Detect which threat APIs are available at runtime
+-- ==================================================================
+local hasUnitDetailedThreatSituation = false
+local hasGetThreatPercent = false
+local hasUnitThreatSituation = false
+
+local function DetectThreatAPIs()
+    hasUnitDetailedThreatSituation = (UnitDetailedThreatSituation ~= nil)
+    hasGetThreatPercent = (GetThreatPercent ~= nil)
+    hasUnitThreatSituation = (UnitThreatSituation ~= nil)
+
+    if hasUnitDetailedThreatSituation then
+        addon:ui_print("UnitDetailedThreatSituation detected")
+    end
+    if hasGetThreatPercent then
+        addon:ui_print("GetThreatPercent detected")
+    end
+    if hasUnitThreatSituation then
+        addon:ui_print("UnitThreatSituation detected")
+    end
+    if not hasUnitDetailedThreatSituation and not hasGetThreatPercent and not hasUnitThreatSituation then
+        addon:ui_print("No native threat API - using combat log parsing + heuristic")
+    end
+end
+
+-- ==================================================================
+-- Cache party/raid member names for threat heuristic
+-- ==================================================================
+local function UpdatePartyNames()
+    partyNames = {}
+    partyUnits = {}
+    -- Player
+    if playerName then
+        partyNames[playerName] = "player"
+        partyUnits[1] = "player"
+    end
+    -- Party
+    for i = 1, 4 do
+        local unit = "party" .. i
+        if UnitExists(unit) then
+            local ok, name = pcall(UnitName, unit)
+            if ok and name then
+                partyNames[name] = unit
+                partyUnits[table.getn(partyUnits) + 1] = unit
+            end
+        end
+    end
+    -- Raid
+    for i = 1, 40 do
+        local unit = "raid" .. i
+        if UnitExists(unit) then
+            local ok, name = pcall(UnitName, unit)
+            if ok and name then
+                partyNames[name] = unit
+                partyUnits[table.getn(partyUnits) + 1] = unit
+            end
+        end
+    end
+end
+
+-- ==================================================================
+-- Scan group threat: check all party/raid members' threat on
+-- a specific mob unit using native threat APIs.
+--
+-- Returns: bestPct, bestSit, bestSourceName, playerPct, playerSit
+--   bestPct = highest threat % from any group member
+--   bestSit = threat situation of the member with highest threat
+--   bestSourceName = name of the group member with highest threat
+--   playerPct = the player's own threat % on this mob
+--   playerSit = the player's own threat situation
+--
+-- If no native APIs are available, returns nil (caller should
+-- fall through to ThreatEngine / heuristic).
+-- ==================================================================
+local function ScanGroupThreatOnUnit(mobUnit)
+    if not mobUnit or not UnitExists(mobUnit) then
+        return nil
+    end
+
+    -- Only scan if at least one native threat API is available
+    if not hasUnitDetailedThreatSituation and not hasGetThreatPercent
+       and not hasUnitThreatSituation then
+        return nil
+    end
+
+    local bestPct = 0
+    local bestSit = 0
+    local bestSource = nil
+    local playerPct = 0
+    local playerSit = 0
+
+    for i = 1, table.getn(partyUnits) do
+        local groupUnit = partyUnits[i]
+        if UnitExists(groupUnit) then
+            local memberPct = nil
+            local memberSit = nil
+
+            -- Method 1: UnitDetailedThreatSituation
+            if hasUnitDetailedThreatSituation then
+                local isTanking, status, scaledPct, rawPct, threatVal =
+                    SafeCall5(UnitDetailedThreatSituation, groupUnit, mobUnit)
+                if rawPct then
+                    memberPct = math.min(100, math.max(0, rawPct))
+                    memberSit = status or 0
+                end
+            end
+
+            -- Method 2: GetThreatPercent
+            if not memberPct and hasGetThreatPercent then
+                local pct = SafeCall2(GetThreatPercent, groupUnit, mobUnit)
+                if pct then
+                    memberPct = math.min(100, math.max(0, pct))
+                    if hasUnitThreatSituation then
+                        memberSit = SafeCall2(UnitThreatSituation, groupUnit, mobUnit) or 0
+                    else
+                        if memberPct >= 100 then memberSit = 3
+                        elseif memberPct >= 60 then memberSit = 2
+                        elseif memberPct >= 30 then memberSit = 1
+                        else memberSit = 0 end
+                    end
+                end
+            end
+
+            -- Method 3: UnitThreatSituation
+            if not memberPct and hasUnitThreatSituation then
+                memberSit = SafeCall2(UnitThreatSituation, groupUnit, mobUnit) or 0
+                if memberSit == 0 then
+                    memberPct = 0
+                elseif memberSit == 1 then
+                    memberPct = 25
+                elseif memberSit == 2 then
+                    memberPct = 60
+                elseif memberSit == 3 then
+                    memberPct = 100
+                end
+            end
+
+            if memberPct then
+                -- Track player's own threat specifically
+                if groupUnit == "player" then
+                    playerPct = memberPct
+                    playerSit = memberSit or 0
+                end
+
+                -- Track the best threat from any group member
+                if memberPct > bestPct then
+                    bestPct = memberPct
+                    bestSit = memberSit or 0
+                    local ok, name = pcall(UnitName, groupUnit)
+                    bestSource = (ok and name) or groupUnit
+                end
+            end
+        end
+    end
+
+    return bestPct, bestSit, bestSource, playerPct, playerSit
+end
+
+-- ==================================================================
+-- Check if a name belongs to a party/raid member
+-- Returns: true if the name is a group member, false otherwise
+-- ==================================================================
+function addon.Threat:IsPartyMember(name)
+    if not name then return false end
+    if name == playerName then return true end
+    if partyNames[name] then return true end
+    return false
+end
+
+-- ==================================================================
+-- Initialize threat module
+-- ==================================================================
+function addon.Threat:Initialize()
+    playerName = UnitName("player")
+
+    -- Detect available APIs
+    DetectThreatAPIs()
+
+    -- Cache party names
+    UpdatePartyNames()
+
+    -- Polling frame for periodic threat updates
+    self.pollFrame = CreateFrame("Frame", "ThreatPlatesPollFrame")
+    self.pollFrame.elapsed = 0
+    self.pollFrame:SetScript("OnUpdate", function()
+        this.elapsed = this.elapsed + arg1
+        if this.elapsed >= THROTTLE then
+            this.elapsed = 0
+            addon.Threat:PollThreat()
+        end
+    end)
+
+    -- Event frame for threat-related events
+    local eventFrame = CreateFrame("Frame", "ThreatPlatesEventFrame")
+    eventFrame:RegisterEvent("PLAYER_TARGET_CHANGED")
+    eventFrame:RegisterEvent("PARTY_MEMBERS_CHANGED")
+    eventFrame:RegisterEvent("RAID_ROSTER_UPDATE")
+
+    -- Safely register threat event only if API exists
+    if hasUnitThreatSituation or hasUnitDetailedThreatSituation then
+        eventFrame:RegisterEvent("UNIT_THREAT_SITUATION_UPDATE")
+    end
+
+    eventFrame:SetScript("OnEvent", function()
+        addon.Threat:OnEvent(event)
+    end)
+
+    self.eventFrame = eventFrame
+end
+
+-- ==================================================================
+-- Event handler
+-- ==================================================================
+function addon.Threat:OnEvent(ev)
+    if ev == "PLAYER_TARGET_CHANGED" then
+        self:PollThreat()
+    elseif ev == "UNIT_THREAT_SITUATION_UPDATE" then
+        local unit = arg1
+        if unit and UnitExists(unit) then
+            self:UpdateUnitThreat(unit)
+        end
+    elseif ev == "PARTY_MEMBERS_CHANGED" or ev == "RAID_ROSTER_UPDATE" then
+        UpdatePartyNames()
+        self:PollThreat()
+    end
+end
+
+-- ==================================================================
+-- Poll threat for all visible nameplates
+-- ==================================================================
+function addon.Threat:PollThreat()
+    if not ThreatPlatesDB or not ThreatPlatesDB.enabled then
+        return
+    end
+
+    for nameplate, data in pairs(addon.Nameplates.plates) do
+        if nameplate:IsVisible() and data.unit then
+            self:UpdateUnitThreat(data.unit)
+        end
+    end
+end
+
+-- ==================================================================
+-- Get threat percentage for a unit
+-- Returns: threatPct (0-100), threatSit (0-3)
+--
+-- PRIORITY:
+--   1. Group-wide scan via UnitDetailedThreatSituation (Turtle WoW)
+--   2. Group-wide scan via GetThreatPercent API (custom extension)
+--   3. Group-wide scan via UnitThreatSituation (partial API)
+--   4. ThreatEngine combat log data (precise per-1% values)
+--   5. Target-based heuristic (crude fallback only)
+--
+-- KEY CHANGE: Methods 1-3 now check ALL party/raid members' threat
+-- on the mob, not just the player. This ensures that:
+--   - Mobs attacking the player show the player's threat %
+--   - Mobs attacking party members show those members' threat %
+--   - ALL mobs in combat with the group show accurate threat bars
+----------------------------------------------------------------------
+
+function addon.Threat:GetThreatPercent(unit)
+    if not unit or not UnitExists(unit) then
+        return 0, 0
+    end
+
+    -- ==============================================================
+    -- Pre-filter: Only check threat for hostile, in-combat mobs
+    -- These checks apply regardless of which method we use below.
+    -- ==============================================================
+
+    -- Only check threat for hostile units
+    local reaction = UnitReaction(unit, "player")
+    if reaction and reaction > 4 then
+        -- Friendly unit - no threat display
+        return 0, 0
+    end
+
+    -- Check if player OR any group member is in combat.
+    -- CRITICAL FIX: Previously only checked UnitAffectingCombat("player"),
+    -- which meant mobs attacking party members showed no threat when the
+    -- player wasn't in combat. Now we check the entire group.
+    local playerInCombat = UnitAffectingCombat("player")
+    local groupInCombat = addon.ThreatEngine:IsGroupInCombat()
+
+    -- The MOB itself must be in combat.
+    local ok_mc, mobCombat = pcall(UnitAffectingCombat, unit)
+    if ok_mc and not mobCombat then
+        return 0, 0
+    end
+
+    -- Verify this is a hostile unit the player can attack
+    local ok_ca, canAttack = pcall(UnitCanAttack, "player", unit)
+    if ok_ca and not canAttack then
+        -- Also check if any group member can attack it
+        local groupCanAttack = false
+        for i = 1, table.getn(partyUnits) do
+            local ok_gca, gca = pcall(UnitCanAttack, partyUnits[i], unit)
+            if ok_gca and gca then
+                groupCanAttack = true
+                break
+            end
+        end
+        if not groupCanAttack then
+            return 0, 0
+        end
+    end
+
+    -- Get mob name and who the mob is targeting (used by multiple methods)
+    local ok_name, mobName = pcall(UnitName, unit)
+    if not ok_name or not mobName then
+        return 0, 0
+    end
+
+    local mobTargetName = nil
+    local ok_mt, mt = pcall(UnitName, unit .. "target")
+    if ok_mt and mt then
+        mobTargetName = mt
+    end
+
+    -- ==============================================================
+    -- Methods 1-3: Group-wide native threat API scan
+    -- Check ALL party/raid members' threat on this mob.
+    -- This is the KEY fix: instead of only checking the player's
+    -- threat, we check every group member and return the best.
+    -- ==============================================================
+
+    if hasUnitDetailedThreatSituation or hasGetThreatPercent or hasUnitThreatSituation then
+        local bestPct, bestSit, bestSource, playerPct, playerSit =
+            ScanGroupThreatOnUnit(unit)
+
+        if bestPct and bestPct > 0 then
+            -- We have threat data from at least one group member.
+
+            -- Determine whose threat to display:
+            -- If the mob is targeting the player -> show player's threat
+            -- If the mob is targeting a group member -> show that member's threat
+            -- If the mob is targeting an outsider -> show player's threat
+            -- Otherwise -> show the best (highest) threat from any member
+
+            if mobTargetName == playerName then
+                -- Mob is attacking the player - show player's own threat
+                return playerPct, playerSit
+            elseif mobTargetName and partyNames[mobTargetName] then
+                -- Mob is attacking a group member - show that member's threat
+                -- Look up that member's threat from the group scan
+                local memberUnit = partyNames[mobTargetName]
+                local memberPct = nil
+                local memberSit = nil
+
+                if hasUnitDetailedThreatSituation then
+                    local _, status, _, rawPct = SafeCall5(UnitDetailedThreatSituation, memberUnit, unit)
+                    if rawPct then
+                        memberPct = math.min(100, math.max(0, rawPct))
+                        memberSit = status or 0
+                    end
+                end
+
+                if not memberPct and hasGetThreatPercent then
+                    local pct = SafeCall2(GetThreatPercent, memberUnit, unit)
+                    if pct then
+                        memberPct = math.min(100, math.max(0, pct))
+                        if hasUnitThreatSituation then
+                            memberSit = SafeCall2(UnitThreatSituation, memberUnit, unit) or 0
+                        else
+                            if memberPct >= 100 then memberSit = 3
+                            elseif memberPct >= 60 then memberSit = 2
+                            elseif memberPct >= 30 then memberSit = 1
+                            else memberSit = 0 end
+                        end
+                    end
+                end
+
+                if not memberPct and hasUnitThreatSituation then
+                    memberSit = SafeCall2(UnitThreatSituation, memberUnit, unit) or 0
+                    if memberSit == 0 then memberPct = 0
+                    elseif memberSit == 1 then memberPct = 25
+                    elseif memberSit == 2 then memberPct = 60
+                    elseif memberSit == 3 then memberPct = 100 end
+                end
+
+                if memberPct then
+                    return memberPct, memberSit or 0
+                end
+
+                -- Fallback: can't get specific member data, use best
+                return bestPct, bestSit
+            else
+                -- Mob targets an outsider, or we can't see its target.
+                -- Show player's threat if they have any, otherwise the
+                -- best group threat.
+                if playerPct > 0 then
+                    return playerPct, playerSit
+                end
+                return bestPct, bestSit
+            end
+        end
+
+        -- All group members have 0 threat on this mob via native APIs,
+        -- but the mob IS in combat. This can happen if:
+        --   - Only ThreatEngine has data (combat log parsing)
+        --   - The mob is fighting an outsider
+        --   - The mob was just pulled and the API hasn't updated yet
+        -- Fall through to ThreatEngine / heuristic below.
+    end
+
+    -- ==============================================================
+    -- Method 4: ThreatEngine combat log parsing
+    -- This provides precise per-1% threat values based on actual
+    -- damage/healing/ability threat tracked from the combat log.
+    -- This is the PRIMARY method on servers without native APIs.
+    --
+    -- KEY FIX: Now uses group combat state instead of only player combat.
+    -- If any group member is in combat, ThreatEngine data is relevant.
+    -- ==============================================================
+
+    -- Someone in the group must be in combat for ThreatEngine data
+    -- to be relevant. This prevents threat bars on idle mobs when
+    -- no one in the group is fighting.
+    if not groupInCombat then
+        return 0, 0
+    end
+
+    -- If the mob targets an outsider (someone not in the
+    -- player's party/raid), verify the player has actually engaged
+    -- this mob personally before showing any threat bar.
+    if mobTargetName and mobTargetName ~= playerName and not partyNames[mobTargetName] then
+        -- Mob targets someone outside our group.
+        -- Check if the player has personally hit this mob.
+        -- If player has 0 threat on this mob, don't show a bar.
+        local playerThreat = addon.ThreatEngine:GetPlayerThreat(mobName)
+        if playerThreat <= 0 then
+            return 0, 0
+        end
+        -- Player has some threat but mob targets an outsider.
+        -- The player's threat is secondary - show it but reduced.
+        -- We can't know the outsider's threat, so estimate conservatively.
+        -- Use ThreatEngine data if available, otherwise heuristic.
+        local enginePct, engineSit, _, _, hasGroupData = addon.ThreatEngine:GetThreatOnTarget(mobName)
+        if enginePct > 0 then
+            if hasGroupData then
+                return enginePct, engineSit
+            end
+            -- Solo data only - the outsider probably has more threat.
+            -- Cap our displayed percentage conservatively.
+            if enginePct >= 100 then
+                return 80, 2
+            end
+            return enginePct, engineSit
+        end
+        -- No ThreatEngine data but player is hitting it - rough estimate
+        if UnitIsUnit("target", unit) then
+            return 40, 1
+        end
+        return 20, 0
+    end
+
+    -- Query ThreatEngine with the mob's name
+    local enginePct, engineSit, enginePlayerThreat, engineTopThreat, hasGroupData =
+        addon.ThreatEngine:GetThreatOnTarget(mobName)
+
+    if enginePct > 0 then
+        if hasGroupData then
+            -- We have threat data from multiple sources (group broadcasts).
+            -- The percentage is reliable - use it directly.
+            return enginePct, engineSit
+        end
+
+        -- ThreatEngine only has the player's own threat data (no group
+        -- broadcasts). Cross-reference with mob's target to calibrate.
+        if mobTargetName then
+            if mobTargetName == playerName then
+                -- Mob targets the player AND player has threat data.
+                -- Player really does have aggro. Since we only know our
+                -- own threat and we're the top, show as 100%.
+                return 100, 3
+            elseif partyNames[mobTargetName] then
+                -- Mob targets a PARTY/RAID member. The player doesn't
+                -- have aggro but does have some threat. Show the
+                -- ThreatEngine percentage as the player's relative threat.
+                -- This is much better than the old fixed 60%/30% estimate.
+                return enginePct, engineSit
+            else
+                -- Mob targets an outsider - show conservative estimate
+                if enginePct >= 100 then
+                    return 90, 2
+                end
+                return enginePct, engineSit
+            end
+        else
+            -- Can't see mob's target. Show raw ThreatEngine data
+            -- but cap at 90% since we can't confirm we have aggro.
+            if enginePct >= 100 then
+                return 90, 2
+            end
+            return enginePct, engineSit
+        end
+    end
+
+    -- ==============================================================
+    -- Method 5: Target-based heuristic (last resort fallback)
+    -- Only used when ThreatEngine has NO data for a mob.
+    -- This can happen for: newly engaged mobs, mobs in combat with
+    -- other players outside our group, or very brief encounters.
+    --
+    -- This is the MOST RELIABLE heuristic in Vanilla WoW:
+    -- Who is the mob targeting? That person has aggro.
+    --
+    -- KEY CHANGE: Now properly handles party/raid members.
+    -- If the mob is targeting a group member, we show a high
+    -- threat bar (that member has aggro), not a low estimate.
+    -- ==============================================================
+
+    -- Check if the mob is targeting someone
+    if mobTargetName then
+        if mobTargetName == playerName then
+            -- Mob is targeting the PLAYER - player has AGGRO (100%)
+            threatPct = 100
+            situation = 3
+        elseif partyNames[mobTargetName] then
+            -- Mob is targeting a PARTY/RAID member.
+            -- That member has aggro - show high threat.
+            -- This is the KEY fix: previously showed only 60%/30%
+            -- for mobs targeting group members. Now shows 100%
+            -- because that group member IS the one being attacked.
+            threatPct = 100
+            situation = 3
+        else
+            -- Mob is targeting someone outside the party
+            -- (another player, a pet, etc.)
+            if UnitIsUnit("target", unit) then
+                threatPct = 40
+                situation = 1
+            else
+                threatPct = 15
+                situation = 0
+            end
+        end
+    else
+        -- Mob's target is nil. We already know it's in combat.
+        -- This happens when someone outside our group has aggro
+        -- or the mob is between targets.
+        if UnitIsUnit("target", unit) then
+            threatPct = 40
+            situation = 1
+        else
+            threatPct = 10
+            situation = 0
+        end
+    end
+
+    return threatPct, situation
+end
+
+-- ==================================================================
+-- Update threat for a specific unit and notify nameplates
+-- ==================================================================
+function addon.Threat:UpdateUnitThreat(unit)
+    if not unit or not UnitExists(unit) then return end
+
+    local pct, situation = self:GetThreatPercent(unit)
+    local uid = addon:GetUnitID(unit)
+
+    if uid then
+        -- Get mob target info for group context
+        local mobTargetName = nil
+        local ok_mt, mt = pcall(UnitName, unit .. "target")
+        if ok_mt and mt then
+            mobTargetName = mt
+        end
+
+        threatCache[uid] = {
+            pct = pct,
+            situation = situation,
+            unit = unit,
+            lastUpdate = GetTime(),
+            mobTargetName = mobTargetName,
+        }
+
+        -- Also store in group threat cache for cross-reference
+        groupThreatCache[uid] = {
+            bestPct = pct,
+            bestSit = situation,
+            mobTargetName = mobTargetName,
+            lastUpdate = GetTime(),
+        }
+
+        addon.Nameplates:UpdateThreatForUnit(unit, pct, situation)
+    end
+end
+
+-- ==================================================================
+-- Get cached threat for a unit identifier
+-- ==================================================================
+function addon.Threat:GetCachedThreat(uid)
+    if not uid then return 0, 0 end
+    local cache = threatCache[uid]
+    if cache then
+        if GetTime() - cache.lastUpdate < 5 then
+            return cache.pct, cache.situation
+        end
+    end
+    return 0, 0
+end
+
+-- ==================================================================
+-- Get threat percentage by mob NAME (no unit token required)
+-- This is the fallback for when FindUnitByName couldn't resolve
+-- a unit token for a nameplate.
+--
+-- CRITICAL FIX for same-name mob confusion:
+--   In Vanilla 1.12 there is no UnitGUID. Multiple mobs with the
+--   same name (e.g. "Defias Bandit") all share one ThreatEngine
+--   entry. If we return threat data by name alone, idle same-name
+--   mobs will incorrectly show threat bars.
+--
+--   Solution: GetThreatByName now REQUIRES finding a unit token
+--   that is verified to be in combat. If no combat-verified unit
+--   token can be found for the given name, it returns 0, 0.
+--   This ensures idle mobs never get threat data.
+--
+-- Returns: threatPct (0-100), threatSit (0-3)
+-- ==================================================================
+function addon.Threat:GetThreatByName(mobName)
+    if not mobName or strlen(mobName) == 0 then
+        return 0, 0
+    end
+
+    -- KEY FIX: Only require that SOMEONE in the group is in combat,
+    -- not necessarily the player. This allows threat bars to show
+    -- on mobs attacking party/raid members even when the player
+    -- isn't in combat themselves.
+    if not addon.ThreatEngine:IsGroupInCombat() then
+        return 0, 0
+    end
+
+    -- ==============================================================
+    -- Step 1: Try to find a combat-verified unit token.
+    -- If we can find one and verify it's in combat, use the full
+    -- GetThreatPercent which has all the proper checks.
+    -- ==============================================================
+
+    local unitTokens = {
+        "target", "mouseover", "targettarget", "pet",
+    }
+
+    for i = 1, 4 do
+        unitTokens[table.getn(unitTokens) + 1] = "party" .. i .. "target"
+        unitTokens[table.getn(unitTokens) + 1] = "party" .. i .. "targettarget"
+    end
+
+    for i = 1, 40 do
+        unitTokens[table.getn(unitTokens) + 1] = "raid" .. i .. "target"
+        unitTokens[table.getn(unitTokens) + 1] = "raid" .. i .. "targettarget"
+    end
+
+    -- Search for a unit token that matches the name AND is in combat
+    for i = 1, table.getn(unitTokens) do
+        local token = unitTokens[i]
+        local ok, exists = pcall(UnitExists, token)
+        if ok and exists then
+            local ok2, name = pcall(UnitName, token)
+            if ok2 and name and name == mobName then
+                local ok3, inCombat = pcall(UnitAffectingCombat, token)
+                if ok3 and inCombat then
+                    local pct, sit = self:GetThreatPercent(token)
+                    return pct, sit
+                end
+            end
+        end
+    end
+
+    -- ==============================================================
+    -- Step 2: No combat-verified unit token found.
+    --
+    -- For UNIQUE-name mobs (only 1 plate with this name visible),
+    -- the ThreatEngine data IS unambiguous — there's only one mob
+    -- with this name, so the threat data is definitely about it.
+    -- We can use ThreatEngine data directly.
+    --
+    -- For SAME-name mobs (multiple plates share this name), we
+    -- CANNOT use ThreatEngine data without a unit token because
+    -- it would apply the same threat to all same-name plates,
+    -- including idle ones.
+    --
+    -- The caller (UpdateAllPlates) decides whether a name is
+    -- unique. GetThreatByName is ONLY called for unique names
+    -- from UpdateAllPlates, so it's safe to use ThreatEngine here.
+    -- ==============================================================
+
+    if addon.ThreatEngine:HasDataForTarget(mobName) then
+        local enginePct, engineSit, _, _, hasGroupData =
+            addon.ThreatEngine:GetThreatOnTarget(mobName)
+
+        if enginePct > 0 then
+            -- We have ThreatEngine data for this unique-name mob.
+            -- Cap at 90% since we can't verify who has aggro
+            -- without seeing the mob's target.
+            if enginePct >= 100 then
+                return 90, 2
+            end
+            return enginePct, engineSit
+        end
+    end
+
+    -- No ThreatEngine data either. This mob likely hasn't been
+    -- engaged by the player. Return 0.
+    return 0, 0
+end
+
+-- ==================================================================
+-- Check if a mob is attacking any group member
+-- Returns: the name of the group member being attacked, or nil
+-- ==================================================================
+function addon.Threat:GetMobTarget(mobUnit)
+    if not mobUnit or not UnitExists(mobUnit) then
+        return nil
+    end
+
+    local ok, targetName = pcall(UnitName, mobUnit .. "target")
+    if ok and targetName then
+        if targetName == playerName or partyNames[targetName] then
+            return targetName
+        end
+    end
+    return nil
+end
+
+-- ==================================================================
+-- Get cached group threat for a unit identifier
+-- Returns: bestPct, bestSit, mobTargetName
+-- ==================================================================
+function addon.Threat:GetGroupCachedThreat(uid)
+    if not uid then return 0, 0, nil end
+    local cache = groupThreatCache[uid]
+    if cache then
+        if GetTime() - cache.lastUpdate < 5 then
+            return cache.bestPct, cache.bestSit, cache.mobTargetName
+        end
+    end
+    return 0, 0, nil
+end
+
+-- ==================================================================
+-- Clear all threat data
+-- ==================================================================
+function addon.Threat:ClearAll()
+    threatCache = {}
+    groupThreatCache = {}
+end
diff --git a/ThreatPlates_ThreatEngine.lua b/ThreatPlates_ThreatEngine.lua
new file mode 100644
index 0000000..ea3dd08
--- /dev/null
+++ b/ThreatPlates_ThreatEngine.lua
@@ -0,0 +1,1982 @@
+----------------------------------------------------------------------
+-- ThreatPlates_ThreatEngine.lua
+-- Accurate threat calculation engine for WoW 1.12 (Vanilla API)
+-- Parses combat log events to calculate precise per-1% threat values
+-- instead of crude target-based heuristics (20%, 50%, 75%, 100%)
+--
+-- APPROACH:
+--   1. Parse Vanilla 1.12 combat log events using GlobalStrings pattern
+--      matching (same technique as KTM/ShaguDPS)
+--   2. Track absolute threat values per mob name per player
+--   3. Apply class-specific threat modifiers (stance, buffs, talents)
+--   4. Calculate precise percentage: playerThreat / topThreat * 100
+--   5. Broadcast threat data via CHAT_MSG_ADDON for group sync
+--
+-- VANILLA 1.12 COMPATIBILITY:
+--   - No string.match() -> use string.find()
+--   - No select() -> use arg1..arg9
+--   - No varargs (...) -> use arg table
+--   - No CombatLogGetCurrentEventInfo() -> use GlobalStrings parsing
+--   - No UnitGUID -> track by mob name
+--   - string.gfind exists in 1.12 (alias for string.gmatch)
+----------------------------------------------------------------------
+-- CHANGES (multi-mob threat display fix):
+--   * Added PARTY damage/heal parsers using OTHEROTHER GlobalStrings
+--     (Vanilla 1.12 has no PARTY-specific GlobalStrings; the same
+--     OTHEROTHER patterns like SPELLLOGSCHOOLOTHEROTHER appear on
+--     party/friendly combat log events per ShaguDPS/KTM conventions)
+--   * Events: CHAT_MSG_SPELL_PARTY_DAMAGE, CHAT_MSG_COMBAT_PARTY_HITS,
+--     CHAT_MSG_SPELL_FRIENDLYPLAYER_DAMAGE, CHAT_MSG_COMBAT_FRIENDLYPLAYER_HITS,
+--     CHAT_MSG_SPELL_PERIODIC_PARTY_DAMAGE, CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_DAMAGE,
+--     CHAT_MSG_SPELL_PARTY_BUFF, CHAT_MSG_SPELL_FRIENDLYPLAYER_BUFF,
+--     CHAT_MSG_SPELL_PERIODIC_PARTY_BUFFS, CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_BUFFS
+--   * Now tracks threat per mob per ALL group members, not just player
+--   * Added partyThreatModifier estimation for group members
+--   * AddThreat() now accepts optional sourceName parameter
+--   * GetThreatOnTarget() returns threat for any group member
+--   * GetEngagedMobs() includes mobs attacking any group member
+----------------------------------------------------------------------
+
+local addon = ThreatPlates
+
+addon.ThreatEngine = {}
+
+-- ============================================================
+-- Constants
+-- ============================================================
+
+-- Threat constants (from KTM/ThreatClassic-1.0)
+local THREAT_CONST = {
+    healing     = 0.5,    -- healing threat coefficient
+    meleeAggro  = 1.1,    -- melee pull aggro at 110%
+    rangeAggro  = 1.3,    -- ranged pull aggro at 130%
+    rageGain    = 5.0,    -- threat per rage gained
+    energyGain  = 5.0,    -- threat per energy gained
+    manaGain    = 0.5,    -- threat per mana gained
+}
+
+-- Addon communication prefix
+local COMM_PREFIX = "TPThreat"
+local COMM_VERSION = 1
+
+-- ============================================================
+-- State variables
+-- ============================================================
+
+-- Player info (cached on load)
+local playerName = nil
+local playerClass = nil   -- lowercase english class name
+
+-- Threat table: threatData[targetName][sourceName] = absoluteThreatValue
+-- This tracks how much threat each player has on each mob
+-- KEY CHANGE: sourceName can now be any group member, not just playerName
+local threatData = {}
+
+-- Target tracking: what the player's current target is
+local currentTargetName = nil
+
+-- Player's threat modifiers (recalculated periodically)
+local threatModifier = 1.0
+
+-- Party member class cache: partyMemberName -> classLowercase
+-- Used for estimating threat modifiers for group members
+local partyClassCache = {}
+
+-- Sunder Armor transaction (KTM-style: assume success, retract on failure)
+local pendingSunder = nil
+local pendingSunderTime = 0
+
+-- Player combat state
+local playerInCombat = false
+
+-- Group combat state: true if any party/raid member is in combat.
+-- This is CRITICAL for showing threat bars on mobs attacking group
+-- members when the player is NOT in combat themselves.
+local groupInCombat = false
+
+-- ============================================================
+-- Safe API helpers
+-- ============================================================
+
+local function SafeCall1(func, a)
+    if not func then return nil end
+    local ok, r1 = pcall(func, a)
+    if ok then return r1 end
+    return nil
+end
+
+local function SafeCall2(func, a, b)
+    if not func then return nil, nil end
+    local ok, r1, r2 = pcall(func, a, b)
+    if ok then return r1, r2 end
+    return nil, nil
+end
+
+-- ============================================================
+-- GlobalStrings -> Regex conversion
+-- Same technique used by KTM and ShaguDPS:
+-- Convert format strings like "Your %s hits %s for %d."
+-- into regex patterns like "^Your (.+) hits (.+) for (%d+)%."
+-- This works on ALL locales automatically because the client
+-- defines these GlobalStrings variables at runtime.
+-- ============================================================
+
+local regexCache = {}
+
+-- Convert a printf-style format string into a Lua regex pattern
+-- Handles both simple (%s, %d) and positional (%1$s, %2$d) formats
+local function FormatToRegex(formatStr)
+    if not formatStr then return nil end
+    if regexCache[formatStr] then return regexCache[formatStr] end
+
+    local regex = formatStr
+
+    -- Escape regex magic characters in the format string
+    -- We need to escape: . ( ) % + - * ? [ ^ $
+    -- But NOT the %s %d format specifiers
+    regex = string.gsub(regex, "([%+%-%*%?%[%]%^%$])", "%%%1")
+    regex = string.gsub(regex, "%.", "%%.")
+
+    -- Now replace format specifiers with capture groups
+    -- Handle positional format: %1$s, %2$d, etc.
+    regex = string.gsub(regex, "%%(%d+)%$([sd])", function(idx, typ)
+        if typ == "d" then
+            return "(%d+)"
+        else
+            return "(.+)"
+        end
+    end)
+
+    -- Handle simple format: %s, %d
+    regex = string.gsub(regex, "%%([sd])", function(typ)
+        if typ == "d" then
+            return "(%d+)"
+        else
+            return "(.+)"
+        end
+    end)
+
+    -- Anchor to start of string for faster matching
+    regex = "^" .. regex
+
+    regexCache[formatStr] = regex
+    return regex
+end
+
+-- ============================================================
+-- Parser definitions
+-- Maps GlobalStrings variable names to parse handlers
+-- These are the combat log patterns we need to track for threat
+-- ============================================================
+
+-- Each parser entry: { globalVarName, handler }
+-- The handler receives the captures from the regex match
+-- and returns: sourceName, targetName, value, spellName, isCrit, spellSchool
+
+local SELF_DAMAGE_PARSERS = {}
+local SELF_HEAL_PARSERS = {}
+local SELF_BUFF_PARSERS = {}
+local PERIODIC_PARSERS = {}
+
+-- Party/raid member parsers - same patterns but with player name captures
+local PARTY_DAMAGE_PARSERS = {}
+local PARTY_HEAL_PARSERS = {}
+local PARTY_PERIODIC_PARSERS = {}
+
+-- Build parsers from GlobalStrings at load time
+local parsersBuilt = false
+
+-- ============================================================
+-- Build parsers from GlobalStrings at runtime
+-- This converts GlobalStrings like SPELLLOGSELFOTHER into
+-- regex patterns and stores them for fast matching
+-- ============================================================
+
+local function BuildParser(t, globalVarName, handler)
+    local formatStr = getglobal(globalVarName)
+    if not formatStr then return end
+    local regex = FormatToRegex(formatStr)
+    if not regex then return end
+    t[table.getn(t) + 1] = { regex = regex, handler = handler, globalVar = globalVarName }
+end
+
+local function BuildAllParsers()
+    if parsersBuilt then return end
+    parsersBuilt = true
+
+    -- ========================================
+    -- CHAT_MSG_COMBAT_SELF_HITS parsers
+    -- Auto-attack (white damage) from player
+    -- ========================================
+    BuildParser(SELF_DAMAGE_PARSERS, "COMBATHITSELFOTHER",
+        function(target, damage)
+            return playerName, target, tonumber(damage) or 0, nil, false, nil
+        end)
+    BuildParser(SELF_DAMAGE_PARSERS, "COMBATHITCRITSELFOTHER",
+        function(target, damage)
+            return playerName, target, tonumber(damage) or 0, nil, true, nil
+        end)
+    BuildParser(SELF_DAMAGE_PARSERS, "COMBATHITSCHOOLSELFOTHER",
+        function(target, damage, school)
+            return playerName, target, tonumber(damage) or 0, nil, false, school
+        end)
+    BuildParser(SELF_DAMAGE_PARSERS, "COMBATHITCRITSCHOOLSELFOTHER",
+        function(target, damage, school)
+            return playerName, target, tonumber(damage) or 0, nil, true, school
+        end)
+
+    -- ========================================
+    -- CHAT_MSG_SPELL_SELF_DAMAGE parsers
+    -- Spell/ability damage from player
+    -- ========================================
+    BuildParser(SELF_DAMAGE_PARSERS, "SPELLLOGSCHOOLSELFOTHER",
+        function(spell, target, damage, school)
+            return playerName, target, tonumber(damage) or 0, spell, false, school
+        end)
+    BuildParser(SELF_DAMAGE_PARSERS, "SPELLLOGCRITSCHOOLSELFOTHER",
+        function(spell, target, damage, school)
+            return playerName, target, tonumber(damage) or 0, spell, true, school
+        end)
+    BuildParser(SELF_DAMAGE_PARSERS, "SPELLLOGSELFOTHER",
+        function(spell, target, damage)
+            return playerName, target, tonumber(damage) or 0, spell, false, nil
+        end)
+    BuildParser(SELF_DAMAGE_PARSERS, "SPELLLOGCRITSELFOTHER",
+        function(spell, target, damage)
+            return playerName, target, tonumber(damage) or 0, spell, true, nil
+        end)
+
+    -- Non-damage spell performs (Sunder Armor, etc.)
+    BuildParser(SELF_DAMAGE_PARSERS, "SPELLPERFORMGOSELFTARGETTED",
+        function(spell, target)
+            return playerName, target, 0, spell, false, nil
+        end)
+    BuildParser(SELF_DAMAGE_PARSERS, "SPELLCASTGOSELFTARGETTED",
+        function(spell, target)
+            return playerName, target, 0, spell, false, nil
+        end)
+
+    -- Spell hitting self (e.g. own spell reflected)
+    BuildParser(SELF_DAMAGE_PARSERS, "SPELLLOGSCHOOLSELFSELF",
+        function(spell, damage, school)
+            return playerName, playerName, tonumber(damage) or 0, spell, false, school
+        end)
+
+    -- ========================================
+    -- CHAT_MSG_SPELL_SELF_BUFF parsers
+    -- Healing from player
+    -- ========================================
+    BuildParser(SELF_HEAL_PARSERS, "HEALEDSELFOTHER",
+        function(spell, target, amount)
+            return playerName, target, tonumber(amount) or 0, spell, false, nil
+        end)
+    BuildParser(SELF_HEAL_PARSERS, "HEALEDCRITSELFOTHER",
+        function(spell, target, amount)
+            return playerName, target, tonumber(amount) or 0, spell, true, nil
+        end)
+    BuildParser(SELF_HEAL_PARSERS, "HEALEDSELFSELF",
+        function(spell, amount)
+            return playerName, playerName, tonumber(amount) or 0, spell, false, nil
+        end)
+    BuildParser(SELF_HEAL_PARSERS, "HEALEDCRITSELFSELF",
+        function(spell, amount)
+            return playerName, playerName, tonumber(amount) or 0, spell, true, nil
+        end)
+
+    -- ========================================
+    -- CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS parsers
+    -- HoT ticks and power gains
+    -- ========================================
+    BuildParser(PERIODIC_PARSERS, "PERIODICAURAHEALSELFSELF",
+        function(amount, spell)
+            return playerName, playerName, tonumber(amount) or 0, spell, false, nil
+        end)
+    BuildParser(PERIODIC_PARSERS, "PERIODICAURAHEALSELFOTHER",
+        function(target, amount, spell)
+            return playerName, target, tonumber(amount) or 0, spell, false, nil
+        end)
+    -- Power gains (rage, energy, mana)
+    BuildParser(PERIODIC_PARSERS, "POWERGAINSELFSELF",
+        function(amount, powerType, spell)
+            return playerName, nil, tonumber(amount) or 0, spell, false, powerType
+        end)
+
+    -- ========================================
+    -- CHAT_MSG_SPELL_PERIODIC_CREATURE_DAMAGE parsers
+    -- DoT ticks from player on mobs
+    -- ========================================
+    BuildParser(PERIODIC_PARSERS, "PERIODICAURADAMAGESELFOTHER",
+        function(target, damage, school, spell)
+            return playerName, target, tonumber(damage) or 0, spell, false, school
+        end)
+
+    addon:ui_print("Threat engine: " .. table.getn(SELF_DAMAGE_PARSERS) ..
+        " damage, " .. table.getn(SELF_HEAL_PARSERS) ..
+        " heal, " .. table.getn(PERIODIC_PARSERS) .. " periodic parsers built")
+
+    -- ========================================
+    -- CHAT_MSG_SPELL_PARTY_DAMAGE parsers
+    -- CHAT_MSG_SPELL_FRIENDLYPLAYER_DAMAGE parsers
+    -- Spell/ability damage from party/raid members
+    -- Uses OTHEROTHER GlobalStrings: "%s's %s hits %s for %d."
+    -- Vanilla 1.12 has no PARTY-specific GlobalStrings;
+    -- the same OTHEROTHER patterns appear on party/friendly events.
+    -- ========================================
+    BuildParser(PARTY_DAMAGE_PARSERS, "SPELLLOGSCHOOLOTHEROTHER",
+        function(source, spell, target, damage, school)
+            return source, target, tonumber(damage) or 0, spell, false, school
+        end)
+    BuildParser(PARTY_DAMAGE_PARSERS, "SPELLLOGCRITSCHOOLOTHEROTHER",
+        function(source, spell, target, damage, school)
+            return source, target, tonumber(damage) or 0, spell, true, school
+        end)
+    BuildParser(PARTY_DAMAGE_PARSERS, "SPELLLOGOTHEROTHER",
+        function(source, spell, target, damage)
+            return source, target, tonumber(damage) or 0, spell, false, nil
+        end)
+    BuildParser(PARTY_DAMAGE_PARSERS, "SPELLLOGCRITOTHEROTHER",
+        function(source, spell, target, damage)
+            return source, target, tonumber(damage) or 0, spell, true, nil
+        end)
+
+    -- ========================================
+    -- CHAT_MSG_COMBAT_PARTY_HITS parsers
+    -- Auto-attack (white damage) from party/raid members
+    -- Uses OTHEROTHER GlobalStrings: "%s hits %s for %d."
+    -- ========================================
+    BuildParser(PARTY_DAMAGE_PARSERS, "COMBATHITOTHEROTHER",
+        function(source, target, damage)
+            return source, target, tonumber(damage) or 0, nil, false, nil
+        end)
+    BuildParser(PARTY_DAMAGE_PARSERS, "COMBATHITCRITOTHEROTHER",
+        function(source, target, damage)
+            return source, target, tonumber(damage) or 0, nil, true, nil
+        end)
+    BuildParser(PARTY_DAMAGE_PARSERS, "COMBATHITSCHOOLOTHEROTHER",
+        function(source, target, damage, school)
+            return source, target, tonumber(damage) or 0, nil, false, school
+        end)
+    BuildParser(PARTY_DAMAGE_PARSERS, "COMBATHITCRITSCHOOLOTHEROTHER",
+        function(source, target, damage, school)
+            return source, target, tonumber(damage) or 0, nil, true, school
+        end)
+
+    -- ========================================
+    -- CHAT_MSG_SPELL_PERIODIC_PARTY_DAMAGE parsers
+    -- CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_DAMAGE parsers
+    -- DoT ticks from party/raid members
+    -- Uses OTHEROTHER: "%s suffers %d %s damage from %s's %s."
+    -- ========================================
+    BuildParser(PARTY_DAMAGE_PARSERS, "PERIODICAURADAMAGEOTHEROTHER",
+        function(target, damage, school, source, spell)
+            return source, target, tonumber(damage) or 0, spell, false, school
+        end)
+
+    -- ========================================
+    -- CHAT_MSG_SPELL_FRIENDLYPLAYER_BUFF parsers
+    -- CHAT_MSG_SPELL_PARTY_BUFF parsers
+    -- Healing from party/raid members
+    -- Uses OTHEROTHER GlobalStrings: "%s's %s heals %s for %d."
+    -- ========================================
+    BuildParser(PARTY_HEAL_PARSERS, "HEALEDOTHEROTHER",
+        function(source, spell, target, amount)
+            return source, target, tonumber(amount) or 0, spell, false, nil
+        end)
+    BuildParser(PARTY_HEAL_PARSERS, "HEALEDCRITOTHEROTHER",
+        function(source, spell, target, amount)
+            return source, target, tonumber(amount) or 0, spell, true, nil
+        end)
+    -- OTHERSELF: "%s's %s heals you for %d." - party member healing the player
+    BuildParser(PARTY_HEAL_PARSERS, "HEALEDOTHERSELF",
+        function(source, spell, amount)
+            return source, playerName, tonumber(amount) or 0, spell, false, nil
+        end)
+    BuildParser(PARTY_HEAL_PARSERS, "HEALEDCRITOTHERSELF",
+        function(source, spell, amount)
+            return source, playerName, tonumber(amount) or 0, spell, true, nil
+        end)
+
+    -- ========================================
+    -- CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_BUFFS parsers
+    -- CHAT_MSG_SPELL_PERIODIC_PARTY_BUFFS parsers
+    -- HoT ticks from party/raid members
+    -- Uses OTHEROTHER: "%s gains %d health from %s's %s."
+    -- Note: SELFOTHER is NOT included here to avoid double-counting
+    -- with CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS which already tracks
+    -- the player's own HoT ticks via the self-event handlers.
+    -- ========================================
+    BuildParser(PARTY_PERIODIC_PARSERS, "PERIODICAURAHEALOTHEROTHER",
+        function(target, amount, source, spell)
+            return source, target, tonumber(amount) or 0, spell, false, nil
+        end)
+
+    addon:ui_print("Threat engine: " .. table.getn(PARTY_DAMAGE_PARSERS) ..
+        " party damage, " .. table.getn(PARTY_HEAL_PARSERS) ..
+        " party heal, " .. table.getn(PARTY_PERIODIC_PARSERS) ..
+        " party periodic parsers built")
+end
+
+-- ============================================================
+-- Parse a combat log message against a set of parsers
+-- Returns: sourceName, targetName, value, spellName, isCrit, spellSchool
+-- or nil if no match
+-- ============================================================
+
+local function ParseMessage(parserSet, msg)
+    if not msg then return nil end
+
+    for i = 1, table.getn(parserSet) do
+        local entry = parserSet[i]
+        local _, _, c1, c2, c3, c4, c5 = string.find(msg, entry.regex)
+        if c1 then
+            -- Call the handler with whatever captures we got
+            local s, t, v, sp, cr, sc = entry.handler(c1, c2, c3, c4, c5)
+            if s then
+                return s, t, v, sp, cr, sc
+            end
+        end
+    end
+    return nil
+end
+
+-- ============================================================
+-- Special spell threat table
+-- Flat threat values for abilities that generate threat without
+-- (or in addition to) damage
+-- Values from KTM/ThreatClassic-1.0 class modules
+-- ============================================================
+
+local SPELL_THREAT = {}
+
+-- Warrior abilities
+SPELL_THREAT["sunder"]        = 261   -- Sunder Armor rank 8
+SPELL_THREAT["revenge"]       = 355   -- Revenge rank 6
+SPELL_THREAT["shieldslam"]    = 250   -- Shield Slam bonus threat
+SPELL_THREAT["heroicstrike"]  = 145   -- Heroic Strike rank 8 bonus threat
+SPELL_THREAT["shieldbash"]    = 110   -- Shield Bash bonus threat
+SPELL_THREAT["hamstring"]     = 145   -- Hamstring bonus threat
+SPELL_THREAT["thunderclap"]   = 130   -- Thunder Clap bonus threat
+SPELL_THREAT["demoralizingshout"] = 43 -- Demo Shout threat
+SPELL_THREAT["battle shout"]  = 69    -- Battle Shout threat per target hit
+SPELL_THREAT["disarm"]        = 104   -- Disarm bonus threat
+
+-- Druid abilities
+SPELL_THREAT["maul"]          = nil   -- Maul uses multiplier instead
+SPELL_THREAT["swipe"]         = nil   -- Swipe uses multiplier
+SPELL_THREAT["demoralizingroar"] = 30 -- Demo Roar threat
+
+-- Warlock abilities
+SPELL_THREAT["searingpain"]   = nil   -- Searing Pain uses multiplier
+SPELL_THREAT["lifetap"]       = 0     -- Life Tap generates no threat
+SPELL_THREAT["drainlife"]     = 0     -- Drain Life generates no threat
+SPELL_THREAT["siphonlife"]    = 0     -- Siphon Life generates no threat
+
+-- Priest abilities
+SPELL_THREAT["holynova"]      = 0     -- Holy Nova generates no threat
+
+-- Rogue abilities
+SPELL_THREAT["feint"]         = -150  -- Feint reduces threat (rank 5)
+SPELL_THREAT["vanish"]        = -1000000  -- Vanish wipes threat
+
+-- Spell multiplier table (some spells multiply damage for threat)
+local SPELL_MULTIPLIER = {}
+SPELL_MULTIPLIER["searingpain"]  = 2.0   -- Searing Pain double threat
+SPELL_MULTIPLIER["heroicstrike"] = 1.0   -- HS adds flat + bonus on top
+SPELL_MULTIPLIER["maul"]         = 1.75  -- Maul multiplier
+SPELL_MULTIPLIER["swipe"]        = 1.0   -- Swipe multiplier
+
+-- Unlocalise spell name: map localised name to internal ID
+-- We build this at runtime from known localised names
+local spellNameToId = {}
+
+local function BuildSpellNameMap()
+    -- Warrior spells
+    local warriorSpells = {
+        "sunder", "revenge", "shieldslam", "heroicstrike",
+        "shieldbash", "hamstring", "thunderclap", "demoralizingshout",
+        "disarm"
+    }
+
+    -- Check if player is the right class and cache localised names
+    if playerClass == "warrior" then
+        for i = 1, table.getn(warriorSpells) do
+            local id = warriorSpells[i]
+            -- Try to get localised name from spellbook
+            -- This is a best-effort approach; if we can't find it,
+            -- we'll fall back to string matching
+        end
+    end
+end
+
+-- Match a localised spell name against known threat spells
+-- Uses simple substring matching for common spell patterns
+local function MatchSpell(spellName)
+    if not spellName then return nil end
+
+    -- Try exact match first (case-insensitive)
+    local lowerName = string.lower(spellName)
+
+    -- Common substring patterns for spell identification
+    -- This works across locales where the spell name contains
+    -- recognizable fragments
+
+    -- Sunder Armor
+    if SPELL_THREAT["sunder"] then
+        -- Check if this could be sunder by checking known localisations
+        -- English: "Sunder Armor", "Sunder"
+        if string.find(lowerName, "sunder") then
+            return "sunder"
+        end
+    end
+
+    -- Revenge
+    if string.find(lowerName, "revenge") then
+        return "revenge"
+    end
+
+    -- Shield Slam
+    if string.find(lowerName, "shield slam") or string.find(lowerName, "shieldslam") then
+        return "shieldslam"
+    end
+
+    -- Shield Bash
+    if string.find(lowerName, "shield bash") or string.find(lowerName, "shieldbash") then
+        return "shieldbash"
+    end
+
+    -- Heroic Strike
+    if string.find(lowerName, "heroic strike") or string.find(lowerName, "heroicstrike") then
+        return "heroicstrike"
+    end
+
+    -- Hamstring
+    if string.find(lowerName, "hamstring") then
+        return "hamstring"
+    end
+
+    -- Thunder Clap
+    if string.find(lowerName, "thunder clap") or string.find(lowerName, "thunderclap") then
+        return "thunderclap"
+    end
+
+    -- Demoralizing Shout
+    if string.find(lowerName, "demoralizing") or string.find(lowerName, "demoralising") then
+        return "demoralizingshout"
+    end
+
+    -- Battle Shout
+    if string.find(lowerName, "battle shout") then
+        return "battle shout"
+    end
+
+    -- Disarm
+    if string.find(lowerName, "disarm") then
+        return "disarm"
+    end
+
+    -- Feint
+    if string.find(lowerName, "feint") then
+        return "feint"
+    end
+
+    -- Vanish
+    if string.find(lowerName, "vanish") then
+        return "vanish"
+    end
+
+    -- Searing Pain
+    if string.find(lowerName, "searing pain") or string.find(lowerName, "searingpain") then
+        return "searingpain"
+    end
+
+    -- Maul
+    if string.find(lowerName, "maul") then
+        return "maul"
+    end
+
+    -- Swipe
+    if string.find(lowerName, "swipe") then
+        return "swipe"
+    end
+
+    -- Life Tap (no threat)
+    if string.find(lowerName, "life tap") or string.find(lowerName, "lifetap") then
+        return "lifetap"
+    end
+
+    -- Holy Nova (no threat)
+    if string.find(lowerName, "holy nova") or string.find(lowerName, "holynova") then
+        return "holynova"
+    end
+
+    return nil
+end
+
+-- ============================================================
+-- Threat modifier calculation
+-- Recalculated periodically based on player buffs, stance, etc.
+-- ============================================================
+
+local function CalculateThreatModifier()
+    threatModifier = 1.0
+
+    -- Blessing of Salvation (-30%)
+    for i = 1, 16 do
+        local ok, texture = pcall(UnitBuff, "player", i)
+        if ok and texture then
+            if texture == "Interface\\Icons\\Spell_Holy_SealOfSalvation" or
+               texture == "Interface\\Icons\\Spell_Holy_GreaterBlessingofSalvation" then
+                threatModifier = threatModifier * 0.7
+            end
+        end
+    end
+
+    -- Tranquil Air Totem (-20%)
+    for i = 1, 16 do
+        local ok, texture = pcall(UnitBuff, "player", i)
+        if ok and texture then
+            if texture == "Interface\\Icons\\Spell_Nature_Brilliance" then
+                threatModifier = threatModifier * 0.8
+            end
+        end
+    end
+
+    -- Class-specific modifiers
+    if playerClass == "warrior" then
+        -- Check stance via buff texture detection
+        -- In Vanilla 1.12, stances appear as buffs with specific icons
+        local stanceIndex = 0
+        for i = 1, 16 do
+            local ok, texture = pcall(UnitBuff, "player", i)
+            if ok and texture then
+                -- Defensive Stance icon
+                if texture == "Interface\\Icons\\Ability_Warrior_DefensiveStance" then
+                    stanceIndex = 2
+                -- Battle Stance icon
+                elseif texture == "Interface\\Icons\\Ability_Warrior_BattleStance" then
+                    stanceIndex = 1
+                -- Berserker Stance icon
+                elseif texture == "Interface\\Icons\\Ability_Warrior_BerserkerStance" then
+                    stanceIndex = 3
+                end
+            end
+        end
+
+        if stanceIndex == 2 then
+            -- Defensive Stance: +30% threat modifier (1.3x)
+            threatModifier = threatModifier * 1.3
+            -- Defiance talent: +5% per rank (5 ranks max = +25%)
+            -- We approximate based on talent tree position
+            -- For now, use a conservative estimate
+        elseif stanceIndex == 1 then
+            -- Battle Stance: -20% threat (0.8x)
+            threatModifier = threatModifier * 0.8
+        elseif stanceIndex == 3 then
+            -- Berserker Stance: -20% threat (0.8x)
+            threatModifier = threatModifier * 0.8
+        end
+
+    elseif playerClass == "druid" then
+        -- Check form
+        for i = 1, 16 do
+            local ok, texture = pcall(UnitBuff, "player", i)
+            if ok and texture then
+                -- Bear Form / Dire Bear Form
+                if texture == "Interface\\Icons\\Ability_Racial_BearForm" or
+                   texture == "Interface\\Icons\\Ability_Racial_DireBearForm" then
+                    threatModifier = threatModifier * 1.3
+                -- Cat Form
+                elseif texture == "Interface\\Icons\\Ability_Druid_CatForm" then
+                    threatModifier = threatModifier * 0.71
+                end
+            end
+        end
+
+    elseif playerClass == "rogue" then
+        -- Rogues have -29% passive threat modifier
+        threatModifier = threatModifier * 0.71
+
+    elseif playerClass == "mage" then
+        -- Arcanist 8/8 set bonus: -15%
+        -- For now, just base modifier
+    end
+
+    -- +2% threat enchant on gloves (enchant ID 2613)
+    local ok, link = pcall(GetInventoryItemLink, "player", 10)
+    if ok and link then
+        local _, _, enchant = string.find(link, ".-item:%d+:(%d+).*")
+        if enchant == "2613" then
+            threatModifier = threatModifier * 1.02
+        end
+    end
+
+    -- -2% threat enchant on cloak (enchant ID 2621)
+    ok, link = pcall(GetInventoryItemLink, "player", 15)
+    if ok and link then
+        local _, _, enchant = string.find(link, ".-item:%d+:(%d+).*")
+        if enchant == "2621" then
+            threatModifier = threatModifier * 0.98
+        end
+    end
+end
+
+-- ============================================================
+-- Add threat for a player to a specific target
+-- sourceName: the player generating threat (defaults to playerName)
+-- ============================================================
+
+local function AddThreat(targetName, amount, sourceName)
+    if not targetName then return end
+    if not amount then return end
+    if amount == 0 then return end
+
+    -- Default source to the player
+    if not sourceName then sourceName = playerName end
+
+    -- Don't track threat on friendly targets
+    -- We'll let the nameplate system handle the filtering
+
+    -- Initialize target table if needed
+    if not threatData[targetName] then
+        threatData[targetName] = {}
+    end
+
+    -- Add to the source player's threat on this target
+    local current = threatData[targetName][sourceName] or 0
+    threatData[targetName][sourceName] = current + amount
+
+    -- Clamp to 0 minimum
+    if threatData[targetName][sourceName] < 0 then
+        threatData[targetName][sourceName] = 0
+    end
+end
+
+-- ============================================================
+-- Get estimated threat modifier for a group member
+-- We don't have full buff/stance info for other players, so
+-- we estimate based on their class. This is better than using
+-- the player's own modifier (which was the old behavior).
+-- ============================================================
+
+local function EstimateGroupMemberModifier(memberName)
+    -- Default modifier: 1.0 (no adjustment)
+    local mod = 1.0
+
+    -- Check cached class for this party member
+    local class = partyClassCache[memberName]
+    if class then
+        if class == "rogue" then
+            mod = 0.71
+        elseif class == "mage" then
+            mod = 1.0
+        elseif class == "warrior" then
+            -- Could be any stance; default to battle stance (0.8)
+            -- Defensive would be 1.3, but we can't know remotely
+            mod = 0.8
+        elseif class == "druid" then
+            -- Could be any form; default to 0.71 (cat/humanoid)
+            mod = 0.71
+        elseif class == "priest" then
+            mod = 0.8  -- shadowform not considered
+        elseif class == "warlock" then
+            mod = 1.0
+        elseif class == "hunter" then
+            mod = 1.0
+        elseif class == "paladin" then
+            mod = 1.0  -- Righteous Fury not considered
+        elseif class == "shaman" then
+            mod = 1.0
+        end
+    end
+
+    -- Blessing of Salvation / Tranquil Air Totem can't be detected
+    -- remotely, so we don't adjust for those.
+
+    return mod
+end
+
+-- ============================================================
+-- Cache party member classes for modifier estimation
+-- ============================================================
+
+local function UpdatePartyClassCache()
+    partyClassCache = {}
+
+    -- Player
+    if playerClass then
+        partyClassCache[playerName] = playerClass
+    end
+
+    -- Party members
+    for i = 1, 4 do
+        local unit = "party" .. i
+        if UnitExists(unit) then
+            local ok, name = pcall(UnitName, unit)
+            if ok and name then
+                local ok2, class = pcall(UnitClass, unit)
+                if ok2 and class then
+                    partyClassCache[name] = string.lower(class)
+                end
+            end
+        end
+    end
+
+    -- Raid members
+    for i = 1, 40 do
+        local unit = "raid" .. i
+        if UnitExists(unit) then
+            local ok, name = pcall(UnitName, unit)
+            if ok and name then
+                local ok2, class = pcall(UnitClass, unit)
+                if ok2 and class then
+                    partyClassCache[name] = string.lower(class)
+                end
+            end
+        end
+    end
+end
+
+-- ============================================================
+-- Process damage event (from combat log parsing)
+-- sourceName: who dealt the damage (player or group member)
+-- ============================================================
+
+local function ProcessDamage(sourceName, targetName, damage, spellName, isCrit, spellSchool)
+    if not sourceName then return end
+    if not targetName then return end
+
+    -- Don't track self-damage
+    if targetName == sourceName then return end
+
+    -- Determine threat modifier for the source
+    local sourceModifier = threatModifier
+    if sourceName ~= playerName then
+        sourceModifier = EstimateGroupMemberModifier(sourceName)
+    end
+
+    local threatAmount = 0
+
+    -- Check if this is a special spell with known threat values
+    local spellId = MatchSpell(spellName)
+
+    if spellId and SPELL_THREAT[spellId] ~= nil then
+        -- Special spell with flat threat value
+        local flatThreat = SPELL_THREAT[spellId]
+
+        if flatThreat == 0 then
+            -- No threat from this spell (Life Tap, Holy Nova, etc.)
+            return
+        elseif flatThreat < 0 then
+            -- Negative threat (Feint, Vanish)
+            AddThreat(targetName, flatThreat * sourceModifier, sourceName)
+            return
+        else
+            -- Flat threat + damage threat
+            threatAmount = damage + flatThreat
+        end
+
+    elseif spellId and SPELL_MULTIPLIER[spellId] then
+        -- Spell with threat multiplier
+        threatAmount = damage * SPELL_MULTIPLIER[spellId]
+
+    else
+        -- Normal damage: 1 threat per damage
+        threatAmount = damage
+    end
+
+    -- Apply source's threat modifier
+    threatAmount = threatAmount * sourceModifier
+
+    AddThreat(targetName, threatAmount, sourceName)
+end
+
+-- ============================================================
+-- Process heal event
+-- Healing generates 0.5x threat, split across all mobs in combat
+-- ============================================================
+
+local function ProcessHeal(sourceName, targetName, amount, spellName)
+    if not sourceName then return end
+    if not amount or amount <= 0 then return end
+
+    -- Skip healing on hostile targets
+    if targetName then
+        local unit = addon.Nameplates and addon.Nameplates:FindUnitByName(targetName)
+        if unit then
+            local ok, canAttack = pcall(UnitCanAttack, "player", unit)
+            if ok and canAttack then return end
+        end
+    end
+
+    -- Calculate effective heal (minus overheal)
+    -- We can check the target's health deficit to estimate overheal
+    local effectiveAmount = amount
+    if targetName then
+        local unit = addon.Nameplates and addon.Nameplates:FindUnitByName(targetName)
+        if unit then
+            local ok, maxHp = pcall(UnitHealthMax, unit)
+            if ok and maxHp then
+                local ok2, hp = pcall(UnitHealth, unit)
+                if ok2 and hp then
+                    local deficit = maxHp - hp
+                    if deficit > 0 then
+                        effectiveAmount = math.min(amount, deficit)
+                    else
+                        effectiveAmount = 0
+                    end
+                end
+            end
+        end
+    end
+
+    if effectiveAmount <= 0 then return end
+
+    -- Determine threat modifier for the source
+    local sourceModifier = threatModifier
+    if sourceName ~= playerName then
+        sourceModifier = EstimateGroupMemberModifier(sourceName)
+    end
+
+    -- Healing threat = amount * 0.5 * sourceModifier
+    local healThreat = effectiveAmount * THREAT_CONST.healing * sourceModifier
+
+    -- Split healing threat across mobs the player is ACTIVELY in combat with.
+    -- We use GetEngagedMobs() which verifies each mob is actually in combat
+    -- via UnitAffectingCombat, rather than just having a threatData entry.
+    -- This prevents healing threat from being added to idle nearby mobs that
+    -- accumulated threat from prior healing splits.
+    local engagedMobs, mobCount = addon.ThreatEngine:GetEngagedMobs()
+
+    if mobCount > 0 then
+        -- Add healing threat to all engaged mobs (split evenly)
+        local splitThreat = healThreat / mobCount
+        for i = 1, mobCount do
+            AddThreat(engagedMobs[i], splitThreat, sourceName)
+        end
+    else
+        -- Source has no actively engaged mobs yet - add healing threat to current target
+        -- For group members, use the player's current target as approximation
+        if sourceName == playerName then
+            if currentTargetName then
+                AddThreat(currentTargetName, healThreat, sourceName)
+            end
+        end
+    end
+end
+
+-- ============================================================
+-- Process power gain event (rage, energy, mana)
+-- ============================================================
+
+local function ProcessPowerGain(sourceName, amount, powerType, spellName)
+    if sourceName ~= playerName then return end
+    if not amount or amount <= 0 then return end
+
+    -- Prevent "overheal" for power gain
+    local ok, maxPower = pcall(UnitManaMax, "player")
+    if ok and maxPower then
+        local ok2, power = pcall(UnitMana, "player")
+        if ok2 and power then
+            amount = math.min(amount, maxPower - power)
+        end
+    end
+
+    local playerPowerType = UnitPowerType("player")
+    local gainThreat = 0
+
+    -- Check power type matches player's power type
+    -- powerType is localised (e.g. "Mana", "Rage", "Energy")
+    if powerType then
+        local pt = string.lower(powerType)
+        if string.find(pt, "rage") and playerPowerType == 1 then
+            gainThreat = amount * THREAT_CONST.rageGain
+        elseif string.find(pt, "energy") and playerPowerType == 3 then
+            gainThreat = amount * THREAT_CONST.energyGain
+        elseif string.find(pt, "mana") and playerPowerType == 0 then
+            gainThreat = amount * THREAT_CONST.manaGain
+        end
+    end
+
+    -- Skip Life Tap (warlock mana gain = no threat)
+    if spellName then
+        local spellId = MatchSpell(spellName)
+        if spellId == "lifetap" then return end
+    end
+
+    if gainThreat > 0 then
+        -- Add to current target
+        if currentTargetName then
+            AddThreat(currentTargetName, gainThreat * threatModifier)
+        end
+    end
+end
+
+-- ============================================================
+-- Sunder Armor handling (KTM-style transaction)
+-- We assume sunder hits when cast, and retract on failure
+-- ============================================================
+
+local function SubmitSunderCast()
+    if playerClass ~= "warrior" then return end
+    if not currentTargetName then return end
+
+    -- Add sunder threat immediately
+    local sunderThreat = SPELL_THREAT["sunder"] or 261
+    AddThreat(currentTargetName, sunderThreat * threatModifier)
+    pendingSunder = currentTargetName
+    pendingSunderTime = GetTime()
+end
+
+local function RetractSunderCast()
+    if not pendingSunder then return end
+
+    -- Remove the sunder threat we added
+    local sunderThreat = SPELL_THREAT["sunder"] or 261
+    AddThreat(pendingSunder, -(sunderThreat * threatModifier))
+    pendingSunder = nil
+end
+
+-- ============================================================
+-- Addon Communication
+-- Broadcast threat data to group members
+-- ============================================================
+
+local function BroadcastThreat()
+    -- Only broadcast if in a group
+    local inParty = GetNumPartyMembers() > 0
+    local inRaid = GetNumRaidMembers() > 0
+    if not inParty and not inRaid then return end
+
+    -- Build threat data string
+    -- Format: "TPv1~target1:player=val~target2:player=val~..."
+    -- NOTE: Uses ~ as delimiter instead of | because | is the WoW
+    -- chat escape prefix (|c, |H, |T, etc.) and causes "invalid
+    -- escape code in chat message" errors if a name starts with
+    -- one of those letters after a | delimiter.
+    local parts = {}
+    local count = 0
+    for target, sources in pairs(threatData) do
+        for source, value in pairs(sources) do
+            if value > 0 then
+                count = count + 1
+                -- Sanitize: replace any ~ in names with - to avoid
+                -- delimiter collision (extremely rare but safe)
+                local safeTarget = string.gsub(target, "~", "-")
+                local safeSource = string.gsub(source, "~", "-")
+                parts[count] = safeTarget .. ":" .. safeSource .. "=" .. string.format("%.0f", value)
+                -- Limit broadcast size to avoid chat message length limits
+                if count >= 20 then
+                    -- Send what we have so far
+                    local msg = "TPv1~" .. table.concat(parts, "~")
+                    SendAddonMessage(COMM_PREFIX, msg, inRaid and "RAID" or "PARTY")
+                    parts = {}
+                    count = 0
+                end
+            end
+        end
+    end
+
+    if count > 0 then
+        local msg = "TPv1~" .. table.concat(parts, "~")
+        SendAddonMessage(COMM_PREFIX, msg, inRaid and "RAID" or "PARTY")
+    end
+end
+
+-- Parse incoming threat data from other players
+local function ReceiveThreat(msg)
+    if not msg then return end
+
+    -- Check version prefix (now uses ~ as separator)
+    local _, _, version = string.find(msg, "^(TPv%d+)~")
+    if not version then return end
+
+    -- Remove version prefix
+    local data = string.gsub(msg, "^TPv%d+~", "")
+
+    -- Parse entries: target:source=value (delimited by ~)
+    for entry in string.gfind(data, "[^~]+") do
+        local _, _, target, source, value = string.find(entry, "(.+):(.+)=(%d+)")
+        if target and source and value then
+            if not threatData[target] then
+                threatData[target] = {}
+            end
+            local numValue = tonumber(value) or 0
+            -- Only update if the incoming value is higher (avoid stale data overwriting fresh)
+            if not threatData[target][source] or numValue > threatData[target][source] then
+                threatData[target][source] = numValue
+            end
+        end
+    end
+end
+
+-- ============================================================
+-- Taunt handling
+-- When you taunt, you gain threat equal to the current top threat
+-- ============================================================
+
+local function ProcessTaunt(targetName)
+    if not targetName then return end
+    if not threatData[targetName] then return end
+
+    -- Find the maximum threat on this target from any player
+    local maxThreat = 0
+    for source, value in pairs(threatData[targetName]) do
+        if value > maxThreat then
+            maxThreat = value
+        end
+    end
+
+    -- Set player's threat to match the top
+    local playerThreat = threatData[targetName][playerName] or 0
+    if maxThreat > playerThreat then
+        AddThreat(targetName, maxThreat - playerThreat)
+    end
+end
+
+-- ============================================================
+-- Event handler for combat log events
+-- ============================================================
+
+function addon.ThreatEngine:OnCombatEvent(ev, msg)
+    if not msg then return end
+    if not playerName then return end
+
+    -- Strip absorb/resist suffixes (like KTM does)
+    -- These can modify the damage string format
+    if ABSORB_TRAILER then
+        msg = string.gsub(msg, FormatToRegex(ABSORB_TRAILER), "")
+    end
+
+    -- Process based on event type
+    if ev == "CHAT_MSG_COMBAT_SELF_HITS" then
+        local s, t, v, sp, cr, sc = ParseMessage(SELF_DAMAGE_PARSERS, msg)
+        if s then
+            ProcessDamage(s, t, v, sp, cr, sc)
+        end
+
+    elseif ev == "CHAT_MSG_SPELL_SELF_DAMAGE" then
+        local s, t, v, sp, cr, sc = ParseMessage(SELF_DAMAGE_PARSERS, msg)
+        if s then
+            -- Check for Sunder Armor failure (retract pending sunder)
+            if sp and string.find(string.lower(sp), "sunder") then
+                -- If we had a pending sunder, check if this is a failure message
+                if string.find(msg, "fail") or string.find(msg, "fail:") then
+                    RetractSunderCast()
+                end
+            end
+
+            -- Check for taunt
+            if sp then
+                local lowerSpell = string.lower(sp)
+                if string.find(lowerSpell, "taunt") then
+                    ProcessTaunt(t)
+                end
+            end
+
+            ProcessDamage(s, t, v, sp, cr, sc)
+        end
+
+    elseif ev == "CHAT_MSG_SPELL_SELF_BUFF" then
+        local s, t, v, sp, cr, sc = ParseMessage(SELF_HEAL_PARSERS, msg)
+        if s then
+            ProcessHeal(s, t, v, sp)
+        end
+        -- Also check for power gains in this event
+        local ps, pt, pv, psp, pcr, psc = ParseMessage(PERIODIC_PARSERS, msg)
+        if ps and psc then
+            -- psc contains the power type for POWERGAINSELFSELF
+            ProcessPowerGain(ps, pv, psc, psp)
+        end
+
+    elseif ev == "CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS" then
+        local s, t, v, sp, cr, sc = ParseMessage(PERIODIC_PARSERS, msg)
+        if s then
+            if sc and (string.lower(sc) == "mana" or string.lower(sc) == "rage" or string.lower(sc) == "energy") then
+                -- This is a power gain, not a heal
+                ProcessPowerGain(s, v, sc, sp)
+            else
+                -- This is a HoT tick
+                ProcessHeal(s, t, v, sp)
+            end
+        end
+
+    elseif ev == "CHAT_MSG_SPELL_PERIODIC_CREATURE_DAMAGE" then
+        local s, t, v, sp, cr, sc = ParseMessage(PERIODIC_PARSERS, msg)
+        if s then
+            ProcessDamage(s, t, v, sp, cr, sc)
+        end
+
+    elseif ev == "CHAT_MSG_SPELL_PERIODIC_SELF_DAMAGE" then
+        -- Self-inflicted periodic damage (e.g. standing in fire)
+        -- Usually no threat implications, skip
+
+    elseif ev == "CHAT_MSG_COMBAT_HOSTILE_DEATH" then
+        -- A hostile unit died - clear threat on it
+        -- Try multiple patterns for robustness across locales
+        local deadName = nil
+        -- Pattern 1: "X dies." (English)
+        _, _, deadName = string.find(msg, "^(.+) dies%.$")
+        if not deadName then
+            -- Pattern 2: "X dies." without anchor
+            _, _, deadName = string.find(msg, "(.+) dies%.")
+        end
+        if not deadName then
+            -- Pattern 3: Try the GlobalStrings pattern for UNITDIESOTHER
+            local unitDiesOther = getglobal("UNITDIESOTHER")
+            if unitDiesOther then
+                local diesRegex = FormatToRegex(unitDiesOther)
+                if diesRegex then
+                    _, _, deadName = string.find(msg, diesRegex)
+                end
+            end
+        end
+        if deadName and threatData[deadName] then
+            threatData[deadName] = nil
+        end
+
+    elseif ev == "CHAT_MSG_COMBAT_FRIENDLY_DEATH" then
+        -- Player died - wipe threat
+        if msg == UNITDIESSELF then
+            -- "You die."
+            threatData = {}
+        end
+
+    elseif ev == "CHAT_MSG_SPELL_FAILED_LOCALPLAYER" then
+        -- Spell failed - check for sunder failure
+        if string.find(string.lower(msg), "sunder") then
+            RetractSunderCast()
+        end
+
+    elseif ev == "CHAT_MSG_ADDON" then
+        -- Addon communication - receive threat data from others
+        -- arg1 = prefix, arg2 = message, arg3 = channel, arg4 = sender
+        if arg1 == COMM_PREFIX then
+            ReceiveThreat(arg2)
+        end
+    end
+end
+
+-- ============================================================
+-- Get threat percentage for a specific mob
+-- Returns: threatPct (0-100), threatSit (0-3), rawThreat, topThreat,
+--          hasGroupData, bestSourceName
+--
+-- KEY CHANGE: Now returns threat info for ALL group members, not
+-- just the player. The bestPct reflects the highest threat from
+-- any group member. The caller can use this to show accurate
+-- threat bars on mobs attacking any group member.
+-- ============================================================
+
+function addon.ThreatEngine:GetThreatOnTarget(mobName)
+    if not mobName then return 0, 0, 0, 0, false, nil end
+
+    -- Check if we have threat data for this mob
+    local mobThreat = threatData[mobName]
+    if not mobThreat then
+        return 0, 0, 0, 0, false, nil
+    end
+
+    -- Find player's threat and top threat
+    local playerThreat = mobThreat[playerName] or 0
+    local topThreat = 0
+    local topPlayer = nil
+    local sourceCount = 0
+
+    for source, value in pairs(mobThreat) do
+        sourceCount = sourceCount + 1
+        if value > topThreat then
+            topThreat = value
+            topPlayer = source
+        end
+    end
+
+    if topThreat <= 0 then
+        return 0, 0, 0, 0, false, nil
+    end
+
+    -- Calculate the player's percentage relative to top threat
+    local pct = (playerThreat / topThreat) * 100
+
+    -- Determine threat situation based on the player's threat
+    local sit = 0
+    if topPlayer == playerName then
+        -- Player has aggro (or is tied for top)
+        sit = 3
+    elseif pct >= 60 then
+        sit = 2
+    elseif pct >= 30 then
+        sit = 1
+    else
+        sit = 0
+    end
+
+    -- hasGroupData: true if we have threat data from OTHER players
+    -- (via addon communication or party combat log parsing).
+    local hasGroupData = (sourceCount > 1)
+
+    return pct, sit, playerThreat, topThreat, hasGroupData, topPlayer
+end
+
+-- ============================================================
+-- Get threat info for a specific group member on a mob
+-- Returns: memberPct (0-100), memberSit (0-3), memberThreat
+-- ============================================================
+
+function addon.ThreatEngine:GetMemberThreatOnTarget(mobName, memberName)
+    if not mobName or not memberName then return 0, 0, 0 end
+
+    local mobThreat = threatData[mobName]
+    if not mobThreat then
+        return 0, 0, 0
+    end
+
+    local memberThreat = mobThreat[memberName] or 0
+    if memberThreat <= 0 then
+        return 0, 0, 0
+    end
+
+    -- Find top threat on this mob
+    local topThreat = 0
+    for source, value in pairs(mobThreat) do
+        if value > topThreat then
+            topThreat = value
+        end
+    end
+
+    if topThreat <= 0 then
+        return 0, 0, 0
+    end
+
+    local pct = (memberThreat / topThreat) * 100
+    local sit = 0
+    if pct >= 100 then
+        sit = 3
+    elseif pct >= 60 then
+        sit = 2
+    elseif pct >= 30 then
+        sit = 1
+    end
+
+    return pct, sit, memberThreat
+end
+
+-- ============================================================
+-- Get threat data for the player on a specific mob
+-- ============================================================
+
+function addon.ThreatEngine:GetPlayerThreat(mobName)
+    if not mobName then return 0 end
+    if not threatData[mobName] then return 0 end
+    return threatData[mobName][playerName] or 0
+end
+
+-- ============================================================
+-- Get the mob that the player has the most threat on
+-- ============================================================
+
+function addon.ThreatEngine:GetTopThreatTarget()
+    local maxThreat = 0
+    local maxTarget = nil
+
+    for target, sources in pairs(threatData) do
+        local playerThreat = sources[playerName] or 0
+        if playerThreat > maxThreat then
+            maxThreat = playerThreat
+            maxTarget = target
+        end
+    end
+
+    return maxTarget, maxThreat
+end
+
+-- ============================================================
+-- Get list of mob names the player or group is actively engaged with.
+-- A mob is "engaged" if:
+--   1. Any group member has threat on it (threatData entry exists)
+--   2. The mob can be found via a unit token
+--   3. The mob is actually in combat (UnitAffectingCombat)
+--
+-- KEY CHANGE: Now includes mobs that ANY group member has threat on,
+-- not just the player. This ensures healing threat splits across
+-- all mobs the group is fighting, and threat bars appear on all
+-- engaged mobs.
+--
+-- Returns: table of mob names (indexed), count
+-- ============================================================
+
+function addon.ThreatEngine:GetEngagedMobs()
+    local engaged = {}
+    local count = 0
+
+    for targetName, sources in pairs(threatData) do
+        -- Check if any group member has threat on this mob
+        local hasActiveThreat = false
+        for source, value in pairs(sources) do
+            if value > 0 then
+                -- Verify the source is in our group (or is the player)
+                if source == playerName or partyClassCache[source] then
+                    hasActiveThreat = true
+                    break
+                end
+            end
+        end
+
+        if hasActiveThreat then
+            -- Verify the mob is actually in combat.
+            -- CRITICAL FIX for same-name mobs: Check ALL unit tokens
+            -- matching this name. If ANY is in combat, the mob is engaged.
+            local anyInCombat = false
+
+            if addon.Nameplates and addon.Nameplates.GetCandidateUnitsByName then
+                local candidates = addon.Nameplates:GetCandidateUnitsByName(targetName)
+                for i = 1, table.getn(candidates) do
+                    if candidates[i].inCombat then
+                        anyInCombat = true
+                        break
+                    end
+                end
+            else
+                -- Fallback: single-token check
+                local unit = addon.Nameplates and addon.Nameplates:FindUnitByName(targetName)
+                if unit then
+                    local ok, inCombat = pcall(UnitAffectingCombat, unit)
+                    if ok and inCombat then
+                        anyInCombat = true
+                    end
+                end
+            end
+
+            if anyInCombat then
+                count = count + 1
+                engaged[count] = targetName
+            elseif addon.ThreatEngine:IsGroupInCombat() then
+                -- Can't find any in-combat unit token for this name.
+                -- If anyone in the group is in combat, assume it's still
+                -- engaged (mob might be out of unit-token range).
+                count = count + 1
+                engaged[count] = targetName
+            end
+        end
+    end
+
+    return engaged, count
+end
+
+-- ============================================================
+-- Update group combat state.
+-- Checks all party/raid members to see if any are in combat.
+-- This is essential for showing threat on mobs attacking group
+-- members when the player is NOT in combat.
+-- ============================================================
+
+local function UpdateGroupCombatState()
+    groupInCombat = false
+
+    -- Check player
+    if UnitAffectingCombat("player") then
+        groupInCombat = true
+        return
+    end
+
+    -- Check party members
+    for i = 1, 4 do
+        local unit = "party" .. i
+        if UnitExists(unit) then
+            local ok, inCombat = pcall(UnitAffectingCombat, unit)
+            if ok and inCombat then
+                groupInCombat = true
+                return
+            end
+        end
+    end
+
+    -- Check raid members
+    for i = 1, 40 do
+        local unit = "raid" .. i
+        if UnitExists(unit) then
+            local ok, inCombat = pcall(UnitAffectingCombat, unit)
+            if ok and inCombat then
+                groupInCombat = true
+                return
+            end
+        end
+    end
+end
+
+-- ============================================================
+-- Check if any group member (player or party/raid) is in combat.
+-- Returns: true if any group member is in combat, false otherwise.
+-- ============================================================
+
+function addon.ThreatEngine:IsGroupInCombat()
+    return groupInCombat or playerInCombat
+end
+
+-- ============================================================
+-- Clear all threat data
+-- ============================================================
+
+function addon.ThreatEngine:ClearAll()
+    threatData = {}
+end
+
+-- ============================================================
+-- Clear only the player's own threat data, preserving group data.
+-- Called when the player leaves combat but group members may
+-- still be fighting.
+-- ============================================================
+
+function addon.ThreatEngine:ClearPlayerThreat()
+    for target, sources in pairs(threatData) do
+        sources[playerName] = nil
+        -- If no sources remain for this target, remove the entry
+        local hasAny = false
+        for s, v in pairs(sources) do
+            if v and v > 0 then
+                hasAny = true
+                break
+            end
+        end
+        if not hasAny then
+            threatData[target] = nil
+        end
+    end
+end
+
+-- ============================================================
+-- Clear threat on a specific target
+-- ============================================================
+
+function addon.ThreatEngine:ClearTarget(mobName)
+    if mobName then
+        threatData[mobName] = nil
+    end
+end
+
+-- ============================================================
+-- Decay old threat entries (prevents stale data buildup)
+-- ============================================================
+
+function addon.ThreatEngine:DecayOld()
+    -- Remove mobs that are no longer in combat or have zero threat.
+    -- This prevents stale threat data from causing threat bars to
+    -- appear on idle nearby mobs.
+    --
+    -- CRITICAL FIX for same-name mobs: FindUnitByName only returns the
+    -- FIRST unit token matching a name. With multiple same-name mobs
+    -- (e.g. 3 "Defias Bandit"), it might find an idle one while a
+    -- different one with the same name is still in combat.
+    --
+    -- Solution: Check ALL unit tokens matching the mob name. Only
+    -- remove threat data if NO same-name unit is in combat.
+    --
+    -- Collect keys first to avoid modifying table during pairs() iteration.
+    local toRemove = {}
+    local removeCount = 0
+    for target, sources in pairs(threatData) do
+        local shouldRemove = false
+
+        -- Condition 1: All sources have zero threat
+        local hasActiveThreat = false
+        for source, value in pairs(sources) do
+            if value > 0 then
+                hasActiveThreat = true
+                break
+            end
+        end
+        if not hasActiveThreat then
+            shouldRemove = true
+        end
+
+        -- Condition 2: No one in the group is in combat — clear all mob threat.
+        if not shouldRemove and not addon.ThreatEngine:IsGroupInCombat() then
+            shouldRemove = true
+        end
+
+        -- Condition 3: Are ALL same-name mobs out of combat?
+        -- This is the critical same-name fix. We must check ALL unit
+        -- tokens matching this mob name, not just the first one.
+        if not shouldRemove and addon.ThreatEngine:IsGroupInCombat() then
+            local anyInCombat = false
+
+            -- Use GetCandidateUnitsByName to find ALL matching units
+            if addon.Nameplates and addon.Nameplates.GetCandidateUnitsByName then
+                local candidates = addon.Nameplates:GetCandidateUnitsByName(target)
+                for i = 1, table.getn(candidates) do
+                    if candidates[i].inCombat then
+                        anyInCombat = true
+                        break
+                    end
+                end
+            else
+                -- Fallback: single-token check (less accurate but safe)
+                local unit = addon.Nameplates and addon.Nameplates:FindUnitByName(target)
+                if unit then
+                    local ok, inCombat = pcall(UnitAffectingCombat, unit)
+                    if ok and inCombat then
+                        anyInCombat = true
+                    end
+                end
+            end
+
+            if not anyInCombat then
+                shouldRemove = true
+            end
+        end
+
+        if shouldRemove then
+            removeCount = removeCount + 1
+            toRemove[removeCount] = target
+        end
+    end
+    for i = 1, removeCount do
+        threatData[toRemove[i]] = nil
+    end
+end
+
+-- ============================================================
+-- Party/raid member damage event handler
+-- Parses CHAT_MSG_SPELL_PARTY_DAMAGE, CHAT_MSG_COMBAT_PARTY_HITS,
+-- CHAT_MSG_SPELL_FRIENDLYPLAYER_DAMAGE, CHAT_MSG_COMBAT_FRIENDLYPLAYER_HITS,
+-- CHAT_MSG_SPELL_PERIODIC_PARTY_DAMAGE, and
+-- CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_DAMAGE events
+-- ============================================================
+
+function addon.ThreatEngine:OnPartyDamageEvent(ev, msg)
+    if not msg then return end
+    if not playerName then return end
+
+    -- Only process if in a group
+    local inParty = GetNumPartyMembers() > 0
+    local inRaid = GetNumRaidMembers() > 0
+    if not inParty and not inRaid then return end
+
+    -- Strip absorb/resist suffixes
+    if ABSORB_TRAILER then
+        msg = string.gsub(msg, FormatToRegex(ABSORB_TRAILER), "")
+    end
+
+    -- Try to parse against party damage parsers
+    local s, t, v, sp, cr, sc = ParseMessage(PARTY_DAMAGE_PARSERS, msg)
+    if s then
+        -- Validate: source must be a known party/raid member
+        if s ~= playerName and not partyClassCache[s] then
+            -- Source is not in our group - might be a naming mismatch
+            -- or the parser captured the wrong field. Skip.
+            return
+        end
+        ProcessDamage(s, t, v, sp, cr, sc)
+    end
+end
+
+-- ============================================================
+-- Party/raid member heal event handler
+-- Parses CHAT_MSG_SPELL_PARTY_BUFF and
+-- CHAT_MSG_SPELL_FRIENDLYPLAYER_BUFF events
+-- ============================================================
+
+function addon.ThreatEngine:OnPartyHealEvent(ev, msg)
+    if not msg then return end
+    if not playerName then return end
+
+    local inParty = GetNumPartyMembers() > 0
+    local inRaid = GetNumRaidMembers() > 0
+    if not inParty and not inRaid then return end
+
+    local s, t, v, sp, cr, sc = ParseMessage(PARTY_HEAL_PARSERS, msg)
+    if s then
+        if s ~= playerName and not partyClassCache[s] then
+            return
+        end
+        ProcessHeal(s, t, v, sp)
+    end
+end
+
+-- ============================================================
+-- Party/raid member periodic event handler
+-- Parses CHAT_MSG_SPELL_PERIODIC_PARTY_BUFFS and
+-- CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_BUFFS events
+-- ============================================================
+
+function addon.ThreatEngine:OnPartyPeriodicEvent(ev, msg)
+    if not msg then return end
+    if not playerName then return end
+
+    local inParty = GetNumPartyMembers() > 0
+    local inRaid = GetNumRaidMembers() > 0
+    if not inParty and not inRaid then return end
+
+    local s, t, v, sp, cr, sc = ParseMessage(PARTY_PERIODIC_PARSERS, msg)
+    if s then
+        if s ~= playerName and not partyClassCache[s] then
+            return
+        end
+        -- HoT ticks from group members generate healing threat
+        ProcessHeal(s, t, v, sp)
+    end
+end
+
+-- ============================================================
+-- Initialize the threat engine
+-- ============================================================
+
+function addon.ThreatEngine:Initialize()
+    playerName = UnitName("player")
+    local _, class = UnitClass("player")
+    playerClass = string.lower(class or "")
+
+    -- Build parsers from GlobalStrings
+    BuildAllParsers()
+
+    -- Calculate initial threat modifier
+    CalculateThreatModifier()
+
+    -- Register for all combat log events we need
+    local combatFrame = CreateFrame("Frame", "ThreatPlatesCombatFrame")
+
+    -- Damage events
+    combatFrame:RegisterEvent("CHAT_MSG_COMBAT_SELF_HITS")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_SELF_DAMAGE")
+
+    -- Heal events
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_SELF_BUFF")
+
+    -- Periodic events (HoTs, DoTs, power gains)
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_CREATURE_DAMAGE")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_SELF_DAMAGE")
+
+    -- Death events (threat wipes)
+    combatFrame:RegisterEvent("CHAT_MSG_COMBAT_HOSTILE_DEATH")
+    combatFrame:RegisterEvent("CHAT_MSG_COMBAT_FRIENDLY_DEATH")
+
+    -- Spell failure (sunder retraction)
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_FAILED_LOCALPLAYER")
+
+    -- Addon communication
+    combatFrame:RegisterEvent("CHAT_MSG_ADDON")
+
+    -- Target tracking
+    combatFrame:RegisterEvent("PLAYER_TARGET_CHANGED")
+
+    -- Group changes
+    combatFrame:RegisterEvent("PARTY_MEMBERS_CHANGED")
+    combatFrame:RegisterEvent("RAID_ROSTER_UPDATE")
+
+    -- Combat state
+    combatFrame:RegisterEvent("PLAYER_REGEN_DISABLED")
+    combatFrame:RegisterEvent("PLAYER_REGEN_ENABLED")
+
+    -- Zone change (threat wipes on zone)
+    combatFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
+
+    -- Party/raid member combat log events
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PARTY_DAMAGE")
+    combatFrame:RegisterEvent("CHAT_MSG_COMBAT_PARTY_HITS")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_FRIENDLYPLAYER_DAMAGE")
+    combatFrame:RegisterEvent("CHAT_MSG_COMBAT_FRIENDLYPLAYER_HITS")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PARTY_BUFF")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_FRIENDLYPLAYER_BUFF")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_PARTY_BUFFS")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_BUFFS")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_PARTY_DAMAGE")
+    combatFrame:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_DAMAGE")
+
+    combatFrame:SetScript("OnEvent", function()
+        -- Vanilla 1.12: event name is in global 'event', args in global arg1..arg9
+        -- IMPORTANT: we must NOT shadow 'event' with a local or parameter
+        if event == "CHAT_MSG_ADDON" then
+            addon.ThreatEngine:OnCombatEvent(event, arg2)
+        elseif event == "CHAT_MSG_COMBAT_SELF_HITS"
+            or event == "CHAT_MSG_SPELL_SELF_DAMAGE"
+            or event == "CHAT_MSG_SPELL_SELF_BUFF"
+            or event == "CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS"
+            or event == "CHAT_MSG_SPELL_PERIODIC_CREATURE_DAMAGE"
+            or event == "CHAT_MSG_SPELL_PERIODIC_SELF_DAMAGE"
+            or event == "CHAT_MSG_COMBAT_HOSTILE_DEATH"
+            or event == "CHAT_MSG_COMBAT_FRIENDLY_DEATH"
+            or event == "CHAT_MSG_SPELL_FAILED_LOCALPLAYER" then
+            addon.ThreatEngine:OnCombatEvent(event, arg1)
+        -- Party/raid member combat log events
+        elseif event == "CHAT_MSG_SPELL_PARTY_DAMAGE"
+            or event == "CHAT_MSG_COMBAT_PARTY_HITS"
+            or event == "CHAT_MSG_SPELL_FRIENDLYPLAYER_DAMAGE"
+            or event == "CHAT_MSG_COMBAT_FRIENDLYPLAYER_HITS"
+            or event == "CHAT_MSG_SPELL_PERIODIC_PARTY_DAMAGE"
+            or event == "CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_DAMAGE" then
+            addon.ThreatEngine:OnPartyDamageEvent(event, arg1)
+        elseif event == "CHAT_MSG_SPELL_PARTY_BUFF"
+            or event == "CHAT_MSG_SPELL_FRIENDLYPLAYER_BUFF" then
+            addon.ThreatEngine:OnPartyHealEvent(event, arg1)
+        elseif event == "CHAT_MSG_SPELL_PERIODIC_PARTY_BUFFS"
+            or event == "CHAT_MSG_SPELL_PERIODIC_FRIENDLYPLAYER_BUFFS" then
+            addon.ThreatEngine:OnPartyPeriodicEvent(event, arg1)
+        end
+
+        -- Handle non-combat events
+        if event == "PLAYER_TARGET_CHANGED" then
+            local ok, name = pcall(UnitName, "target")
+            if ok and name then
+                currentTargetName = name
+            else
+                currentTargetName = nil
+            end
+
+        elseif event == "PARTY_MEMBERS_CHANGED" or event == "RAID_ROSTER_UPDATE" then
+            UpdatePartyClassCache()
+
+        elseif event == "PLAYER_ENTERING_WORLD" then
+            -- Clear threat on zone change
+            addon.ThreatEngine:ClearAll()
+
+        elseif event == "PLAYER_REGEN_DISABLED" then
+            -- Entered combat
+            playerInCombat = true
+            groupInCombat = true
+
+        elseif event == "PLAYER_REGEN_ENABLED" then
+            -- Left combat - clear the player's own threat data.
+            -- IMPORTANT: Do NOT clear all threat data if group members
+            -- are still in combat. Their threat data must be preserved
+            -- so that threat bars continue to show on mobs attacking them.
+            playerInCombat = false
+            UpdateGroupCombatState()
+            if groupInCombat then
+                -- Group members still in combat: only clear player's threat
+                addon.ThreatEngine:ClearPlayerThreat()
+            else
+                -- No one in group is in combat: safe to clear all
+                addon.ThreatEngine:ClearAll()
+            end
+        end
+    end)
+
+    self.combatFrame = combatFrame
+
+    -- Register addon communication prefix
+    local ok, _ = pcall(RegisterAddonMessagePrefix, COMM_PREFIX)
+
+    -- Set up periodic updates
+    self.updateFrame = CreateFrame("Frame", "ThreatPlatesEngineUpdateFrame")
+    self.updateFrame.elapsed = 0
+    self.updateFrame:SetScript("OnUpdate", function()
+        -- Vanilla 1.12: OnUpdate receives elapsed time in global arg1
+        this.elapsed = this.elapsed + arg1
+        if this.elapsed >= 2.0 then
+            this.elapsed = 0
+            addon.ThreatEngine:OnPeriodicUpdate()
+        end
+    end)
+
+    -- Hook CastSpellByName for Sunder Armor detection
+    if playerClass == "warrior" then
+        self:HookSunder()
+    end
+
+    addon:ui_print("Threat engine initialized for " .. playerClass)
+end
+
+-- ============================================================
+-- Periodic update (every 2 seconds)
+-- ============================================================
+
+function addon.ThreatEngine:OnPeriodicUpdate()
+    -- Recalculate threat modifier
+    CalculateThreatModifier()
+
+    -- Update party member class cache
+    UpdatePartyClassCache()
+
+    -- Update group combat state
+    UpdateGroupCombatState()
+
+    -- Broadcast threat to group
+    BroadcastThreat()
+
+    -- Decay old entries
+    self:DecayOld()
+end
+
+-- ============================================================
+-- Hook CastSpellByName and UseAction for Sunder Armor
+-- (KTM-style: detect when player casts Sunder and add threat immediately)
+-- ============================================================
+
+function addon.ThreatEngine:HookSunder()
+    -- Hook CastSpellByName
+    if not self.originalCastSpellByName then
+        self.originalCastSpellByName = CastSpellByName
+        local origCast = self.originalCastSpellByName
+
+        CastSpellByName = function(name, onSelf)
+            if name and string.find(string.lower(name), "sunder") then
+                SubmitSunderCast()
+            end
+            origCast(name, onSelf)
+        end
+    end
+
+    -- Hook UseAction (for action bar buttons)
+    if not self.originalUseAction then
+        self.originalUseAction = UseAction
+        local origUse = self.originalUseAction
+
+        UseAction = function(slot, checkCursor, onSelf)
+            -- Check if this is a Sunder Armor action
+            local ok, texture = pcall(GetActionTexture, slot)
+            if ok and texture == "Interface\\Icons\\Ability_Warrior_Sunder" then
+                SubmitSunderCast()
+            end
+            origUse(slot, checkCursor, onSelf)
+        end
+    end
+end
+
+-- ============================================================
+-- Get all threat data (for debugging/external use)
+-- ============================================================
+
+function addon.ThreatEngine:GetAllThreatData()
+    return threatData
+end
+
+-- ============================================================
+-- Check if ThreatEngine has any data for a mob
+-- ============================================================
+
+function addon.ThreatEngine:HasDataForTarget(mobName)
+    if not mobName then return false end
+    return threatData[mobName] ~= nil
+end
+
+-- ============================================================
+-- Check if player is in combat (from ThreatEngine's perspective)
+-- ============================================================
+
+function addon.ThreatEngine:IsInCombat()
+    return playerInCombat
+end
+
+-- ============================================================
+-- Slash command: /tp threat - show threat table
+-- ============================================================
+
+function addon.ThreatEngine:DumpThreat()
+    addon:ui_print("=== Threat Table ===")
+    local count = 0
+    for target, sources in pairs(threatData) do
+        for source, value in pairs(sources) do
+            if value > 0 then
+                local pct, sit, pt, tt, hasGroup = self:GetThreatOnTarget(target)
+                local groupTag = hasGroup and " [group]" or " [solo]"
+                addon:ui_print(string.format("  %s -> %s: %.0f threat (%.0f%% of %.0f)%s",
+                    source, target, value, pct, tt, groupTag))
+                count = count + 1
+            end
+        end
+    end
+    if count == 0 then
+        addon:ui_print("  (no threat data)")
+    end
+    addon:ui_print(string.format("Threat modifier: %.2f", threatModifier))
+end