-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6a74978ea2884d2c5b5fdcd9"))()
	end)
end)
--[[rscripts:analytics:end]]

--
-- Improved version:
--   * Instant Proximity Prompt: auto-loaded from scriptblox (user's pick)
--     every time the hub opens — no UI button anymore
--   * Silent Aim / Kill Closest: loops actually STOP on toggle off (the old ones
--     never stopped and stacked = lag), fire rate throttled instead of 60x/sec
--   * Enemy ESP: single update loop, safe highlight cleanup

local okLib, library = pcall(function()
    local src = game:HttpGet("https://raw.githubusercontent.com/deeeity/mercury-lib/master/src.lua")
    -- set the toggle key to K from the start (library defaults to Delete)
    src = src:gsub("Keybind = Enum.KeyCode.Delete", "Keybind = Enum.KeyCode.K", 1)
    return loadstring(src)()
end)
if not okLib or not library then
    warn("[notveryuhq] Mercury UI failed to load: " .. tostring(library))
    return
end

-- ================================================================
-- WINDOW (Legacy theme: dark + purple accent)
-- ================================================================
local window = library:create{ Theme = library.Themes.Legacy }
_G.BIOSYN_WINDOW = window   -- exposed: the ⬡ toggle + external tools use this

-- ================================================================
-- MAIN TABS
-- ================================================================
local combatTab = window:tab{ Name = "Combat", Icon = "rbxassetid://6034996695" }
local visualsTab = window:tab{ Name = "Visuals", Icon = "rbxassetid://6034996695" }
local miscTab = window:tab{ Name = "Misc", Icon = "rbxassetid://6034996695" }

-- ================================================================
-- OPEN ONLY Combat / Visuals / Misc AT START
-- Mercury hides tab buttons until you click a quick-access icon on
-- the home page. Reveal just our 3 tabs in the nav bar and open
-- Combat. Settings / Credits are NOT deleted: they stay reachable
-- through the home-page gear / credits icons, but their nav buttons
-- are kept hidden — even if something tries to reveal them later.
-- ================================================================
local startupOk, startupErr = pcall(function()
    local wanted = { Combat = true, Visuals = true, Misc = true }
    local nav = window.navigation.AbsoluteObject
    local nilFolder = window.nilFolder and window.nilFolder.AbsoluteObject
    local activePage = nil

    for _, info in ipairs(window.Tabs) do
        local page, btn, name = info[1], info[2], info[3]
        if name and wanted[name] then
            -- reveal only our 3 tab buttons in the nav bar
            btn.Parent = nav
            btn.Visible = true
            if name == "Combat" then
                activePage = page
            end
        elseif name then
            -- Settings / Credits: pull out of the nav and keep hidden.
            -- If the home-page gear/credits icon reveals them again the
            -- button is hidden instantly — the page itself still opens,
            -- so Settings/Credits remain fully usable.
            pcall(function()
                btn.Visible = false
                if nilFolder then
                    btn.Parent = nilFolder
                end
                btn:GetPropertyChangedSignal("Visible"):Connect(function()
                    if btn.Visible then
                        task.defer(function()
                            btn.Visible = false
                        end)
                    end
                end)
            end)
        end
    end

    -- fallback: first wanted tab if Combat wasn't found
    if not activePage then
        for _, info in ipairs(window.Tabs) do
            if wanted[info[3]] then
                activePage = info[1]
                break
            end
        end
    end

    -- show only the active page (pages overlap, so only one can show)
    for _, info in ipairs(window.Tabs) do
        if info[3] then
            info[1].Visible = (info[1] == activePage)
        end
    end
    if window.homePage then
        window.homePage.Visible = false
    end

    -- selected button = solid, the rest = transparent
    for _, info in ipairs(window.Tabs) do
        local page, btn, name = info[1], info[2], info[3]
        if name and wanted[name] then
            btn.BackgroundTransparency = (page == activePage) and 0 or 1
        end
    end

    -- deselect the home button so only Combat reads as active
    if window.homeButton then
        window.homeButton.BackgroundTransparency = 1
    end

    -- keep the address bar in sync
    pcall(function()
        window.UrlLabel.Text = window.Url .. "/combat"
    end)
end)
if not startupOk then
    warn("[notveryuhq] tab reveal failed: " .. tostring(startupErr))
end

-- ================================================================
-- SECTION LABELS (Mercury has no Section object — labels divide)
-- ================================================================
local aimSection = combatTab
local tanzaniteSection = combatTab
local espSection = visualsTab
local utilitySection = miscTab
local infoSection = miscTab

-- ================================================================
-- VARIABLES
-- ================================================================
local plr = game.Players.LocalPlayer
local workspace = game.Workspace
local players = game.Players
local runService = game:GetService("RunService")
local npcFolder = workspace:FindFirstChild("NPCs")
local uis = game:GetService("UserInputService")

-- ================================================================
-- FALLBACK fireproximityprompt (fixed: InputHoldStart/Finish)
-- ================================================================
if not fireproximityprompt then
    fireproximityprompt = function(prompt)
        if not prompt or not prompt:IsA("ProximityPrompt") then return end
        pcall(function()
            prompt:InputHoldStart()
            task.wait(0.05)
            prompt:InputHoldFinish()
        end)
    end
end

-- ================================================================
-- INSTANT PROXIMITY PROMPT — external script (user's pick), auto-run
-- every time the hub opens. Spawned in its own thread so the Mercury UI
-- never waits on the HttpGet/scan (zero visible hitch), pcall-guarded.
-- No UI button anymore: it just runs.
-- ================================================================
local INSTANT_PROMPT_URL = "https://scriptblox.com/raw/Universal-Script-Best-Instant-Proximity-Prompt-Script-242054"
local instantPromptStatus = "loading"

-- anti-stutter: lighter slide impact FX + lower graphics baseline (client-side)
task.spawn(function()
    pcall(function()
        workspace:SetAttribute("SlideHitFxOff", true)          -- no dust/sound spam on slide impacts (yours and others')
        plr:SetAttribute("ScreenEffects", "low")               -- halves particle counts for effects that respect it
        local Lighting = game:GetService("Lighting")
        Lighting.GlobalShadows = false                         -- big GPU win
        pcall(function() setfpscap(144) end)                   -- Xeno-only; pcall-guarded
        pcall(function()
            local ugs = UserSettings():GetService("UserGameSettings")
            ugs.SavedQualityLevel = Enum.SavedQualitySetting.QualityLevel5
        end)
    end)
end)

-- anti-stutter: throttle ambient/emitter storm (fog, poison goo, portals,
-- weapon barrel flames, fireflies). Purely visual — no gameplay effect.
task.spawn(function()
    local function matchesAmbient(n)
        local l = string.lower(n or "")
        for _, pat in ipairs({ "icy fog", "forest", "poongoo", "goo", "poison", "portal", "spark", "firefly", "fog" }) do
            if l:find(pat, 1, true) then return true end
        end
        return false
    end
    local function throttle(root)
        for _, d in ipairs(root:GetDescendants()) do
            if d:IsA("ParticleEmitter") then
                local a = d.Parent
                local b = a and a.Parent
                local bg = (b and b.Name) or ""
                local pn = (a and a.Name) or ""
                -- environmental haze: disable outright
                if (string.lower(bg):find("icy fog") or string.lower(bg):find("forest") or string.lower(bg):find("fog")) and d.Enabled then
                    pcall(function() d.Enabled = false end)
                elseif (matchesAmbient(bg .. pn) or pn == "Particles" or bg == "ToAnimte") and d.Rate > 8 then
                    pcall(function() d.Rate = 8 end)
                elseif a and a.Name == "Barrel" and d.Rate > 8 then
                    pcall(function() d.Rate = 8 end)           -- burning weapon flames
                end
            end
        end
    end
    throttle(workspace)
    -- keep watching for newly spawned ambient emitters while playing
    local conn
    conn = workspace.DescendantAdded:Connect(function(d)
        if d:IsA("ParticleEmitter") then
            task.delay(0.1, function()
                if not d.Parent then return end
                local a = d.Parent
                local b = a and a.Parent
                local n = string.lower(((b and b.Name) or "") .. " " .. ((a and a.Name) or ""))
                if n:find("icy fog") or n:find("forest") or n:find("fog") then
                    pcall(function() d.Enabled = false end)
                elseif matchesAmbient(n) or (a and (a.Name == "Particles" or a.Name == "Barrel") or (b and b.Name == "ToAnimte")) then
                    pcall(function() if d.Rate > 8 then d.Rate = 8 end end)
                end
            end)
        end
    end)
    -- drop watchers from previous runs instead of stacking them
    if _G.BIOSYN_CLEANUP then
        for _, c in ipairs(_G.BIOSYN_CLEANUP) do
            pcall(function() c:Disconnect() end)
        end
        _G.BIOSYN_CLEANUP = {}
    else
        _G.BIOSYN_CLEANUP = {}
    end
    table.insert(_G.BIOSYN_CLEANUP, conn)
end)

task.spawn(function()
    local okRun, err = pcall(function()
        local src = game:HttpGet(INSTANT_PROMPT_URL)
        -- soften the external script: instant 0s hold -> 0.4s hold (guards included)
        src = src:gsub("HoldDuration%s*=%s*0", "HoldDuration = 0.4")
        src = src:gsub("HoldDuration%s*~=%s*0", "HoldDuration ~= 0.4")
        local chunk = loadstring(src)
        if not chunk then error("loadstring returned nil") end
        chunk()
    end)
    instantPromptStatus = okRun and "on" or ("failed: " .. tostring(err))
    if okRun then
        print("[✓] Instant Proximity Prompt: loaded (external)")
    else
        warn("[notveryuhq] instant prompt load failed: " .. tostring(err))
    end
end)

-- ================================================================
-- GENERATOR TARGETING (permanent rule, no toggle button)
-- Every target pick (silent aim, kill closest, axe aura) ranks
-- enemies by their distance to THE GENERATOR — the thing enemies
-- actually attack. The generator is auto-found on every map; when a
-- map has none, everything silently falls back to closest-to-player.
-- ================================================================
local generatorRef = nil
local generatorPos = nil
local findFailedAt = nil

local function findGenerator()
    -- fast path known for this game: Workspace.GeneratorFolder.GeneratorPart
    local folder = workspace:FindFirstChild("GeneratorFolder")
    if folder then
        local part = folder:FindFirstChild("GeneratorPart")
        if part and part:IsA("BasePart") then
            generatorRef, generatorPos = part, part.Position
            return true
        end
        local any = folder:FindFirstChildWhichIsA("BasePart", true)
        if any then
            generatorRef, generatorPos = any, any.Position
            return true
        end
    end
    -- generic fallback: any generator-named part/model in the map
    local now = tick()
    if findFailedAt and (now - findFailedAt) < 10 then
        return generatorRef ~= nil   -- don't rescan the whole map constantly after a miss
    end
    for _, d in ipairs(workspace:GetDescendants()) do
        local ln = string.lower(d.Name)
        if ln:find("generator", 1, true)
            and (d:IsA("BasePart") or d:IsA("Model"))
            and ln:find("danger", 1, true) == nil
            and ln:find("manager", 1, true) == nil then
            if d:IsA("BasePart") then
                generatorRef, generatorPos = d, d.Position
                break
            elseif d:IsA("Model") then
                local p = d:FindFirstChildWhichIsA("BasePart")
                if p then
                    generatorRef, generatorPos = p, p.Position
                    break
                end
            end
        end
    end
    if not generatorRef then
        findFailedAt = now
        return false
    end
    return true
end

-- make sure the reference is still valid (maps get replaced/destroyed)
local function ensureGenerator()
    if not generatorRef or not generatorRef.Parent then
        generatorRef, generatorPos = nil, nil
        findGenerator()
    end
end

-- new map spawned: a fresh GeneratorFolder appears — notice it cheaply
workspace.ChildAdded:Connect(function(child)
    if child.Name == "GeneratorFolder" then
        findGenerator()
    end
end)
findGenerator()
print("[✓] Generator targeting: " .. (generatorRef and ("on (" .. tostring(math.floor(generatorPos.X)) .. ", " .. tostring(math.floor(generatorPos.Y)) .. ", " .. tostring(math.floor(generatorPos.Z)) .. ")") or "no generator on this map yet — will auto-find"))

-- ================================================================
-- FRIENDLY-FIRE GUARD (permanent) — players are NEVER targets.
-- A teammate who spawned as a lake monster still owns a real Player
-- Character and gets tagged like an NPC for pathing; without this the
-- aura/aim/ESP treat him as food. Any model owned by a Player is
-- skipped everywhere (enemy waves are NPC-owned, they stay targetable).
-- ================================================================
local function isPlayerOwned(model)
    if model and players:GetPlayerFromCharacter(model) then
        return true
    end
    return false
end

-- ================================================================
-- SINGLE ENEMY CACHE
-- ================================================================
local enemyCache = {}
local cacheTimestamp = 0
local CACHE_DURATION = 0.25   -- was 0.5: faster target switching

local function refreshEnemyCache()
    local now = tick()
    if now - cacheTimestamp < CACHE_DURATION then
        return enemyCache
    end
    cacheTimestamp = now

    local newCache = {}
    if npcFolder then
        for _, v in ipairs(npcFolder:GetChildren()) do
            if v.Name == "Tango" or v.Name == "Monsters" then
                for _, k in ipairs(v:GetChildren()) do
                    if k:IsA("Model") and k:FindFirstChild("HumanoidRootPart") and not isPlayerOwned(k) then
                        local humanoid = k:FindFirstChild("Humanoid")
                        if humanoid and humanoid.Health > 0 then
                            table.insert(newCache, k)
                        end
                    end
                end
            end
        end
    end

    enemyCache = newCache
    return enemyCache
end

local function getclosestenemy()
    local enemies = refreshEnemyCache()
    if #enemies == 0 then return nil end

    local char = plr.Character
    if not char then return nil end
    local hrp = char:FindFirstChild("HumanoidRootPart")
    local playerPos = hrp and hrp.Position or nil

    ensureGenerator()

    local closest = nil
    local bestKey = math.huge

    for _, k in ipairs(enemies) do
        local targetHrp = k:FindFirstChild("HumanoidRootPart")
        if targetHrp then
            local key
            if generatorPos then
                -- PERMANENT RULE: rank by distance to the generator
                key = (targetHrp.Position - generatorPos).Magnitude
            elseif playerPos then
                -- no generator on this map: closest to player
                key = (targetHrp.Position - playerPos).Magnitude
            end
            if key and key < bestKey then
                closest = k
                bestKey = key
            end
        end
    end
    return closest
end

-- ================================================================
-- CACHED TOOL / REMOTE
-- ================================================================
local cachedTool = nil
local cachedRemote = nil

local function getTool()
    local char = plr.Character
    if not char then return nil end
    if cachedTool and cachedTool.Parent == char then
        return cachedTool
    end
    cachedTool = char:FindFirstChildOfClass("Tool")
    if cachedTool then
        cachedRemote = cachedTool:FindFirstChild("Main")
    else
        cachedRemote = nil
    end
    return cachedTool
end

local function getAmmo()
    local gui = plr.PlayerGui
    if not gui then return 999 end
    local crosshair = gui:FindFirstChild("Crosshair")
    if not crosshair then return 999 end
    local counter = crosshair:FindFirstChild("Counter")
    if not counter then return 999 end
    local stored = counter:FindFirstChild("StoredAmmo")
    if not stored then return 999 end
    return tonumber(stored.Text) or 999
end

-- ================================================================
-- COMBAT TOGGLES (throttled, stop in <100ms on toggle off, idle when dead)
-- ================================================================

-- interruptible sleep: wakes every `slice` so toggling OFF takes effect fast,
-- but still respects the throttle rate (no busy-waiting)
local function sleepWhile(cond, seconds, slice)
    local deadline = tick() + seconds
    while cond() and tick() < deadline do
        task.wait(slice or 0.02)
    end
end

local function charAlive()
    local char = plr.Character
    if not char then return false end
    local hum = char:FindFirstChildOfClass("Humanoid")
    return hum ~= nil and hum.Health > 0
end

-- shots fired counter (for tuning/verification)
local shotCount = { silent = 0, kill = 0 }

-- target must still be alive, else force a cache rescan immediately
local function validTarget(target)
    if not target or not target.Parent then return false end
    local hum = target:FindFirstChild("Humanoid")
    if not hum or hum.Health <= 0 then
        cacheTimestamp = 0
        return false
    end
    return target:FindFirstChild("Head") ~= nil
end

-- Silent Aim
local silentAimOn = false
local silentAimLoop = false
local SILENT_AIM_RATE = 0.02   -- ~50 shots/sec (maxed out)
local IDLE_WAIT = 0.4          -- dead / no weapon = near-zero activity

local function setSilentAim(state)
    silentAimOn = state
    if not state or silentAimLoop then return end
    silentAimLoop = true

    task.spawn(function()
        while silentAimOn do
            if not charAlive() then
                sleepWhile(function() return silentAimOn end, IDLE_WAIT, 0.05)
                continue
            end

            local tool = getTool()
            local remote = cachedRemote
            if not tool or not remote then
                sleepWhile(function() return silentAimOn end, IDLE_WAIT, 0.05)
                continue
            end

            local target = getclosestenemy()
            if not validTarget(target) then
                sleepWhile(function() return silentAimOn end, 0.05)
                continue
            end

            local head = target:FindFirstChild("Head")
            shotCount.silent += 1
            pcall(function()
                remote:FireServer("DAMAGE", {head, head.Position, 0, false})
            end)
            sleepWhile(function() return silentAimOn end, SILENT_AIM_RATE)
        end
        silentAimLoop = false
    end)
end

-- Kill Closest
local killClosestOn = false
local killClosestLoop = false
local KILL_RATE = 0.015         -- ~66 swings/sec (maxed out)

local function setKillClosest(state)
    killClosestOn = state
    if not state or killClosestLoop then return end
    killClosestLoop = true

    task.spawn(function()
        while killClosestOn do
            if not charAlive() then
                sleepWhile(function() return killClosestOn end, IDLE_WAIT, 0.05)
                continue
            end

            local tool = getTool()
            local remote = cachedRemote
            if not tool or not remote then
                sleepWhile(function() return killClosestOn end, IDLE_WAIT, 0.05)
                continue
            end

            local target = getclosestenemy()
            if not validTarget(target) then
                sleepWhile(function() return killClosestOn end, 0.05)
                continue
            end

            local head = target:FindFirstChild("Head")
            local ammo = getAmmo()

            -- DAMAGE always fires (this is what kills); ammo only gates the
            -- cosmetic shot-feel calls, so low reserve never stalls the aura
            shotCount.kill += 1
            pcall(function()
                remote:FireServer("DAMAGE", {head, head.Position, 0, false})
                if ammo and ammo >= 10 then
                    remote:FireServer("AMMO")
                    local handle = tool:FindFirstChild("Handle")
                    if handle then
                        local barrel = handle:FindFirstChild("Barrel")
                        if barrel then
                            remote:FireServer("MUZZLE", barrel)
                        end
                    end
                end
            end)

            sleepWhile(function() return killClosestOn end, KILL_RATE)
        end
        killClosestLoop = false
    end)
end

-- ONE button drives both (user request: same button)
local function setCombat(state)
    setSilentAim(state)
    setKillClosest(state)
end

combatTab:label{ Text = "🎯 Silent Aim", Description = "Auto-aim + kill aura" }
combatTab:toggle{
    Name = "⚔️ Combat Combo",
    Description = "Silent aim + kill closest in one toggle",
    StartingState = false,
    Callback = setCombat,
}

-- ================================================================
-- ESP (single update loop, safe cleanup)
-- ================================================================
local espEnabled = false
local espLoopRunning = false
local espHighlights = {}

local function updateESP()
    if not espEnabled then
        for i = #espHighlights, 1, -1 do
            local h = espHighlights[i]
            pcall(function() h:Destroy() end)
            table.remove(espHighlights, i)
        end
        return
    end

    local enemies = refreshEnemyCache()

    for i = #espHighlights, 1, -1 do
        local h = espHighlights[i]
        local dead = false
        pcall(function()
            dead = (not h.Parent) or (not h.Adornee) or (not h.Adornee.Parent)
        end)
        if dead then
            pcall(function() h:Destroy() end)
            table.remove(espHighlights, i)
        end
    end

    for _, enemy in ipairs(enemies) do
        local hasHighlight = false
        for _, h in ipairs(espHighlights) do
            if h.Adornee == enemy then
                hasHighlight = true
                break
            end
        end
        if not hasHighlight then
            local highlight = Instance.new("Highlight")
            highlight.FillTransparency = 1
            highlight.OutlineColor = Color3.fromRGB(255, 0, 0)
            highlight.OutlineTransparency = 0
            highlight.Adornee = enemy
            highlight.Parent = enemy
            table.insert(espHighlights, highlight)
        end
    end
end

local function setESP(state)
    espEnabled = state
    if state then
        if not espLoopRunning then
            espLoopRunning = true
            task.spawn(function()
                while espEnabled do
                    pcall(updateESP)
                    sleepWhile(function() return espEnabled end, 0.75)
                end
                espLoopRunning = false
                pcall(updateESP)
            end)
        end
    else
        pcall(updateESP) -- clears highlights immediately
    end
end
_G.BIOSYN_SETESP = setESP

visualsTab:label{ Text = "👁️ Visuals", Description = "See enemies through walls" }
visualsTab:toggle{
    Name = "Enemy ESP",
    Description = "Highlights all enemies",
    StartingState = false,
    Callback = setESP,
}

-- ================================================================
-- TANZANITE AXE TAB (native)
-- The old toggles loaded MoonSec-obfuscated remote scripts that now
-- die instantly inside their VM: "attempt to index nil with 'Main'".
-- These use the axe's own client protocol instead (verified live):
--   SWING:   Main:FireServer("SWING", {})
--   DAMAGE:  Main:FireServer("DAMAGE", { enemyModel })
--   CHARGE:  Main:FireServer("CHARGE", { seconds })   (2..8)
--   5th combo: Main:FireServer("AxeExplode", {})
-- Enemies come from CollectionService tags "Tango"/"Monster"
-- (what the axe itself targets). Server accepted DAMAGE from 700+
-- studs away, so no distance gating is needed.
-- ================================================================
local CollectionService = game:GetService("CollectionService")

local function getCharAxe()
    local char = plr.Character
    if not char then return nil end
    -- Tanzanite Axe first, then any other axe variant
    local a = char:FindFirstChild("Tanzanite Axe")
    if a then return a end
    local held = char:FindFirstChildOfClass("Tool")
    if held and held.Name:find("Axe", 1, true) then return held end
    return nil
end

-- enemies via the same tags the axe's own client scans
-- PERMANENT RULE: sorted by distance to the generator (falls back to
-- player distance only on maps without one). The "dist" field stays
-- = distance to PLAYER (used by the close-swing check below).
local function collectTargets(tags)
    local char = plr.Character
    local hrp = char and char:FindFirstChild("HumanoidRootPart")
    ensureGenerator()
    local out = {}
    for _, tag in ipairs(tags) do
        for _, m in ipairs(CollectionService:GetTagged(tag)) do
            local root = m:FindFirstChild("HumanoidRootPart")
            local hum = m:FindFirstChild("Humanoid")
            if root and hum and hum.Health > 0 and not (m:GetAttribute("HitByClient") or false) and not isPlayerOwned(m) then
                table.insert(out, {
                    model = m,
                    dist = hrp and (root.Position - hrp.Position).Magnitude or 9e9,
                    gen = generatorPos and (root.Position - generatorPos).Magnitude or nil,
                })
            end
        end
    end
    if generatorPos and #out > 0 then
        table.sort(out, function(a, b) return a.gen < b.gen end)
    else
        table.sort(out, function(a, b)
            return a.dist < b.dist
        end)
    end
    return out
end

-- one aura cycle (measured live: constant 2.0s cycle keeps swings accepted):
--  - close target  -> real tool:Activate() swing (free, no meter usage)
--  - far targets   -> raw SWING + DAMAGE + AxeExplode packets (accepted at
--    any distance by the server)
-- the aura never teleports or moves you.
local function axeAuraCycle(tags)
    local char = plr.Character
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    if not (hum and hum.Health > 0) then return end
    local axe = getCharAxe()
    if not axe then
        -- auto-equip from the backpack (Tanzanite Axe, then any Axe variant)
        local bp = plr:FindFirstChildOfClass("Backpack")
        local a2 = bp and (bp:FindFirstChild("Tanzanite Axe") or bp:FindFirstChild("Axe"))
        if a2 then pcall(function() hum:EquipTool(a2) end) end
        return
    end
    if not axe:FindFirstChild("Main") then return end
    if (axe:GetAttribute("Uses") or 0) <= 0 then return end
    local hrp = char:FindFirstChild("HumanoidRootPart")
    if not hrp then return end

    local targets = collectTargets(tags)
    if #targets == 0 then return end

    -- close range: actual swing, always works
    if targets[1].dist <= (axe:GetAttribute("Range") or 10) + 2 then
        pcall(function() axe:Activate() end)
        task.wait(0.9)
        return
    end

    -- far: raw packets, keeps whole map reachable
    local maxTargets = axe:GetAttribute("MaxTargets") or 3
    local chosen = {}
    for i = 1, math.min(maxTargets, #targets) do
        table.insert(chosen, targets[i])
    end
    local mainEvent = axe:FindFirstChild("Main")
    mainEvent:FireServer("SWING", {})
    task.wait(0.07)
    for _, t in ipairs(chosen) do
        if t.model.Parent then
            pcall(function()
                mainEvent:FireServer("DAMAGE", { t.model })
            end)
        end
    end
    pcall(function()
        mainEvent:FireServer("AxeExplode", {})
    end)
end

local function startAuraLoop(getState, tags, label)
    task.spawn(function()
        while getState() do
            local ok, err = pcall(axeAuraCycle, tags)
            if not ok then
                warn("[notveryuhq] " .. label .. " error: " .. tostring(err))
            end
            sleepWhile(getState, 0.45)  -- ~1 swing / 0.9s (in-game Cooldown is 0.8)
        end
    end)
end

local infChargeRunning = false

combatTab:label{ Text = "🪓 Tanzanite Axe", Description = "Axe charge + kill aura (native)" }
combatTab:toggle{
    Name = "⚡ Infinite Charge",
    Description = "Instantly re-charges the axe when possible",
    StartingState = false,
    Callback = function(state)
        infChargeRunning = state
        print("[✓] Tanzanite Axe Inf Charge: " .. (state and "ENABLED" or "DISABLED"))
        if state then
            task.spawn(function()
                while infChargeRunning do
                    pcall(function()
                        local axe = getCharAxe()
                        local main = axe and axe:FindFirstChild("Main")
                        if axe and main
                            and not axe:GetAttribute("Charged")
                            and not axe:GetAttribute("IsChargeCooldown") then
                            main:FireServer("CHARGE", { 8 })
                        end
                    end)
                    sleepWhile(function() return infChargeRunning end, 1.0)
                end
            end)
        end
    end,
}

local allAuraRunning = false

combatTab:toggle{
    Name = "💀 Kill All",
    Description = "Kill Tango + Monsters at once (native)",
    StartingState = false,
    Callback = function(state)
        if state and not allAuraRunning then
            allAuraRunning = true
            print("[✓] Kill All Aura: ENABLED")
            startAuraLoop(function() return allAuraRunning end, { "Tango", "Monster" }, "Kill All aura")
        elseif not state and allAuraRunning then
            allAuraRunning = false
            print("[✓] Kill All Aura: DISABLED")
        end
    end,
}

-- ================================================================
-- UTILITY BUTTONS
-- ================================================================
miscTab:label{ Text = "🛠️ Utility", Description = "Server + character tools" }
miscTab:button{
    Name = "💀 Reset Char",
    Description = "Respawns you",
    Callback = function()
        local char = plr.Character
        if char then
            char:BreakJoints()
        end
    end,
}

miscTab:button{
    Name = "Rejoin Server",
    Description = "Leaves and rejoins",
    Callback = function()
        game:GetService("TeleportService"):Teleport(game.PlaceId)
    end,
}

-- ================================================================
-- INFO
-- ================================================================
miscTab:label{ Text = "⌨️ K = show / hide hub" }
miscTab:label{ Text = "📱 Tap the ⬡ button (top-right) to show/hide hub • hold + move to drag it" }
miscTab:label{ Text = "📱 Drag the top bar to move" }

-- ================================================================
-- MOBILE SHOW/HIDE BUTTON — floating button that toggles the hub
-- window; works on touch AND mouse (tap or click).
-- ================================================================
task.spawn(function()
    local UserInputService = game:GetService("UserInputService")

    -- remove toggle buttons from previous runs (no duplicates)
    pcall(function()
        local containers = {}
        local okHui, hui = pcall(function() return gethui and gethui() end)
        if okHui and hui then table.insert(containers, hui) end
        pcall(function() table.insert(containers, game:GetService("CoreGui")) end)
        table.insert(containers, plr:FindFirstChild("PlayerGui"))
        for _, container in ipairs(containers) do
            if container then
                for _, gui in ipairs(container:GetChildren()) do
                    if gui:IsA("ScreenGui") and gui.Name == "BIOSYN_MobileToggle" then
                        gui:Destroy()
                    end
                end
            end
        end
    end)

    -- Mercury wraps its window in a tweened "core" frame controlled by
    -- window:show(state) — that's the same path its own K keybind uses.
    local hubVisible = true      -- window starts visible

    local function toggleHub()
        hubVisible = not hubVisible
        pcall(function()
            window:show(hubVisible)
        end)
    end
    _G.BIOSYN_TOGGLE = function(force)
        if force == nil then force = not hubVisible end
        hubVisible = force
        pcall(function()
            window:show(hubVisible)
        end)
        return hubVisible
    end

    -- floating button (parented to a CoreGui holder so the game cannot delete it)
    local holderOk, holder = pcall(function()
        local okHui, hui = pcall(function() return gethui and gethui() end)
        return (okHui and hui) or game:GetService("CoreGui")
    end)
    if not holderOk or not holder then holder = plr:FindFirstChild("PlayerGui") end

    local screen = Instance.new("ScreenGui")
    screen.Name = "BIOSYN_MobileToggle"
    screen.ResetOnSpawn = false
    screen.IgnoreGuiInset = true
    screen.DisplayOrder = 999999

    local btn = Instance.new("TextButton")
    btn.Name = "ToggleHub"
    btn.Text = "⬡"
    btn.TextSize = 26
    btn.Font = Enum.Font.GothamBold
    btn.TextColor3 = Color3.fromRGB(235, 235, 255)
    btn.BackgroundColor3 = Color3.fromRGB(35, 30, 55)
    btn.BackgroundTransparency = 0.15
    btn.Size = UDim2.fromOffset(56, 56)
    btn.Position = UDim2.new(1, -66, 0, 66)      -- top-right, thumb friendly
    btn.Active = true
    btn.Visible = true                           -- always visible (mouse + touch)
    screen.Parent = holder
    btn.Parent = screen

    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(1, 0)
    corner.Parent = btn

    local stroke = Instance.new("UIStroke")
    stroke.Color = Color3.fromRGB(150, 120, 255)
    stroke.Thickness = 2
    stroke.Parent = btn

    -- tap/click = toggle; drag = move 1:1 with the cursor.
    -- FIX: the old math mixed two coordinate spaces (input position vs the
    -- gui's own offset space — the hidden UI container shifts our gui
    -- vertically), so the button TELEPORTED toward the wrong corner the
    -- moment a drag started. Every move is now anchored to the button's
    -- live AbsolutePosition + this event's Delta, then clamped to the
    -- viewport: it follows the cursor exactly and can never leave screen.
    local dragging = false
    local dragMoved = false
    local pressInput
    btn.InputBegan:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
            dragging = true
            dragMoved = false
            pressInput = Vector2.new(input.Position.X, input.Position.Y)
        end
    end)
    btn.InputEnded:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
            if dragging and not dragMoved then
                _G.BIOSYN_TOGGLE()
            end
            dragging = false
            pressInput = nil
        end
    end)
    UserInputService.InputChanged:Connect(function(input)
        if not (dragging and pressInput and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch)) then
            return
        end
        -- dead zone: anything within 8px of the press counts as a click
        if not dragMoved then
            if (Vector2.new(input.Position.X, input.Position.Y) - pressInput).Magnitude > 8 then
                dragMoved = true
            else
                return
            end
        end
        if dragMoved then
            local cam = workspace.CurrentCamera
            local vp = cam and cam.ViewportSize or Vector2.new(1920, 1080)
            if vp.X > 200 and vp.Y > 200 then
                local abs = btn.AbsolutePosition
                local size = btn.AbsoluteSize
                local nx = math.clamp(abs.X + input.Delta.X, 8, vp.X - size.X - 8)
                local ny = math.clamp(abs.Y + input.Delta.Y, 8, vp.Y - size.Y - 8)
                btn.Position = UDim2.fromOffset(nx - screen.AbsolutePosition.X, ny - screen.AbsolutePosition.Y)
            end
        end
    end)

    -- Mercury's own K keybind keeps working; keep our flag in sync
    pcall(function()
        UserInputService.InputBegan:Connect(function(input, gp)
            if gp then return end
            if input.KeyCode == Enum.KeyCode.K then
                hubVisible = not hubVisible
            end
        end)
    end)

    print("[✓] ⬡ toggle: ready (tap/click to show/hide hub)")
end)

-- remote control / diagnostics (lets tools toggle features without the UI)
_G.BIOSYN = {
    setSilentAim = setSilentAim,
    setKillClosest = setKillClosest,
    setCombat = setCombat,
    setESP = setESP,
    state = function()
        return {
            instantPrompt = instantPromptStatus,
            silent = silentAimOn,
            silentLoop = silentAimLoop,
            kill = killClosestOn,
            killLoop = killClosestLoop,
            esp = espEnabled,
            shots = { silent = shotCount.silent, kill = shotCount.kill },
            build = 22,
        }
    end,
}