local BASE_URL = "https://e.eyes-of-zero.workers.dev/?file=scripts/"
local C    = loadstring(game:HttpGet(BASE_URL.."shared/constants.lua",true))()
local Keys = loadstring(game:HttpGet(BASE_URL.."shared/keys.lua",true))()

local Players = game:GetService("Players")
local Run     = game:GetService("RunService")
local UIS     = game:GetService("UserInputService")
local Http    = game:GetService("HttpService")
local SG      = game:GetService("StarterGui")
local WS      = game:GetService("Workspace")
local VIM     = game:GetService("VirtualInputManager")
local Light   = game:GetService("Lighting")
local TweenS  = game:GetService("TweenService")
local CAS     = game:GetService("ContextActionService")
local lp      = Players.LocalPlayer

-- ── Persistence ───────────────────────────────────────────────────────────────
local function cfgPath(tag)
    return("EyesOfZero_REDLINERS_%s_%s.json"):format((lp.Name or"u"):gsub("[^%w]",""),tag)
end
local function saveCfg(t,d) if writefile then pcall(function() writefile(cfgPath(t),Http:JSONEncode(d)) end) end end
local function loadCfg(t,def)
    if not isfile or not isfile(cfgPath(t)) then return def end
    local ok,r=pcall(function() return Http:JSONDecode(readfile(cfgPath(t))) end)
    if not ok or type(r)~="table" then return def end
    for k,v in pairs(def) do if r[k]==nil then r[k]=v end end return r
end
local function loadBuilds()
    if not isfile or not isfile(cfgPath("builds")) then return{} end
    local ok,d=pcall(function() return Http:JSONDecode(readfile(cfgPath("builds"))) end)
    return(ok and type(d)=="table") and d or{}
end
local function saveBuilds(b) if writefile then pcall(function() writefile(cfgPath("builds"),Http:JSONEncode(b)) end) end end
local function getAutoLoad()
    if not isfile or not isfile(cfgPath("autoload")) then return nil end
    local ok,d=pcall(function() return Http:JSONDecode(readfile(cfgPath("autoload"))) end)
    return(ok and type(d)=="table") and d.buildName or nil
end
local function setAutoLoad(name)
    if name then saveCfg("autoload",{buildName=name})
    else if delfile then pcall(function() delfile(cfgPath("autoload")) end) end end
end
local function notify(t,d) pcall(function() SG:SetCore("SendNotification",{Title="Eyes Of Zero",Text=t,Duration=d or 3}) end) end

