KEYLESS ORBS MAGNET, MOVE SPEED, AUTO STEER , ETC...

Script source Luau

Copy Script

-- [[ BloxScripts Risk Notice ]]
-- This script has not been verified by BloxScripts.fun. 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 BloxScripts 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=6addd36a91f0da85692b2104"))()
	end)
end)
--[[rscripts:analytics:end]]

--!nolint
-- ============================================================================
-- roblox-exploit - worm odyssey
--
-- Target: worm odyssey | PlaceId: 113394252054854
-- Dump:   client only (no ServerScriptService), so server validation is unseen.
-- Features: 12 | Highest risk generated: T3 (one manual dev-remote button)
--
-- ONE FILE ONLY. No external files, no loadstring, no HTTP, no print/warn.
-- This game keeps all of its state in in-game ModuleScripts, so the script
-- imports those modules at runtime to reach the real objects:
--   PlayerScripts.Client.{Behavior,Collision,Snake}
--   ReplicatedStorage.Shared.Constants
--   ReplicatedStorage.Remotes.*
-- ============================================================================

local CONFIG = {
    Title = "worm odyssey | client tools",
    Width = 660,
    Height = 500,
    ToggleKey = Enum.KeyCode.RightControl,
    GuiName = "Interface",
    Version = "1.0.0",
}

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UIS = game:GetService("UserInputService")
local Lighting = game:GetService("Lighting")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local LocalPlayer = Players.LocalPlayer

-- ============================================================================
-- Compatibility layer
-- ============================================================================

local Compat = {}
Compat.Name = "unknown"

do
    local ok, name = pcall(function()
        if type(identifyexecutor) == "function" then
            return identifyexecutor()
        end
        return nil
    end)
    if ok and name then
        Compat.Name = tostring(name)
    end
end

function Compat.GetGenv()
    local ok, env = pcall(function()
        if type(getgenv) == "function" then
            return getgenv()
        end
        return nil
    end)
    if ok and type(env) == "table" then
        return env
    end
    return _G
end

function Compat.Gethui()
    local ok, hui = pcall(function()
        if type(gethui) == "function" then
            return gethui()
        end
        return nil
    end)
    if ok then
        return hui
    end
    return nil
end

function Compat.HasDrawing()
    return type(Drawing) == "table" and type(Drawing.new) == "function"
end

-- ============================================================================
-- Utilities
-- ============================================================================

local State = {
    Unloading = false,
    StartedAt = os.clock(),
}

local Log = {
    Entries = {},
    Max = 200,
}

function Log:Add(level, message)
    table.insert(self.Entries, {
        level = tostring(level or "info"),
        message = tostring(message or ""),
        time = os.clock(),
    })
    while #self.Entries > self.Max do
        table.remove(self.Entries, 1)
    end
end

local Bag = {}
Bag.__index = Bag

function Bag.new()
    return setmetatable({ Items = {} }, Bag)
end

function Bag:Connect(signal, callback)
    local connection = signal:Connect(callback)
    table.insert(self.Items, connection)
    return connection
end

function Bag:Add(connection)
    table.insert(self.Items, connection)
    return connection
end

function Bag:Clear()
    for index = #self.Items, 1, -1 do
        local connection = self.Items[index]
        if connection then
            pcall(function()
                connection:Disconnect()
            end)
        end
    end
    self.Items = {}
end

-- Restore also works on plain tables (module tables), because it only uses
-- instance[property] reads and writes.
local Restore = {}
Restore.__index = Restore

function Restore.new()
    return setmetatable({ Saved = {} }, Restore)
end

function Restore:Set(instance, property, value)
    if not instance then
        return
    end
    self.Saved[instance] = self.Saved[instance] or { values = {} }
    local record = self.Saved[instance]
    if record.values[property] == nil then
        local ok, original = pcall(function()
            return instance[property]
        end)
        if ok then
            record.values[property] = original
        end
    end
    local ok = pcall(function()
        instance[property] = value
    end)
    if not ok then
        Log:Add("warn", "restore set failed: " .. tostring(property))
    end
end

function Restore:All()
    for instance, record in pairs(self.Saved) do
        for property, original in pairs(record.values) do
            pcall(function()
                instance[property] = original
            end)
        end
    end
    self.Saved = {}
end

local GlobalBag = Bag.new()
local GlobalRestore = Restore.new()
local GlobalThreads = {}

local function spawnGlobal(fn, name)
    local thread = task.spawn(function()
        local ok, err = pcall(fn)
        if not ok then
            Log:Add("error", tostring(name or "thread") .. ": " .. tostring(err))
        end
    end)
    table.insert(GlobalThreads, thread)
    return thread
end

-- ============================================================================
-- Remote wrapper: token bucket + jitter. Never fires in a tight loop.
-- ============================================================================

local Net = {
    Buckets = {},
    MaxPerSecond = 8,
}

function Net:Fire(remote, minInterval, ...)
    if not remote then
        return false
    end
    local now = os.clock()
    local bucket = self.Buckets[remote]
    if not bucket then
        bucket = { last = 0, window = now, count = 0 }
        self.Buckets[remote] = bucket
    end
    if now - bucket.window >= 1 then
        bucket.window = now
        bucket.count = 0
    end
    local interval = (minInterval or 0.1) * (0.85 + math.random() * 0.3)
    if now - bucket.last < interval then
        return false
    end
    if bucket.count >= self.MaxPerSecond then
        return false
    end
    bucket.last = now
    bucket.count = bucket.count + 1
    local args = table.pack(...)
    local ok, err = pcall(function()
        remote:FireServer(table.unpack(args, 1, args.n))
    end)
    if not ok then
        Log:Add("error", "remote fire failed: " .. tostring(err))
    end
    return ok
end

function Net:Invoke(remote, ...)
    if not remote then
        return nil
    end
    local args = table.pack(...)
    local ok, result = pcall(function()
        return remote:InvokeServer(table.unpack(args, 1, args.n))
    end)
    if not ok then
        Log:Add("error", "remote invoke failed: " .. tostring(result))
        return nil
    end
    return result
end

-- ============================================================================
-- GUI library (embedded, cheap scrolling menu, Right Ctrl toggle)
-- ============================================================================

--!nolint
-- ============================================================================
-- Cheap scrolling GUI for Roblox executor scripts (single-file, paste-in).
--
-- This file is meant to be pasted INTO a generated script, not required as a
-- module. It starts with `local Gui = {}` and intentionally has no top-level
-- `return`, so it will not abort the host script.
--
-- Usage:
--   local Menu = Gui.new({
--       Title = "roblox-exploit",
--       Width = 640,
--       Height = 480,
--       ToggleKey = Enum.KeyCode.RightControl,
--       OnUnload = function() end,
--   })
--   local tab = Menu:Tab("Combat")
--   local sec = tab:Section("Aimbot", true)
--   sec:Checkbox("Enabled", false, function(v) end)
--   sec:Slider("FOV", 10, 360, 120, function(v) end)
--   Menu:AddUnloadTab({ Info = "..." })
--   Menu:SetStatus("Ready")
-- ============================================================================

local Gui = {}
Gui.__index = Gui
Gui.Version = "1.0.0"

local Players = game:GetService("Players")
local UIS = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")
local LocalPlayer = Players.LocalPlayer

local THEME = {
    WindowBg = Color3.fromRGB(240, 240, 240),
    TitleBg = Color3.fromRGB(200, 200, 200),
    StatusBg = Color3.fromRGB(200, 200, 200),
    SectionBg = Color3.fromRGB(230, 230, 230),
    FrameBg = Color3.fromRGB(255, 255, 255),
    FrameHover = Color3.fromRGB(225, 225, 225),
    FrameActive = Color3.fromRGB(210, 210, 210),
    TabActive = Color3.fromRGB(230, 230, 230),
    TabInactive = Color3.fromRGB(210, 210, 210),
    Border = Color3.fromRGB(150, 150, 150),
    Text = Color3.fromRGB(0, 0, 0),
    TextDim = Color3.fromRGB(80, 80, 80),
    Accent = Color3.fromRGB(0, 100, 200),
    Danger = Color3.fromRGB(200, 0, 0),
    Green = Color3.fromRGB(0, 150, 0),
    Yellow = Color3.fromRGB(180, 150, 0),
    ToastBg = Color3.fromRGB(255, 255, 200),
}

local function make(class, props, parent)
    local inst = Instance.new(class)
    for key, value in pairs(props or {}) do
        inst[key] = value
    end
    if parent then
        inst.Parent = parent
    end
    return inst
end

local function addStroke(parent, color, transparency)
    local stroke = Instance.new("UIStroke")
    stroke.Color = color or THEME.Border
    stroke.Thickness = 1
    stroke.Transparency = transparency or 0
    stroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
    stroke.Parent = parent
    return stroke
end

local function addPadding(parent, left, right, top, bottom)
    local pad = Instance.new("UIPadding")
    pad.PaddingLeft = UDim.new(0, left or 0)
    pad.PaddingRight = UDim.new(0, right or 0)
    pad.PaddingTop = UDim.new(0, top or 0)
    pad.PaddingBottom = UDim.new(0, bottom or 0)
    pad.Parent = parent
    return pad
end

local function addList(parent, padding, horizontal)
    local layout = Instance.new("UIListLayout")
    layout.Padding = UDim.new(0, padding or 0)
    layout.SortOrder = Enum.SortOrder.LayoutOrder
    layout.FillDirection = horizontal and Enum.FillDirection.Horizontal or Enum.FillDirection.Vertical
    layout.VerticalAlignment = Enum.VerticalAlignment.Center
    layout.Parent = parent
    return layout
end

local function textLabel(parent, text, color, size)
    return make("TextLabel", {
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 0, size or 18),
        Font = Enum.Font.Code,
        Text = text or "",
        TextSize = 13,
        TextColor3 = color or THEME.Text,
        TextXAlignment = Enum.TextXAlignment.Left,
        TextYAlignment = Enum.TextYAlignment.Center,
        TextWrapped = false,
        RichText = false,
        TextTruncate = Enum.TextTruncate.AtEnd,
    }, parent)
end

local function viewportSize()
    local camera = workspace.CurrentCamera
    if camera then
        return camera.ViewportSize
    end
    return Vector2.new(1920, 1080)
end

local function resolveGuiParent()
    local ok, hui = pcall(function()
        if type(gethui) == "function" then
            return gethui()
        end
        return nil
    end)
    if ok and hui then
        return hui
    end
    local okCore, core = pcall(function()
        return game:GetService("CoreGui")
    end)
    if okCore and core then
        return core
    end
    return LocalPlayer:WaitForChild("PlayerGui")
end

-- ---------------------------------------------------------------------------
-- Handles returned by widgets
-- ---------------------------------------------------------------------------

local Handle = {}
Handle.__index = Handle

