AtomUI.lua

local safe_clone = cloneref or function(service) return service end

local tween_service     = safe_clone(game:GetService("TweenService"))
local input_service     = safe_clone(game:GetService("UserInputService"))
local run_service       = safe_clone(game:GetService("RunService"))
local players           = safe_clone(game:GetService("Players"))
local text_service      = safe_clone(game:GetService("TextService"))
local core_gui          = safe_clone(game:GetService("CoreGui"))
local gui_service       = safe_clone(game:GetService("GuiService"))
local http_service      = safe_clone(game:GetService("HttpService"))
local lighting          = safe_clone(game:GetService("Lighting"))

--#endregion═════════════════════════════════════════════════════════════════════


--#region ══╗ Icons System ╔═════════════════════════════════════════════════════

local icons_module = nil
local icons_cache = {}

local function load_icons_module()
    if icons_module then return icons_module end
    local ok, result = pcall(function()
        return loadstring(game:HttpGetAsync("https://raw.githubusercontent.com/Footagesus/Icons/main/Main-v2.lua"))()
    end)
    if ok and result then
        icons_module = result
        pcall(function() icons_module.SetIconsType("lucide") end)
    end
    return icons_module
end

local function get_icon(name, fallback)
    if not name or name == "" then
        return fallback or "rbxassetid://94219370057308"  -- default tab icon
    end

    if name:match("^rbxassetid://") or name:match("^rbxasset://") or name:match("^http") then
        return name
    end

    if icons_cache[name] then
        return icons_cache[name]
    end

    local mod = load_icons_module()
    if mod and type(mod.GetIcon) == "function" then
        local ok, icon_id = pcall(mod.GetIcon, name)
        if ok and icon_id and icon_id ~= "" then
            icons_cache[name] = icon_id
            return icon_id
        end
    end

    return fallback or "rbxassetid://94219370057308"  -- default tab icon (safe fallback)
end

local default_icons = {
    section         = "rbxassetid://98092584632154",
    tab             = "rbxassetid://94219370057308",
    group           = "rbxassetid://10723427199",
    search          = "rbxassetid://10734943674",
    settings        = "rbxassetid://6031280882",
    expand          = "rbxassetid://111626678408582",
    resize          = "rbxassetid://111626678408582",
    close           = "rbxassetid://10747384394",
    dropdown_arrow  = "rbxassetid://111626678408582",
}

local atomic_logo   = "rbxassetid://113081944862488"
--#endregion═════════════════════════════════════════════════════════════════════


--#region ══╗ Core ╔═════════════════════════════════════════════════════════════

local atom_ui = {}
atom_ui.__index = atom_ui

local local_player      = players.LocalPlayer
local player_mouse      = local_player:GetMouse()

local is_mobile         = input_service.TouchEnabled and not input_service.KeyboardEnabled
local scale_factor      = is_mobile and 0.7 or 1
local default_font_enum     = Enum.Font.GothamSemibold
local default_font_family   = "rbxasset://fonts/families/GothamSSm.json"

local function resolve_font_enum(weight)
    if weight == Enum.FontWeight.Bold then
        return Enum.Font.GothamBold
    end
    if weight == Enum.FontWeight.Medium then
        return Enum.Font.GothamMedium
    end
    return default_font_enum
end

local font_face_supported = false

local function make_font_descriptor(family, weight, style, enumFont)
    return {
        __atom_font = true,
        Family = family or default_font_family,
        Weight = weight or Enum.FontWeight.SemiBold,
        Style = style or Enum.FontStyle.Normal,
        EnumFont = enumFont or resolve_font_enum(weight)
    }
end

local function is_font_descriptor(value)
    return type(value) == "table" and value.__atom_font == true
end

local function get_fallback_font(value, fallbackEnum)
    if is_font_descriptor(value) then
        return value.EnumFont or fallbackEnum or default_font_enum
    end
    return fallbackEnum or default_font_enum
end

local function apply_font(instance, value, fallbackEnum)
    if not instance or not (instance:IsA("TextLabel") or instance:IsA("TextButton") or instance:IsA("TextBox")) then
        return false
    end

    pcall(function()
        instance.Font = get_fallback_font(value, fallbackEnum)
    end)
    return false
end

local Font = {
    new = function(family, weight, style)
        family = family or default_font_family
        weight = weight or Enum.FontWeight.SemiBold
        style = style or Enum.FontStyle.Normal
        return make_font_descriptor(family, weight, style)
    end,
    fromEnum = function(enumFont)
        enumFont = enumFont or default_font_enum
        return make_font_descriptor(default_font_family, Enum.FontWeight.SemiBold, Enum.FontStyle.Normal, enumFont)
    end
}

local function create(className, properties)
    local instance = Instance.new(className)
    for property, value in pairs(properties) do
        if property ~= "Parent" then
            if property == "FontFace" then
                apply_font(instance, value)
            else
                pcall(function()
                    instance[property] = value
                end)
            end
        end
    end
    if properties.Parent then
        instance.Parent = properties.Parent
    end
    return instance
end

local function tween_to(instance, properties, duration, easingStyle, easingDirection)
    if not instance or typeof(instance) ~= "Instance" then
        return nil
    end
    local ok, tween_info = pcall(function()
        return TweenInfo.new(duration or 0.22, easingStyle or Enum.EasingStyle.Quint, easingDirection or Enum.EasingDirection.Out)
    end)
    if not ok then
        return nil
    end
    local ok2, tween_obj = pcall(function()
        return tween_service:Create(instance, tween_info, properties)
    end)
    if not ok2 or not tween_obj then
        return nil
    end
    pcall(function() tween_obj:Play() end)
    return tween_obj
end

local function disconnect_signal(conn)
    if conn and typeof(conn) == "RBXScriptConnection" then
        pcall(function()
            if conn.Connected then
                conn:Disconnect()
            end
        end)
    elseif type(conn) == "function" then
        pcall(conn)
    end
end

local function make_draggable(frame, handle, libraryRef)
    local amIDragging = false
    local activeDragInput
    local whereDidIStart
    local whereWasIBefore
    local targetDragPosition = frame.Position
    local dragLerpSpeed = is_mobile and 18 or 22
    local renderDragConn
    
    handle = handle or frame

    local function stopDragLoop()
        disconnect_signal(renderDragConn)
        renderDragConn = nil
    end

    local function ensureDragLoop()
        if renderDragConn and renderDragConn.Connected then
            return
        end
        renderDragConn = run_service.RenderStepped:Connect(function(dt)
            if not frame or not frame.Parent then
                stopDragLoop()
                return
            end
            local currentPos = frame.Position
            local goalPos = targetDragPosition
            local offsetDelta = math.abs(goalPos.X.Offset - currentPos.X.Offset) + math.abs(goalPos.Y.Offset - currentPos.Y.Offset)
            if offsetDelta <= 0.1 then
                if currentPos ~= goalPos then
                    frame.Position = goalPos
                end
                if not amIDragging then
                    stopDragLoop()
                end
                return
            end
            local alpha = math.clamp(1 - math.exp(-dragLerpSpeed * dt), 0, 0.45)
            frame.Position = currentPos:Lerp(goalPos, alpha)
        end)
        if libraryRef and type(libraryRef._TrackConnection) == "function" then
            libraryRef:_TrackConnection(renderDragConn)
        end
    end
    
    local function updateTargetPositionYay(input)
        local howMuchDidIMove = input.Position - whereDidIStart
        targetDragPosition = UDim2.new(
            whereWasIBefore.X.Scale,
            whereWasIBefore.X.Offset + howMuchDidIMove.X,
            whereWasIBefore.Y.Scale,
            whereWasIBefore.Y.Offset + howMuchDidIMove.Y
        )
    end
    
    local inputBeganConn = handle.InputBegan:Connect(function(input)
        local isMouse = input.UserInputType == Enum.UserInputType.MouseButton1
        local isTouch = input.UserInputType == Enum.UserInputType.Touch
        if not isMouse and not isTouch then
            return
        end

        amIDragging = true
        activeDragInput = isTouch and input or nil
        whereDidIStart = input.Position
        whereWasIBefore = frame.Position
        targetDragPosition = frame.Position
        ensureDragLoop()
        
        local inputEndConn
        inputEndConn = input.Changed:Connect(function()
            if input.UserInputState == Enum.UserInputState.End then
                if frame and frame.Parent then
                    frame.Position = targetDragPosition
                end
                amIDragging = false
                activeDragInput = nil
                stopDragLoop()
                if inputEndConn then
                    inputEndConn:Disconnect()
                    inputEndConn = nil
                end
            end
        end)
        if libraryRef and type(libraryRef._TrackConnection) == "function" then
            libraryRef:_TrackConnection(inputEndConn)
        end
    end)
    
    local userInputChangedConn = input_service.InputChanged:Connect(function(input)
        if not amIDragging then
            return
        end
        if input.UserInputType == Enum.UserInputType.MouseMovement then
            updateTargetPositionYay(input)
        elseif input.UserInputType == Enum.UserInputType.Touch and (activeDragInput == nil or input == activeDragInput) then
            updateTargetPositionYay(input)
        end
    end)

    if libraryRef and type(libraryRef._TrackConnection) == "function" then
        libraryRef:_TrackConnection(inputBeganConn)
        libraryRef:_TrackConnection(userInputChangedConn)
    end
end

local function start_position_tracker(libraryRef, anchorInstance, updateFn)
    if type(updateFn) ~= "function" or not anchorInstance then
        return nil
    end

    local active = true
    local connections = {}

    local function bindSignal(instance, propertyName)
        if not instance then
            return
        end
        table.insert(connections, libraryRef:_TrackConnection(instance:GetPropertyChangedSignal(propertyName):Connect(updateFn)))
    end

    bindSignal(anchorInstance, "AbsolutePosition")
    bindSignal(anchorInstance, "AbsoluteSize")
    table.insert(connections, libraryRef:_TrackConnection(anchorInstance.AncestryChanged:Connect(updateFn)))

    if libraryRef and libraryRef.screen_gui then
        bindSignal(libraryRef.screen_gui, "AbsoluteSize")
    end

    updateFn()

    return function()
        if not active then
            return
        end
        active = false
        for i = #connections, 1, -1 do
            disconnect_signal(connections[i])
            connections[i] = nil
        end
    end
end

local function attach_scrollbar(libraryRef, scrollFrame, parentInstance, options)
    if not libraryRef or not scrollFrame or not parentInstance then
        return nil
    end

    options = options or {}

    local trackWidth = math.max(4, math.floor((options.TrackWidth or (6 * scale_factor)) + 0.5))
    local thumbWidth = math.max(2, math.min(trackWidth - 1, math.floor((options.ThumbWidth or (3 * scale_factor)) + 0.5)))
    local edgeInset = math.max(1, math.floor((options.EdgeInset or (2 * scale_factor)) + 0.5))
    local verticalInset = math.max(2, math.floor((options.VerticalInset or (4 * scale_factor)) + 0.5))
    local minThumbHeight = math.max(18, math.floor((options.MinThumbHeight or (26 * scale_factor)) + 0.5))
    local idleThumbHeight = math.max(minThumbHeight, math.floor((options.IdleThumbHeight or (42 * scale_factor)) + 0.5))
    local alwaysShowTrack = options.AlwaysShowTrack == true
    local zIndex = options.ZIndex or ((scrollFrame.ZIndex or 1) + 2)
    local xOffset = options.XOffset or 0

    local trackFrame = create("Frame", {
        Name = "AtomUIScrollbarTrack",
        BackgroundColor3 = Color3.fromRGB(11, 11, 14),
        BackgroundTransparency = 0.12,
        BorderSizePixel = 0,
        Visible = false,
        ZIndex = zIndex,
        Parent = parentInstance
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = trackFrame})

    local thumbFrame = create("Frame", {
        Name = "AtomUIScrollbarThumb",
        AnchorPoint = Vector2.new(0.5, 0),
        BackgroundColor3 = libraryRef.config.AccentColor,
        BorderSizePixel = 0,
        Position = UDim2.new(0.5, 0, 0, 0),
        Size = UDim2.new(0, thumbWidth, 0, minThumbHeight),
        ZIndex = zIndex + 1,
        Parent = trackFrame
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = thumbFrame})

    local function resolveCanvasHeight()
        local canvasHeight = math.max(scrollFrame.CanvasSize.Y.Offset, 0)
        local okAbsoluteCanvas, absoluteCanvasSize = pcall(function()
            return scrollFrame.AbsoluteCanvasSize
        end)
        if okAbsoluteCanvas and typeof(absoluteCanvasSize) == "Vector2" then
            canvasHeight = math.max(canvasHeight, absoluteCanvasSize.Y)
        end
        return canvasHeight
    end

    local function updateScrollbar()
        if libraryRef._destroyed or not scrollFrame.Parent or not parentInstance.Parent or not trackFrame.Parent then
            return false
        end

        local frameSize = scrollFrame.AbsoluteSize
        local windowHeight = frameSize.Y
        local frameVisible = scrollFrame.Visible and frameSize.X > 0 and frameSize.Y > 0
        local canvasHeight = math.max(resolveCanvasHeight(), windowHeight)
        local canScroll = frameVisible and canvasHeight > (windowHeight + 1)

        if not frameVisible then
            trackFrame.Visible = false
            thumbFrame.Visible = false
            return true
        end

        local parentAbsolute = parentInstance.AbsolutePosition
        local frameAbsolute = scrollFrame.AbsolutePosition
        local trackHeight = math.max(0, frameSize.Y - (verticalInset * 2))
        if trackHeight <= 2 then
            trackFrame.Visible = false
            return true
        end
        local trackX = math.floor((frameAbsolute.X - parentAbsolute.X) + frameSize.X - trackWidth - edgeInset + xOffset + 0.5)
        local trackY = math.floor((frameAbsolute.Y - parentAbsolute.Y) + verticalInset + 0.5)

        trackFrame.Visible = true
        trackFrame.Position = UDim2.fromOffset(trackX, trackY)
        trackFrame.Size = UDim2.fromOffset(trackWidth, math.floor(trackHeight + 0.5))
        trackFrame.BackgroundColor3 = Color3.fromRGB(11, 11, 14)
        thumbFrame.BackgroundColor3 = libraryRef.config.AccentColor

        if not canScroll then
            trackFrame.Visible = alwaysShowTrack
            thumbFrame.Visible = alwaysShowTrack
            if alwaysShowTrack then
                local restingThumbHeight = math.min(idleThumbHeight, trackHeight)
                thumbFrame.Size = UDim2.fromOffset(thumbWidth, math.floor(restingThumbHeight + 0.5))
                thumbFrame.Position = UDim2.fromOffset(math.floor(trackWidth * 0.5 + 0.5), math.floor(math.max(0, (trackHeight - restingThumbHeight) * 0.08) + 0.5))
            end
            return true
        end

        thumbFrame.Visible = true
        local minimumThumbHeight = math.min(minThumbHeight, trackHeight)
        local thumbHeight = math.clamp((windowHeight / canvasHeight) * trackHeight, minimumThumbHeight, trackHeight)
        local maxScroll = math.max(canvasHeight - windowHeight, 0)
        local scrollRatio = maxScroll > 0 and math.clamp(scrollFrame.CanvasPosition.Y / maxScroll, 0, 1) or 0
        local thumbTravel = math.max(trackHeight - thumbHeight, 0)

        thumbFrame.Size = UDim2.fromOffset(thumbWidth, math.floor(thumbHeight + 0.5))
        thumbFrame.Position = UDim2.fromOffset(math.floor(trackWidth * 0.5 + 0.5), math.floor((thumbTravel * scrollRatio) + 0.5))

        return true
    end

    local function bindProperty(propertyName)
        local okSignal, signal = pcall(function()
            return scrollFrame:GetPropertyChangedSignal(propertyName)
        end)
        if okSignal and signal then
            libraryRef:_TrackConnection(signal:Connect(updateScrollbar))
        end
    end

    bindProperty("CanvasPosition")
    bindProperty("CanvasSize")
    bindProperty("AbsoluteSize")
    bindProperty("AbsoluteCanvasSize")
    bindProperty("Visible")

    local stopFloatingTracker = start_position_tracker(libraryRef, scrollFrame, updateScrollbar)
    if stopFloatingTracker then
        libraryRef:_TrackConnection(stopFloatingTracker)
    end

    if type(libraryRef._scrollbarRefreshers) == "table" then
        table.insert(libraryRef._scrollbarRefreshers, updateScrollbar)
    end

    updateScrollbar()

    return {
        Track = trackFrame,
        Thumb = thumbFrame,
        Refresh = updateScrollbar
    }
end

local function get_player_avatar(userId)
    local didItWork, whatWeGot = pcall(function()
        return players:GetUserThumbnailAsync(userId, Enum.ThumbnailType.HeadShot, Enum.ThumbnailSize.Size420x420)
    end)
    if didItWork then
        return whatWeGot
    end
    return "rbxassetid://135756197673563"
end

local function resolve_avatar_3d(defaultUserId)
    local fallbackUserId = tonumber(defaultUserId) or 1
    local endpoint = "https://thumbnails.roblox.com/v1/users/avatar-3d?userId=" .. tostring(fallbackUserId)

    local okBody, rawBody = pcall(function()
        return game:HttpGet(endpoint)
    end)
    if not okBody or type(rawBody) ~= "string" or rawBody == "" then
        return fallbackUserId, nil
    end

    local okDecode, payload = pcall(function()
        return http_service:JSONDecode(rawBody)
    end)
    if not okDecode or type(payload) ~= "table" then
        return fallbackUserId, nil
    end

    local resolvedUserId = tonumber(payload.targetId) or tonumber(payload.userId) or fallbackUserId
    local imageUrl = type(payload.imageUrl) == "string" and payload.imageUrl or nil
    return resolvedUserId, imageUrl
end

local function measure_text_width(text, textSize, font)
    local textBoundsYay = text_service:GetTextSize(text, textSize, font or Enum.Font.GothamSemibold, Vector2.new(math.huge, math.huge))
    return textBoundsYay.X
end

local function truncate_text(text, maxWidth, textSize, font)
    local fullWidth = measure_text_width(text, textSize, font)
    if fullWidth <= maxWidth then
        return text
    end
    
    local truncated = text
    while measure_text_width(truncated .. "...", textSize, font) > maxWidth and #truncated > 0 do
        truncated = truncated:sub(1, -2)
    end
    return truncated .. "..."
end

local function normalize_search(text)
    return string.lower(tostring(text or "")):gsub("^%s+", ""):gsub("%s+$", "")
end

local function normalize_dropdown(options)
    local normalized = {}
    if type(options) == "table" then
        for _, option in ipairs(options) do
            if option ~= nil then
                table.insert(normalized, option)
            end
        end
    end
    if #normalized == 0 then
        normalized[1] = "None"
    end
    return normalized
end

local function get_dropdown_signature(options)
    if type(options) ~= "table" then
        return "0"
    end
    local count = #options
    if count <= 0 then
        return "0"
    end
    local signaturePieces = table.create and table.create(count + 1, "") or {}
    signaturePieces[1] = tostring(count)
    for index, option in ipairs(options) do
        signaturePieces[index + 1] = tostring(option)
    end
    return table.concat(signaturePieces, "\31")
end

local function get_decimal_places(value)
    if type(value) ~= "number" then
        return 0
    end
    local valueString = tostring(value)
    local decimalPart = valueString:match("%.(%d+)")
    if decimalPart then
        return #decimalPart
    end
    local exponentPart = valueString:match("[eE]([%+%-]?%d+)")
    if exponentPart then
        local exponent = tonumber(exponentPart) or 0
        if exponent < 0 then
            return -exponent
        end
    end
    return 0
end

local function round_to_decimals(value, decimals)
    if decimals <= 0 then
        if value >= 0 then
            return math.floor(value + 0.5)
        end
        return math.ceil(value - 0.5)
    end
    local factor = 10 ^ decimals
    if value >= 0 then
        return math.floor(value * factor + 0.5) / factor
    end
    return math.ceil(value * factor - 0.5) / factor
end

local function resolve_precision(minValue, maxValue, increment, defaultValue)
    local precision = 0
    precision = math.max(precision, get_decimal_places(minValue))
    precision = math.max(precision, get_decimal_places(maxValue))
    precision = math.max(precision, get_decimal_places(increment))
    precision = math.max(precision, get_decimal_places(defaultValue))
    return math.clamp(precision, 0, 6)
end

local function normalize_slider_value(value, minValue, maxValue, increment, precision)
    local numericValue = tonumber(value) or minValue
    numericValue = math.clamp(numericValue, minValue, maxValue)
    local normalizedIncrement = math.max(math.abs(tonumber(increment) or 1), 1e-6)
    local steps = math.floor(((numericValue - minValue) / normalizedIncrement) + 0.5)
    local snappedValue = minValue + (steps * normalizedIncrement)
    snappedValue = round_to_decimals(snappedValue, precision)
    return math.clamp(snappedValue, minValue, maxValue)
end

local function format_slider_value(value, precision)
    if precision <= 0 then
        return tostring(round_to_decimals(value, 0))
    end
    local formatted = string.format("%." .. tostring(precision) .. "f", value)
    formatted = formatted:gsub("(%..-)0+$", "%1"):gsub("%.$", "")
    return formatted
end

local function serialize_value(value)
    local valueType = typeof(value)
    if valueType == "Color3" then
        return {
            __type = "Color3",
            r = value.R,
            g = value.G,
            b = value.B
        }
    end
    if valueType == "EnumItem" and value.EnumType == Enum.KeyCode then
        return {
            __type = "KeyCode",
            value = value.Name
        }
    end
    return value
end

local function deserialize_value(value)
    if type(value) ~= "table" or not value.__type then
        return value
    end
    if value.__type == "Color3" and value.r and value.g and value.b then
        return Color3.new(value.r, value.g, value.b)
    end
    if value.__type == "KeyCode" and value.value then
        return Enum.KeyCode[value.value] or Enum.KeyCode.Unknown
    end
    return value
end

local function sanitize_config_name(name)
    local cleanName = tostring(name or "default")
    cleanName = cleanName:gsub("[\\/:*?\"<>|]", "_")
    cleanName = cleanName:gsub("^%s+", ""):gsub("%s+$", "")
    if cleanName == "" then
        cleanName = "default"
    end
    return cleanName
end

local function get_config_folder()
    return "AtomUIConfigs"
end

local function ensure_config_folder()
    local folder = get_config_folder()

    if isfolder and isfolder(folder) then
        return true, folder
    end

    if makefolder then
        pcall(function()
            makefolder(folder)
        end)
    end

    if isfolder and isfolder(folder) then
        return true, folder
    end

    return false, folder
end

local function get_config_filename(configName)
    return sanitize_config_name(configName) .. ".json"
end

local function get_writable_config_path(configName)
    local fileName = get_config_filename(configName)
    local okFolder, folder = ensure_config_folder()
    if okFolder then
        return folder .. "/" .. fileName, true
    end
    return fileName, false
end

local function get_readable_config_paths(configName)
    local fileName = get_config_filename(configName)
    local folder = get_config_folder()
    return {
        folder .. "/" .. fileName,
        folder .. "\\" .. fileName,
        fileName
    }
end

local RUNTIME_INSTANCE_KEY = "__ATOM_UI_ACTIVE"
local SCREEN_GUI_NAME = "AtomUI"

local function get_shared_env()
    if type(getgenv) == "function" then
        local okEnv, sharedEnv = pcall(getgenv)
        if okEnv and type(sharedEnv) == "table" then
            return sharedEnv
        end
    end
    return _G
end

local function destroy_existing_guis()
    local roots = {}
    local seenRoots = {}

    local function addRoot(root)
        if not root or seenRoots[root] then
            return
        end
        seenRoots[root] = true
        table.insert(roots, root)
    end

    addRoot(core_gui)

    if type(gethui) == "function" then
        local okHui, huiRoot = pcall(gethui)
        if okHui then
            addRoot(huiRoot)
        end
    end

    if local_player then
        local okPlayerGui, playerGui = pcall(function()
            return local_player:FindFirstChild("PlayerGui")
        end)
        if okPlayerGui then
            addRoot(playerGui)
        end
    end

    for _, root in ipairs(roots) do
        local okChildren, children = pcall(function()
            return root:GetChildren()
        end)
        if okChildren and type(children) == "table" then
            for _, child in ipairs(children) do
                if child and child:IsA("ScreenGui") and child.Name == SCREEN_GUI_NAME then
                    pcall(function()
                        child:Destroy()
                    end)
                end
            end
        end
    end
end

local function cleanup_previous_instance()
    local sharedEnv = get_shared_env()
    local previousInstance = rawget(sharedEnv, RUNTIME_INSTANCE_KEY)
    if previousInstance and type(previousInstance) == "table" and type(previousInstance.Destroy) == "function" then
        pcall(function()
            previousInstance:Destroy()
        end)
    end
    rawset(sharedEnv, RUNTIME_INSTANCE_KEY, nil)
    destroy_existing_guis()
end

function atom_ui.new(config)
    cleanup_previous_instance()

    local self = setmetatable({}, atom_ui)
    
    self.config = config or {}
    self.config.Name = self.config.Name or "o11 vision"
    self.config.AccentColor = self.config.AccentColor or Color3.fromRGB(2, 133, 255)
    self.config.BackgroundColor = self.config.BackgroundColor or Color3.fromRGB(16, 16, 16)
    self.config.SecondaryColor = self.config.SecondaryColor or Color3.fromRGB(18, 18, 18)
    self.config.TextColor = self.config.TextColor or Color3.fromRGB(255, 255, 255)
    self.config.SubTextColor = self.config.SubTextColor or Color3.fromRGB(124, 124, 124)
    self.config.CustomBackground = self.config.CustomBackground or false
    self.config.BackgroundImage = self.config.BackgroundImage or ""
    self.config.BackgroundTransparency = self.config.BackgroundTransparency or 0.35
    -- ToggleImage: hub makers can pass a custom rbxassetid:// for the toggle button logo
    self.config.ToggleImage = self.config.ToggleImage or nil
    
    self.sections = {}
    self.all_tabs = {}
    self.active_tab = nil
    self.notifications = {}
    self.is_visible = true
    self.dropdown_holder = nil
    self.toggleKeyCode = Enum.KeyCode.RightControl
    self.toggleButtonVisible = true
    self._destroyed = false
    self._connections = {}
    self._trackedControls = {}
    self._lastControlRegistration = 0
    self._autoConfigName = sanitize_config_name((self.config.Name or "AtomUI") .. "_last")
    local autoConfigSetting = self.config.AutoConfig
    if autoConfigSetting == nil then
        autoConfigSetting = self.config.AutoSaveConfig
    end
    if autoConfigSetting == nil then
        autoConfigSetting = false
    end
    self._autoConfigEnabled = autoConfigSetting == true
    self._autoConfigLoadAttempted = not self._autoConfigEnabled
    self._autoConfigAccumulator = 0
    self._autoConfigInterval = 1.2
    self._autoConfigSnapshot = nil
    self._isApplyingConfig = false
    self._configPathHints = {}
    self._smoothScrollFrames = {}
    self._scrollbarRefreshers = {}
    self._searchQuery = ""
    self._fpsRollingSize = 60
    self._fpsRollingWindow = table.create and table.create(self._fpsRollingSize, 0) or {}
    self._fpsRollingTotal = 0
    self._fpsRollingIndex = 1
    self._fpsRollingCount = 0
    self._latestFPSValue = 0
    self._cachedViewportSize = Vector2.new(1280, 720)
    self._cachedViewportWidth = 1280
    self._cachedViewportHeight = 720
    self._cachedViewportAreaScale = 1
    self._blurEffectRef = nil
    self._snowflakes = {}
    self._snowSpawnAccumulator = 0
    self._snowMaxFlakes = is_mobile and 45 or 90
    self._overlayMode = "None"
    self._overlayModes = {"Snow", "Rain", "Stars", "None"}
    self._backgroundFxTime = 0
    self._backgroundFxAccumulator = 0
    self._textGradientAnimationTime = 0
    self._gradientAnimationAccumulator = 0
    self._overlayUpdateAccumulator = 0
    self._watermarkUpdateAccumulator = 0
    self._watermarkLastWidth = 0
    self._refreshJobs = {}
    self._notificationTimestamps = {}
    self._uiVisualSettings = {
        Blur = false,
        Snow = false,
        BackgroundEffects = false,
        TextGradient = false,
        ESPSelfPreview = false,
        HideName = false
    }
    self._fontPresets = {
        {Name = "Gotham", EnumFont = Enum.Font.Gotham, Family = "rbxasset://fonts/families/GothamSSm.json", Weight = Enum.FontWeight.SemiBold},
        {Name = "Gotham Medium", EnumFont = Enum.Font.GothamMedium, Family = "rbxasset://fonts/families/GothamSSm.json", Weight = Enum.FontWeight.Medium},
        {Name = "Montserrat", EnumFont = Enum.Font.Gotham, Family = "rbxasset://fonts/families/Montserrat.json", Weight = Enum.FontWeight.SemiBold},
        {Name = "Nunito", EnumFont = Enum.Font.Gotham, Family = "rbxasset://fonts/families/Nunito.json", Weight = Enum.FontWeight.SemiBold},
        {Name = "Bodoni", EnumFont = Enum.Font.Bodoni},
        {Name = "Garamond", EnumFont = Enum.Font.Garamond},
        {Name = "Source Sans", EnumFont = Enum.Font.SourceSans, Family = "rbxasset://fonts/families/SourceSansPro.json", Weight = Enum.FontWeight.SemiBold},
        {Name = "Highway", EnumFont = Enum.Font.Highway},
        {Name = "Antique", EnumFont = Enum.Font.Antique},
        {Name = "Code", EnumFont = Enum.Font.Code}
    }
    self._fontPresetIndex = 1
    self._gradientLabels = {}
    self._gradientObjects = {}
    self._espPreviewProvider = nil
    self._espPreviewData = nil
    self._espPreviewState = nil
    self._espPreviewResolveAccumulator = 0
    self._espPreviewUpdateAccumulator = 0
    self._espPreviewWasShowing = false
    self._espPreviewPanel = nil
    self._espPreviewViewport = nil
    self._espPreviewWorldModel = nil
    self._espPreviewCamera = nil
    self._espPreviewCharacter = nil
    self._espPreviewLastCharacter = nil
    self._espPreviewPartDefaults = {}
    self._espPreviewHeadPart = nil
    self._espPreviewRootPart = nil
    self._espPreviewVisualState = nil
    self._espPreviewVisualDirty = false
    self._espPreviewProjectionCache = nil
    self._espPreviewProjectionDirty = true
    self._espPreviewHighlight = nil
    self._espPreviewHeaderTag = nil
    self._espPreviewBox = nil
    self._espPreviewBoxStroke = nil
    self._espPreviewHealthTrack = nil
    self._espPreviewHealthFill = nil
    self._espPreviewDot = nil
    self._espPreviewTracer = nil
    self._espPreviewName = nil
    self._espPreviewItem = nil
    self._espPreviewDistance = nil
    self._espPreviewWalkTrack = nil
    self._espPreviewAnimationId = nil
    self._espPreviewAvatar3DUserId = tonumber(local_player.UserId) or 0
    self._espPreviewAvatar3DImageUrl = nil
    self._espPreviewRotationYaw = math.rad(180)
    self._espPreviewRotationTargetYaw = math.rad(180)
    self._espPreviewStaticMode = true
    self._espPreviewAllowManualRotation = true
    self._espPreviewPivotYOffset = -2
    self._espPreviewRotateCapture = nil
    self._espPreviewIsRotating = false
    self._espPreviewRotateInput = nil
    self._espPreviewRotateLastX = 0
    
    self:BuildUI()
    rawset(get_shared_env(), RUNTIME_INSTANCE_KEY, self)
    
    return self
end

function atom_ui:_TrackConnection(conn)
    if conn then
        table.insert(self._connections, conn)
        if #self._connections % 100 == 0 then
            local activeConnections = {}
            for _, item in ipairs(self._connections) do
                if item then
                    if typeof(item) == "RBXScriptConnection" then
                        if item.Connected then
                            table.insert(activeConnections, item)
                        end
                    else
                        table.insert(activeConnections, item)
                    end
                end
            end
            self._connections = activeConnections
        end
    end
    return conn
end

function atom_ui:RegisterControl(flag, getter, setter)
    if type(flag) ~= "string" or flag == "" then return end
    if type(getter) ~= "function" or type(setter) ~= "function" then return end
    self._trackedControls[flag] = {
        get = getter,
        set = setter
    }
    self._lastControlRegistration = os.clock()
end

function atom_ui:_RegisterRefreshJob(interval, isAliveFn, stepFn)
    if type(stepFn) ~= "function" then
        return nil
    end

    local job = {
        Interval = math.max(tonumber(interval) or 0.5, 0.05),
        IsAlive = isAliveFn,
        Step = stepFn,
        Accumulator = 0
    }

    table.insert(self._refreshJobs, job)
    return job
end

function atom_ui:_StepRefreshJobs(dt)
    if not self._refreshJobs then
        return
    end

    local resolvedDt = tonumber(dt) or 0
    for index = #self._refreshJobs, 1, -1 do
        local job = self._refreshJobs[index]
        local keepJob = true

        if type(job) ~= "table" or type(job.Step) ~= "function" then
            keepJob = false
        elseif type(job.IsAlive) == "function" then
            local okAlive, isAlive = pcall(job.IsAlive)
            keepJob = okAlive and isAlive ~= false
        end

        if not keepJob then
            table.remove(self._refreshJobs, index)
        else
            job.Accumulator = (job.Accumulator or 0) + resolvedDt
            if job.Accumulator >= (job.Interval or 0.5) then
                job.Accumulator = 0
                local okStep, keepResult = pcall(job.Step)
                if not okStep or keepResult == false then
                    table.remove(self._refreshJobs, index)
                end
            end
        end
    end
end

function atom_ui:_BuildAutoConfigSnapshot()
    local controlsSnapshot = {}
    local trackedFlags = {}

    for flag in pairs(self._trackedControls) do
        table.insert(trackedFlags, flag)
    end

    table.sort(trackedFlags)

    for _, flag in ipairs(trackedFlags) do
        local control = self._trackedControls[flag]
        if control and type(control.get) == "function" then
            local ok, value = pcall(control.get)
            if ok then
                controlsSnapshot[flag] = serialize_value(value)
            end
        end
    end

    local okEncode, encoded = pcall(function()
        return http_service:JSONEncode(controlsSnapshot)
    end)

    if okEncode then
        return encoded
    end

    return nil
end

function atom_ui:_TryAutoSaveConfig(forceSave)
    if self._destroyed or not self._autoConfigEnabled or self._isApplyingConfig then
        return false
    end

    if not writefile or next(self._trackedControls) == nil then
        return false
    end

    local snapshot = self:_BuildAutoConfigSnapshot()
    if not snapshot then
        return false
    end

    if not forceSave and snapshot == self._autoConfigSnapshot then
        return false
    end

    local okSave = self:SaveConfig(self._autoConfigName)
    if okSave then
        self._autoConfigSnapshot = snapshot
    end

    return okSave == true
end

function atom_ui:_TryAutoLoadConfig(forceAttempt)
    if self._destroyed then
        return false
    end

    if self._autoConfigLoadAttempted and not forceAttempt then
        return false
    end

    if not readfile or next(self._trackedControls) == nil then
        return false
    end

    self._isApplyingConfig = true
    local okLoad = self:LoadConfig(self._autoConfigName)
    self._isApplyingConfig = false
    self._autoConfigLoadAttempted = true
    self._autoConfigAccumulator = 0
    self._autoConfigSnapshot = self:_BuildAutoConfigSnapshot()
    return okLoad == true
end

function atom_ui:_RefreshViewportMetrics()
    local viewportSize = (self.screen_gui and self.screen_gui.AbsoluteSize) or Vector2.new(0, 0)
    local width = math.max(200, math.floor(viewportSize.X > 0 and viewportSize.X or 1280))
    local height = math.max(320, math.floor(viewportSize.Y > 0 and viewportSize.Y or 720))
    self._cachedViewportSize = Vector2.new(width, height)
    self._cachedViewportWidth = width
    self._cachedViewportHeight = height
    self._cachedViewportAreaScale = math.clamp(math.sqrt((width * height) / (1280 * 720)), is_mobile and 0.52 or 0.68, 1.12)
end

function atom_ui:_InvalidateESPPreviewProjection(clearCache)
    self._espPreviewProjectionDirty = true
    if clearCache then
        self._espPreviewProjectionCache = nil
    end
end

function atom_ui:_EnsureBlurEffect()
    if self._blurEffectRef and self._blurEffectRef.Parent then
        return self._blurEffectRef
    end
    local existingBlur = lighting:FindFirstChild("AtomUIBlurEffect")
    if existingBlur and existingBlur:IsA("BlurEffect") then
        self._blurEffectRef = existingBlur
        return existingBlur
    end
    self._blurEffectRef = create("BlurEffect", {
        Name = "AtomUIBlurEffect",
        Size = 0,
        Enabled = true,
        Parent = lighting
    })
    return self._blurEffectRef
end

function atom_ui:_SetBlurActive(active, instant)
    local blur = self:_EnsureBlurEffect()
    local shouldEnable = self._uiVisualSettings.Blur and active
    local targetSize = shouldEnable and (is_mobile and 14 or 18) or 0
    if instant then
        blur.Size = targetSize
        return
    end
    tween_to(blur, {Size = targetSize}, 0.28, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
end

function atom_ui:_ClearSnowflakes()
    for i = #self._snowflakes, 1, -1 do
        local snowObj = self._snowflakes[i]
        if snowObj and snowObj.instance and snowObj.instance.Parent then
            snowObj.instance:Destroy()
        end
        self._snowflakes[i] = nil
    end
end

function atom_ui:_SpawnSnowflake()
    if not self.snow_layer or not self.snow_layer.Parent then
        return
    end
    local width = self._cachedViewportWidth or 200
    local size = math.random(2, 7) * scale_factor
    local startX = math.random(-18, width + 18)
    local flake = create("ImageLabel", {
        BackgroundTransparency = 1,
        Image = "rbxassetid://3570695787",
        ImageColor3 = Color3.fromRGB(236 + math.random(0, 19), 243 + math.random(0, 12), 255),
        ImageTransparency = math.random(22, 56) / 100,
        Size = UDim2.new(0, size, 0, size),
        Position = UDim2.new(0, startX, 0, -math.random(6, 80)),
        Rotation = math.random(0, 359),
        ZIndex = 2,
        Parent = self.snow_layer
    })
    table.insert(self._snowflakes, {
        overlayType = "Snow",
        instance = flake,
        baseX = startX,
        fallSpeed = math.random(16, 42) * scale_factor,
        driftAmount = math.random(12, 42) * scale_factor,
        swirlAmount = math.random(2, 10) * scale_factor,
        driftSpeed = math.random(5, 15) / 10,
        twinkleSpeed = math.random(6, 15) / 10,
        baseTransparency = flake.ImageTransparency,
        phase = math.random() * math.pi * 2,
        spin = math.random(-14, 14),
        size = size,
        yOffset = flake.Position.Y.Offset
    })
end

function atom_ui:_SpawnRainDrop()
    if not self.snow_layer or not self.snow_layer.Parent then
        return
    end
    local width = self._cachedViewportWidth or 200
    local depthScale = math.random(62, 150) / 100
    local length = (math.random(12, 30) * depthScale + 3) * scale_factor
    local thickness = math.max(1, math.floor((0.8 + depthScale * 0.9) * scale_factor + 0.5))
    local startX = math.random(-58, width + 58)
    local startY = -math.random(30, 180)
    local windSpeed = (math.random(26, 88) * depthScale) * scale_factor
    local fallSpeed = (math.random(270, 560) * depthScale) * scale_factor
    local angle = math.deg(math.atan(fallSpeed / windSpeed)) - 90
    local drop = create("Frame", {
        BorderSizePixel = 0,
        BackgroundColor3 = Color3.fromRGB(176 + math.random(0, 26), 208 + math.random(0, 26), 255),
        BackgroundTransparency = math.random(15, 45) / 100,
        Position = UDim2.new(0, startX, 0, startY),
        Size = UDim2.new(0, thickness, 0, length),
        Rotation = angle,
        ZIndex = depthScale > 1 and 3 or 2,
        Parent = self.snow_layer
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = drop})
    table.insert(self._snowflakes, {
        overlayType = "RainDrop",
        instance = drop,
        xOffset = startX,
        yOffset = startY,
        velocityX = windSpeed,
        velocityY = fallSpeed,
        angle = angle,
        width = thickness,
        length = length,
        baseTransparency = drop.BackgroundTransparency,
        driftSpeed = math.random(11, 24) / 10,
        windJitter = math.random(6, 18) * scale_factor,
        stretchPulse = math.random(16, 30) / 10,
        splashChance = 0.55 + math.random() * 0.25,
        phase = math.random() * math.pi * 2
    })
end

function atom_ui:_SpawnRainSplash(xPosition, yPosition)
    if not self.snow_layer or not self.snow_layer.Parent then
        return
    end
    local startSize = math.random(2, 5) * scale_factor
    local splash = create("Frame", {
        BorderSizePixel = 0,
        BackgroundColor3 = Color3.fromRGB(194 + math.random(0, 20), 224 + math.random(0, 22), 255),
        BackgroundTransparency = math.random(24, 42) / 100,
        Position = UDim2.new(0, xPosition, 0, yPosition),
        Size = UDim2.new(0, startSize, 0, math.max(1 * scale_factor, startSize * 0.5)),
        ZIndex = 3,
        Parent = self.snow_layer
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = splash})
    local life = math.random(8, 14) / 100
    table.insert(self._snowflakes, {
        overlayType = "RainSplash",
        instance = splash,
        baseX = xPosition,
        yOffset = yPosition,
        life = life,
        totalLife = life,
        startSize = startSize,
        startThickness = math.max(1 * scale_factor, startSize * 0.5),
        endSize = math.random(10, 20) * scale_factor,
        driftX = math.random(-14, 14) * scale_factor,
        baseTransparency = splash.BackgroundTransparency
    })
end

function atom_ui:_SpawnStarParticle()
    if not self.snow_layer or not self.snow_layer.Parent then
        return
    end
    local width = self._cachedViewportWidth or 200
    local height = self._cachedViewportHeight or 320
    local size = (math.random(10, 28) / 10) * scale_factor
    local startX = math.random(0, width)
    local startY = math.random(0, height)
    local star = create("ImageLabel", {
        BackgroundTransparency = 1,
        Image = "rbxassetid://3570695787",
        ImageColor3 = Color3.fromRGB(224 + math.random(0, 28), 233 + math.random(0, 20), 255),
        ImageTransparency = math.random(22, 56) / 100,
        Position = UDim2.new(0, startX, 0, startY),
        Size = UDim2.new(0, size, 0, size),
        ZIndex = 3,
        Parent = self.snow_layer
    })
    table.insert(self._snowflakes, {
        overlayType = "Stars",
        instance = star,
        xOffset = startX,
        yOffset = startY,
        velocityX = (math.random(-16, 16) / 10) * scale_factor,
        velocityY = (math.random(-9, 9) / 10) * scale_factor,
        baseSize = size,
        driftAmount = math.random(5, 18) * scale_factor,
        driftLift = math.random(4, 14) * scale_factor,
        driftSpeed = math.random(3, 10) / 10,
        twinkleSpeed = math.random(7, 18) / 10,
        pulseAmount = (math.random(8, 24) / 100),
        baseTransparency = star.ImageTransparency,
        phase = math.random() * math.pi * 2
    })
end

function atom_ui:_SetSnowEnabled(enabled)
    self._uiVisualSettings.Snow = enabled == true
    if self.snow_layer then
        self.snow_layer.Visible = self._uiVisualSettings.Snow and self.is_visible and self._overlayMode ~= "None"
    end
    if not self._uiVisualSettings.Snow or not self.is_visible or self._overlayMode == "None" then
        self._overlayUpdateAccumulator = 0
        self._snowSpawnAccumulator = 0
        self:_ClearSnowflakes()
    end
end

function atom_ui:_SetOverlayMode(mode)
    local normalized = string.lower(tostring(mode or "snow"))
    local resolved = "Snow"
    if normalized == "rain" then
        resolved = "Rain"
    elseif normalized == "stars" or normalized == "star" then
        resolved = "Stars"
    elseif normalized == "none" or normalized == "off" then
        resolved = "None"
    end
    local changed = self._overlayMode ~= resolved
    self._overlayMode = resolved
    if self.overlay_mode_label then
        self.overlay_mode_label.Text = resolved
    end
    if self.snow_layer then
        self.snow_layer.Visible = self.is_visible and self._uiVisualSettings.Snow and resolved ~= "None"
    end
    if changed or resolved == "None" then
        self._overlayUpdateAccumulator = 0
        self._snowSpawnAccumulator = 0
        self:_ClearSnowflakes()
    end
end

function atom_ui:_SetBackgroundEffectsEnabled(enabled)
    self._uiVisualSettings.BackgroundEffects = enabled == true
    if not self._uiVisualSettings.BackgroundEffects then
        self._backgroundFxAccumulator = 0
    end
    if self.bg_effects_frame then
        self.bg_effects_frame.Visible = self._uiVisualSettings.BackgroundEffects
    end
end

function atom_ui:_SetNameHidden(enabled)
    self._uiVisualSettings.HideName = enabled == true
    local hideName = self._uiVisualSettings.HideName == true

    if self.user_name_label then
        self.user_name_label.Visible = not hideName
        if not hideName then
            self.user_name_label.Text = "@" .. tostring(local_player.Name)
        end
    end

    if self._espPreviewHeaderTag then
        self._espPreviewHeaderTag.Visible = not hideName
        if not hideName then
            self._espPreviewHeaderTag.Text = "@" .. tostring(local_player.Name)
        end
    end

    if self._espPreviewPanel then
        self:_UpdateESPPreview(0)
    end
end

function atom_ui:_SetTextGradientEnabled(enabled)
    self._uiVisualSettings.TextGradient = enabled == true
    if not self._uiVisualSettings.TextGradient then
        self._gradientAnimationAccumulator = 0
    end
    local accent = self.config.AccentColor
    local gradientSweepSpeed = 0.9
    local animationTime = tonumber(self._textGradientAnimationTime) or 0
    local sweepX = ((animationTime * gradientSweepSpeed) % 2) - 1
    for i = #self._gradientObjects, 1, -1 do
        self._gradientObjects[i] = nil
    end
    for _, label in ipairs(self._gradientLabels) do
        if label and label.Parent then
            local gradientObj = label:FindFirstChild("AtomUITextGradient")
            if self._uiVisualSettings.TextGradient then
                if not gradientObj then
                    gradientObj = create("UIGradient", {
                        Name = "AtomUITextGradient",
                        Rotation = 0,
                        Parent = label
                    })
                end
                gradientObj.Rotation = 0
                gradientObj.Color = ColorSequence.new({
                    ColorSequenceKeypoint.new(0, accent:Lerp(Color3.new(1, 1, 1), 0.2)),
                    ColorSequenceKeypoint.new(0.55, Color3.new(1, 1, 1)),
                    ColorSequenceKeypoint.new(1, accent:Lerp(Color3.new(1, 1, 1), 0.35))
                })
                gradientObj.Offset = Vector2.new(sweepX, 0)
                table.insert(self._gradientObjects, gradientObj)
            elseif gradientObj then
                gradientObj:Destroy()
            end
        end
    end
end

function atom_ui:_AnimateTextGradients(dt)
    if not self._uiVisualSettings.TextGradient then
        return
    end

    self._gradientAnimationAccumulator = (tonumber(self._gradientAnimationAccumulator) or 0) + (dt or 0)
    if self._gradientAnimationAccumulator < (1 / 30) then
        return
    end
    local resolvedDt = self._gradientAnimationAccumulator
    self._gradientAnimationAccumulator = 0

    local gradientSweepSpeed = 0.9
    self._textGradientAnimationTime = (tonumber(self._textGradientAnimationTime) or 0) + resolvedDt
    local sweepX = ((self._textGradientAnimationTime * gradientSweepSpeed) % 2) - 1
    local animatedOffset = Vector2.new(sweepX, 0)

    for i = #self._gradientObjects, 1, -1 do
        local gradientObj = self._gradientObjects[i]
        if gradientObj and gradientObj.Parent then
            gradientObj.Rotation = 0
            gradientObj.Offset = animatedOffset
        else
            table.remove(self._gradientObjects, i)
        end
    end
end

function atom_ui:_SetCustomBackgroundEnabled(enabled, imageId)
    local useBg = enabled == true
    if self.bg_image_frame then
        self.bg_image_frame.Visible = useBg
    end
    if useBg and self.bg_image_label then
        local img = type(imageId) == "string" and imageId or self.config.BackgroundImage or ""
        if img ~= "" then
            self.bg_image_label.Image = img
        end
        self.bg_image_label.ImageTransparency = self.config.BackgroundTransparency or 0.35
    end
    if self.bg_image_overlay then
        self.bg_image_overlay.BackgroundTransparency = self.config.BackgroundTransparency or 0.45
    end
end

function atom_ui:SetCustomBackground(imageId, transparency)
    self.config.CustomBackground = true
    self.config.BackgroundImage = type(imageId) == "string" and imageId or self.config.BackgroundImage or ""
    if type(transparency) == "number" then
        self.config.BackgroundTransparency = math.clamp(transparency, 0, 1)
    end
    self:_SetCustomBackgroundEnabled(true, self.config.BackgroundImage)
end

function atom_ui:ClearCustomBackground()
    self.config.CustomBackground = false
    self.config.BackgroundImage = ""
    self:_SetCustomBackgroundEnabled(false)
end

function atom_ui:SetBackgroundImage(imageId)
    if type(imageId) == "string" and imageId ~= "" then
        self.config.BackgroundImage = imageId
        self.config.CustomBackground = true
        if self.bg_image_label then
            self.bg_image_label.Image = imageId
        end
        if self.bg_image_frame then
            self.bg_image_frame.Visible = true
        end
    end
end

function atom_ui:SetBackgroundTransparency(transparency)
    self.config.BackgroundTransparency = math.clamp(tonumber(transparency) or 0.35, 0, 1)
    if self.bg_image_label then
        self.bg_image_label.ImageTransparency = self.config.BackgroundTransparency
    end
    if self.bg_image_overlay then
        self.bg_image_overlay.BackgroundTransparency = self.config.BackgroundTransparency
    end
end

function atom_ui:SetFontPreset(index)
    if #self._fontPresets == 0 then
        return
    end
    local normalizedIndex = tonumber(index) or (self._fontPresetIndex + 1)
    if normalizedIndex > #self._fontPresets then
        normalizedIndex = 1
    elseif normalizedIndex < 1 then
        normalizedIndex = #self._fontPresets
    end
    self._fontPresetIndex = normalizedIndex
    local preset = self._fontPresets[self._fontPresetIndex]
    local targetFontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
    if preset.Family then
        local okFont, generatedFont = pcall(function()
            return Font.new(preset.Family, preset.Weight or Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
        end)
        if okFont then
            targetFontFace = generatedFont
        end
    elseif preset.EnumFont then
        pcall(function()
            targetFontFace = Font.fromEnum(preset.EnumFont)
        end)
    end
    if self.screen_gui and self.screen_gui.Parent then
        for _, obj in ipairs(self.screen_gui:GetDescendants()) do
            if obj:IsA("TextLabel") or obj:IsA("TextButton") or obj:IsA("TextBox") then
                if preset.EnumFont then
                    pcall(function()
                        obj.Font = preset.EnumFont
                    end)
                end
                apply_font(obj, targetFontFace, preset.EnumFont or default_font_enum)
            end
        end
    end
    if self.uiSettingsFontValueLabel then
        self.uiSettingsFontValueLabel.Text = preset.Name
    end
end

function atom_ui:_RefreshAccentCore()
    local accent = self.config.AccentColor
    if self._accentTopLine then
        self._accentTopLine.BackgroundColor3 = accent
    end
    if self.toggle_icon then
        self.toggle_icon.ImageColor3 = accent
    end
    if self.bg_accent_glow then
        self.bg_accent_glow.ImageColor3 = accent
    end
    if self.accent_preview then
        self.accent_preview.BackgroundColor3 = accent
    end
    if self.settings_btn_stroke then
        self.settings_btn_stroke.Color = self.settings_open and accent:Lerp(Color3.fromRGB(20, 20, 20), 0.45) or Color3.fromRGB(45, 45, 45)
    end
    if self.floating_toggle then
        self.floating_toggle.ImageColor3 = accent
    end
    if self.active_tab and self.active_tab.button_frame then
        self.active_tab.button_frame.BackgroundColor3 = accent
    end
    if self._scrollbarRefreshers then
        for index = #self._scrollbarRefreshers, 1, -1 do
            local refresher = self._scrollbarRefreshers[index]
            local okRefresh, keepRefresher = pcall(refresher)
            if not okRefresh or keepRefresher == false then
                table.remove(self._scrollbarRefreshers, index)
            end
        end
    end
    self:_SetTextGradientEnabled(self._uiVisualSettings.TextGradient)
end

function atom_ui:_ApplyOpenCloseVisuals(instant)
    self:_SetBlurActive(self.is_visible, instant)
    if self.backdrop_dim then
        local targetTransparency = (self.is_visible and self._uiVisualSettings.Blur) and 0.55 or 1
        if instant then
            self.backdrop_dim.BackgroundTransparency = targetTransparency
        else
            tween_to(self.backdrop_dim, {
                BackgroundTransparency = targetTransparency
            }, 0.28, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
        end
    end
    if self.snow_layer then
        self.snow_layer.Visible = self.is_visible and self._uiVisualSettings.Snow and self._overlayMode ~= "None"
    end
    if not self.is_visible or not self._uiVisualSettings.Snow or self._overlayMode == "None" then
        self._overlayUpdateAccumulator = 0
        self._snowSpawnAccumulator = 0
        self:_ClearSnowflakes()
    end
    self:_UpdateESPPreview(0)
end

local function pull_preview_value(sourceTable, keys)
    if type(sourceTable) ~= "table" then
        return nil
    end
    for _, key in ipairs(keys) do
        local value = sourceTable[key]
        if value ~= nil then
            return value
        end
    end
    return nil
end

local function flowPreviewToBool(value)
    if type(value) == "boolean" then
        return value
    end
    if type(value) == "number" then
        return value ~= 0
    end
    if type(value) == "string" then
        local normalized = string.lower(value)
        if normalized == "true" or normalized == "on" or normalized == "enabled" or normalized == "yes" or normalized == "1" then
            return true
        end
        if normalized == "false" or normalized == "off" or normalized == "disabled" or normalized == "no" or normalized == "0" then
            return false
        end
    end
    return nil
end

local function flowPreviewToColor3(value)
    if typeof(value) == "Color3" then
        return value
    end
    if type(value) ~= "table" then
        return nil
    end
    local r = value.r or value.R or value[1]
    local g = value.g or value.G or value[2]
    local b = value.b or value.B or value[3]
    if type(r) ~= "number" or type(g) ~= "number" or type(b) ~= "number" then
        return nil
    end
    if r > 1 or g > 1 or b > 1 then
        r, g, b = r / 255, g / 255, b / 255
    end
    return Color3.new(math.clamp(r, 0, 1), math.clamp(g, 0, 1), math.clamp(b, 0, 1))
end

local flowPreviewCoreBodyParts = {
    Head = true,
    UpperTorso = true,
    LowerTorso = true,
    Torso = true,
    LeftUpperArm = true,
    LeftLowerArm = true,
    LeftHand = true,
    RightUpperArm = true,
    RightLowerArm = true,
    RightHand = true,
    LeftUpperLeg = true,
    LeftLowerLeg = true,
    LeftFoot = true,
    RightUpperLeg = true,
    RightLowerLeg = true,
    RightFoot = true,
    ["Left Arm"] = true,
    ["Right Arm"] = true,
    ["Left Leg"] = true,
    ["Right Leg"] = true
}

local flowPreviewBoundingCornerSigns = {
    Vector3.new(-1, -1, -1),
    Vector3.new(-1, -1, 1),
    Vector3.new(-1, 1, -1),
    Vector3.new(-1, 1, 1),
    Vector3.new(1, -1, -1),
    Vector3.new(1, -1, 1),
    Vector3.new(1, 1, -1),
    Vector3.new(1, 1, 1)
}

local function getModelBoundingBoxSafe(model)
    if not model or not model.Parent then
        return nil, nil
    end
    local okBounds, boundsCF, boundsSize = pcall(function()
        return model:GetBoundingBox()
    end)
    if okBounds and typeof(boundsCF) == "CFrame" and typeof(boundsSize) == "Vector3" and boundsSize.Magnitude > 0 then
        return boundsCF, boundsSize
    end
    return nil, nil
end

function atom_ui:SetESPProvider(providerFn)
    if providerFn ~= nil and type(providerFn) ~= "function" then
        return false, "ESP preview provider must be a function or nil."
    end
    self._espPreviewProvider = providerFn
    self._espPreviewResolveAccumulator = 0.2
    return true
end

function atom_ui:SetESPData(previewData)
    if previewData ~= nil and type(previewData) ~= "table" then
        return false, "ESP preview data must be a table or nil."
    end
    self._espPreviewData = previewData
    self._espPreviewResolveAccumulator = 0.2
    return true
end

function atom_ui:SetESPPreview(enabled)
    self._uiVisualSettings.ESPSelfPreview = enabled == true
    if not self._uiVisualSettings.ESPSelfPreview then
        self._espPreviewWasShowing = false
        self._espPreviewUpdateAccumulator = 0
        self:_DestroyESPPreviewCharacter()
    else
        self:_InvalidateESPPreviewProjection(true)
    end
    self:_UpdateESPPreview(0)
end

function atom_ui:_ResolveESPPreviewWalkAnimationId(sourceCharacter)
    if not sourceCharacter then
        return nil
    end
    local animateScript = sourceCharacter:FindFirstChild("Animate")
    if animateScript then
        local preferredFolders = {"walk", "run"}
        for _, folderName in ipairs(preferredFolders) do
            local folder = animateScript:FindFirstChild(folderName)
            if folder then
                local directAnimation = folder:FindFirstChildWhichIsA("Animation")
                if directAnimation and type(directAnimation.AnimationId) == "string" and directAnimation.AnimationId ~= "" then
                    return directAnimation.AnimationId
                end
                for _, child in ipairs(folder:GetDescendants()) do
                    if child:IsA("Animation") and type(child.AnimationId) == "string" and child.AnimationId ~= "" then
                        return child.AnimationId
                    end
                end
            end
        end
        for _, child in ipairs(animateScript:GetDescendants()) do
            if child:IsA("Animation") then
                local childName = string.lower(child.Name or "")
                if (string.find(childName, "walk", 1, true) or string.find(childName, "run", 1, true))
                    and type(child.AnimationId) == "string"
                    and child.AnimationId ~= "" then
                    return child.AnimationId
                end
            end
        end
    end
    return nil
end

function atom_ui:_StartESPPreviewWalkAnimation(sourceCharacter)
    if self._espPreviewStaticMode then
        if self._espPreviewWalkTrack then
            pcall(function()
                self._espPreviewWalkTrack:Stop(0.1)
            end)
            pcall(function()
                self._espPreviewWalkTrack:Destroy()
            end)
            self._espPreviewWalkTrack = nil
        end
        self._espPreviewAnimationId = nil
        return
    end
    if not self._espPreviewCharacter or not self._espPreviewCharacter.Parent then
        return
    end
    if self._espPreviewWalkTrack and self._espPreviewWalkTrack.IsPlaying and self._espPreviewAnimationId then
        pcall(function()
            self._espPreviewWalkTrack:AdjustSpeed(0.95)
        end)
        return
    end
    local previewHumanoid = self._espPreviewCharacter:FindFirstChildOfClass("Humanoid")
    if not previewHumanoid then
        return
    end
    local resolvedId = self:_ResolveESPPreviewWalkAnimationId(sourceCharacter)
    if not resolvedId then
        return
    end
    if self._espPreviewWalkTrack and self._espPreviewAnimationId ~= resolvedId then
        pcall(function()
            self._espPreviewWalkTrack:Stop(0.1)
        end)
        pcall(function()
            self._espPreviewWalkTrack:Destroy()
        end)
        self._espPreviewWalkTrack = nil
    end

    local animator = previewHumanoid:FindFirstChildOfClass("Animator")
    if not animator then
        animator = Instance.new("Animator")
        animator.Parent = previewHumanoid
    end
    if not self._espPreviewWalkTrack then
        local walkAnimation = Instance.new("Animation")
        walkAnimation.AnimationId = resolvedId
        local okTrack, track = pcall(function()
            return animator:LoadAnimation(walkAnimation)
        end)
        walkAnimation:Destroy()
        if not okTrack or not track then
            return
        end
        track.Looped = true
        self._espPreviewWalkTrack = track
        self._espPreviewAnimationId = resolvedId
    end
    if self._espPreviewWalkTrack and not self._espPreviewWalkTrack.IsPlaying then
        pcall(function()
            self._espPreviewWalkTrack:Play(0.15, 1, 1)
        end)
    end
    if self._espPreviewWalkTrack then
        pcall(function()
            self._espPreviewWalkTrack:AdjustSpeed(0.95)
        end)
    end
end

function atom_ui:_CreateESPPreviewFallbackCharacter()
    local fallbackModel = nil
    local created = false
    local previewUserId, previewImageUrl = resolve_avatar_3d(local_player.UserId)
    self._espPreviewAvatar3DUserId = previewUserId
    self._espPreviewAvatar3DImageUrl = previewImageUrl

    local okCreate = pcall(function()
        fallbackModel = players:CreateHumanoidModelFromUserId(previewUserId)
    end)
    if not okCreate or not fallbackModel then
        local okDescription, humanoidDescription = pcall(function()
            return players:GetHumanoidDescriptionFromUserId(previewUserId)
        end)
        if okDescription and humanoidDescription then
            pcall(function()
                fallbackModel = players:CreateHumanoidModelFromDescription(humanoidDescription, Enum.HumanoidRigType.R15)
                created = true
            end)
        end
    end
    if fallbackModel then
        fallbackModel.Name = "FlowESPSelfPreviewAvatar"
        if created and not fallbackModel:FindFirstChildOfClass("Humanoid") then
            fallbackModel:Destroy()
            return nil
        end
    end
    return fallbackModel
end

function atom_ui:_DestroyESPPreviewCharacter()
    if self._espPreviewWalkTrack then
        pcall(function()
            self._espPreviewWalkTrack:Stop(0.1)
        end)
        pcall(function()
            self._espPreviewWalkTrack:Destroy()
        end)
    end
    self._espPreviewWalkTrack = nil
    self._espPreviewAnimationId = nil
    if self._espPreviewHighlight then
        self._espPreviewHighlight.Adornee = nil
        self._espPreviewHighlight.Enabled = false
    end
    self._espPreviewPartDefaults = {}
    self._espPreviewHeadPart = nil
    self._espPreviewRootPart = nil
    self._espPreviewVisualState = nil
    self._espPreviewVisualDirty = false
    self._espPreviewProjectionCache = nil
    self._espPreviewProjectionDirty = true
    if self._espPreviewCharacter and self._espPreviewCharacter.Parent then
        self._espPreviewCharacter:Destroy()
    end
    self._espPreviewCharacter = nil
    self._espPreviewLastCharacter = nil
    self._espPreviewPivotYOffset = -2
end

function atom_ui:_EnsureESPPreviewCharacter()
    if not self._espPreviewWorldModel then
        return
    end
    local liveCharacter = local_player.Character
    if self._espPreviewCharacter and self._espPreviewCharacter.Parent then
        if liveCharacter and self._espPreviewLastCharacter == liveCharacter then
            return
        end
        if not liveCharacter and self._espPreviewLastCharacter == false then
            return
        end
    end
    self:_DestroyESPPreviewCharacter()

    local function cloneFromLiveCharacter()
        if not liveCharacter then
            return nil
        end
        local previousArchivable = liveCharacter.Archivable
        local cloneCharacter = nil
        local clonedOk = pcall(function()
            liveCharacter.Archivable = true
            cloneCharacter = liveCharacter:Clone()
        end)
        pcall(function()
            liveCharacter.Archivable = previousArchivable
        end)
        if not clonedOk then
            return nil
        end
        return cloneCharacter
    end

    local function preparePreviewCharacter(model)
        if not model then
            return false
        end
        self._espPreviewPartDefaults = {}
        local rootPart = model:FindFirstChild("HumanoidRootPart")
            or model:FindFirstChild("UpperTorso")
            or model:FindFirstChild("Torso")
        local corePartCount = 0
        local visibleCorePartCount = 0
        local visiblePartCount = 0
        for _, obj in ipairs(model:GetDescendants()) do
            if obj:IsA("Script") or obj:IsA("LocalScript") then
                obj:Destroy()
            elseif obj:IsA("BasePart") then
                local isRootPart = obj.Name == "HumanoidRootPart"
                local isCoreBodyPart = flowPreviewCoreBodyParts[obj.Name] == true
                local sanitizedTransparency = math.clamp(tonumber(obj.Transparency) or 0, 0, 1)
                if isRootPart then
                    sanitizedTransparency = 1
                elseif isCoreBodyPart and sanitizedTransparency >= 0.98 then
                    sanitizedTransparency = 0
                end
                self._espPreviewPartDefaults[obj] = {
                    Color = obj.Color,
                    Material = obj.Material,
                    Transparency = sanitizedTransparency
                }
                obj.Transparency = sanitizedTransparency
                pcall(function()
                    obj.LocalTransparencyModifier = 0
                end)
                if isRootPart then
                    pcall(function()
                        obj.LocalTransparencyModifier = 1
                    end)
                end
                obj.CanCollide = false
                pcall(function()
                    obj.CanQuery = false
                end)
                pcall(function()
                    obj.CanTouch = false
                end)
                obj.Massless = true
                obj.CastShadow = false
                if rootPart == nil then
                    rootPart = obj
                end
                obj.Anchored = obj == rootPart

                if sanitizedTransparency < 0.985 and obj.Size.Magnitude > 0.05 then
                    visiblePartCount = visiblePartCount + 1
                end
                if isCoreBodyPart then
                    corePartCount = corePartCount + 1
                    if sanitizedTransparency < 0.985 then
                        visibleCorePartCount = visibleCorePartCount + 1
                    end
                end
            end
        end

        local headPart = model:FindFirstChild("Head")
            or model:FindFirstChild("UpperTorso")
            or model:FindFirstChild("Torso")
            or rootPart

        if corePartCount > 0 and visibleCorePartCount < math.min(4, corePartCount) then
            for part, originalData in pairs(self._espPreviewPartDefaults) do
                if part and part.Parent and originalData and flowPreviewCoreBodyParts[part.Name] then
                    originalData.Transparency = 0
                    part.Transparency = 0
                end
            end
            visibleCorePartCount = math.max(visibleCorePartCount, math.min(4, corePartCount))
        end

        if visiblePartCount < 6 then
            for _, obj in ipairs(model:GetDescendants()) do
                if obj:IsA("BasePart") and obj.Transparency >= 0.98 and obj.Name ~= "HumanoidRootPart" then
                    local originalData = self._espPreviewPartDefaults[obj]
                    if originalData then
                        originalData.Transparency = 0
                    end
                    obj.Transparency = 0
                end
            end
            visiblePartCount = 6
        end

        self._espPreviewHeadPart = headPart
        self._espPreviewRootPart = rootPart or headPart
        self._espPreviewVisualDirty = true
        self:_InvalidateESPPreviewProjection(true)
        if rootPart then
            pcall(function()
                model.PrimaryPart = rootPart
            end)
        end

        if corePartCount > 0 and corePartCount < 3 then
            return false
        end
        if corePartCount >= 3 and visibleCorePartCount < 3 then
            return false
        end
        return visiblePartCount >= 6
    end

    local previewCharacter = self:_CreateESPPreviewFallbackCharacter()
    local hasReliableAvatar = preparePreviewCharacter(previewCharacter)
    if not hasReliableAvatar and previewCharacter and previewCharacter.Parent == nil then
        previewCharacter:Destroy()
        previewCharacter = nil
    end

    if not previewCharacter then
        previewCharacter = cloneFromLiveCharacter()
        local hasReliableClone = preparePreviewCharacter(previewCharacter)
        if not hasReliableClone and previewCharacter and previewCharacter.Parent == nil then
            previewCharacter:Destroy()
            previewCharacter = nil
        end
    end
    if not previewCharacter then
        return
    end

    previewCharacter.Parent = self._espPreviewWorldModel
    local previewHumanoid = previewCharacter:FindFirstChildOfClass("Humanoid")
    if previewHumanoid then
        previewHumanoid.AutoRotate = false
        previewHumanoid.PlatformStand = false
        pcall(function()
            previewHumanoid.BreakJointsOnDeath = false
        end)
    end
    local previewExtents = Vector3.new(4, 6, 3)
    local okPreviewExtents, calculatedPreviewExtents = pcall(function()
        return previewCharacter:GetExtentsSize()
    end)
    if okPreviewExtents and calculatedPreviewExtents then
        previewExtents = calculatedPreviewExtents
    end
    local pivotYOffset = self._espPreviewStaticMode and 0 or -math.clamp(previewExtents.Y * 0.43, 1.2, 3.2)
    self._espPreviewPivotYOffset = pivotYOffset
    local allowPreviewRotate = self._espPreviewAllowManualRotation == true
    local initialYaw = (self._espPreviewStaticMode and not allowPreviewRotate) and math.rad(180) or (tonumber(self._espPreviewRotationYaw) or tonumber(self._espPreviewRotationTargetYaw) or math.rad(180))
    self._espPreviewRotationYaw = initialYaw
    self._espPreviewRotationTargetYaw = initialYaw
    pcall(function()
        previewCharacter:PivotTo(CFrame.new(0, pivotYOffset, 0) * CFrame.Angles(0, initialYaw, 0))
    end)
    self._espPreviewCharacter = previewCharacter
    self._espPreviewLastCharacter = liveCharacter or false
    if self._espPreviewHighlight then
        self._espPreviewHighlight.Adornee = previewCharacter
    end

    if self._espPreviewCamera then
        if self._espPreviewStaticMode then
            self._espPreviewCamera.FieldOfView = 30
            local boundsCF, boundsSize = getModelBoundingBoxSafe(previewCharacter)
            if boundsCF and boundsSize then
                local boundsCenter = boundsCF.Position
                local viewportSize = self._espPreviewViewport and self._espPreviewViewport.AbsoluteSize or Vector2.new(1, 1)
                local aspectRatio = math.max(0.5, viewportSize.X / math.max(1, viewportSize.Y))
                local verticalHalfFov = math.rad(self._espPreviewCamera.FieldOfView) * 0.5
                local horizontalHalfFov = math.atan(math.tan(verticalHalfFov) * aspectRatio)
                local fitDepthY = (boundsSize.Y * 0.5) / math.max(0.001, math.tan(verticalHalfFov))
                local fitDepthX = (boundsSize.X * 0.5) / math.max(0.001, math.tan(horizontalHalfFov))
                local depth = math.max(fitDepthX, fitDepthY) + boundsSize.Z * 0.92 + 1.25
                depth = math.clamp(depth, 7.2, 16.2)
                local focus = boundsCenter + Vector3.new(0, math.clamp(boundsSize.Y * 0.03, -0.08, 0.25), 0)
                self._espPreviewCamera.CFrame = CFrame.new(focus + Vector3.new(0, math.clamp(boundsSize.Y * 0.03, -0.08, 0.35), depth), focus)
            else
                local fallbackFocus = Vector3.new(0, 0.45, 0)
                self._espPreviewCamera.CFrame = CFrame.new(Vector3.new(0, fallbackFocus.Y, 9.2), fallbackFocus)
            end
        else
            local focus = Vector3.new(0, math.clamp(previewExtents.Y * 0.36, 1.2, 2.45), 0)
            local depth = math.clamp(math.max(6.8, previewExtents.Y * 1.05 + previewExtents.X * 0.65), 6.8, 18)
            self._espPreviewCamera.FieldOfView = 32
            self._espPreviewCamera.CFrame = CFrame.new(Vector3.new(0, focus.Y, depth), focus)
        end
    end
    if not self._espPreviewStaticMode then
        self:_StartESPPreviewWalkAnimation(liveCharacter)
    end
end

function atom_ui:_CreateESPPreviewPanel()
    if self._espPreviewPanel and self._espPreviewPanel.Parent then
        return
    end
    if not self.screen_gui or not self.screen_gui.Parent then
        return
    end

    local panelWidth = 226 * scale_factor
    local panelHeight = 296 * scale_factor
    local defaultPanelPosition = UDim2.new(0, 14 * scale_factor, 0, 66 * scale_factor)
    if self.main_frame and self.main_frame.Parent then
        local mainPos = self.main_frame.Position
        defaultPanelPosition = UDim2.new(
            mainPos.X.Scale,
            mainPos.X.Offset - panelWidth - 12 * scale_factor,
            mainPos.Y.Scale,
            mainPos.Y.Offset + 42 * scale_factor
        )
    end
    local panel = create("Frame", {
        Name = "FlowESPSelfPreviewPanel",
        BackgroundColor3 = Color3.fromRGB(14, 14, 16),
        BackgroundTransparency = 0.06,
        BorderSizePixel = 0,
        Position = defaultPanelPosition,
        Size = UDim2.new(0, panelWidth, 0, panelHeight),
        Visible = false,
        ZIndex = 30,
        Parent = self.screen_gui
    })
    create("UICorner", {CornerRadius = UDim.new(0, 10), Parent = panel})
    create("UIStroke", {Color = Color3.fromRGB(40, 40, 44), Thickness = 1.1, Parent = panel})
    create("UIGradient", {
        Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Color3.fromRGB(20, 20, 24)),
            ColorSequenceKeypoint.new(1, Color3.fromRGB(12, 12, 14))
        }),
        Rotation = 90,
        Parent = panel
    })
    local panelDragHandle = create("TextButton", {
        Name = "ESPPreviewDragHandle",
        Text = "",
        AutoButtonColor = false,
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 0, 0, 0),
        Size = UDim2.new(1, 0, 0, 24 * scale_factor),
        Active = true,
        ZIndex = 36,
        Parent = panel
    })

    create("TextLabel", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 10 * scale_factor, 0, 8 * scale_factor),
        Size = UDim2.new(0, 110 * scale_factor, 0, 16 * scale_factor),
        Text = "ESP Preview",
        TextXAlignment = Enum.TextXAlignment.Left,
        TextColor3 = Color3.fromRGB(240, 240, 240),
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold, Enum.FontStyle.Normal),
        TextSize = 13 * scale_factor,
        ZIndex = 31,
        Parent = panel
    })

    self._espPreviewHeaderTag = create("TextLabel", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0.42, 0, 0, 8 * scale_factor),
        Size = UDim2.new(0.58, -8 * scale_factor, 0, 16 * scale_factor),
        Text = "@" .. tostring(local_player.Name),
        TextXAlignment = Enum.TextXAlignment.Right,
        TextColor3 = Color3.fromRGB(156, 156, 164),
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal),
        TextSize = 12 * scale_factor,
        TextTruncate = Enum.TextTruncate.AtEnd,
        ZIndex = 31,
        Parent = panel
    })

    local card = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(11, 11, 13),
        BorderSizePixel = 0,
        Position = UDim2.new(0, 8 * scale_factor, 0, 28 * scale_factor),
        Size = UDim2.new(1, -16 * scale_factor, 1, -34 * scale_factor),
        ZIndex = 30,
        Parent = panel
    })
    create("UICorner", {CornerRadius = UDim.new(0, 8), Parent = card})
    create("UIStroke", {Color = Color3.fromRGB(33, 33, 37), Parent = card})

    local viewport = create("ViewportFrame", {
        BackgroundColor3 = Color3.fromRGB(15, 15, 18),
        BackgroundTransparency = 0.08,
        Position = UDim2.new(0, 6 * scale_factor, 0, 6 * scale_factor),
        Size = UDim2.new(1, -12 * scale_factor, 1, -44 * scale_factor),
        Active = true,
        LightColor = Color3.new(1, 1, 1),
        LightDirection = Vector3.new(-0.34, -1, -0.22),
        Ambient = Color3.fromRGB(122, 122, 130),
        ZIndex = 31,
        Parent = card
    })
    create("UICorner", {CornerRadius = UDim.new(0, 7), Parent = viewport})
    local worldModel = create("WorldModel", {Parent = viewport})
    local camera = create("Camera", {
        CFrame = CFrame.new(Vector3.new(0, 1.4, 7.2), Vector3.new(0, 1.2, 0)),
        Parent = viewport
    })
    viewport.CurrentCamera = camera

    local rotateCapture = create("TextButton", {
        Name = "ESPPreviewRotateCapture",
        Text = "",
        AutoButtonColor = false,
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 0, 0, 0),
        Size = UDim2.new(1, 0, 1, 0),
        Active = self._espPreviewAllowManualRotation == true,
        Selectable = false,
        ZIndex = 35,
        Parent = viewport
    })

    self._espPreviewBox = create("Frame", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0.18, 0, 0.07, 0),
        Size = UDim2.new(0.64, 0, 0.84, 0),
        Visible = false,
        ZIndex = 33,
        Parent = viewport
    })
    self._espPreviewBoxStroke = create("UIStroke", {
        Color = self.config.AccentColor,
        Thickness = 1.5,
        Parent = self._espPreviewBox
    })

    self._espPreviewHealthTrack = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(28, 28, 32),
        BorderSizePixel = 0,
        Position = UDim2.new(0.15, 0, 0.07, 0),
        Size = UDim2.new(0, 3 * scale_factor, 0.84, 0),
        Visible = false,
        ZIndex = 33,
        Parent = viewport
    })
    self._espPreviewHealthFill = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(100, 255, 100),
        BorderSizePixel = 0,
        AnchorPoint = Vector2.new(0, 1),
        Position = UDim2.new(0, 0, 1, 0),
        Size = UDim2.new(1, 0, 1, 0),
        ZIndex = 34,
        Parent = self._espPreviewHealthTrack
    })

    self._espPreviewDot = create("Frame", {
        BackgroundColor3 = self.config.AccentColor,
        BorderSizePixel = 0,
        Position = UDim2.new(0.5, -3 * scale_factor, 0.27, -3 * scale_factor),
        Size = UDim2.new(0, 6 * scale_factor, 0, 6 * scale_factor),
        Visible = false,
        ZIndex = 34,
        Parent = viewport
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = self._espPreviewDot})

    self._espPreviewTracer = create("Frame", {
        BackgroundColor3 = self.config.AccentColor,
        BorderSizePixel = 0,
        AnchorPoint = Vector2.new(0.5, 1),
        Position = UDim2.new(0.5, -1 * scale_factor, 0.58, 0),
        Size = UDim2.new(0, 2 * scale_factor, 0.34, 0),
        Visible = false,
        ZIndex = 33,
        Parent = viewport
    })

    self._espPreviewName = create("TextLabel", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 0, 0, 1 * scale_factor),
        Size = UDim2.new(1, 0, 0, 15 * scale_factor),
        Text = tostring(local_player.Name),
        TextColor3 = self.config.AccentColor,
        TextXAlignment = Enum.TextXAlignment.Center,
        TextTruncate = Enum.TextTruncate.AtEnd,
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold, Enum.FontStyle.Normal),
        TextSize = 11 * scale_factor,
        Visible = false,
        ZIndex = 34,
        Parent = viewport
    })

    self._espPreviewDistance = create("TextLabel", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 0, 1, -18 * scale_factor),
        Size = UDim2.new(1, 0, 0, 14 * scale_factor),
        Text = "0m",
        TextColor3 = Color3.fromRGB(186, 186, 192),
        TextXAlignment = Enum.TextXAlignment.Center,
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal),
        TextSize = 11 * scale_factor,
        Visible = false,
        ZIndex = 34,
        Parent = card
    })

    self._espPreviewItem = create("TextLabel", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 0, 1, -32 * scale_factor),
        Size = UDim2.new(1, 0, 0, 14 * scale_factor),
        Text = "None",
        TextColor3 = Color3.fromRGB(206, 206, 212),
        TextXAlignment = Enum.TextXAlignment.Center,
        TextTruncate = Enum.TextTruncate.AtEnd,
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal),
        TextSize = 11 * scale_factor,
        Visible = false,
        ZIndex = 34,
        Parent = card
    })

    self._espPreviewHighlight = create("Highlight", {
        Enabled = false,
        DepthMode = Enum.HighlightDepthMode.AlwaysOnTop,
        Parent = worldModel
    })

    self._espPreviewPanel = panel
    self._espPreviewViewport = viewport
    self._espPreviewWorldModel = worldModel
    self._espPreviewCamera = camera
    self._espPreviewRotateCapture = rotateCapture
    self:_TrackConnection(viewport:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
        self:_InvalidateESPPreviewProjection(false)
    end))

    if self._espPreviewAllowManualRotation == true then
        local function stopESPPreviewRotate()
            self._espPreviewIsRotating = false
            self._espPreviewRotateInput = nil
        end

        self:_TrackConnection(rotateCapture.InputBegan:Connect(function(input)
            local isMouse = input.UserInputType == Enum.UserInputType.MouseButton1
            local isTouch = input.UserInputType == Enum.UserInputType.Touch
            if not isMouse and not isTouch then
                return
            end
            self._espPreviewIsRotating = true
            self._espPreviewRotateInput = isTouch and input or nil
            self._espPreviewRotateLastX = input.Position.X
        end))

        self:_TrackConnection(rotateCapture.InputEnded:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.MouseButton1 then
                stopESPPreviewRotate()
                return
            end
            if input.UserInputType == Enum.UserInputType.Touch and (self._espPreviewRotateInput == nil or input == self._espPreviewRotateInput) then
                stopESPPreviewRotate()
            end
        end))

        self:_TrackConnection(input_service.InputChanged:Connect(function(input)
            if not self._espPreviewIsRotating then
                return
            end
            local isMouseMove = input.UserInputType == Enum.UserInputType.MouseMovement and self._espPreviewRotateInput == nil
            local isTouchMove = input.UserInputType == Enum.UserInputType.Touch and (self._espPreviewRotateInput == nil or input == self._espPreviewRotateInput)
            if not isMouseMove and not isTouchMove then
                return
            end

            local previousX = tonumber(self._espPreviewRotateLastX) or input.Position.X
            local deltaX = input.Position.X - previousX
            self._espPreviewRotateLastX = input.Position.X

            local rotationSensitivity = is_mobile and 0.02 or 0.015
            self._espPreviewRotationTargetYaw = (tonumber(self._espPreviewRotationTargetYaw) or math.rad(180)) - deltaX * rotationSensitivity
        end))

        self:_TrackConnection(input_service.InputEnded:Connect(function(input)
            if not self._espPreviewIsRotating then
                return
            end
            if input.UserInputType == Enum.UserInputType.MouseButton1 then
                stopESPPreviewRotate()
                return
            end
            if input.UserInputType == Enum.UserInputType.Touch and (self._espPreviewRotateInput == nil or input == self._espPreviewRotateInput) then
                stopESPPreviewRotate()
            end
        end))
    else
        self._espPreviewIsRotating = false
        self._espPreviewRotateInput = nil
        self._espPreviewRotateLastX = 0
    end

    make_draggable(panel, panelDragHandle, self)
    self:_EnsureESPPreviewCharacter()
    self:_UpdateESPPreview(0)
end

function atom_ui:_ResolveESPPreviewState()
    local state = {
        Enabled = true,
        ShowBox = false,
        ShowHealth = false,
        ShowName = false,
        UseDisplayName = false,
        ShowItem = false,
        ShowDistance = false,
        ShowTracers = false,
        ShowDot = false,
        ShowChams = false,
        ShowHighlight = false,
        ChamsTransparency = 0.55,
        HighlightFillTransparency = 0.5,
        HighlightOutlineTransparency = 0,
        Color = self.config.AccentColor,
        Name = tostring(local_player.Name),
        Item = "None",
        DistanceText = "0m",
        HealthPercent = 1
    }

    local liveCharacter = local_player.Character
    local liveHumanoid = liveCharacter and liveCharacter:FindFirstChildOfClass("Humanoid")
    if liveHumanoid and liveHumanoid.MaxHealth > 0 then
        state.HealthPercent = math.clamp(liveHumanoid.Health / liveHumanoid.MaxHealth, 0, 1)
    end
    if liveCharacter then
        for _, tool in ipairs(liveCharacter:GetChildren()) do
            if tool:IsA("Tool") then
                state.Item = tool.Name
                break
            end
        end
        local localRoot = liveCharacter:FindFirstChild("HumanoidRootPart")
        local cameraRef = workspace.CurrentCamera
        if localRoot and cameraRef then
            state.DistanceText = string.format("%.0fm", (cameraRef.CFrame.Position - localRoot.Position).Magnitude)
        end
    end

    local function applyStateFromTrackedControls()
        local touched = false
        for flagName, control in pairs(self._trackedControls) do
            if type(control) == "table" and type(control.get) == "function" then
                local okValue, controlValue = pcall(control.get)
                if okValue then
                    local rawFlag = string.lower(tostring(flagName or ""))
                    local compactFlag = rawFlag:gsub("[^%w]", "")
                    local function hasFlagToken(...)
                        local tokens = {...}
                        for _, token in ipairs(tokens) do
                            local rawToken = string.lower(tostring(token))
                            local compactToken = rawToken:gsub("[^%w]", "")
                            if rawToken ~= "" and string.find(rawFlag, rawToken, 1, true) then
                                return true
                            end
                            if compactToken ~= "" and string.find(compactFlag, compactToken, 1, true) then
                                return true
                            end
                        end
                        return false
                    end
                    local boolValue = flowPreviewToBool(controlValue)
                    if boolValue ~= nil then
                        if hasFlagToken("esp enabled", "espenabled", "esp toggle", "toggle esp", "enable esp") then
                            state.Enabled = boolValue
                            touched = true
                        elseif hasFlagToken("show box", "showbox", "box esp", "boxes") then
                            state.ShowBox = boolValue
                            touched = true
                        elseif hasFlagToken("show health", "health bar", "healthesp", "showhealth") then
                            state.ShowHealth = boolValue
                            touched = true
                        elseif hasFlagToken("show name", "name esp", "nametag", "showname") then
                            state.ShowName = boolValue
                            touched = true
                        elseif hasFlagToken("display name", "usedisplayname") then
                            state.UseDisplayName = boolValue
                            touched = true
                        elseif hasFlagToken("show equipped item", "show item", "show weapon", "item esp", "tool esp") then
                            state.ShowItem = boolValue
                            touched = true
                        elseif hasFlagToken("show distance", "distance esp", "showdistance") then
                            state.ShowDistance = boolValue
                            touched = true
                        elseif hasFlagToken("show tracers", "tracers", "tracer esp") then
                            state.ShowTracers = boolValue
                            touched = true
                        elseif hasFlagToken("show dot", "dot esp", "head dot", "headdot") then
                            state.ShowDot = boolValue
                            touched = true
                        elseif hasFlagToken("chams enabled", "chams", "use chams") then
                            state.ShowChams = boolValue
                            touched = true
                        elseif hasFlagToken("highlight enabled", "use highlight", "highlight") then
                            state.ShowHighlight = boolValue
                            touched = true
                        end
                    elseif typeof(controlValue) == "Color3" then
                        if hasFlagToken("esp color", "visual color", "highlight color", "chams color", "espcolour", "visualcolour") then
                            state.Color = controlValue
                            touched = true
                        end
                    elseif type(controlValue) == "number" then
                        if hasFlagToken("chams transparency", "cham transparency") then
                            state.ChamsTransparency = math.clamp(controlValue, 0, 1)
                            touched = true
                        elseif hasFlagToken("fill transparency", "highlight fill transparency") then
                            state.HighlightFillTransparency = math.clamp(controlValue, 0, 1)
                            touched = true
                        elseif hasFlagToken("outline transparency", "highlight outline transparency") then
                            state.HighlightOutlineTransparency = math.clamp(controlValue, 0, 1)
                            touched = true
                        end
                    end
                end
            end
        end
        return touched
    end

    local function applyStateFrom(sourceTable)
        if type(sourceTable) ~= "table" then
            return false
        end
        local touched = false
        local function setBoolField(targetField, keys)
            local rawValue = pull_preview_value(sourceTable, keys)
            local boolValue = flowPreviewToBool(rawValue)
            if boolValue ~= nil then
                state[targetField] = boolValue
                touched = true
            end
        end
        local function setNumberField(targetField, keys, minValue, maxValue)
            local rawValue = pull_preview_value(sourceTable, keys)
            if type(rawValue) == "number" then
                state[targetField] = math.clamp(rawValue, minValue, maxValue)
                touched = true
            end
        end

        setBoolField("Enabled", {"ESPEnabled", "Enabled", "ESP", "MasterEnabled", "MasterSwitch"})
        setBoolField("ShowBox", {"ShowBox", "Boxes", "Box", "BoxESP"})
        setBoolField("ShowHealth", {"ShowHealth", "Health", "HealthBar", "HealthESP"})
        setBoolField("ShowName", {"ShowName", "Names", "NameESP", "Nametags"})
        setBoolField("UseDisplayName", {"UseDisplayName", "DisplayName", "DisplayNames"})
        setBoolField("ShowItem", {"ShowEquippedItem", "ShowItem", "ItemESP", "ShowWeapon", "ShowTool"})
        setBoolField("ShowDistance", {"ShowDistance", "Distance", "DistanceESP"})
        setBoolField("ShowTracers", {"ShowTracers", "Tracers", "TracerESP"})
        setBoolField("ShowDot", {"ShowDot", "Dot", "DotESP", "HeadDot"})
        setBoolField("ShowChams", {"ChamsEnabled", "Chams", "UseChams", "CharacterMaterial"})
        setBoolField("ShowHighlight", {"HighlightEnabled", "Highlight", "UseHighlight"})

        setNumberField("ChamsTransparency", {"ChamsTransparency", "ChamTransparency", "ChamsAlpha"}, 0, 1)
        setNumberField("HighlightFillTransparency", {"HighlightFillTransparency", "HighlightFillAlpha"}, 0, 1)
        setNumberField("HighlightOutlineTransparency", {"HighlightOutlineTransparency", "HighlightOutlineAlpha"}, 0, 1)

        local colorValue = flowPreviewToColor3(pull_preview_value(sourceTable, {
            "VisualColor", "ESPColor", "Color", "Colour", "MainColor", "ChamsColor", "HighlightColor"
        }))
        if colorValue then
            state.Color = colorValue
            touched = true
        end

        local suppliedName = pull_preview_value(sourceTable, {"Name", "PlayerName", "DisplayName", "NameText"})
        if type(suppliedName) == "string" and suppliedName ~= "" then
            state.Name = suppliedName
            touched = true
        end
        local suppliedItem = pull_preview_value(sourceTable, {"Item", "ItemName", "Tool", "ToolName", "Weapon", "WeaponName"})
        if type(suppliedItem) == "string" and suppliedItem ~= "" then
            state.Item = suppliedItem
            touched = true
        end
        local suppliedDistanceText = pull_preview_value(sourceTable, {"DistanceText", "DistanceString", "DistanceLabel"})
        if type(suppliedDistanceText) == "string" and suppliedDistanceText ~= "" then
            state.DistanceText = suppliedDistanceText
            touched = true
        else
            local suppliedDistance = pull_preview_value(sourceTable, {"Distance", "DistanceValue"})
            if type(suppliedDistance) == "number" then
                state.DistanceText = string.format("%.0fm", suppliedDistance)
                touched = true
            end
        end

        local suppliedHealthPercent = pull_preview_value(sourceTable, {"HealthPercent", "HPPercent", "HealthRatio"})
        if type(suppliedHealthPercent) == "number" then
            if suppliedHealthPercent > 1 then
                suppliedHealthPercent = suppliedHealthPercent / 100
            end
            state.HealthPercent = math.clamp(suppliedHealthPercent, 0, 1)
            touched = true
        else
            local suppliedHealth = pull_preview_value(sourceTable, {"Health", "HP"})
            local suppliedMaxHealth = pull_preview_value(sourceTable, {"MaxHealth", "MaxHP", "HealthMax"})
            if type(suppliedHealth) == "number" and type(suppliedMaxHealth) == "number" and suppliedMaxHealth > 0 then
                state.HealthPercent = math.clamp(suppliedHealth / suppliedMaxHealth, 0, 1)
                touched = true
            end
        end

        return touched
    end

    local appliedTracked = applyStateFromTrackedControls()
    local appliedExternal = false
    if type(self._espPreviewData) == "table" then
        appliedExternal = applyStateFrom(self._espPreviewData) or appliedExternal
    end
    if type(self._espPreviewProvider) == "function" then
        local ok, providerResult = pcall(self._espPreviewProvider, self, state)
        if ok and type(providerResult) == "table" then
            appliedExternal = applyStateFrom(providerResult) or appliedExternal
        end
    end

    if not appliedExternal and not appliedTracked then
        local candidates = {}
        local candidateSet = {}
        local function addCandidate(candidate)
            if type(candidate) ~= "table" then
                return
            end
            if candidateSet[candidate] then
                return
            end
            candidateSet[candidate] = true
            table.insert(candidates, candidate)
        end
        local function addFromEnvironment(env)
            if type(env) ~= "table" then
                return
            end
            addCandidate(env.Settings)
            addCandidate(env.settings)
            addCandidate(env.ESPSettings)
            addCandidate(env.VisualSettings)
            addCandidate(env.Visuals)
            addCandidate(env.ESP)
            addCandidate(env.esp)
            addCandidate(env.Flags)
            addCandidate(env.flags)
            if type(env.Config) == "table" then
                addCandidate(env.Config.Settings)
                addCandidate(env.Config.ESP)
                addCandidate(env.Config.Visuals)
            end
        end
        if type(getgenv) == "function" then
            local okEnv, env = pcall(getgenv)
            if okEnv then
                addFromEnvironment(env)
            end
        end
        addFromEnvironment(_G)

        local knownKeys = {
            "ESPEnabled", "ShowBox", "ShowHealth", "ShowName", "UseDisplayName", "ShowEquippedItem",
            "ShowDistance", "ShowTracers", "ShowDot", "ChamsEnabled", "HighlightEnabled", "VisualColor"
        }
        local bestCandidate = nil
        local bestScore = 0
        for _, candidate in ipairs(candidates) do
            local score = 0
            for _, keyName in ipairs(knownKeys) do
                if candidate[keyName] ~= nil then
                    score = score + 1
                end
            end
            if score > bestScore then
                bestScore = score
                bestCandidate = candidate
            end
        end
        if bestCandidate and bestScore > 0 then
            applyStateFrom(bestCandidate)
        end
    end

    if state.UseDisplayName then
        state.Name = tostring(local_player.DisplayName or local_player.Name)
    elseif state.Name == "" or state.Name == nil then
        state.Name = tostring(local_player.Name)
    end
    return state
end

function atom_ui:_ApplyESPPreviewPartVisualState(showChams, previewColor, chamsTransparency)
    local targetShowChams = showChams == true
    local targetChamsTransparency = math.clamp(chamsTransparency or 0.55, 0, 0.92)
    local lastVisualState = self._espPreviewVisualState or {}
    local colorChanged = targetShowChams and lastVisualState.Color ~= previewColor
    local transparencyChanged = targetShowChams and math.abs((lastVisualState.ChamsTransparency or targetChamsTransparency) - targetChamsTransparency) > 0.001

    if not self._espPreviewVisualDirty
        and lastVisualState.ShowChams == targetShowChams
        and not colorChanged
        and not transparencyChanged then
        return
    end

    for part, originalData in pairs(self._espPreviewPartDefaults) do
        if part and part.Parent and originalData then
            local isRootPart = part.Name == "HumanoidRootPart"
            if targetShowChams and not isRootPart then
                if part.Material ~= Enum.Material.ForceField then
                    part.Material = Enum.Material.ForceField
                end
                if part.Color ~= previewColor then
                    part.Color = previewColor
                end
                if math.abs(part.Transparency - targetChamsTransparency) > 0.001 then
                    part.Transparency = targetChamsTransparency
                end
            else
                if part.Material ~= originalData.Material then
                    part.Material = originalData.Material
                end
                if part.Color ~= originalData.Color then
                    part.Color = originalData.Color
                end

                local targetTransparency
                if isRootPart then
                    targetTransparency = 1
                elseif flowPreviewCoreBodyParts[part.Name] and (originalData.Transparency or 0) >= 0.98 then
                    targetTransparency = 0
                else
                    targetTransparency = originalData.Transparency
                end

                if math.abs(part.Transparency - targetTransparency) > 0.001 then
                    part.Transparency = targetTransparency
                end
            end
        end
    end

    self._espPreviewVisualState = {
        ShowChams = targetShowChams,
        Color = previewColor,
        ChamsTransparency = targetChamsTransparency
    }
    self._espPreviewVisualDirty = false
end

function atom_ui:_UpdateESPPreview(dt)
    local shouldShow = self.is_visible and self._uiVisualSettings.ESPSelfPreview
    if not shouldShow then
        if self._espPreviewPanel then
            self._espPreviewPanel.Visible = false
        end
        if self._espPreviewWasShowing then
            self._espPreviewWasShowing = false
            self._espPreviewUpdateAccumulator = 0
            self:_DestroyESPPreviewCharacter()
        end
        return
    end

    self._espPreviewWasShowing = true

    if not self._espPreviewPanel or not self._espPreviewPanel.Parent then
        self:_CreateESPPreviewPanel()
    end
    if not self._espPreviewPanel then
        return
    end
    self._espPreviewPanel.Visible = true

    local resolvedDt = tonumber(dt) or 0
    if resolvedDt > 0 then
        self._espPreviewUpdateAccumulator = (tonumber(self._espPreviewUpdateAccumulator) or 0) + resolvedDt
        local updateInterval = is_mobile and 0.22 or 0.16
        if self._latestFPSValue > 0 then
            if self._latestFPSValue < 40 then
                updateInterval = is_mobile and 0.28 or 0.22
            elseif self._latestFPSValue < 55 then
                updateInterval = is_mobile and 0.24 or 0.18
            elseif self._latestFPSValue > 95 then
                updateInterval = is_mobile and 0.18 or 0.12
            end
        end
        if self._espPreviewUpdateAccumulator < updateInterval then
            return
        end
        resolvedDt = self._espPreviewUpdateAccumulator
        self._espPreviewUpdateAccumulator = 0
    end

    self._espPreviewResolveAccumulator = self._espPreviewResolveAccumulator + resolvedDt
    if not self._espPreviewState or self._espPreviewResolveAccumulator >= 0.3 then
        self._espPreviewState = self:_ResolveESPPreviewState()
        self._espPreviewResolveAccumulator = 0
    end
    local state = self._espPreviewState or self:_ResolveESPPreviewState()
    local previewColor = state.Color or self.config.AccentColor
    local showMaster = state.Enabled ~= false
    local hidePlayerName = self._uiVisualSettings.HideName == true
    local needsProjection = showMaster and (
        state.ShowBox == true
        or state.ShowHealth == true
        or state.ShowName == true
        or state.ShowDot == true
        or state.ShowTracers == true
    )

    self:_EnsureESPPreviewCharacter()
    if self._espPreviewAllowManualRotation == true and self._espPreviewCharacter and self._espPreviewCharacter.Parent then
        local currentYaw = tonumber(self._espPreviewRotationYaw) or math.rad(180)
        local targetYaw = tonumber(self._espPreviewRotationTargetYaw) or currentYaw
        local yawDelta = math.atan2(math.sin(targetYaw - currentYaw), math.cos(targetYaw - currentYaw))
        local yawAlpha = math.clamp((resolvedDt > 0 and resolvedDt or (1 / 60)) * 14, 0.08, 0.58)
        if math.abs(yawDelta) > 0.0004 then
            currentYaw = currentYaw + yawDelta * yawAlpha
            self._espPreviewRotationYaw = currentYaw
            self:_InvalidateESPPreviewProjection(false)
            local pivotYOffset = tonumber(self._espPreviewPivotYOffset) or -2
            pcall(function()
                self._espPreviewCharacter:PivotTo(CFrame.new(0, pivotYOffset, 0) * CFrame.Angles(0, currentYaw, 0))
            end)
        end
    end
    if not self._espPreviewStaticMode and (not self._espPreviewWalkTrack or not self._espPreviewWalkTrack.IsPlaying) then
        self:_StartESPPreviewWalkAnimation(local_player.Character)
    end
    if self._espPreviewHeaderTag then
        self._espPreviewHeaderTag.Visible = not hidePlayerName
        if not hidePlayerName then
            self._espPreviewHeaderTag.Text = "@" .. tostring(local_player.Name)
        end
    end
    if not self._espPreviewCharacter then
        if self._espPreviewBox then self._espPreviewBox.Visible = false end
        if self._espPreviewHealthTrack then self._espPreviewHealthTrack.Visible = false end
        if self._espPreviewDot then self._espPreviewDot.Visible = false end
        if self._espPreviewTracer then self._espPreviewTracer.Visible = false end
        if self._espPreviewName then self._espPreviewName.Visible = false end
        if self._espPreviewItem then self._espPreviewItem.Visible = false end
        if self._espPreviewDistance then self._espPreviewDistance.Visible = false end
        if self._espPreviewHighlight then self._espPreviewHighlight.Enabled = false end
        return
    end

    if self._espPreviewBoxStroke then self._espPreviewBoxStroke.Color = previewColor end
    if self._espPreviewDot then self._espPreviewDot.BackgroundColor3 = previewColor end
    if self._espPreviewTracer then self._espPreviewTracer.BackgroundColor3 = previewColor end

    local viewportCamera = self._espPreviewCamera or (self._espPreviewViewport and self._espPreviewViewport.CurrentCamera)
    local viewportSize = self._espPreviewViewport and self._espPreviewViewport.AbsoluteSize or Vector2.new(0, 0)
    local hasProjectedBox = false
    local boxMinX, boxMinY = math.huge, math.huge
    local boxMaxX, boxMaxY = -math.huge, -math.huge
    local headScreenPos = nil
    local rootScreenPos = nil
    local boundsCF = nil
    local boundsSize = nil
    local projectionCache = nil
    local canReuseProjection = false

    if needsProjection and viewportCamera and viewportSize.X > 2 and viewportSize.Y > 2 then
        projectionCache = self._espPreviewProjectionCache
        canReuseProjection = self._espPreviewStaticMode
            and self._espPreviewProjectionDirty ~= true
            and projectionCache ~= nil
            and math.abs((projectionCache.ViewportWidth or 0) - viewportSize.X) < 0.5
            and math.abs((projectionCache.ViewportHeight or 0) - viewportSize.Y) < 0.5

        if canReuseProjection then
            hasProjectedBox = projectionCache.HasProjectedBox == true
            boxMinX = projectionCache.BoxMinX or boxMinX
            boxMinY = projectionCache.BoxMinY or boxMinY
            boxMaxX = projectionCache.BoxMaxX or boxMaxX
            boxMaxY = projectionCache.BoxMaxY or boxMaxY
            if projectionCache.HeadX ~= nil and projectionCache.HeadY ~= nil then
                headScreenPos = Vector2.new(projectionCache.HeadX, projectionCache.HeadY)
            end
            if projectionCache.RootX ~= nil and projectionCache.RootY ~= nil then
                rootScreenPos = Vector2.new(projectionCache.RootX, projectionCache.RootY)
            end
        else
            boundsCF, boundsSize = getModelBoundingBoxSafe(self._espPreviewCharacter)

            if not self._espPreviewStaticMode and boundsCF and boundsSize then
                viewportCamera.FieldOfView = 32
                local boundsCenter = boundsCF.Position
                local verticalFov = math.rad(math.clamp(viewportCamera.FieldOfView, 18, 80))
                local aspectRatio = math.max(0.35, viewportSize.X / viewportSize.Y)
                local horizontalHalfFov = math.atan(math.tan(verticalFov * 0.5) * aspectRatio)
                local fitDepthY = (boundsSize.Y * 0.5) / math.max(0.001, math.tan(verticalFov * 0.5))
                local fitDepthX = (boundsSize.X * 0.5) / math.max(0.001, math.tan(horizontalHalfFov))
                local targetDepth = math.max(fitDepthX, fitDepthY) + boundsSize.Z * 0.85 + 1.35
                targetDepth = math.clamp(targetDepth, 6.8, 19.5)
                local lookTarget = boundsCenter + Vector3.new(0, math.clamp(boundsSize.Y * 0.03, -0.1, 0.45), 0)
                local cameraPos = lookTarget + Vector3.new(0, math.clamp(boundsSize.Y * 0.08, -0.2, 0.6), targetDepth)
                local targetCFrame = CFrame.new(cameraPos, lookTarget)
                local lerpAlpha = math.clamp((resolvedDt > 0 and resolvedDt or (1 / 60)) * 10, 0.12, 0.52)
                viewportCamera.CFrame = viewportCamera.CFrame:Lerp(targetCFrame, lerpAlpha)
            end

            if boundsCF and boundsSize then
                local halfSize = boundsSize * 0.5
                for _, cornerSign in ipairs(flowPreviewBoundingCornerSigns) do
                    local worldPoint = boundsCF:PointToWorldSpace(Vector3.new(
                        halfSize.X * cornerSign.X,
                        halfSize.Y * cornerSign.Y,
                        halfSize.Z * cornerSign.Z
                    ))
                    local screenPoint = viewportCamera:WorldToViewportPoint(worldPoint)
                    if screenPoint.Z > 0 then
                        hasProjectedBox = true
                        boxMinX = math.min(boxMinX, screenPoint.X)
                        boxMinY = math.min(boxMinY, screenPoint.Y)
                        boxMaxX = math.max(boxMaxX, screenPoint.X)
                        boxMaxY = math.max(boxMaxY, screenPoint.Y)
                    end
                end
            end

            local headPart = self._espPreviewHeadPart
            if headPart and headPart.Parent then
                local headWorld = headPart.Position + Vector3.new(0, math.max(0.12, headPart.Size.Y * 0.3), 0)
                local headPoint = viewportCamera:WorldToViewportPoint(headWorld)
                if headPoint.Z > 0 then
                    headScreenPos = Vector2.new(headPoint.X, headPoint.Y)
                end
            end

            local rootPart = self._espPreviewRootPart
            if rootPart and rootPart.Parent then
                local rootPoint = viewportCamera:WorldToViewportPoint(rootPart.Position)
                if rootPoint.Z > 0 then
                    rootScreenPos = Vector2.new(rootPoint.X, rootPoint.Y)
                end
            end
        end
    end

    if needsProjection and hasProjectedBox then
        boxMinX = math.clamp(boxMinX, 0, viewportSize.X)
        boxMinY = math.clamp(boxMinY, 0, viewportSize.Y)
        boxMaxX = math.clamp(boxMaxX, 0, viewportSize.X)
        boxMaxY = math.clamp(boxMaxY, 0, viewportSize.Y)
        if boxMaxX - boxMinX < 2 or boxMaxY - boxMinY < 2 then
            hasProjectedBox = false
        end
    end

    if needsProjection and not hasProjectedBox and viewportSize.X > 2 and viewportSize.Y > 2 then
        local fallbackWidth = viewportSize.X * 0.44
        local fallbackHeight = viewportSize.Y * 0.78
        boxMinX = (viewportSize.X - fallbackWidth) * 0.5
        boxMaxX = boxMinX + fallbackWidth
        boxMinY = viewportSize.Y * 0.1
        boxMaxY = boxMinY + fallbackHeight
        hasProjectedBox = true
        if not headScreenPos then
            headScreenPos = Vector2.new((boxMinX + boxMaxX) * 0.5, boxMinY + 8 * scale_factor)
        end
        if not rootScreenPos then
            rootScreenPos = Vector2.new((boxMinX + boxMaxX) * 0.5, boxMaxY)
        end
    end

    if needsProjection and self._espPreviewStaticMode and viewportSize.X > 2 and viewportSize.Y > 2 and not canReuseProjection then
        self._espPreviewProjectionCache = {
            ViewportWidth = viewportSize.X,
            ViewportHeight = viewportSize.Y,
            HasProjectedBox = hasProjectedBox == true,
            BoxMinX = hasProjectedBox and boxMinX or nil,
            BoxMinY = hasProjectedBox and boxMinY or nil,
            BoxMaxX = hasProjectedBox and boxMaxX or nil,
            BoxMaxY = hasProjectedBox and boxMaxY or nil,
            HeadX = headScreenPos and headScreenPos.X or nil,
            HeadY = headScreenPos and headScreenPos.Y or nil,
            RootX = rootScreenPos and rootScreenPos.X or nil,
            RootY = rootScreenPos and rootScreenPos.Y or nil
        }
        self._espPreviewProjectionDirty = false
    end
    if self._espPreviewBox then
        local showBox = showMaster and state.ShowBox == true and hasProjectedBox
        self._espPreviewBox.Visible = showBox
        if showBox then
            self._espPreviewBox.Position = UDim2.new(0, boxMinX, 0, boxMinY)
            self._espPreviewBox.Size = UDim2.new(0, boxMaxX - boxMinX, 0, boxMaxY - boxMinY)
        end
    end
    if self._espPreviewDot then
        local showDot = showMaster and state.ShowDot == true and headScreenPos ~= nil
        self._espPreviewDot.Visible = showDot
        if showDot then
            local dotSize = math.max(5 * scale_factor, 1)
            self._espPreviewDot.Position = UDim2.new(0, headScreenPos.X - dotSize * 0.5, 0, headScreenPos.Y - dotSize * 0.5)
            self._espPreviewDot.Size = UDim2.new(0, dotSize, 0, dotSize)
        end
    end
    if self._espPreviewTracer then
        local showTracer = showMaster and state.ShowTracers == true and (hasProjectedBox or rootScreenPos ~= nil)
        self._espPreviewTracer.Visible = showTracer
        if showTracer then
            local fromX = viewportSize.X * 0.5
            local fromY = viewportSize.Y - 1
            local toX = rootScreenPos and rootScreenPos.X or (boxMinX + (boxMaxX - boxMinX) * 0.5)
            local toY = rootScreenPos and rootScreenPos.Y or boxMaxY
            local dx = toX - fromX
            local dy = toY - fromY
            local length = math.sqrt(dx * dx + dy * dy)
            if length >= 2 then
                self._espPreviewTracer.Position = UDim2.new(0, fromX, 0, fromY)
                self._espPreviewTracer.Size = UDim2.new(0, 2 * scale_factor, 0, length)
                self._espPreviewTracer.Rotation = math.deg(math.atan2(dy, dx)) + 90
            else
                self._espPreviewTracer.Visible = false
            end
        end
    end

    if self._espPreviewName then
        local showName = not hidePlayerName and showMaster and state.ShowName == true and (hasProjectedBox or headScreenPos ~= nil)
        self._espPreviewName.Visible = showName
        if not hidePlayerName then
            self._espPreviewName.Text = tostring(state.Name or local_player.Name)
        end
        self._espPreviewName.TextColor3 = previewColor
        if showName then
            local nameWidth = hasProjectedBox and (boxMaxX - boxMinX + 20 * scale_factor) or (120 * scale_factor)
            nameWidth = math.clamp(nameWidth, 70 * scale_factor, viewportSize.X)
            local centerX = hasProjectedBox and (boxMinX + (boxMaxX - boxMinX) * 0.5) or headScreenPos.X
            local nameX = math.clamp(centerX - nameWidth * 0.5, 0, math.max(0, viewportSize.X - nameWidth))
            local nameY = hasProjectedBox and math.max(0, boxMinY - 16 * scale_factor) or math.max(0, headScreenPos.Y - 16 * scale_factor)
            self._espPreviewName.Position = UDim2.new(0, nameX, 0, nameY)
            self._espPreviewName.Size = UDim2.new(0, nameWidth, 0, 14 * scale_factor)
        end
    end

    if self._espPreviewItem then
        self._espPreviewItem.Visible = state.ShowItem == true and showMaster
        self._espPreviewItem.Text = tostring(state.Item or "None")
        self._espPreviewItem.TextColor3 = previewColor
    end

    if self._espPreviewDistance then
        self._espPreviewDistance.Visible = state.ShowDistance == true and showMaster
        self._espPreviewDistance.Text = tostring(state.DistanceText or "0m")
        self._espPreviewDistance.TextColor3 = previewColor
    end

    if self._espPreviewHealthTrack then
        local showHealth = state.ShowHealth == true and showMaster and hasProjectedBox
        self._espPreviewHealthTrack.Visible = showHealth
        if showHealth and self._espPreviewHealthFill then
            self._espPreviewHealthTrack.Position = UDim2.new(0, math.max(0, boxMinX - 5 * scale_factor), 0, boxMinY)
            self._espPreviewHealthTrack.Size = UDim2.new(0, 3 * scale_factor, 0, boxMaxY - boxMinY)
            local hpPercent = math.clamp(tonumber(state.HealthPercent) or 1, 0, 1)
            self._espPreviewHealthFill.Size = UDim2.new(1, 0, hpPercent, 0)
            self._espPreviewHealthFill.BackgroundColor3 = Color3.new(1 - hpPercent, hpPercent, 0)
        end
    end

    self:_ApplyESPPreviewPartVisualState(state.ShowChams == true and showMaster, previewColor, state.ChamsTransparency)

    if self._espPreviewHighlight then
        self._espPreviewHighlight.FillColor = previewColor
        self._espPreviewHighlight.OutlineColor = previewColor
        self._espPreviewHighlight.FillTransparency = math.clamp(state.HighlightFillTransparency or 0.5, 0, 1)
        self._espPreviewHighlight.OutlineTransparency = math.clamp(state.HighlightOutlineTransparency or 0, 0, 1)
        self._espPreviewHighlight.Enabled = state.ShowHighlight == true and state.Enabled ~= false
    end
end

function atom_ui:SetSmoothScroll(scrollFrame, smoothSpeed)
    if not scrollFrame or self._smoothScrollFrames[scrollFrame] then return end
    if scrollFrame:GetAttribute("FlowDisableSmoothScroll") == true then
        scrollFrame.ScrollingDirection = Enum.ScrollingDirection.Y
        scrollFrame.ElasticBehavior = Enum.ElasticBehavior.Never
        scrollFrame.ScrollBarImageTransparency = 0.1
        return
    end
    self._smoothScrollFrames[scrollFrame] = {
        targetY = scrollFrame.CanvasPosition.Y,
        internal = false,
        speed = smoothSpeed or 34
    }
    scrollFrame.ScrollingDirection = Enum.ScrollingDirection.Y
    scrollFrame.ElasticBehavior = Enum.ElasticBehavior.WhenScrollable
    scrollFrame.ScrollBarImageTransparency = 0.25
    self:_TrackConnection(scrollFrame:GetPropertyChangedSignal("CanvasPosition"):Connect(function()
        local state = self._smoothScrollFrames[scrollFrame]
        if not state or state.internal then return end
        state.targetY = scrollFrame.CanvasPosition.Y
    end))
end

function atom_ui:SetSearchFilter(rawQuery)
    local query = normalize_search(rawQuery)
    self._searchQuery = query
    local firstVisibleTab = nil
    local function matchesAny(queryText, termList)
        if queryText == "" then return true end
        if type(termList) ~= "table" then return false end
        for _, term in ipairs(termList) do
            local normalized = normalize_search(term)
            if normalized ~= "" and string.find(normalized, queryText, 1, true) ~= nil then
                return true
            end
        end
        return false
    end
    
    for _, section in ipairs(self.sections) do
        local sectionHasVisibleContent = false
        for _, tab in ipairs(section.tabs) do
            local tabMatch = matchesAny(query, tab.searchTerms)
            local groupMatch = false
            
            for _, group in ipairs(tab.groups) do
                local visible = query == "" or tabMatch or matchesAny(query, group.searchTerms)
                if group.mainFrame then
                    group.mainFrame.Visible = visible
                end
                if visible then
                    groupMatch = true
                end
            end
            
            local tabVisible = query == "" or tabMatch or groupMatch
            tab.isFilteredVisible = tabVisible
            if tab.button_frame then
                tab.button_frame.Visible = tabVisible
                if tab.defaultButtonSize then
                    tab.button_frame.Size = tabVisible and tab.defaultButtonSize or UDim2.new(tab.defaultButtonSize.X.Scale, tab.defaultButtonSize.X.Offset, tab.defaultButtonSize.Y.Scale, 0)
                end
            end
            if tabVisible and not firstVisibleTab then
                firstVisibleTab = tab
            end
            if tabVisible then
                sectionHasVisibleContent = true
            end
        end
        
        if section.container then
            section.container.Visible = sectionHasVisibleContent or query == ""
        end
    end
    
    if self.active_tab and not self.active_tab.isFilteredVisible then
        if firstVisibleTab then
            firstVisibleTab:Activate()
        else
            self.active_tab:Deactivate()
            self.active_tab = nil
        end
    elseif not self.active_tab and firstVisibleTab then
        firstVisibleTab:Activate()
    end
end

function atom_ui:SaveConfig(fileName)
    if not writefile then
        return false, "writefile API is unavailable in this executor."
    end

    local configName = sanitize_config_name(fileName)
    local payload = {
        version = 1,
        ui = self.config.Name,
        background = {
            CustomBackground = self.config.CustomBackground,
            BackgroundImage = self.config.BackgroundImage,
            BackgroundTransparency = self.config.BackgroundTransparency
        },
        controls = {}
    }
    
    for flag, control in pairs(self._trackedControls) do
        local ok, value = pcall(control.get)
        if ok then
            payload.controls[flag] = serialize_value(value)
        end
    end

    local encoded = http_service:JSONEncode(payload)
    local writableCandidates = {}
    local fileOnlyName = get_config_filename(configName)
    local okFolder, folderPath = ensure_config_folder()
    if okFolder then
        table.insert(writableCandidates, folderPath .. "/" .. fileOnlyName)
        table.insert(writableCandidates, folderPath .. "\\" .. fileOnlyName)
    end
    table.insert(writableCandidates, fileOnlyName)

    local visitedPaths = {}
    local lastWriteError = nil
    local savedPath = nil

    for _, candidatePath in ipairs(writableCandidates) do
        if not visitedPaths[candidatePath] then
            visitedPaths[candidatePath] = true
            local okWrite, errWrite = pcall(function()
                writefile(candidatePath, encoded)
            end)

            if okWrite then
                savedPath = candidatePath
                break
            else
                lastWriteError = errWrite
            end
        end
    end

    if not savedPath then
        return false, "Failed to write config file: " .. tostring(lastWriteError)
    end

    self._configPathHints[configName] = savedPath

    return true, savedPath
end

function atom_ui:LoadConfig(fileName)
    if not readfile then
        return false, "readfile API is unavailable in this executor."
    end

    local configName = sanitize_config_name(fileName)
    local path = nil
    local rawConfig = nil
    local readableCandidates = get_readable_config_paths(configName)
    local hintedPath = self._configPathHints and self._configPathHints[configName]

    if type(hintedPath) == "string" and hintedPath ~= "" then
        table.insert(readableCandidates, 1, hintedPath)
    end

    local visitedPaths = {}

    for _, candidatePath in ipairs(readableCandidates) do
        if not visitedPaths[candidatePath] then
            visitedPaths[candidatePath] = true

            local canRead = true
            if isfile then
                local okExists, exists = pcall(function()
                    return isfile(candidatePath)
                end)
                canRead = okExists and exists == true
            end

            if canRead then
                local okRead, fileData = pcall(function()
                    return readfile(candidatePath)
                end)

                if okRead and type(fileData) == "string" then
                    path = candidatePath
                    rawConfig = fileData
                    break
                end
            end
        end
    end
    if not path then
        return false, "Config file not found: " .. get_config_folder() .. "/" .. get_config_filename(configName)
    end

    local okDecode, data = pcall(function()
        return http_service:JSONDecode(rawConfig)
    end)
    if not okDecode or type(data) ~= "table" or type(data.controls) ~= "table" then
        return false, "Invalid config JSON format."
    end
    
    for flag, rawValue in pairs(data.controls) do
        local control = self._trackedControls[flag]
        if control then
            local decodedValue = deserialize_value(rawValue)
            pcall(control.set, decodedValue)
        end
    end

    if type(data.background) == "table" then
        if data.background.CustomBackground ~= nil then
            self.config.CustomBackground = data.background.CustomBackground == true
        end
        if type(data.background.BackgroundImage) == "string" then
            self.config.BackgroundImage = data.background.BackgroundImage
        end
        if type(data.background.BackgroundTransparency) == "number" then
            self.config.BackgroundTransparency = math.clamp(data.background.BackgroundTransparency, 0, 1)
        end
        self:_SetCustomBackgroundEnabled(self.config.CustomBackground, self.config.BackgroundImage)
    end

    return true, path
end

function atom_ui:BuildUI()
    self.screen_gui = create("ScreenGui", {
        Name = "AtomUI",
        ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
        ResetOnSpawn = false,
        IgnoreGuiInset = true
    })
    
    if syn then
        syn.protect_gui(self.screen_gui)
        self.screen_gui.Parent = core_gui
    elseif gethui then
        self.screen_gui.Parent = core_gui
    else
        self.screen_gui.Parent = core_gui
    end

    self:_RefreshViewportMetrics()
    self:_TrackConnection(self.screen_gui:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
        self:_RefreshViewportMetrics()
        self:_InvalidateESPPreviewProjection(false)
    end))

    self.backdrop_dim = create("Frame", {
        Name = "BackdropDimForBlur",
        BackgroundColor3 = Color3.new(0, 0, 0),
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 1, 0),
        ZIndex = 0,
        Parent = self.screen_gui
    })

    self.snow_layer = create("Frame", {
        Name = "SnowLayerWhenOpen",
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Size = UDim2.new(1, 0, 1, 0),
        ZIndex = 2,
        ClipsDescendants = true,
        Parent = self.screen_gui
    })
    
    self.dropdown_holder = create("Frame", {
        Name = "DropdownHolderBecauseDropdownsNeedHomes",
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 1, 0),
        ZIndex = 9999,
        Parent = self.screen_gui
    })
    
    self:BuildWatermark()
    self:BuildMainFrame()
    if self._uiVisualSettings.ESPSelfPreview then
        self:_CreateESPPreviewPanel()
    end
    self:BuildNotificationHolder()
    self:BuildToggleButton()
    -- Set initial toggle icon state based on visibility
    if self.toggle_icon then
        if self.is_visible then
            self.toggle_icon.ImageColor3 = self.config.AccentColor
        else
            self.toggle_icon.ImageColor3 = Color3.new(1, 1, 1)
        end
    end
    self:SetFontPreset(self._fontPresetIndex)
    self:_SetTextGradientEnabled(self._uiVisualSettings.TextGradient)
    self:_SetBackgroundEffectsEnabled(self._uiVisualSettings.BackgroundEffects)
    self:_SetOverlayMode(self._overlayMode)
    self:_SetCustomBackgroundEnabled(self.config.CustomBackground, self.config.BackgroundImage)
    self:_ApplyOpenCloseVisuals(true)
    
    self:_TrackConnection(input_service.InputBegan:Connect(function(input, gameProcessed)
        if gameProcessed then return end
        if input.KeyCode == self.toggleKeyCode then
            self:Toggle()
        end
    end))
    
    self:_TrackConnection(run_service.RenderStepped:Connect(function(dt)
        if self._destroyed then return end
        
        local rollingIndex = self._fpsRollingIndex or 1
        local previousDt = self._fpsRollingWindow[rollingIndex] or 0
        if (self._fpsRollingCount or 0) >= self._fpsRollingSize then
            self._fpsRollingTotal = self._fpsRollingTotal - previousDt
        else
            self._fpsRollingCount = (self._fpsRollingCount or 0) + 1
        end
        self._fpsRollingWindow[rollingIndex] = dt
        self._fpsRollingTotal = self._fpsRollingTotal + dt
        rollingIndex = rollingIndex + 1
        if rollingIndex > self._fpsRollingSize then
            rollingIndex = 1
        end
        self._fpsRollingIndex = rollingIndex
        if self._fpsRollingTotal > 0 and (self._fpsRollingCount or 0) > 0 then
            self._latestFPSValue = math.clamp(math.floor(((self._fpsRollingCount or 0) / self._fpsRollingTotal) + 0.5), 1, 360)
        end

        local nowClock = os.clock()
        if not self._autoConfigLoadAttempted then
            if next(self._trackedControls) ~= nil and (nowClock - (self._lastControlRegistration or nowClock)) >= 1.25 then
                self:_TryAutoLoadConfig(false)
            end
        elseif self._autoConfigEnabled then
            self._autoConfigAccumulator = (self._autoConfigAccumulator or 0) + dt
            if self._autoConfigAccumulator >= (self._autoConfigInterval or 1.2) then
                self._autoConfigAccumulator = 0
                self:_TryAutoSaveConfig(false)
            end
        else
            self._autoConfigAccumulator = 0
        end
        
        for scrollingFrame, state in pairs(self._smoothScrollFrames) do
            if not scrollingFrame or not scrollingFrame.Parent then
                self._smoothScrollFrames[scrollingFrame] = nil
            else
                local currentY = scrollingFrame.CanvasPosition.Y
                local goalY = state.targetY
                local diff = goalY - currentY
                if math.abs(diff) > 0.05 then
                    state.internal = true
                    local frameDt = math.clamp(tonumber(dt) or (1 / 60), 1 / 240, 1 / 20)
                    local alpha = math.clamp(1 - math.exp(-(state.speed or 34) * frameDt), 0.16, 1)
                    scrollingFrame.CanvasPosition = Vector2.new(scrollingFrame.CanvasPosition.X, currentY + diff * alpha)
                    state.internal = false
                elseif state.internal then
                    state.internal = false
                end
            end
        end

        if self._uiVisualSettings.ESPSelfPreview or self._espPreviewWasShowing then
            self:_UpdateESPPreview(dt)
        end
        self:_StepRefreshJobs(dt)
        self:_UpdateWatermark(dt)
        if self._uiVisualSettings.TextGradient and #self._gradientObjects > 0 then
            self:_AnimateTextGradients(dt)
        end

        local currentFps = self._latestFPSValue

        if self.is_visible and self._uiVisualSettings.BackgroundEffects and self.bg_effects_frame and self.bg_effects_frame.Visible then
            self._backgroundFxAccumulator = (self._backgroundFxAccumulator or 0) + dt
            local backgroundStep
            if currentFps > 0 and currentFps < 36 then
                backgroundStep = is_mobile and (1 / 10) or (1 / 14)
            elseif currentFps > 0 and currentFps < 50 then
                backgroundStep = is_mobile and (1 / 13) or (1 / 18)
            else
                backgroundStep = is_mobile and (1 / 16) or (1 / 24)
            end
            if self._backgroundFxAccumulator >= backgroundStep then
                local backgroundDt = self._backgroundFxAccumulator
                self._backgroundFxAccumulator = 0
                self._backgroundFxTime = self._backgroundFxTime + backgroundDt
                if self.bg_gradient then
                    self.bg_gradient.Rotation = (self.bg_gradient.Rotation + backgroundDt * 8) % 360
                end
                if self.bg_accent_glow then
                    local timeNow = self._backgroundFxTime
                    local xPos = 0.5 + math.sin(timeNow * 0.45) * 0.09
                    local yPos = 0.5 + math.cos(timeNow * 0.63) * 0.06
                    self.bg_accent_glow.Position = UDim2.new(xPos, 0, yPos, 0)
                    self.bg_accent_glow.ImageTransparency = 0.9 - (math.sin(timeNow * 1.6) + 1) * 0.03
                end
            end
        else
            self._backgroundFxAccumulator = 0
        end

        if self.is_visible and self._uiVisualSettings.Snow and self.snow_layer and self.snow_layer.Visible and self._overlayMode ~= "None" then
            self._overlayUpdateAccumulator = (self._overlayUpdateAccumulator or 0) + dt
            local overlayStep
            if currentFps > 0 and currentFps < 36 then
                overlayStep = is_mobile and (1 / 14) or (1 / 18)
            elseif currentFps > 0 and currentFps < 50 then
                overlayStep = is_mobile and (1 / 18) or (1 / 24)
            else
                overlayStep = is_mobile and (1 / 24) or (1 / 34)
            end

            if self._overlayUpdateAccumulator >= overlayStep then
                local overlayDt = math.min(self._overlayUpdateAccumulator, 0.12)
                self._overlayUpdateAccumulator = 0

                self._snowSpawnAccumulator = self._snowSpawnAccumulator + overlayDt
                local overlayMode = self._overlayMode
                local spawnInterval
                local maxParticles
                if overlayMode == "Rain" then
                    spawnInterval = is_mobile and 0.018 or 0.011
                    maxParticles = is_mobile and 72 or 150
                elseif overlayMode == "Stars" then
                    spawnInterval = is_mobile and 0.038 or 0.022
                    maxParticles = is_mobile and 72 or 150
                else
                    spawnInterval = is_mobile and 0.16 or 0.105
                    maxParticles = is_mobile and 30 or 62
                end

                local overlayQualityScale = self._cachedViewportAreaScale or 1
                if is_mobile then
                    overlayQualityScale = overlayQualityScale * 0.82
                end
                if currentFps > 0 then
                    if currentFps < 30 then
                        overlayQualityScale = overlayQualityScale * 0.28
                    elseif currentFps < 36 then
                        overlayQualityScale = overlayQualityScale * 0.4
                    elseif currentFps < 45 then
                        overlayQualityScale = overlayQualityScale * 0.55
                    elseif currentFps < 58 then
                        overlayQualityScale = overlayQualityScale * 0.72
                    elseif currentFps > 120 then
                        overlayQualityScale = overlayQualityScale * 1.04
                    end
                end
                overlayQualityScale = math.clamp(overlayQualityScale, is_mobile and 0.22 or 0.3, 1.08)
                spawnInterval = spawnInterval / math.max(overlayQualityScale, 0.35)
                maxParticles = math.max(overlayMode == "Snow" and 10 or 12, math.floor(maxParticles * overlayQualityScale))
                local maxSpawnBurst
                if overlayMode == "Rain" then
                    maxSpawnBurst = is_mobile and 3 or 6
                elseif overlayMode == "Stars" then
                    maxSpawnBurst = is_mobile and 2 or 4
                else
                    maxSpawnBurst = is_mobile and 1 or 2
                end
                self._snowSpawnAccumulator = math.min(self._snowSpawnAccumulator, spawnInterval * maxSpawnBurst)

                local spawnedThisStep = 0
                while self._snowSpawnAccumulator >= spawnInterval and #self._snowflakes < maxParticles and spawnedThisStep < maxSpawnBurst do
                    if overlayMode == "Rain" then
                        self:_SpawnRainDrop()
                    elseif overlayMode == "Stars" then
                        self:_SpawnStarParticle()
                    else
                        self:_SpawnSnowflake()
                    end
                    self._snowSpawnAccumulator = self._snowSpawnAccumulator - spawnInterval
                    spawnedThisStep = spawnedThisStep + 1
                end

                local nowTick = os.clock()
                local viewportHeight = self._cachedViewportHeight or 320
                local viewportWidth = self._cachedViewportWidth or 200
                local allowRainSplashes = overlayMode == "Rain" and overlayQualityScale > (is_mobile and 0.52 or 0.38)
                for i = #self._snowflakes, 1, -1 do
                    local flakeData = self._snowflakes[i]
                    local flakeObj = flakeData and flakeData.instance
                    if not flakeObj or not flakeObj.Parent then
                        table.remove(self._snowflakes, i)
                    else
                        local overlayType = flakeData.overlayType or "Snow"
                        if overlayType == "RainDrop" then
                            flakeData.yOffset = flakeData.yOffset + flakeData.velocityY * overlayDt
                            flakeData.xOffset = flakeData.xOffset + flakeData.velocityX * overlayDt
                            local windOffset = math.sin(nowTick * flakeData.driftSpeed + flakeData.phase) * flakeData.windJitter
                            local xPos = flakeData.xOffset + windOffset
                            flakeObj.Position = UDim2.new(0, xPos, 0, flakeData.yOffset)
                            local stretchPulse = 0.82 + math.sin(nowTick * flakeData.stretchPulse + flakeData.phase) * 0.18
                            flakeObj.Size = UDim2.new(0, flakeData.width, 0, flakeData.length * stretchPulse)
                            flakeObj.Rotation = flakeData.angle
                            flakeObj.BackgroundTransparency = math.clamp(flakeData.baseTransparency + (math.sin(nowTick * 3.6 + flakeData.phase) * 0.07), 0.08, 0.9)
                            if flakeData.yOffset > viewportHeight + 20 then
                                if allowRainSplashes and xPos > -40 and xPos < viewportWidth + 40 and math.random() < (flakeData.splashChance * overlayQualityScale) then
                                    self:_SpawnRainSplash(xPos, viewportHeight - math.random(1, 8))
                                end
                                flakeObj:Destroy()
                                table.remove(self._snowflakes, i)
                            end
                        elseif overlayType == "RainSplash" then
                            flakeData.life = flakeData.life - overlayDt
                            if flakeData.life <= 0 then
                                flakeObj:Destroy()
                                table.remove(self._snowflakes, i)
                            else
                                local progress = 1 - (flakeData.life / flakeData.totalLife)
                                local widthNow = flakeData.startSize + flakeData.endSize * progress
                                local heightNow = math.max(1 * scale_factor, flakeData.startThickness * (1 - progress * 0.8))
                                flakeObj.Size = UDim2.new(0, widthNow, 0, heightNow)
                                flakeObj.Position = UDim2.new(0, flakeData.baseX + flakeData.driftX * progress, 0, flakeData.yOffset - progress * 1.2)
                                flakeObj.BackgroundTransparency = math.clamp(flakeData.baseTransparency + progress * 0.55, 0.2, 0.97)
                            end
                        elseif overlayType == "Stars" then
                            flakeData.xOffset = flakeData.xOffset + flakeData.velocityX * overlayDt
                            flakeData.yOffset = flakeData.yOffset + flakeData.velocityY * overlayDt
                            local driftX = math.sin(nowTick * flakeData.driftSpeed + flakeData.phase) * flakeData.driftAmount
                            local driftY = math.cos(nowTick * (flakeData.driftSpeed * 0.72) + flakeData.phase) * flakeData.driftLift
                            local xPos = flakeData.xOffset + driftX
                            local yPos = flakeData.yOffset + driftY
                            if xPos < -16 then
                                flakeData.xOffset = viewportWidth + 16
                                xPos = flakeData.xOffset
                            elseif xPos > viewportWidth + 16 then
                                flakeData.xOffset = -16
                                xPos = flakeData.xOffset
                            end
                            if yPos < -16 then
                                flakeData.yOffset = viewportHeight + 16
                                yPos = flakeData.yOffset
                            elseif yPos > viewportHeight + 16 then
                                flakeData.yOffset = -16
                                yPos = flakeData.yOffset
                            end
                            flakeObj.Position = UDim2.new(0, xPos, 0, yPos)
                            local sparkle = (math.sin(nowTick * flakeData.twinkleSpeed + flakeData.phase) + 1) * 0.5
                            local pulse = 1 + (math.sin(nowTick * (flakeData.twinkleSpeed * 0.75) + flakeData.phase) * flakeData.pulseAmount)
                            local sizeNow = math.max(1 * scale_factor, flakeData.baseSize * (0.82 + pulse * 0.36))
                            flakeObj.Size = UDim2.new(0, sizeNow, 0, sizeNow)
                            flakeObj.ImageTransparency = math.clamp(flakeData.baseTransparency - sparkle * 0.5, 0.01, 0.92)
                        else
                            flakeData.yOffset = flakeData.yOffset + flakeData.fallSpeed * overlayDt
                            local driftX = math.sin(nowTick * flakeData.driftSpeed + flakeData.phase) * flakeData.driftAmount
                            local swirlX = math.cos(nowTick * (flakeData.driftSpeed * 0.58) + flakeData.phase) * flakeData.swirlAmount
                            flakeObj.Position = UDim2.new(0, flakeData.baseX + driftX + swirlX, 0, flakeData.yOffset)
                            flakeObj.Rotation = (flakeObj.Rotation + flakeData.spin * overlayDt) % 360
                            local twinkle = (math.sin(nowTick * flakeData.twinkleSpeed + flakeData.phase) + 1) * 0.5
                            flakeObj.ImageTransparency = math.clamp(flakeData.baseTransparency + twinkle * 0.22, 0.08, 0.84)
                            if flakeData.yOffset > viewportHeight + 28 then
                                flakeObj:Destroy()
                                table.remove(self._snowflakes, i)
                            end
                        end
                    end
                end
            end
        else
            self._overlayUpdateAccumulator = 0
        end
    end))
end

function atom_ui:Toggle()
    self.is_visible = not self.is_visible
    local openPosition = self._mainFrameOpenPosition or UDim2.new(0.5, -392 * scale_factor, 0.5, -262 * scale_factor)
    local closedPosition = self._mainFrameClosedPosition or UDim2.new(0.5, openPosition.X.Offset, 1.5, 0)

    if self.is_visible then
        -- OPEN: smooth scale-up + slide in
        self.main_frame.Visible = true
        tween_to(self.main_frame, {Position = openPosition}, 0.45, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
        if self.backdrop_dim then
            tween_to(self.backdrop_dim, {BackgroundTransparency = 0.55}, 0.45)
        end
        if self.blur then self.blur.Enabled = true end
        if self.floating_toggle then
            tween_to(self.floating_toggle, {ImageTransparency = 1}, 0.2)
            task.delay(0.25, function()
                if self.floating_toggle then self.floating_toggle.Visible = false end
            end)
        end
        -- Pulse the toggle icon to show "active" state
        if self.toggle_icon then
            tween_to(self.toggle_icon, {ImageColor3 = self.config.AccentColor}, 0.3)
        end
    else
        -- CLOSE: slide down + fade
        tween_to(self.main_frame, {Position = closedPosition}, 0.4, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
        if self.backdrop_dim then
            tween_to(self.backdrop_dim, {BackgroundTransparency = 1}, 0.35)
        end
        if self.blur then self.blur.Enabled = false end
        if self.floating_toggle then
            self.floating_toggle.Visible = true
            self.floating_toggle.ImageTransparency = 1
            tween_to(self.floating_toggle, {ImageTransparency = 0}, 0.3)
        end
        -- Reset toggle icon color
        if self.toggle_icon then
            tween_to(self.toggle_icon, {ImageColor3 = Color3.new(1, 1, 1)}, 0.3)
        end
    end
    self:_ApplyOpenCloseVisuals(false)
end

function atom_ui:SetToggleVisible(visible)
    self.toggleButtonVisible = visible
    if self.toggle_frame then
        self.toggle_frame.Visible = visible
    end
end

function atom_ui:SetToggleKey(keyCode)
    self.toggleKeyCode = keyCode
end

-- SetToggleImage: lets hub scripts set a custom image for the toggle button at runtime
function atom_ui:SetToggleImage(assetId)
    if not assetId or type(assetId) ~= "string" then return end
    self.config.ToggleImage = assetId
    if self.toggle_icon and self.toggle_icon.Parent then
        self.toggle_icon.Image = assetId
    end
    if self.floating_toggle and self.floating_toggle.Parent then
        self.floating_toggle.Image = assetId
    end
end

function atom_ui:BuildToggleButton()
    local btn_size = 55 * scale_factor

    self.toggle_frame = create("Frame", {
        Name = "ToggleButton",
        BackgroundColor3 = self.config.SecondaryColor or Color3.fromRGB(18, 18, 18),
        AnchorPoint = Vector2.new(0, 0.5),
        Position = UDim2.new(0, 8, 0.5, 0),
        BorderSizePixel = 0,
        Size = UDim2.new(0, btn_size, 0, btn_size),
        Parent = self.screen_gui
    })
    create("UICorner", {CornerRadius = UDim.new(0, 14), Parent = self.toggle_frame})

    create("UIStroke", {
        Color = Color3.fromRGB(45, 45, 45),
        Thickness = 2,
        Parent = self.toggle_frame
    })

    self.toggle_icon = create("ImageLabel", {
        Name = "ToggleIcon",
        BackgroundTransparency = 1,
        Image = self.config.ToggleImage or atomic_logo,
        ImageColor3 = self.config.AccentColor or Color3.fromRGB(2, 133, 255),
        AnchorPoint = Vector2.new(0.5, 0.5),
        Position = UDim2.new(0.5, 0, 0.5, 0),
        Size = UDim2.new(0, btn_size * 0.55, 0, btn_size * 0.55),
        Parent = self.toggle_frame
    })

    local toggle_btn = create("TextButton", {
        Name = "ClickButton",
        Text = "", BackgroundTransparency = 1,
        Size = UDim2.new(0, btn_size, 0, btn_size),
        ZIndex = 9999999,
        Parent = self.toggle_frame
    })

    toggle_btn.MouseButton1Click:Connect(function()
        self:Toggle()
    end)

    make_draggable(self.toggle_frame, toggle_btn, self)
end

function atom_ui:BuildWatermark()
    local initialText = self.config.Name .. " | 00:00:00 | 60 FPS | 0ms"
    local initialWidth = measure_text_width(initialText, 14, Enum.Font.GothamSemibold) + 45
    
    self.watermark_frame = create("Frame", {
        Name = "WatermarkCuzWeNeedFlexing",
        BackgroundColor3 = Color3.fromRGB(16, 16, 16),
        AnchorPoint = Vector2.new(0.5, 0),
        Position = UDim2.new(0.5, 0, 0, 6),
        BorderSizePixel = 0,
        Size = UDim2.new(0, initialWidth * scale_factor, 0, 36 * scale_factor),
        Parent = self.screen_gui
    })
    
    create("UICorner", {CornerRadius = UDim.new(1,0), Parent = self.watermark_frame})
    
    create("ImageLabel", {
        Image = self.config.ToggleImage or atomic_logo, BackgroundTransparency = 1,
        AnchorPoint = Vector2.new(0, 0.5),
        Position = UDim2.new(0, 8, 0.5, 0),
        Size = UDim2.new(0, 20 * scale_factor, 0, 20 * scale_factor),
        Parent = self.watermark_frame
    })
    
    local icon_offset = math.floor(8 + 20 * scale_factor + 6)
    self.watermark_textLabel = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        TextColor3 = Color3.new(1, 1, 1), Text = initialText, BackgroundTransparency = 1,
        Position = UDim2.new(0, icon_offset, 0, 0), TextSize = 14 * scale_factor,
        Size = UDim2.new(1, -icon_offset - 8, 1, 0), TextXAlignment = Enum.TextXAlignment.Left,
        Parent = self.watermark_frame
    })
    table.insert(self._gradientLabels, self.watermark_textLabel)
    
    make_draggable(self.watermark_frame, nil, self)
end

function atom_ui:_UpdateWatermark(dt)
    if not (self.watermark_frame and self.watermark_frame.Parent and self.watermark_textLabel and self.watermark_textLabel.Parent) then
        return
    end

    self._watermarkUpdateAccumulator = (self._watermarkUpdateAccumulator or 0) + (tonumber(dt) or 0)
    if self._watermarkUpdateAccumulator < 0.6 then
        return
    end
    self._watermarkUpdateAccumulator = 0

    local timeNow = os.date("%H:%M:%S")
    local fpsCount = self._latestFPSValue > 0 and self._latestFPSValue or 0
    local ping_now = 0
    pcall(function()
        ping_now = math.floor(game:GetService("Stats").Network.ServerStatsItem["Data Ping"]:GetValue())
    end)
    local newText = self.config.Name .. " | " .. timeNow .. " | " .. fpsCount .. " FPS | " .. ping_now .. " ms"
    if self.watermark_textLabel.Text ~= newText then
        self.watermark_textLabel.Text = newText
    end

    local newWidth = measure_text_width(newText, 14 * scale_factor, Enum.Font.GothamSemibold) + 45
    if math.abs(newWidth - (self._watermarkLastWidth or 0)) > 1 then
        self._watermarkLastWidth = newWidth
        tween_to(self.watermark_frame, {Size = UDim2.new(0, newWidth, 0, 36 * scale_factor)}, 0.18)
    end
end

function atom_ui:_ResizeLayout(newWidth, newHeight)
    local min_w = 600 * scale_factor
    local min_h = 380 * scale_factor
    local max_w = 1200 * scale_factor
    local max_h = 850 * scale_factor
    newWidth = math.clamp(newWidth, min_w, max_w)
    newHeight = math.clamp(newHeight, min_h, max_h)

    local header_h = 65 * scale_factor
    local content_top = 62 * scale_factor
    local sidebar_x = 17
    local sidebar_w = 162 * scale_factor
    local content_start_x = 198 * scale_factor
    local content_right_pad = 7 * scale_factor
    local search_w = 214 * scale_factor
    local search_right_pad = 12 * scale_factor

    self.main_frame.Size = UDim2.new(0, newWidth, 0, newHeight)

    local content_w = newWidth - content_start_x - content_right_pad
    local content_h = newHeight - content_top - 7 * scale_factor
    local sidebar_h = newHeight - (75 * scale_factor) - (58 * scale_factor)
    local search_x = newWidth - search_w - search_right_pad

    if self.section_scroll then
        self.section_scroll.Size = UDim2.new(0, sidebar_w, 0, sidebar_h)
    end

    if self.content_holder then
        self.content_holder.Size = UDim2.new(0, content_w, 0, content_h)
    end

    if self.search_frame then
        self.search_frame.Position = UDim2.new(0, search_x, 0, 16 * scale_factor)
    end

    local col_w = math.floor((content_w - 26 * scale_factor) / 2)
    local col_gap = content_w - 26 * scale_factor - col_w * 2 + 10 * scale_factor
    local canvas_w = col_w * 2 + col_gap

    for _, section in ipairs(self.sections) do
        if section.tabs then
            for _, tab in ipairs(section.tabs) do
                if tab.left_column then
                    tab.left_column.Size = UDim2.new(0, col_w, 0, tab.left_column.Size.Y.Offset)
                end
                if tab.right_column then
                    tab.right_column.Position = UDim2.new(0, col_w + col_gap, 0, 0)
                    tab.right_column.Size = UDim2.new(0, col_w, 0, tab.right_column.Size.Y.Offset)
                end
                if tab.content_scroll then
                    tab.content_scroll.CanvasSize = UDim2.new(0, canvas_w, 0, tab.content_scroll.CanvasSize.Y.Offset)
                end
            end
        end
    end

    self._mainFrameOpenPosition = UDim2.new(0.5, -newWidth / 2, 0.5, -newHeight / 2)
    self._mainFrameClosedPosition = UDim2.new(0.5, -newWidth / 2, 1.5, 0)

    if self._scrollbarRefreshers then
        for _, refresher in ipairs(self._scrollbarRefreshers) do
            pcall(refresher)
        end
    end
end

function atom_ui:BuildMainFrame()
    local frameWidth = 830 * scale_factor
    local frameHeight = 530 * scale_factor
    local headerLeftPadding = 10 * scale_factor
    local headerAvatarBaseX = 160 * scale_factor
    local headerAvatarSize = 30 * scale_factor
    local headerAvatarGap = 10 * scale_factor
    local searchWidth = 214 * scale_factor
    local searchRightPadding = 12 * scale_factor
    local contentStartX = 198 * scale_factor
    local contentRightPadding = 7 * scale_factor
    local sectionScrollHeight = 441 * scale_factor
    local contentHeight = 461 * scale_factor
    self._mainFrameOpenPosition = UDim2.new(0.5, -frameWidth/2, 0.5, -frameHeight/2)
    self._mainFrameClosedPosition = UDim2.new(0.5, -frameWidth/2, 1.5, 0)
    
    self.main_frame = create("Frame", {
        Name = "MainFrameIsAwesome",
        BackgroundColor3 = Color3.fromRGB(13, 13, 13),
        Position = self._mainFrameOpenPosition,
        ClipsDescendants = true,
        BorderSizePixel = 0,
        Size = UDim2.new(0, frameWidth, 0, frameHeight),
        Parent = self.screen_gui
    })
    create("UICorner", {CornerRadius = UDim.new(0, 12), Parent = self.main_frame})
    create("UIStroke", {
        Color = Color3.fromRGB(28, 28, 28),
        Thickness = 1,
        ApplyStrokeMode = Enum.ApplyStrokeMode.Border,
        Parent = self.main_frame
    })
    local accent_top_line = create("Frame", {
        BackgroundColor3 = self.config.AccentColor,
        BorderSizePixel = 0,
        Position = UDim2.new(0.18, 0, 0, 0),
        Size = UDim2.new(0.64, 0, 0, 1),
        ZIndex = 3,
        Parent = self.main_frame
    })
    create("UIGradient", {
        Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Color3.new(0, 0, 0)),
            ColorSequenceKeypoint.new(0.12, Color3.new(1, 1, 1)),
            ColorSequenceKeypoint.new(0.88, Color3.new(1, 1, 1)),
            ColorSequenceKeypoint.new(1, Color3.new(0, 0, 0))
        }),
        Parent = accent_top_line
    })
    self._accentTopLine = accent_top_line

    self.bg_effects_frame = create("Frame", {
        Name = "MainBackgroundEffects",
        BackgroundColor3 = Color3.fromRGB(18, 18, 18),
        BackgroundTransparency = 0.45,
        Size = UDim2.new(1, 0, 1, 0),
        ClipsDescendants = true,
        ZIndex = 0,
        Parent = self.main_frame
    })
    self.bg_gradient = create("UIGradient", {
        Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Color3.fromRGB(10, 10, 10)),
            ColorSequenceKeypoint.new(0.5, Color3.fromRGB(18, 18, 18)),
            ColorSequenceKeypoint.new(1, Color3.fromRGB(12, 12, 12))
        }),
        Rotation = 210,
        Parent = self.bg_effects_frame
    })
    self.bg_accent_glow = create("ImageLabel", {
        Name = "AccentGlow",
        BackgroundTransparency = 1,
        Image = "rbxassetid://5028857084",
        ImageColor3 = self.config.AccentColor,
        ImageTransparency = 0.9,
        Size = UDim2.new(1.8, 0, 1.8, 0),
        Position = UDim2.new(0.5, 0, 0.5, 0),
        AnchorPoint = Vector2.new(0.5, 0.5),
        ZIndex = 0,
        Parent = self.bg_effects_frame
    })

    -- Custom Background Image Layer
    self.bg_image_frame = create("Frame", {
        Name = "CustomBackgroundImage",
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 1, 0),
        ClipsDescendants = true,
        ZIndex = 0,
        Visible = false,
        Parent = self.main_frame
    })
    self.bg_image_label = create("ImageLabel", {
        Name = "BackgroundImage",
        BackgroundTransparency = 1,
        Image = "",
        ImageTransparency = 0.35,
        Size = UDim2.new(1, 0, 1, 0),
        ScaleType = Enum.ScaleType.Crop,
        ZIndex = 0,
        Parent = self.bg_image_frame
    })
    self.bg_image_overlay = create("Frame", {
        Name = "BackgroundImageOverlay",
        BackgroundColor3 = Color3.fromRGB(0, 0, 0),
        BackgroundTransparency = 0.45,
        Size = UDim2.new(1, 0, 1, 0),
        ZIndex = 1,
        Parent = self.bg_image_frame
    })
    
    self.drag_bar = create("Frame", {
        BackgroundTransparency = 1, Position = UDim2.new(0, 0, 0, 0),
        Size = UDim2.new(1, 0, 0, 65 * scale_factor), Parent = self.main_frame
    })
    
    make_draggable(self.main_frame, self.drag_bar, self)

    local resize_handle = create("Frame", {
        Name = "ResizeHandle",
        BackgroundTransparency = 1,
        AnchorPoint = Vector2.new(1, 1),
        Position = UDim2.new(1, -2, 1, -2),
        Size = UDim2.new(0, 18 * scale_factor, 0, 18 * scale_factor),
        ZIndex = 10,
        Parent = self.main_frame
    })
    create("ImageLabel", {
        Image = default_icons.resize,
        ImageColor3 = Color3.fromRGB(72, 72, 72),
        ImageTransparency = 0.2,
        BackgroundTransparency = 1,
        Size = UDim2.new(0.8, 0, 0.8, 0),
        Position = UDim2.new(0.1, 0, 0.1, 0),
        Rotation = 90,
        ZIndex = 10,
        Parent = resize_handle
    })

    do
        local is_resizing = false
        local resize_start_pos
        local resize_start_size

        local resize_button = create("TextButton", {
            Text = "",
            BackgroundTransparency = 1,
            Size = UDim2.new(1, 8, 1, 8),
            Position = UDim2.new(0, -4, 0, -4),
            ZIndex = 11,
            Parent = resize_handle
        })

        local resize_input_conn
        local function stop_resize()
            is_resizing = false
            if resize_input_conn then
                resize_input_conn:Disconnect()
                resize_input_conn = nil
            end
        end

        resize_button.InputBegan:Connect(function(input)
            local is_mouse = input.UserInputType == Enum.UserInputType.MouseButton1
            local is_touch = input.UserInputType == Enum.UserInputType.Touch
            if not is_mouse and not is_touch then
                return
            end

            is_resizing = true
            resize_start_pos = input.Position
            resize_start_size = self.main_frame.AbsoluteSize

            if resize_input_conn then
                resize_input_conn:Disconnect()
            end
            resize_input_conn = input_service.InputChanged:Connect(function(moved_input)
                if not is_resizing then
                    return
                end
                if moved_input.UserInputType ~= Enum.UserInputType.MouseMovement and moved_input.UserInputType ~= Enum.UserInputType.Touch then
                    return
                end
                local delta = moved_input.Position - resize_start_pos
                local new_w = resize_start_size.X + delta.X
                local new_h = resize_start_size.Y + delta.Y
                self:_ResizeLayout(new_w, new_h)
            end)
            if self._TrackConnection then
                self:_TrackConnection(resize_input_conn)
            end

            local end_conn
            end_conn = input.Changed:Connect(function()
                if input.UserInputState == Enum.UserInputState.End then
                    stop_resize()
                    if end_conn then
                        end_conn:Disconnect()
                        end_conn = nil
                    end
                end
            end)
            if self._TrackConnection then
                self:_TrackConnection(end_conn)
            end
        end)

        resize_button.MouseEnter:Connect(function()
            tween_to(resize_handle:FindFirstChildOfClass("ImageLabel"), {ImageColor3 = Color3.fromRGB(160, 160, 160), ImageTransparency = 0}, 0.15)
        end)
        resize_button.MouseLeave:Connect(function()
            if not is_resizing then
                tween_to(resize_handle:FindFirstChildOfClass("ImageLabel"), {ImageColor3 = Color3.fromRGB(72, 72, 72), ImageTransparency = 0.2}, 0.15)
            end
        end)
    end

    local hubNameWidth = measure_text_width(self.config.Name, 17 * scale_factor, Enum.Font.GothamSemibold)
    local searchX = frameWidth - searchWidth - searchRightPadding
    local avatarX = math.min(
        searchX - headerAvatarSize - 18 * scale_factor,
        math.max(headerAvatarBaseX, headerLeftPadding + hubNameWidth + headerAvatarGap)
    )
    local headerNameMaxWidth = math.max(110 * scale_factor, avatarX - headerLeftPadding - headerAvatarGap)
    local avatarRight = avatarX + headerAvatarSize
    local tabHeaderX = math.max(201 * scale_factor, avatarRight + 18 * scale_factor)
    local separatorWidth = math.max(156 * scale_factor, avatarRight - 19 * scale_factor)
    local contentWidth = frameWidth - contentStartX - contentRightPadding
    
    self.hub_name_label = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold),
        TextColor3 = Color3.new(1, 1, 1), Text = self.config.Name, BackgroundTransparency = 1,
        Position = UDim2.new(0, headerLeftPadding, 0, 13 * scale_factor), TextSize = 16 * scale_factor,
        Size = UDim2.new(0, headerNameMaxWidth, 0, 20 * scale_factor),
        TextTruncate = Enum.TextTruncate.AtEnd, TextXAlignment = Enum.TextXAlignment.Left, Parent = self.main_frame
    })
    table.insert(self._gradientLabels, self.hub_name_label)
    
    local playerName = local_player.Name
    self.user_name_label = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Regular),
        TextColor3 = Color3.fromRGB(52, 52, 52), Text = playerName, BackgroundTransparency = 1,
        Position = UDim2.new(0, headerLeftPadding, 0, 32 * scale_factor), TextSize = 12 * scale_factor,
        Size = UDim2.new(0, 120 * scale_factor, 0, 16 * scale_factor),
        TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd,
        Parent = self.main_frame
    })
    self:_SetNameHidden(self._uiVisualSettings.HideName)
    
    self.avatar_image = create("ImageLabel", {
        Image = get_player_avatar(local_player.UserId), BackgroundTransparency = 1,
        Position = UDim2.new(0, avatarX, 0, 17 * scale_factor),
        Size = UDim2.new(0, headerAvatarSize, 0, headerAvatarSize), Parent = self.main_frame
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = self.avatar_image})
    
    self.separator_line = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(255, 255, 255),
        BackgroundTransparency = 0.88,
        Position = UDim2.new(0, 19, 0, 64 * scale_factor),
        Size = UDim2.new(0, separatorWidth, 0, 1), Parent = self.main_frame
    })
    create("UIGradient", {
        Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Color3.new(0, 0, 0)),
            ColorSequenceKeypoint.new(0.1, Color3.new(1, 1, 1)),
            ColorSequenceKeypoint.new(0.9, Color3.new(1, 1, 1)),
            ColorSequenceKeypoint.new(1, Color3.new(0, 0, 0))
        }),
        Parent = self.separator_line
    })
    
    self.tab_name_label = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold),
        TextColor3 = Color3.new(1, 1, 1), Text = "tab name", BackgroundTransparency = 1,
        Position = UDim2.new(0, tabHeaderX, 0, 13 * scale_factor),
        TextSize = 16 * scale_factor, Size = UDim2.new(0, 220, 0, 20 * scale_factor),
        TextXAlignment = Enum.TextXAlignment.Left, Parent = self.main_frame
    })
    table.insert(self._gradientLabels, self.tab_name_label)
    
    self.tab_desc_label = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Regular),
        TextColor3 = Color3.fromRGB(52, 52, 52), Text = "tab description", BackgroundTransparency = 1,
        Position = UDim2.new(0, tabHeaderX, 0, 32 * scale_factor),
        TextSize = 12 * scale_factor, Size = UDim2.new(0, 260, 0, 16 * scale_factor),
        TextXAlignment = Enum.TextXAlignment.Left, Parent = self.main_frame
    })

    self.minimize_btn = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(22, 22, 22), AnchorPoint = Vector2.new(1, 0.5),
        Position = UDim2.new(1, -12 * scale_factor, 0, 32 * scale_factor),
        Size = UDim2.new(0, 20 * scale_factor, 0, 20 * scale_factor),
        ZIndex = 3, Parent = self.main_frame
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = self.minimize_btn})
    create("UIStroke", {Color = Color3.fromRGB(38, 38, 38), Thickness = 1, Parent = self.minimize_btn})
    create("ImageLabel", {
        Image = default_icons.close, ImageColor3 = Color3.fromRGB(75, 75, 75),
        BackgroundTransparency = 1, AnchorPoint = Vector2.new(0.5, 0.5),
        Position = UDim2.new(0.5, 0, 0.5, 0), Size = UDim2.new(0.55, 0, 0.55, 0),
        ZIndex = 4, Parent = self.minimize_btn
    })
    local minimize_click = create("TextButton", {
        Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0),
        ZIndex = 5, Parent = self.minimize_btn
    })
    minimize_click.MouseButton1Click:Connect(function() self:Toggle() end)
    minimize_click.MouseEnter:Connect(function()
        tween_to(self.minimize_btn, {BackgroundColor3 = Color3.fromRGB(55, 35, 35)}, 0.15)
        tween_to(self.minimize_btn:FindFirstChildOfClass("ImageLabel"), {ImageColor3 = Color3.fromRGB(255, 80, 80)}, 0.15)
    end)
    minimize_click.MouseLeave:Connect(function()
        tween_to(self.minimize_btn, {BackgroundColor3 = Color3.fromRGB(22, 22, 22)}, 0.15)
        tween_to(self.minimize_btn:FindFirstChildOfClass("ImageLabel"), {ImageColor3 = Color3.fromRGB(75, 75, 75)}, 0.15)
    end)

    self.search_frame = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(19, 19, 19),
        Position = UDim2.new(0, searchX, 0, 16 * scale_factor),
        Size = UDim2.new(0, searchWidth, 0, 28 * scale_factor),
        Parent = self.main_frame
    })
    create("UICorner", {CornerRadius = UDim.new(0, 8), Parent = self.search_frame})
    create("UIStroke", {Color = Color3.fromRGB(33, 33, 33), Thickness = 1, Parent = self.search_frame})
    create("ImageLabel", {
        Image = default_icons.search,
        ImageColor3 = Color3.fromRGB(120, 120, 120),
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 8, 0.5, -7 * scale_factor),
        Size = UDim2.new(0, 14 * scale_factor, 0, 14 * scale_factor),
        Parent = self.search_frame
    })
    self.search_box = create("TextBox", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = "",
        PlaceholderText = "Search tabs/groups...",
        PlaceholderColor3 = Color3.fromRGB(80, 80, 80),
        TextColor3 = Color3.fromRGB(210, 210, 210),
        TextSize = 13 * scale_factor,
        BackgroundTransparency = 1,
        ClearTextOnFocus = false,
        Position = UDim2.new(0, 28 * scale_factor, 0, 0),
        Size = UDim2.new(1, -34 * scale_factor, 1, 0),
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = self.search_frame
    })
    self:_TrackConnection(self.search_box:GetPropertyChangedSignal("Text"):Connect(function()
        self:SetSearchFilter(self.search_box.Text)
    end))
    
    self.section_scroll = create("ScrollingFrame", {
        BackgroundTransparency = 1, Position = UDim2.new(0, 17, 0, 75 * scale_factor),
        Size = UDim2.new(0, 162 * scale_factor, 0, sectionScrollHeight),
        ScrollBarThickness = 0, CanvasSize = UDim2.new(0, 0, 0, 0),
        AutomaticCanvasSize = Enum.AutomaticSize.Y, ClipsDescendants = true, Parent = self.main_frame
    })

    local sidebar_divider = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(255, 255, 255),
        BackgroundTransparency = 0.9,
        BorderSizePixel = 0,
        Position = UDim2.new(0, 187 * scale_factor, 0, 70 * scale_factor),
        Size = UDim2.new(0, 1, 0, sectionScrollHeight + 10 * scale_factor),
        ZIndex = -9999,
        Parent = self.main_frame
    })
    create("UIGradient", {
        Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Color3.new(0, 0, 0)),
            ColorSequenceKeypoint.new(0.08, Color3.new(1, 1, 1)),
            ColorSequenceKeypoint.new(0.92, Color3.new(1, 1, 1)),
            ColorSequenceKeypoint.new(1, Color3.new(0, 0, 0))
        }),
        Rotation = 90,
        Parent = sidebar_divider
    })

    attach_scrollbar(self, self.section_scroll, self.main_frame, {
        TrackWidth = 5 * scale_factor,
        ThumbWidth = 3 * scale_factor,
        EdgeInset = 1 * scale_factor,
        VerticalInset = 5 * scale_factor,
        XOffset = 16 * scale_factor,
        ZIndex = 6
    })
    
    create("UIPadding", {PaddingLeft = UDim.new(0, 2), PaddingRight = UDim.new(0, 2), PaddingTop = UDim.new(0, 2), Parent = self.section_scroll})
    self.section_layout = create("UIListLayout", {Padding = UDim.new(0, 10), SortOrder = Enum.SortOrder.LayoutOrder, Parent = self.section_scroll})
    --self:SetSmoothScroll(self.section_scroll, 34)
    
    self.content_holder = create("Frame", {
        BackgroundTransparency = 1, Position = UDim2.new(0, contentStartX, 0, 62 * scale_factor),
        Size = UDim2.new(0, contentWidth, 0, contentHeight),
        ClipsDescendants = true, Parent = self.main_frame
    })

    local settingsPanelWidth = 185 * scale_factor
    local settingsPanelHeight = 292 * scale_factor
    self.settings_open = false

    self.settings_btn_frame = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(20, 20, 20),
        Position = UDim2.new(0, 10, 1, -31 * scale_factor),
        Size = UDim2.new(0, 116 * scale_factor, 0, 22 * scale_factor),
        BorderSizePixel = 0,
        Parent = self.main_frame
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = self.settings_btn_frame})
    self.settings_btn_stroke = create("UIStroke", {Color = Color3.fromRGB(45, 45, 45), Parent = self.settings_btn_frame})

    create("ImageLabel", {
        Image = default_icons.settings,
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 7, 0.5, -6 * scale_factor),
        Size = UDim2.new(0, 12 * scale_factor, 0, 12 * scale_factor),
        ImageColor3 = Color3.fromRGB(165, 165, 165),
        Parent = self.settings_btn_frame
    })
    create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = "UI Settings",
        TextColor3 = Color3.fromRGB(185, 185, 185),
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 24 * scale_factor, 0, 0),
        Size = UDim2.new(1, -28 * scale_factor, 1, 0),
        TextXAlignment = Enum.TextXAlignment.Left,
        TextSize = 12 * scale_factor,
        Parent = self.settings_btn_frame
    })
    local settingsToggleButton = create("TextButton", {
        Text = "",
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 1, 0),
        Parent = self.settings_btn_frame
    })

    self.settings_panel = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(15, 15, 15),
        AnchorPoint = Vector2.new(0, 1),
        Position = UDim2.new(0, 10, 1, -36 * scale_factor),
        Size = UDim2.new(0, settingsPanelWidth, 0, 0),
        ClipsDescendants = true,
        Visible = false,
        Parent = self.main_frame
    })
    create("UICorner", {CornerRadius = UDim.new(0, 8), Parent = self.settings_panel})
    create("UIStroke", {Color = Color3.fromRGB(44, 44, 44), Parent = self.settings_panel})

    create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = "UI Tweaks",
        TextColor3 = Color3.new(1, 1, 1),
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 10, 0, 8 * scale_factor),
        Size = UDim2.new(0.7, 0, 0, 16 * scale_factor),
        TextSize = 13 * scale_factor,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = self.settings_panel
    })

    self.accent_preview = create("Frame", {
        BackgroundColor3 = self.config.AccentColor,
        Position = UDim2.new(1, -22 * scale_factor, 0, 11 * scale_factor),
        Size = UDim2.new(0, 10 * scale_factor, 0, 10 * scale_factor),
        Parent = self.settings_panel
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = self.accent_preview})

    local rowY = 30 * scale_factor
    local rowStep = 24 * scale_factor
    local function createSettingsToggle(labelText, initial, callback)
        local rowFrame = create("Frame", {
            BackgroundTransparency = 1,
            Position = UDim2.new(0, 10, 0, rowY),
            Size = UDim2.new(1, -20, 0, 20 * scale_factor),
            Parent = self.settings_panel
        })
        create("TextLabel", {
            FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
            Text = labelText,
            TextColor3 = Color3.fromRGB(150, 150, 150),
            BackgroundTransparency = 1,
            Size = UDim2.new(1, -46 * scale_factor, 1, 0),
            TextSize = 12 * scale_factor,
            TextXAlignment = Enum.TextXAlignment.Left,
            Parent = rowFrame
        })
        local switchFrame = create("Frame", {
            BackgroundColor3 = initial and self.config.AccentColor or Color3.fromRGB(33, 33, 33),
            Position = UDim2.new(1, -34 * scale_factor, 0.5, -8 * scale_factor),
            Size = UDim2.new(0, 34 * scale_factor, 0, 16 * scale_factor),
            Parent = rowFrame
        })
        create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = switchFrame})
        local knob = create("Frame", {
            BackgroundColor3 = initial and Color3.new(1, 1, 1) or Color3.fromRGB(95, 95, 95),
            Position = initial and UDim2.new(0.5, 0, 0.5, -6 * scale_factor) or UDim2.new(0, 2 * scale_factor, 0.5, -6 * scale_factor),
            Size = UDim2.new(0, 12 * scale_factor, 0, 12 * scale_factor),
            Parent = switchFrame
        })
        create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = knob})

        local state = initial == true
        local function setState(nextState, skipCallback)
            state = nextState == true
            tween_to(switchFrame, {BackgroundColor3 = state and self.config.AccentColor or Color3.fromRGB(33, 33, 33)}, 0.16)
            tween_to(knob, {
                Position = state and UDim2.new(0.5, 0, 0.5, -6 * scale_factor) or UDim2.new(0, 2 * scale_factor, 0.5, -6 * scale_factor),
                BackgroundColor3 = state and Color3.new(1, 1, 1) or Color3.fromRGB(95, 95, 95)
            }, 0.16, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
            if not skipCallback then
                callback(state)
            end
        end

        local toggleButton = create("TextButton", {
            Text = "",
            BackgroundTransparency = 1,
            Size = UDim2.new(1, 0, 1, 0),
            Parent = rowFrame
        })
        toggleButton.MouseButton1Click:Connect(function()
            setState(not state, false)
        end)

        rowY = rowY + rowStep
        return {
            Set = setState,
            Get = function()
                return state
            end
        }
    end

    local blurToggleRef = createSettingsToggle("Blur Background", self._uiVisualSettings.Blur, function(enabled)
        self._uiVisualSettings.Blur = enabled
        self:_ApplyOpenCloseVisuals(false)
    end)
    local overlayToggleRef = createSettingsToggle("Overlay FX", self._uiVisualSettings.Snow, function(enabled)
        self:_SetSnowEnabled(enabled)
    end)
    local bgFxToggleRef = createSettingsToggle("Background FX", self._uiVisualSettings.BackgroundEffects, function(enabled)
        self:_SetBackgroundEffectsEnabled(enabled)
    end)
    local gradientToggleRef = createSettingsToggle("Text Gradient", self._uiVisualSettings.TextGradient, function(enabled)
        self:_SetTextGradientEnabled(enabled)
    end)
    local espPreviewToggleRef = createSettingsToggle("ESP Preview", self._uiVisualSettings.ESPSelfPreview, function(enabled)
        self:SetESPPreview(enabled)
    end)
    local hideNameToggleRef = createSettingsToggle("Hide Name", self._uiVisualSettings.HideName, function(enabled)
        self:_SetNameHidden(enabled)
    end)
    local customBgToggleRef = createSettingsToggle("Custom BG", self.config.CustomBackground, function(enabled)
        self.config.CustomBackground = enabled
        self:_SetCustomBackgroundEnabled(enabled)
    end)
    local autoSaveToggleRef = nil
    if self.config.ShowAutoSaveToggle ~= false then
        autoSaveToggleRef = createSettingsToggle("Auto Save Config", self._autoConfigEnabled, function(enabled)
            self._autoConfigEnabled = enabled == true
            if self._autoConfigEnabled then
                self._autoConfigLoadAttempted = false
                self._autoConfigAccumulator = self._autoConfigInterval or 1.2
                self:_TryAutoSaveConfig(true)
            else
                self._autoConfigAccumulator = 0
            end
        end)
    end

    self.settings_toggle_refs = {blurToggleRef, overlayToggleRef, bgFxToggleRef, gradientToggleRef, espPreviewToggleRef, hideNameToggleRef, customBgToggleRef}
    if autoSaveToggleRef then
        table.insert(self.settings_toggle_refs, autoSaveToggleRef)
    end

    local overlayRow = create("Frame", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 10, 0, rowY + 2 * scale_factor),
        Size = UDim2.new(1, -20, 0, 20 * scale_factor),
        Parent = self.settings_panel
    })
    create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = "Overlay",
        TextColor3 = Color3.fromRGB(150, 150, 150),
        BackgroundTransparency = 1,
        Size = UDim2.new(0, 52 * scale_factor, 1, 0),
        TextSize = 12 * scale_factor,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = overlayRow
    })

    local overlayPickerFrame = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(29, 29, 29),
        Position = UDim2.new(1, -84 * scale_factor, 0, 0),
        Size = UDim2.new(0, 84 * scale_factor, 1, 0),
        Parent = overlayRow
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = overlayPickerFrame})
    create("UIStroke", {Color = Color3.fromRGB(44, 44, 44), Parent = overlayPickerFrame})

    self.overlay_mode_label = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = self._overlayMode,
        TextColor3 = Color3.fromRGB(210, 210, 210),
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 8 * scale_factor, 0, 0),
        Size = UDim2.new(1, -24 * scale_factor, 1, 0),
        TextSize = 11.5 * scale_factor,
        TextTruncate = Enum.TextTruncate.AtEnd,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = overlayPickerFrame
    })

    local overlayArrowImage = create("ImageLabel", {
        Image = default_icons.expand,
        ImageColor3 = Color3.fromRGB(132, 132, 132),
        BackgroundTransparency = 1,
        Position = UDim2.new(1, -18 * scale_factor, 0.5, -6 * scale_factor),
        Size = UDim2.new(0, 12 * scale_factor, 0, 12 * scale_factor),
        Parent = overlayPickerFrame
    })

    local overlayDropdownWidth = 102 * scale_factor
    local overlayDropdownRowHeight = 21 * scale_factor
    local overlayDropdownFrame = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(16, 16, 16),
        Size = UDim2.new(0, overlayDropdownWidth, 0, 0),
        ClipsDescendants = true,
        Visible = false,
        ZIndex = 9999,
        Parent = self.dropdown_holder
    })
    create("UICorner", {CornerRadius = UDim.new(0, 7), Parent = overlayDropdownFrame})
    create("UIStroke", {Color = Color3.fromRGB(42, 42, 42), Parent = overlayDropdownFrame})

    local overlayDropdownContainer = create("Frame", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 4 * scale_factor, 0, 4 * scale_factor),
        Size = UDim2.new(1, -8 * scale_factor, 0, 0),
        ZIndex = 10000,
        Parent = overlayDropdownFrame
    })

    local overlayDropdownOpen = false
    local overlayDropdownPositionConn = nil
    local overlayDropdownOutsideConn = nil

    local function updateOverlayDropdownPosition()
        local pickerAbsPos = overlayPickerFrame.AbsolutePosition
        local pickerAbsSize = overlayPickerFrame.AbsoluteSize
        overlayDropdownFrame.Position = UDim2.new(0, pickerAbsPos.X + pickerAbsSize.X - overlayDropdownWidth, 0, pickerAbsPos.Y + pickerAbsSize.Y + 5)
    end

    local function closeOverlayDropdown(isInstant)
        overlayDropdownOpen = false
        if overlayDropdownPositionConn then
            overlayDropdownPositionConn()
            overlayDropdownPositionConn = nil
        end
        if overlayDropdownOutsideConn then
            overlayDropdownOutsideConn:Disconnect()
            overlayDropdownOutsideConn = nil
        end
        tween_to(overlayArrowImage, {Rotation = 0}, 0.16)
        tween_to(overlayPickerFrame, {BackgroundColor3 = Color3.fromRGB(29, 29, 29)}, 0.16)
        if isInstant then
            overlayDropdownFrame.Size = UDim2.new(0, overlayDropdownWidth, 0, 0)
            overlayDropdownFrame.Visible = false
            return
        end
        tween_to(overlayDropdownFrame, {Size = UDim2.new(0, overlayDropdownWidth, 0, 0)}, 0.18, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
        task.delay(0.18, function()
            if overlayDropdownFrame and overlayDropdownFrame.Parent and not overlayDropdownOpen then
                overlayDropdownFrame.Visible = false
            end
        end)
    end

    local rebuildOverlayDropdownOptions
    rebuildOverlayDropdownOptions = function()
        for _, child in ipairs(overlayDropdownContainer:GetChildren()) do
            if child:IsA("Frame") or child:IsA("TextButton") then
                child:Destroy()
            end
        end
        local optionY = 0
        for _, modeName in ipairs(self._overlayModes) do
            local isSelected = modeName == self._overlayMode
            local optionFrame = create("Frame", {
                BackgroundColor3 = isSelected and Color3.fromRGB(33, 33, 33) or Color3.fromRGB(23, 23, 23),
                Position = UDim2.new(0, 0, 0, optionY),
                Size = UDim2.new(1, 0, 0, overlayDropdownRowHeight - 2 * scale_factor),
                ZIndex = 10001,
                Parent = overlayDropdownContainer
            })
            create("UICorner", {CornerRadius = UDim.new(0, 5), Parent = optionFrame})
            local optionLabel = create("TextLabel", {
                FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                Text = modeName,
                TextColor3 = isSelected and Color3.new(1, 1, 1) or Color3.fromRGB(138, 138, 138),
                BackgroundTransparency = 1,
                Size = UDim2.new(1, -8 * scale_factor, 1, 0),
                Position = UDim2.new(0, 8 * scale_factor, 0, 0),
                TextXAlignment = Enum.TextXAlignment.Left,
                TextSize = 11.5 * scale_factor,
                ZIndex = 10002,
                Parent = optionFrame
            })
            local optionButton = create("TextButton", {
                Text = "",
                BackgroundTransparency = 1,
                Size = UDim2.new(1, 0, 1, 0),
                ZIndex = 10003,
                Parent = optionFrame
            })
            optionButton.MouseButton1Click:Connect(function()
                self:_SetOverlayMode(modeName)
                self.overlay_mode_label.Text = self._overlayMode
                rebuildOverlayDropdownOptions()
                closeOverlayDropdown(false)
            end)
            optionButton.MouseEnter:Connect(function()
                if self._overlayMode ~= modeName then
                    tween_to(optionFrame, {BackgroundColor3 = Color3.fromRGB(30, 30, 30)}, 0.12)
                    tween_to(optionLabel, {TextColor3 = Color3.fromRGB(188, 188, 188)}, 0.12)
                end
            end)
            optionButton.MouseLeave:Connect(function()
                if self._overlayMode ~= modeName then
                    tween_to(optionFrame, {BackgroundColor3 = Color3.fromRGB(23, 23, 23)}, 0.12)
                    tween_to(optionLabel, {TextColor3 = Color3.fromRGB(138, 138, 138)}, 0.12)
                end
            end)
            optionY = optionY + overlayDropdownRowHeight
        end
        overlayDropdownContainer.Size = UDim2.new(1, -8 * scale_factor, 0, optionY)
    end

    local function openOverlayDropdown()
        overlayDropdownOpen = true
        rebuildOverlayDropdownOptions()
        updateOverlayDropdownPosition()
        overlayDropdownFrame.Visible = true
        tween_to(overlayDropdownFrame, {Size = UDim2.new(0, overlayDropdownWidth, 0, #self._overlayModes * overlayDropdownRowHeight + 8 * scale_factor)}, 0.2)
        tween_to(overlayArrowImage, {Rotation = 180}, 0.16)
        tween_to(overlayPickerFrame, {BackgroundColor3 = Color3.fromRGB(35, 35, 35)}, 0.16)
        if overlayDropdownPositionConn then
            overlayDropdownPositionConn()
            overlayDropdownPositionConn = nil
        end
        overlayDropdownPositionConn = start_position_tracker(self, overlayPickerFrame, function()
            if overlayDropdownOpen then
                updateOverlayDropdownPosition()
            end
        end)
        if overlayDropdownOutsideConn then
            overlayDropdownOutsideConn:Disconnect()
            overlayDropdownOutsideConn = nil
        end
        overlayDropdownOutsideConn = self:_TrackConnection(input_service.InputBegan:Connect(function(input)
            if not overlayDropdownOpen then
                return
            end
            local isClick = input.UserInputType == Enum.UserInputType.MouseButton1
                or input.UserInputType == Enum.UserInputType.MouseButton2
                or input.UserInputType == Enum.UserInputType.Touch
            if not isClick then
                return
            end
            local clickPos = input.Position
            local menuPos = overlayDropdownFrame.AbsolutePosition
            local menuSize = overlayDropdownFrame.AbsoluteSize
            local pickerPos = overlayPickerFrame.AbsolutePosition
            local pickerSize = overlayPickerFrame.AbsoluteSize
            local insideMenu = clickPos.X >= menuPos.X and clickPos.X <= menuPos.X + menuSize.X and clickPos.Y >= menuPos.Y and clickPos.Y <= menuPos.Y + menuSize.Y
            local insidePicker = clickPos.X >= pickerPos.X and clickPos.X <= pickerPos.X + pickerSize.X and clickPos.Y >= pickerPos.Y and clickPos.Y <= pickerPos.Y + pickerSize.Y
            if not insideMenu and not insidePicker then
                closeOverlayDropdown(false)
            end
        end))
    end

    local overlayPickerButton = create("TextButton", {
        Text = "",
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 1, 0),
        Parent = overlayPickerFrame
    })
    overlayPickerButton.MouseButton1Click:Connect(function()
        if overlayDropdownOpen then
            closeOverlayDropdown(false)
        else
            openOverlayDropdown()
        end
    end)
    overlayPickerButton.MouseEnter:Connect(function()
        if not overlayDropdownOpen then
            tween_to(overlayPickerFrame, {BackgroundColor3 = Color3.fromRGB(35, 35, 35)}, 0.12)
        end
    end)
    overlayPickerButton.MouseLeave:Connect(function()
        if not overlayDropdownOpen then
            tween_to(overlayPickerFrame, {BackgroundColor3 = Color3.fromRGB(29, 29, 29)}, 0.12)
        end
    end)

    rowY = rowY + rowStep

    local fontRow = create("Frame", {
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 10, 0, rowY + 2 * scale_factor),
        Size = UDim2.new(1, -20, 0, 20 * scale_factor),
        Parent = self.settings_panel
    })
    create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = "Font",
        TextColor3 = Color3.fromRGB(150, 150, 150),
        BackgroundTransparency = 1,
        Size = UDim2.new(0, 34 * scale_factor, 1, 0),
        TextSize = 12 * scale_factor,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = fontRow
    })
    self.uiSettingsFontValueLabel = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = self._fontPresets[self._fontPresetIndex].Name,
        TextColor3 = Color3.fromRGB(210, 210, 210),
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 36 * scale_factor, 0, 0),
        Size = UDim2.new(0, 82 * scale_factor, 1, 0),
        TextSize = 12 * scale_factor,
        TextTruncate = Enum.TextTruncate.AtEnd,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = fontRow
    })
    local fontCycleFrame = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(29, 29, 29),
        Position = UDim2.new(1, -44 * scale_factor, 0, 0),
        Size = UDim2.new(0, 44 * scale_factor, 1, 0),
        Parent = fontRow
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = fontCycleFrame})
    create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = "Next",
        TextColor3 = Color3.fromRGB(190, 190, 190),
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 1, 0),
        TextSize = 11 * scale_factor,
        Parent = fontCycleFrame
    })
    local fontCycleButton = create("TextButton", {
        Text = "",
        BackgroundTransparency = 1,
        Size = UDim2.new(1, 0, 1, 0),
        Parent = fontCycleFrame
    })
    fontCycleButton.MouseButton1Click:Connect(function()
        self:SetFontPreset(self._fontPresetIndex + 1)
    end)

    local accentRowY = rowY + 28 * scale_factor
    create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        Text = "Accent",
        TextColor3 = Color3.fromRGB(150, 150, 150),
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 10, 0, accentRowY),
        Size = UDim2.new(0, 46 * scale_factor, 0, 16 * scale_factor),
        TextSize = 12 * scale_factor,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = self.settings_panel
    })
    local accentColors = {
        Color3.fromRGB(2, 133, 255),
        Color3.fromRGB(48, 196, 122),
        Color3.fromRGB(237, 88, 88),
        Color3.fromRGB(255, 169, 64),
        Color3.fromRGB(185, 108, 255)
    }
    for index, color in ipairs(accentColors) do
        local swatch = create("Frame", {
            BackgroundColor3 = color,
            Position = UDim2.new(0, (58 + (index - 1) * 22) * scale_factor, 0, accentRowY - 1 * scale_factor),
            Size = UDim2.new(0, 16 * scale_factor, 0, 16 * scale_factor),
            Parent = self.settings_panel
        })
        create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = swatch})
        local swatchClick = create("TextButton", {
            Text = "",
            BackgroundTransparency = 1,
            Size = UDim2.new(1, 0, 1, 0),
            Parent = swatch
        })
        swatchClick.MouseButton1Click:Connect(function()
            self:SetAccentColor(color)
            blurToggleRef:Set(self._uiVisualSettings.Blur, true)
            overlayToggleRef:Set(self._uiVisualSettings.Snow, true)
            bgFxToggleRef:Set(self._uiVisualSettings.BackgroundEffects, true)
            gradientToggleRef:Set(self._uiVisualSettings.TextGradient, true)
        end)
    end

    local function setSettingsPanelOpen(openState)
        self.settings_open = openState == true
        if self.settings_open then
            self.settings_panel.Visible = true
            tween_to(self.settings_panel, {Size = UDim2.new(0, settingsPanelWidth, 0, settingsPanelHeight)}, 0.22)
            tween_to(self.settings_btn_frame, {BackgroundColor3 = Color3.fromRGB(30, 30, 30)}, 0.2)
            tween_to(self.settings_btn_stroke, {Color = self.config.AccentColor:Lerp(Color3.fromRGB(20, 20, 20), 0.45)}, 0.2)
        else
            closeOverlayDropdown(true)
            tween_to(self.settings_panel, {Size = UDim2.new(0, settingsPanelWidth, 0, 0)}, 0.18, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
            tween_to(self.settings_btn_frame, {BackgroundColor3 = Color3.fromRGB(20, 20, 20)}, 0.2)
            tween_to(self.settings_btn_stroke, {Color = Color3.fromRGB(45, 45, 45)}, 0.2)
            task.delay(0.18, function()
                if self.settings_panel and self.settings_panel.Parent and not self.settings_open then
                    self.settings_panel.Visible = false
                end
            end)
        end
    end

    settingsToggleButton.MouseButton1Click:Connect(function()
        setSettingsPanelOpen(not self.settings_open)
    end)
    settingsToggleButton.MouseEnter:Connect(function()
        tween_to(self.settings_btn_frame, {BackgroundColor3 = Color3.fromRGB(28, 28, 28)}, 0.15)
    end)
    settingsToggleButton.MouseLeave:Connect(function()
        if not self.settings_open then
            tween_to(self.settings_btn_frame, {BackgroundColor3 = Color3.fromRGB(20, 20, 20)}, 0.15)
        end
    end)
    -- Sleek floating toggle button (appears when UI is closed)
    self.floating_toggle = create("ImageLabel", {
        Name = "AtomFloatingToggle",
        Image = self.config.ToggleImage or atomic_logo,
        ImageColor3 = self.config.AccentColor,
        BackgroundTransparency = 1,
        Position = UDim2.new(0, 14, 0, 14),
        Size = UDim2.new(0, 38 * scale_factor, 0, 38 * scale_factor),
        AnchorPoint = Vector2.new(0, 0),
        ZIndex = 99999,
        Parent = self.screen_gui,
        Visible = false,
        Active = true
    })

    local ft_click = create("TextButton", {
        Text = "",
        BackgroundTransparency = 1,
        Size = UDim2.new(1.4, 0, 1.4, 0),
        Position = UDim2.new(-0.2, 0, -0.2, 0),
        ZIndex = 99999,
        Parent = self.floating_toggle
    })

    ft_click.MouseButton1Click:Connect(function()
        self:Toggle()
    end)
    ft_click.MouseEnter:Connect(function()
        tween_to(self.floating_toggle, {ImageColor3 = Color3.new(1, 1, 1)}, 0.15)
    end)
    ft_click.MouseLeave:Connect(function()
        tween_to(self.floating_toggle, {ImageColor3 = self.config.AccentColor}, 0.15)
    end)
end




function atom_ui:SetWatermark(config)
    if self._destroyed then return end
    config = config or {}
    config.Text = config.Text or "Watermark"
    config.Position = config.Position or "TopRight"

    if self.watermark_frame then
        pcall(function() self.watermark_frame:Destroy() end)
    end

    local positions = {
        TopRight = UDim2.new(1, -12, 0, 12),
        TopLeft = UDim2.new(0, 12, 0, 12),
        BottomRight = UDim2.new(1, -12, 1, -12),
        BottomLeft = UDim2.new(0, 12, 1, -12)
    }

    self.watermark_frame = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(14, 14, 14),
        BackgroundTransparency = 0.25,
        Position = positions[config.Position] or positions.TopRight,
        AnchorPoint = Vector2.new(1, 0),
        Size = UDim2.new(0, 200, 0, 28),
        ZIndex = 99999,
        Parent = self.screen_gui
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = self.watermark_frame})
    create("UIStroke", {Color = Color3.fromRGB(40, 40, 40), Thickness = 1, Parent = self.watermark_frame})

    self.watermark_label = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        TextColor3 = Color3.fromRGB(210, 210, 210),
        Text = config.Text,
        BackgroundTransparency = 1,
        Size = UDim2.new(1, -16, 1, 0),
        Position = UDim2.new(0, 8, 0, 0),
        TextSize = 12 * scale_factor,
        TextXAlignment = Enum.TextXAlignment.Center,
        Parent = self.watermark_frame
    })

    local bounds = text_service:GetTextSize(
        config.Text,
        12 * scale_factor,
        Enum.Font.GothamSemibold,
        Vector2.new(800, 40)
    )
    self.watermark_frame.Size = UDim2.new(0, math.max(100, bounds.X + 24), 0, 28)
end

function atom_ui:SetWatermarkText(text)
    if self._destroyed or not self.watermark_label then return end
    self.watermark_label.Text = tostring(text or "")
    local bounds = text_service:GetTextSize(
        tostring(text or ""),
        12 * scale_factor,
        Enum.Font.GothamSemibold,
        Vector2.new(800, 40)
    )
    if self.watermark_frame then
        self.watermark_frame.Size = UDim2.new(0, math.max(100, bounds.X + 24), 0, 28)
    end
end


function atom_ui:BuildNotificationHolder()
    self.notification_holder = create("Frame", {
        BackgroundTransparency = 1, Position = UDim2.new(0, 20, 0.5, 0),
        AnchorPoint = Vector2.new(0, 0.5), Size = UDim2.new(0, 300 * scale_factor, 0, 400),
        Parent = self.screen_gui
    })
    create("UIListLayout", {Padding = UDim.new(0, 10), SortOrder = Enum.SortOrder.LayoutOrder, VerticalAlignment = Enum.VerticalAlignment.Center, Parent = self.notification_holder})
end

function atom_ui:Notify(config)
    config = config or {}
    config.Title = tostring(config.Title or "Notification")
    config.Description = tostring(config.Description or "")
    config.Duration = tonumber(config.Duration) or 3
    config.Duration = math.max(0.8, config.Duration)
    config.Icon = config.Icon or "rbxassetid://10747361219"

    if self._destroyed or self._isApplyingConfig then
        return nil
    end

    local notificationKey = config.Title .. "\31" .. config.Description
    local nowClock = os.clock()
    local lastNotificationAt = self._notificationTimestamps[notificationKey]
    if lastNotificationAt and (nowClock - lastNotificationAt) < 0.85 then
        return nil
    end
    self._notificationTimestamps[notificationKey] = nowClock
    
    local hasDescription = normalize_search(config.Description) ~= ""
    local titleBounds = text_service:GetTextSize(
        config.Title,
        15 * scale_factor,
        Enum.Font.GothamSemibold,
        Vector2.new(210 * scale_factor, math.huge)
    )
    local descBounds = Vector2.new(0, 0)
    if hasDescription then
        descBounds = text_service:GetTextSize(
            config.Description,
            13 * scale_factor,
            Enum.Font.GothamSemibold,
            Vector2.new(220 * scale_factor, math.huge)
        )
    end
    
    local notifWidth = math.max(190 * scale_factor, math.min(310 * scale_factor, math.max(titleBounds.X, descBounds.X) + 84 * scale_factor))
    local notifHeight = hasDescription and (66 * scale_factor) or (52 * scale_factor)
    
    local notificationFrame = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(14, 14, 14),
        Position = UDim2.new(-1.25, 0, 0, 0),
        Size = UDim2.new(0, notifWidth, 0, notifHeight),
        BackgroundTransparency = 0.18,
        ClipsDescendants = true,
        Parent = self.notification_holder
    })
    create("UICorner", {CornerRadius = UDim.new(0, 12), Parent = notificationFrame})
    local notificationStroke = create("UIStroke", {
        Color = Color3.fromRGB(38, 38, 38),
        Thickness = 1.1,
        Parent = notificationFrame
    })
    create("UIGradient", {
        Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Color3.fromRGB(24, 24, 24)),
            ColorSequenceKeypoint.new(1, Color3.fromRGB(16, 16, 16))
        }),
        Rotation = 22,
        Parent = notificationFrame
    })
    local uiScaleRef = create("UIScale", {Scale = 0.88, Parent = notificationFrame})
    
    local glowEffect = create("ImageLabel", {
        Name = "NotifGlow",
        BackgroundTransparency = 1,
        Image = "rbxassetid://5028857084",
        ImageColor3 = self.config.AccentColor,
        ImageTransparency = 0.92,
        Position = UDim2.new(0.25, 0, 0.5, 0),
        AnchorPoint = Vector2.new(0.5, 0.5),
        Size = UDim2.new(1.8, 0, 2, 0),
        ZIndex = 0,
        Parent = notificationFrame
    })
    
    local accentBar = create("Frame", {
        BackgroundColor3 = self.config.AccentColor,
        Position = UDim2.new(0, 0, 0, 0),
        Size = UDim2.new(0, 4 * scale_factor, 1, 0),
        Parent = notificationFrame
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = accentBar})
    
    local iconHolder = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(24, 24, 24),
        Position = UDim2.new(0, 12 * scale_factor, 0.5, 0),
        AnchorPoint = Vector2.new(0, 0.5),
        Size = UDim2.new(0, 28 * scale_factor, 0, 28 * scale_factor),
        Parent = notificationFrame
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = iconHolder})
    create("UIStroke", {
        Color = self.config.AccentColor:Lerp(Color3.fromRGB(16, 16, 16), 0.55),
        Thickness = 1.1,
        Parent = iconHolder
    })
    
    local notifImageLabel = create("ImageLabel", {
        Image = config.Icon,
        BackgroundTransparency = 1,
        Position = UDim2.new(0.5, 0, 0.5, 0),
        AnchorPoint = Vector2.new(0.5, 0.5),
        Size = UDim2.new(0, 17 * scale_factor, 0, 17 * scale_factor),
        ImageTransparency = 1,
        Parent = iconHolder
    })
    
    local textStartX = 48 * scale_factor
    local notifTitle = create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        TextColor3 = Color3.new(1, 1, 1),
        Text = config.Title,
        BackgroundTransparency = 1,
        Position = hasDescription and UDim2.new(0, textStartX, 0, 8 * scale_factor) or UDim2.new(0, textStartX, 0.5, -9 * scale_factor),
        TextSize = 15 * scale_factor,
        Size = UDim2.new(1, -textStartX - 12 * scale_factor, 0, 18 * scale_factor),
        TextXAlignment = Enum.TextXAlignment.Left,
        TextTruncate = Enum.TextTruncate.AtEnd,
        TextTransparency = 1,
        Parent = notificationFrame
    })
    
    local notifDescription = nil
    if hasDescription then
        notifDescription = create("TextLabel", {
            FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
            TextColor3 = Color3.fromRGB(170, 170, 170),
            Text = config.Description,
            BackgroundTransparency = 1,
            Position = UDim2.new(0, textStartX, 0, 28 * scale_factor),
            TextSize = 12.5 * scale_factor,
            Size = UDim2.new(1, -textStartX - 12 * scale_factor, 0, 16 * scale_factor),
            TextXAlignment = Enum.TextXAlignment.Left,
            TextTruncate = Enum.TextTruncate.AtEnd,
            TextTransparency = 1,
            Parent = notificationFrame
        })
    end
    
    local progressTrack = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(28, 28, 28),
        Position = UDim2.new(0, 10 * scale_factor, 1, -6 * scale_factor),
        Size = UDim2.new(1, -20 * scale_factor, 0, 2 * scale_factor),
        BorderSizePixel = 0,
        Parent = notificationFrame
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = progressTrack})
    
    local progressFill = create("Frame", {
        BackgroundColor3 = self.config.AccentColor,
        Size = UDim2.new(1, 0, 1, 0),
        BorderSizePixel = 0,
        Parent = progressTrack
    })
    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = progressFill})
    
    local progressTween = tween_service:Create(
        progressFill,
        TweenInfo.new(config.Duration, Enum.EasingStyle.Linear, Enum.EasingDirection.Out),
        {Size = UDim2.new(0, 0, 1, 0)}
    )

    table.insert(self.notifications, notificationFrame)
    while #self.notifications > 5 do
        local oldestNotification = table.remove(self.notifications, 1)
        if oldestNotification and oldestNotification.Parent then
            oldestNotification:Destroy()
        end
    end
    
    task.defer(function()
        if not notificationFrame or not notificationFrame.Parent then return end
        tween_to(notificationFrame, {Position = UDim2.new(0, 0, 0, 0), BackgroundTransparency = 0.05}, 0.44, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
        tween_to(uiScaleRef, {Scale = 1}, 0.44, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
        tween_to(glowEffect, {ImageTransparency = 0.8}, 0.3)
        tween_to(notificationStroke, {Color = self.config.AccentColor:Lerp(Color3.fromRGB(24, 24, 24), 0.65)}, 0.3)
        tween_to(notifImageLabel, {ImageTransparency = 0}, 0.24)
        tween_to(notifTitle, {TextTransparency = 0}, 0.24)
        if notifDescription then
            tween_to(notifDescription, {TextTransparency = 0}, 0.24)
        end
        progressTween:Play()
    end)
    
    task.delay(config.Duration, function()
        if notificationFrame and notificationFrame.Parent then
            progressTween:Cancel()
            tween_to(glowEffect, {ImageTransparency = 1}, 0.2)
            tween_to(notifImageLabel, {ImageTransparency = 1}, 0.2)
            tween_to(notifTitle, {TextTransparency = 1}, 0.2)
            if notifDescription then
                tween_to(notifDescription, {TextTransparency = 1}, 0.2)
            end
            tween_to(notificationFrame, {Position = UDim2.new(-1.25, 0, 0, 0), BackgroundTransparency = 1}, 0.38, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
            tween_to(uiScaleRef, {Scale = 0.9}, 0.34, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
            task.wait(0.4)
            if notificationFrame and notificationFrame.Parent then
                notificationFrame:Destroy()
            end
        end
        for index = #self.notifications, 1, -1 do
            if self.notifications[index] == notificationFrame then
                table.remove(self.notifications, index)
                break
            end
        end
    end)
    return notificationFrame
end

function atom_ui:AddSection(config)
    config = config or {}
    config.Name = config.Name or "Section"
    config.Icon = get_icon(config.Icon, default_icons.section)
    
    local sectionObj = {}
    sectionObj.tabs = {}
    sectionObj.isExpanded = true
    sectionObj.Library = self
    
    sectionObj.container = create("Frame", {
        BackgroundTransparency = 1, Size = UDim2.new(0, 160 * scale_factor, 0, 34 * scale_factor),
        ClipsDescendants = true, Parent = self.section_scroll
    })
    
    sectionObj.mainFrame = create("Frame", {
        BackgroundColor3 = Color3.fromRGB(16, 16, 16), Position = UDim2.new(0, 1, 0, 2),
        Size = UDim2.new(0, 158 * scale_factor, 0, 30 * scale_factor), Parent = sectionObj.container
    })
    create("UICorner", {CornerRadius = UDim.new(0, 8), Parent = sectionObj.mainFrame})
    
    create("ImageLabel", {
        Image = config.Icon, BackgroundTransparency = 1,
        Position = UDim2.new(0, 10, 0.5, -7.5 * scale_factor),
        Size = UDim2.new(0, 15 * scale_factor, 0, 15 * scale_factor), Parent = sectionObj.mainFrame
    })
    
    create("TextLabel", {
        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
        TextColor3 = Color3.new(1, 1, 1), Text = config.Name, BackgroundTransparency = 1,
        Position = UDim2.new(0, 33, 0.5, -9 * scale_factor), TextSize = 15.5 * scale_factor,
        Size = UDim2.new(0, 84, 0, 18 * scale_factor), TextXAlignment = Enum.TextXAlignment.Left,
        Parent = sectionObj.mainFrame
    })
    
    local expandButtonImg = create("ImageButton", {
        Image = default_icons.expand, BackgroundTransparency = 1,
        Position = UDim2.new(1, -24, 0.5, -8.5 * scale_factor),
        Size = UDim2.new(0, 17 * scale_factor, 0, 17 * scale_factor), Parent = sectionObj.mainFrame
    })
    
    sectionObj.tab_holder = create("Frame", {
        BackgroundTransparency = 1, Position = UDim2.new(0, 10, 0, 40 * scale_factor),
        Size = UDim2.new(0, 148 * scale_factor, 0, 0), ClipsDescendants = true, Parent = sectionObj.container
    })
    
    sectionObj.tab_layout = create("UIListLayout", {Padding = UDim.new(0, 5), SortOrder = Enum.SortOrder.LayoutOrder, Parent = sectionObj.tab_holder})
    
    local function update_container_size()
        local tabsHeight = sectionObj.tab_layout.AbsoluteContentSize.Y
        sectionObj.tab_holder.Size = UDim2.new(0, 148 * scale_factor, 0, tabsHeight)
        if sectionObj.isExpanded then
            tween_to(sectionObj.container, {Size = UDim2.new(0, 160 * scale_factor, 0, 34 * scale_factor + tabsHeight + 10)}, 0.25)
        end
    end
    
    self:_TrackConnection(sectionObj.tab_layout:GetPropertyChangedSignal("AbsoluteContentSize"):Connect(update_container_size))
    
    self:_TrackConnection(expandButtonImg.MouseButton1Click:Connect(function()
        sectionObj.isExpanded = not sectionObj.isExpanded
        tween_to(expandButtonImg, {Rotation = sectionObj.isExpanded and 0 or -90}, 0.25)
        if sectionObj.isExpanded then
            local tabsHeight = sectionObj.tab_layout.AbsoluteContentSize.Y
            tween_to(sectionObj.container, {Size = UDim2.new(0, 160 * scale_factor, 0, 34 * scale_factor + tabsHeight + 10)}, 0.25)
        else
            tween_to(sectionObj.container, {Size = UDim2.new(0, 160 * scale_factor, 0, 34 * scale_factor)}, 0.25)
        end
    end))

    function sectionObj:AddTab(tabConfig)
        tabConfig = tabConfig or {}
        tabConfig.Name = tabConfig.Name or "Tab"
        tabConfig.Description = tabConfig.Description or "Tab description"
        tabConfig.Icon = get_icon(tabConfig.Icon, default_icons.tab)
        
        local tabObj = {}
        tabObj.tab_name = tabConfig.Name
        tabObj.searchTerms = {tabConfig.Name, tabConfig.Description}
        tabObj.groups = {}
        tabObj.group_offsets = {Left = 0, Right = 0}
        tabObj.isActive = false
        tabObj.Library = sectionObj.Library
        tabObj.defaultButtonSize = UDim2.new(0, 140 * scale_factor, 0, 31 * scale_factor)
        
        tabObj.button_frame = create("Frame", {
            BackgroundColor3 = sectionObj.Library.config.AccentColor, BackgroundTransparency = 1,
            Size = tabObj.defaultButtonSize, ClipsDescendants = true, Parent = sectionObj.tab_holder
        })
        create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = tabObj.button_frame})
        
        tabObj.iconImg = create("ImageLabel", {
            ImageColor3 = Color3.fromRGB(89, 89, 89), Image = tabConfig.Icon, BackgroundTransparency = 1,
            Position = UDim2.new(0, 10, 0.5, -7.5 * scale_factor),
            Size = UDim2.new(0, 15 * scale_factor, 0, 15 * scale_factor), Parent = tabObj.button_frame
        })
        
        tabObj.nameLabel = create("TextLabel", {
            FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
            TextColor3 = Color3.fromRGB(89, 89, 89), Text = tabConfig.Name, BackgroundTransparency = 1,
            Position = UDim2.new(0, 30, 0.5, -8.5 * scale_factor), TextSize = 13.8 * scale_factor,
            Size = UDim2.new(0, 108 * scale_factor, 0, 17 * scale_factor),
            TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd,
            ClipsDescendants = true, Parent = tabObj.button_frame
        })
        
        local tabClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Parent = tabObj.button_frame})
        
        tabObj.content_scroll = create("ScrollingFrame", {
            BackgroundTransparency = 1, Position = UDim2.new(0, 4, 0, 4),
            Size = UDim2.new(1, -8, 1, -8), ScrollBarThickness = 0,
            CanvasSize = UDim2.new(0, 540 * scale_factor, 0, 0), Visible = false,
            Parent = sectionObj.Library.content_holder
        })
        attach_scrollbar(sectionObj.Library, tabObj.content_scroll, sectionObj.Library.content_holder, {
            TrackWidth = 7 * scale_factor,
            ThumbWidth = 3 * scale_factor,
            EdgeInset = 2 * scale_factor,
            VerticalInset = 4 * scale_factor,
            IdleThumbHeight = 46 * scale_factor,
            AlwaysShowTrack = true,
            ZIndex = 6
        })
        --sectionObj.Library:SetSmoothScroll(tabObj.content_scroll, 38)
        
        tabObj.left_column = create("Frame", {BackgroundTransparency = 1, Size = UDim2.new(0, 262 * scale_factor, 0, 1000), Parent = tabObj.content_scroll})
        tabObj.right_column = create("Frame", {BackgroundTransparency = 1, Position = UDim2.new(0, 272 * scale_factor, 0, 0), Size = UDim2.new(0, 262 * scale_factor, 0, 1000), Parent = tabObj.content_scroll})
        
        local groupSpacingY = 15 * scale_factor
        local function relayout_groups()
            local sideOffsets = {Left = 0, Right = 0}
            for _, group in ipairs(tabObj.groups) do
                if group.mainFrame and group.mainFrame.Parent then
                    local side = group.side == "Right" and "Right" or "Left"
                    local nextY = sideOffsets[side]
                    group.mainFrame.Position = UDim2.new(0, 1, 0, nextY + 1)
                    sideOffsets[side] = nextY + group.mainFrame.Size.Y.Offset + groupSpacingY
                end
            end
            tabObj.group_offsets.Left = sideOffsets.Left
            tabObj.group_offsets.Right = sideOffsets.Right
            local maxHeight = math.max(sideOffsets.Left, sideOffsets.Right)
            tabObj.content_scroll.CanvasSize = UDim2.new(0, tabObj.content_scroll.AbsoluteSize.X, 0, maxHeight)
        end
        
        function tabObj:Activate()
            if tabObj.isActive then
                return
            end
            local previousTab = sectionObj.Library.active_tab
            if previousTab and previousTab ~= tabObj then
                previousTab:Deactivate(true)
            end
            sectionObj.Library.active_tab = tabObj
            tabObj.isActive = true
            tabObj.content_scroll.Position = UDim2.new(0, 14 * scale_factor, 0, 4)
            tabObj.content_scroll.Visible = true
            tween_to(tabObj.content_scroll, {Position = UDim2.new(0, 4, 0, 4)}, 0.26, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
            tween_to(tabObj.button_frame, {BackgroundTransparency = 0}, 0.22)
            tween_to(tabObj.iconImg, {ImageColor3 = Color3.new(1, 1, 1)}, 0.22)
            tween_to(tabObj.nameLabel, {TextColor3 = Color3.new(1, 1, 1)}, 0.22)
            sectionObj.Library.tab_name_label.Text = tabConfig.Name
            sectionObj.Library.tab_desc_label.Text = tabConfig.Description
        end
        
        function tabObj:Deactivate(skipAnimation)
            tabObj.isActive = false
            for _, group in ipairs(tabObj.groups) do
                for _, element in ipairs(group.elements) do
                    if type(element) == "table" and type(element.Close) == "function" then
                        pcall(function()
                            element:Close()
                        end)
                    end
                end
            end
            if skipAnimation then
                tabObj.content_scroll.Visible = false
                tabObj.content_scroll.Position = UDim2.new(0, 4, 0, 4)
            else
                tween_to(tabObj.content_scroll, {Position = UDim2.new(0, -8 * scale_factor, 0, 4)}, 0.18, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                task.delay(0.18, function()
                    if not tabObj.isActive and tabObj.content_scroll and tabObj.content_scroll.Parent then
                        tabObj.content_scroll.Visible = false
                        tabObj.content_scroll.Position = UDim2.new(0, 4, 0, 4)
                    end
                end)
            end
            tween_to(tabObj.button_frame, {BackgroundTransparency = 1}, 0.18)
            tween_to(tabObj.iconImg, {ImageColor3 = Color3.fromRGB(89, 89, 89)}, 0.18)
            tween_to(tabObj.nameLabel, {TextColor3 = Color3.fromRGB(89, 89, 89)}, 0.18)
        end
        
        tabClickButton.MouseButton1Click:Connect(function() if not tabObj.isActive then tabObj:Activate() end end)
        tabClickButton.MouseEnter:Connect(function()
            if not tabObj.isActive then
                tween_to(tabObj.nameLabel, {TextColor3 = Color3.fromRGB(150, 150, 150)}, 0.2)
                tween_to(tabObj.iconImg, {ImageColor3 = Color3.fromRGB(150, 150, 150)}, 0.2)
            end
        end)
        tabClickButton.MouseLeave:Connect(function()
            if not tabObj.isActive then
                tween_to(tabObj.nameLabel, {TextColor3 = Color3.fromRGB(89, 89, 89)}, 0.2)
                tween_to(tabObj.iconImg, {ImageColor3 = Color3.fromRGB(89, 89, 89)}, 0.2)
            end
        end)

        function tabObj:AddGroup(groupConfig)
            groupConfig = groupConfig or {}
            groupConfig.Name = groupConfig.Name or "Group"
            groupConfig.Side = groupConfig.Side or "Left"
            groupConfig.Icon = get_icon(groupConfig.Icon, default_icons.group)
            if string.lower(tostring(groupConfig.Side)) == "right" then
                groupConfig.Side = "Right"
            else
                groupConfig.Side = "Left"
            end
            
            local groupObj = {}
            groupObj.group_name = groupConfig.Name
            groupObj.searchTerms = {groupConfig.Name}
            groupObj.elements = {}
            groupObj.Library = tabObj.Library
            groupObj.side = groupConfig.Side
            groupObj.element_y = 38 * scale_factor
            local function createAutoFlag(elementName)
                return tostring(tabObj.tab_name) .. "." .. tostring(groupObj.group_name) .. "." .. tostring(elementName or "Value")
            end
            local function addSearchTerm(term)
                local normalized = normalize_search(term)
                if normalized ~= "" then
                    table.insert(groupObj.searchTerms, tostring(term))
                end
            end
            
            local parentColumn = groupObj.side == "Left" and tabObj.left_column or tabObj.right_column
            groupObj.mainFrame = create("Frame", {
                BackgroundColor3 = Color3.fromRGB(18, 18, 18), Position = UDim2.new(0, 1, 0, 1),
                Size = UDim2.new(1, -2, 0, 54 * scale_factor),
                ClipsDescendants = true, Parent = parentColumn
            })
            
            local groupStrokeThing = create("UIStroke", {Color = Color3.fromRGB(33, 33, 33), Parent = groupObj.mainFrame})
            create("UIGradient", {
                Color = ColorSequence.new({ColorSequenceKeypoint.new(0, Color3.new(1,1,1)), ColorSequenceKeypoint.new(0.5, Color3.fromRGB(150,150,150)), ColorSequenceKeypoint.new(1, Color3.new(1,1,1))}),
                Rotation = 260, Parent = groupStrokeThing
            })
            create("UICorner", {CornerRadius = UDim.new(0, 11), Parent = groupObj.mainFrame})
            
            create("ImageLabel", {
                Image = groupConfig.Icon, BackgroundTransparency = 1, Position = UDim2.new(0, 10, 0, 10 * scale_factor),
                Size = UDim2.new(0, 17 * scale_factor, 0, 17 * scale_factor), Parent = groupObj.mainFrame
            })
            
            create("TextLabel", {
                FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                TextColor3 = Color3.new(1, 1, 1), Text = groupConfig.Name, BackgroundTransparency = 1,
                Position = UDim2.new(0, 33, 0, 8 * scale_factor), TextSize = 15.6 * scale_factor,
                Size = UDim2.new(0, 215 * scale_factor, 0, 16 * scale_factor), TextXAlignment = Enum.TextXAlignment.Left,
                TextTruncate = Enum.TextTruncate.AtEnd, Parent = groupObj.mainFrame
            })
            
            local function update_group_size()
                local newHeight = groupObj.element_y + 12 * scale_factor
                groupObj.mainFrame.Size = UDim2.new(1, -2, 0, newHeight)
                relayout_groups()
            end

            function groupObj:AddToggle(toggleConfig)
                toggleConfig = toggleConfig or {}
                toggleConfig.Name = toggleConfig.Name or "Toggle"
                toggleConfig.Default = toggleConfig.Default or false
                toggleConfig.Callback = toggleConfig.Callback or function() end
                toggleConfig.Flag = toggleConfig.Flag or createAutoFlag(toggleConfig.Name)
                addSearchTerm(toggleConfig.Name)
                
                local toggleObj = {}
                toggleObj.value = toggleConfig.Default
                local yPosition = groupObj.element_y
                
                toggleObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = toggleConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14.6 * scale_factor,
                    Size = UDim2.new(0, 195 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd,
                    Parent = groupObj.mainFrame
                })
                
                toggleObj.switchFrame = create("Frame", {
                    BackgroundColor3 = toggleObj.value and groupObj.Library.config.AccentColor or Color3.fromRGB(32, 32, 32),
                    Position = UDim2.new(1, -44 * scale_factor, 0, yPosition),
                    Size = UDim2.new(0, 36 * scale_factor, 0, 22 * scale_factor), Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = toggleObj.switchFrame})
                
                toggleObj.circleFrame = create("Frame", {
                    BackgroundColor3 = toggleObj.value and Color3.new(1, 1, 1) or Color3.fromRGB(75, 75, 75),
                    Position = toggleObj.value and UDim2.new(0.462, 0, 0.143, 0) or UDim2.new(0.0104, 0, 0.143, 0),
                    Size = UDim2.new(0, 16 * scale_factor, 0, 16 * scale_factor), Parent = toggleObj.switchFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = toggleObj.circleFrame})
                
                local toggleClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Parent = toggleObj.switchFrame})
                
                function toggleObj:Set(value, silent)
                    toggleObj.value = value == true
                    if toggleObj.value then
                        tween_to(toggleObj.switchFrame, {BackgroundColor3 = groupObj.Library.config.AccentColor}, 0.2)
                        tween_to(toggleObj.circleFrame, {Position = UDim2.new(0.462, 0, 0.143, 0), BackgroundColor3 = Color3.new(1, 1, 1)}, 0.2, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
                    else
                        tween_to(toggleObj.switchFrame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2)
                        tween_to(toggleObj.circleFrame, {Position = UDim2.new(0.0104, 0, 0.143, 0), BackgroundColor3 = Color3.fromRGB(75, 75, 75)}, 0.2, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
                    end
                    if not silent then
                        toggleConfig.Callback(toggleObj.value)
                    end
                end

                function toggleObj:Get()
                    return toggleObj.value
                end
                
                toggleClickButton.MouseButton1Click:Connect(function() toggleObj:Set(not toggleObj.value, false) end)
                groupObj.Library:RegisterControl(toggleConfig.Flag, function()
                    return toggleObj:Get()
                end, function(value)
                    toggleObj:Set(value == true, true)
                end)
                
                groupObj.element_y = groupObj.element_y + 28 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, toggleObj)
                return toggleObj
            end

            function groupObj:AddSlider(sliderConfig)
                sliderConfig = sliderConfig or {}
                sliderConfig.Name = sliderConfig.Name or "Slider"
                sliderConfig.Min = tonumber(sliderConfig.Min) or 0
                sliderConfig.Max = tonumber(sliderConfig.Max) or 100
                if sliderConfig.Max < sliderConfig.Min then
                    sliderConfig.Min, sliderConfig.Max = sliderConfig.Max, sliderConfig.Min
                end
                sliderConfig.Default = tonumber(sliderConfig.Default)
                if sliderConfig.Default == nil then
                    sliderConfig.Default = sliderConfig.Min
                end
                sliderConfig.Increment = math.abs(tonumber(sliderConfig.Increment) or 1)
                if sliderConfig.Increment < 1e-6 then
                    sliderConfig.Increment = 1
                end
                sliderConfig.Suffix = tostring(sliderConfig.Suffix or "")
                sliderConfig.ShowMax = sliderConfig.ShowMax == true
                sliderConfig.Callback = sliderConfig.Callback or function() end
                sliderConfig.Flag = sliderConfig.Flag or createAutoFlag(sliderConfig.Name)
                addSearchTerm(sliderConfig.Name)
                
                local sliderPrecision = resolve_precision(sliderConfig.Min, sliderConfig.Max, sliderConfig.Increment, sliderConfig.Default)
                local sliderRange = sliderConfig.Max - sliderConfig.Min
                local function getSliderPercentage(value)
                    if sliderRange <= 0 then
                        return 0
                    end
                    return math.clamp((value - sliderConfig.Min) / sliderRange, 0, 1)
                end
                local function formatDisplayValue(value)
                    local text = format_slider_value(value, sliderPrecision) .. sliderConfig.Suffix
                    if sliderConfig.ShowMax then
                        return text .. " / " .. format_slider_value(sliderConfig.Max, sliderPrecision) .. sliderConfig.Suffix
                    end
                    return text
                end
                
                local sliderObj = {}
                sliderObj.value = normalize_slider_value(sliderConfig.Default, sliderConfig.Min, sliderConfig.Max, sliderConfig.Increment, sliderPrecision)
                local yPosition = groupObj.element_y
                local valueLabelWidth = 72 * scale_factor
                local sliderHitHeight = 20 * scale_factor
                local sliderTrackHeight = 8 * scale_factor
                local sliderKnobWidth = 16 * scale_factor
                local sliderKnobHeight = 16 * scale_factor
                local slider_padding = 10 * scale_factor
                
                sliderObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(118, 118, 130), Text = sliderConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, slider_padding, 0, yPosition), TextSize = 14.2 * scale_factor,
                    Size = UDim2.new(1, -valueLabelWidth - slider_padding * 3, 0, 19 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd,
                    Parent = groupObj.mainFrame
                })
                
                sliderObj.backgroundFrame = create("Frame", {
                    BackgroundTransparency = 1,
                    Position = UDim2.new(0, slider_padding, 0, yPosition + 20 * scale_factor),
                    Size = UDim2.new(1, -slider_padding * 2, 0, sliderHitHeight),
                    Parent = groupObj.mainFrame
                })

                sliderObj.trackFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(43, 43, 51),
                    BorderSizePixel = 0,
                    Position = UDim2.new(0, 0, 0.5, -sliderTrackHeight * 0.5),
                    Size = UDim2.new(1, 0, 0, sliderTrackHeight),
                    Parent = sliderObj.backgroundFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = sliderObj.trackFrame})

                local percentage = getSliderPercentage(sliderObj.value)
                sliderObj.fillFrame = create("Frame", {
                    BackgroundColor3 = groupObj.Library.config.AccentColor,
                    BorderSizePixel = 0,
                    Size = UDim2.new(percentage, 0, 1, 0),
                    Parent = sliderObj.trackFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = sliderObj.fillFrame})

                sliderObj.knobFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(244, 244, 248),
                    BorderSizePixel = 0,
                    AnchorPoint = Vector2.new(0.5, 0.5),
                    Position = UDim2.new(percentage, 0, 0.5, 0),
                    Size = UDim2.new(0, sliderKnobWidth, 0, sliderKnobHeight),
                    ZIndex = 2,
                    Parent = sliderObj.backgroundFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = sliderObj.knobFrame})
                create("UIStroke", {
                    Color = Color3.fromRGB(196, 196, 204),
                    Thickness = 1,
                    Parent = sliderObj.knobFrame
                })
                
                sliderObj.valueLabelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(184, 184, 194), Text = formatDisplayValue(sliderObj.value),
                    BackgroundTransparency = 1, Position = UDim2.new(1, -valueLabelWidth - slider_padding, 0, yPosition),
                    TextSize = 14.2 * scale_factor, Size = UDim2.new(0, valueLabelWidth, 0, 19 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Right, Parent = groupObj.mainFrame
                })
                
                local sliderClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Parent = sliderObj.backgroundFrame})

                local function updateSliderVisuals(animate)
                    local currentPercentage = getSliderPercentage(sliderObj.value)
                    local fillTarget = {Size = UDim2.new(currentPercentage, 0, 1, 0)}
                    local knobTarget = {
                        Position = UDim2.new(currentPercentage, 0, 0.5, 0)
                    }
                    if animate then
                        tween_to(sliderObj.fillFrame, fillTarget, 0.12)
                        tween_to(sliderObj.knobFrame, knobTarget, 0.12, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                    else
                        sliderObj.fillFrame.Size = fillTarget.Size
                        sliderObj.knobFrame.Position = knobTarget.Position
                    end
                    sliderObj.valueLabelText.Text = formatDisplayValue(sliderObj.value)
                end

                function sliderObj:Set(value, instant, silent)
                    value = normalize_slider_value(value, sliderConfig.Min, sliderConfig.Max, sliderConfig.Increment, sliderPrecision)
                    sliderObj.value = value
                    updateSliderVisuals(instant ~= true)
                    if not silent then
                        sliderConfig.Callback(value)
                    end
                end

                function sliderObj:Get()
                    return sliderObj.value
                end
                
                local isDraggingSlider = false
                local activeSliderInput = nil
                local function setSliderFromInput(input, instant)
                    if not input then
                        return
                    end
                    local percentageNow = math.clamp((input.Position.X - sliderObj.backgroundFrame.AbsolutePosition.X) / math.max(1, sliderObj.backgroundFrame.AbsoluteSize.X), 0, 1)
                    local value = sliderConfig.Min + sliderRange * percentageNow
                    sliderObj:Set(value, instant, false)
                end
                sliderClickButton.InputBegan:Connect(function(input)
                    local isMouse = input.UserInputType == Enum.UserInputType.MouseButton1
                    local isTouch = input.UserInputType == Enum.UserInputType.Touch
                    if not isMouse and not isTouch then
                        return
                    end
                    isDraggingSlider = true
                    activeSliderInput = isTouch and input or nil
                    setSliderFromInput(input, true)
                end)
                groupObj.Library:_TrackConnection(input_service.InputEnded:Connect(function(input)
                    if input.UserInputType == Enum.UserInputType.MouseButton1 or (input.UserInputType == Enum.UserInputType.Touch and (activeSliderInput == nil or input == activeSliderInput)) then
                        isDraggingSlider = false
                        activeSliderInput = nil
                    end
                end))
                groupObj.Library:_TrackConnection(input_service.InputChanged:Connect(function(input)
                    if isDraggingSlider and (input.UserInputType == Enum.UserInputType.MouseMovement or (input.UserInputType == Enum.UserInputType.Touch and (activeSliderInput == nil or input == activeSliderInput))) then
                        setSliderFromInput(input, true)
                    end
                end))

                updateSliderVisuals(false)
                groupObj.Library:RegisterControl(sliderConfig.Flag, function()
                    return sliderObj:Get()
                end, function(value)
                    sliderObj:Set(tonumber(value) or sliderConfig.Min, true, true)
                end)
                groupObj.element_y = groupObj.element_y + 44 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, sliderObj)
                return sliderObj
            end

            function groupObj:AddButton(buttonConfig)
                buttonConfig = buttonConfig or {}
                buttonConfig.Name = buttonConfig.Name or "Button"
                buttonConfig.Icon = buttonConfig.Icon
                buttonConfig.Locked = buttonConfig.Locked or false
                buttonConfig.Callback = buttonConfig.Callback or function() end
                addSearchTerm(buttonConfig.Name)
                
                local buttonObj = {}
                buttonObj.isLocked = buttonConfig.Locked
                local yPosition = groupObj.element_y
                
                buttonObj.mainFrame = create("Frame", {
                    BackgroundColor3 = buttonObj.isLocked and Color3.fromRGB(24, 24, 24) or Color3.fromRGB(32, 32, 32),
                    Position = UDim2.new(0, 10, 0, yPosition),
                    Size = UDim2.new(1, -20 * scale_factor, 0, 28 * scale_factor), Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = buttonObj.mainFrame})
                
                local buttonStrokeThing = create("UIStroke", {Color = buttonObj.isLocked and Color3.fromRGB(32, 32, 32) or Color3.fromRGB(48, 48, 48), Parent = buttonObj.mainFrame})
                create("UIGradient", {
                    Color = ColorSequence.new({ColorSequenceKeypoint.new(0, Color3.new(1,1,1)), ColorSequenceKeypoint.new(0.5, Color3.fromRGB(150,150,150)), ColorSequenceKeypoint.new(1, Color3.new(1,1,1))}),
                    Rotation = 260, Parent = buttonStrokeThing
                })
                
                local textXPos = 8
                if buttonConfig.Icon then
                    create("ImageLabel", {
                        ImageColor3 = buttonObj.isLocked and Color3.fromRGB(50, 50, 50) or Color3.fromRGB(125, 125, 125),
                        Image = buttonConfig.Icon, BackgroundTransparency = 1,
                        Position = UDim2.new(0, 8, 0.5, -8 * scale_factor),
                        Size = UDim2.new(0, 16 * scale_factor, 0, 16 * scale_factor), Parent = buttonObj.mainFrame
                    })
                    textXPos = 30
                end
                
                buttonObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = buttonObj.isLocked and Color3.fromRGB(46, 46, 46) or Color3.fromRGB(120, 120, 120),
                    Text = buttonConfig.Name .. (buttonObj.isLocked and " (locked)" or ""), BackgroundTransparency = 1,
                    Position = UDim2.new(0, textXPos * scale_factor, 0, 0), TextSize = 14 * scale_factor,
                    Size = UDim2.new(1, -textXPos * scale_factor - 10, 1, 0),
                    TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd,
                    Parent = buttonObj.mainFrame
                })
                
                local buttonClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Parent = buttonObj.mainFrame})
                buttonClickButton.MouseButton1Click:Connect(function() if not buttonObj.isLocked then buttonConfig.Callback() end end)
                buttonClickButton.MouseEnter:Connect(function() if not buttonObj.isLocked then tween_to(buttonObj.mainFrame, {BackgroundColor3 = Color3.fromRGB(40, 40, 40)}, 0.2) end end)
                buttonClickButton.MouseLeave:Connect(function() if not buttonObj.isLocked then tween_to(buttonObj.mainFrame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2) end end)
                
                groupObj.element_y = groupObj.element_y + 35 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, buttonObj)
                return buttonObj
            end

            function groupObj:AddKeybind(keybindConfig)
                keybindConfig = keybindConfig or {}
                keybindConfig.Name = keybindConfig.Name or "Keybind"
                keybindConfig.Default = keybindConfig.Default or Enum.KeyCode.Unknown
                keybindConfig.Callback = keybindConfig.Callback or function() end
                keybindConfig.ChangedCallback = keybindConfig.ChangedCallback or function() end
                keybindConfig.ModeChangedCallback = keybindConfig.ModeChangedCallback or function() end
                keybindConfig.Mode = tostring(keybindConfig.Mode or "Toggle")
                keybindConfig.Flag = keybindConfig.Flag or createAutoFlag(keybindConfig.Name)
                keybindConfig.ModeFlag = keybindConfig.ModeFlag or createAutoFlag(keybindConfig.Name .. ".Mode")
                addSearchTerm(keybindConfig.Name)
                addSearchTerm("hold")
                addSearchTerm("toggle")
                
                local keybindObj = {}
                keybindObj.value = keybindConfig.Default
                keybindObj.mode = string.lower(keybindConfig.Mode) == "hold" and "Hold" or "Toggle"
                keybindObj.isListening = false
                keybindObj.holdActive = false
                local yPosition = groupObj.element_y
                
                keybindObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = keybindConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14.6 * scale_factor,
                    Size = UDim2.new(0, 145 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd,
                    Parent = groupObj.mainFrame
                })
                
                local function normalizeMode(modeValue)
                    return string.lower(tostring(modeValue or "toggle")) == "hold" and "Hold" or "Toggle"
                end
                
                local function getKeyText()
                    return keybindObj.value == Enum.KeyCode.Unknown and "None" or keybindObj.value.Name
                end
                
                local keyText = getKeyText()
                local keyWidth = math.max(48 * scale_factor, measure_text_width(keyText, 12 * scale_factor) + 30 * scale_factor)
                
                keybindObj.button_frame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(32, 32, 32), Position = UDim2.new(1, -keyWidth - 10, 0, yPosition),
                    Size = UDim2.new(0, keyWidth, 0, 22 * scale_factor), Active = true, Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = keybindObj.button_frame})
                
                local keybindStrokeThing = create("UIStroke", {Color = Color3.fromRGB(40, 40, 40), Parent = keybindObj.button_frame})
                create("UIGradient", {
                    Color = ColorSequence.new({ColorSequenceKeypoint.new(0, Color3.new(1,1,1)), ColorSequenceKeypoint.new(0.5, Color3.fromRGB(150,150,150)), ColorSequenceKeypoint.new(1, Color3.new(1,1,1))}),
                    Rotation = 260, Parent = keybindStrokeThing
                })
                
                keybindObj.keyLabelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(113, 113, 113), Text = keyText, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 2, 0, 0), TextSize = 12.8 * scale_factor,
                    Size = UDim2.new(1, -24 * scale_factor, 1, 0), TextXAlignment = Enum.TextXAlignment.Left,
                    Parent = keybindObj.button_frame
                })
                create("UIPadding", {PaddingLeft = UDim.new(0, 2), Parent = keybindObj.keyLabelText})
                
                keybindObj.keyboardIconImg = create("ImageLabel", {
                    ImageColor3 = Color3.fromRGB(76, 76, 76), Image = "rbxassetid://10723416765", BackgroundTransparency = 1,
                    Position = UDim2.new(1, -18 * scale_factor, 0.5, -7.5 * scale_factor),
                    Size = UDim2.new(0, 15 * scale_factor, 0, 15 * scale_factor), Parent = keybindObj.button_frame
                })
                
                local keybindClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Active = true, Parent = keybindObj.button_frame})
                
                local modeMenuWidth = 120 * scale_factor
                local modeMenuHeight = 78 * scale_factor
                local modeMenuPositionConn = nil
                local modeMenuOutsideConn = nil
                keybindObj.isModeMenuOpen = false
                
                keybindObj.modeMenuFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(16, 16, 16),
                    Size = UDim2.new(0, modeMenuWidth, 0, 0),
                    ClipsDescendants = true,
                    Visible = false,
                    ZIndex = 9999,
                    Parent = groupObj.Library.dropdown_holder
                })
                create("UICorner", {CornerRadius = UDim.new(0, 7), Parent = keybindObj.modeMenuFrame})
                create("UIStroke", {Color = Color3.fromRGB(40, 40, 40), Parent = keybindObj.modeMenuFrame})
                
                create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    Text = "Keybind Mode",
                    TextColor3 = Color3.new(1, 1, 1),
                    BackgroundTransparency = 1,
                    Position = UDim2.new(0, 8, 0, 5 * scale_factor),
                    Size = UDim2.new(1, -16, 0, 16 * scale_factor),
                    TextSize = 12 * scale_factor,
                    TextXAlignment = Enum.TextXAlignment.Left,
                    ZIndex = 10000,
                    Parent = keybindObj.modeMenuFrame
                })
                
                local toggleModeFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(28, 28, 28),
                    Position = UDim2.new(0, 8, 0, 26 * scale_factor),
                    Size = UDim2.new(1, -16, 0, 20 * scale_factor),
                    ZIndex = 10000,
                    Parent = keybindObj.modeMenuFrame
                })
                create("UICorner", {CornerRadius = UDim.new(0, 5), Parent = toggleModeFrame})
                
                local toggleModeLabel = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    Text = "Toggle",
                    TextColor3 = Color3.fromRGB(124, 124, 124),
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 0, 1, 0),
                    TextSize = 12 * scale_factor,
                    ZIndex = 10001,
                    Parent = toggleModeFrame
                })
                
                local holdModeFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(28, 28, 28),
                    Position = UDim2.new(0, 8, 0, 50 * scale_factor),
                    Size = UDim2.new(1, -16, 0, 20 * scale_factor),
                    ZIndex = 10000,
                    Parent = keybindObj.modeMenuFrame
                })
                create("UICorner", {CornerRadius = UDim.new(0, 5), Parent = holdModeFrame})
                
                local holdModeLabel = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    Text = "Hold",
                    TextColor3 = Color3.fromRGB(124, 124, 124),
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 0, 1, 0),
                    TextSize = 12 * scale_factor,
                    ZIndex = 10001,
                    Parent = holdModeFrame
                })
                
                local toggleModeClickButton = create("TextButton", {
                    Text = "",
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 0, 1, 0),
                    ZIndex = 10002,
                    Parent = toggleModeFrame
                })
                
                local holdModeClickButton = create("TextButton", {
                    Text = "",
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 0, 1, 0),
                    ZIndex = 10002,
                    Parent = holdModeFrame
                })
                
                local function updateKeybindSizeYay(text)
                    local newWidth = math.max(48 * scale_factor, measure_text_width(text, 12 * scale_factor) + 30 * scale_factor)
                    tween_to(keybindObj.button_frame, {Size = UDim2.new(0, newWidth, 0, 22 * scale_factor), Position = UDim2.new(1, -newWidth - 10, 0, yPosition)}, 0.15)
                end
                
                local function updateModeVisuals()
                    local selectedBg = groupObj.Library.config.AccentColor:Lerp(Color3.fromRGB(16, 16, 16), 0.45)
                    local idleBg = Color3.fromRGB(28, 28, 28)
                    local selectedText = Color3.new(1, 1, 1)
                    local idleText = Color3.fromRGB(124, 124, 124)
                    local isToggleSelected = keybindObj.mode == "Toggle"
                    
                    tween_to(toggleModeFrame, {BackgroundColor3 = isToggleSelected and selectedBg or idleBg}, 0.12)
                    tween_to(toggleModeLabel, {TextColor3 = isToggleSelected and selectedText or idleText}, 0.12)
                    tween_to(holdModeFrame, {BackgroundColor3 = isToggleSelected and idleBg or selectedBg}, 0.12)
                    tween_to(holdModeLabel, {TextColor3 = isToggleSelected and idleText or selectedText}, 0.12)
                end
                
                local function updateModeMenuPositionYay()
                    local buttonAbsPos = keybindObj.button_frame.AbsolutePosition
                    local buttonAbsSize = keybindObj.button_frame.AbsoluteSize
                    keybindObj.modeMenuFrame.Position = UDim2.new(0, buttonAbsPos.X + buttonAbsSize.X - modeMenuWidth, 0, buttonAbsPos.Y + buttonAbsSize.Y + 5)
                end
                
                local function closeModeMenu(isInstant)
                    keybindObj.isModeMenuOpen = false
                    if modeMenuPositionConn then
                        modeMenuPositionConn()
                        modeMenuPositionConn = nil
                    end
                    if modeMenuOutsideConn then
                        modeMenuOutsideConn:Disconnect()
                        modeMenuOutsideConn = nil
                    end
                    if isInstant then
                        keybindObj.modeMenuFrame.Size = UDim2.new(0, modeMenuWidth, 0, 0)
                        keybindObj.modeMenuFrame.Visible = false
                        return
                    end
                    tween_to(keybindObj.modeMenuFrame, {Size = UDim2.new(0, modeMenuWidth, 0, 0)}, 0.18, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
                    task.delay(0.18, function()
                        if keybindObj.modeMenuFrame and keybindObj.modeMenuFrame.Parent and not keybindObj.isModeMenuOpen then
                            keybindObj.modeMenuFrame.Visible = false
                        end
                    end)
                end
                
                local function openModeMenu()
                    if keybindObj.isListening then return end
                    keybindObj.isModeMenuOpen = true
                    updateModeVisuals()
                    updateModeMenuPositionYay()
                    keybindObj.modeMenuFrame.Visible = true
                    tween_to(keybindObj.modeMenuFrame, {Size = UDim2.new(0, modeMenuWidth, 0, modeMenuHeight)}, 0.22, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                    
                    if modeMenuPositionConn then modeMenuPositionConn() end
                    modeMenuPositionConn = start_position_tracker(groupObj.Library, keybindObj.button_frame, function()
                        if keybindObj.isModeMenuOpen then
                            updateModeMenuPositionYay()
                        end
                    end)
                    
                    if modeMenuOutsideConn then modeMenuOutsideConn:Disconnect() end
                    modeMenuOutsideConn = groupObj.Library:_TrackConnection(input_service.InputBegan:Connect(function(input)
                        if not keybindObj.isModeMenuOpen then return end
                        local isPress = input.UserInputType == Enum.UserInputType.MouseButton1
                            or input.UserInputType == Enum.UserInputType.MouseButton2
                            or input.UserInputType == Enum.UserInputType.Touch
                        if not isPress then return end
                        
                        local mousePos = input.Position
                        local menuPos = keybindObj.modeMenuFrame.AbsolutePosition
                        local menuSize = keybindObj.modeMenuFrame.AbsoluteSize
                        local buttonPos = keybindObj.button_frame.AbsolutePosition
                        local buttonSize = keybindObj.button_frame.AbsoluteSize
                        
                        local insideMenu = mousePos.X >= menuPos.X and mousePos.X <= (menuPos.X + menuSize.X)
                            and mousePos.Y >= menuPos.Y and mousePos.Y <= (menuPos.Y + menuSize.Y)
                        local insideButton = mousePos.X >= buttonPos.X and mousePos.X <= (buttonPos.X + buttonSize.X)
                            and mousePos.Y >= buttonPos.Y and mousePos.Y <= (buttonPos.Y + buttonSize.Y)
                        
                        if not insideMenu and not insideButton then
                            closeModeMenu(false)
                        end
                    end))
                end
                
                local function toggleModeMenu()
                    if keybindObj.isModeMenuOpen then
                        closeModeMenu(false)
                    else
                        openModeMenu()
                    end
                end
                
                local function setMode(modeValue, silent)
                    local newMode = normalizeMode(modeValue)
                    if newMode == keybindObj.mode then
                        updateModeVisuals()
                        return
                    end
                    if keybindObj.holdActive then
                        keybindObj.holdActive = false
                        keybindConfig.Callback(false)
                    end
                    keybindObj.mode = newMode
                    updateModeVisuals()
                    if not silent then
                        keybindConfig.ModeChangedCallback(newMode)
                    end
                    if not silent then
                        groupObj.Library:Notify({
                            Title = keybindConfig.Name .. " mode updated",
                            Description = "Now using " .. newMode .. " input",
                            Duration = 2.2,
                            Icon = "rbxassetid://6031075938"
                        })
                    end
                end
                
                function keybindObj:Set(key, silent)
                    if keybindObj.holdActive then
                        keybindObj.holdActive = false
                        keybindConfig.Callback(false)
                    end
                    keybindObj.value = key
                    local newKeyText = getKeyText()
                    keybindObj.keyLabelText.Text = newKeyText
                    updateKeybindSizeYay(newKeyText)
                    if not silent then
                        keybindConfig.ChangedCallback(key)
                    end
                end

                function keybindObj:Get()
                    return keybindObj.value
                end
                
                function keybindObj:SetMode(modeValue, silent)
                    setMode(modeValue, silent)
                end
                
                function keybindObj:GetMode()
                    return keybindObj.mode
                end
                
                function keybindObj:Close()
                    keybindObj.isListening = false
                    if keybindObj.holdActive then
                        keybindObj.holdActive = false
                        keybindConfig.Callback(false)
                    end
                    closeModeMenu(true)
                end
                
                keybindClickButton.MouseButton1Click:Connect(function()
                    closeModeMenu(true)
                    keybindObj.isListening = true
                    keybindObj.keyLabelText.Text = "..."
                    updateKeybindSizeYay("...")
                    tween_to(keybindObj.button_frame, {BackgroundColor3 = Color3.fromRGB(48, 48, 48)}, 0.2)
                end)
                
                local modeMenuToggleDebounceAt = 0
                local function toggleModeMenuFromRightClick()
                    if keybindObj.isListening then
                        return
                    end
                    local now = os.clock()
                    if now - modeMenuToggleDebounceAt < 0.12 then
                        return
                    end
                    modeMenuToggleDebounceAt = now
                    toggleModeMenu()
                end
                
                keybindClickButton.MouseButton2Click:Connect(toggleModeMenuFromRightClick)
                keybindClickButton.InputBegan:Connect(function(input)
                    if input.UserInputType ~= Enum.UserInputType.MouseButton2 then
                        return
                    end
                    toggleModeMenuFromRightClick()
                end)
                
                toggleModeClickButton.MouseButton1Click:Connect(function()
                    setMode("Toggle", false)
                    closeModeMenu(false)
                end)
                
                holdModeClickButton.MouseButton1Click:Connect(function()
                    setMode("Hold", false)
                    closeModeMenu(false)
                end)
                
                groupObj.Library:_TrackConnection(input_service.InputBegan:Connect(function(input, gameProcessed)
                    if keybindObj.isListening then
                        if input.UserInputType == Enum.UserInputType.Keyboard then
                            keybindObj.isListening = false
                            local pickedKey = input.KeyCode
                            if pickedKey == Enum.KeyCode.Backspace or pickedKey == Enum.KeyCode.Delete then
                                pickedKey = Enum.KeyCode.Unknown
                            end
                            keybindObj:Set(pickedKey, false)
                            tween_to(keybindObj.button_frame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2)
                        end
                    elseif not gameProcessed and input.UserInputType == Enum.UserInputType.Keyboard then
                        if input.KeyCode == keybindObj.value and keybindObj.value ~= Enum.KeyCode.Unknown then
                            if keybindObj.mode == "Hold" then
                                if not keybindObj.holdActive then
                                    keybindObj.holdActive = true
                                    keybindConfig.Callback(true)
                                end
                            else
                                keybindConfig.Callback()
                            end
                        end
                    end
                end))
                
                groupObj.Library:_TrackConnection(input_service.InputEnded:Connect(function(input)
                    if keybindObj.mode == "Hold" and keybindObj.holdActive and input.UserInputType == Enum.UserInputType.Keyboard and input.KeyCode == keybindObj.value then
                        keybindObj.holdActive = false
                        keybindConfig.Callback(false)
                    end
                end))
                
                keybindClickButton.MouseEnter:Connect(function()
                    if not keybindObj.isListening then tween_to(keybindObj.button_frame, {BackgroundColor3 = Color3.fromRGB(48, 48, 48)}, 0.2) end
                end)
                keybindClickButton.MouseLeave:Connect(function()
                    if not keybindObj.isListening then tween_to(keybindObj.button_frame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2) end
                end)
                
                toggleModeClickButton.MouseEnter:Connect(function()
                    if keybindObj.mode ~= "Toggle" then
                        tween_to(toggleModeFrame, {BackgroundColor3 = Color3.fromRGB(42, 42, 42)}, 0.12)
                    end
                end)
                toggleModeClickButton.MouseLeave:Connect(function()
                    updateModeVisuals()
                end)
                holdModeClickButton.MouseEnter:Connect(function()
                    if keybindObj.mode ~= "Hold" then
                        tween_to(holdModeFrame, {BackgroundColor3 = Color3.fromRGB(42, 42, 42)}, 0.12)
                    end
                end)
                holdModeClickButton.MouseLeave:Connect(function()
                    updateModeVisuals()
                end)
                
                groupObj.Library:RegisterControl(keybindConfig.Flag, function()
                    return keybindObj:Get()
                end, function(value)
                    if typeof(value) == "EnumItem" and value.EnumType == Enum.KeyCode then
                        keybindObj:Set(value, true)
                    end
                end)
                groupObj.Library:RegisterControl(keybindConfig.ModeFlag, function()
                    return keybindObj:GetMode()
                end, function(value)
                    keybindObj:SetMode(value, true)
                end)
                
                groupObj.element_y = groupObj.element_y + 28 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, keybindObj)
                return keybindObj
            end

            function groupObj:AddKeybindToggle(keybindToggleConfig)
                keybindToggleConfig = keybindToggleConfig or {}
                keybindToggleConfig.Name = keybindToggleConfig.Name or "Keybind Toggle"
                keybindToggleConfig.Default = keybindToggleConfig.Default or Enum.KeyCode.Unknown
                keybindToggleConfig.ToggleDefault = keybindToggleConfig.ToggleDefault or false
                keybindToggleConfig.Callback = keybindToggleConfig.Callback or function() end
                keybindToggleConfig.ToggleCallback = keybindToggleConfig.ToggleCallback or function() end
                keybindToggleConfig.ChangedCallback = keybindToggleConfig.ChangedCallback or function() end
                keybindToggleConfig.Flag = keybindToggleConfig.Flag or createAutoFlag(keybindToggleConfig.Name .. ".Key")
                keybindToggleConfig.ToggleFlag = keybindToggleConfig.ToggleFlag or createAutoFlag(keybindToggleConfig.Name .. ".Enabled")
                addSearchTerm(keybindToggleConfig.Name)
                
                local keybindToggleObj = {}
                keybindToggleObj.keyValue = keybindToggleConfig.Default
                keybindToggleObj.toggleValue = keybindToggleConfig.ToggleDefault
                keybindToggleObj.isListening = false
                local yPosition = groupObj.element_y
                
                keybindToggleObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = keybindToggleConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14.6 * scale_factor,
                    Size = UDim2.new(0, 115 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd,
                    Parent = groupObj.mainFrame
                })
                
                local keyText = keybindToggleObj.keyValue == Enum.KeyCode.Unknown and "None" or keybindToggleObj.keyValue.Name
                local keyWidth = math.max(48 * scale_factor, measure_text_width(keyText, 12 * scale_factor) + 30 * scale_factor)
                
                keybindToggleObj.keybindButtonFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(32, 32, 32), Position = UDim2.new(1, -keyWidth - 10, 0, yPosition),
                    Size = UDim2.new(0, keyWidth, 0, 22 * scale_factor), Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = keybindToggleObj.keybindButtonFrame})
                
                local keybindStrokeThing = create("UIStroke", {Color = Color3.fromRGB(40, 40, 40), Parent = keybindToggleObj.keybindButtonFrame})
                
                keybindToggleObj.keyLabelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(113, 113, 113), Text = keyText, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 6, 0, 0), TextSize = 12.8 * scale_factor,
                    Size = UDim2.new(1, -24 * scale_factor, 1, 0), TextXAlignment = Enum.TextXAlignment.Left,
                    Parent = keybindToggleObj.keybindButtonFrame
                })
                
                keybindToggleObj.keyboardIconImg = create("ImageLabel", {
                    ImageColor3 = Color3.fromRGB(76, 76, 76), Image = "rbxassetid://10723416765", BackgroundTransparency = 1,
                    Position = UDim2.new(1, -18 * scale_factor, 0.5, -7.5 * scale_factor),
                    Size = UDim2.new(0, 15 * scale_factor, 0, 15 * scale_factor), Parent = keybindToggleObj.keybindButtonFrame
                })
                
                keybindToggleObj.toggleSwitchFrame = create("Frame", {
                    BackgroundColor3 = keybindToggleObj.toggleValue and groupObj.Library.config.AccentColor or Color3.fromRGB(32, 32, 32),
                    Position = UDim2.new(1, -keyWidth - 48 * scale_factor, 0, yPosition),
                    Size = UDim2.new(0, 36 * scale_factor, 0, 22 * scale_factor), Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = keybindToggleObj.toggleSwitchFrame})
                
                keybindToggleObj.toggleCircleFrame = create("Frame", {
                    BackgroundColor3 = keybindToggleObj.toggleValue and Color3.new(1, 1, 1) or Color3.fromRGB(75, 75, 75),
                    Position = keybindToggleObj.toggleValue and UDim2.new(0.462, 0, 0.143, 0) or UDim2.new(0.0104, 0, 0.143, 0),
                    Size = UDim2.new(0, 16 * scale_factor, 0, 16 * scale_factor), Parent = keybindToggleObj.toggleSwitchFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = keybindToggleObj.toggleCircleFrame})
                
                local toggleClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Parent = keybindToggleObj.toggleSwitchFrame})
                local keybindClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Parent = keybindToggleObj.keybindButtonFrame})
                
                function keybindToggleObj:SetToggle(value, silent)
                    keybindToggleObj.toggleValue = value == true
                    if value then
                        tween_to(keybindToggleObj.toggleSwitchFrame, {BackgroundColor3 = groupObj.Library.config.AccentColor}, 0.2)
                        tween_to(keybindToggleObj.toggleCircleFrame, {Position = UDim2.new(0.462, 0, 0.143, 0), BackgroundColor3 = Color3.new(1, 1, 1)}, 0.2, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
                    else
                        tween_to(keybindToggleObj.toggleSwitchFrame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2)
                        tween_to(keybindToggleObj.toggleCircleFrame, {Position = UDim2.new(0.0104, 0, 0.143, 0), BackgroundColor3 = Color3.fromRGB(75, 75, 75)}, 0.2, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
                    end
                    if not silent then
                        keybindToggleConfig.ToggleCallback(keybindToggleObj.toggleValue)
                    end
                end
                
                local function updateKeybindSizeYay(text)
                    local newWidth = math.max(48 * scale_factor, measure_text_width(text, 12 * scale_factor) + 30 * scale_factor)
                    tween_to(keybindToggleObj.keybindButtonFrame, {Size = UDim2.new(0, newWidth, 0, 22 * scale_factor), Position = UDim2.new(1, -newWidth - 10, 0, yPosition)}, 0.15)
                    tween_to(keybindToggleObj.toggleSwitchFrame, {Position = UDim2.new(1, -newWidth - 48 * scale_factor, 0, yPosition)}, 0.15)
                end
                
                function keybindToggleObj:SetKey(key, silent)
                    keybindToggleObj.keyValue = key
                    local keyText = key == Enum.KeyCode.Unknown and "None" or key.Name
                    keybindToggleObj.keyLabelText.Text = keyText
                    updateKeybindSizeYay(keyText)
                    if not silent then
                        keybindToggleConfig.ChangedCallback(key)
                    end
                end

                function keybindToggleObj:GetKey()
                    return keybindToggleObj.keyValue
                end

                function keybindToggleObj:GetToggle()
                    return keybindToggleObj.toggleValue
                end
                
                toggleClickButton.MouseButton1Click:Connect(function() keybindToggleObj:SetToggle(not keybindToggleObj.toggleValue, false) end)
                keybindClickButton.MouseButton1Click:Connect(function()
                    keybindToggleObj.isListening = true
                    keybindToggleObj.keyLabelText.Text = "..."
                    updateKeybindSizeYay("...")
                    tween_to(keybindToggleObj.keybindButtonFrame, {BackgroundColor3 = Color3.fromRGB(48, 48, 48)}, 0.2)
                end)
                
                groupObj.Library:_TrackConnection(input_service.InputBegan:Connect(function(input, gameProcessed)
                    if keybindToggleObj.isListening then
                        if input.UserInputType == Enum.UserInputType.Keyboard then
                            keybindToggleObj.isListening = false
                            keybindToggleObj:SetKey(input.KeyCode, false)
                            tween_to(keybindToggleObj.keybindButtonFrame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2)
                        end
                    elseif not gameProcessed and input.UserInputType == Enum.UserInputType.Keyboard then
                        if input.KeyCode == keybindToggleObj.keyValue and keybindToggleObj.toggleValue then
                            keybindToggleConfig.Callback()
                        end
                    end
                end))
                
                keybindClickButton.MouseEnter:Connect(function() if not keybindToggleObj.isListening then tween_to(keybindToggleObj.keybindButtonFrame, {BackgroundColor3 = Color3.fromRGB(48, 48, 48)}, 0.2) end end)
                keybindClickButton.MouseLeave:Connect(function() if not keybindToggleObj.isListening then tween_to(keybindToggleObj.keybindButtonFrame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2) end end)
                
                groupObj.Library:RegisterControl(keybindToggleConfig.Flag, function()
                    return keybindToggleObj:GetKey()
                end, function(value)
                    if typeof(value) == "EnumItem" and value.EnumType == Enum.KeyCode then
                        keybindToggleObj:SetKey(value, true)
                    end
                end)
                groupObj.Library:RegisterControl(keybindToggleConfig.ToggleFlag, function()
                    return keybindToggleObj:GetToggle()
                end, function(value)
                    keybindToggleObj:SetToggle(value == true, true)
                end)
                groupObj.element_y = groupObj.element_y + 31 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, keybindToggleObj)
                return keybindToggleObj
            end

            function groupObj:AddDropdown(dropdownConfig)
                dropdownConfig = dropdownConfig or {}
                dropdownConfig.Name = dropdownConfig.Name or "Dropdown"
                dropdownConfig.Options = dropdownConfig.Options or {"Option 1", "Option 2", "Option 3"}
                dropdownConfig.OptionsProvider = dropdownConfig.OptionsProvider or dropdownConfig.GetOptions
                local dropdownHasProvider = type(dropdownConfig.OptionsProvider) == "function"
                if dropdownConfig.AutoRefresh == nil then
                    dropdownConfig.AutoRefresh = dropdownHasProvider
                else
                    dropdownConfig.AutoRefresh = dropdownConfig.AutoRefresh == true
                end
                dropdownConfig.RefreshInterval = math.max(tonumber(dropdownConfig.RefreshInterval) or 0.85, 0.35)
                dropdownConfig.Callback = dropdownConfig.Callback or function() end
                dropdownConfig.Flag = dropdownConfig.Flag or createAutoFlag(dropdownConfig.Name)
                local dropdownOptionsSource = dropdownConfig.Options
                if type(dropdownConfig.OptionsProvider) == "function" then
                    local ok, providedOptions = pcall(dropdownConfig.OptionsProvider)
                    if ok and type(providedOptions) == "table" then
                        dropdownOptionsSource = providedOptions
                    end
                end
                dropdownConfig.Options = normalize_dropdown(dropdownOptionsSource)
                dropdownConfig.Default = dropdownConfig.Default or dropdownConfig.Options[1] or "None"
                if not table.find(dropdownConfig.Options, dropdownConfig.Default) then
                    dropdownConfig.Default = dropdownConfig.Options[1] or "None"
                end
                addSearchTerm(dropdownConfig.Name)
                for _, option in ipairs(dropdownConfig.Options) do
                    addSearchTerm(tostring(option))
                end
                
                local dropdownObj = {}
                dropdownObj.value = dropdownConfig.Default
                dropdownObj.isOpen = false
                dropdownObj._optionsSignature = get_dropdown_signature(dropdownOptionsSource)
                if dropdownObj._optionsSignature == "0" then
                    dropdownObj._optionsSignature = get_dropdown_signature(dropdownConfig.Options)
                end
                local yPosition = groupObj.element_y
                
                dropdownObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = dropdownConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 13.8 * scale_factor,
                    Size = UDim2.new(0, 130 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd, Parent = groupObj.mainFrame
                })
                
                local displayText = tostring(dropdownObj.value or "None")
                local buttonWidth = math.max(70 * scale_factor, measure_text_width(displayText, 12 * scale_factor) + 30 * scale_factor)
                
                dropdownObj.button_frame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(32, 32, 32), Position = UDim2.new(1, -buttonWidth - 10, 0, yPosition),
                    Size = UDim2.new(0, buttonWidth, 0, 23 * scale_factor), Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = dropdownObj.button_frame})
                
                local dropdownStrokeThing = create("UIStroke", {Color = Color3.fromRGB(44, 44, 44), Parent = dropdownObj.button_frame})
                
                dropdownObj.selectedLabelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(84, 84, 84), Text = displayText, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 8, 0, 0), TextSize = 12.8 * scale_factor,
                    Size = UDim2.new(1, -28 * scale_factor, 1, 0), TextXAlignment = Enum.TextXAlignment.Left,
                    TextTruncate = Enum.TextTruncate.AtEnd, Parent = dropdownObj.button_frame
                })
                
                dropdownObj.arrowImg = create("ImageLabel", {
                    ImageColor3 = Color3.fromRGB(80, 80, 80), Image = default_icons.expand, BackgroundTransparency = 1,
                    Position = UDim2.new(1, -20 * scale_factor, 0.5, -7.5 * scale_factor),
                    Size = UDim2.new(0, 15 * scale_factor, 0, 15 * scale_factor), Parent = dropdownObj.button_frame
                })
                
                local dropdown_popup_w = math.max(180 * scale_factor, buttonWidth + 20 * scale_factor)
                dropdownObj.optionHolderFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(16, 16, 16), Size = UDim2.new(0, dropdown_popup_w, 0, 0),
                    ClipsDescendants = true, Visible = false, ZIndex = 9999, Parent = groupObj.Library.dropdown_holder
                })
                create("UICorner", {CornerRadius = UDim.new(0, 8), Parent = dropdownObj.optionHolderFrame})
                create("UIStroke", {Color = Color3.fromRGB(40, 40, 40), Parent = dropdownObj.optionHolderFrame})

                create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.new(1, 1, 1), Text = dropdownConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 12, 0, 7 * scale_factor), TextSize = 13 * scale_factor,
                    Size = UDim2.new(1, -44 * scale_factor, 0, 20 * scale_factor), TextXAlignment = Enum.TextXAlignment.Left,
                    TextTruncate = Enum.TextTruncate.AtEnd, ZIndex = 10000, Parent = dropdownObj.optionHolderFrame
                })

                local dropdownCloseButton = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(26, 26, 26),
                    Position = UDim2.new(1, -26 * scale_factor, 0, 6 * scale_factor),
                    Size = UDim2.new(0, 18 * scale_factor, 0, 18 * scale_factor),
                    ZIndex = 10002, Parent = dropdownObj.optionHolderFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = dropdownCloseButton})
                local dropdownCloseIcon = create("ImageLabel", {
                    Image = default_icons.close, ImageColor3 = Color3.fromRGB(130, 130, 130),
                    BackgroundTransparency = 1, AnchorPoint = Vector2.new(0.5, 0.5),
                    Position = UDim2.new(0.5, 0, 0.5, 0), Size = UDim2.new(0.6, 0, 0.6, 0),
                    ZIndex = 10003, Parent = dropdownCloseButton
                })
                local dropdownCloseClickBtn = create("TextButton", {
                    Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0),
                    ZIndex = 10004, Parent = dropdownCloseButton
                })
                
                dropdownObj.optionScrollFrame = create("ScrollingFrame", {
                    BackgroundTransparency = 1, Position = UDim2.new(0, 0, 0, 58 * scale_factor),
                    Size = UDim2.new(1, 0, 1, -63 * scale_factor), ScrollBarThickness = 0,
                    ScrollBarImageColor3 = Color3.fromRGB(80, 80, 80), CanvasSize = UDim2.new(0, 0, 0, 0),
                    ZIndex = 10000, Parent = dropdownObj.optionHolderFrame
                })
                attach_scrollbar(groupObj.Library, dropdownObj.optionScrollFrame, dropdownObj.optionHolderFrame, {
                    TrackWidth = 7 * scale_factor,
                    ThumbWidth = 3 * scale_factor,
                    EdgeInset = 2 * scale_factor,
                    VerticalInset = 4 * scale_factor,
                    ZIndex = 10002
                })
                dropdownObj.optionScrollFrame:SetAttribute("FlowDisableSmoothScroll", true)
                --groupObj.Library:SetSmoothScroll(dropdownObj.optionScrollFrame, 22)
                
                dropdownObj.optionContainerFrame = create("Frame", {
                    BackgroundTransparency = 1, Size = UDim2.new(1, -6, 0, 0),
                    ZIndex = 10000, Parent = dropdownObj.optionScrollFrame
                })
                
                local maxDropdownHeight = 200 * scale_factor
                local dropdownPositionUpdateConn = nil

                local function closeDropdown(isInstant)
                    dropdownObj.isOpen = false
                    if dropdownPositionUpdateConn then
                        dropdownPositionUpdateConn()
                        dropdownPositionUpdateConn = nil
                    end
                    if search_textbox then
                        search_textbox.Text = ""
                        search_query = ""
                    end
                    if isInstant then
                        dropdownObj.optionHolderFrame.Size = UDim2.new(0, dropdown_popup_w, 0, 0)
                        dropdownObj.optionHolderFrame.Visible = false
                        dropdownObj.arrowImg.Rotation = 0
                        dropdownObj.button_frame.BackgroundColor3 = Color3.fromRGB(32, 32, 32)
                        dropdownStrokeThing.Color = Color3.fromRGB(44, 44, 44)
                        return
                    end
                    tween_to(dropdownObj.optionHolderFrame, {Size = UDim2.new(0, dropdown_popup_w, 0, 0)}, 0.22, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
                    tween_to(dropdownObj.arrowImg, {Rotation = 0}, 0.2)
                    tween_to(dropdownObj.button_frame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.18)
                    tween_to(dropdownStrokeThing, {Color = Color3.fromRGB(44, 44, 44)}, 0.18)
                    task.delay(0.22, function()
                        if dropdownObj.optionHolderFrame.Parent and not dropdownObj.isOpen then
                            dropdownObj.optionHolderFrame.Visible = false
                        end
                    end)
                end

                dropdownCloseClickBtn.MouseButton1Click:Connect(function()
                    closeDropdown(false)
                end)
                dropdownCloseClickBtn.MouseEnter:Connect(function()
                    tween_to(dropdownCloseButton, {BackgroundColor3 = Color3.fromRGB(44, 44, 44)}, 0.12)
                    tween_to(dropdownCloseIcon, {ImageColor3 = Color3.fromRGB(220, 220, 220)}, 0.12)
                end)
                dropdownCloseClickBtn.MouseLeave:Connect(function()
                    tween_to(dropdownCloseButton, {BackgroundColor3 = Color3.fromRGB(26, 26, 26)}, 0.12)
                    tween_to(dropdownCloseIcon, {ImageColor3 = Color3.fromRGB(130, 130, 130)}, 0.12)
                end)

                local search_query = ""
                local search_textbox

                local search_frame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(22, 22, 22), BorderSizePixel = 0,
                    Position = UDim2.new(0, 8, 0, 32 * scale_factor),
                    Size = UDim2.new(1, -16, 0, 22 * scale_factor),
                    ZIndex = 10001, Parent = dropdownObj.optionHolderFrame
                })
                create("UICorner", {CornerRadius = UDim.new(0, 5), Parent = search_frame})
                create("UIStroke", {Color = Color3.fromRGB(50, 50, 50), Thickness = 1, Parent = search_frame})

                search_textbox = create("TextBox", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Regular),
                    TextColor3 = Color3.fromRGB(200, 200, 200), PlaceholderColor3 = Color3.fromRGB(70, 70, 70),
                    PlaceholderText = "Search...", Text = "", BackgroundTransparency = 1,
                    Position = UDim2.new(0, 8, 0, 0), TextSize = 12 * scale_factor,
                    Size = UDim2.new(1, -16, 1, 0), TextXAlignment = Enum.TextXAlignment.Left,
                    ClearTextOnFocus = false, ZIndex = 10002, Parent = search_frame
                })

                local function createOptionsYay(filter_text)
                    for _, child in pairs(dropdownObj.optionContainerFrame:GetChildren()) do
                        if child:IsA("TextLabel") or child:IsA("TextButton") then child:Destroy() end
                    end
                    local filtered = {}
                    for _, option in ipairs(dropdownConfig.Options) do
                        if not filter_text or filter_text == "" or string.find(tostring(option):lower(), filter_text:lower(), 1, true) then
                            table.insert(filtered, option)
                        end
                    end
                    local optY = 0
                    for _, option in ipairs(filtered) do
                        local isSelected = dropdownObj.value == option
                        local optionLabelText = create("TextLabel", {
                            FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                            TextColor3 = isSelected and groupObj.Library.config.AccentColor or Color3.fromRGB(124, 124, 124),
                            Text = tostring(option), BackgroundTransparency = 1, Position = UDim2.new(0, 12, 0, optY),
                            TextSize = 14 * scale_factor, Size = UDim2.new(1, -24, 0, 18 * scale_factor),
                            TextXAlignment = Enum.TextXAlignment.Left, TextTruncate = Enum.TextTruncate.AtEnd,
                            ZIndex = 10001, Parent = dropdownObj.optionContainerFrame
                        })
                        local optionClickButton = create("TextButton", {
                            Text = "", BackgroundTransparency = 1, Position = UDim2.new(0, 0, 0, optY),
                            Size = UDim2.new(1, 0, 0, 20 * scale_factor), ZIndex = 10002, Parent = dropdownObj.optionContainerFrame
                        })
                        optionClickButton.MouseButton1Click:Connect(function()
                            dropdownObj.value = option
                            closeDropdown(false)
                            local optionText = tostring(option)
                            dropdownObj.selectedLabelText.Text = optionText
                            local newWidth = math.max(70 * scale_factor, measure_text_width(optionText, 12 * scale_factor) + 30 * scale_factor)
                            tween_to(dropdownObj.button_frame, {Size = UDim2.new(0, newWidth, 0, 21 * scale_factor), Position = UDim2.new(1, -newWidth - 10, 0, yPosition)}, 0.15)
                            dropdownConfig.Callback(option)
                        end)
                        optionClickButton.MouseEnter:Connect(function() if dropdownObj.value ~= option then tween_to(optionLabelText, {TextColor3 = Color3.fromRGB(180, 180, 180)}, 0.2) end end)
                        optionClickButton.MouseLeave:Connect(function() if dropdownObj.value ~= option then tween_to(optionLabelText, {TextColor3 = Color3.fromRGB(124, 124, 124)}, 0.2) end end)
                        optY = optY + 22 * scale_factor
                    end
                    dropdownObj.optionContainerFrame.Size = UDim2.new(1, -6, 0, optY)
                    dropdownObj.optionScrollFrame.CanvasSize = UDim2.new(0, 0, 0, optY)
                    if dropdownObj.isOpen then
                        local target_h = math.min((63 + optY / scale_factor) * scale_factor, maxDropdownHeight)
                        tween_to(dropdownObj.optionHolderFrame, {Size = UDim2.new(0, dropdown_popup_w, 0, target_h)}, 0.14, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                    end
                end

                search_textbox:GetPropertyChangedSignal("Text"):Connect(function()
                    search_query = search_textbox.Text
                    createOptionsYay(search_query)
                end)

                createOptionsYay()
                
                local dropdownClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Parent = dropdownObj.button_frame})
                
                local function updateDropdownPositionYay()
                    local buttonAbsPos = dropdownObj.button_frame.AbsolutePosition
                    local buttonAbsSize = dropdownObj.button_frame.AbsoluteSize
                    local screen_size = workspace.CurrentCamera.ViewportSize
                    local popup_h = dropdownObj.optionHolderFrame.AbsoluteSize.Y
                    local raw_x = buttonAbsPos.X
                    local raw_y = buttonAbsPos.Y + buttonAbsSize.Y + 5
                    if raw_y + popup_h > screen_size.Y - 5 then
                        raw_y = math.max(5, buttonAbsPos.Y - popup_h - 5)
                    end
                    local clamped_x = math.clamp(raw_x, 5, math.max(5, screen_size.X - dropdown_popup_w - 5))
                    dropdownObj.optionHolderFrame.Position = UDim2.new(0, clamped_x, 0, raw_y)
                end
                
                dropdownClickButton.MouseButton1Click:Connect(function()
                    dropdownObj.isOpen = not dropdownObj.isOpen
                    if dropdownObj.isOpen then
                        updateDropdownPositionYay()
                        dropdownObj.optionHolderFrame.Visible = true
                        search_textbox.Text = ""
                        search_query = ""
                        createOptionsYay()
                        local contentHeight = (63 + (#dropdownConfig.Options * 22)) * scale_factor
                        local height = math.min(contentHeight, maxDropdownHeight)
                        tween_to(dropdownObj.optionHolderFrame, {Size = UDim2.new(0, dropdown_popup_w, 0, height)}, 0.28, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                        tween_to(dropdownObj.arrowImg, {Rotation = 180}, 0.24, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                        task.defer(function() if search_textbox and search_textbox.Parent then search_textbox:CaptureFocus() end end)
                        if dropdownPositionUpdateConn then dropdownPositionUpdateConn() end
                        dropdownPositionUpdateConn = start_position_tracker(groupObj.Library, dropdownObj.button_frame, function()
                            if dropdownObj.isOpen then
                                updateDropdownPositionYay()
                            end
                        end)
                    else
                        closeDropdown(false)
                    end
                end)
                
                dropdownClickButton.MouseEnter:Connect(function()
                    tween_to(dropdownObj.button_frame, {BackgroundColor3 = Color3.fromRGB(48, 48, 48)}, 0.2)
                    tween_to(dropdownStrokeThing, {Color = Color3.fromRGB(83, 83, 83)}, 0.2)
                end)
                dropdownClickButton.MouseLeave:Connect(function()
                    if not dropdownObj.isOpen then
                        tween_to(dropdownObj.button_frame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2)
                        tween_to(dropdownStrokeThing, {Color = Color3.fromRGB(44, 44, 44)}, 0.2)
                    end
                end)
                
                function dropdownObj:Set(value, silent)
                    if value == nil then return end
                    dropdownObj.value = value
                    local displayValue = tostring(value)
                    dropdownObj.selectedLabelText.Text = displayValue
                    local newWidth = math.max(70 * scale_factor, measure_text_width(displayValue, 12 * scale_factor) + 30 * scale_factor)
                    dropdownObj.button_frame.Size = UDim2.new(0, newWidth, 0, 21 * scale_factor)
                    dropdownObj.button_frame.Position = UDim2.new(1, -newWidth - 10, 0, yPosition)
                    createOptionsYay()
                    if not silent then
                        dropdownConfig.Callback(value)
                    end
                end

                function dropdownObj:Get()
                    return dropdownObj.value
                end
                
                function dropdownObj:UpdateOptions(newOptions)
                    if type(newOptions) ~= "table" then
                        return
                    end
                    dropdownOptionsSource = newOptions
                    dropdownObj._optionsSignature = get_dropdown_signature(newOptions)
                    dropdownConfig.Options = normalize_dropdown(newOptions)
                    for _, option in ipairs(dropdownConfig.Options) do
                        addSearchTerm(tostring(option))
                    end
                    if not table.find(dropdownConfig.Options, dropdownObj.value) then
                        dropdownObj.value = dropdownConfig.Options[1] or "None"
                    end
                    local displayValue = tostring(dropdownObj.value or "None")
                    dropdownObj.selectedLabelText.Text = displayValue
                    local newWidth = math.max(70 * scale_factor, measure_text_width(displayValue, 12 * scale_factor) + 30 * scale_factor)
                    dropdownObj.button_frame.Size = UDim2.new(0, newWidth, 0, 21 * scale_factor)
                    dropdownObj.button_frame.Position = UDim2.new(1, -newWidth - 10, 0, yPosition)
                    createOptionsYay(search_query)
                    if groupObj.Library._searchQuery ~= "" then
                        groupObj.Library:SetSearchFilter(groupObj.Library._searchQuery)
                    end
                end

                if dropdownConfig.AutoRefresh then
                    groupObj.Library:_RegisterRefreshJob(dropdownConfig.RefreshInterval, function()
                        return not groupObj.Library._destroyed and dropdownObj.button_frame and dropdownObj.button_frame.Parent
                    end, function()
                        local latestOptions = dropdownOptionsSource
                        if type(dropdownConfig.OptionsProvider) == "function" then
                            local ok, providedOptions = pcall(dropdownConfig.OptionsProvider)
                            if ok and type(providedOptions) == "table" then
                                latestOptions = providedOptions
                            end
                        end
                        local latestSignature = get_dropdown_signature(latestOptions)
                        if latestSignature ~= dropdownObj._optionsSignature then
                            dropdownObj:UpdateOptions(latestOptions)
                        end
                        return true
                    end)
                end

                function dropdownObj:Close()
                    closeDropdown(true)
                end
                groupObj.Library:RegisterControl(dropdownConfig.Flag, function()
                    return dropdownObj:Get()
                end, function(value)
                    if value ~= nil then
                        dropdownObj:Set(value, true)
                    end
                end)
                
                groupObj.element_y = groupObj.element_y + 28 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, dropdownObj)
                return dropdownObj
            end

            function groupObj:AddMultiDropdown(multiDropdownConfig)
                multiDropdownConfig = multiDropdownConfig or {}
                multiDropdownConfig.Name = multiDropdownConfig.Name or "Multi Dropdown"
                multiDropdownConfig.Options = multiDropdownConfig.Options or {"Option 1", "Option 2", "Option 3"}
                multiDropdownConfig.OptionsProvider = multiDropdownConfig.OptionsProvider or multiDropdownConfig.GetOptions
                local multiDropdownHasProvider = type(multiDropdownConfig.OptionsProvider) == "function"
                if multiDropdownConfig.AutoRefresh == nil then
                    multiDropdownConfig.AutoRefresh = multiDropdownHasProvider
                else
                    multiDropdownConfig.AutoRefresh = multiDropdownConfig.AutoRefresh == true
                end
                multiDropdownConfig.RefreshInterval = math.max(tonumber(multiDropdownConfig.RefreshInterval) or 0.85, 0.35)
                multiDropdownConfig.Default = multiDropdownConfig.Default or {}
                multiDropdownConfig.Callback = multiDropdownConfig.Callback or function() end
                multiDropdownConfig.Flag = multiDropdownConfig.Flag or createAutoFlag(multiDropdownConfig.Name)
                local multiDropdownOptionsSource = multiDropdownConfig.Options
                if type(multiDropdownConfig.OptionsProvider) == "function" then
                    local ok, providedOptions = pcall(multiDropdownConfig.OptionsProvider)
                    if ok and type(providedOptions) == "table" then
                        multiDropdownOptionsSource = providedOptions
                    end
                end
                multiDropdownConfig.Options = normalize_dropdown(multiDropdownOptionsSource)
                addSearchTerm(multiDropdownConfig.Name)
                for _, option in ipairs(multiDropdownConfig.Options) do
                    addSearchTerm(tostring(option))
                end
                
                local multiDropdownObj = {}
                multiDropdownObj.selectedValues = {}
                for _, v in ipairs(multiDropdownConfig.Default) do
                    if table.find(multiDropdownConfig.Options, v) then
                        multiDropdownObj.selectedValues[v] = true
                    end
                end
                multiDropdownObj.isOpen = false
                multiDropdownObj._optionsSignature = get_dropdown_signature(multiDropdownOptionsSource)
                if multiDropdownObj._optionsSignature == "0" then
                    multiDropdownObj._optionsSignature = get_dropdown_signature(multiDropdownConfig.Options)
                end
                local yPosition = groupObj.element_y
                
                multiDropdownObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = multiDropdownConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14 * scale_factor,
                    Size = UDim2.new(0, 100 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, Parent = groupObj.mainFrame
                })
                
                local function getDisplayText()
                    local selected = {}
                    for option, isSelected in pairs(multiDropdownObj.selectedValues) do
                        if isSelected then table.insert(selected, option) end
                    end
                    table.sort(selected, function(a, b)
                        return tostring(a) < tostring(b)
                    end)
                    if #selected == 0 then return "None"
                    elseif #selected == 1 then return selected[1]
                    elseif #selected <= 2 then return table.concat(selected, ", ")
                    else return #selected .. " selected" end
                end
                
                local function getSelectedArray()
                    local arr = {}
                    for option, isSelected in pairs(multiDropdownObj.selectedValues) do
                        if isSelected then table.insert(arr, option) end
                    end
                    table.sort(arr, function(a, b)
                        return tostring(a) < tostring(b)
                    end)
                    return arr
                end
                
                local displayText = getDisplayText()
                local buttonWidth = math.max(85 * scale_factor, measure_text_width(displayText, 12 * scale_factor) + 35 * scale_factor)
                
                multiDropdownObj.button_frame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(32, 32, 32), Position = UDim2.new(1, -buttonWidth - 10, 0, yPosition),
                    Size = UDim2.new(0, buttonWidth, 0, 21 * scale_factor), Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = multiDropdownObj.button_frame})
                
                local dropdownStrokeThing = create("UIStroke", {Color = Color3.fromRGB(44, 44, 44), Parent = multiDropdownObj.button_frame})
                
                multiDropdownObj.selectedLabelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(84, 84, 84), Text = displayText, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 8, 0, 0), TextSize = 12 * scale_factor,
                    Size = UDim2.new(1, -28 * scale_factor, 1, 0), TextXAlignment = Enum.TextXAlignment.Left,
                    TextTruncate = Enum.TextTruncate.AtEnd, Parent = multiDropdownObj.button_frame
                })
                
                multiDropdownObj.arrowImg = create("ImageLabel", {
                    ImageColor3 = Color3.fromRGB(80, 80, 80), Image = default_icons.expand, BackgroundTransparency = 1,
                    Position = UDim2.new(1, -20 * scale_factor, 0.5, -7 * scale_factor),
                    Size = UDim2.new(0, 14 * scale_factor, 0, 14 * scale_factor), Parent = multiDropdownObj.button_frame
                })
                
                multiDropdownObj.optionHolderFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(16, 16, 16), Size = UDim2.new(0, 160 * scale_factor, 0, 0),
                    ClipsDescendants = true, Visible = false, ZIndex = 9999, Parent = groupObj.Library.dropdown_holder
                })
                create("UICorner", {CornerRadius = UDim.new(0, 6), Parent = multiDropdownObj.optionHolderFrame})
                create("UIStroke", {Color = Color3.fromRGB(40, 40, 40), Parent = multiDropdownObj.optionHolderFrame})
                
                create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.new(1, 1, 1), Text = multiDropdownConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 12, 0, 8 * scale_factor), TextSize = 14 * scale_factor,
                    Size = UDim2.new(1, -44 * scale_factor, 0, 20 * scale_factor), TextXAlignment = Enum.TextXAlignment.Left,
                    TextTruncate = Enum.TextTruncate.AtEnd, ZIndex = 10000, Parent = multiDropdownObj.optionHolderFrame
                })

                local multiDropdownCloseButton = create("TextButton", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold),
                    Text = "X", TextColor3 = Color3.fromRGB(170, 170, 170), TextSize = 14 * scale_factor,
                    BackgroundColor3 = Color3.fromRGB(24, 24, 24), AutoButtonColor = false,
                    Position = UDim2.new(1, -25 * scale_factor, 0, 5 * scale_factor),
                    Size = UDim2.new(0, 18 * scale_factor, 0, 18 * scale_factor),
                    ZIndex = 10002, Parent = multiDropdownObj.optionHolderFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = multiDropdownCloseButton})
                
                multiDropdownObj.optionScrollFrame = create("ScrollingFrame", {
                    BackgroundTransparency = 1, Position = UDim2.new(0, 0, 0, 30 * scale_factor),
                    Size = UDim2.new(1, 0, 1, -35 * scale_factor), ScrollBarThickness = 0,
                    ScrollBarImageColor3 = Color3.fromRGB(80, 80, 80), CanvasSize = UDim2.new(0, 0, 0, 0),
                    ZIndex = 10000, Parent = multiDropdownObj.optionHolderFrame
                })
                attach_scrollbar(groupObj.Library, multiDropdownObj.optionScrollFrame, multiDropdownObj.optionHolderFrame, {
                    TrackWidth = 7 * scale_factor,
                    ThumbWidth = 3 * scale_factor,
                    EdgeInset = 2 * scale_factor,
                    VerticalInset = 4 * scale_factor,
                    ZIndex = 10002
                })
                multiDropdownObj.optionScrollFrame:SetAttribute("FlowDisableSmoothScroll", true)
                --groupObj.Library:SetSmoothScroll(multiDropdownObj.optionScrollFrame, 22)
                
                multiDropdownObj.optionContainerFrame = create("Frame", {
                    BackgroundTransparency = 1, Size = UDim2.new(1, -6, 0, 0),
                    ZIndex = 10000, Parent = multiDropdownObj.optionScrollFrame
                })
                
                local maxMultiDropdownHeight = 220 * scale_factor
                local multiDropdownPositionConn = nil

                local function closeMultiDropdown(isInstant)
                    multiDropdownObj.isOpen = false
                    if multiDropdownPositionConn then
                        multiDropdownPositionConn()
                        multiDropdownPositionConn = nil
                    end
                    if isInstant then
                        multiDropdownObj.optionHolderFrame.Size = UDim2.new(0, 160 * scale_factor, 0, 0)
                        multiDropdownObj.optionHolderFrame.Visible = false
                        multiDropdownObj.arrowImg.Rotation = 0
                        multiDropdownObj.button_frame.BackgroundColor3 = Color3.fromRGB(32, 32, 32)
                        dropdownStrokeThing.Color = Color3.fromRGB(44, 44, 44)
                        return
                    end
                    tween_to(multiDropdownObj.optionHolderFrame, {Size = UDim2.new(0, 160 * scale_factor, 0, 0)}, 0.22, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
                    tween_to(multiDropdownObj.arrowImg, {Rotation = 0}, 0.2, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
                    tween_to(multiDropdownObj.button_frame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.18)
                    tween_to(dropdownStrokeThing, {Color = Color3.fromRGB(44, 44, 44)}, 0.18)
                    task.delay(0.22, function()
                        if multiDropdownObj.optionHolderFrame.Parent and not multiDropdownObj.isOpen then
                            multiDropdownObj.optionHolderFrame.Visible = false
                        end
                    end)
                end

                multiDropdownCloseButton.MouseButton1Click:Connect(function()
                    closeMultiDropdown(false)
                end)
                multiDropdownCloseButton.MouseEnter:Connect(function()
                    tween_to(multiDropdownCloseButton, {BackgroundColor3 = Color3.fromRGB(44, 44, 44), TextColor3 = Color3.fromRGB(220, 220, 220)}, 0.12)
                end)
                multiDropdownCloseButton.MouseLeave:Connect(function()
                    tween_to(multiDropdownCloseButton, {BackgroundColor3 = Color3.fromRGB(24, 24, 24), TextColor3 = Color3.fromRGB(138, 138, 138)}, 0.12)
                end)

                local function createMultiOptionsYay()
                    for _, child in pairs(multiDropdownObj.optionContainerFrame:GetChildren()) do
                        if child:IsA("Frame") or child:IsA("TextButton") then child:Destroy() end
                    end
                    local optY = 0
                    for _, option in ipairs(multiDropdownConfig.Options) do
                        local isSelected = multiDropdownObj.selectedValues[option] == true
                        
                        local optionFrame = create("Frame", {
                            BackgroundTransparency = 1, Position = UDim2.new(0, 0, 0, optY),
                            Size = UDim2.new(1, 0, 0, 22 * scale_factor), ZIndex = 10001,
                            Parent = multiDropdownObj.optionContainerFrame
                        })
                        
                        local checkboxFrame = create("Frame", {
                            BackgroundColor3 = isSelected and groupObj.Library.config.AccentColor or Color3.fromRGB(32, 32, 32),
                            Position = UDim2.new(0, 12, 0.5, -8 * scale_factor),
                            Size = UDim2.new(0, 16 * scale_factor, 0, 16 * scale_factor),
                            ZIndex = 10002, Parent = optionFrame
                        })
                        create("UICorner", {CornerRadius = UDim.new(0, 4), Parent = checkboxFrame})
                        
                        local checkmarkImg = create("ImageLabel", {
                            Image = "rbxassetid://10709790644", ImageColor3 = Color3.new(1, 1, 1),
                            ImageTransparency = isSelected and 0 or 1, BackgroundTransparency = 1,
                            Position = UDim2.new(0.5, 0, 0.5, 0), AnchorPoint = Vector2.new(0.5, 0.5),
                            Size = UDim2.new(0, 12 * scale_factor, 0, 12 * scale_factor),
                            ZIndex = 10003, Parent = checkboxFrame
                        })
                        
                        local optionLabelText = create("TextLabel", {
                            FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                            TextColor3 = isSelected and groupObj.Library.config.AccentColor or Color3.fromRGB(124, 124, 124),
                            Text = tostring(option), BackgroundTransparency = 1, Position = UDim2.new(0, 34, 0, 0),
                            TextSize = 14 * scale_factor, Size = UDim2.new(1, -46, 1, 0),
                            TextXAlignment = Enum.TextXAlignment.Left, ZIndex = 10002, Parent = optionFrame
                        })
                        
                        local optionClickButton = create("TextButton", {
                            Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0),
                            ZIndex = 10004, Parent = optionFrame
                        })
                        
                        optionClickButton.MouseButton1Click:Connect(function()
                            multiDropdownObj.selectedValues[option] = not multiDropdownObj.selectedValues[option]
                            local nowSelected = multiDropdownObj.selectedValues[option]
                            
                            tween_to(checkboxFrame, {BackgroundColor3 = nowSelected and groupObj.Library.config.AccentColor or Color3.fromRGB(32, 32, 32)}, 0.15)
                            tween_to(checkmarkImg, {ImageTransparency = nowSelected and 0 or 1}, 0.15)
                            tween_to(optionLabelText, {TextColor3 = nowSelected and groupObj.Library.config.AccentColor or Color3.fromRGB(124, 124, 124)}, 0.15)
                            
                            local newDisplayText = getDisplayText()
                            multiDropdownObj.selectedLabelText.Text = newDisplayText
                            local newWidth = math.max(85 * scale_factor, measure_text_width(newDisplayText, 12 * scale_factor) + 35 * scale_factor)
                            tween_to(multiDropdownObj.button_frame, {Size = UDim2.new(0, newWidth, 0, 21 * scale_factor), Position = UDim2.new(1, -newWidth - 10, 0, yPosition)}, 0.15)
                            
                            multiDropdownConfig.Callback(getSelectedArray())
                        end)
                        
                        optionClickButton.MouseEnter:Connect(function()
                            if not multiDropdownObj.selectedValues[option] then
                                tween_to(optionLabelText, {TextColor3 = Color3.fromRGB(180, 180, 180)}, 0.15)
                                tween_to(checkboxFrame, {BackgroundColor3 = Color3.fromRGB(48, 48, 48)}, 0.15)
                            end
                        end)
                        optionClickButton.MouseLeave:Connect(function()
                            if not multiDropdownObj.selectedValues[option] then
                                tween_to(optionLabelText, {TextColor3 = Color3.fromRGB(124, 124, 124)}, 0.15)
                                tween_to(checkboxFrame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.15)
                            end
                        end)
                        
                        optY = optY + 24 * scale_factor
                    end
                    multiDropdownObj.optionContainerFrame.Size = UDim2.new(1, -6, 0, optY)
                    multiDropdownObj.optionScrollFrame.CanvasSize = UDim2.new(0, 0, 0, optY)
                end
                createMultiOptionsYay()
                
                local dropdownClickButton = create("TextButton", {Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0), Parent = multiDropdownObj.button_frame})
                
                local function updateDropdownPositionYay()
                    local buttonAbsPos = multiDropdownObj.button_frame.AbsolutePosition
                    local buttonAbsSize = multiDropdownObj.button_frame.AbsoluteSize
                    multiDropdownObj.optionHolderFrame.Position = UDim2.new(0, buttonAbsPos.X, 0, buttonAbsPos.Y + buttonAbsSize.Y + 5)
                end
                
                dropdownClickButton.MouseButton1Click:Connect(function()
                    multiDropdownObj.isOpen = not multiDropdownObj.isOpen
                    if multiDropdownObj.isOpen then
                        updateDropdownPositionYay()
                        multiDropdownObj.optionHolderFrame.Visible = true
                        local contentHeight = (38 + (#multiDropdownConfig.Options * 24)) * scale_factor
                        local height = math.min(contentHeight, maxMultiDropdownHeight)
                        tween_to(multiDropdownObj.optionHolderFrame, {Size = UDim2.new(0, 160 * scale_factor, 0, height)}, 0.28, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                        tween_to(multiDropdownObj.arrowImg, {Rotation = 180}, 0.24, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                        if multiDropdownPositionConn then multiDropdownPositionConn() end
                        multiDropdownPositionConn = start_position_tracker(groupObj.Library, multiDropdownObj.button_frame, function()
                            if multiDropdownObj.isOpen then
                                updateDropdownPositionYay()
                            end
                        end)
                    else
                        closeMultiDropdown(false)
                    end
                end)
                
                dropdownClickButton.MouseEnter:Connect(function()
                    tween_to(multiDropdownObj.button_frame, {BackgroundColor3 = Color3.fromRGB(48, 48, 48)}, 0.2)
                    tween_to(dropdownStrokeThing, {Color = Color3.fromRGB(83, 83, 83)}, 0.2)
                end)
                dropdownClickButton.MouseLeave:Connect(function()
                    if not multiDropdownObj.isOpen then
                        tween_to(multiDropdownObj.button_frame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2)
                        tween_to(dropdownStrokeThing, {Color = Color3.fromRGB(44, 44, 44)}, 0.2)
                    end
                end)
                
                function multiDropdownObj:Set(values, silent)
                    if type(values) ~= "table" then
                        values = {}
                    end
                    multiDropdownObj.selectedValues = {}
                    for _, v in ipairs(values) do
                        if table.find(multiDropdownConfig.Options, v) then
                            multiDropdownObj.selectedValues[v] = true
                        end
                    end
                    local newDisplayText = getDisplayText()
                    multiDropdownObj.selectedLabelText.Text = newDisplayText
                    local newWidth = math.max(85 * scale_factor, measure_text_width(newDisplayText, 12 * scale_factor) + 35 * scale_factor)
                    multiDropdownObj.button_frame.Size = UDim2.new(0, newWidth, 0, 21 * scale_factor)
                    multiDropdownObj.button_frame.Position = UDim2.new(1, -newWidth - 10, 0, yPosition)
                    createMultiOptionsYay()
                    if not silent then
                        multiDropdownConfig.Callback(getSelectedArray())
                    end
                end
                
                function multiDropdownObj:UpdateOptions(newOptions)
                    if type(newOptions) ~= "table" then
                        return
                    end
                    multiDropdownOptionsSource = newOptions
                    multiDropdownObj._optionsSignature = get_dropdown_signature(newOptions)
                    multiDropdownConfig.Options = normalize_dropdown(newOptions)
                    for _, option in ipairs(multiDropdownConfig.Options) do
                        addSearchTerm(tostring(option))
                    end
                    local filteredSelectedValues = {}
                    for option, isSelected in pairs(multiDropdownObj.selectedValues) do
                        if isSelected and table.find(multiDropdownConfig.Options, option) then
                            filteredSelectedValues[option] = true
                        end
                    end
                    multiDropdownObj.selectedValues = filteredSelectedValues
                    local newDisplayText = getDisplayText()
                    multiDropdownObj.selectedLabelText.Text = newDisplayText
                    local newWidth = math.max(85 * scale_factor, measure_text_width(newDisplayText, 12 * scale_factor) + 35 * scale_factor)
                    multiDropdownObj.button_frame.Size = UDim2.new(0, newWidth, 0, 21 * scale_factor)
                    multiDropdownObj.button_frame.Position = UDim2.new(1, -newWidth - 10, 0, yPosition)
                    createMultiOptionsYay()
                    if groupObj.Library._searchQuery ~= "" then
                        groupObj.Library:SetSearchFilter(groupObj.Library._searchQuery)
                    end
                end

                if multiDropdownConfig.AutoRefresh then
                    groupObj.Library:_RegisterRefreshJob(multiDropdownConfig.RefreshInterval, function()
                        return not groupObj.Library._destroyed and multiDropdownObj.button_frame and multiDropdownObj.button_frame.Parent
                    end, function()
                        local latestOptions = multiDropdownOptionsSource
                        if type(multiDropdownConfig.OptionsProvider) == "function" then
                            local ok, providedOptions = pcall(multiDropdownConfig.OptionsProvider)
                            if ok and type(providedOptions) == "table" then
                                latestOptions = providedOptions
                            end
                        end
                        local latestSignature = get_dropdown_signature(latestOptions)
                        if latestSignature ~= multiDropdownObj._optionsSignature then
                            multiDropdownObj:UpdateOptions(latestOptions)
                        end
                        return true
                    end)
                end
                
                function multiDropdownObj:Get() return getSelectedArray() end

                function multiDropdownObj:Close()
                    closeMultiDropdown(true)
                end
                groupObj.Library:RegisterControl(multiDropdownConfig.Flag, function()
                    return multiDropdownObj:Get()
                end, function(value)
                    if type(value) == "table" then
                        multiDropdownObj:Set(value, true)
                    end
                end)

                groupObj.element_y = groupObj.element_y + 31 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, multiDropdownObj)
                return multiDropdownObj
            end

            function groupObj:AddProgressBar(progressConfig)
                progressConfig = progressConfig or {}
                progressConfig.Name = progressConfig.Name or "Progress"
                progressConfig.Value = math.clamp(tonumber(progressConfig.Value) or 0, 0, 1)
                progressConfig.Color = progressConfig.Color
                progressConfig.ShowPercent = progressConfig.ShowPercent ~= false
                addSearchTerm(progressConfig.Name)

                local progressObj = {}
                progressObj.value = progressConfig.Value
                local yPosition = groupObj.element_y
                local barHeight = 10 * scale_factor
                local barColor = progressConfig.Color or groupObj.Library.config.AccentColor

                progressObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = progressConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14 * scale_factor,
                    Size = UDim2.new(0, 160 * scale_factor, 0, 18 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, Parent = groupObj.mainFrame
                })

                if progressConfig.ShowPercent then
                    progressObj.percentLabel = create("TextLabel", {
                        FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                        TextColor3 = Color3.fromRGB(90, 90, 90),
                        Text = math.floor(progressConfig.Value * 100) .. "%",
                        BackgroundTransparency = 1,
                        Position = UDim2.new(1, -40 * scale_factor, 0, yPosition),
                        TextSize = 12.5 * scale_factor,
                        Size = UDim2.new(0, 36 * scale_factor, 0, 18 * scale_factor),
                        TextXAlignment = Enum.TextXAlignment.Right, Parent = groupObj.mainFrame
                    })
                end

                progressObj.trackFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(32, 32, 32),
                    Position = UDim2.new(0, 10, 0, yPosition + 22 * scale_factor),
                    Size = UDim2.new(1, -20 * scale_factor, 0, barHeight),
                    Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = progressObj.trackFrame})

                progressObj.fillFrame = create("Frame", {
                    BackgroundColor3 = barColor,
                    Size = UDim2.new(progressObj.value, 0, 1, 0),
                    Parent = progressObj.trackFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = progressObj.fillFrame})

                function progressObj:Set(value, animate)
                    progressObj.value = math.clamp(tonumber(value) or 0, 0, 1)
                    if animate ~= false then
                        tween_to(progressObj.fillFrame, {Size = UDim2.new(progressObj.value, 0, 1, 0)}, 0.3)
                    else
                        progressObj.fillFrame.Size = UDim2.new(progressObj.value, 0, 1, 0)
                    end
                    if progressObj.percentLabel then
                        progressObj.percentLabel.Text = math.floor(progressObj.value * 100) .. "%"
                    end
                end

                function progressObj:Get()
                    return progressObj.value
                end

                function progressObj:SetColor(color)
                    tween_to(progressObj.fillFrame, {BackgroundColor3 = color}, 0.2)
                end

                groupObj.element_y = groupObj.element_y + 40 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, progressObj)
                return progressObj
            end

            function groupObj:AddNumberInput(numberInputConfig)
                numberInputConfig = numberInputConfig or {}
                numberInputConfig.Name = numberInputConfig.Name or "Number"
                numberInputConfig.Min = tonumber(numberInputConfig.Min)
                numberInputConfig.Max = tonumber(numberInputConfig.Max)
                local rawDefault = tonumber(numberInputConfig.Default) or 0
                numberInputConfig.Default = rawDefault
                numberInputConfig.Step = math.abs(tonumber(numberInputConfig.Step) or 1)
                numberInputConfig.Callback = numberInputConfig.Callback or function() end
                numberInputConfig.Flag = numberInputConfig.Flag or createAutoFlag(numberInputConfig.Name)
                addSearchTerm(numberInputConfig.Name)

                local numberObj = {}
                numberObj.value = rawDefault
                local yPosition = groupObj.element_y

                local function clampValue(v)
                    if numberInputConfig.Min and v < numberInputConfig.Min then v = numberInputConfig.Min end
                    if numberInputConfig.Max and v > numberInputConfig.Max then v = numberInputConfig.Max end
                    return v
                end

                numberObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = numberInputConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14.6 * scale_factor,
                    Size = UDim2.new(0, 130 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, Parent = groupObj.mainFrame
                })

                local controlWidth = 96 * scale_factor
                numberObj.controlFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(28, 28, 28),
                    Position = UDim2.new(1, -controlWidth - 10, 0, yPosition - 1),
                    Size = UDim2.new(0, controlWidth, 0, 22 * scale_factor),
                    Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = numberObj.controlFrame})
                create("UIStroke", {Color = Color3.fromRGB(44, 44, 44), Parent = numberObj.controlFrame})

                local btnSize = 22 * scale_factor

                local decrementBtn = create("TextButton", {
                    Text = "−", BackgroundTransparency = 1,
                    TextColor3 = Color3.fromRGB(100, 100, 100),
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextSize = 16 * scale_factor,
                    Size = UDim2.new(0, btnSize, 1, 0),
                    Position = UDim2.new(0, 0, 0, 0),
                    Parent = numberObj.controlFrame
                })

                numberObj.valueLabel = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(210, 210, 210),
                    Text = tostring(numberObj.value), BackgroundTransparency = 1,
                    Position = UDim2.new(0, btnSize, 0, 0),
                    Size = UDim2.new(1, -btnSize * 2, 1, 0),
                    TextSize = 13 * scale_factor, TextXAlignment = Enum.TextXAlignment.Center,
                    Parent = numberObj.controlFrame
                })

                local incrementBtn = create("TextButton", {
                    Text = "+", BackgroundTransparency = 1,
                    TextColor3 = Color3.fromRGB(100, 100, 100),
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextSize = 16 * scale_factor,
                    Size = UDim2.new(0, btnSize, 1, 0),
                    Position = UDim2.new(1, -btnSize, 0, 0),
                    Parent = numberObj.controlFrame
                })

                local function updateDisplay()
                    numberObj.valueLabel.Text = tostring(numberObj.value)
                end

                function numberObj:Set(value, silent)
                    numberObj.value = clampValue(tonumber(value) or numberObj.value)
                    updateDisplay()
                    if not silent then
                        numberInputConfig.Callback(numberObj.value)
                    end
                end

                function numberObj:Get()
                    return numberObj.value
                end

                decrementBtn.MouseButton1Click:Connect(function()
                    numberObj:Set(numberObj.value - numberInputConfig.Step)
                end)
                incrementBtn.MouseButton1Click:Connect(function()
                    numberObj:Set(numberObj.value + numberInputConfig.Step)
                end)

                decrementBtn.MouseEnter:Connect(function() tween_to(decrementBtn, {TextColor3 = Color3.fromRGB(180, 180, 180)}, 0.15) end)
                decrementBtn.MouseLeave:Connect(function() tween_to(decrementBtn, {TextColor3 = Color3.fromRGB(100, 100, 100)}, 0.15) end)
                incrementBtn.MouseEnter:Connect(function() tween_to(incrementBtn, {TextColor3 = Color3.fromRGB(180, 180, 180)}, 0.15) end)
                incrementBtn.MouseLeave:Connect(function() tween_to(incrementBtn, {TextColor3 = Color3.fromRGB(100, 100, 100)}, 0.15) end)

                groupObj.Library:RegisterControl(numberInputConfig.Flag, function()
                    return numberObj:Get()
                end, function(value)
                    numberObj:Set(value, true)
                end)

                groupObj.element_y = groupObj.element_y + 28 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, numberObj)
                return numberObj
            end

            function groupObj:AddBadge(badgeConfig)
                badgeConfig = badgeConfig or {}
                badgeConfig.Name = badgeConfig.Name or "Badge"
                badgeConfig.Value = tostring(badgeConfig.Value or "")
                badgeConfig.Color = badgeConfig.Color or "blue"
                addSearchTerm(badgeConfig.Name)
                addSearchTerm(badgeConfig.Value)

                local badgeObj = {}
                local yPosition = groupObj.element_y

                local colorMap = {
                    blue   = {bg = Color3.fromRGB(2, 60, 120),   text = Color3.fromRGB(130, 195, 255)},
                    green  = {bg = Color3.fromRGB(10, 70, 30),   text = Color3.fromRGB(100, 220, 130)},
                    red    = {bg = Color3.fromRGB(90, 15, 15),   text = Color3.fromRGB(255, 110, 110)},
                    yellow = {bg = Color3.fromRGB(80, 55, 5),    text = Color3.fromRGB(250, 190, 80)},
                    purple = {bg = Color3.fromRGB(60, 20, 100),  text = Color3.fromRGB(195, 155, 255)},
                    gray   = {bg = Color3.fromRGB(30, 30, 30),   text = Color3.fromRGB(150, 150, 150)},
                }
                local colorEntry = colorMap[badgeConfig.Color] or colorMap.blue

                badgeObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = badgeConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14 * scale_factor,
                    Size = UDim2.new(0, 155 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, Parent = groupObj.mainFrame
                })

                local measuredW = math.max(38 * scale_factor, measure_text_width(badgeConfig.Value, 12 * scale_factor) + 18 * scale_factor)

                badgeObj.pillFrame = create("Frame", {
                    BackgroundColor3 = colorEntry.bg,
                    Position = UDim2.new(1, -measuredW - 10, 0, yPosition + 2),
                    Size = UDim2.new(0, measuredW, 0, 18 * scale_factor),
                    Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = badgeObj.pillFrame})

                badgeObj.valueLabel = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = colorEntry.text, Text = badgeConfig.Value, BackgroundTransparency = 1,
                    Size = UDim2.new(1, -4, 1, 0), Position = UDim2.new(0, 2, 0, 0),
                    TextSize = 12 * scale_factor, TextXAlignment = Enum.TextXAlignment.Center,
                    TextTruncate = Enum.TextTruncate.AtEnd, Parent = badgeObj.pillFrame
                })

                function badgeObj:Set(newValue, newColor)
                    newValue = tostring(newValue or "")
                    badgeObj.valueLabel.Text = newValue
                    local newW = math.max(38 * scale_factor, measure_text_width(newValue, 12 * scale_factor) + 18 * scale_factor)
                    tween_to(badgeObj.pillFrame, {
                        Size = UDim2.new(0, newW, 0, 18 * scale_factor),
                        Position = UDim2.new(1, -newW - 10, 0, yPosition + 2)
                    }, 0.18)
                    if newColor then
                        local c = colorMap[newColor] or colorMap.blue
                        tween_to(badgeObj.pillFrame, {BackgroundColor3 = c.bg}, 0.2)
                        tween_to(badgeObj.valueLabel, {TextColor3 = c.text}, 0.2)
                    end
                end

                function badgeObj:Get()
                    return badgeObj.valueLabel.Text
                end

                groupObj.element_y = groupObj.element_y + 28 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, badgeObj)
                return badgeObj
            end

            function groupObj:AddDivider()
                local yPosition = groupObj.element_y
                local dividerFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(36, 36, 36),
                    Position = UDim2.new(0, 10, 0, yPosition + 4 * scale_factor),
                    Size = UDim2.new(0.92, 0, 0, 1), Parent = groupObj.mainFrame
                })
                create("UIGradient", {
                    Color = ColorSequence.new({ColorSequenceKeypoint.new(0, Color3.fromRGB(108, 108, 108)), ColorSequenceKeypoint.new(0.514, Color3.new(1, 1, 1)), ColorSequenceKeypoint.new(1, Color3.fromRGB(108, 108, 108))}),
                    Parent = dividerFrame
                })
                groupObj.element_y = groupObj.element_y + 12 * scale_factor
                update_group_size()
                return dividerFrame
            end
                        function groupObj:AddSpacer(height)
                height = tonumber(height) or 10
                groupObj.element_y = groupObj.element_y + height * scale_factor
                update_group_size()
            end

            
            function groupObj:AddLabel(labelConfig)
                labelConfig = labelConfig or {}
                labelConfig.Text = labelConfig.Text or "Label"
                labelConfig.Wrap = labelConfig.Wrap == true
                addSearchTerm(labelConfig.Text)
                local yPosition = groupObj.element_y
                local labelMaxWidth = 238 * scale_factor
                local labelTextSize = 14 * scale_factor
                local measuredBounds = text_service:GetTextSize(
                    tostring(labelConfig.Text),
                    labelTextSize,
                    Enum.Font.GothamSemibold,
                    Vector2.new(labelMaxWidth, labelConfig.Wrap and math.huge or (labelTextSize + 4))
                )
                local labelHeight = labelConfig.Wrap and math.max(20 * scale_factor, measuredBounds.Y) or (20 * scale_factor)
                local labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = labelConfig.Text, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = labelTextSize,
                    Size = UDim2.new(0, labelMaxWidth, 0, labelHeight), TextXAlignment = Enum.TextXAlignment.Left,
                    TextYAlignment = Enum.TextYAlignment.Top, TextWrapped = labelConfig.Wrap,
                    TextTruncate = labelConfig.Wrap and Enum.TextTruncate.None or Enum.TextTruncate.AtEnd,
                    ClipsDescendants = true,
                    Parent = groupObj.mainFrame
                })
                groupObj.element_y = groupObj.element_y + labelHeight + 6 * scale_factor
                update_group_size()
                return labelText
            end
                        function groupObj:AddParagraph(config)
                config = config or {}
                config.Text = config.Text or config.Content or "Paragraph text goes here."
                return groupObj:AddLabel({
                    Name = config.Text,
                    Text = config.Text,
                    Wrap = true
                })
            end

            
            function groupObj:AddTextInput(textInputConfig)
                textInputConfig = textInputConfig or {}
                textInputConfig.Name = textInputConfig.Name or "Input"
                textInputConfig.Placeholder = textInputConfig.Placeholder or "Enter text..."
                textInputConfig.Default = tostring(textInputConfig.Default or "")
                textInputConfig.Callback = textInputConfig.Callback or function() end
                textInputConfig.Flag = textInputConfig.Flag or createAutoFlag(textInputConfig.Name)
                addSearchTerm(textInputConfig.Name)
                addSearchTerm(textInputConfig.Placeholder)
                
                local textInputObj = {}
                textInputObj.value = textInputConfig.Default
                textInputObj.Flag = textInputConfig.Flag
                textInputObj.Name = textInputConfig.Name
                local yPosition = groupObj.element_y
                
                textInputObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = textInputConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14.6 * scale_factor,
                    Size = UDim2.new(0, 80 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, Parent = groupObj.mainFrame
                })
                
                textInputObj.inputFrame = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(32, 32, 32),
                    Position = UDim2.new(0, 10, 0, yPosition + 23 * scale_factor),
                    Size = UDim2.new(0, 240 * scale_factor, 0, 28 * scale_factor),
                    Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(0, 6), Parent = textInputObj.inputFrame})
                create("UIStroke", {Color = Color3.fromRGB(44, 44, 44), Parent = textInputObj.inputFrame})
                
                textInputObj.textBox = create("TextBox", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    PlaceholderText = textInputConfig.Placeholder,
                    PlaceholderColor3 = Color3.fromRGB(80, 80, 80),
                    Text = textInputConfig.Default,
                    TextColor3 = Color3.fromRGB(200, 200, 200),
                    TextSize = 13.8 * scale_factor,
                    BackgroundTransparency = 1,
                    ClearTextOnFocus = false,
                    Position = UDim2.new(0, 8, 0, 0),
                    Size = UDim2.new(1, -16, 1, 0),
                    TextXAlignment = Enum.TextXAlignment.Left,
                    Parent = textInputObj.inputFrame
                })
                
                textInputObj.textBox.Focused:Connect(function()
                    tween_to(textInputObj.inputFrame, {BackgroundColor3 = Color3.fromRGB(40, 40, 40)}, 0.2)
                end)
                
                textInputObj.textBox.FocusLost:Connect(function(enterPressed)
                    tween_to(textInputObj.inputFrame, {BackgroundColor3 = Color3.fromRGB(32, 32, 32)}, 0.2)
                    textInputObj.value = textInputObj.textBox.Text
                    textInputConfig.Callback(textInputObj.value, enterPressed)
                end)
                
                function textInputObj:Set(text)
                    local asString = tostring(text or "")
                    textInputObj.value = asString
                    textInputObj.textBox.Text = asString
                end
                
                function textInputObj:Get()
                    return textInputObj.value
                end

                function textInputObj:GetValue()
                    return textInputObj:Get()
                end

                function textInputObj:SetValue(text, silent)
                    textInputObj:Set(tostring(text or ""))
                    if not silent then
                        textInputConfig.Callback(textInputObj.value, false)
                    end
                end

                function textInputObj:ResetValue()
                    textInputObj:Set(textInputConfig.Default)
                end

                groupObj.Library:RegisterControl(textInputConfig.Flag, function()
                    return textInputObj:Get()
                end, function(value)
                    textInputObj:Set(tostring(value or ""))
                end)
                
                groupObj.element_y = groupObj.element_y + 58 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, textInputObj)
                return textInputObj
            end

            function groupObj:AddTextbox(textboxConfig)
                textboxConfig = textboxConfig or {}

                local primaryCallback = textboxConfig.Callback
                if type(primaryCallback) ~= "function" then
                    primaryCallback = textboxConfig.Function
                end
                if type(primaryCallback) ~= "function" then
                    primaryCallback = function() end
                end

                local changedCallback = textboxConfig.ChangedCallback or textboxConfig.OnChanged
                local signalCallback = textboxConfig.OnPressed or textboxConfig.Signal
                local enterOnly = textboxConfig.EnterOnly == true
                local defaultText = tostring(textboxConfig.Default or textboxConfig.Value or "")

                local function fireTextboxCallbacks(value, enterPressed)
                    if enterOnly and not enterPressed then
                        return
                    end
                    primaryCallback(value, enterPressed)
                    if type(changedCallback) == "function" then
                        changedCallback(value, enterPressed)
                    end
                    if type(signalCallback) == "function" then
                        signalCallback(value, enterPressed)
                    end
                end

                local function fireTextboxCallbacksForced(value, enterPressed)
                    primaryCallback(value, enterPressed)
                    if type(changedCallback) == "function" then
                        changedCallback(value, enterPressed)
                    end
                    if type(signalCallback) == "function" then
                        signalCallback(value, enterPressed)
                    end
                end

                local textInputObj = groupObj:AddTextInput({
                    Name = textboxConfig.Name or textboxConfig.Title or textboxConfig.Text or "Textbox",
                    Placeholder = textboxConfig.Placeholder or textboxConfig.PlaceholderText or textboxConfig.Hint or "Enter text...",
                    Default = defaultText,
                    Callback = fireTextboxCallbacks,
                    Flag = textboxConfig.Flag or textboxConfig.ConfigId
                })

                textInputObj.Title = textboxConfig.Title or textboxConfig.Text or textboxConfig.Name or "Textbox"
                textInputObj.ConfigId = tostring(textboxConfig.ConfigId or textInputObj.Flag or textInputObj.Title)
                textInputObj.Box = textInputObj.textBox

                local baseSetValue = textInputObj.SetValue
                function textInputObj:SetValue(text, silent)
                    baseSetValue(self, text, true)
                    if not silent then
                        fireTextboxCallbacksForced(self:Get(), false)
                    end
                end

                return textInputObj
            end

            function groupObj:AddTextBox(textboxConfig)
                return groupObj:AddTextbox(textboxConfig)
            end
            
            function groupObj:AddColorPicker(colorPickerConfig)
                colorPickerConfig = colorPickerConfig or {}
                colorPickerConfig.Name = colorPickerConfig.Name or "Color"
                colorPickerConfig.Default = colorPickerConfig.Default or Color3.fromRGB(255, 100, 150)
                colorPickerConfig.Callback = colorPickerConfig.Callback or function() end
                colorPickerConfig.Flag = colorPickerConfig.Flag or createAutoFlag(colorPickerConfig.Name)
                addSearchTerm(colorPickerConfig.Name)
                
                local colorPickerObj = {}
                colorPickerObj.value = colorPickerConfig.Default
                colorPickerObj.isOpen = false
                local yPosition = groupObj.element_y
                
                -- Convert Color3 to HSV
                local function rgbToHsv(color)
                    local r, g, b = color.R, color.G, color.B
                    local max, min = math.max(r, g, b), math.min(r, g, b)
                    local h, s, v = 0, 0, max
                    local d = max - min
                    s = max == 0 and 0 or d / max
                    if max ~= min then
                        if max == r then h = (g - b) / d + (g < b and 6 or 0)
                        elseif max == g then h = (b - r) / d + 2
                        elseif max == b then h = (r - g) / d + 4 end
                        h = h / 6
                    end
                    return h, s, v
                end
                
                local currentH, currentS, currentV = rgbToHsv(colorPickerConfig.Default)
                
                colorPickerObj.labelText = create("TextLabel", {
                    FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.SemiBold),
                    TextColor3 = Color3.fromRGB(124, 124, 124), Text = colorPickerConfig.Name, BackgroundTransparency = 1,
                    Position = UDim2.new(0, 10, 0, yPosition), TextSize = 14 * scale_factor,
                    Size = UDim2.new(0, 100 * scale_factor, 0, 20 * scale_factor),
                    TextXAlignment = Enum.TextXAlignment.Left, Parent = groupObj.mainFrame
                })
                
                -- Color preview button
                colorPickerObj.colorPreview = create("Frame", {
                    BackgroundColor3 = colorPickerObj.value,
                    Position = UDim2.new(1, -40 * scale_factor, 0, yPosition),
                    Size = UDim2.new(0, 30 * scale_factor, 0, 20 * scale_factor),
                    Parent = groupObj.mainFrame
                })
                create("UICorner", {CornerRadius = UDim.new(0, 6), Parent = colorPickerObj.colorPreview})
                create("UIStroke", {Color = Color3.fromRGB(60, 60, 60), Parent = colorPickerObj.colorPreview})
                
                -- Picker popup holder
                colorPickerObj.pickerHolder = create("Frame", {
                    BackgroundColor3 = Color3.fromRGB(24, 24, 24),
                    Size = UDim2.new(0, 200 * scale_factor, 0, 0),
                    ClipsDescendants = true, Visible = false, ZIndex = 9999,
                    Parent = groupObj.Library.dropdown_holder
                })
                create("UICorner", {CornerRadius = UDim.new(0, 8), Parent = colorPickerObj.pickerHolder})
                create("UIStroke", {Color = Color3.fromRGB(50, 50, 50), Parent = colorPickerObj.pickerHolder})
                
                -- Saturation/Value gradient box
                colorPickerObj.svBox = create("Frame", {
                    BackgroundColor3 = Color3.fromHSV(currentH, 1, 1),
                    Position = UDim2.new(0, 10, 0, 10),
                    Size = UDim2.new(1, -20, 0, 100 * scale_factor),
                    ZIndex = 10000, Parent = colorPickerObj.pickerHolder
                })
                create("UICorner", {CornerRadius = UDim.new(0, 6), Parent = colorPickerObj.svBox})
                
                -- White to transparent gradient (saturation)
                create("UIGradient", {
                    Color = ColorSequence.new({
                        ColorSequenceKeypoint.new(0, Color3.new(1, 1, 1)),
                        ColorSequenceKeypoint.new(1, Color3.new(1, 1, 1))
                    }),
                    Transparency = NumberSequence.new({
                        NumberSequenceKeypoint.new(0, 0),
                        NumberSequenceKeypoint.new(1, 1)
                    }), Parent = colorPickerObj.svBox
                })
                
                -- Black overlay for value
                local valueOverlay = create("Frame", {
                    BackgroundColor3 = Color3.new(0, 0, 0),
                    Size = UDim2.new(1, 0, 1, 0), ZIndex = 10001, Parent = colorPickerObj.svBox
                })
                create("UICorner", {CornerRadius = UDim.new(0, 6), Parent = valueOverlay})
                create("UIGradient", {
                    Color = ColorSequence.new(Color3.new(0, 0, 0)),
                    Transparency = NumberSequence.new({
                        NumberSequenceKeypoint.new(0, 1),
                        NumberSequenceKeypoint.new(1, 0)
                    }),
                    Rotation = 90, Parent = valueOverlay
                })
                
                -- SV cursor
                colorPickerObj.svCursor = create("Frame", {
                    BackgroundTransparency = 1,
                    Position = UDim2.new(currentS, -6, 1 - currentV, -6),
                    Size = UDim2.new(0, 12, 0, 12), ZIndex = 10003, Parent = colorPickerObj.svBox
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = colorPickerObj.svCursor})
                create("UIStroke", {Color = Color3.new(1, 1, 1), Thickness = 2, Parent = colorPickerObj.svCursor})
                
                -- Hue slider
                colorPickerObj.hueSlider = create("Frame", {
                    BackgroundColor3 = Color3.new(1, 1, 1),
                    Position = UDim2.new(0, 10, 0, 120 * scale_factor),
                    Size = UDim2.new(1, -20, 0, 14 * scale_factor),
                    ZIndex = 10000, Parent = colorPickerObj.pickerHolder
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = colorPickerObj.hueSlider})
                create("UIGradient", {
                    Color = ColorSequence.new({
                        ColorSequenceKeypoint.new(0, Color3.fromHSV(0, 1, 1)),
                        ColorSequenceKeypoint.new(0.167, Color3.fromHSV(0.167, 1, 1)),
                        ColorSequenceKeypoint.new(0.333, Color3.fromHSV(0.333, 1, 1)),
                        ColorSequenceKeypoint.new(0.5, Color3.fromHSV(0.5, 1, 1)),
                        ColorSequenceKeypoint.new(0.667, Color3.fromHSV(0.667, 1, 1)),
                        ColorSequenceKeypoint.new(0.833, Color3.fromHSV(0.833, 1, 1)),
                        ColorSequenceKeypoint.new(1, Color3.fromHSV(1, 1, 1))
                    }), Parent = colorPickerObj.hueSlider
                })
                
                -- Hue cursor
                colorPickerObj.hueCursor = create("Frame", {
                    BackgroundColor3 = Color3.new(1, 1, 1),
                    Position = UDim2.new(currentH, -7, 0.5, -7),
                    Size = UDim2.new(0, 14, 0, 14), ZIndex = 10001, Parent = colorPickerObj.hueSlider
                })
                create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = colorPickerObj.hueCursor})
                create("UIStroke", {Color = Color3.fromRGB(40, 40, 40), Thickness = 2, Parent = colorPickerObj.hueCursor})
                
                -- Preset colors
                local presetColors = {
                    Color3.fromRGB(38, 70, 83), Color3.fromRGB(42, 157, 143), 
                    Color3.fromRGB(233, 196, 106), Color3.fromRGB(244, 162, 97),
                    Color3.fromRGB(231, 111, 81), Color3.fromRGB(190, 49, 49),
                    Color3.fromRGB(40, 55, 114), Color3.fromRGB(68, 114, 196),
                    Color3.fromRGB(78, 166, 206), Color3.fromRGB(108, 225, 226)
                }
                
                local presetY = 145 * scale_factor
                for i, preset in ipairs(presetColors) do
                    local col = (i - 1) % 5
                    local row = math.floor((i - 1) / 5)
                    local presetBtn = create("Frame", {
                        BackgroundColor3 = preset,
                        Position = UDim2.new(0, 10 + col * 38 * scale_factor, 0, presetY + row * 28 * scale_factor),
                        Size = UDim2.new(0, 32 * scale_factor, 0, 22 * scale_factor),
                        ZIndex = 10000, Parent = colorPickerObj.pickerHolder
                    })
                    create("UICorner", {CornerRadius = UDim.new(1, 0), Parent = presetBtn})
                    
                    local presetClick = create("TextButton", {
                        Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0),
                        ZIndex = 10001, Parent = presetBtn
                    })
                    presetClick.MouseButton1Click:Connect(function()
                        currentH, currentS, currentV = rgbToHsv(preset)
                        colorPickerObj.value = preset
                        colorPickerObj.colorPreview.BackgroundColor3 = preset
                        colorPickerObj.svBox.BackgroundColor3 = Color3.fromHSV(currentH, 1, 1)
                        colorPickerObj.svCursor.Position = UDim2.new(currentS, -6, 1 - currentV, -6)
                        colorPickerObj.hueCursor.Position = UDim2.new(currentH, -7, 0.5, -7)
                        colorPickerConfig.Callback(preset)
                    end)
                end
                
                local function updateColor()
                    colorPickerObj.value = Color3.fromHSV(currentH, currentS, currentV)
                    colorPickerObj.colorPreview.BackgroundColor3 = colorPickerObj.value
                    colorPickerObj.svBox.BackgroundColor3 = Color3.fromHSV(currentH, 1, 1)
                    colorPickerConfig.Callback(colorPickerObj.value)
                end
                
                -- SV box interaction
                local svClickBtn = create("TextButton", {
                    Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0),
                    ZIndex = 10002, Parent = colorPickerObj.svBox
                })
                
                local svDragging = false
                svClickBtn.MouseButton1Down:Connect(function() svDragging = true end)
                groupObj.Library:_TrackConnection(input_service.InputEnded:Connect(function(input)
                    if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
                        svDragging = false
                    end
                end))
                groupObj.Library:_TrackConnection(input_service.InputChanged:Connect(function(input)
                    if svDragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
                        local absPos, absSize = colorPickerObj.svBox.AbsolutePosition, colorPickerObj.svBox.AbsoluteSize
                        currentS = math.clamp((input.Position.X - absPos.X) / absSize.X, 0, 1)
                        currentV = math.clamp(1 - (input.Position.Y - absPos.Y) / absSize.Y, 0, 1)
                        colorPickerObj.svCursor.Position = UDim2.new(currentS, -6, 1 - currentV, -6)
                        updateColor()
                    end
                end))
                
                -- Hue slider interaction
                local hueClickBtn = create("TextButton", {
                    Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0),
                    ZIndex = 10002, Parent = colorPickerObj.hueSlider
                })
                
                local hueDragging = false
                hueClickBtn.MouseButton1Down:Connect(function() hueDragging = true end)
                groupObj.Library:_TrackConnection(input_service.InputEnded:Connect(function(input)
                    if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
                        hueDragging = false
                    end
                end))
                groupObj.Library:_TrackConnection(input_service.InputChanged:Connect(function(input)
                    if hueDragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
                        local absPos, absSize = colorPickerObj.hueSlider.AbsolutePosition, colorPickerObj.hueSlider.AbsoluteSize
                        currentH = math.clamp((input.Position.X - absPos.X) / absSize.X, 0, 1)
                        colorPickerObj.hueCursor.Position = UDim2.new(currentH, -7, 0.5, -7)
                        updateColor()
                    end
                end))
                
                -- Open/close picker
                local pickerClickBtn = create("TextButton", {
                    Text = "", BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0),
                    Parent = colorPickerObj.colorPreview
                })
                
                local colorPickerPositionConn = nil
                local function closeColorPicker(isInstant)
                    colorPickerObj.isOpen = false
                    if colorPickerPositionConn then
                        colorPickerPositionConn()
                        colorPickerPositionConn = nil
                    end
                    if isInstant then
                        colorPickerObj.pickerHolder.Size = UDim2.new(0, 200 * scale_factor, 0, 0)
                        colorPickerObj.pickerHolder.Visible = false
                        return
                    end
                    tween_to(colorPickerObj.pickerHolder, {
                        Size = UDim2.new(0, 200 * scale_factor, 0, 0)
                    }, 0.2, Enum.EasingStyle.Quint, Enum.EasingDirection.In)
                    task.delay(0.2, function()
                        if colorPickerObj.pickerHolder.Parent and not colorPickerObj.isOpen then
                            colorPickerObj.pickerHolder.Visible = false
                        end
                    end)
                end

                local function updatePickerPosition()
                    local absPos = colorPickerObj.colorPreview.AbsolutePosition
                    local absSize = colorPickerObj.colorPreview.AbsoluteSize
                    colorPickerObj.pickerHolder.Position = UDim2.new(0, absPos.X - 160 * scale_factor, 0, absPos.Y + absSize.Y + 5)
                end
                
                pickerClickBtn.MouseButton1Click:Connect(function()
                    colorPickerObj.isOpen = not colorPickerObj.isOpen
                    if colorPickerObj.isOpen then
                        updatePickerPosition()
                        colorPickerObj.pickerHolder.Visible = true
                        tween_to(colorPickerObj.pickerHolder, {
                            Size = UDim2.new(0, 200 * scale_factor, 0, 210 * scale_factor)
                        }, 0.26, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
                        if colorPickerPositionConn then colorPickerPositionConn() end
                        colorPickerPositionConn = start_position_tracker(groupObj.Library, colorPickerObj.colorPreview, function()
                            if colorPickerObj.isOpen then
                                updatePickerPosition()
                            end
                        end)
                    else
                        closeColorPicker(false)
                    end
                end)
                
                function colorPickerObj:Set(color, silent)
                    colorPickerObj.value = color
                    currentH, currentS, currentV = rgbToHsv(color)
                    colorPickerObj.colorPreview.BackgroundColor3 = color
                    colorPickerObj.svBox.BackgroundColor3 = Color3.fromHSV(currentH, 1, 1)
                    colorPickerObj.svCursor.Position = UDim2.new(currentS, -6, 1 - currentV, -6)
                    colorPickerObj.hueCursor.Position = UDim2.new(currentH, -7, 0.5, -7)
                    if not silent then
                        colorPickerConfig.Callback(color)
                    end
                end
                
                function colorPickerObj:Get() return colorPickerObj.value end

                function colorPickerObj:Close()
                    closeColorPicker(true)
                end
                groupObj.Library:RegisterControl(colorPickerConfig.Flag, function()
                    return colorPickerObj:Get()
                end, function(value)
                    if typeof(value) == "Color3" then
                        colorPickerObj:Set(value, true)
                    end
                end)

                groupObj.element_y = groupObj.element_y + 31 * scale_factor
                update_group_size()
                table.insert(groupObj.elements, colorPickerObj)
                return colorPickerObj
            end
            
            table.insert(tabObj.groups, groupObj)
            update_group_size()
            return groupObj
        end
        
        table.insert(sectionObj.tabs, tabObj)
        table.insert(sectionObj.Library.all_tabs, tabObj)
        
        if #sectionObj.Library.all_tabs == 1 then tabObj:Activate() end
        
        task.defer(function()
            local tabsHeight = sectionObj.tab_layout.AbsoluteContentSize.Y
            sectionObj.tab_holder.Size = UDim2.new(0, 148 * scale_factor, 0, tabsHeight)
            sectionObj.container.Size = UDim2.new(0, 160 * scale_factor, 0, 34 * scale_factor + tabsHeight + 10)
        end)
        
        if sectionObj.Library._searchQuery ~= "" then
            sectionObj.Library:SetSearchFilter(sectionObj.Library._searchQuery)
        end
        
        return tabObj
    end
    
    table.insert(self.sections, sectionObj)
    return sectionObj
end

function atom_ui:SetAccentColor(color)
    if typeof(color) ~= "Color3" then
        return
    end
    self.config.AccentColor = color
    for _, section in ipairs(self.sections) do
        for _, tab in ipairs(section.tabs or {}) do
            if tab.isActive and tab.button_frame then
                tab.button_frame.BackgroundColor3 = color
            end
            for _, group in ipairs(tab.groups or {}) do
                for _, element in ipairs(group.elements or {}) do
                    if type(element) == "table" then
                        if element.switchFrame and element.value == true then
                            element.switchFrame.BackgroundColor3 = color
                        end
                        if element.fillFrame then
                            element.fillFrame.BackgroundColor3 = color
                        end
                        if element.knobCore then
                            element.knobCore.BackgroundColor3 = color
                        end
                        if element.knobGlow then
                            element.knobGlow.BackgroundColor3 = color
                        end
                        if element.knobStroke then
                            element.knobStroke.Color = color:Lerp(Color3.fromRGB(26, 26, 28), 0.2)
                        end
                        if element.toggleSwitchFrame and element.toggleValue == true then
                            element.toggleSwitchFrame.BackgroundColor3 = color
                        end
                    end
                end
            end
        end
    end
    self:_RefreshAccentCore()
    if self.settings_toggle_refs then
        for _, toggleRef in ipairs(self.settings_toggle_refs) do
            if toggleRef and type(toggleRef.Get) == "function" and type(toggleRef.Set) == "function" then
                toggleRef:Set(toggleRef:Get(), true)
            end
        end
    end
    self:_UpdateESPPreview(0)
end

function atom_ui:Destroy()
    if self._destroyed then return end

    pcall(function()
        self:_TryAutoSaveConfig(true)
    end)

    self._destroyed = true

    for _, section in ipairs(self.sections) do
        for _, tab in ipairs(section.tabs or {}) do
            for _, group in ipairs(tab.groups or {}) do
                for _, element in ipairs(group.elements or {}) do
                    if type(element) == "table" and type(element.Close) == "function" then
                        pcall(function()
                            element:Close()
                        end)
                    end
                end
            end
        end
    end

    if self.active_tab and type(self.active_tab.Deactivate) == "function" then
        pcall(function()
            self.active_tab:Deactivate()
        end)
        self.active_tab = nil
    end

    for i = #self._connections, 1, -1 do
        disconnect_signal(self._connections[i])
        self._connections[i] = nil
    end

    self._smoothScrollFrames = {}
    self._refreshJobs = {}
    self._trackedControls = {}
    self:_ClearSnowflakes()
    self:_DestroyESPPreviewCharacter()
    self._fpsRollingWindow = table.create and table.create(self._fpsRollingSize or 60, 0) or {}
    self._fpsRollingTotal = 0
    self._fpsRollingIndex = 1
    self._fpsRollingCount = 0
    self._latestFPSValue = 0
    self._cachedViewportSize = Vector2.new(1280, 720)
    self._cachedViewportWidth = 1280
    self._cachedViewportHeight = 720
    self._cachedViewportAreaScale = 1
    self._espPreviewState = nil
    self._espPreviewProvider = nil
    self._espPreviewData = nil
    self._espPreviewWalkTrack = nil
    self._espPreviewAnimationId = nil
    self._espPreviewAvatar3DUserId = nil
    self._espPreviewAvatar3DImageUrl = nil
    self._espPreviewRotationYaw = nil
    self._espPreviewRotationTargetYaw = nil
    self._espPreviewAllowManualRotation = nil
    self._espPreviewPivotYOffset = nil
    self._espPreviewRotateCapture = nil
    self._espPreviewIsRotating = false
    self._espPreviewRotateInput = nil
    self._espPreviewRotateLastX = nil
    self._textGradientAnimationTime = nil
    self._gradientAnimationAccumulator = 0
    self._backgroundFxAccumulator = 0
    self._overlayUpdateAccumulator = 0
    self._watermarkUpdateAccumulator = 0
    self._watermarkLastWidth = 0
    self._snowSpawnAccumulator = 0
    self._gradientObjects = {}
    self._espPreviewProjectionCache = nil
    self._espPreviewProjectionDirty = true

    if self._blurEffectRef and self._blurEffectRef.Parent then
        self._blurEffectRef:Destroy()
    end
    self._blurEffectRef = nil

    if self._espPreviewPanel and self._espPreviewPanel.Parent then
        self._espPreviewPanel:Destroy()
    end
    self._espPreviewPanel = nil
    self._espPreviewViewport = nil
    self._espPreviewWorldModel = nil
    self._espPreviewCamera = nil
    self._espPreviewHighlight = nil
    self._espPreviewHeaderTag = nil
    self._espPreviewBox = nil
    self._espPreviewBoxStroke = nil
    self._espPreviewHealthTrack = nil
    self._espPreviewHealthFill = nil
    self._espPreviewDot = nil
    self._espPreviewTracer = nil
    self._espPreviewName = nil
    self._espPreviewItem = nil
    self._espPreviewDistance = nil
    self._espPreviewRotateCapture = nil

    if self.screen_gui and self.screen_gui.Parent then
        self.screen_gui:Destroy()
    end

    local sharedEnv = get_shared_env()
    if rawget(sharedEnv, RUNTIME_INSTANCE_KEY) == self then
        rawset(sharedEnv, RUNTIME_INSTANCE_KEY, nil)
    end
end

function atom_ui.Demo()
    local lib = atom_ui.new({
        Name = "AtomUI Demo",
        AccentColor = Color3.fromRGB(2, 133, 255),
        AutoConfig = false
    })

    local main_section = lib:AddSection({Name = "Main", Icon = "sword"})

    local combat_tab = main_section:AddTab({
        Name = "Combat",
        Description = "Combat settings",
        Icon = "crosshair"
    })

    local aimbot_group = combat_tab:AddGroup({Name = "Aimbot", Side = "Left", Icon = "target"})

    aimbot_group:AddToggle({
        Name = "Enabled",
        Default = false,
        Callback = function(val) print("[Demo] Aimbot:", val) end
    })

    aimbot_group:AddSlider({
        Name = "FOV",
        Min = 10,
        Max = 800,
        Default = 120,
        Increment = 5,
        Callback = function(val) print("[Demo] FOV:", val) end
    })

    aimbot_group:AddDropdown({
        Name = "Target Part",
        Options = {"Head", "HumanoidRootPart", "Torso"},
        Default = "Head",
        Callback = function(val) print("[Demo] Part:", val) end
    })

    aimbot_group:AddKeybindToggle({
        Name = "Toggle Key",
        Default = Enum.KeyCode.E,
        ToggleDefault = false,
        Callback = function(val) print("[Demo] Keybind toggle:", val) end
    })

    local visuals_group = combat_tab:AddGroup({Name = "Visuals", Side = "Right", Icon = "eye"})

    visuals_group:AddToggle({
        Name = "Show FOV Circle",
        Default = true,
        Callback = function(val) print("[Demo] FOV Circle:", val) end
    })

    visuals_group:AddColorPicker({
        Name = "FOV Color",
        Default = Color3.fromRGB(255, 0, 0),
        Callback = function(val) print("[Demo] Color:", val) end
    })

    visuals_group:AddLabel({Name = "Visuals are client-side only."})

    local util_tab = main_section:AddTab({
        Name = "Utility",
        Description = "Utility features",
        Icon = "wrench"
    })

    local movement_group = util_tab:AddGroup({Name = "Movement", Side = "Left", Icon = "move"})

    movement_group:AddToggle({
        Name = "Speed Hack",
        Default = false,
        Callback = function(val) print("[Demo] Speed:", val) end
    })

    movement_group:AddSlider({
        Name = "Walk Speed",
        Min = 16,
        Max = 200,
        Default = 16,
        Increment = 1,
        Callback = function(val) print("[Demo] WalkSpeed:", val) end
    })

    movement_group:AddSlider({
        Name = "Jump Power",
        Min = 50,
        Max = 500,
        Default = 50,
        Increment = 5,
        Callback = function(val) print("[Demo] JumpPower:", val) end
    })

    movement_group:AddKeybind({
        Name = "Fly Key",
        Default = Enum.KeyCode.F,
        Callback = function() print("[Demo] Fly pressed") end
    })

    local misc_group = util_tab:AddGroup({Name = "Misc", Side = "Right", Icon = "box"})

    misc_group:AddButton({
        Name = "Rejoin Server",
        Callback = function() print("[Demo] Rejoin clicked") end
    })

    misc_group:AddButton({
        Name = "Copy Game Link",
        Callback = function() print("[Demo] Copy link clicked") end
    })

    misc_group:AddTextInput({
        Name = "Webhook URL",
        Default = "",
        PlaceholderText = "https://...",
        Callback = function(val) print("[Demo] Webhook:", val) end
    })

    misc_group:AddDropdown({
        Name = "Theme",
        Options = {"Dark", "Midnight", "Ocean", "Sunset"},
        Default = "Dark",
        Callback = function(val) print("[Demo] Theme:", val) end
    })

    misc_group:AddMultiDropdown({
        Name = "Notifications",
        Options = {"Kills", "Deaths", "Chat", "Joins", "Teleports"},
        Default = {"Kills", "Chat"},
        Callback = function(val) print("[Demo] Notifs:", val) end
    })

    misc_group:AddDivider()

    misc_group:AddNumberInput({
        Name = "Max Players",
        Default = 10,
        Min = 1,
        Max = 100,
        Step = 1,
        Callback = function(val) print("[Demo] MaxPlayers:", val) end
    })

    misc_group:AddProgressBar({
        Name = "Download Progress",
        Value = 0.72,
        ShowPercent = true,
    })

    misc_group:AddBadge({
        Name = "Script Status",
        Value = "Active",
        Color = "green"
    })

    misc_group:AddLabel({Name = "v1.0.0 - AtomUI Demo"})

    local settings_section = lib:AddSection({Name = "Config", Icon = "settings"})

    local cfg_tab = settings_section:AddTab({
        Name = "Settings",
        Description = "Configuration",
        Icon = "save"
    })

    local cfg_group = cfg_tab:AddGroup({Name = "Config", Side = "Left", Icon = "hard-drive"})

    cfg_group:AddButton({
        Name = "Save Config",
        Callback = function()
            pcall(function() lib:SaveConfig("demo_config") end)
            lib:Notify({Title = "Config", Description = "Saved!", Duration = 3})
        end
    })

    cfg_group:AddButton({
        Name = "Load Config",
        Callback = function()
            pcall(function() lib:LoadConfig("demo_config") end)
            lib:Notify({Title = "Config", Description = "Loaded!", Duration = 3})
        end
    })

    local info_group = cfg_tab:AddGroup({Name = "Info", Side = "Right", Icon = "info"})
    info_group:AddLabel({Name = "Game: " .. tostring(game.PlaceId)})
    info_group:AddLabel({Name = "Player: " .. tostring(local_player.Name)})

    lib:Notify({
        Title = "AtomUI Demo",
        Description = "UI loaded. Press RightCtrl to toggle.",
        Duration = 5
    })

    return lib
end

local function safe_wrap(fn, context)
    return function(...)
        local ok, result = pcall(fn, ...)
        if not ok then
            warn("[AtomUI] " .. tostring(context) .. " error: " .. tostring(result))
            return nil
        end
        return result
    end
end


--#endregion═════════════════════════════════════════════════════════════════════

return atom_ui