Keys.show(C,{gameName="REDLINERS"},function()

-- ── State & Config ────────────────────────────────────────────────────────────
local ON  = {
    autoparry=false, automelee=false, aimbot=false, esp=false, chams=false,
    wallcheck=false, showfov=false, teamcheck=false,
    hitboxexpand=false, hitboxvisual=false, velocityboost=false,
    perftweaks=false, triggerbot=false, mouseunlock=false,
}
local Cfg = loadCfg("cfg",{
    fovRadius     = 150,
    smoothing     = 1.0,    -- 1.0 = instant snap (brusco/directo), <1 = smooth
    parryRange    = 30,
    maxDist       = 800,
    hitboxSize    = 5,      -- hitbox expander size (studs)
    velocityBoost = 2.8,    -- velocity booster multiplier (default 2.8x = very noticeable)
    meleeRange    = 12,     -- auto melee range
    triggerHoldTime = 1.4,  -- seconds the triggerbot lock holds after Q+M1
})
local Keybinds = loadCfg("keybinds",{
    autoparry     = "P",
    automelee     = "N",
    esp           = "H",
    chams         = "J",
    wallcheck     = "K",
    showfov       = "B",
    aimbot        = "None",
    triggerbot    = "T",
    hitboxexpand  = "G",
    hitboxvisual  = "None",  -- separate: ESP visual of hitbox (in Visuals page)
    teamcheck     = "Y",
    velocityboost = "V",
    perftweaks    = "M",
    mouseunlock   = "U",
    togglehub     = "L",
})
local conns  = {}
local alive  = true
local BOXES  = {}   -- legacy SelectionBox refs (kept for compat, unused by new ESP)
local CHAMS  = {}   -- Highlight refs     (chams esp)
local HITBOXES = {} -- expanded hitbox part refs
local activeLoadedBuild = nil
local listeningFor = nil
local kbBtnRefs = {}
local togBtnRefs = {}

-- ── Entity helpers ────────────────────────────────────────────────────────────
local function getEntitiesFolder() return WS:FindFirstChild("Entities") end
local function getMyChar() return lp.Character end
local function getMyRoot()
    local c=getMyChar() return c and c:FindFirstChild("HumanoidRootPart")
end

local function getOwnerPlayer(model)
    -- Resolve which Player owns a given character model (for team check)
    local plr = Players:GetPlayerFromCharacter(model)
    if plr then return plr end
    -- Fallback: match by name against workspace.Entities naming
    for _, p in ipairs(Players:GetPlayers()) do
        if p.Character == model then return p end
    end
    return nil
end

local function isSameTeam(model)
    if not ON.teamcheck then return false end
    local plr = getOwnerPlayer(model)
    if not plr then return false end -- can't resolve = treat as enemy (battlegrounds/1v1 safe)
    if not plr.Team or not lp.Team then return false end -- no real teams = FFA/1v1, nothing is "ally"
    return plr.Team == lp.Team
end

local function getEnemies()
    local myChar = getMyChar()
    local seen   = {}
    local t      = {}

    local function tryAdd(model)
        if not model or model == myChar or seen[model] then return end
        local hum  = model:FindFirstChildOfClass("Humanoid")
        local root = model:FindFirstChild("HumanoidRootPart") or model.PrimaryPart
        if hum and hum.Health > 0 and root then
            if isSameTeam(model) then return end -- skip allies when team check is ON
            seen[model] = true
            t[#t+1] = {model=model, root=root}
        end
    end

    -- Source 1: workspace.Entities (game's primary entity folder)
    local ef = getEntitiesFolder()
    if ef then for _, e in ipairs(ef:GetChildren()) do tryAdd(e) end end

    -- Source 2: Players[*].Character (catches far/streamed players)
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= lp and plr.Character then tryAdd(plr.Character) end
    end

    return t
end

local function getAllies()
    -- Used by ESP to render green boxes in 2v2 when team check is on
    if not ON.teamcheck then return {} end
    local myChar = getMyChar()
    local t = {}
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= lp and plr.Character and plr.Team and lp.Team and plr.Team == lp.Team then
            local hum = plr.Character:FindFirstChildOfClass("Humanoid")
            local root = plr.Character:FindFirstChild("HumanoidRootPart")
            if hum and hum.Health > 0 and root then
                t[#t+1] = {model=plr.Character, root=root, player=plr}
            end
        end
    end
    return t
end

local function getNearestEnemy()
    local cam=WS.CurrentCamera
    local center=cam.ViewportSize/2
    local best,bestDist=nil,math.huge
    for _,e in ipairs(getEnemies()) do
        local head=e.model:FindFirstChild("Head") or e.root
        local pos,vis=cam:WorldToViewportPoint(head.Position)
        if vis then
            local d=(Vector2.new(pos.X,pos.Y)-center).Magnitude
            if d<bestDist and d<=Cfg.fovRadius then
                bestDist=d best=e
            end
        end
    end
    return best
end

-- Wall check: raycast from our root to enemy root
local function hasLOS(enemyRoot)
    local myRoot=getMyRoot() if not myRoot then return true end
    local origin=myRoot.Position
    local dir=enemyRoot.Position-origin
    local params=RaycastParams.new()
    params.FilterDescendantsInstances={getMyChar(),getEntitiesFolder()}
    params.FilterType=Enum.RaycastFilterType.Exclude
    local result=WS:Raycast(origin,dir,params)
    return result==nil  -- nil = nothing in the way = has LOS
end

-- ── Auto Parry ────────────────────────────────────────────────────────────────
local parryCooldown = false
local parryAnims    = {}   -- track which animation IDs we've seen start

local function pressF()
    pcall(function()
        VIM:SendKeyEvent(true, Enum.KeyCode.F, false, game)
        task.wait(0.05)
        VIM:SendKeyEvent(false, Enum.KeyCode.F, false, game)
    end)
end

table.insert(conns, Run.Heartbeat:Connect(function(dt)
    if not alive or not ON.autoparry or parryCooldown then return end
    local myRoot=getMyRoot() if not myRoot then return end

    for _,e in ipairs(getEnemies()) do
        if (e.root.Position-myRoot.Position).Magnitude > Cfg.parryRange then continue end

        -- Check animator for recently-started attack animations
        local hum=e.model:FindFirstChildOfClass("Humanoid")
        local anim=hum and hum:FindFirstChild("Animator")
        if not anim then continue end

        for _,track in ipairs(anim:GetPlayingAnimationTracks()) do
            -- A track in its first 0.25s = just started = possible attack
            local id=track.Animation and track.Animation.AnimationId or ""
            local key=e.model.Name..id
            if track.TimePosition>0 and track.TimePosition<0.25 and not parryAnims[key] then
                parryAnims[key]=true
                task.delay(0.5, function() parryAnims[key]=nil end)
                -- Auto-parry!
                pressF()
                parryCooldown=true
                task.delay(0.45, function() parryCooldown=false end)
                break
            end
        end
    end
end))

-- ── Auto Melee (auto-clicks M1 — left mouse button — when an enemy is close) ──
-- Same trigger pattern as Auto Parry: distance-gated, fires a left click via
-- VirtualInputManager so it behaves exactly like the player clicking M1.
-- Cooldown kept short (0.15s) so it reacts fast instead of feeling laggy.
local meleeCooldown = false
local function pressQ()
    pcall(function()
        VIM:SendKeyEvent(true, Enum.KeyCode.Q, false, game)
        task.wait(0.05)
        VIM:SendKeyEvent(false, Enum.KeyCode.Q, false, game)
    end)
end
local function clickM1()
    pcall(function()
        local mp = UIS:GetMouseLocation()
        VIM:SendMouseButtonEvent(mp.X, mp.Y, 0, true, game, 0)
        task.wait(0.04)
        VIM:SendMouseButtonEvent(mp.X, mp.Y, 0, false, game, 0)
    end)
end

table.insert(conns, Run.Heartbeat:Connect(function()
    if not alive or not ON.automelee or meleeCooldown then return end
    local myRoot=getMyRoot() if not myRoot then return end

    for _,e in ipairs(getEnemies()) do
        if (e.root.Position-myRoot.Position).Magnitude <= Cfg.meleeRange then
            clickM1()
            meleeCooldown=true
            task.delay(0.15, function() meleeCooldown=false end)
            break
        end
    end
end))

-- ── Triggerbot (Gun + M1) ─────────────────────────────────────────────────────
-- Discreet behavior (not a permanent toggle-lock like Aimbot):
--   1. Player holds Q (draw gun) and presses M1 (left click)
--   2. Camera snaps to the nearest enemy and HOLDS there for ~1.2s so the shot
--      (and any travel-time/animation the gun has) actually lands on target
--   3. Lock then releases automatically — no manual toggle needed
-- This only watches for the Q+M1 combo; it does nothing on its own otherwise.
local qHeld = false
table.insert(conns, UIS.InputBegan:Connect(function(i, gp)
    if i.KeyCode == Enum.KeyCode.Q then qHeld = true end
end))
table.insert(conns, UIS.InputEnded:Connect(function(i, gp)
    if i.KeyCode == Enum.KeyCode.Q then qHeld = false end
end))

local triggerLockUntil = 0
local triggerLockTarget = nil

table.insert(conns, UIS.InputBegan:Connect(function(i, gp)
    if not alive or not ON.triggerbot then return end
    if gp then return end
    if i.UserInputType ~= Enum.UserInputType.MouseButton1 then return end
    if not qHeld then return end -- only fires on the Q + M1 combo

    local myRoot = getMyRoot()
    if not myRoot then return end
    local target = getNearestEnemy()
    if not target then return end

    -- Hold the lock for Cfg.triggerHoldTime seconds instead of a single
    -- one-frame snap — this is what was causing it to "release" almost
    -- instantly before the shot could actually register.
    triggerLockTarget = target.model
    triggerLockUntil = os.clock() + Cfg.triggerHoldTime
end))

table.insert(conns, Run.RenderStepped:Connect(function()
    if not alive or not ON.triggerbot then triggerLockTarget=nil return end
    if not triggerLockTarget or os.clock() > triggerLockUntil then triggerLockTarget=nil return end
    if not triggerLockTarget.Parent then triggerLockTarget=nil return end

    local head = triggerLockTarget:FindFirstChild("Head") or triggerLockTarget:FindFirstChild("HumanoidRootPart")
    if not head then triggerLockTarget=nil return end

    local cam = WS.CurrentCamera
    local targetPos = head.Position + Vector3.new(0, 0.25, 0)
    cam.CFrame = CFrame.new(cam.CFrame.Position, targetPos)
end))

-- ── Aimbot (RenderPriority.Last — absolute last in render pipeline) ──────────
-- Runs AFTER everything else, including the game's own camera scripts.
-- No Q/LMB requirement — while ON, camera is permanently locked to nearest head.
Run:BindToRenderStep("GothamAimbot", Enum.RenderPriority.Last.Value, function()
    if not alive or not ON.aimbot then return end

    local myRoot = getMyRoot()
    if not myRoot then return end

    -- Find nearest enemy by WORLD DISTANCE (not screen position)
    local nearest, nearestDist = nil, math.huge
    for _, e in ipairs(getEnemies()) do
        local d = (e.root.Position - myRoot.Position).Magnitude
        if d < nearestDist then
            nearestDist = d
            nearest = e
        end
    end

    if not nearest then return end

    local head = nearest.model:FindFirstChild("Head") or nearest.root
    local cam  = WS.CurrentCamera

    -- Tiny upward offset so shots register at head center (not chin/neck)
    local targetPos = head.Position + Vector3.new(0, 0.25, 0)

    if Cfg.smoothing >= 0.999 then
        cam.CFrame = CFrame.new(cam.CFrame.Position, targetPos)
    else
        local goalCFrame = CFrame.new(cam.CFrame.Position, targetPos)
        cam.CFrame = cam.CFrame:Lerp(goalCFrame, Cfg.smoothing)
    end
end)
table.insert(conns, {Disconnect = function()
    pcall(function() Run:UnbindFromRenderStep("GothamAimbot") end)
end})

-- ── Hitbox Expander (scales the enemy's HumanoidRootPart hitbox up) ──────────
-- Uses a PropertyChangedSignal watchdog in addition to the loop: some games
-- re-sync the hitbox size from the server every frame, which silently undid
-- the old version. Re-asserting on the Size-changed signal wins that race.
-- A red wireframe box (visualHitbox) is drawn so you can SEE the new hitbox.
local hitboxWatchers = {}

local function enforceHitboxSize(root, size)
    pcall(function() root.Size = size end)
end

table.insert(conns, Run.Heartbeat:Connect(function()
    if not alive then return end
    if not ON.hitboxexpand then
        for model, data in pairs(HITBOXES) do
            pcall(function()
                if data.part and data.part.Parent then data.part.Size = data.origSize end
                if data.visual then data.visual:Destroy() end
            end)
            if hitboxWatchers[model] then hitboxWatchers[model]:Disconnect() hitboxWatchers[model]=nil end
        end
        HITBOXES = {}
        return
    end
    for model, data in pairs(HITBOXES) do
        if not model or not model.Parent then
            if data.visual then pcall(function() data.visual:Destroy() end) end
            if hitboxWatchers[model] then hitboxWatchers[model]:Disconnect() hitboxWatchers[model]=nil end
            HITBOXES[model]=nil
        end
    end
    local target = Vector3.new(Cfg.hitboxSize, Cfg.hitboxSize, Cfg.hitboxSize)
    for _, e in ipairs(getEnemies()) do
        local root = e.root
        if not HITBOXES[e.model] then
            local visual = Instance.new("SelectionBox")
            visual.Name = "GothamHitboxVisual"
            visual.Adornee = root
            visual.Color3 = Color3.fromRGB(255, 210, 0)
            visual.LineThickness = 0.05
            visual.SurfaceTransparency = 1
            visual.Parent = WS

            HITBOXES[e.model] = {part=root, origSize=root.Size, visual=visual}

            -- Watchdog: if the server/game resets Size, snap it right back.
            hitboxWatchers[e.model] = root:GetPropertyChangedSignal("Size"):Connect(function()
                if ON.hitboxexpand and HITBOXES[e.model] and (root.Size - target).Magnitude > 0.05 then
                    enforceHitboxSize(root, target)
                end
            end)
        end
        if (root.Size - target).Magnitude > 0.05 then
            enforceHitboxSize(root, target)
        end
    end
end))

-- ── Velocity Booster (multiplies horizontal movement speed) ─────────────────
-- Runs at RenderPriority.Last — the absolute final write each frame, same
-- priority as the Aimbot — so it always wins the race against the game's own
-- character-control script, which is what made the old version invisible.
local baseWalkSpeed = 16
local walkSpeedCaptured = false
Run:BindToRenderStep("GothamVelocityBoost", Enum.RenderPriority.Last.Value, function()
    if not alive then return end
    local char = getMyChar()
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    if not hum then return end

    if not walkSpeedCaptured and hum.WalkSpeed > 0 and not ON.velocityboost then
        baseWalkSpeed = hum.WalkSpeed
        walkSpeedCaptured = true
    end

    if ON.velocityboost then
        local want = baseWalkSpeed * Cfg.velocityBoost
        if hum.WalkSpeed ~= want then hum.WalkSpeed = want end
    end
end)
table.insert(conns, {Disconnect = function()
    pcall(function() Run:UnbindFromRenderStep("GothamVelocityBoost") end)
end})

-- ── Performance Tweaks (strip textures/effects for clearer, lighter visuals) ──
local perfOriginals = {}
local function applyPerfTweaks(on)
    if on then
        pcall(function()
            Light.GlobalShadows = false
            Light.FogEnd = 100000
        end)
        for _, v in ipairs(WS:GetDescendants()) do
            if v:IsA("Texture") or v:IsA("Decal") then
                if perfOriginals[v]==nil then perfOriginals[v]=v.Transparency end
                pcall(function() v.Transparency = 1 end)
            elseif v:IsA("ParticleEmitter") or v:IsA("Trail") or v:IsA("Smoke") or v:IsA("Fire") then
                if perfOriginals[v]==nil then perfOriginals[v]=v.Enabled end
                pcall(function() v.Enabled = false end)
            elseif v:IsA("MeshPart") then
                if perfOriginals[v]==nil then perfOriginals[v]=v.Material end
                pcall(function() v.Material = Enum.Material.SmoothPlastic end)
            end
        end
        notify("Performance tweaks applied",2)
    else
        for inst, orig in pairs(perfOriginals) do
            pcall(function()
                if inst and inst.Parent then
                    if inst:IsA("Texture") or inst:IsA("Decal") then inst.Transparency = orig
                    elseif inst:IsA("ParticleEmitter") or inst:IsA("Trail") or inst:IsA("Smoke") or inst:IsA("Fire") then inst.Enabled = orig
                    elseif inst:IsA("MeshPart") then inst.Material = orig end
                end
            end)
        end
        perfOriginals = {}
    end
end
local lastPerf = false
table.insert(conns, Run.Heartbeat:Connect(function()
    if ON.perftweaks ~= lastPerf then
        lastPerf = ON.perftweaks
        applyPerfTweaks(lastPerf)
    end
end))

-- ── Mouse Unlock (frees the cursor and makes it VISIBLY PRESENT) ──────────────────────
-- Forces MouseBehavior.Default and aggressively sets cursor to always be visible.
-- The game may try to hide it but we re-apply every frame with standard arrows.
local mouse = lp:GetMouse()
table.insert(conns, Run.Heartbeat:Connect(function()
    if not alive then return end
    if ON.mouseunlock then
        if UIS.MouseBehavior ~= Enum.MouseBehavior.Default then
            UIS.MouseBehavior = Enum.MouseBehavior.Default
        end
        UIS.MouseIconEnabled = true
        -- Force a visible cursor by constantly re-setting to default arrow icon
        -- which Roblox always provides built-in.
        if mouse.Icon ~= "rbxasset://textures/Cursors/MouseArrow.png" then
            mouse.Icon = "rbxasset://textures/Cursors/MouseArrow.png"
        end
    end
end))

-- ══════════════════════════════════════════════════════════════════════════
-- ESP — built with the Drawing API (vector lines), not SelectionBox/ImageLabel.
-- This is what fixes the "pixelated" look: SelectionBox renders through the
-- game's 3D pipeline at native res and can look blocky at distance, and the
-- old FOV circle was a raster image (rbxassetid) stretched up, which blurs.
-- Drawing objects are GPU vector overlays — crisp at any zoom/distance.
-- ══════════════════════════════════════════════════════════════════════════
local DrawingAvailable = (typeof(Drawing) == "table")

local ESP_OBJ = {} -- [model] = { box, name, dist }

local function newDrawing(class, props)
    local ok, obj = pcall(function() return Drawing.new(class) end)
    if not ok then return nil end
    for k,v in pairs(props) do pcall(function() obj[k]=v end) end
    return obj
end

local function destroyEspObj(e)
    for _,k in pairs(e) do
        if typeof(k)=="table" and k.Remove then pcall(function() k:Remove() end) end
    end
end

local function ensureEspObj(model)
    if ESP_OBJ[model] or not DrawingAvailable then return end
    ESP_OBJ[model] = {
        box      = newDrawing("Square",  {Thickness=1.4, Filled=false, Color=Color3.fromRGB(255,60,60), Transparency=1, Visible=false}),
        name     = newDrawing("Text",    {Size=14, Center=true, Outline=true, Color=Color3.fromRGB(255,255,255), Visible=false}),
        dist     = newDrawing("Text",    {Size=12, Center=true, Outline=true, Color=Color3.fromRGB(200,200,200), Visible=false}),
    }
end

local function hideEspObj(model)
    local e = ESP_OBJ[model]
    if not e then return end
    for k,v in pairs(e) do
        if typeof(v)=="table" and v.Visible~=nil then v.Visible=false end
    end
end

local function clearAllEsp()
    for model, e in pairs(ESP_OBJ) do destroyEspObj(e) end
    ESP_OBJ = {}
end

local function getToolName(model)
    local tool = model:FindFirstChildOfClass("Tool")
    return tool and tool.Name or nil
end

local function updateEspEntity(e, color, isAlly)
    ensureEspObj(e.model)
    local d = ESP_OBJ[e.model]
    if not d then return end

    local cam = WS.CurrentCamera
    local hum = e.model:FindFirstChildOfClass("Humanoid")
    local root = e.root
    local head = e.model:FindFirstChild("Head") or root

    -- Bounding box from head/root corners projected to screen
    local topPos, topVis    = cam:WorldToViewportPoint((head.Position + Vector3.new(0,1,0)))
    local botPos, botVis    = cam:WorldToViewportPoint((root.Position - Vector3.new(0,3,0)))

    if (not topVis and not botVis) or topPos.Z<0 then
        hideEspObj(e.model)
        return
    end

    local height = math.abs(topPos.Y - botPos.Y)
    local width  = height * 0.55
    local cx, cy = topPos.X, (topPos.Y+botPos.Y)/2

    if ON.esp then
        d.box.Visible = true
        d.box.Color = color
        d.box.Size = Vector2.new(width, height)
        d.box.Position = Vector2.new(cx - width/2, topPos.Y)

        d.name.Visible = true
        d.name.Text = e.model.Name .. (isAlly and " [Ally]" or "")
        d.name.Color = isAlly and Color3.fromRGB(80,255,120) or Color3.fromRGB(255,255,255)
        d.name.Position = Vector2.new(cx, topPos.Y - 16)

        local dist = (getMyRoot() and (getMyRoot().Position - root.Position).Magnitude) or 0
        d.dist.Visible = true
        d.dist.Text = string.format("[%dm]", dist)
        d.dist.Position = Vector2.new(cx, botPos.Y + 2)

    else
        d.box.Visible=false d.name.Visible=false d.dist.Visible=false
    end
end

table.insert(conns, Run.RenderStepped:Connect(function()
    if not alive or not DrawingAvailable then return end

    if not ON.esp then
        for _, e in pairs(ESP_OBJ) do hideEspObj(nil) end
        for model,_ in pairs(ESP_OBJ) do hideEspObj(model) end
        return
    end

    local seenModels = {}

    for _, e in ipairs(getEnemies()) do
        seenModels[e.model] = true
        updateEspEntity(e, Color3.fromRGB(255,60,60), false)
    end

    if ON.teamcheck then
        for _, e in ipairs(getAllies()) do
            seenModels[e.model] = true
            updateEspEntity(e, Color3.fromRGB(80,255,120), true)
        end
    end

    for model, e in pairs(ESP_OBJ) do
        if not seenModels[model] or not model.Parent then
            destroyEspObj(e)
            ESP_OBJ[model] = nil
        end
    end
end))

-- ── Chams (Glow style or Box Fill style — selectable, always through walls) ──
table.insert(conns, Run.Heartbeat:Connect(function()
    if not alive then return end

    if not ON.chams then
        for _,h in pairs(CHAMS) do pcall(function() h:Destroy() end) end CHAMS={} return
    end

    for e,h in pairs(CHAMS) do
        if not e or not e.Parent then pcall(function() h:Destroy() end) CHAMS[e]=nil end
    end

    for _,e in ipairs(getEnemies()) do
        if not CHAMS[e.model] then
            local h=Instance.new("Highlight")
            h.Adornee=e.model
            h.DepthMode=Enum.HighlightDepthMode.AlwaysOnTop
            h.Parent=e.model