local TabMethods = {}
local SectionMethods = {}

local function newHandle(setter, getter)
    return setmetatable({
        _set = setter,
        _get = getter,
    }, Handle)
end

function Handle:Set(value)
    if self._set then
        self._set(value)
    end
end

function Handle:Get()
    if self._get then
        return self._get()
    end
    return nil
end

-- ---------------------------------------------------------------------------
-- Menu
-- ---------------------------------------------------------------------------

function Gui.new(opts)
    opts = opts or {}
    local self = setmetatable({}, Gui)

    self.Opts = opts
    self.Title = opts.Title or "roblox-exploit"
    self.Width = opts.Width or 640
    self.Height = opts.Height or 480
    self.ToggleKey = opts.ToggleKey or Enum.KeyCode.RightControl
    self.Theme = setmetatable(opts.Theme or {}, { __index = THEME })
    self.Tabs = {}
    self.TabOrder = {}
    self.CurrentTab = nil
    self._conns = {}
    self._unloaded = false
    self._destroyed = false
    self._visible = true
    self._collapsed = false
    self._expandedHeight = self.Height
    self._onUnload = opts.OnUnload
    self._onRestore = opts.OnRestore
    self._capturingKey = false
    self._captureToken = nil
    self._toastToken = nil

    local parent = resolveGuiParent()
    self.Gui = make("ScreenGui", {
        Name = opts.GuiName or "Interface",
        ResetOnSpawn = false,
        IgnoreGuiInset = true,
        DisplayOrder = 999999,
        ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
        Enabled = true,
    })
    local okParent = pcall(function()
        self.Gui.Parent = parent
    end)
    if not okParent then
        self.Gui.Parent = LocalPlayer:WaitForChild("PlayerGui")
    end

    local viewport = viewportSize()
    local startX = math.max(8, math.floor((viewport.X - self.Width) / 2))
    local startY = math.max(8, math.floor((viewport.Y - self.Height) / 2))

    self.Window = make("Frame", {
        Name = "Window",
        BackgroundColor3 = self.Theme.WindowBg,
        BorderSizePixel = 0,
        ClipsDescendants = true,
        Active = true,
        Size = UDim2.fromOffset(self.Width, self.Height),
        Position = UDim2.fromOffset(startX, startY),
        ZIndex = 2,
    }, self.Gui)
    addStroke(self.Window, self.Theme.Border)

    self.TitleBar = make("Frame", {
        Name = "TitleBar",
        BackgroundColor3 = self.Theme.TitleBg,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 26),
        Position = UDim2.new(0, 0, 0, 0),
        ZIndex = 3,
    }, self.Window)

    self.TitleLabel = make("TextButton", {
        Name = "Title",
        BackgroundTransparency = 1,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(1, -56, 1, 0),
        Position = UDim2.new(0, 0, 0, 0),
        Font = Enum.Font.Code,
        Text = "  " .. self.Title,
        TextSize = 13,
        TextColor3 = self.Theme.Text,
        TextXAlignment = Enum.TextXAlignment.Left,
        ZIndex = 4,
    }, self.TitleBar)

    self.CollapseButton = make("TextButton", {
        Name = "Collapse",
        BackgroundTransparency = 1,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(0, 26, 0, 26),
        Position = UDim2.new(1, -52, 0, 0),
        Font = Enum.Font.Code,
        Text = "-",
        TextSize = 16,
        TextColor3 = self.Theme.TextDim,
        ZIndex = 4,
    }, self.TitleBar)

    self.CloseButton = make("TextButton", {
        Name = "Close",
        BackgroundTransparency = 1,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(0, 26, 0, 26),
        Position = UDim2.new(1, -26, 0, 0),
        Font = Enum.Font.Code,
        Text = "x",
        TextSize = 14,
        TextColor3 = self.Theme.TextDim,
        ZIndex = 4,
    }, self.TitleBar)

    self.Body = make("Frame", {
        Name = "Body",
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 1, -26),
        Position = UDim2.new(0, 0, 0, 26),
        ClipsDescendants = true,
        ZIndex = 3,
    }, self.Window)

    self.TabBar = make("Frame", {
        Name = "TabBar",
        BackgroundColor3 = self.Theme.WindowBg,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 26),
        Position = UDim2.new(0, 0, 0, 0),
        ClipsDescendants = true,
        ZIndex = 4,
    }, self.Body)
    addPadding(self.TabBar, 4, 4, 2, 2)
    addList(self.TabBar, 2, true)

    self.Content = make("Frame", {
        Name = "Content",
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 1, -48),
        Position = UDim2.new(0, 0, 0, 26),
        ClipsDescendants = true,
        ZIndex = 3,
    }, self.Body)

    self.Status = make("TextLabel", {
        Name = "Status",
        BackgroundColor3 = self.Theme.StatusBg,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 22),
        Position = UDim2.new(0, 0, 1, -22),
        Font = Enum.Font.Code,
        Text = "  Ready",
        TextSize = 12,
        TextColor3 = self.Theme.TextDim,
        TextXAlignment = Enum.TextXAlignment.Left,
        ZIndex = 4,
    }, self.Body)

    self.Resize = make("TextButton", {
        Name = "Resize",
        BackgroundTransparency = 1,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(0, 16, 0, 16),
        Position = UDim2.new(1, -16, 1, -16),
        Font = Enum.Font.Code,
        Text = "/",
        TextSize = 14,
        TextColor3 = self.Theme.TextDim,
        ZIndex = 10,
    }, self.Window)

    self.Toast = make("TextLabel", {
        Name = "Toast",
        BackgroundColor3 = self.Theme.ToastBg,
        BorderSizePixel = 0,
        Size = UDim2.new(1, -40, 0, 24),
        Position = UDim2.new(0, 20, 1, -56),
        Font = Enum.Font.Code,
        Text = "",
        TextSize = 12,
        TextColor3 = self.Theme.Text,
        Visible = false,
        ZIndex = 20,
    }, self.Window)

    self:_bindDrag()
    self:_bindResize()
    self:_bindToggle()
    self:_bindTitleButtons()
    return self
end

function Gui:_bindToggle()
    table.insert(self._conns, UIS.InputBegan:Connect(function(input, processed)
        if self._capturingKey then
            return
        end
        if processed and input.KeyCode ~= self.ToggleKey then
            return
        end
        if input.KeyCode == self.ToggleKey then
            self:SetVisible(not self._visible)
        end
    end))
end

function Gui:_bindTitleButtons()
    table.insert(self._conns, self.CloseButton.MouseButton1Click:Connect(function()
        self:SetVisible(false)
    end))

    table.insert(self._conns, self.CollapseButton.MouseButton1Click:Connect(function()
        self._collapsed = not self._collapsed
        if self._collapsed then
            self._expandedWidth = self.Window.Size.X.Offset
            self._expandedHeight = self.Window.Size.Y.Offset
            self.Window.Size = UDim2.new(0, self._expandedWidth, 0, 26)
            self.Body.Visible = false
            self.CollapseButton.Text = "+"
        else
            self.Window.Size = UDim2.new(0, self._expandedWidth or self.Width, 0, self._expandedHeight)
            self.Body.Visible = true
            self.CollapseButton.Text = "-"
        end
    end))

    table.insert(self._conns, self.CloseButton.MouseEnter:Connect(function()
        self.CloseButton.TextColor3 = self.Theme.Danger
    end))
    table.insert(self._conns, self.CloseButton.MouseLeave:Connect(function()
        self.CloseButton.TextColor3 = self.Theme.TextDim
    end))
    table.insert(self._conns, self.CollapseButton.MouseEnter:Connect(function()
        self.CollapseButton.TextColor3 = self.Theme.Text
    end))
    table.insert(self._conns, self.CollapseButton.MouseLeave:Connect(function()
        self.CollapseButton.TextColor3 = self.Theme.TextDim
    end))
end

function Gui:_bindDrag()
    local dragging = false
    local startMouse = Vector2.zero
    local startPos = UDim2.new()
    local moveConn = nil
    local endConn = nil

    local function stop()
        dragging = false
        if moveConn then
            moveConn:Disconnect()
            moveConn = nil
        end
        if endConn then
            endConn:Disconnect()
            endConn = nil
        end
    end

    table.insert(self._conns, self.TitleLabel.InputBegan:Connect(function(input)
        if input.UserInputType ~= Enum.UserInputType.MouseButton1
            and input.UserInputType ~= Enum.UserInputType.Touch then
            return
        end
        dragging = true
        startMouse = UIS:GetMouseLocation()
        startPos = self.Window.Position
        stop()
        dragging = true
        moveConn = UIS.InputChanged:Connect(function()
            if not dragging then
                return
            end
            local delta = UIS:GetMouseLocation() - startMouse
            self:_setPosition(startPos.X.Offset + delta.X, startPos.Y.Offset + delta.Y)
        end)
        endConn = UIS.InputEnded:Connect(function(event)
            if event.UserInputType == input.UserInputType then
                stop()
            end
        end)
        table.insert(self._conns, moveConn)
        table.insert(self._conns, endConn)
    end))
end

function Gui:_bindResize()
    local resizing = false
    local startMouse = Vector2.zero
    local startSize = Vector2.zero
    local moveConn = nil
    local endConn = nil

    local function stop()
        resizing = false
        if moveConn then
            moveConn:Disconnect()
            moveConn = nil
        end
        if endConn then
            endConn:Disconnect()
            endConn = nil
        end
    end

    table.insert(self._conns, self.Resize.InputBegan:Connect(function(input)
        if input.UserInputType ~= Enum.UserInputType.MouseButton1
            and input.UserInputType ~= Enum.UserInputType.Touch then
            return
        end
        resizing = true
        startMouse = UIS:GetMouseLocation()
        startSize = Vector2.new(self.Window.Size.X.Offset, self.Window.Size.Y.Offset)
        stop()
        resizing = true
        moveConn = UIS.InputChanged:Connect(function()
            if not resizing then
                return
            end
            local delta = UIS:GetMouseLocation() - startMouse
            local viewport = viewportSize()
            local width = math.clamp(startSize.X + delta.X, 420, math.max(420, viewport.X))
            local height = math.clamp(startSize.Y + delta.Y, 300, math.max(300, viewport.Y))
            self.Window.Size = UDim2.fromOffset(width, height)
        end)
        endConn = UIS.InputEnded:Connect(function(event)
            if event.UserInputType == input.UserInputType then
                stop()
            end
        end)
        table.insert(self._conns, moveConn)
        table.insert(self._conns, endConn)
    end))
end

function Gui:_setPosition(x, y)
    local viewport = viewportSize()
    local width = self.Window.Size.X.Offset
    local height = self.Window.Size.Y.Offset
    x = math.clamp(x, 0, math.max(0, viewport.X - width))
    y = math.clamp(y, 0, math.max(0, viewport.Y - math.min(height, 26)))
    self.Window.Position = UDim2.fromOffset(x, y)
end

function Gui:Tab(name)
    if self.Tabs[name] then
        return self.Tabs[name]
    end

    local tab = {
        Name = name,
        Menu = self,
        _order = 0,
    }
    setmetatable(tab, { __index = TabMethods })

    local button = make("TextButton", {
        Name = "Tab_" .. name,
        BackgroundColor3 = self.Theme.TabInactive,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(0, math.max(44, #name * 7 + 18), 0, 22),
        Font = Enum.Font.Code,
        Text = name,
        TextSize = 12,
        TextColor3 = self.Theme.TextDim,
        TextXAlignment = Enum.TextXAlignment.Center,
        ZIndex = 5,
    }, self.TabBar)
    addPadding(button, 7, 7, 0, 0)

    local frame = make("ScrollingFrame", {
        Name = "TabFrame_" .. name,
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 1, 0),
        Position = UDim2.new(0, 0, 0, 0),
        CanvasSize = UDim2.new(0, 0, 0, 0),
        AutomaticCanvasSize = Enum.AutomaticSize.Y,
        ScrollingDirection = Enum.ScrollingDirection.Y,
        ScrollBarThickness = 6,
        ScrollBarImageColor3 = self.Theme.Accent,
        ClipsDescendants = true,
        Visible = false,
        ZIndex = 3,
    }, self.Content)
    addPadding(frame, 8, 8, 8, 8)
    addList(frame, 6, false)

    tab.Button = button
    tab.Frame = frame
    self.Tabs[name] = tab
    table.insert(self.TabOrder, tab)

    table.insert(self._conns, button.MouseButton1Click:Connect(function()
        self:SelectTab(tab)
    end))
    table.insert(self._conns, button.MouseEnter:Connect(function()
        if self.CurrentTab ~= tab then
            button.BackgroundColor3 = self.Theme.FrameHover
        end
    end))
    table.insert(self._conns, button.MouseLeave:Connect(function()
        if self.CurrentTab ~= tab then
            button.BackgroundColor3 = self.Theme.TabInactive
        end
    end))

    if not self.CurrentTab then
        self:SelectTab(tab)
    end
    return tab
end

function Gui:SelectTab(tab)
    for _, candidate in ipairs(self.TabOrder) do
        local active = candidate == tab
        candidate.Frame.Visible = active
        candidate.Button.BackgroundColor3 = active and self.Theme.TabActive or self.Theme.TabInactive
        candidate.Button.TextColor3 = active and self.Theme.Text or self.Theme.TextDim
    end
    self.CurrentTab = tab
end

function Gui:SetVisible(value)
    self._visible = value and true or false
    if self.Gui then
        self.Gui.Enabled = self._visible
    end
end

function Gui:IsVisible()
    return self._visible
end

function Gui:Toggle()
    self:SetVisible(not self._visible)
end

function Gui:SetStatus(text)
    if self._destroyed then
        return
    end
    if self.Status then
        self.Status.Text = "  " .. tostring(text or "")
    end
end

function Gui:Toast(text, duration)
    if not self.Toast or self._destroyed then
        return
    end
    local token = {}
    self._toastToken = token
    self.Toast.Text = tostring(text or "")
    self.Toast.Visible = true
    self.Toast.TextTransparency = 0
    self.Toast.BackgroundTransparency = 0.1
    task.delay(duration or 2, function()
        if self._toastToken ~= token or self._destroyed then
            return
        end
        pcall(function()
            TweenService:Create(self.Toast, TweenInfo.new(0.25), {
                TextTransparency = 1,
                BackgroundTransparency = 1,
            }):Play()
        end)
        task.wait(0.3)
        if self._toastToken == token and not self._destroyed then
            self.Toast.Visible = false
        end
    end)
end

function Gui:AddUnloadTab(info)
    info = info or {}
    local tab = self:Tab("Unload")
    if self._unloadTabBuilt then
        return tab
    end
    self._unloadTabBuilt = true

    tab:Text(info.Info or "Unload the script and restore every change.", self.Theme.TextDim)
    tab:Separator()
    tab:Button("Unload Script", function()
        self:Unload()
    end, self.Theme.Danger)
    tab:Button("Reset Features", function()
        if self._onRestore then
            pcall(self._onRestore)
            self:Toast("Features reset")
        end
    end)
    tab:Button("Hide Menu (Right Ctrl)", function()
        self:SetVisible(false)
    end)
    tab:Text("Risk: green = local, yellow = replicated, red = server-visible or guarded.", self.Theme.TextDim)
    return tab
end

function Gui:OnRestore(fn)
    self._onRestore = fn
end

function Gui:Unload()
    if self._unloaded then
        return
    end
    self._unloaded = true
    if self._onUnload then
        pcall(self._onUnload)
    end
    -- Defer destruction so a button callback is not torn down mid-call.
    task.defer(function()
        if not self._destroyed then
            self:Destroy()
        end
    end)
end

function Gui:Destroy()
    if self._destroyed then
        return
    end
    self._destroyed = true
    for index = #self._conns, 1, -1 do
        pcall(function()
            self._conns[index]:Disconnect()
        end)
    end
    self._conns = {}
    if self.Gui then
        pcall(function()
            self.Gui:Destroy()
        end)
        self.Gui = nil
    end
end

-- ---------------------------------------------------------------------------
-- Tabs and sections
-- ---------------------------------------------------------------------------

function TabMethods:Section(title, open)
    local menu = self.Menu
    local theme = menu.Theme
    self._order = self._order + 1

    local section = {
        Tab = self,
        Menu = menu,
        Open = open ~= false,
        _order = 0,
    }
    setmetatable(section, { __index = SectionMethods })

    local frame = make("Frame", {
        Name = "Section_" .. tostring(title),
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 0),
        AutomaticSize = Enum.AutomaticSize.Y,
        LayoutOrder = self._order,
        ClipsDescendants = true,
        ZIndex = 3,
    }, self.Frame)
    addStroke(frame, theme.Border, 0.55)
    addList(frame, 0, false)

    local header = make("TextButton", {
        Name = "Header",
        BackgroundColor3 = theme.FrameBg,
        BackgroundTransparency = 0.25,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(1, 0, 0, 24),
        LayoutOrder = 1,
        Font = Enum.Font.Code,
        Text = (section.Open and "  v  " or "  >  ") .. tostring(title),
        TextSize = 12,
        TextColor3 = theme.Text,
        TextXAlignment = Enum.TextXAlignment.Left,
        ZIndex = 4,
    }, frame)

    local content = make("Frame", {
        Name = "Content",
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 0),
        AutomaticSize = Enum.AutomaticSize.Y,
        LayoutOrder = 2,
        Visible = section.Open,
        ZIndex = 3,
    }, frame)
    addPadding(content, 8, 8, 6, 6)
    addList(content, 4, false)

    section.Frame = frame
    section.Header = header
    section.Content = content

    table.insert(menu._conns, header.MouseButton1Click:Connect(function()
        section.Open = not section.Open
        content.Visible = section.Open
        header.Text = (section.Open and "  v  " or "  >  ") .. tostring(title)
    end))
    table.insert(menu._conns, header.MouseEnter:Connect(function()
        header.BackgroundColor3 = theme.FrameHover
    end))
    table.insert(menu._conns, header.MouseLeave:Connect(function()
        header.BackgroundColor3 = theme.FrameBg
    end))

    return section
end

function TabMethods:Text(text, color)
    self._order = self._order + 1
    local label = make("TextLabel", {
        Name = "Text",
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 0, 0),
        AutomaticSize = Enum.AutomaticSize.Y,
        LayoutOrder = self._order,
        Font = Enum.Font.Code,
        Text = tostring(text or ""),
        TextSize = 12,
        TextColor3 = color or self.Menu.Theme.TextDim,
        TextXAlignment = Enum.TextXAlignment.Left,
        TextYAlignment = Enum.TextYAlignment.Top,
        TextWrapped = true,
        ZIndex = 4,
    }, self.Frame)
    return label
end

function TabMethods:Separator()
    self._order = self._order + 1
    local holder = make("Frame", {
        Name = "Separator",
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 9),
        LayoutOrder = self._order,
        ZIndex = 4,
    }, self.Frame)
    make("Frame", {
        BackgroundColor3 = self.Menu.Theme.Border,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 1),
        Position = UDim2.new(0, 0, 0.5, 0),
        ZIndex = 4,
    }, holder)
    return holder
end

function TabMethods:Button(label, callback, color)
    local theme = self.Menu.Theme
    self._order = self._order + 1
    local button = make("TextButton", {
        Name = "Button_" .. tostring(label),
        BackgroundColor3 = color or theme.FrameBg,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(1, 0, 0, 26),
        LayoutOrder = self._order,
        Font = Enum.Font.Code,
        Text = tostring(label),
        TextSize = 12,
        TextColor3 = theme.Text,
        ZIndex = 4,
    }, self.Frame)
    addStroke(button, theme.Border, 0.4)
    table.insert(self.Menu._conns, button.MouseButton1Click:Connect(function()
        if callback then
            local ok, err = pcall(callback)
            if not ok then
                self.Menu:Toast("Error: " .. tostring(err), 4)
            end
        end
    end))
    local normal = color or theme.FrameBg
    table.insert(self.Menu._conns, button.MouseEnter:Connect(function()
        button.BackgroundColor3 = theme.FrameHover
    end))
    table.insert(self.Menu._conns, button.MouseLeave:Connect(function()
        button.BackgroundColor3 = normal
    end))
    return button
end

function TabMethods:Progress(label, value)
    local theme = self.Menu.Theme
    self._order = self._order + 1
    local row = make("Frame", {
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 22),
        LayoutOrder = self._order,
        ZIndex = 4,
    }, self.Frame)
    textLabel(row, tostring(label), theme.Text, 20).Size = UDim2.new(1, -140, 1, 0)
    local track = make("Frame", {
        BackgroundColor3 = theme.FrameBg,
        BorderSizePixel = 0,
        Size = UDim2.new(0, 120, 0, 8),
        Position = UDim2.new(1, -120, 0.5, -4),
        ZIndex = 4,
    }, row)
    local fill = make("Frame", {
        BackgroundColor3 = theme.Accent,
        BorderSizePixel = 0,
        Size = UDim2.new(math.clamp(value or 0, 0, 1), 0, 1, 0),
        ZIndex = 5,
    }, track)
    return newHandle(function(v)
        fill.Size = UDim2.new(math.clamp(v or 0, 0, 1), 0, 1, 0)
    end, function()
        return fill.Size.X.Scale
    end)
end

-- ---------------------------------------------------------------------------
-- Sections
-- ---------------------------------------------------------------------------

function SectionMethods:_row(height)
    self._order = self._order + 1
    return make("Frame", {
        Name = "Row",
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, height),
        LayoutOrder = self._order,
        ZIndex = 4,
    }, self.Content)
end

function SectionMethods:Text(text, color)
    self._order = self._order + 1
    local label = make("TextLabel", {
        Name = "Text",
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 0, 0),
        AutomaticSize = Enum.AutomaticSize.Y,
        LayoutOrder = self._order,
        Font = Enum.Font.Code,
        Text = tostring(text or ""),
        TextSize = 12,
        TextColor3 = color or self.Menu.Theme.TextDim,
        TextXAlignment = Enum.TextXAlignment.Left,
        TextYAlignment = Enum.TextYAlignment.Top,
        TextWrapped = true,
        ZIndex = 4,
    }, self.Content)
    return label
end

function SectionMethods:Separator()
    self._order = self._order + 1
    local holder = make("Frame", {
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 7),
        LayoutOrder = self._order,
        ZIndex = 4,
    }, self.Content)
    make("Frame", {
        BackgroundColor3 = self.Menu.Theme.Border,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 1),
        Position = UDim2.new(0, 0, 0.5, 0),
        ZIndex = 4,
    }, holder)
    return holder
end

function SectionMethods:Checkbox(label, value, callback)
    local theme = self.Menu.Theme
    local row = self:_row(24)
    local state = { value = value and true or false }

    textLabel(row, tostring(label), theme.Text, 22).Size = UDim2.new(1, -30, 1, 0)
    local box = make("TextButton", {
        Name = "Check",
        BackgroundColor3 = state.value and theme.FrameActive or theme.FrameBg,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(0, 18, 0, 18),
        Position = UDim2.new(1, -18, 0.5, -9),
        Font = Enum.Font.Code,
        Text = state.value and "x" or "",
        TextSize = 13,
        TextColor3 = theme.Accent,
        ZIndex = 5,
    }, row)
    addStroke(box, theme.Border, 0.4)

    local function draw()
        box.BackgroundColor3 = state.value and theme.FrameActive or theme.FrameBg
        box.Text = state.value and "x" or ""
    end

    table.insert(self.Menu._conns, box.MouseButton1Click:Connect(function()
        state.value = not state.value
        draw()
        if callback then
            local ok, err = pcall(callback, state.value)
            if not ok then
                self.Menu:Toast("Error: " .. tostring(err), 4)
            end
        end
    end))
    table.insert(self.Menu._conns, box.MouseEnter:Connect(function()
        box.BackgroundColor3 = theme.FrameHover
    end))
    table.insert(self.Menu._conns, box.MouseLeave:Connect(draw))

    return newHandle(function(v)
        state.value = v and true or false
        draw()
    end, function()
        return state.value
    end)
end

function SectionMethods:Slider(label, minValue, maxValue, value, callback, step)
    local theme = self.Menu.Theme
    local row = self:_row(42)
    local state = { value = math.clamp(tonumber(value) or minValue, minValue, maxValue) }
    local valueLabel

    valueLabel = textLabel(row, "", theme.Text, 18)
    valueLabel.Size = UDim2.new(0, 64, 0, 18)
    valueLabel.Position = UDim2.new(1, -64, 0, 0)
    valueLabel.TextXAlignment = Enum.TextXAlignment.Right
    textLabel(row, tostring(label), theme.Text, 18).Size = UDim2.new(1, -70, 0, 18)

    local track = make("Frame", {
        Name = "Track",
        BackgroundColor3 = theme.FrameBg,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 0, 6),
        Position = UDim2.new(0, 0, 0, 29),
        Active = true,
        ZIndex = 5,
    }, row)
    local fill = make("Frame", {
        BackgroundColor3 = theme.Accent,
        BorderSizePixel = 0,
        Size = UDim2.new(0, 0, 1, 0),
        ZIndex = 6,
    }, track)
    local knob = make("Frame", {
        BackgroundColor3 = theme.Text,
        BorderSizePixel = 0,
        Size = UDim2.new(0, 8, 1, 0),
        Position = UDim2.new(0, -4, 0, 0),
        ZIndex = 7,
    }, track)

    local function format(v)
        if step and step >= 1 then
            return tostring(math.floor(v + 0.5))
        end
        return string.format("%.2f", v)
    end

    local function draw()
        local alpha = 0
        if maxValue > minValue then
            alpha = (state.value - minValue) / (maxValue - minValue)
        end
        alpha = math.clamp(alpha, 0, 1)
        fill.Size = UDim2.new(alpha, 0, 1, 0)
        knob.Position = UDim2.new(alpha, -4, 0, 0)
        valueLabel.Text = format(state.value)
    end

    local function setFromMouse(x)
        local absolute = track.AbsolutePosition.X
        local width = track.AbsoluteSize.X
        if width <= 0 then
            return
        end
        local alpha = math.clamp((x - absolute) / width, 0, 1)
        local nextValue = minValue + (maxValue - minValue) * alpha
        if step then
            nextValue = math.floor(nextValue / step + 0.5) * step
        end
        state.value = math.clamp(nextValue, minValue, maxValue)
        draw()
        if callback then
            local ok, err = pcall(callback, state.value)
            if not ok then
                self.Menu:Toast("Error: " .. tostring(err), 4)
            end
        end
    end

    draw()

    table.insert(self.Menu._conns, track.InputBegan:Connect(function(input)
        if input.UserInputType ~= Enum.UserInputType.MouseButton1
            and input.UserInputType ~= Enum.UserInputType.Touch then
            return
        end
        setFromMouse(input.Position.X)
        local moveConn, endConn
        moveConn = UIS.InputChanged:Connect(function(move)
            if move.UserInputType == Enum.UserInputType.MouseMovement
                or move.UserInputType == Enum.UserInputType.Touch then
                setFromMouse(move.Position.X)
            end
        end)
        endConn = UIS.InputEnded:Connect(function(event)
            if event.UserInputType == input.UserInputType then
                moveConn:Disconnect()
                endConn:Disconnect()
            end
        end)
        table.insert(self.Menu._conns, moveConn)
        table.insert(self.Menu._conns, endConn)
    end))

    return newHandle(function(v)
        state.value = math.clamp(tonumber(v) or minValue, minValue, maxValue)
        draw()
    end, function()
        return state.value
    end)
end

function SectionMethods:Combo(label, items, value, callback)
    local theme = self.Menu.Theme
    items = items or {}
    local row = self:_row(24)
    local index = 1
    for i, item in ipairs(items) do
        if item == value then
            index = i
            break
        end
    end

    textLabel(row, tostring(label), theme.Text, 22).Size = UDim2.new(1, -140, 1, 0)
    local button = make("TextButton", {
        Name = "Combo",
        BackgroundColor3 = theme.FrameBg,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(0, 130, 0, 20),
        Position = UDim2.new(1, -130, 0.5, -10),
        Font = Enum.Font.Code,
        Text = tostring(items[index] or "-") .. "  v",
        TextSize = 12,
        TextColor3 = theme.Text,
        ZIndex = 5,
    }, row)
    addStroke(button, theme.Border, 0.4)

    local function draw()
        button.Text = tostring(items[index] or "-") .. "  v"
    end

    table.insert(self.Menu._conns, button.MouseButton1Click:Connect(function()
        if #items == 0 then
            return
        end
        index = index % #items + 1
        draw()
        if callback then
            local ok, err = pcall(callback, items[index])
            if not ok then
                self.Menu:Toast("Error: " .. tostring(err), 4)
            end
        end
    end))
    table.insert(self.Menu._conns, button.MouseEnter:Connect(function()
        button.BackgroundColor3 = theme.FrameHover
    end))
    table.insert(self.Menu._conns, button.MouseLeave:Connect(function()
        button.BackgroundColor3 = theme.FrameBg
    end))

    return newHandle(function(v)
        for i, item in ipairs(items) do
            if item == v then
                index = i
                draw()
                return
            end
        end
    end, function()
        return items[index]
    end)
end

function SectionMethods:Input(label, value, callback)
    local theme = self.Menu.Theme
    local row = self:_row(24)
    textLabel(row, tostring(label), theme.Text, 22).Size = UDim2.new(1, -160, 1, 0)
    local box = make("TextBox", {
        Name = "Input",
        BackgroundColor3 = theme.FrameBg,
        BorderSizePixel = 0,
        Size = UDim2.new(0, 150, 0, 20),
        Position = UDim2.new(1, -150, 0.5, -10),
        Font = Enum.Font.Code,
        Text = tostring(value or ""),
        PlaceholderText = "...",
        PlaceholderColor3 = theme.TextDim,
        TextSize = 12,
        TextColor3 = theme.Text,
        TextXAlignment = Enum.TextXAlignment.Left,
        ClearTextOnFocus = false,
        ZIndex = 5,
    }, row)
    addPadding(box, 4, 4, 0, 0)
    addStroke(box, theme.Border, 0.4)

    local function commit()
        if callback then
            local ok, err = pcall(callback, box.Text)
            if not ok then
                self.Menu:Toast("Error: " .. tostring(err), 4)
            end
        end
    end
    table.insert(self.Menu._conns, box.FocusLost:Connect(commit))
    return newHandle(function(v)
        box.Text = tostring(v or "")
    end, function()
        return box.Text
    end)
end

function SectionMethods:Keybind(label, key, callback)
    local theme = self.Menu.Theme
    local row = self:_row(24)
    local state = { key = key, listening = false }
    textLabel(row, tostring(label), theme.Text, 22).Size = UDim2.new(1, -120, 1, 0)

    local button = make("TextButton", {
        Name = "Keybind",
        BackgroundColor3 = theme.FrameBg,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(0, 110, 0, 20),
        Position = UDim2.new(1, -110, 0.5, -10),
        Font = Enum.Font.Code,
        Text = state.key and state.key.Name or "None",
        TextSize = 12,
        TextColor3 = theme.Text,
        ZIndex = 5,
    }, row)
    addStroke(button, theme.Border, 0.4)

    table.insert(self.Menu._conns, button.MouseButton1Click:Connect(function()
        state.listening = true
        self.Menu._capturingKey = true
        button.Text = "press key..."
        local token = {}
        state.token = token
        self.Menu._captureToken = token
        task.delay(6, function()
            if self.Menu._destroyed then
                return
            end
            if state.token == token and self.Menu._captureToken == token then
                state.listening = false
                state.token = nil
                self.Menu._captureToken = nil
                self.Menu._capturingKey = false
                button.Text = state.key and state.key.Name or "None"
            end
        end)
    end))

    table.insert(self.Menu._conns, UIS.InputBegan:Connect(function(input)
        if not state.listening then
            return
        end
        if self.Menu._captureToken ~= state.token then
            state.listening = false
            state.token = nil
            button.Text = state.key and state.key.Name or "None"
            return
        end
        if input.KeyCode == Enum.KeyCode.Unknown then
            return
        end
        state.listening = false
        state.token = nil
        self.Menu._captureToken = nil
        self.Menu._capturingKey = false
        state.key = input.KeyCode
        button.Text = input.KeyCode.Name
        if callback then
            local ok, err = pcall(callback, input.KeyCode)
            if not ok then
                self.Menu:Toast("Error: " .. tostring(err), 4)
            end
        end
    end))

    table.insert(self.Menu._conns, button.MouseEnter:Connect(function()
        button.BackgroundColor3 = theme.FrameHover
    end))
    table.insert(self.Menu._conns, button.MouseLeave:Connect(function()
        button.BackgroundColor3 = theme.FrameBg
    end))

    return newHandle(function(v)
        state.key = v
        button.Text = v and tostring(v.Name) or "None"
    end, function()
        return state.key
    end)
end

function SectionMethods:Button(label, callback, color)
    local theme = self.Menu.Theme
    local row = self:_row(28)
    local button = make("TextButton", {
        Name = "Button_" .. tostring(label),
        BackgroundColor3 = color or theme.FrameBg,
        AutoButtonColor = false,
        Selectable = false,
        Size = UDim2.new(1, 0, 0, 26),
        Position = UDim2.new(0, 0, 0, 1),
        Font = Enum.Font.Code,
        Text = tostring(label),
        TextSize = 12,
        TextColor3 = theme.Text,
        ZIndex = 5,
    }, row)
    addStroke(button, theme.Border, 0.4)
    local normal = color or theme.FrameBg
    table.insert(self.Menu._conns, button.MouseButton1Click:Connect(function()
        if callback then
            local ok, err = pcall(callback)
            if not ok then
                self.Menu:Toast("Error: " .. tostring(err), 4)
            end
        end
    end))
    table.insert(self.Menu._conns, button.MouseEnter:Connect(function()
        button.BackgroundColor3 = theme.FrameHover
    end))
    table.insert(self.Menu._conns, button.MouseLeave:Connect(function()
        button.BackgroundColor3 = normal
    end))
    return button
end

-- ============================================================================
-- Feature framework
-- ============================================================================

local Features = {}
local FeatureById = {}
local Menu
local unload

local function makeContext(feature)
    local ctx = {
        Feature = feature,
        Bag = Bag.new(),
        Restore = Restore.new(),
        Threads = {},
        Active = true,
    }

    function ctx:Spawn(fn, name)
        local thread = task.spawn(function()
            local ok, err = pcall(fn)
            if not ok then
                Log:Add("error", tostring(name or feature.Id) .. ": " .. tostring(err))
                if Menu then
                    Menu:Toast("Error in " .. tostring(feature.Name or feature.Id), 4)
                end
            end
        end)
        table.insert(self.Threads, thread)
        return thread
    end

    function ctx:Loop(interval, fn)
        local thread = task.spawn(function()
            while self.Active and not State.Unloading do
                local ok, err = pcall(fn)
                if not ok then
                    Log:Add("error", tostring(feature.Id) .. " loop: " .. tostring(err))
                    break
                end
                task.wait(interval or 0.1)
            end
        end)
        table.insert(self.Threads, thread)
        return thread
    end

    function ctx:Connect(signal, callback)
        return self.Bag:Connect(signal, callback)
    end

    function ctx:Cancel()
        self.Active = false
        local current = coroutine.running()
        for _, thread in ipairs(self.Threads) do
            if thread ~= current then
                pcall(task.cancel, thread)
            end
        end
        self.Threads = {}
    end

    function ctx:Cleanup()
        self:Cancel()
        self.Bag:Clear()
        self.Restore:All()
    end

    return ctx
end

local function Feature(definition)
    local feature = definition
    feature.Enabled = false
    feature.Ctx = makeContext(feature)
    table.insert(Features, feature)
    FeatureById[feature.Id] = feature
    return feature
end

local function setFeature(feature, enabled)
    if not feature or feature.Enabled == enabled then
        return
    end
    if enabled and State.Unloading then
        return
    end
    feature.Enabled = enabled and true or false
    if feature.Checkbox then
        feature.Checkbox:Set(feature.Enabled)
    end
    if enabled then
        feature.Ctx.Active = true
        if feature.OnEnable then
            local ok, err = pcall(feature.OnEnable, feature, feature.Ctx)
            if not ok then
                feature.Enabled = false
                if feature.Checkbox then
                    feature.Checkbox:Set(false)
                end
                feature.Ctx:Cleanup()
                Log:Add("error", tostring(feature.Id) .. ": " .. tostring(err))
                if Menu then
                    Menu:Toast("Failed: " .. tostring(feature.Name or feature.Id), 4)
                end
                return
            end
        end
    else
        if feature.OnDisable then
            pcall(feature.OnDisable, feature, feature.Ctx)
        end
        feature.Ctx:Cleanup()
    end
end

-- ============================================================================
-- Game modules (worm odyssey)
--
-- Everything the game does happens in these client modules; the executor script
-- reuses them instead of re-implementing the game. `import` is just require with
-- a local name: the script still ships as one self-contained file and loads no
-- external code.
-- ============================================================================

local import = require

local G = {
    Root = nil,
    Behavior = nil,
    Collision = nil,
    Snake = nil,
    Constants = nil,
    Remotes = nil,
    Instance = nil,
}

local function waitChild(parent, name, timeout)
    if not parent then
        return nil
    end
    local existing = parent:FindFirstChild(name)
    if existing then
        return existing
    end
    local deadline = os.clock() + (timeout or 5)
    repeat
        local child = parent:FindFirstChild(name)
        if child then
            return child
        end
        task.wait(0.1)
    until os.clock() > deadline
    return nil
end

local function safeImport(module)
    if not module then
        return nil
    end
    local ok, value = pcall(import, module)
    if ok and type(value) == "table" then
        return value
    end
    return nil
end

-- Importing a client module too early can throw: they execute with
-- ReplicatedStorage.Assets already present, and the script can reach the
-- ModuleScripts before the game's own LocalScript imported them. So the
-- instances are kept and the import is retried instead of cached as nil.
local Modules = {}
local Imported = {}

local function moduleTable(name)
    local cached = Imported[name]
    if cached then
        return cached
    end
    local module = Modules[name]
    if not module or not ReplicatedStorage:FindFirstChild("Assets") then
        return nil
    end
    local ok, value = pcall(import, module)
    if ok and type(value) == "table" then
        Imported[name] = value
        return value
    end
    return nil
end

do
    local shared = waitChild(ReplicatedStorage, "Shared", 5)
    G.Constants = safeImport(waitChild(shared, "Constants", 5))
    G.Remotes = waitChild(ReplicatedStorage, "Remotes", 5)

    local deadline = os.clock() + 10
    repeat
        local playerScripts = LocalPlayer:FindFirstChild("PlayerScripts")
        if playerScripts then
            local candidates = { playerScripts:FindFirstChild("Client"), playerScripts }
            for _, child in ipairs(playerScripts:GetChildren()) do
                table.insert(candidates, child)
            end
            for _, candidate in ipairs(candidates) do
                if candidate and candidate:FindFirstChild("Behavior") and candidate:FindFirstChild("Snake") then
                    G.Root = candidate
                    break
                end
            end
            if G.Root then
                break
            end
        end
        task.wait(0.2)
    until os.clock() > deadline

    if G.Root then
        Modules.Behavior = G.Root:FindFirstChild("Behavior")
        Modules.Collision = G.Root:FindFirstChild("Collision")
        Modules.Snake = G.Root:FindFirstChild("Snake")
        Modules.Food = G.Root:FindFirstChild("Food")
        G.Behavior = moduleTable("Behavior")
        G.Collision = moduleTable("Collision")
        G.Snake = moduleTable("Snake")
    end
end

local function refreshModules()
    if not G.Constants then
        local shared = ReplicatedStorage:FindFirstChild("Shared")
        G.Constants = safeImport(shared and shared:FindFirstChild("Constants"))
    end
    G.Behavior = G.Behavior or moduleTable("Behavior")
    G.Collision = G.Collision or moduleTable("Collision")
    G.Snake = G.Snake or moduleTable("Snake")
end

local function remote(name)
    if not G.Remotes then
        return nil
    end
    return G.Remotes:FindFirstChild(name)
end

-- Behaviour is a singleton held in a module-local, so capture the live instance
-- the first frame the game calls its own tick. Purely passive: the original
-- method still runs.
local Patches = {}

local function restorePatches()
    for index = #Patches, 1, -1 do
        pcall(Patches[index])
        Patches[index] = nil
    end
end

local BehaviorWrapped = false

local function captureBehavior()
    if G.Instance then
        return true
    end
    local class = G.Behavior or moduleTable("Behavior")
    if not class or type(class.tickRoutine) ~= "function" then
        return false
    end
    G.Behavior = class
    if not BehaviorWrapped then
        local original = class.tickRoutine
        BehaviorWrapped = true
        class.tickRoutine = function(self, deltaTime)
            G.Instance = self
            return original(self, deltaTime)
        end
        table.insert(Patches, function()
            if class.tickRoutine ~= original then
                class.tickRoutine = original
            end
            BehaviorWrapped = false
        end)
    end
    return G.Instance ~= nil
end

local function behavior()
    return G.Instance
end

-- The live objects carry the real class table in their metatable (Snake/Food/
-- Behavior instances are plain tables setmetatable'd to their module table), so
-- a patch can target the exact table the game is using without going through
-- require again.
local function classOf(object)
    if type(object) ~= "table" then
        return nil
    end
    local ok, meta = pcall(getmetatable, object)
    if ok and type(meta) == "table" then
        return meta
    end
    return nil
end

local function behaviorClass()
    local class = classOf(G.Instance)
    if class and type(class.getMouseWorldPosition) == "function" then
        return class
    end
    return G.Behavior
end

local function snakeClass()
    local class = G.Instance and classOf(G.Instance.snake)
    if class and type(class.driveHeadVelocity) == "function" then
        return class
    end
    return nil
end

local function foodClass()
    local instance = G.Instance
    local food = instance and instance.client and instance.client.food
    local class = classOf(food)
    if class and type(class.findNearby) == "function" then
        return class
    end
    return nil
end

local function sprintMultiplier()
    local constants = G.Constants
    return (constants and constants.SPRINT_SPEED_MULTIPLIER) or 1.75
end

-- Patch features register an installer for tables that may not exist yet (module
-- import race, or no snake until spawn). The pump retries instead of failing the
-- checkbox, and drops each installer once its patch is in place.
local Installers = {}

local function addInstaller(try)
    local entry = { Try = try }
    table.insert(Installers, entry)
    return entry
end

local function removeInstaller(entry)
    if not entry then
        return
    end
    for index = #Installers, 1, -1 do
        if Installers[index] == entry then
            table.remove(Installers, index)
        end
    end
end

local function runInstallers()
    for index = #Installers, 1, -1 do
        local entry = Installers[index]
        local ok, done = pcall(entry.Try)
        if not ok then
            if not entry.Warned then
                entry.Warned = true
                Log:Add("warn", "installer retry: " .. tostring(done))
            end
        elseif done then
            table.remove(Installers, index)
        end
    end
end

task.spawn(function()
    while not State.Unloading do
        pcall(captureBehavior)
        pcall(refreshModules)
        runInstallers()
        task.wait(G.Instance and #Installers == 0 and 2 or 0.5)
    end
end)

local function headPartOf(folder)
    for _, child in ipairs(folder:GetChildren()) do
        if child:IsA("BasePart") and child:FindFirstChild("Eye0") then
            return child
        end
    end
    return nil
end

local function pickTarget(feature, behaviorInstance)
    local snake = behaviorInstance.snake
    if not snake then
        return nil
    end
    local head = snake:getHeadPosition()
    local now = os.clock()
    local cache = feature.Cache
    if cache and now - cache.Time < 0.08 then
        return cache.Position
    end

    local bestPosition, bestDistance = nil, math.huge
    if feature.Mode == "Nearest player" then
        local client = behaviorInstance.client
        local remotes = client and client.players and client.players.remotePlayers
        for _, other in pairs(remotes or {}) do
            local ok, position = pcall(function()
                return other:getHeadPosition()
            end)
            if ok and typeof(position) == "Vector3" then
                local distance = (position - head).Magnitude
                if distance < bestDistance then
                    bestPosition, bestDistance = position, distance
                end
            end
        end
    else
        local largeOnly = feature.Mode == "Large orb"
        local client = behaviorInstance.client
        local droplets = client and client.food and client.food.droplets
        for _, droplet in pairs(droplets or {}) do
            if typeof(droplet.position) == "Vector3" and (not largeOnly or droplet.isLarge) then
                local distance = (droplet.position - head).Magnitude
                if distance < bestDistance then
                    bestPosition, bestDistance = droplet.position, distance
                end
            end
        end
    end

    feature.Cache = { Time = now, Position = bestPosition }
    return bestPosition
end

-- ============================================================================
-- Features
-- ============================================================================

Feature({
    Id = "Invincible",
    Name = "Invincible + walk through snakes",
    Tab = "Gameplay",
    Section = "Survival",
    Risk = "T1",
    Default = true,
    Build = function(feature, section)
        section:Text(
            "Sets Behavior.invincible = true, the game's own flag (Behavior.luau:364) that the built-in "
                .. "Debug menu exposes (Debug.luau:397). checkCollision then skips the \"local\" entry, "
                .. "so your snake never asks the server to kill it. Kills you report on other snakes "
                .. "still go out, and out-of-bounds death is skipped too.",
            Color3.fromRGB(120, 120, 120)
        )
        section:Text(
            "Two more layers for safety: requestDeath on the live behavior object is neutered, and the "
                .. "\"local\" key is stripped from Collision.resolve when that module is reachable. "
                .. "Applied as soon as the game hands over a frame, so it survives load-order races.",
            Color3.fromRGB(120, 120, 120)
        )
        section:Text(
            "Another client can still fire SnakeRemoved about you (Client/Behavior.luau:384). "
                .. "Whether the server honours that report is not visible in a client-only dump.",
            Color3.fromRGB(180, 150, 0)
        )
    end,
    OnEnable = function(feature, ctx)
        feature.Flagged = false
        feature.DeathGuarded = false
        local function try()
            local instance = G.Instance
            if instance then
                if not feature.Flagged then
                    feature.Flagged = true
                    ctx.Restore:Set(instance, "invincible", true)
                end
                if not feature.DeathGuarded then
                    feature.DeathGuarded = true
                    feature.DeathOriginal = instance.requestDeath
                    instance.requestDeath = function() end
                end
            end
            local collision = G.Collision
            if collision and type(collision.resolve) == "function" and not feature.ResolveOriginal then
                feature.ResolveOriginal = collision.resolve
                collision.resolve = function(localSnake, remotePlayers)
                    local result = feature.ResolveOriginal(localSnake, remotePlayers)
                    if type(result) == "table" then
                        result["local"] = nil
                    end
                    return result
                end
            end
            return instance ~= nil and feature.Flagged
        end
        feature.Installer = addInstaller(try)
        try()
    end,
    OnDisable = function(feature, ctx)
        removeInstaller(feature.Installer)
        feature.Installer = nil
        local instance = G.Instance
        if instance and feature.DeathGuarded then
            instance.requestDeath = feature.DeathOriginal
        end
        feature.DeathGuarded = false
        feature.DeathOriginal = nil
        feature.Flagged = false
        if G.Collision and feature.ResolveOriginal then
            G.Collision.resolve = feature.ResolveOriginal
        end
        feature.ResolveOriginal = nil
    end,
})

Feature({
    Id = "MoveSpeed",
    Name = "Move speed",
    Tab = "Gameplay",
    Section = "Movement",
    Risk = "T1",
    Default = false,
    Build = function(feature, section)
        feature.Value = 22
        section:Slider("Speed (game default 15)", 15, 60, 22, function(value)
            feature.Value = value
        end, 1)
        section:Text(
            "Your head is a server-owned part driven by a LinearVelocity constraint, so the game moves "
                .. "you through Snake.driveHeadVelocity (Snake.luau:432), never through Snake.moveHead. "
                .. "Both are replaced with the same math at your speed; sprint still multiplies by 1.75.",
            Color3.fromRGB(180, 150, 0)
        )
        section:Text(
            "The patch is applied to the class table read from your live snake's metatable, so it lands "
                .. "the moment you have a snake and does not depend on the module import.",
            Color3.fromRGB(120, 120, 120)
        )
    end,
    OnEnable = function(feature, ctx)
        local function try()
            local class = snakeClass()
            if not class then
                return false
            end
            if type(class.driveHeadVelocity) == "function" and not feature.DriveClass then
                local original = class.driveHeadVelocity
                feature.DriveClass = class
                feature.DriveOriginal = original
                class.driveHeadVelocity = function(self, deltaTime, targetFacingAngle)
                    if self.lastTargetFacingAngle then
                        local turn = (targetFacingAngle - self.lastTargetFacingAngle + math.pi) % (2 * math.pi) - math.pi
                        self.angularVelocity.AngularVelocity = Vector3.new(0, turn / deltaTime, 0)
                    end
                    self.lastTargetFacingAngle = targetFacingAngle
                    local head = self.segments and self.segments[1]
                    local heightLift = self.heightLift
                    if not (head and heightLift and self.linearVelocity) then
                        return original(self, deltaTime, targetFacingAngle)
                    end
                    local speed = (feature.Value or 22) * (self.sprinting and sprintMultiplier() or 1)
                    self.linearVelocity.VectorVelocity = Vector3.new(
                        0,
                        -(head.instance.CFrame.Position.Y - heightLift.Y),
                        speed
                    )
                end
            end
            if type(class.moveHead) == "function" and not feature.MoveClass then
                local original = class.moveHead
                feature.MoveClass = class
                feature.MoveOriginal = original
                class.moveHead = function(self, deltaTime)
                    local head = self.segments and self.segments[1]
                    if not head then
                        return original(self, deltaTime)
                    end
                    local speed = (feature.Value or 22) * (self.sprinting and sprintMultiplier() or 1)
                    local position = head.cframe.Position
                    local direction = Vector3.new(math.cos(self.facingAngle), 0, -math.sin(self.facingAngle))
                    local nextPosition = position + direction * (speed * deltaTime)
                    head.cframe = CFrame.new(nextPosition, nextPosition - direction)
                end
            end
            return feature.DriveClass ~= nil or feature.MoveClass ~= nil
        end
        feature.Installer = addInstaller(try)
        try()
    end,
    OnDisable = function(feature, ctx)
        removeInstaller(feature.Installer)
        feature.Installer = nil
        if feature.DriveClass and feature.DriveOriginal then
            feature.DriveClass.driveHeadVelocity = feature.DriveOriginal
        end
        if feature.MoveClass and feature.MoveOriginal then
            feature.MoveClass.moveHead = feature.MoveOriginal
        end
        feature.DriveClass = nil
        feature.DriveOriginal = nil
        feature.MoveClass = nil
        feature.MoveOriginal = nil
    end,
})

Feature({
    Id = "FreeSprint",
    Name = "Sprint costs no points",
    Tab = "Gameplay",
    Section = "Movement",
    Risk = "T1",
    Default = false,
    Build = function(feature, section)
        section:Text(
            "Constants.SPRINT_DRAIN_POINTS = 0 (Shared/Constants.luau:15). Sprint (LeftShift, LMB, ButtonA) no longer eats points; "
                .. "the dropped-food trail still fires on the game's own path.",
            Color3.fromRGB(120, 120, 120)
        )
    end,
    OnEnable = function(feature, ctx)
        assert(G.Constants, "Constants not found")
        ctx.Restore:Set(G.Constants, "SPRINT_DRAIN_POINTS", 0)
    end,
    OnDisable = function(feature, ctx)
        ctx.Restore:All()
    end,
})

Feature({
    Id = "AutoRespawn",
    Name = "Auto respawn",
    Tab = "Gameplay",
    Section = "Survival",
    Risk = "T2",
    Default = false,
    Build = function(feature, section)
        section:Text(
            "When you have no snake, calls RequestSpawn exactly like the main menu does "
                .. "(Client/Menu.luau:182) and rebuilds the local snake. 4s minimum between tries.",
            Color3.fromRGB(180, 150, 0)
        )
    end,
    OnEnable = function(feature, ctx)
        local lastAttempt = 0
        ctx:Loop(1, function()
            local instance = behavior()
            if not instance or instance.snake then
                return
            end
            if instance.awaitingDeathConfirmation then
                return
            end
            local spawnRemote = remote("RequestSpawn")
            if not spawnRemote then
                return
            end
            local now = os.clock()
            if now - lastAttempt < 4 then
                return
            end
            lastAttempt = now
            local color = G.Constants and G.Constants.randomColor and G.Constants.randomColor() or Color3.new(0.4, 0.8, 0.4)
            local ok, position, facingAngle, skinId, headInstance, spawnTime = pcall(function()
                return spawnRemote:InvokeServer(color)
            end)
            if ok and position and not instance.snake then
                instance:spawn(position, color, facingAngle, skinId, headInstance, spawnTime)
                pcall(function()
                    instance.client.menu:disable()
                end)
            end
        end)
    end,
    OnDisable = function(feature, ctx)
        ctx:Cancel()
    end,
})

Feature({
    Id = "SharpTurns",
    Name = "Sharp turns",
    Tab = "Gameplay",
    Section = "Movement",
    Risk = "T1",
    Default = false,
    Build = function(feature, section)
        section:Text(
            "Turns are normally rate-limited by Constants.turnRate (TURN_RATE / snake width) inside the "
                .. "steering step, which is why the snake circles before turning. This wraps tickRoutine so "
                .. "the heading snaps instantly toward the mouse each tick and syncs lastTargetFacingAngle.",
            Color3.fromRGB(180, 150, 0)
        )
    end,
    OnEnable = function(feature, ctx)
        local function try()
            local class = behaviorClass()
            if not class or type(class.tickRoutine) ~= "function" then
                return false
            end
            if feature.SharpPatched then
                return true
            end
            feature.SharpPatched = true
            local original = class.tickRoutine
            feature.SharpClass = class
            feature.SharpOriginal = original
            class.tickRoutine = function(self, deltaTime)
                local snake = self.snake
                if not (self.movementPaused or self.awaitingDeathConfirmation) and snake then
                    local mouseWorld = self:getMouseWorldPosition()
                    if mouseWorld then
                        local head = snake:getHeadPosition()
                        local toMouse = mouseWorld - head
                        local target = math.atan2(-toMouse.Z, toMouse.X)
                        self.facingAngle = target
                        if snake.lastTargetFacingAngle ~= nil then
                            snake.lastTargetFacingAngle = target
                        end
                    end
                end
                return original(self, deltaTime)
            end
            return true
        end
        feature.Installer = addInstaller(try)
        try()
    end,
    OnDisable = function(feature, ctx)
        removeInstaller(feature.Installer)
        feature.Installer = nil
        local class = feature.SharpClass
        if class and feature.SharpOriginal then
            class.tickRoutine = feature.SharpOriginal
        end
        feature.SharpClass = nil
        feature.SharpOriginal = nil
        feature.SharpPatched = false
    end,
})

Feature({
    Id = "OrbMagnet",
    Name = "Orb magnet (bigger pickup)",
    Tab = "Orbs",
    Section = "Pickup radius",
    Risk = "T2",
    Default = false,
    Build = function(feature, section)
        feature.Radius = 8
        feature.Lead = 6
        feature.Cap = 6
        section:Slider("Pickup radius (default 3)", 3, 200, 8, function(value)
            feature.Radius = value
            if feature.Enabled and G.Constants then
                G.Constants.COLLECT_RADIUS = value
            end
        end, 1)
        section:Slider("Pickup lead (default 2)", 2, 100, 6, function(value)
            feature.Lead = value
            if feature.Enabled and G.Constants then
                G.Constants.COLLECT_LEAD = value
            end
        end, 1)
        section:Slider("Orbs per tick (freeze guard)", 1, 30, 6, function(value)
            feature.Cap = value
            if feature.FoodClass and feature.FoodOriginal then
                feature.FoodClass.findNearby = feature.WrapFindNearby
            end
        end, 1)
        section:Text(
            "Constants.COLLECT_RADIUS / COLLECT_LEAD drive Client/Behavior.checkFoodCollection "
                .. "(Behavior.luau:436), then RequestCollect:FireServer(droplets, points) at line 453. "
                .. "200 studs is the whole play radius, so the top of the slider finds every orb on the "
                .. "map at once.",
            Color3.fromRGB(180, 150, 0)
        )
        section:Text(
            "Freeze guard: eating hundreds of orbs in one frame used to clone thousands of body "
                .. "segments and sort medals in a single tick. Food.findNearby is capped at \"orbs per "
                .. "tick\", so a huge radius still vacuums the map, just over a few seconds instead of "
                .. "one frame. Set it low for smooth play.",
            Color3.fromRGB(180, 150, 0)
        )
    end,
    OnEnable = function(feature, ctx)
        local function try()
            local constants = G.Constants
            if constants and not feature.ConstantsPatched then
                feature.ConstantsPatched = true
                ctx.Restore:Set(constants, "COLLECT_RADIUS", feature.Radius or 8)
                ctx.Restore:Set(constants, "COLLECT_LEAD", feature.Lead or 6)
            end
            local class = foodClass()
            if class and not feature.FoodClass then
                feature.FoodClass = class
                feature.FoodOriginal = class.findNearby
                feature.WrapFindNearby = function(self, position, radius)
                    local list = feature.FoodOriginal(self, position, radius)
                    local cap = feature.Cap or 6
                    for index = #list, cap + 1, -1 do
                        list[index] = nil
                    end
                    return list
                end
                class.findNearby = feature.WrapFindNearby
            end
            return constants ~= nil and feature.FoodClass ~= nil
        end
        feature.Installer = addInstaller(try)
        try()
    end,
    OnDisable = function(feature, ctx)
        removeInstaller(feature.Installer)
        feature.Installer = nil
        if feature.FoodClass and feature.FoodOriginal then
            feature.FoodClass.findNearby = feature.FoodOriginal
        end
        feature.FoodClass = nil
        feature.FoodOriginal = nil
        feature.WrapFindNearby = nil
        feature.ConstantsPatched = false
    end,
})

Feature({
    Id = "AutoSteer",
    Name = "Auto steer",
    Tab = "Orbs",
    Section = "Autopilot",
    Risk = "T2",
    Default = false,
    Build = function(feature, section)
        feature.Mode = "Nearest orb"
        feature.Cache = nil
        section:Combo("Target", { "Nearest orb", "Large orb", "Nearest player" }, "Nearest orb", function(value)
            feature.Mode = value
            feature.Cache = nil
        end)
        section:Text(
            "Replaces Behavior.getMouseWorldPosition (Behavior.luau:234) with the nearest target, so the "
                .. "game's own steering walks you there. \"Nearest player\" plus Invincible is the ram combo.",
            Color3.fromRGB(180, 150, 0)
        )
    end,
    OnEnable = function(feature, ctx)
        local behaviorModule = behaviorClass()
        assert(behaviorModule and type(behaviorModule.getMouseWorldPosition) == "function", "Behavior.getMouseWorldPosition not found")
        local original = behaviorModule.getMouseWorldPosition
        feature.Original = original
        feature.Class = behaviorModule
        behaviorModule.getMouseWorldPosition = function(self)
            local ok, target = pcall(pickTarget, feature, self)
            if ok and target then
                return target
            end
            return original(self)
        end
    end,
    OnDisable = function(feature, ctx)
        if feature.Class and feature.Original then
            feature.Class.getMouseWorldPosition = feature.Original
        end
        feature.Class = nil
        feature.Original = nil
        feature.Cache = nil
    end,
})

Feature({
    Id = "SnakeESP",
    Name = "Snake outlines (ESP)",
    Tab = "Visuals",
    Section = "Overlay",
    Risk = "T0",
    Default = false,
    Build = function(feature, section)
        section:Text(
            "Red Highlight, always on top, on every other head in workspace.Snakes. Local only: "
                .. "nobody else sees it and no server state changes.",
            Color3.fromRGB(120, 120, 120)
        )
    end,
    OnEnable = function(feature, ctx)
        feature.Highlights = {}
        ctx:Loop(0.5, function()
            local folder = workspace:FindFirstChild("Snakes")
            if not folder then
                return
            end
            local myId = tostring(LocalPlayer.UserId)
            for _, snakeFolder in ipairs(folder:GetChildren()) do
                if snakeFolder.Name ~= myId then
                    local head = headPartOf(snakeFolder)
                    if head then
                        local highlight = feature.Highlights[head]
                        if not highlight or not highlight.Parent then
                            highlight = Instance.new("Highlight")
                            highlight.Name = "Hl"
                            highlight.Adornee = head
                            highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                            highlight.FillTransparency = 1
                            highlight.OutlineTransparency = 0
                            highlight.OutlineColor = Color3.fromRGB(255, 70, 70)
                            highlight.Parent = head
                            feature.Highlights[head] = highlight
                        end
                    end
                end
            end
            for part, highlight in pairs(feature.Highlights) do
                if not part.Parent or not highlight.Parent then
                    feature.Highlights[part] = nil
                    pcall(function()
                        highlight:Destroy()
                    end)
                end
            end
        end)
    end,
    OnDisable = function(feature, ctx)
        for part, highlight in pairs(feature.Highlights or {}) do
            pcall(function()
                highlight:Destroy()
            end)
            feature.Highlights[part] = nil
        end
        feature.Highlights = {}
    end,
})

Feature({
    Id = "Fullbright",
    Name = "Fullbright / no fog",
    Tab = "Visuals",
    Section = "Lighting",
    Risk = "T0",
    Default = false,
    Build = function(feature, section)
        section:Text("Lighting only; the map is flat, this just removes fog and dark ambient.", Color3.fromRGB(120, 120, 120))
    end,
    OnEnable = function(feature, ctx)
        ctx.Restore:Set(Lighting, "Brightness", 3)
        ctx.Restore:Set(Lighting, "Ambient", Color3.fromRGB(170, 170, 170))
        ctx.Restore:Set(Lighting, "OutdoorAmbient", Color3.fromRGB(170, 170, 170))
        ctx.Restore:Set(Lighting, "GlobalShadows", false)
        ctx.Restore:Set(Lighting, "FogEnd", 1000000)
    end,
    OnDisable = function(feature, ctx)
        ctx.Restore:All()
    end,
})

Feature({
    Id = "Zoom",
    Name = "Zoom out (FOV)",
    Tab = "Visuals",
    Section = "Camera",
    Risk = "T0",
    Default = false,
    Build = function(feature, section)
        feature.Value = 95
        section:Slider("Field of view (default 70)", 70, 120, 95, function(value)
            feature.Value = value
            local camera = workspace.CurrentCamera
            if feature.Enabled and camera then
                camera.FieldOfView = value
            end
        end, 1)
        section:Text(
            "The game drives the camera CFrame every frame but never touches FieldOfView, so this is stable. "
                .. "Wider view = more orbs on screen.",
            Color3.fromRGB(120, 120, 120)
        )
    end,
    OnEnable = function(feature, ctx)
        local camera = workspace.CurrentCamera
        assert(camera, "no camera")
        ctx.Restore:Set(camera, "FieldOfView", feature.Value or 95)
    end,
    OnDisable = function(feature, ctx)
        ctx.Restore:All()
    end,
})

Feature({
    Id = "Radar",
    Name = "Player radar",
    Tab = "Visuals",
    Section = "Overlay",
    Risk = "T0",
    Default = false,
    Build = function(feature, section)
        feature.Label = section:Text("waiting for a snake...", Color3.fromRGB(80, 80, 80))
        section:Text("Nearest six snakes with distance and points. Read from the client's own snake table.", Color3.fromRGB(120, 120, 120))
    end,
    OnEnable = function(feature, ctx)
        ctx:Loop(0.5, function()
            local instance = behavior()
            local label = feature.Label
            if not (instance and label) then
                return
            end
            local snake = instance.snake
            if not snake then
                label.Text = "spectating (no snake)"
                return
            end
            local head = snake:getHeadPosition()
            local rows = {}
            local client = instance.client
            local remotes = client and client.players and client.players.remotePlayers
            for id, other in pairs(remotes or {}) do
                local ok, position = pcall(function()
                    return other:getHeadPosition()
                end)
                if ok and typeof(position) == "Vector3" then
                    table.insert(rows, {
                        name = string.sub(tostring(other.username or id), 1, 14),
                        distance = (position - head).Magnitude,
                        points = other.points or 0,
                    })
                end
            end
            table.sort(rows, function(a, b)
                return a.distance < b.distance
            end)
            local lines = {}
            for index = 1, math.min(#rows, 6) do
                local row = rows[index]
                lines[index] = string.format("%-14s %4.0f studs  %d pts", row.name, row.distance, row.points)
            end
            label.Text = #lines > 0 and table.concat(lines, "\n") or "no other snakes"
        end)
    end,
    OnDisable = function(feature, ctx)
        ctx:Cancel()
        if feature.Label then
            feature.Label.Text = "off"
        end
    end,
})

Feature({
    Id = "Hud",
    Name = "Stats HUD",
    Tab = "Visuals",
    Section = "Overlay",
    Risk = "T0",
    Default = true,
    Build = function(feature, section)
        section:Text("Small always-on readout: points, rank, segments, kills, coins, magnet state.", Color3.fromRGB(120, 120, 120))
    end,
    OnEnable = function(feature, ctx)
        local parent = Compat.Gethui() or LocalPlayer:FindFirstChild("PlayerGui") or LocalPlayer:WaitForChild("PlayerGui")
        local gui = Instance.new("ScreenGui")
        gui.Name = "StatsHud"
        gui.ResetOnSpawn = false
        gui.IgnoreGuiInset = true
        gui.DisplayOrder = 10
        local label = Instance.new("TextLabel")
        label.Name = "Readout"
        label.BackgroundTransparency = 1
        label.Size = UDim2.fromOffset(360, 78)
        label.Position = UDim2.fromOffset(10, 8)
        label.Font = Enum.Font.Code
        label.TextSize = 13
        label.TextXAlignment = Enum.TextXAlignment.Left
        label.TextYAlignment = Enum.TextYAlignment.Top
        label.TextColor3 = Color3.fromRGB(255, 255, 255)
        label.TextStrokeTransparency = 0.4
        label.Text = ""
        label.Parent = gui
        gui.Parent = parent
        feature.Gui = gui
        feature.Label = label

        ctx:Loop(0.25, function()
            local instance = behavior()
            if not (instance and feature.Label) then
                return
            end
            local snake = instance.snake
            local kills = 0
            local stats = LocalPlayer:FindFirstChild("leaderstats")
            local killValue = stats and stats:FindFirstChild("Kills")
            if killValue then
                kills = killValue.Value
            end
            local coins = instance.client and instance.client.coins and instance.client.coins.balance or 0
            local magnet = FeatureById.OrbMagnet.Enabled
            local lines = {}
            if snake then
                lines[1] = string.format(
                    "pts %d   rank #%s   segs %d   kills %d   coins %s",
                    snake.points or 0,
                    tostring(snake.rank or "-"),
                    #(snake.segments or {}),
                    kills,
                    tostring(coins)
                )
            else
                lines[1] = string.format("dead   kills %d   coins %s", kills, tostring(coins))
            end
            lines[2] = string.format(
                "speed %s   magnet %s   invincible %s   right ctrl = menu",
                FeatureById.MoveSpeed.Enabled and tostring(FeatureById.MoveSpeed.Value) or "15",
                magnet and "on" or "off",
                FeatureById.Invincible.Enabled and "on" or "off"
            )
            feature.Label.Text = table.concat(lines, "\n")
        end)
    end,
    OnDisable = function(feature, ctx)
        ctx:Cancel()
        if feature.Gui then
            feature.Gui:Destroy()
        end
        feature.Gui = nil
        feature.Label = nil
    end,
})

-- ============================================================================
-- Menu build
-- ============================================================================

Menu = Gui.new({
    Title = CONFIG.Title,
    Width = CONFIG.Width,
    Height = CONFIG.Height,
    ToggleKey = CONFIG.ToggleKey,
    GuiName = CONFIG.GuiName,
    OnUnload = function()
        if unload then
            unload()
        end
    end,
})

Menu:SetStatus("Ready | " .. #Features .. " features | " .. Compat.Name)

for _, feature in ipairs(Features) do
    local tab = Menu:Tab(feature.Tab or "Main")
    local sectionName = feature.Section or feature.Name
    tab._sections = tab._sections or {}
    local section = tab._sections[sectionName]
    if not section then
        section = tab:Section(sectionName, feature.Expanded ~= false)
        tab._sections[sectionName] = section
    end
    feature.Checkbox = section:Checkbox(feature.Name .. "  [" .. tostring(feature.Risk or "T0") .. "]", feature.Default and true or false, function(value)
        setFeature(feature, value)
    end)
    if feature.Build then
        local ok, err = pcall(feature.Build, feature, section, feature.Ctx)
        if not ok then
            section:Text("Build error: " .. tostring(err), Color3.fromRGB(200, 70, 70))
        end
    end
end

-- Utility: dev remotes found in the dump. Button only, never looped.
local utilityTab = Menu:Tab("Utility")
local utilitySection = utilityTab:Section("Dev remotes", true)
utilitySection:Text(
    "RequestDebugCoin is fired only after Client/Debug.luau:47 checks DevList = {358520147, 414345702}. "
        .. "The client check is bypassable, the server check (if any) is not visible in this dump.",
    Color3.fromRGB(180, 150, 0)
)
utilitySection:Button("RequestDebugCoin  [T3]", function()
    local target = remote("RequestDebugCoin")
    if not target then
        Menu:Toast("RequestDebugCoin not present", 3)
        return
    end
    local ok = Net:Fire(target, 5)
    Menu:Toast(ok and "RequestDebugCoin sent (5s cooldown)" or "Rate limited, wait 5s", 3)
end, Color3.fromRGB(255, 225, 225))
utilitySection:Text("One shot per 5s. If the server re-checks the dev list, nothing happens.", Color3.fromRGB(120, 120, 120))
utilitySection:Separator()
utilitySection:Text("Not generated on purpose: forged point totals in RequestCollect, and SnakeRemoved claims about other players.", Color3.fromRGB(120, 120, 120))

-- Debug
local debugTab = Menu:Tab("Debug")
debugTab:Text("Target PlaceId: " .. tostring(game.PlaceId), Color3.fromRGB(235, 235, 235))
debugTab:Text("Executor: " .. Compat.Name .. " | Drawing: " .. tostring(Compat.HasDrawing()))
debugTab:Text("Features: " .. #Features .. " | Right Ctrl toggles the menu.")
debugTab:Text("Unload tab disconnects everything, restores properties and patches, and destroys the GUI.")
debugTab:Separator()
debugTab:Text("Risk tiers: T0 local, T1 replicated, T2 remote-valid, T3 remote-abuse.", Color3.fromRGB(220, 190, 80))
debugTab:Text(
    "This game has no Humanoid character model (it is a snake on a flat plate), so CharacterAdded / "
        .. "WalkSpeed / godmode features do not exist here; invincibility comes from the game's own collision pass.",
    Color3.fromRGB(120, 120, 120)
)
debugTab:Separator()
local statusLabel = debugTab:Text("resolving client modules...", Color3.fromRGB(80, 80, 80))
local logLabel = debugTab:Text("", Color3.fromRGB(120, 120, 120))

spawnGlobal(function()
    while not State.Unloading do
        local instance = behavior()
        local enabled = 0
        for _, feature in ipairs(Features) do
            if feature.Enabled then
                enabled = enabled + 1
            end
        end
        if statusLabel and statusLabel.Parent then
            statusLabel.Text = table.concat({
                string.format("client root: %s", G.Root and G.Root:GetFullName() or "MISSING"),
                string.format("behavior captured: %s", instance and "yes" or "no (waiting for a frame)"),
                string.format("constants: %s | remotes: %s", G.Constants and "ok" or "MISSING", G.Remotes and "ok" or "MISSING"),
                string.format("snake class: %s | invincible flag: %s", snakeClass() and "ok" or "no snake", instance and tostring(instance.invincible) or "-"),
                string.format("pending installs: %d | patches installed: %d | features on: %d/%d", #Installers, #Patches, enabled, #Features),
            }, "\n")
        end
        if logLabel and logLabel.Parent and #Log.Entries > 0 then
            local entry = Log.Entries[#Log.Entries]
            logLabel.Text = string.format("last %s: %s", entry.level, entry.message)
        end
        task.wait(1)
    end
end, "debug-status")

Menu:AddUnloadTab({
    Info = "worm odyssey | " .. tostring(game.PlaceId) .. " | " .. #Features .. " features",
})

Menu:OnRestore(function()
    for _, feature in ipairs(Features) do
        if feature.Enabled then
            setFeature(feature, false)
        end
    end
    for _, feature in ipairs(Features) do
        if feature.Default then
            setFeature(feature, true)
        end
    end
end)

for _, feature in ipairs(Features) do
    if feature.Default then
        setFeature(feature, true)
    end
end

-- ============================================================================
-- Unload
-- ============================================================================

function unload()
    if State.Unloading then
        return
    end
    State.Unloading = true

    for index = #Features, 1, -1 do
        local feature = Features[index]
        if feature.Enabled then
            pcall(setFeature, feature, false)
        end
    end

    restorePatches()
    GlobalBag:Clear()
    for _, thread in ipairs(GlobalThreads) do
        pcall(task.cancel, thread)
    end
    GlobalThreads = {}
    GlobalRestore:All()
    G.Instance = nil

    if Menu then
        local menu = Menu
        Menu = nil
        task.defer(function()
            pcall(function()
                menu:Destroy()
            end)
        end)
    end

    local env = Compat.GetGenv()
    if env and env.RobloxExploit and env.RobloxExploit.Version == CONFIG.Version then
        env.RobloxExploit = nil
    end
end

local API = {
    Version = CONFIG.Version,
    Unload = function()
        unload()
    end,
}

local env = Compat.GetGenv()
if env and env.RobloxExploit and type(env.RobloxExploit.Unload) == "function" then
    pcall(env.RobloxExploit.Unload)
end
if env then
    env.RobloxExploit = API
end

Review the source before using it. Executions count successful copies, capped at 10 per user and network per script in 24 hours.