--!strict
--[[
    Vokthos NXx Hub - Iris Edition (Bundled)
    Single-file bundle - self-contained, no readfile dependencies
    Generated by bundle.py
--]]

-- ============================================================================
-- CORE (src/init.lua)
-- ============================================================================
local Vokthos = (function()
    --!strict
    --[[
    	Vokthos NXx Hub - Iris Edition
    	Modern immediate-mode UI using SirMallard/Iris (Dear ImGui for Roblox)

    	Migration from Rayfield to Iris - Full rewrite with:
    	- 7-tab architecture (Movement, Combat, Visuals, Player, World, Tools, Settings)
    	- 12 unified modules (down from 55)
    	- Persistent state with JSON config
    	- Notification system (typed, auto-dismiss)
    	- Command system (Infinite Yield style)
    	- Plugin architecture (Nameless Admin style)
    ]]

    -- ============================================================================
    -- SERVICES
    -- ============================================================================
    local ReplicatedStorage = game:GetService("ReplicatedStorage")
    local RunService = game:GetService("RunService")
    local Players = game:GetService("Players")
    local UserInputService = game:GetService("UserInputService")
    local TweenService = game:GetService("TweenService")
    local HttpService = game:GetService("HttpService")
    local CoreGui = game:GetService("CoreGui")

    local LocalPlayer = Players.LocalPlayer

    -- Seed RNG deterministically per session (fixes predictable randomString)
    -- Use tick() instead of os.time() — many executors don't support os library
    math.randomseed(tick())

    -- ============================================================================
    -- IRIS LOADER (pinned to specific commit for security)
    -- ============================================================================
    local Iris
    do
    	-- Pinned commit hash from SirMallard/Iris for reproducible builds
    	local IRIS_COMMIT = "801973f1c3e0df5e788f26a824fa64a2a42e4054"
    	local urls = {
    		"https://raw.githubusercontent.com/SirMallard/Iris/" .. IRIS_COMMIT .. "/lib/init.lua",
    	}
    	for _, url in ipairs(urls) do
    		local ok, result = pcall(function()
    			return loadstring(game:HttpGet(url, true))()
    		end)
    		if ok and result then
    			Iris = result
    			break
    		end
    	end
    	if not Iris then
    	    warn("[Vokthos] Failed to load Iris. Check executor HTTP support.")
    	    Iris = nil -- Will be nil; UI falls back gracefully
    	end
    end

    -- ============================================================================
    -- CONNECTION MANAGER (prevents leaks)
    -- ============================================================================
    local ConnectionManager = {}
    ConnectionManager._connections = {}
    ConnectionManager._tasks = {}

    function ConnectionManager.Connect(signal: RBXScriptSignal, callback: () -> ()): RBXScriptConnection
    	local conn = signal:Connect(callback)
    	ConnectionManager._connections[conn] = {signal = signal, conn = conn}
    	return conn
    end

    function ConnectionManager.Spawn(callback: () -> ()): thread?
    	local thread
    	if task and task.spawn then
    		thread = task.spawn(callback)
    	elseif typeof(spawn) == "function" then
    		thread = spawn(callback)
    	else
    		thread = coroutine.create(callback)
    		coroutine.resume(thread)
    	end
    	ConnectionManager._tasks[thread or true] = true
    	return thread
    end

    function ConnectionManager.RunServiceConnect(event: EnumItem, callback: () -> ()): RBXScriptConnection
    	local conn = RunService[event]:Connect(callback)
    	ConnectionManager._connections[conn] = {signal = RunService[event], conn = conn}
    	return conn
    end

    function ConnectionManager.Cleanup()
    	for _, entry in pairs(ConnectionManager._connections) do
    		if entry.conn.Connected then
    			entry.conn:Disconnect()
    		end
    	end
    	ConnectionManager._connections = {}
    	-- Tasks will finish naturally, no force-kill in Lua
    end

    -- ============================================================================
    -- CORE UTILITIES
    -- ============================================================================
    local Utils = {}

    function Utils.randomString(length: number?): string
    	length = length or 16
    	local chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
    	local result = {}
    	for i = 1, length do
    		local idx = math.random(1, #chars)
    		result[i] = chars:sub(idx, idx)
    	end
    	return table.concat(result)
    end

    function Utils.isMobile(): boolean
    	local success, result = pcall(function()
    		return UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled
    	end)
    	return success and result or false
    end

    function Utils.formatTime(fmt: string?): string
    	-- Safe replacement for os.date() — many executors don't support os library
    	-- Falls back to tick() timestamp if os.date is unavailable
    	if fmt then
    		local ok, result = pcall(os.date, fmt)
    		if ok then return result end
    	end
    	-- Fallback: return raw tick value as string
    	return string.format("%d", math.floor(tick()))
    end

    function Utils.getChar()
    	return LocalPlayer and LocalPlayer.Character
    end

    function Utils.getRoot(char: Model?): BasePart?
    	return char and char:FindFirstChild("HumanoidRootPart")
    end

    function Utils.getHumanoid(char: Model?): Humanoid?
    	return char and char:FindFirstChildOfClass("Humanoid")
    end

    function Utils.getHead(char: Model?): BasePart?
    	return char and char:FindFirstChild("Head")
    end

    function Utils.breakVelocity(hrp: BasePart?)
    	if hrp then
    		hrp.AssemblyLinearVelocity = Vector3.zero
    		hrp.AssemblyAngularVelocity = Vector3.zero
    	end
    end

    -- Infinite Yield style argument parsing
    function Utils.splitString(str: string, delim: string?): {string}
    	delim = delim or ","
    	local result = {}
    	for w in string.gmatch(str, "[^" .. delim .. "]+") do
    		table.insert(result, w)
    	end
    	return result
    end

    function Utils.getString(begin: number, args: {string}?): string
    	args = args or {}
    	return table.concat(args, " ", begin)
    end

    function Utils.parseBoolean(raw: string?, default: boolean?): boolean?
    	raw = tostring(raw):lower()
    	local truthy = {["true"]=true, ["t"]=true, ["1"]=true, ["yes"]=true, ["y"]=true, ["on"]=true, ["enable"]=true, ["enabled"]=true}
    	local falsy = {["false"]=true, ["f"]=true, ["0"]=true, ["no"]=true, ["n"]=true, ["off"]=true, ["disable"]=true, ["disabled"]=true}
    	if truthy[raw] then return true end
    	if falsy[raw] then return false end
    	return default or false
    end

    function Utils.trim(str: string): string
    	return str:match("^%s*(.-)%s*$")
    end

    function Utils.findFirst(child: Instance, name: string): Instance?
    	if not child then return nil end
    	return child:FindFirstChild(name)
    end

    -- ============================================================================
    -- STATE MANAGEMENT (type-safe wrapper)
    -- ============================================================================
    local State = {}
    local StateData: {[string]: any} = {}

    -- State schema for type validation (optional)
    State.Schema = {}

    function State.Get(key: string, default: any?): any?
    	local val = StateData[key]
    	if val == nil then
    		return default
    	end
    	return val
    end

    function State.Set(key: string, value: any?): ()
    	StateData[key] = value
    end

    function State.Toggle(key: string): boolean
    	StateData[key] = not (StateData[key] or false)
    	return StateData[key]
    end

    function State.GetAll(): {[string]: any}
    	local copy = {}
    	for k, v in pairs(StateData) do
    		copy[k] = v
    	end
    	return copy
    end

    function State.LoadFromTable(tbl: {[string]: any}): ()
    	for k, v in pairs(tbl) do
    		StateData[k] = v
    	end
    end

    -- ============================================================================
    -- CONFIG SYSTEM (JSON persistent)
    -- ============================================================================
    local Config = {}
    Config.FolderName = "VokthosIris"
    Config.FileName = "config.json"

    function Config.GetPath(): string
    	return Config.FolderName .. "/" .. Config.FileName
    end

    function Config.EnsureFolder(): ()
    	if not isfolder(Config.FolderName) then
    		makefolder(Config.FolderName)
    	end
    end

    function Config.Save(): ()
    	Config.EnsureFolder()
    	local data = {
    		version = 3,
    		metadata = {
    			name = "default",
    			created = Utils.formatTime("!%Y-%m-%dT%H:%M:%SZ"),
    			description = "Vokthos Iris Config v3",
    		},
    		modules = State.GetAll(),
    		ui = {
    			theme = State.Get("ui_theme", 0),
    			notifications = State.Get("ui_notifications", true),
    			notificationDuration = State.Get("ui_notificationDuration", 3),
    		},
    	}
    	local json = HttpService:JSONEncode(data)
    	writefile(Config.GetPath(), json)
    end

    function Config.Load(): boolean
    	if not isfile(Config.GetPath()) then return false end
    	local ok, data = pcall(function()
    		return HttpService:JSONDecode(readfile(Config.GetPath()))
    	end)
    	if ok and data and data.modules then
    		State.LoadFromTable(data.modules)
    		if data.ui then
    			State.Set("ui_theme", data.ui.theme or 0)
    			State.Set("ui_notifications", data.ui.notifications ~= false)
    			State.Set("ui_notificationDuration", data.ui.notificationDuration or 3)
    		end
    		return true
    	end
    	return false
    end

    function Config.List(): {string}
    	Config.EnsureFolder()
    	local files = listfiles(Config.FolderName)
    	local configs = {}
    	for _, file in ipairs(files) do
    		if file:match("%.json$") then
    			table.insert(configs, file:match("([^/\\]+)%.json$"))
    		end
    	end
    	return configs
    end

    function Config.LoadPreset(name: string): boolean
    	local path = Config.FolderName .. "/" .. name .. ".json"
    	if isfile(path) then
    		local ok, data = pcall(function()
    			return HttpService:JSONDecode(readfile(path))
    		end)
    		if ok and data and data.modules then
    			State.LoadFromTable(data.modules)
    			return true
    		end
    	end
    	return false
    end

    function Config.SavePreset(name: string): ()
    	Config.EnsureFolder()
    	local data = {
    		version = 3,
    		metadata = {
    			name = name,
    			created = Utils.formatTime("!%Y-%m-%dT%H:%M:%SZ"),
    			description = "User preset",
    		},
    		modules = State.GetAll(),
    		ui = {
    			theme = State.Get("ui_theme", 0),
    			notifications = State.Get("ui_notifications", true),
    			notificationDuration = State.Get("ui_notificationDuration", 3),
    		},
    	}
    	writefile(Config.FolderName .. "/" .. name .. ".json", HttpService:JSONEncode(data))
    end

    function Config.DeletePreset(name: string): boolean
    	if name == "default" or name == "config" then return false end
    	local path = Config.FolderName .. "/" .. name .. ".json"
    	if isfile(path) then
    		delfile(path)
    		return true
    	end
    	return false
    end

    -- ============================================================================
    -- NOTIFICATION SYSTEM (typed, auto-dismiss, non-leaking)
    -- ============================================================================
    local NotificationManager = {}
    NotificationManager.Notifications = {}
    NotificationManager.Enabled = true
    NotificationManager.DefaultDuration = 3
    NotificationManager.MaxVisible = 5

    export type NotificationType = "Info" | "Success" | "Warning" | "Error" | "Debug"

    local TypeColors = {
    	Info = Color3.fromRGB(100, 150, 255),
    	Success = Color3.fromRGB(80, 255, 120),
    	Warning = Color3.fromRGB(255, 200, 50),
    	Error = Color3.fromRGB(255, 80, 80),
    	DEBUG = Color3.fromRGB(150, 150, 150),
    }

    function NotificationManager.Push(type: string, title: string, message: string, duration: number?, persistent: boolean?, actionLabel: string?, actionCallback: () -> ()): string
    	if not NotificationManager.Enabled then return "" end

    	local notif = {
    		id = Utils.randomString(8),
    		type = type or "Info",
    		title = title or "Notification",
    		message = message or "",
    		timestamp = tick(),
    		duration = duration or NotificationManager.DefaultDuration,
    		persistent = persistent or false,
    		actionLabel = actionLabel,
    		actionCallback = actionCallback,
    	}

    	table.insert(NotificationManager.Notifications, 1, notif)

    	-- Trim: only keep MaxVisible + small buffer
    	while #NotificationManager.Notifications > NotificationManager.MaxVisible + 3 do
    		table.remove(NotificationManager.Notifications)
    	end

    	return notif.id
    end

    function NotificationManager.Info(title, msg, dur) return NotificationManager.Push("Info", title, msg, dur) end
    function NotificationManager.Success(title, msg, dur) return NotificationManager.Push("Success", title, msg, dur) end
    function NotificationManager.Warning(title, msg, dur) return NotificationManager.Push("Warning", title, msg, dur) end
    function NotificationManager.Error(title, msg, dur) return NotificationManager.Push("Error", title, msg, dur) end
    function NotificationManager.Debug(title, msg, dur) return NotificationManager.Push("Debug", title, msg, dur) end

    function NotificationManager.Dismiss(id: string): ()
    	for i, n in ipairs(NotificationManager.Notifications) do
    		if n.id == id then
    			table.remove(NotificationManager.Notifications, i)
    			break
    		end
    	end
    end

    function NotificationManager.Clear(): ()
    	NotificationManager.Notifications = {}
    end

    -- ============================================================================
    -- COMMAND SYSTEM (Infinite Yield style)
    -- ============================================================================
    local CommandSystem = {}
    CommandSystem.Commands = {}
    CommandSystem.Aliases = {}
    CommandSystem.History = {}
    CommandSystem.HistoryIndex = 0
    CommandSystem.Prefix = ";"

    function CommandSystem.Register(name: string, aliases: {string}?, callback: (args: {string}) -> (), info: string?): ()
    	local cmd = {
    		name = name:lower(),
    		aliases = aliases or {},
    		callback = callback,
    		info = info or "",
    	}
    	CommandSystem.Commands[name:lower()] = cmd
    	for _, alias in ipairs(cmd.aliases) do
    		CommandSystem.Aliases[alias:lower()] = name:lower()
    	end
    end

    function CommandSystem.Execute(cmdString: string): ()
    	if not cmdString or cmdString == "" then return end

    	local parts = Utils.splitString(cmdString, "\\")

    	for _, part in ipairs(parts) do
    		part = Utils.trim(part)
    		if part == "" then continue end

    		local repeatCount = 1
    		local delay = 0
    		local isInfinite = false

    		local prefix, rest = part:match("^(%d+)%^(%d*)%^(.*)$")
    		if prefix then
    			repeatCount = tonumber(prefix) or 1
    			delay = tonumber(rest) or 0
    			part = rest
    		else
    			local infPrefix, infDelay, infRest = part:match("^inf%^(%d*)%^(.*)$")
    			if infPrefix then
    				isInfinite = true
    				delay = tonumber(infDelay) or 1
    				part = infRest
    			end
    		end

    		-- Handle history recall: !alias
    		if part:sub(1, 1) == "!" then
    			local histAlias = part:sub(2)
    			for i = #CommandSystem.History, 1, -1 do
    				if CommandSystem.History[i]:lower():find(histAlias, 1, true) == 1 then
    					part = CommandSystem.History[i]
    					break
    				end
    			end
    		end

    		local args = Utils.splitString(part, " ")
    		local cmdName = args[1] and args[1]:lower()
    		table.remove(args, 1)

    		local resolved = CommandSystem.Aliases[cmdName] or cmdName
    		local cmd = CommandSystem.Commands[resolved]

    		if cmd then
    			table.insert(CommandSystem.History, 1, cmdString)
    			if #CommandSystem.History > 30 then table.remove(CommandSystem.History) end
    			CommandSystem.HistoryIndex = 0

    			ConnectionManager.Spawn(function()
    				local count = 0
    				while isInfinite or count < repeatCount do
    					if not State.Get("command_running", true) then break end
    					pcall(cmd.callback, args)
    					count = count + 1
    					if isInfinite or count < repeatCount then
    						if task and task.wait then task.wait(delay) else wait(delay) end
    					end
    				end
    			end)
    		else
    			NotificationManager.Error("Command", "Unknown command: " .. (cmdName or ""))
    		end
    	end
    end

    function CommandSystem.GetSuggestions(input: string): {string}
    	input = input:lower()
    	local suggestions = {}
    	for name, cmd in pairs(CommandSystem.Commands) do
    		if name:find(input, 1, true) == 1 then
    			table.insert(suggestions, name)
    		end
    		for _, alias in ipairs(cmd.aliases) do
    			if alias:find(input, 1, true) == 1 then
    				table.insert(suggestions, alias)
    			end
    		end
    	end
    	table.sort(suggestions)
    	return suggestions
    end

    function CommandSystem.SetPrefix(prefix: string): ()
    	CommandSystem.Prefix = prefix
    end

    -- ============================================================================
    -- PLUGIN SYSTEM (Nameless Admin style builder pattern)
    -- ============================================================================
    local PluginManager = {}
    PluginManager.Plugins = {}

    local Plugin = {}
    Plugin.__index = Plugin

    function Plugin.new(name: string): Plugin
    	local self = setmetatable({}, Plugin)
    	self.name = name
    	self.commands = {}
    	self.loaded = false
    	return self
    end

    function Plugin:cmd(name: string, ...: string): PluginCommandBuilder
    	local aliases = {...}
    	local cmd = {
    		name = name,
    		aliases = aliases,
    		args = "",
    		info = "",
    		requiresArgs = false,
    		callback = function() end,
    	}

    	local builder = {}

    	function builder:args(argString: string): PluginCommandBuilder
    		cmd.args = argString
    		return builder
    	end

    	function builder:info(infoString: string): PluginCommandBuilder
    		cmd.info = infoString
    		return builder
    	end

    	function builder:requiresArgs(req: boolean?): PluginCommandBuilder
    		cmd.requiresArgs = req ~= false
    		return builder
    	end

    	function builder:userButton(opts: {Label: string, SaveArgs: boolean}?): PluginCommandBuilder
    		cmd.userButton = opts
    		return builder
    	end

    	function builder:run(callback: (ctx: PluginContext, ...: any) -> ()): PluginCommandBuilder
    		cmd.callback = callback
    		CommandSystem.Register(name, aliases, function(args)
    			local ctx = {
    				Name = self.name,
    				notify = function(text: string, kind: string?, dur: number?)
    					NotificationManager.Push(kind or "Info", self.name, text, dur)
    				end,
    				run = function(cmdName: string, ...)
    					local args = {...}
    					CommandSystem.Execute(cmdName .. " " .. table.concat(args, " "))
    				end,
    				getPlayer = function(name: string): Model?
    					for _, p in ipairs(Players:GetPlayers()) do
    						if p.Name:lower():find(name:lower(), 1, true) == 1 then
    							return p.Character
    						end
    					end
    					return nil
    				end,
    				getChar = Utils.getChar,
    				getRoot = Utils.getRoot,
    				getHumanoid = Utils.getHumanoid,
    				Services = setmetatable({}, {
    					__index = function(_, k)
    						return game:GetService(k)
    					end
    				}),
    				isMobile = Utils.isMobile,
    			}
    			callback(ctx, table.unpack(args))
    		end, cmd.info)
    		table.insert(self.commands, cmd)
    		return builder
    	end

    	return builder
    end

    function Plugin:load(): ()
    	self.loaded = true
    	PluginManager.Plugins[self.name] = self
    end

    function PluginManager.LoadPlugin(name: string): ()
    	-- Placeholder for future .lua plugin file loading
    end

    -- ============================================================================
    -- MODULE REGISTRY
    -- ============================================================================
    local ModuleRegistry = {}
    ModuleRegistry.Modules = {}
    ModuleRegistry.Categories = {}

    type Module = {
    	name: string,
    	category: string,
    	id: string,
    	enabled: boolean,
    	connections: {RBXScriptConnection},
    	draw: (self: Module) -> (),
    	onEnable: (self: Module) -> (),
    	onDisable: (self: Module) -> (),
    }

    function ModuleRegistry.Register(category: string, module: Module): Module
    	if not ModuleRegistry.Categories[category] then
    		ModuleRegistry.Categories[category] = {}
    	end
    	module.category = category
    	module.id = category .. "." .. module.name:lower():gsub("%s+", "_")
    	module.connections = module.connections or {}
    	module.enabled = false
    	table.insert(ModuleRegistry.Categories[category], module)
    	ModuleRegistry.Modules[module.id] = module
    	return module
    end

    function ModuleRegistry.GetAll(): {[string]: Module}
    	return ModuleRegistry.Modules
    end

    function ModuleRegistry.GetByCategory(category: string): {Module}
    	return ModuleRegistry.Categories[category] or {}
    end

    function ModuleRegistry.DisableAll(): ()
    	for id, module in pairs(ModuleRegistry.Modules) do
    		if module.enabled and module.onDisable then
    			module.onDisable(module)
    			module.enabled = false
    		end
    	end
    end

    -- ============================================================================
    -- SharedTicker (single Heartbeat, replaces 25+ per-module connections)
    -- ============================================================================
    local SharedTicker = {
    	_subscribers = {},
    	_cache = {},
    }

    function SharedTicker.Subscribe(fn: (cache: {char: Model?, hrp: BasePart?, hum: Humanoid?}) -> ())
    	table.insert(SharedTicker._subscribers, fn)
    end

    function SharedTicker.Unsubscribe(fn: (cache: {char: Model?, hrp: BasePart?, hum: Humanoid?}) -> ())
    	for i, sub in ipairs(SharedTicker._subscribers) do
    		if sub == fn then
    			table.remove(SharedTicker._subscribers, i)
    			return true
    		end
    	end
    	return false
    end

    -- One Heartbeat connection for all subscribers
    RunService.Heartbeat:Connect(function()
    	local char = Utils.getChar()
    	SharedTicker._cache = {
    		char = char,
    		hrp = Utils.getRoot(char),
    		hum = Utils.getHumanoid(char),
    	}
    	for _, fn in ipairs(SharedTicker._subscribers) do
    		local ok, err = pcall(fn, SharedTicker._cache)
    		if not ok then
    			warn("[Vokthos] SharedTicker error:", err)
    		end
    	end
    end)

    -- ============================================================================
    -- MAIN CORE EXPORT (no global pollution)
    -- ============================================================================
    local Vokthos = {
    	Utils = Utils,
    	State = State,
    	Config = Config,
    	Notifications = NotificationManager,
    	Commands = CommandSystem,
    	Plugins = PluginManager,
    	Modules = ModuleRegistry,
    	Iris = Iris,
    	Connections = ConnectionManager,
    	SharedTicker = SharedTicker,
    }

    -- Auto-save timer (every 30 seconds)
    if RunService:IsStudio() or true then
    	ConnectionManager.Spawn(function()
    		while true do
    			if task and task.wait then task.wait(30) else wait(30) end
    			if State.Get("ui_auto_save", true) then
    				Config.Save()
    			end
    		end
    	end)
    end

    return Vokthos
end)()

-- ============================================================================
-- UI (src/ui/main.lua)
-- ============================================================================
local UI = (function()
    local Core = Vokthos
    local Utils = Core.Utils
    local State = Core.State
    local Iris = Core.Iris
    local Notifications = Core.Notifications
    local Connections = Core.Connections
    local SharedTicker = Core.SharedTicker
    local ModuleRegistry = Core.Modules
    local Commands = Core.Commands
    local Config = Core.Config
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local HttpService = game:GetService("HttpService")
    local LocalPlayer = Players.LocalPlayer

    --[[
    	UI Module - Iris 7-tab interface
    	Tabs: Movement, Combat, Visuals, Player, World, Tools, Settings
    	Fixes: No Core references, Initialize returns cleanup function.
    ]]

    local UI = {}

    UI.WindowOpen = true
    UI.ActiveTab = 1

    local Tabs = {
    	{id = "movement", name = "Movement", icon = "🏃"},
    	{id = "combat", name = "Combat", icon = "⚔️"},
    	{id = "visuals", name = "Visuals", icon = "👁️"},
    	{id = "player", name = "Player", icon = "👤"},
    	{id = "world", name = "World", icon = "🌍"},
    	{id = "tools", name = "Tools", icon = "🔧"},
    	{id = "settings", name = "Settings", icon = "⚙️"},
    }

    function UI.Render(Core)
    	local Iris = Core.Iris
    	local State = Core.State
    	local Config = Core.Config
    	local Notifications = Core.Notifications
    	local ModuleRegistry = Core.Modules

    	if not Iris then return end
    	if not UI.WindowOpen then return end

    	Iris.Window({"Vokthos NXx Hub", true}, {size = Iris.State(Vector2.new(650, 520))}, function()
    		-- Menu Bar
    		if Iris.MenuBar() then
    			if Iris.Menu({"File"}) then
    				if Iris.MenuItem({"Load Config"}) then
    					UI.ShowConfigPicker("load", Core)
    				end
    				if Iris.MenuItem({"Save Config"}) then
    					Config.Save()
    					Notifications.Success("Config", "Saved successfully")
    				end
    				if Iris.MenuItem({"Export Config"}) then
    					UI.ExportConfig(Core)
    				end
    				if Iris.MenuItem({"Import Config"}) then
    					UI.ImportConfig(Core)
    				end
    				Iris.End()
    			end

    			if Iris.Menu({"View"}) then
    				Iris.MenuItem({"Toggle UI (INSERT)", function() UI.Toggle() end})
    				Iris.MenuItem({"Reset Window Position", function() UI.ResetWindowPos(Core) end})
    				Iris.End()
    			end

    			if Iris.Menu({"Help"}) then
    				Iris.MenuItem({"Commands", function() UI.ShowCommandsHelp(Core) end})
    				Iris.MenuItem({"Discord", function() setclipboard("https://discord.gg/zzjYhtMGFD") Notifications.Info("Discord", "Link copied to clipboard") end})
    				Iris.MenuItem({"About", function() UI.ShowAbout(Core) end})
    				Iris.End()
    			end

    			Iris.End()
    		end

    		-- Tab Bar
    		if Iris.TabBar({"##main_tabs"}) then
    			for i, tab in ipairs(Tabs) do
    				if Iris.Tab({tab.icon .. " " .. tab.name}) then
    					UI.ActiveTab = i
    					UI.RenderTabContent(tab.id, Core)
    					Iris.End()
    				end
    			end
    			Iris.End()
    		end

    		-- Footer status
    		Iris.Separator()
    		Iris.SameLine()
    		Iris.Text({"INSERT to toggle | " .. #ModuleRegistry.GetAll() .. " modules loaded"})
    		Iris.SameLine()
    		Iris.Text({" | Session: " .. Utils.formatTime("%H:%M:%S")})
    	end)

    	-- Render notifications overlay
    	UI.RenderNotifications(Core)
    end

    function UI.RenderTabContent(tabId, Core)
    	local ModuleRegistry = Core.Modules
    	local Iris = Core.Iris

    	local modules = ModuleRegistry.GetByCategory(tabId)
    	if #modules == 0 then
    		Iris.Text({"No modules in this category"})
    		Iris.Text({"Use the ModuleRegistry to register modules"})
    		return
    	end

    	for _, module in ipairs(modules) do
    		if module.draw then
    			if Iris.Tree({module.name}) then
    				module.draw()
    				Iris.End()
    			end
    		end
    	end
    end

    function UI.RenderNotifications(Core)
    	local Notifications = Core.Notifications
    	local Iris = Core.Iris

    	if not Notifications.Enabled or #Notifications.Notifications == 0 then return end

    	local viewport = workspace.CurrentCamera and workspace.CurrentCamera.ViewportSize or Vector2.new(1920, 1080)

    	Iris.Window({"##notifications", false}, {
    		size = Iris.State(Vector2.new(320, 0)),
    		position = Iris.State(Vector2.new(viewport.X - 340, 20)),
    		noTitleBar = true,
    		noMove = true,
    		noResize = true,
    		noFocusOnAppearing = true,
    		alwaysAutoResize = true,
    	}, function()
    		local now = tick()
    		for i = #Notifications.Notifications, 1, -1 do
    			local n = Notifications.Notifications[i]
    			local color = n.type and Notifications.TypeColors[n.type] or Color3.fromRGB(255,255,255)

    			Iris.PushConfig({BorderColor = color})
    			Iris.PushConfig({HeaderColor = Color3.new(color.R * 0.15, color.G * 0.15, color.B * 0.15)})

    			Iris.Tree({n.id}, {spanFullWidth = true}, function()
    				Iris.TextColored({color, n.title})
    				Iris.TextWrapped({n.message})

    				if n.actionLabel and n.actionCallback then
    					if Iris.Button({n.actionLabel}) then
    						pcall(n.actionCallback)
    						Notifications.Dismiss(n.id)
    					end
    				end

    				Iris.SameLine()
    				Iris.SameLine()
    				if Iris.Button({"X", Vector2.new(20, 20)}) then
    					Notifications.Dismiss(n.id)
    				end
    			end)

    			Iris.PopConfig(2)

    			-- Auto-dismiss
    			if not n.persistent and (now - n.timestamp) > n.duration then
    				Notifications.Dismiss(n.id)
    			end
    		end
    	end)
    end

    function UI.ShowConfigPicker(mode, Core)
    	local Config = Core.Config
    	local Notifications = Core.Notifications
    	local Iris = Core.Iris

    	Iris.Window({"Config " .. mode:gsub("^%l", string.upper), true}, {size = Iris.State(Vector2.new(400, 300))}, function()
    		local configs = Config.List()
    		if #configs == 0 then
    			Iris.Text({"No configs found"})
    			if Iris.Button({"Create Default"}) then
    				Config.Save()
    			end
    		else
    			for _, name in ipairs(configs) do
    				if Iris.Selectable({name}, {index = Iris.State(name == "default")}) then
    					if mode == "load" then
    						if name == "default" then Config.Load() else Config.LoadPreset(name) end
    						Notifications.Success("Config", "Loaded: " .. name)
    					elseif mode == "delete" then
    						Config.DeletePreset(name)
    						Notifications.Success("Config", "Deleted: " .. name)
    					end
    				end
    			end
    		end

    		Iris.Separator()
    		if Iris.Button({"Close"}) then end
    	end)
    end

    function UI.ExportConfig(Core)
    	local State = Core.State
    	local Config = Core.Config
    	local Notifications = Core.Notifications

    	local data = {
    		version = 3,
    		metadata = {name = "export", created = Utils.formatTime("!%Y-%m-%dT%H:%M:%SZ")},
    		modules = State.GetAll(),
    	}
    	local json = HttpService:JSONEncode(data)
    	if setclipboard then
    		setclipboard(json)
    		Notifications.Success("Export", "Config copied to clipboard")
    	else
    		Notifications.Warning("Export", "Clipboard not supported")
    	end
    end

    function UI.ImportConfig(Core)
    	local State = Core.State
    	local Config = Core.Config
    	local Notifications = Core.Notifications

    	if not getclipboard then
    		Notifications.Error("Import", "Clipboard not supported")
    		return
    	end
    	local json = getclipboard()
    	local ok, data = pcall(function()
    		return HttpService:JSONDecode(json)
    	end)
    	if ok and data and data.modules then
    		State.LoadFromTable(data.modules)
    		Notifications.Success("Import", "Config imported successfully")
    	else
    		Notifications.Error("Import", "Invalid config data")
    	end
    end

    function UI.ResetWindowPos(Core)
    	local State = Core.State
    	local Notifications = Core.Notifications
    	State.Set("window_pos", Vector2.new(100, 100))
    	Notifications.Info("UI", "Window position reset")
    end

    function UI.ShowCommandsHelp(Core)
    	local Commands = Core.Commands
    	local Iris = Core.Iris

    	Iris.Window({"Commands Help", true}, {size = Iris.State(Vector2.new(500, 400))}, function()
    		Iris.Text({"Command Syntax:"})
    		Iris.Text({"  command [args] - Execute command"})
    		Iris.Text({"  command \\ command - Chain commands"})
    		Iris.Text({"  5^command - Repeat 5 times"})
    		Iris.Text({"  3^2^command - Repeat 3 times with 2s delay"})
    		Iris.Text({"  inf^1^command - Infinite loop (1s delay)"})
    		Iris.Text({"  !alias - Recall from history"})
    		Iris.Separator()

    		Iris.Text({"Available Commands:"})
    		for name, cmd in pairs(Commands.Commands) do
    			local aliases = #cmd.aliases > 0 and " (" .. table.concat(cmd.aliases, ", ") .. ")" or ""
    			Iris.BulletText({name .. aliases .. " - " .. cmd.info})
    		end
    	end)
    end

    function UI.ShowAbout(Core)
    	local Iris = Core.Iris

    	Iris.Window({"About Vokthos NXx Hub", true}, {size = Iris.State(Vector2.new(400, 300))}, function()
    		Iris.Text({"Vokthos NXx Hub - Iris Edition"})
    		Iris.Text({"Version: 2.0.0 (Iris Migration)"})
    		Iris.Text({"UI Framework: SirMallard/Iris (Dear ImGui)"})
    		Iris.Text({"Inspired by: Infinite Yield, Nameless Admin"})
    		Iris.Separator()
    		Iris.Text({"Features:"})
    		Iris.BulletText({"50+ modules across 7 categories"})
    		Iris.BulletText({"Immediate-mode UI (zero bloat)"})
    		Iris.BulletText({"Persistent JSON config system"})
    		Iris.BulletText({"Command system with aliases/history"})
    		Iris.BulletText({"Plugin architecture (Nameless Admin style)"})
    		Iris.BulletText({"Typed notification system"})
    		Iris.Separator()
    		Iris.Text({"Built for Roblox exploit environments"})
    	end)
    end

    function UI.Toggle()
    	UI.WindowOpen = not UI.WindowOpen
    end

    function UI.Initialize(Core)
    	local State = Core.State
    	local Notifications = Core.Notifications
    	local Connections = Core.Connections
    	local UserInputService = game:GetService("UserInputService")

    	-- Setup keybind for toggle (INSERT) - returns connection for cleanup
    	local inputConn = Connections.Connect(UserInputService.InputBegan, function(input, processed)
    		if processed then return end
    		if input.KeyCode == Enum.KeyCode.Insert then
    			UI.Toggle()
    		end
    	end)

    	Notifications.Success("Vokthos", "UI initialized - Press INSERT to toggle")

    	-- Return cleanup function
    	return function()
    		if inputConn then inputConn:Disconnect() end
    	end
    end

    return UI
end)()

-- ============================================================================
-- Movement (src/modules/movement.lua)
-- ============================================================================
local Movement = (function()
    local Core = Vokthos
    local Utils = Core.Utils
    local State = Core.State
    local Iris = Core.Iris
    local Notifications = Core.Notifications
    local Connections = Core.Connections
    local SharedTicker = Core.SharedTicker
    local ModuleRegistry = Core.Modules
    local Commands = Core.Commands
    local Config = Core.Config
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local HttpService = game:GetService("HttpService")
    local LocalPlayer = Players.LocalPlayer

    --[[
    	Movement Modules
    	Fixes: Connection guards, SharedTicker integration, FlyCar bug fix.
    	WalkSpeed is the single source (player.lua WalkSpeed removed as duplicate).
    ]]

    local Movement = {}

    local function safeConn(module, key, signal, callback)
    	if module[key] and module[key].Connected then
    		module[key]:Disconnect()
    	end
    	module[key] = signal:Connect(callback)
    end

    -- ============================================================================
    -- SPEED (WalkSpeed) — single source
    -- ============================================================================
    local Speed = {
    	name = "Speed",
    	category = "movement",
    	enabled = false,
    	speed = 100,
    	_tickFn = nil,
    	_charConn = nil,
    }

    function Speed.onEnable()
    	if Speed._tickFn then return end
    	Speed._tickFn = function(cache)
    		if not State.Get("movement_speed_enabled") then return end
    		local hum = cache.hum
    		if hum and hum.WalkSpeed ~= Speed.speed then
    			hum.WalkSpeed = Speed.speed
    		end
    	end
    	SharedTicker.Subscribe(Speed._tickFn)

    	if Speed._charConn then Speed._charConn:Disconnect() end
    	Speed._charConn = LocalPlayer.CharacterAdded:Connect(function()
    		if task and task.wait then task.wait(0.5) else wait(0.5) end
    		if State.Get("movement_speed_enabled") then
    			local hum = Utils.getHumanoid(Utils.getChar())
    			if hum then hum.WalkSpeed = Speed.speed end
    		end
    	end)
    end

    function Speed.onDisable()
    	if Speed._tickFn then
    		SharedTicker.Unsubscribe(Speed._tickFn)
    		Speed._tickFn = nil
    	end
    	if Speed._charConn then
    		Speed._charConn:Disconnect()
    		Speed._charConn = nil
    	end
    	local hum = Utils.getHumanoid(Utils.getChar())
    	if hum then hum.WalkSpeed = 16 end
    end

    function Speed.draw()
    	State.Set("movement_speed_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_speed_enabled"))}))
    	if State.Get("movement_speed_enabled") then
    		Iris.SliderNum({"Speed", 1, 500, "%.0f"}, {number = Iris.State(State.Get("movement_speed_value"))})
    	end
    end

    Movement.Speed = Speed

    -- ============================================================================
    -- NOCLIP
    -- ============================================================================
    local Noclip = {
    	name = "Noclip",
    	category = "movement",
    	enabled = false,
    	_tickFn = nil,
    	_charConn = nil,
    }

    function Noclip.onEnable()
    	if Noclip._tickFn then return end
    	Noclip._tickFn = function(cache)
    		if not State.Get("movement_noclip_enabled") then return end
    		local char = cache.char
    		if char then
    			for _, part in ipairs(char:GetDescendants()) do
    				if part:IsA("BasePart") then
    					part.CanCollide = false
    				end
    			end
    		end
    	end
    	SharedTicker.Subscribe(Noclip._tickFn)

    	if Noclip._charConn then Noclip._charConn:Disconnect() end
    	Noclip._charConn = LocalPlayer.CharacterAdded:Connect(function()
    		if task and task.wait then task.wait(0.5) else wait(0.5) end
    		if State.Get("movement_noclip_enabled") and Noclip._tickFn then
    			Noclip._tickFn(SharedTicker._cache)
    		end
    	end)
    end

    function Noclip.onDisable()
    	if Noclip._tickFn then
    		SharedTicker.Unsubscribe(Noclip._tickFn)
    		Noclip._tickFn = nil
    	end
    	if Noclip._charConn then
    		Noclip._charConn:Disconnect()
    		Noclip._charConn = nil
    	end
    	local char = Utils.getChar()
    	if char then
    		for _, part in ipairs(char:GetDescendants()) do
    			if part:IsA("BasePart") then part.CanCollide = true end
    		end
    	end
    end

    function Noclip.draw()
    	State.Set("movement_noclip_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_noclip_enabled"))}))
    end

    Movement.Noclip = Noclip

    -- ============================================================================
    -- FLY
    -- ============================================================================
    local Fly = {
    	name = "Fly",
    	category = "movement",
    	enabled = false,
    	speed = 50,
    	keys = {},
    	_inputBeganConn = nil,
    	_inputEndedConn = nil,
    	_renderConn = nil,
    	_bodyGyro = nil,
    	_bodyVelocity = nil,
    }

    function Fly.onEnable()
    	local char = Utils.getChar()
    	if not char then return end
    	local hrp = Utils.getRoot(char)
    	local hum = Utils.getHumanoid(char)
    	if not hrp or not hum then return end

    	if Fly._bodyGyro then Fly._bodyGyro:Destroy() end
    	if Fly._bodyVelocity then Fly._bodyVelocity:Destroy() end

    	Fly._bodyGyro = Instance.new("BodyGyro")
    	Fly._bodyGyro.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)
    	Fly._bodyGyro.P = 10000
    	Fly._bodyGyro.Parent = hrp

    	Fly._bodyVelocity = Instance.new("BodyVelocity")
    	Fly._bodyVelocity.MaxForce = Vector3.new(math.huge, math.huge, math.huge)
    	Fly._bodyVelocity.Parent = hrp

    	if Fly._inputBeganConn then Fly._inputBeganConn:Disconnect() end
    	Fly._inputBeganConn = UserInputService.InputBegan:Connect(function(input, gp)
    		if gp then return end
    		Fly.keys[input.KeyCode] = true
    	end)

    	if Fly._inputEndedConn then Fly._inputEndedConn:Disconnect() end
    	Fly._inputEndedConn = UserInputService.InputEnded:Connect(function(input)
    		Fly.keys[input.KeyCode] = nil
    	end)

    	safeConn(Fly, "_renderConn", RunService.RenderStepped, function()
    		if not State.Get("movement_fly_enabled") then return end
    		local char = Utils.getChar()
    		local hrp = Utils.getRoot(char)
    		local hum = Utils.getHumanoid(char)
    		if not hrp or not hum then return end

    		local cam = workspace.CurrentCamera
    		local moveDir = Vector3.zero

    		if Fly.keys[Enum.KeyCode.W] then moveDir = moveDir + cam.CFrame.LookVector end
    		if Fly.keys[Enum.KeyCode.S] then moveDir = moveDir - cam.CFrame.LookVector end
    		if Fly.keys[Enum.KeyCode.D] then moveDir = moveDir + cam.CFrame.RightVector end
    		if Fly.keys[Enum.KeyCode.A] then moveDir = moveDir - cam.CFrame.RightVector end
    		if Fly.keys[Enum.KeyCode.Space] or Fly.keys[Enum.KeyCode.E] then moveDir = moveDir + Vector3.new(0, 1, 0) end
    		if Fly.keys[Enum.KeyCode.LeftShift] or Fly.keys[Enum.KeyCode.Q] then moveDir = moveDir - Vector3.new(0, 1, 0) end

    		if moveDir.Magnitude > 0 then
    			Fly._bodyVelocity.Velocity = moveDir.Unit * Fly.speed
    			Fly._bodyGyro.CFrame = CFrame.new(hrp.Position, hrp.Position + moveDir)
    		else
    			Fly._bodyVelocity.Velocity = Vector3.zero
    			Fly._bodyGyro.CFrame = cam.CFrame
    		end
    		hum.PlatformStand = true
    	end)
    end

    function Fly.onDisable()
    	if Fly._renderConn then Fly._renderConn:Disconnect() Fly._renderConn = nil end
    	if Fly._inputBeganConn then Fly._inputBeganConn:Disconnect() Fly._inputBeganConn = nil end
    	if Fly._inputEndedConn then Fly._inputEndedConn:Disconnect() Fly._inputEndedConn = nil end
    	Fly.keys = {}
    	if Fly._bodyGyro then Fly._bodyGyro:Destroy() Fly._bodyGyro = nil end
    	if Fly._bodyVelocity then Fly._bodyVelocity:Destroy() Fly._bodyVelocity = nil end
    	local char = Utils.getChar()
    	local hrp = Utils.getRoot(char)
    	local hum = Utils.getHumanoid(char)
    	if hrp then hrp.AssemblyLinearVelocity = Vector3.zero end
    	if hum then hum.PlatformStand = false end
    end

    function Fly.draw()
    	State.Set("movement_fly_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_fly_enabled"))}))
    	if State.Get("movement_fly_enabled") then
    		Iris.SliderNum({"Speed", 1, 200, "%.0f"}, {number = Iris.State(State.Get("movement_fly_speed"))})
    	end
    end

    Movement.Fly = Fly

    -- ============================================================================
    -- CFRAME FLY
    -- ============================================================================
    local CFrameFly = {
    	name = "CFrame Fly",
    	category = "movement",
    	enabled = false,
    	speed = 50,
    	_tickFn = nil,
    }

    function CFrameFly.onEnable()
    	if CFrameFly._tickFn then return end
    	CFrameFly._tickFn = function(cache)
    		if not State.Get("movement_cframefly_enabled") then return end
    		local hrp = cache.hrp
    		local hum = cache.hum
    		if not hrp or not hum then return end

    		local moveDir = hum.MoveDirection
    		if moveDir.Magnitude > 0 then
    			local newPos = hrp.CFrame.Position + (moveDir * CFrameFly.speed * 0.1)
    			hrp.CFrame = CFrame.new(newPos)
    		end
    		hum.PlatformStand = true
    		hum.Sit = false
    	end
    	SharedTicker.Subscribe(CFrameFly._tickFn)
    end

    function CFrameFly.onDisable()
    	if CFrameFly._tickFn then
    		SharedTicker.Unsubscribe(CFrameFly._tickFn)
    		CFrameFly._tickFn = nil
    	end
    	local char = Utils.getChar()
    	local hrp = Utils.getRoot(char)
    	local hum = Utils.getHumanoid(char)
    	if hrp then hrp.Anchored = false end
    	if hum then hum.PlatformStand = false; hum.Sit = false end
    end

    function CFrameFly.draw()
    	State.Set("movement_cframefly_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_cframefly_enabled"))}))
    	if State.Get("movement_cframefly_enabled") then
    		Iris.SliderNum({"Speed", 1, 200, "%.0f"}, {number = Iris.State(State.Get("movement_cframefly_speed"))})
    	end
    end

    Movement.CFrameFly = CFrameFly

    -- ============================================================================
    -- INFINITE JUMP
    -- ============================================================================
    local InfiniteJump = {
    	name = "Infinite Jump",
    	category = "movement",
    	enabled = false,
    	_jumpConn = nil,
    }

    function InfiniteJump.onEnable()
    	if InfiniteJump._jumpConn then InfiniteJump._jumpConn:Disconnect() end
    	InfiniteJump._jumpConn = UserInputService.JumpRequest:Connect(function()
    		if not State.Get("movement_infinitejump_enabled") then return end
    		local hum = Utils.getHumanoid(Utils.getChar())
    		if hum then hum:ChangeState(Enum.HumanoidStateType.Jumping) end
    	end)
    end

    function InfiniteJump.onDisable()
    	if InfiniteJump._jumpConn then
    		InfiniteJump._jumpConn:Disconnect()
    		InfiniteJump._jumpConn = nil
    	end
    end

    function InfiniteJump.draw()
    	State.Set("movement_infinitejump_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_infinitejump_enabled"))}))
    end

    Movement.InfiniteJump = InfiniteJump

    -- ============================================================================
    -- ANTI-AFK
    -- ============================================================================
    local AntiAFK = {
    	name = "Anti-AFK",
    	category = "movement",
    	enabled = false,
    	_idledConn = nil,
    }

    function AntiAFK.onEnable()
    	if AntiAFK._idledConn then AntiAFK._idledConn:Disconnect() end
    	AntiAFK._idledConn = LocalPlayer.Idled:Connect(function()
    		if not State.Get("movement_antiafk_enabled") then return end
    		local vu = game:GetService("VirtualUser")
    		vu:Button2Down(Vector2.zero, workspace.CurrentCamera.CFrame)
    		task.wait(1)
    		vu:Button2Up(Vector2.zero, workspace.CurrentCamera.CFrame)
    	end)
    end

    function AntiAFK.onDisable()
    	if AntiAFK._idledConn then
    		AntiAFK._idledConn:Disconnect()
    		AntiAFK._idledConn = nil
    	end
    end

    function AntiAFK.draw()
    	State.Set("movement_antiafk_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_antiafk_enabled"))}))
    end

    Movement.AntiAFK = AntiAFK

    -- ============================================================================
    -- SPIN
    -- ============================================================================
    local Spin = {
    	name = "Spin",
    	category = "movement",
    	enabled = false,
    	speed = 50,
    	_tickFn = nil,
    	_spin = nil,
    }

    function Spin.onEnable()
    	if Spin._tickFn then return end
    	local char = Utils.getChar()
    	local hrp = Utils.getRoot(char)
    	if hrp then
    		if Spin._spin then Spin._spin:Destroy() end
    		Spin._spin = Instance.new("BodyAngularVelocity")
    		Spin._spin.Name = "Spin_" .. Utils.randomString(8)
    		Spin._spin.MaxTorque = Vector3.new(0, math.huge, 0)
    		Spin._spin.AngularVelocity = Vector3.new(0, Spin.speed, 0)
    		Spin._spin.Parent = hrp
    	end

    	Spin._tickFn = function(cache)
    		if not State.Get("movement_spin_enabled") then return end
    		if Spin._spin and Spin._spin.Parent then
    			Spin._spin.AngularVelocity = Vector3.new(0, Spin.speed, 0)
    		end
    	end
    	SharedTicker.Subscribe(Spin._tickFn)
    end

    function Spin.onDisable()
    	if Spin._tickFn then
    		SharedTicker.Unsubscribe(Spin._tickFn)
    		Spin._tickFn = nil
    	end
    	if Spin._spin then
    		Spin._spin:Destroy()
    		Spin._spin = nil
    	end
    end

    function Spin.draw()
    	State.Set("movement_spin_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_spin_enabled"))}))
    	if State.Get("movement_spin_enabled") then
    		Iris.SliderNum({"Speed", 1, 200, "%.0f"}, {number = Iris.State(State.Get("movement_spin_speed"))})
    	end
    end

    Movement.Spin = Spin

    -- ============================================================================
    -- FLY CAR (fixed: cam.CFrame.FinishVector → cam.CFrame.LookVector)
    -- ============================================================================
    local FlyCar = {
    	name = "Fly Car",
    	category = "movement",
    	enabled = false,
    	speed = 100,
    	keys = {},
    	_inputBeganConn = nil,
    	_inputEndedConn = nil,
    	_renderConn = nil,
    	_bodyGyro = nil,
    }

    function FlyCar.onEnable()
    	local char = Utils.getChar()
    	if not char then return end
    	local hum = Utils.getHumanoid(char)
    	local seat = hum and hum.SitPart
    	if not seat then return end

    	local vehicle = seat.Parent
    	while vehicle and vehicle.Parent ~= workspace do vehicle = vehicle.Parent end
    	if not vehicle then return end

    	local primaryPart = vehicle.PrimaryPart or vehicle:FindFirstChild("VehicleSeat") or vehicle:FindFirstChildWhichIsA("BasePart")
    	if not primaryPart then return end

    	FlyCar.vehicle = vehicle
    	FlyCar.primaryPart = primaryPart

    	if FlyCar._bodyGyro then FlyCar._bodyGyro:Destroy() end
    	FlyCar._bodyGyro = Instance.new("BodyGyro")
    	FlyCar._bodyGyro.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)
    	FlyCar._bodyGyro.P = 10000
    	FlyCar._bodyGyro.Parent = primaryPart

    	if FlyCar._inputBeganConn then FlyCar._inputBeganConn:Disconnect() end
    	FlyCar._inputBeganConn = UserInputService.InputBegan:Connect(function(input, gp)
    		if gp then return end
    		FlyCar.keys[input.KeyCode] = true
    	end)

    	if FlyCar._inputEndedConn then FlyCar._inputEndedConn:Disconnect() end
    	FlyCar._inputEndedConn = UserInputService.InputEnded:Connect(function(input)
    		FlyCar.keys[input.KeyCode] = nil
    	end)

    	safeConn(FlyCar, "_renderConn", RunService.RenderStepped, function()
    		if not State.Get("movement_flycar_enabled") then return end
    		if not FlyCar.primaryPart or not FlyCar.primaryPart.Parent then
    			if FlyCar.onDisable then FlyCar.onDisable() end
    			return
    		end

    		local cam = workspace.CurrentCamera
    		local moveDir = Vector3.zero

    		if FlyCar.keys[Enum.KeyCode.W] then moveDir = moveDir + cam.CFrame.LookVector end
    		if FlyCar.keys[Enum.KeyCode.S] then moveDir = moveDir - cam.CFrame.LookVector end
    		if FlyCar.keys[Enum.KeyCode.D] then moveDir = moveDir + cam.CFrame.RightVector end
    		if FlyCar.keys[Enum.KeyCode.A] then moveDir = moveDir - cam.CFrame.RightVector end
    		if FlyCar.keys[Enum.KeyCode.Space] then moveDir = moveDir + Vector3.new(0, 1, 0) end
    		if FlyCar.keys[Enum.KeyCode.LeftShift] then moveDir = moveDir - Vector3.new(0, 1, 0) end

    		if moveDir.Magnitude > 0 then
    			FlyCar.primaryPart.AssemblyLinearVelocity = moveDir.Unit * FlyCar.speed
    			FlyCar._bodyGyro.CFrame = CFrame.new(FlyCar.primaryPart.Position, FlyCar.primaryPart.Position + moveDir)
    		else
    			FlyCar.primaryPart.AssemblyLinearVelocity = Vector3.zero
    			FlyCar._bodyGyro.CFrame = cam.CFrame
    		end
    	end)
    end

    function FlyCar.onDisable()
    	if FlyCar._renderConn then FlyCar._renderConn:Disconnect() FlyCar._renderConn = nil end
    	if FlyCar._inputBeganConn then FlyCar._inputBeganConn:Disconnect() FlyCar._inputBeganConn = nil end
    	if FlyCar._inputEndedConn then FlyCar._inputEndedConn:Disconnect() FlyCar._inputEndedConn = nil end
    	FlyCar.keys = {}
    	if FlyCar._bodyGyro then FlyCar._bodyGyro:Destroy() FlyCar._bodyGyro = nil end
    	FlyCar.vehicle = nil
    	FlyCar.primaryPart = nil
    end

    function FlyCar.draw()
    	State.Set("movement_flycar_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_flycar_enabled"))}))
    	if State.Get("movement_flycar_enabled") then
    		Iris.SliderNum({"Speed", 10, 500, "%.0f"}, {number = Iris.State(State.Get("movement_flycar_speed"))})
    	end
    end

    Movement.FlyCar = FlyCar

    -- ============================================================================
    -- WALK FLING
    -- ============================================================================
    local WalkFling = {
    	name = "Walk Fling",
    	category = "movement",
    	enabled = false,
    	speed = 10000,
    	_tickFn = nil,
    }

    function WalkFling.onEnable()
    	if WalkFling._tickFn then return end
    	WalkFling._tickFn = function(cache)
    		if not State.Get("movement_walkfling_enabled") then return end
    		local hrp = cache.hrp
    		local hum = cache.hum
    		if not hrp or not hum then return end

    		hum.PlatformStand = true
    		hum.AutoRotate = false

    		local vel = hrp.AssemblyLinearVelocity
    		hrp.AssemblyLinearVelocity = Vector3.new(vel.X * 0.1, math.clamp(vel.Y, -WalkFling.speed, WalkFling.speed), vel.Z * 0.1)
    		hrp.Velocity = Vector3.new(WalkFling.speed, WalkFling.speed, WalkFling.speed)
    	end
    	SharedTicker.Subscribe(WalkFling._tickFn)
    end

    function WalkFling.onDisable()
    	if WalkFling._tickFn then
    		SharedTicker.Unsubscribe(WalkFling._tickFn)
    		WalkFling._tickFn = nil
    	end
    	local hum = Utils.getHumanoid(Utils.getChar())
    	if hum then
    		hum.PlatformStand = false
    		hum.AutoRotate = true
    		hum:ChangeState(Enum.HumanoidStateType.GettingUp)
    	end
    end

    function WalkFling.draw()
    	State.Set("movement_walkfling_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("movement_walkfling_enabled"))}))
    	if State.Get("movement_walkfling_enabled") then
    		Iris.SliderNum({"Speed", 1000, 50000, "%.0f"}, {number = Iris.State(State.Get("movement_walkfling_speed"))})
    	end
    end

    Movement.WalkFling = WalkFling

    -- ============================================================================
    -- MODULE REGISTRATION
    -- ============================================================================
    Core.Modules.Register("movement", Speed)
    Core.Modules.Register("movement", Noclip)
    Core.Modules.Register("movement", Fly)
    Core.Modules.Register("movement", CFrameFly)
    Core.Modules.Register("movement", InfiniteJump)
    Core.Modules.Register("movement", AntiAFK)
    Core.Modules.Register("movement", Spin)
    Core.Modules.Register("movement", FlyCar)
    Core.Modules.Register("movement", WalkFling)

    return Movement
end)()

-- ============================================================================
-- Combat (src/modules/combat.lua)
-- ============================================================================
local Combat = (function()
    local Core = Vokthos
    local Utils = Core.Utils
    local State = Core.State
    local Iris = Core.Iris
    local Notifications = Core.Notifications
    local Connections = Core.Connections
    local SharedTicker = Core.SharedTicker
    local ModuleRegistry = Core.Modules
    local Commands = Core.Commands
    local Config = Core.Config
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local HttpService = game:GetService("HttpService")
    local LocalPlayer = Players.LocalPlayer

    --[[
    	Combat Modules
    	Fixes: Loopfling + Fling added, connection guards, SharedTicker integration.
    ]]

    local Combat = {}

    local function safeConn(module, key, signal, callback)
    	if module[key] and module[key].Connected then
    		module[key]:Disconnect()
    	end
    	module[key] = signal:Connect(callback)
    end

    -- ============================================================================
    -- AIMBOT
    -- ============================================================================
    local Aimbot = {
    	name = "Aimbot",
    	category = "combat",
    	enabled = false,
    	fov = 150,
    	smoothness = 0.15,
    	teamCheck = false,
    }

    function Aimbot.onEnable()
    	safeConn(Aimbot, "_conn", RunService.RenderStepped, function()
    		if not State.Get("combat_aimbot_enabled") then return end
    		if not UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2) then return end

    		local cam = workspace.CurrentCamera
    		local center = Vector2.new(cam.ViewportSize.X / 2, cam.ViewportSize.Y / 2)
    		local closest = nil
    		local minDist = math.huge

    		for _, p in ipairs(Players:GetPlayers()) do
    			if p ~= LocalPlayer and p.Character then
    				if Aimbot.teamCheck and p.Team == LocalPlayer.Team then continue end
    				local head = p.Character:FindFirstChild("Head")
    				local hum = p.Character:FindFirstChildOfClass("Humanoid")
    				if head and hum and hum.Health > 0 then
    					local pos, onScreen = cam:WorldToViewportPoint(head.Position)
    					if onScreen then
    						local dist = (Vector2.new(pos.X, pos.Y) - center).Magnitude
    						if dist < minDist and dist < Aimbot.fov then
    							minDist = dist
    							closest = head
    						end
    					end
    				end
    			end
    		end

    		if closest and mousemoverel then
    			local target = cam:WorldToViewportPoint(closest.Position)
    			local mouse = UserInputService:GetMouseLocation()
    			local move = (Vector2.new(target.X, target.Y) - mouse) * Aimbot.smoothness
    			mousemoverel(move.X, move.Y)
    		end
    	end)
    end

    function Aimbot.onDisable()
    	if Aimbot._conn then Aimbot._conn:Disconnect() Aimbot._conn = nil end
    end

    function Aimbot.draw()
    	State.Set("combat_aimbot_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_aimbot_enabled"))}))
    	if State.Get("combat_aimbot_enabled") then
    		Iris.SliderNum({"FOV", 10, 500, "%.0f"}, {number = Iris.State(State.Get("combat_aimbot_fov"))})
    		Iris.SliderNum({"Smoothness", 0.01, 1, "%.2f"}, {number = Iris.State(State.Get("combat_aimbot_smoothness"))})
    		State.Set("combat_aimbot_teamcheck", Iris.Checkbox({"Team Check"}, {isChecked = Iris.State(State.Get("combat_aimbot_teamcheck"))}))
    	end
    end

    Combat.Aimbot = Aimbot

    -- ============================================================================
    -- TRIGGERBOT
    -- ============================================================================
    local Triggerbot = {
    	name = "Triggerbot",
    	category = "combat",
    	enabled = false,
    	delay = 0,
    	teamCheck = false,
    }

    function Triggerbot.onEnable()
    	safeConn(Triggerbot, "_conn", RunService.RenderStepped, function()
    		if not State.Get("combat_triggerbot_enabled") then return end
    		local mouse = LocalPlayer:GetMouse()
    		if mouse.Target and mouse.Target.Parent then
    			local target = mouse.Target.Parent
    			local hum = target:FindFirstChildOfClass("Humanoid")
    			local player = Players:GetPlayerFromCharacter(target)
    			if hum and hum.Health > 0 and player and player ~= LocalPlayer then
    				if Triggerbot.teamCheck and player.Team == LocalPlayer.Team then return end
    				if Triggerbot.delay > 0 then if task and task.wait then task.wait(Triggerbot.delay) else wait(Triggerbot.delay) end end
    				if mouse1click then mouse1click() end
    			end
    		end
    	end)
    end

    function Triggerbot.onDisable()
    	if Triggerbot._conn then Triggerbot._conn:Disconnect() Triggerbot._conn = nil end
    end

    function Triggerbot.draw()
    	State.Set("combat_triggerbot_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_triggerbot_enabled"))}))
    	if State.Get("combat_triggerbot_enabled") then
    		Iris.SliderNum({"Delay", 0, 1, "%.3f"}, {number = Iris.State(State.Get("combat_triggerbot_delay"))})
    		State.Set("combat_triggerbot_teamcheck", Iris.Checkbox({"Team Check"}, {isChecked = Iris.State(State.Get("combat_triggerbot_teamcheck"))}))
    	end
    end

    Combat.Triggerbot = Triggerbot

    -- ============================================================================
    -- HITBOX EXPANDER
    -- ============================================================================
    local Hitbox = {
    	name = "Hitbox Expander",
    	category = "combat",
    	enabled = false,
    	size = 10,
    	transparency = 0.7,
    	teamCheck = false,
    	originalSizes = {},
    	_tickFn = nil,
    }

    function Hitbox.onEnable()
    	if Hitbox._tickFn then return end
    	Hitbox.originalSizes = {}
    	Hitbox._tickFn = function(cache)
    		if not State.Get("combat_hitbox_enabled") then return end
    		local myTeam = LocalPlayer.Team
    		for _, p in ipairs(Players:GetPlayers()) do
    			if p ~= LocalPlayer and p.Character then
    				if Hitbox.teamCheck and p.Team == myTeam then continue end
    				local hrp = p.Character:FindFirstChild("HumanoidRootPart")
    				if hrp then
    					if not Hitbox.originalSizes[p] then Hitbox.originalSizes[p] = hrp.Size end
    					hrp.Size = Vector3.new(Hitbox.size, Hitbox.size, Hitbox.size)
    					hrp.Transparency = Hitbox.transparency
    					hrp.Material = Enum.Material.Neon
    					hrp.CanCollide = false
    				end
    			end
    		end
    	end
    	SharedTicker.Subscribe(Hitbox._tickFn)
    end

    function Hitbox.onDisable()
    	if Hitbox._tickFn then
    		SharedTicker.Unsubscribe(Hitbox._tickFn)
    		Hitbox._tickFn = nil
    	end
    	for p, size in pairs(Hitbox.originalSizes) do
    		if p and p.Character then
    			local hrp = p.Character:FindFirstChild("HumanoidRootPart")
    			if hrp then
    				hrp.Size = size
    				hrp.Transparency = 1
    				hrp.Material = Enum.Material.Plastic
    				hrp.CanCollide = true
    			end
    		end
    	end
    	Hitbox.originalSizes = {}
    end

    function Hitbox.draw()
    	State.Set("combat_hitbox_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_hitbox_enabled"))}))
    	if State.Get("combat_hitbox_enabled") then
    		Iris.SliderNum({"Size", 2, 50, "%.0f"}, {number = Iris.State(State.Get("combat_hitbox_size"))})
    		Iris.SliderNum({"Transparency", 0, 1, "%.2f"}, {number = Iris.State(State.Get("combat_hitbox_transparency"))})
    		State.Set("combat_hitbox_teamcheck", Iris.Checkbox({"Team Check"}, {isChecked = Iris.State(State.Get("combat_hitbox_teamcheck"))}))
    	end
    end

    Combat.Hitbox = Hitbox

    -- ============================================================================
    -- REACH
    -- ============================================================================
    local Reach = {
    	name = "Reach",
    	category = "combat",
    	enabled = false,
    	distance = 30,
    	_tickFn = nil,
    }

    function Reach.onEnable()
    	if Reach._tickFn then return end
    	Reach._tickFn = function(cache)
    		if not State.Get("combat_reach_enabled") then return end
    		local char = cache.char
    		if char then
    			for _, tool in ipairs(char:GetChildren()) do
    				if tool:IsA("Tool") then
    					tool.GripPos = Vector3.new(0, 0, -Reach.distance)
    				end
    			end
    			for _, tool in ipairs(LocalPlayer.Backpack:GetChildren()) do
    				if tool:IsA("Tool") then
    					tool.GripPos = Vector3.new(0, 0, -Reach.distance)
    				end
    			end
    		end
    	end
    	SharedTicker.Subscribe(Reach._tickFn)
    end

    function Reach.onDisable()
    	if Reach._tickFn then
    		SharedTicker.Unsubscribe(Reach._tickFn)
    		Reach._tickFn = nil
    	end
    end

    function Reach.draw()
    	State.Set("combat_reach_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_reach_enabled"))}))
    	if State.Get("combat_reach_enabled") then
    		Iris.SliderNum({"Distance", 5, 100, "%.0f"}, {number = Iris.State(State.Get("combat_reach_distance"))})
    	end
    end

    Combat.Reach = Reach

    -- ============================================================================
    -- FLING (Nameless Admin style - instant velocity spike)
    -- ============================================================================
    local Fling = {
    	name = "Fling",
    	category = "combat",
    	enabled = false,
    	power = 10000,
    	_tickFn = nil,
    }

    function Fling.onEnable()
    	if Fling._tickFn then return end
    	Fling._tickFn = function(cache)
    		if not State.Get("combat_fling_enabled") then return end
    		local hrp = cache.hrp
    		if not hrp then return end
    		local vel = Vector3.new(Fling.power, Fling.power, Fling.power)
    		hrp.Velocity = vel
    		hrp.AssemblyLinearVelocity = vel
    	end
    	SharedTicker.Subscribe(Fling._tickFn)
    end

    function Fling.onDisable()
    	if Fling._tickFn then
    		SharedTicker.Unsubscribe(Fling._tickFn)
    		Fling._tickFn = nil
    	end
    	local char = Utils.getChar()
    	local hrp = Utils.getRoot(char)
    	if hrp then
    		hrp.AssemblyLinearVelocity = Vector3.zero
    		hrp.AssemblyAngularVelocity = Vector3.zero
    	end
    end

    function Fling.draw()
    	State.Set("combat_fling_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_fling_enabled"))}))
    	if State.Get("combat_fling_enabled") then
    		Iris.SliderNum({"Power", 1000, 50000, "%.0f"}, {number = Iris.State(State.Get("combat_fling_power"))})
    	end
    end

    Combat.Fling = Fling

    -- ============================================================================
    -- LOOPFLING (Nameless Admin style - continuous rotational fling)
    -- ============================================================================
    local LoopFling = {
    	name = "Loop Fling",
    	category = "combat",
    	enabled = false,
    	power = 100000,
    }

    function LoopFling.onEnable()
    	if LoopFling._conn then return end
    	-- Use Heartbeat for consistent physics
    	LoopFling._conn = RunService.Heartbeat:Connect(function()
    		if not State.Get("combat_loopfling_enabled") then return end
    		local cache = SharedTicker._cache
    		local hrp = cache.hrp
    		local hum = cache.hum
    		if not hrp or not hum then return end

    		hum.PlatformStand = true
    		hrp.Velocity = Vector3.new(
    			(math.random() - 0.5) * 2 * LoopFling.power / 100,
    			LoopFling.power,
    			(math.random() - 0.5) * 2 * LoopFling.power / 100
    		)
    	end)
    end

    function LoopFling.onDisable()
    	if LoopFling._conn then
    		LoopFling._conn:Disconnect()
    		LoopFling._conn = nil
    	end
    	local cache = SharedTicker._cache
    	local hrp = cache.hrp
    	local hum = cache.hum
    	if hrp then
    		hrp.Velocity = Vector3.zero
    		hrp.AssemblyLinearVelocity = Vector3.zero
    		hrp.AssemblyAngularVelocity = Vector3.zero
    	end
    	if hum then
    		hum.PlatformStand = false
    	end
    end

    function LoopFling.draw()
    	State.Set("combat_loopfling_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_loopfling_enabled"))}))
    	if State.Get("combat_loopfling_enabled") then
    		Iris.SliderNum({"Power", 10000, 500000, "%.0f"}, {number = Iris.State(State.Get("combat_loopfling_power"))})
    	end
    end

    Combat.LoopFling = LoopFling

    -- ============================================================================
    -- AURA (Kill Aura)
    -- ============================================================================
    local Aura = {
    	name = "Kill Aura",
    	category = "combat",
    	enabled = false,
    	range = 30,
    	damage = 100,
    	_tickFn = nil,
    }

    function Aura.onEnable()
    	if Aura._tickFn then return end
    	Aura._tickFn = function(cache)
    		if not State.Get("combat_aura_enabled") then return end
    		local hrp = cache.hrp
    		if not hrp then return end

    		for _, p in ipairs(Players:GetPlayers()) do
    			if p ~= LocalPlayer and p.Character then
    				local targetHrp = p.Character:FindFirstChild("HumanoidRootPart")
    				local hum = p.Character:FindFirstChildOfClass("Humanoid")
    				if targetHrp and hum and hum.Health > 0 then
    					if (hrp.Position - targetHrp.Position).Magnitude <= Aura.range then
    						hum:TakeDamage(Aura.damage)
    					end
    				end
    			end
    		end
    	end
    	SharedTicker.Subscribe(Aura._tickFn)
    end

    function Aura.onDisable()
    	if Aura._tickFn then
    		SharedTicker.Unsubscribe(Aura._tickFn)
    		Aura._tickFn = nil
    	end
    end

    function Aura.draw()
    	State.Set("combat_aura_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_aura_enabled"))}))
    	if State.Get("combat_aura_enabled") then
    		Iris.SliderNum({"Range", 5, 100, "%.0f"}, {number = Iris.State(State.Get("combat_aura_range"))})
    		Iris.SliderNum({"Damage", 1, 500, "%.0f"}, {number = Iris.State(State.Get("combat_aura_damage"))})
    	end
    end

    Combat.Aura = Aura

    -- ============================================================================
    -- ANTI-KICK
    -- ============================================================================
    local AntiKick = {
    	name = "Anti-Kick",
    	category = "combat",
    	enabled = false,
    	mode = "fakeok",
    	_hooked = false,
    	_restored = false,
    }

    function AntiKick.onEnable()
    	if AntiKick._hooked then return end
    	if not (getrawmetatable and setreadonly and newcclosure and getnamecallmethod) then
    		Notifications.Warning("Anti-Kick", "Executor missing metamethod functions")
    		return
    	end
    	local mt = getrawmetatable(game)
    	if mt then
    		AntiKick._mt = mt
    		AntiKick._oldNamecall = mt.__namecall
    		setreadonly(mt, false)
    		mt.__namecall = newcclosure(function(self, ...)
    			local method = getnamecallmethod()
    			if method == "Kick" then
    				if AntiKick.mode == "error" then
    					error("Kick blocked")
    				else
    					return warn("Kick blocked (fake success)")
    				end
    			end
    			return AntiKick._oldNamecall(self, ...)
    		end)
    		setreadonly(mt, true)
    		AntiKick._hooked = true
    	end
    end

    function AntiKick.onDisable()
    	if AntiKick._hooked and AntiKick._mt and AntiKick._oldNamecall then
    		setreadonly(AntiKick._mt, false)
    		AntiKick._mt.__namecall = AntiKick._oldNamecall
    		setreadonly(AntiKick._mt, true)
    		AntiKick._hooked = false
    		AntiKick._mt = nil
    		AntiKick._oldNamecall = nil
    	end
    end

    function AntiKick.draw()
    	State.Set("combat_antikick_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_antikick_enabled"))}))
    	if State.Get("combat_antikick_enabled") then
    		Iris.Combo({"Mode", {"fakeok", "error"}}, {index = Iris.State(State.Get("combat_antikick_mode"))})
    	end
    end

    Combat.AntiKick = AntiKick

    -- ============================================================================
    -- ANTI-FLING
    -- ============================================================================
    local AntiFling = {
    	name = "Anti-Fling",
    	category = "combat",
    	enabled = false,
    	_tickFn = nil,
    }

    function AntiFling.onEnable()
    	if AntiFling._tickFn then return end
    	AntiFling._tickFn = function(cache)
    		if not State.Get("combat_antifling_enabled") then return end
    		local char = cache.char
    		if not char then return end
    		for _, part in ipairs(char:GetDescendants()) do
    			if part:IsA("BasePart") then
    				if part.AssemblyLinearVelocity.Magnitude > 1000 then
    					part.AssemblyLinearVelocity = Vector3.zero
    					part.AssemblyAngularVelocity = Vector3.zero
    				end
    			end
    		end
    	end
    	SharedTicker.Subscribe(AntiFling._tickFn)
    end

    function AntiFling.onDisable()
    	if AntiFling._tickFn then
    		SharedTicker.Unsubscribe(AntiFling._tickFn)
    		AntiFling._tickFn = nil
    	end
    end

    function AntiFling.draw()
    	State.Set("combat_antifling_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_antifling_enabled"))}))
    end

    Combat.AntiFling = AntiFling

    -- ============================================================================
    -- ANTI-KNOCKBACK
    -- ============================================================================
    local AntiKnockback = {
    	name = "Anti-Knockback",
    	category = "combat",
    	enabled = false,
    	_tickFn = nil,
    }

    function AntiKnockback.onEnable()
    	if AntiKnockback._tickFn then return end
    	AntiKnockback._tickFn = function(cache)
    		if not State.Get("combat_antiknockback_enabled") then return end
    		local hum = cache.hum
    		if hum and hum.PlatformStand then
    			hum.PlatformStand = false
    		end
    	end
    	SharedTicker.Subscribe(AntiKnockback._tickFn)
    end

    function AntiKnockback.onDisable()
    	if AntiKnockback._tickFn then
    		SharedTicker.Unsubscribe(AntiKnockback._tickFn)
    		AntiKnockback._tickFn = nil
    	end
    end

    function AntiKnockback.draw()
    	State.Set("combat_antiknockback_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("combat_antiknockback_enabled"))}))
    end

    Combat.AntiKnockback = AntiKnockback

    -- ============================================================================
    -- MODULE REGISTRATION
    -- ============================================================================
    Core.Modules.Register("combat", Aimbot)
    Core.Modules.Register("combat", Triggerbot)
    Core.Modules.Register("combat", Hitbox)
    Core.Modules.Register("combat", Reach)
    Core.Modules.Register("combat", Fling)
    Core.Modules.Register("combat", LoopFling)
    Core.Modules.Register("combat", Aura)
    Core.Modules.Register("combat", AntiKick)
    Core.Modules.Register("combat", AntiFling)
    Core.Modules.Register("combat", AntiKnockback)

    return Combat
end)()

-- ============================================================================
-- Visuals (src/modules/visuals.lua)
-- ============================================================================
local Visuals = (function()
    local Core = Vokthos
    local Utils = Core.Utils
    local State = Core.State
    local Iris = Core.Iris
    local Notifications = Core.Notifications
    local Connections = Core.Connections
    local SharedTicker = Core.SharedTicker
    local ModuleRegistry = Core.Modules
    local Commands = Core.Commands
    local Config = Core.Config
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local HttpService = game:GetService("HttpService")
    local LocalPlayer = Players.LocalPlayer

    --[[
    	Visuals Modules
    	Fixes: ESP single RenderStepped connection, XRay caching, connection guards.
    ]]

    local Visuals = {}

    local function safeConn(module, key, signal, callback)
    	if module[key] and module[key].Connected then
    		module[key]:Disconnect()
    	end
    	module[key] = signal:Connect(callback)
    end

    -- ============================================================================
    -- ESP (single RenderStepped connection for ALL players)
    -- ============================================================================
    local ESP = {
    	name = "ESP",
    	category = "visuals",
    	enabled = false,
    	teamCheck = false,
    	showBox = true,
    	showName = true,
    	showHealth = true,
    	showDistance = true,
    	_renderConn = nil,
    	_playerAddedConn = nil,
    	_playerRemovingConn = nil,
    	_objects = {},
    }

    function ESP.createOrUpdate(player)
    	if player == LocalPlayer then return end
    	if not ESP.enabled then return end

    	local data = ESP._objects[player]
    	if not data then
    		local folder = Instance.new("Folder")
    		folder.Name = player.Name .. "_ESP"
    		folder.Parent = CoreGui
    		data = {folder = folder, parts = {}, billboard = nil}
    		ESP._objects[player] = data
    	end

    	local folder = data.folder
    	if not folder or not folder.Parent then return end

    	local char = player.Character
    	if not char then return end
    	local hum = char:FindFirstChildOfClass("Humanoid")
    	local hrp = char:FindFirstChild("HumanoidRootPart")
    	local head = char:FindFirstChild("Head")
    	if not hum or not hrp or not head then return end

    	local myHrp = Utils.getRoot(Utils.getChar())

    	-- Box
    	if ESP.showBox then
    		for _, part in ipairs(char:GetChildren()) do
    			if part:IsA("BasePart") then
    				local adorn = data.parts[part]
    				if not adorn then
    					adorn = Instance.new("BoxHandleAdornment")
    					adorn.Name = "Box_" .. part.Name
    					adorn.Parent = folder
    					adorn.Adornee = part
    					adorn.AlwaysOnTop = true
    					adorn.ZIndex = 10
    					adorn.Transparency = 0.3
    					data.parts[part] = adorn
    				end
    				adorn.Size = part.Size + Vector3.new(0.1, 0.1, 0.1)
    				adorn.Color3 = ESP.teamCheck and (player.TeamColor == LocalPlayer.TeamColor and Color3.fromRGB(0, 255, 0) or Color3.fromRGB(255, 0, 0)) or player.TeamColor.Color
    			end
    		end
    	end

    	-- Name/Health/Distance billboard
    	if ESP.showName or ESP.showHealth or ESP.showDistance then
    		local billboard = data.billboard
    		if not billboard then
    			billboard = Instance.new("BillboardGui")
    			billboard.Name = "Info"
    			billboard.Size = UDim2.new(0, 200, 0, 100)
    			billboard.StudsOffset = Vector3.new(0, 3, 0)
    			billboard.AlwaysOnTop = true
    			billboard.Adornee = head
    			billboard.Parent = folder
    			data.billboard = billboard

    			local y = 0
    			for _, labelName in ipairs({"Name", "Health", "Distance"}) do
    				local label = Instance.new("TextLabel")
    				label.Name = labelName
    				label.Size = UDim2.new(1, 0, 0, 20)
    				label.Position = UDim2.new(0, 0, 0, y)
    				label.BackgroundTransparency = 1
    				label.TextColor3 = Color3.new(1, 1, 1)
    				label.TextSize = labelName == "Name" and 14 or 12
    				label.Font = labelName == "Name" and Enum.Font.GothamBold or Enum.Font.Gotham
    				label.TextStrokeTransparency = 0
    				label.Parent = billboard
    				y = y + 22
    			end
    		end

    		billboard.Adornee = head
    		if myHrp then
    			billboard.Distance.Text = math.floor((myHrp.Position - hrp.Position).Magnitude) .. "m"
    		end
    		billboard.Health.Text = "HP: " .. math.floor(hum.Health) .. "/" .. math.floor(hum.MaxHealth)
    		local ratio = hum.Health / hum.MaxHealth
    		billboard.Health.TextColor3 = Color3.fromRGB(255 * (1 - ratio), 255 * ratio, 0)
    		billboard.Name.Visible = ESP.showName
    		billboard.Health.Visible = ESP.showHealth
    		billboard.Distance.Visible = ESP.showDistance
    	end
    end

    function ESP.onEnable()
    	safeConn(ESP, "_renderConn", RunService.RenderStepped, function()
    		if not State.Get("visuals_esp_enabled") then return end
    		for _, p in ipairs(Players:GetPlayers()) do
    			ESP.createOrUpdate(p)
    		end
    	end)

    	if ESP._playerAddedConn then ESP._playerAddedConn:Disconnect() end
    	ESP._playerAddedConn = Players.PlayerAdded:Connect(function(p)
    		if State.Get("visuals_esp_enabled") then ESP.createOrUpdate(p) end
    	end)

    	if ESP._playerRemovingConn then ESP._playerRemovingConn:Disconnect() end
    	ESP._playerRemovingConn = Players.PlayerRemoving:Connect(function(p)
    		if ESP._objects[p] then
    			if ESP._objects[p].folder then ESP._objects[p].folder:Destroy() end
    			ESP._objects[p] = nil
    		end
    	end)
    end

    function ESP.onDisable()
    	if ESP._renderConn then ESP._renderConn:Disconnect() ESP._renderConn = nil end
    	if ESP._playerAddedConn then ESP._playerAddedConn:Disconnect() ESP._playerAddedConn = nil end
    	if ESP._playerRemovingConn then ESP._playerRemovingConn:Disconnect() ESP._playerRemovingConn = nil end
    	for _, data in pairs(ESP._objects) do
    		if data.folder then data.folder:Destroy() end
    	end
    	ESP._objects = {}
    end

    function ESP.draw()
    	State.Set("visuals_esp_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("visuals_esp_enabled"))}))
    	if State.Get("visuals_esp_enabled") then
    		State.Set("visuals_esp_teamcheck", Iris.Checkbox({"Team Check"}, {isChecked = Iris.State(State.Get("visuals_esp_teamcheck"))}))
    		State.Set("visuals_esp_showbox", Iris.Checkbox({"Show Box"}, {isChecked = Iris.State(State.Get("visuals_esp_showbox"))}))
    		State.Set("visuals_esp_showname", Iris.Checkbox({"Show Name"}, {isChecked = Iris.State(State.Get("visuals_esp_showname"))}))
    		State.Set("visuals_esp_showhealth", Iris.Checkbox({"Show Health"}, {isChecked = Iris.State(State.Get("visuals_esp_showhealth"))}))
    		State.Set("visuals_esp_showdistance", Iris.Checkbox({"Show Distance"}, {isChecked = Iris.State(State.Get("visuals_esp_showdistance"))}))
    	end
    end

    Visuals.ESP = ESP

    -- ============================================================================
    -- CHAMS
    -- ============================================================================
    local Chams = {
    	name = "Chams",
    	category = "visuals",
    	enabled = false,
    	teamCheck = false,
    	_renderConn = nil,
    	_objects = {},
    }

    function Chams.onEnable()
    	safeConn(Chams, "_renderConn", RunService.RenderStepped, function()
    		if not State.Get("visuals_chams_enabled") then return end
    		for _, p in ipairs(Players:GetPlayers()) do
    			if p ~= LocalPlayer and p.Character then
    				if Chams.teamCheck and p.Team == LocalPlayer.Team then continue end
    				local highlight = Chams._objects[p]
    				if not highlight then
    					highlight = Instance.new("Highlight")
    					highlight.Name = "Chams_" .. p.Name
    					highlight.Parent = CoreGui
    					highlight.FillTransparency = 0.5
    					highlight.OutlineTransparency = 0
    					highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    					Chams._objects[p] = highlight
    				end
    				highlight.Adornee = p.Character
    			end
    		end
    		for p, h in pairs(Chams._objects) do
    			if not p.Character or not p.Parent then
    				h:Destroy()
    				Chams._objects[p] = nil
    			end
    		end
    	end)
    end

    function Chams.onDisable()
    	if Chams._renderConn then Chams._renderConn:Disconnect() Chams._renderConn = nil end
    	for _, h in pairs(Chams._objects) do h:Destroy() end
    	Chams._objects = {}
    end

    function Chams.draw()
    	State.Set("visuals_chams_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("visuals_chams_enabled"))}))
    	if State.Get("visuals_chams_enabled") then
    		State.Set("visuals_chams_teamcheck", Iris.Checkbox({"Team Check"}, {isChecked = Iris.State(State.Get("visuals_chams_teamcheck"))}))
    	end
    end

    Visuals.Chams = Chams

    -- ============================================================================
    -- X-RAY (dirty flag caching - only iterate when toggled)
    -- ============================================================================
    local XRay = {
    	name = "X-Ray",
    	category = "visuals",
    	enabled = false,
    	transparency = 0.5,
    	_dirty = true,
    	_original = {},
    	_renderConn = nil,
    }

    function XRay.onEnable()
    	XRay._original = {}
    	XRay._dirty = true
    	safeConn(XRay, "_renderConn", RunService.RenderStepped, function()
    		if not State.Get("visuals_xray_enabled") then return end
    		if not XRay._dirty then return end
    		XRay._dirty = false
    		for _, part in ipairs(workspace:GetChildren()) do
    			if part:IsA("BasePart") and part.Transparency < 1 then
    				if not XRay._original[part] then XRay._original[part] = part.Transparency end
    				if part ~= workspace.Terrain then
    					part.Transparency = XRay.transparency
    				end
    			end
    		end
    	end)
    end

    function XRay.onDisable()
    	if XRay._renderConn then XRay._renderConn:Disconnect() XRay._renderConn = nil end
    	for part, trans in pairs(XRay._original) do
    		if part and part.Parent then part.Transparency = trans end
    	end
    	XRay._original = {}
    end

    function XRay.draw()
    	State.Set("visuals_xray_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("visuals_xray_enabled"))}))
    	if State.Get("visuals_xray_enabled") then
    		XRay._dirty = true
    		Iris.SliderNum({"Transparency", 0, 0.9, "%.2f"}, {number = Iris.State(State.Get("visuals_xray_transparency"))})
    	end
    end

    Visuals.XRay = XRay

    -- ============================================================================
    -- FULLBRIGHT
    -- ============================================================================
    local FullBright = {
    	name = "FullBright",
    	category = "visuals",
    	enabled = false,
    	_original = {},
    	_changedConn = nil,
    }

    function FullBright.onEnable()
    	FullBright._original = {
    		Ambient = Lighting.Ambient,
    		OutdoorAmbient = Lighting.OutdoorAmbient,
    		Brightness = Lighting.Brightness,
    		ClockTime = Lighting.ClockTime,
    		FogEnd = Lighting.FogEnd,
    		GlobalShadows = Lighting.GlobalShadows,
    	}
    	Lighting.Ambient = Color3.new(1, 1, 1)
    	Lighting.OutdoorAmbient = Color3.new(1, 1, 1)
    	Lighting.Brightness = 2
    	Lighting.ClockTime = 14
    	Lighting.FogEnd = 100000
    	Lighting.GlobalShadows = false
    	safeConn(FullBright, "_changedConn", Lighting.Changed, function()
    		if State.Get("visuals_fullbright_enabled") then
    			Lighting.Ambient = Color3.new(1, 1, 1)
    			Lighting.OutdoorAmbient = Color3.new(1, 1, 1)
    			Lighting.Brightness = 2
    			Lighting.ClockTime = 14
    			Lighting.FogEnd = 100000
    			Lighting.GlobalShadows = false
    		end
    	end)
    end

    function FullBright.onDisable()
    	if FullBright._changedConn then FullBright._changedConn:Disconnect() FullBright._changedConn = nil end
    	for prop, val in pairs(FullBright._original) do
    		Lighting[prop] = val
    	end
    	FullBright._original = {}
    end

    function FullBright.draw()
    	State.Set("visuals_fullbright_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("visuals_fullbright_enabled"))}))
    end

    Visuals.FullBright = FullBright

    -- ============================================================================
    -- NPC ESP (cached: use GetChildren instead of GetDescendants)
    -- ============================================================================
    local NPCESP = {
    	name = "NPC ESP",
    	category = "visuals",
    	enabled = false,
    	maxDistance = 400,
    	_renderConn = nil,
    	_objects = {},
    }

    function NPCESP.onEnable()
    	safeConn(NPCESP, "_renderConn", RunService.Heartbeat, function()
    		if not State.Get("visuals_npc_esp_enabled") then return end
    		local cache = SharedTicker._cache
    		local myHrp = cache.hrp
    		if not myHrp then return end
    		for _, obj in ipairs(workspace:GetChildren()) do
    			if obj:IsA("Model") and obj:FindFirstChildOfClass("Humanoid") and not Players:GetPlayerFromCharacter(obj) then
    				local npcHrp = obj:FindFirstChild("HumanoidRootPart")
    				if npcHrp and (myHrp.Position - npcHrp.Position).Magnitude <= NPCESP.maxDistance then
    					local highlight = NPCESP._objects[obj]
    					if not highlight then
    						highlight = Instance.new("Highlight")
    						highlight.Name = "NPCESP_" .. obj.Name
    						highlight.Parent = CoreGui
    						highlight.FillColor = Color3.fromRGB(255, 165, 0)
    						highlight.OutlineColor = Color3.new(1, 1, 1)
    						highlight.FillTransparency = 0.5
    						highlight.OutlineTransparency = 0
    						highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    						NPCESP._objects[obj] = highlight
    					end
    					highlight.Adornee = obj
    				end
    			end
    		end
    		for obj, h in pairs(NPCESP._objects) do
    			if not obj.Parent or not obj:FindFirstChild("HumanoidRootPart") or (myHrp and (myHrp.Position - obj.HumanoidRootPart.Position).Magnitude > NPCESP.maxDistance) then
    				h:Destroy()
    				NPCESP._objects[obj] = nil
    			end
    		end
    	end)
    end

    function NPCESP.onDisable()
    	if NPCESP._renderConn then NPCESP._renderConn:Disconnect() NPCESP._renderConn = nil end
    	for _, h in pairs(NPCESP._objects) do h:Destroy() end
    	NPCESP._objects = {}
    end

    function NPCESP.draw()
    	State.Set("visuals_npc_esp_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("visuals_npc_esp_enabled"))}))
    	if State.Get("visuals_npc_esp_enabled") then
    		Iris.SliderNum({"Max Distance", 50, 1000, "%.0f"}, {number = Iris.State(State.Get("visuals_npc_esp_distance"))})
    	end
    end

    Visuals.NPCESP = NPCESP

    -- ============================================================================
    -- PING DISPLAY
    -- ============================================================================
    local Ping = {
    	name = "Ping Display",
    	category = "visuals",
    	enabled = false,
    	_renderConn = nil,
    	_gui = nil,
    }

    function Ping.onEnable()
    	Ping._gui = Instance.new("ScreenGui")
    	Ping._gui.Name = "PingDisplay_" .. Utils.randomString(8)
    	Ping._gui.ResetOnSpawn = false
    	Ping._gui.Parent = CoreGui

    	local label = Instance.new("TextLabel")
    	label.Name = "PingLabel"
    	label.Size = UDim2.new(0, 120, 0, 30)
    	label.Position = UDim2.new(1, -130, 0, 10)
    	label.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
    	label.BackgroundTransparency = 0.5
    	label.TextColor3 = Color3.new(1, 1, 1)
    	label.TextSize = 16
    	label.Font = Enum.Font.GothamBold
    	label.Text = "Ping: 0ms"
    	label.Parent = Ping._gui

    	safeConn(Ping, "_renderConn", RunService.RenderStepped, function()
    		if not State.Get("visuals_ping_enabled") then return end
    		local stats = game:GetService("Stats")
    		if stats and stats.Network then
    			local ping = stats.Network.ServerStatsItem["Data Ping"]:GetValue()
    			label.Text = "Ping: " .. math.floor(ping) .. "ms"
    			if ping < 100 then label.TextColor3 = Color3.fromRGB(80, 255, 80)
    			elseif ping < 200 then label.TextColor3 = Color3.fromRGB(255, 200, 50)
    			else label.TextColor3 = Color3.fromRGB(255, 80, 80) end
    		end
    	end)
    end

    function Ping.onDisable()
    	if Ping._renderConn then Ping._renderConn:Disconnect() Ping._renderConn = nil end
    	if Ping._gui then Ping._gui:Destroy() end
    	Ping._gui = nil
    end

    function Ping.draw()
    	State.Set("visuals_ping_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("visuals_ping_enabled"))}))
    end

    Visuals.Ping = Ping

    -- ============================================================================
    -- FPS DISPLAY
    -- ============================================================================
    local FPS = {
    	name = "FPS Display",
    	category = "visuals",
    	enabled = false,
    	_renderConn = nil,
    	_gui = nil,
    }

    function FPS.onEnable()
    	FPS._gui = Instance.new("ScreenGui")
    	FPS._gui.Name = "FPSDisplay_" .. Utils.randomString(8)
    	FPS._gui.ResetOnSpawn = false
    	FPS._gui.Parent = CoreGui

    	local label = Instance.new("TextLabel")
    	label.Name = "FPSLabel"
    	label.Size = UDim2.new(0, 120, 0, 30)
    	label.Position = UDim2.new(1, -130, 0, 45)
    	label.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
    	label.BackgroundTransparency = 0.5
    	label.TextColor3 = Color3.new(1, 1, 1)
    	label.TextSize = 16
    	label.Font = Enum.Font.GothamBold
    	label.Text = "FPS: 60"
    	label.Parent = FPS._gui

    	local frames = 0
    	local lastTime = tick()

    	safeConn(FPS, "_renderConn", RunService.RenderStepped, function()
    		if not State.Get("visuals_fps_enabled") then return end
    		frames = frames + 1
    		local now = tick()
    		if now - lastTime >= 1 then
    			label.Text = "FPS: " .. frames
    			if frames < 30 then label.TextColor3 = Color3.fromRGB(255, 80, 80)
    			elseif frames < 50 then label.TextColor3 = Color3.fromRGB(255, 200, 50)
    			else label.TextColor3 = Color3.fromRGB(80, 255, 80) end
    			frames = 0
    			lastTime = now
    		end
    	end)
    end

    function FPS.onDisable()
    	if FPS._renderConn then FPS._renderConn:Disconnect() FPS._renderConn = nil end
    	if FPS._gui then FPS._gui:Destroy() end
    	FPS._gui = nil
    end

    function FPS.draw()
    	State.Set("visuals_fps_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("visuals_fps_enabled"))}))
    end

    Visuals.FPS = FPS

    -- Register all visuals modules
    Core.Modules.Register("visuals", ESP)
    Core.Modules.Register("visuals", Chams)
    Core.Modules.Register("visuals", XRay)
    Core.Modules.Register("visuals", FullBright)
    Core.Modules.Register("visuals", NPCESP)
    Core.Modules.Register("visuals", Ping)
    Core.Modules.Register("visuals", FPS)

    return Visuals
end)()

-- ============================================================================
-- Player (src/modules/player.lua)
-- ============================================================================
local Player = (function()
    local Core = Vokthos
    local Utils = Core.Utils
    local State = Core.State
    local Iris = Core.Iris
    local Notifications = Core.Notifications
    local Connections = Core.Connections
    local SharedTicker = Core.SharedTicker
    local ModuleRegistry = Core.Modules
    local Commands = Core.Commands
    local Config = Core.Config
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local HttpService = game:GetService("HttpService")
    local LocalPlayer = Players.LocalPlayer

    --[[
    	Player Modules
    	Fix: Removed duplicate WalkSpeed (consolidated into movement.lua Speed module).
    	Connection guards added to all modules.
    ]]

    local Player = {}

    local function safeConn(module, key, signal, callback)
    	if module[key] and module[key].Connected then
    		module[key]:Disconnect()
    	end
    	module[key] = signal:Connect(callback)
    end

    -- ============================================================================
    -- GOD MODE
    -- ============================================================================
    local GodMode = {
    	name = "God Mode",
    	category = "player",
    	enabled = false,
    	_healthConn = nil,
    	_maxHealth = 100,
    }

    function GodMode.onEnable()
    	local char = Utils.getChar()
    	local hum = char and Utils.getHumanoid(char)
    	if not hum then return end
    	GodMode._maxHealth = hum.MaxHealth
    	safeConn(GodMode, "_healthConn", hum.HealthChanged, function()
    		if State.Get("player_godmode_enabled") and hum.Health < GodMode._maxHealth then
    			hum.Health = GodMode._maxHealth
    		end
    	end)
    	hum.Health = GodMode._maxHealth
    end

    function GodMode.onDisable()
    	if GodMode._healthConn then GodMode._healthConn:Disconnect() GodMode._healthConn = nil end
    end

    function GodMode.draw()
    	State.Set("player_godmode_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("player_godmode_enabled"))}))
    end

    Player.GodMode = GodMode

    -- ============================================================================
    -- INVISIBLE
    -- ============================================================================
    local Invisible = {
    	name = "Invisible",
    	category = "player",
    	enabled = false,
    	_originalTransparency = {},
    }

    function Invisible.onEnable()
    	local char = Utils.getChar()
    	if not char then return end
    	Invisible._originalTransparency = {}
    	for _, part in ipairs(char:GetDescendants()) do
    		if part:IsA("BasePart") then
    			Invisible._originalTransparency[part] = part.Transparency
    			part.Transparency = 1
    		elseif part:IsA("Decal") then
    			Invisible._originalTransparency[part] = part.Transparency
    			part.Transparency = 1
    		end
    	end
    	local head = char:FindFirstChild("Head")
    	if head then
    		local face = head:FindFirstChild("face")
    		if face then
    			Invisible._originalTransparency[face] = face.Transparency
    			face.Transparency = 1
    		end
    	end
    end

    function Invisible.onDisable()
    	local char = Utils.getChar()
    	if char then
    		for part, trans in pairs(Invisible._originalTransparency) do
    			if part and part.Parent then part.Transparency = trans end
    		end
    	end
    	Invisible._originalTransparency = {}
    end

    function Invisible.draw()
    	State.Set("player_invisible_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("player_invisible_enabled"))}))
    end

    Player.Invisible = Invisible

    -- ============================================================================
    -- NO SIT
    -- ============================================================================
    local NoSit = {
    	name = "No Sit",
    	category = "player",
    	enabled = false,
    	_tickFn = nil,
    }

    function NoSit.onEnable()
    	if NoSit._tickFn then return end
    	NoSit._tickFn = function(cache)
    		if not State.Get("player_nosit_enabled") then return end
    		local hum = cache.hum
    		if hum and hum.Sit then
    			hum.Sit = false
    			hum.PlatformStand = false
    		end
    	end
    	SharedTicker.Subscribe(NoSit._tickFn)
    end

    function NoSit.onDisable()
    	if NoSit._tickFn then
    		SharedTicker.Unsubscribe(NoSit._tickFn)
    		NoSit._tickFn = nil
    	end
    end

    function NoSit.draw()
    	State.Set("player_nosit_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("player_nosit_enabled"))}))
    end

    Player.NoSit = NoSit

    -- ============================================================================
    -- JUMP POWER
    -- ============================================================================
    local JumpPower = {
    	name = "Jump Power",
    	category = "player",
    	enabled = false,
    	power = 150,
    	_tickFn = nil,
    }

    function JumpPower.onEnable()
    	if JumpPower._tickFn then return end
    	JumpPower._tickFn = function(cache)
    		if not State.Get("player_jumppower_enabled") then return end
    		local hum = cache.hum
    		if hum then hum.JumpPower = JumpPower.power end
    	end
    	SharedTicker.Subscribe(JumpPower._tickFn)
    end

    function JumpPower.onDisable()
    	if JumpPower._tickFn then
    		SharedTicker.Unsubscribe(JumpPower._tickFn)
    		JumpPower._tickFn = nil
    	end
    	local hum = Utils.getHumanoid(Utils.getChar())
    	if hum then hum.JumpPower = 50 end
    end

    function JumpPower.draw()
    	State.Set("player_jumppower_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("player_jumppower_enabled"))}))
    	if State.Get("player_jumppower_enabled") then
    		Iris.SliderNum({"Power", 50, 500, "%.0f"}, {number = Iris.State(State.Get("player_jumppower_value"))})
    	end
    end

    Player.JumpPower = JumpPower

    -- ============================================================================
    -- RESET CHARACTER (button, not toggle)
    -- ============================================================================
    local Reset = {
    	name = "Reset Character",
    	category = "player",
    }

    function Reset.onEnable()
    	local char = Utils.getChar()
    	if char then char:BreakJoints() end
    end

    function Reset.onDisable() end

    function Reset.draw()
    	if Iris.Button({"Reset Character"}) then
    		Reset.onEnable()
    	end
    end

    Player.Reset = Reset

    -- ============================================================================
    -- RESPAWN (button, not toggle)
    -- ============================================================================
    local Respawn = {
    	name = "Respawn",
    	category = "player",
    }

    function Respawn.onEnable()
    	local char = Utils.getChar()
    	if char then char:BreakJoints() end
    end

    function Respawn.onDisable() end

    function Respawn.draw()
    	if Iris.Button({"Respawn"}) then
    		Respawn.onEnable()
    	end
    end

    Player.Respawn = Respawn

    -- Register all player modules
    Core.Modules.Register("player", GodMode)
    Core.Modules.Register("player", Invisible)
    Core.Modules.Register("player", NoSit)
    Core.Modules.Register("player", JumpPower)
    Core.Modules.Register("player", Reset)
    Core.Modules.Register("player", Respawn)

    return Player
end)()

-- ============================================================================
-- World (src/modules/world.lua)
-- ============================================================================
local World = (function()
    local Core = Vokthos
    local Utils = Core.Utils
    local State = Core.State
    local Iris = Core.Iris
    local Notifications = Core.Notifications
    local Connections = Core.Connections
    local SharedTicker = Core.SharedTicker
    local ModuleRegistry = Core.Modules
    local Commands = Core.Commands
    local Config = Core.Config
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local HttpService = game:GetService("HttpService")
    local LocalPlayer = Players.LocalPlayer

    --[[
    	World Modules
    	Fix: Removed duplicate WorldNoclip (use movement.lua Noclip instead).
    	Connection guards + SharedTicker integration.
    ]]

    local World = {}

    local function safeConn(module, key, signal, callback)
    	if module[key] and module[key].Connected then
    		module[key]:Disconnect()
    	end
    	module[key] = signal:Connect(callback)
    end

    -- ============================================================================
    -- ANTI VOID
    -- ============================================================================
    local AntiVoid = {
    	name = "Anti-Void",
    	category = "world",
    	enabled = false,
    	_touchedConn = nil,
    	_platform = nil,
    }

    function AntiVoid.onEnable()
    	if AntiVoid._platform then AntiVoid._platform:Destroy() end
    	AntiVoid._platform = Instance.new("Part")
    	AntiVoid._platform.Name = "AntiVoidPlatform"
    	AntiVoid._platform.Size = Vector3.new(1000, 1, 1000)
    	AntiVoid._platform.Position = Vector3.new(0, -500, 0)
    	AntiVoid._platform.Anchored = true
    	AntiVoid._platform.Transparency = 1
    	AntiVoid._platform.CanCollide = true
    	AntiVoid._platform.Parent = workspace

    	safeConn(AntiVoid, "_touchedConn", AntiVoid._platform.Touched, function(hit)
    		if not State.Get("world_antivoid_enabled") then return end
    		if hit:IsDescendantOf(Utils.getChar()) then
    			local hrp = Utils.getRoot(Utils.getChar())
    			if hrp then hrp.CFrame = CFrame.new(0, -490, 0) end
    		end
    	end)
    end

    function AntiVoid.onDisable()
    	if AntiVoid._touchedConn then AntiVoid._touchedConn:Disconnect() AntiVoid._touchedConn = nil end
    	if AntiVoid._platform then AntiVoid._platform:Destroy() AntiVoid._platform = nil end
    end

    function AntiVoid.draw()
    	State.Set("world_antivoid_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("world_antivoid_enabled"))}))
    end

    World.AntiVoid = AntiVoid

    -- ============================================================================
    -- TIME SCALE (placeholder - executor specific)
    -- ============================================================================
    local TimeScale = {
    	name = "Time Scale",
    	category = "world",
    	enabled = false,
    	scale = 1,
    	_tickFn = nil,
    }

    function TimeScale.onEnable()
    	if TimeScale._tickFn then return end
    	TimeScale._tickFn = function(cache)
    		if not State.Get("world_timescale_enabled") then return end
    		-- Note: Can't change game time scale from client in standard Lua
    		-- This is a placeholder for executor-specific implementations (setfpscap, etc.)
    	end
    	SharedTicker.Subscribe(TimeScale._tickFn)
    end

    function TimeScale.onDisable()
    	if TimeScale._tickFn then
    		SharedTicker.Unsubscribe(TimeScale._tickFn)
    		TimeScale._tickFn = nil
    	end
    end

    function TimeScale.draw()
    	State.Set("world_timescale_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("world_timescale_enabled"))}))
    	if State.Get("world_timescale_enabled") then
    		Iris.SliderNum({"Scale", 0.1, 5, "%.2f"}, {number = Iris.State(State.Get("world_timescale_value"))})
    	end
    end

    World.TimeScale = TimeScale

    -- ============================================================================
    -- GRAVITY
    -- ============================================================================
    local Gravity = {
    	name = "Gravity",
    	category = "world",
    	enabled = false,
    	gravity = 196.2,
    	_tickFn = nil,
    }

    function Gravity.onEnable()
    	if Gravity._tickFn then return end
    	Gravity._tickFn = function(cache)
    		if not State.Get("world_gravity_enabled") then return end
    		workspace.Gravity = Gravity.gravity
    	end
    	SharedTicker.Subscribe(Gravity._tickFn)
    end

    function Gravity.onDisable()
    	if Gravity._tickFn then
    		SharedTicker.Unsubscribe(Gravity._tickFn)
    		Gravity._tickFn = nil
    	end
    	workspace.Gravity = 196.2
    end

    function Gravity.draw()
    	State.Set("world_gravity_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("world_gravity_enabled"))}))
    	if State.Get("world_gravity_enabled") then
    		Iris.SliderNum({"Gravity", 0, 500, "%.1f"}, {number = Iris.State(State.Get("world_gravity_value"))})
    	end
    end

    World.Gravity = Gravity

    -- ============================================================================
    -- REMOVE FOG
    -- ============================================================================
    local RemoveFog = {
    	name = "Remove Fog",
    	category = "world",
    	enabled = false,
    	_original = {},
    	_changedConn = nil,
    }

    function RemoveFog.onEnable()
    	RemoveFog._original = {
    		FogStart = Lighting.FogStart,
    		FogEnd = Lighting.FogEnd,
    		FogColor = Lighting.FogColor,
    	}
    	Lighting.FogStart = 0
    	Lighting.FogEnd = 1000000
    	Lighting.FogColor = Color3.new(1, 1, 1)
    	safeConn(RemoveFog, "_changedConn", Lighting.Changed, function()
    		if State.Get("world_removefog_enabled") then
    			Lighting.FogStart = 0
    			Lighting.FogEnd = 1000000
    			Lighting.FogColor = Color3.new(1, 1, 1)
    		end
    	end)
    end

    function RemoveFog.onDisable()
    	if RemoveFog._changedConn then RemoveFog._changedConn:Disconnect() RemoveFog._changedConn = nil end
    	for prop, val in pairs(RemoveFog._original) do
    		Lighting[prop] = val
    	end
    	RemoveFog._original = {}
    end

    function RemoveFog.draw()
    	State.Set("world_removefog_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("world_removefog_enabled"))}))
    end

    World.RemoveFog = RemoveFog

    -- Register all world modules
    Core.Modules.Register("world", AntiVoid)
    Core.Modules.Register("world", TimeScale)
    Core.Modules.Register("world", Gravity)
    Core.Modules.Register("world", RemoveFog)

    return World
end)()

-- ============================================================================
-- Tools (src/modules/tools.lua)
-- ============================================================================
local Tools = (function()
    local Core = Vokthos
    local Utils = Core.Utils
    local State = Core.State
    local Iris = Core.Iris
    local Notifications = Core.Notifications
    local Connections = Core.Connections
    local SharedTicker = Core.SharedTicker
    local ModuleRegistry = Core.Modules
    local Commands = Core.Commands
    local Config = Core.Config
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local HttpService = game:GetService("HttpService")
    local LocalPlayer = Players.LocalPlayer

    --[[
    	Tools Modules
    	Fixes: CommandBar connection leak, Dex RCE removal, Core references removed.
    ]]

    local Tools = {}

    local Stats = game:GetService("Stats")

    local function safeConn(module, key, signal, callback)
    	if module[key] and module[key].Connected then
    		module[key]:Disconnect()
    	end
    	module[key] = signal:Connect(callback)
    end

    -- ============================================================================
    -- TP TOOL
    -- ============================================================================
    local TPTool = {
    	name = "TP Tool",
    	category = "tools",
    	enabled = false,
    	_tool = nil,
    }

    function TPTool.onEnable()
    	if TPTool._tool then TPTool._tool:Destroy() end

    	TPTool._tool = Instance.new("Tool")
    	TPTool._tool.Name = "TP Tool"
    	TPTool._tool.RequiresHandle = false
    	TPTool._tool.CanBeDropped = false

    	TPTool._tool.Activated:Connect(function()
    		local mouse = LocalPlayer:GetMouse()
    		local char = Utils.getChar()
    		local hrp = Utils.getRoot(char)
    		if hrp and mouse.Hit then
    			local pos = mouse.Hit.Position + Vector3.new(0, 3, 0)
    			hrp.CFrame = CFrame.new(pos.X, pos.Y, pos.Z, select(4, hrp.CFrame:components()))
    			Utils.breakVelocity()
    			Notifications.Success("TP Tool", "Teleported")
    		end
    	end)

    	TPTool._tool.Parent = LocalPlayer.Backpack
    end

    function TPTool.onDisable()
    	if TPTool._tool then TPTool._tool:Destroy() end
    	TPTool._tool = nil
    end

    function TPTool.draw()
    	State.Set("tools_tptool_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("tools_tptool_enabled"))}))
    end

    Tools.TPTool = TPTool

    -- ============================================================================
    -- DEX EXPLORER (safe local version, no remote code execution)
    -- ============================================================================
    local Dex = {
    	name = "Dex Explorer",
    	category = "tools",
    }

    function Dex.onEnable()
    	Notifications.Info("Dex Explorer", "Use ;dex command or external Dex for full features")
    	Dex.enabled = false
    	State.Set("tools_dex_enabled", false)
    end

    function Dex.onDisable() end

    function Dex.draw()
    	if Iris.Button({"Open Dex Explorer"}) then
    		Dex.onEnable()
    	end
    end

    Tools.Dex = Dex

    -- ============================================================================
    -- BTOOLS
    -- ============================================================================
    local BTools = {
    	name = "BTools",
    	category = "tools",
    	enabled = false,
    	_tools = {},
    }

    function BTools.onEnable()
    	local backpack = LocalPlayer.Backpack
    	local toolTypes = {
    		{"Hammer", "Tool", "Delete", "Delete parts on click"},
    		{"Clone", "Tool", "Clone", "Clone parts on click"},
    		{"Move", "Tool", "Move", "Move parts"},
    		{"Resize", "Tool", "Resize", "Resize parts"},
    	}
    	for _, data in ipairs(toolTypes) do
    		local tool = Instance.new("HopperBin")
    		tool.Name = data[1]
    		tool.BinType = Enum.BinType[data[2]]
    		tool.Parent = backpack
    		table.insert(BTools._tools, tool)
    	end
    end

    function BTools.onDisable()
    	for _, tool in ipairs(BTools._tools) do
    		if tool then tool:Destroy() end
    	end
    	BTools._tools = {}
    end

    function BTools.draw()
    	State.Set("tools_btools_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("tools_btools_enabled"))}))
    end

    Tools.BTools = BTools

    -- ============================================================================
    -- COMMAND BAR (fixed: InputBegan connection leak)
    -- ============================================================================
    local CommandBar = {
    	name = "Command Bar",
    	category = "tools",
    	enabled = false,
    	_gui = nil,
    	_history = {},
    	_historyIndex = 0,
    	_inputConn = nil,
    }

    function CommandBar.onEnable()
    	if CommandBar._gui then CommandBar._gui:Destroy() end

    	CommandBar._gui = Instance.new("ScreenGui")
    	CommandBar._gui.Name = "CommandBar_" .. Utils.randomString(8)
    	CommandBar._gui.ResetOnSpawn = false
    	CommandBar._gui.Parent = CoreGui

    	local frame = Instance.new("Frame")
    	frame.Name = "Main"
    	frame.Size = UDim2.new(0, 400, 0, 40)
    	frame.Position = UDim2.new(0.5, -200, 1, -60)
    	frame.BackgroundColor3 = Color3.fromRGB(20, 20, 30)
    	frame.BackgroundTransparency = 0.1
    	frame.BorderSizePixel = 0
    	frame.Parent = CommandBar._gui
    	Instance.new("UICorner", frame).CornerRadius = UDim.new(0, 8)

    	local stroke = Instance.new("UIStroke")
    	stroke.Color = Color3.fromRGB(100, 100, 255)
    	stroke.Thickness = 1
    	stroke.Transparency = 0.5
    	stroke.Parent = frame

    	local textBox = Instance.new("TextBox")
    	textBox.Name = "Input"
    	textBox.Size = UDim2.new(1, -20, 1, -10)
    	textBox.Position = UDim2.new(0, 10, 0, 5)
    	textBox.BackgroundTransparency = 1
    	textBox.Text = ""
    	textBox.PlaceholderText = "Command (prefix: ;) ..."
    	textBox.TextColor3 = Color3.new(1, 1, 1)
    	textBox.TextSize = 16
    	textBox.Font = Enum.Font.Gotham
    	textBox.TextXAlignment = Enum.TextXAlignment.Left
    	textBox.ClearTextOnFocus = false
    	textBox.Parent = frame

    	-- Auto-complete suggestions
    	local suggestions = Instance.new("ScrollingFrame")
    	suggestions.Name = "Suggestions"
    	suggestions.Size = UDim2.new(0, 400, 0, 150)
    	suggestions.Position = UDim2.new(0.5, -200, 1, -190)
    	suggestions.BackgroundColor3 = Color3.fromRGB(15, 15, 25)
    	suggestions.BackgroundTransparency = 0.05
    	suggestions.BorderSizePixel = 0
    	suggestions.Visible = false
    	suggestions.ScrollBarThickness = 4
    	suggestions.Parent = CommandBar._gui
    	Instance.new("UICorner", suggestions).CornerRadius = UDim.new(0, 6)
    	Instance.new("UIListLayout", suggestions).Padding = UDim.new(0, 2)

    	textBox.Focused:Connect(function()
    		suggestions.Visible = true
    	end)

    	textBox.FocusLost:Connect(function(enterPressed)
    		suggestions.Visible = false
    		if enterPressed and textBox.Text ~= "" then
    			Commands.Execute(textBox.Text)
    			table.insert(CommandBar._history, 1, textBox.Text)
    			if #CommandBar._history > 30 then table.remove(CommandBar._history) end
    			CommandBar._historyIndex = 0
    			textBox.Text = ""
    		end
    	end)

    	textBox:GetPropertyChangedSignal("Text"):Connect(function()
    		local input = textBox.Text:lower()
    		for _, child in ipairs(suggestions:GetChildren()) do
    			if child:IsA("TextButton") then child:Destroy() end
    		end
    		if input == "" then return end
    		local sugs = Commands.GetSuggestions(input)
    		for _, cmd in ipairs(sugs) do
    			local btn = Instance.new("TextButton")
    			btn.Size = UDim2.new(1, -10, 0, 25)
    			btn.BackgroundTransparency = 1
    			btn.Text = cmd
    			btn.TextColor3 = Color3.new(1, 1, 1)
    			btn.TextSize = 14
    			btn.Font = Enum.Font.Gotham
    			btn.TextXAlignment = Enum.TextXAlignment.Left
    			btn.Parent = suggestions
    			btn.MouseButton1Click:Connect(function()
    				textBox.Text = cmd .. " "
    				textBox:CaptureFocus()
    			end)
    		end
    	end)

    	-- History navigation - FIXED: store connection for cleanup
    	if CommandBar._inputConn then CommandBar._inputConn:Disconnect() end
    	CommandBar._inputConn = UserInputService.InputBegan:Connect(function(input, gp)
    		if gp then return end
    		if not textBox:IsFocused() then return end
    		if input.KeyCode == Enum.KeyCode.Up then
    			CommandBar._historyIndex = math.min(CommandBar._historyIndex + 1, #CommandBar._history)
    			if CommandBar._historyIndex > 0 then
    				textBox.Text = CommandBar._history[CommandBar._historyIndex]
    			end
    		elseif input.KeyCode == Enum.KeyCode.Down then
    			CommandBar._historyIndex = math.max(CommandBar._historyIndex - 1, 0)
    			if CommandBar._historyIndex > 0 then
    				textBox.Text = CommandBar._history[CommandBar._historyIndex]
    			else
    				textBox.Text = ""
    			end
    		elseif input.KeyCode == Enum.KeyCode.Tab then
    			local sugs = Commands.GetSuggestions(textBox.Text:lower())
    			if #sugs > 0 then
    				textBox.Text = sugs[1] .. " "
    			end
    		end
    	end)
    end

    function CommandBar.onDisable()
    	if CommandBar._inputConn then CommandBar._inputConn:Disconnect() CommandBar._inputConn = nil end
    	if CommandBar._gui then CommandBar._gui:Destroy() end
    	CommandBar._gui = nil
    	CommandBar._history = {}
    	CommandBar._historyIndex = 0
    end

    function CommandBar.draw()
    	State.Set("tools_commandbar_enabled", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("tools_commandbar_enabled"))}))
    	if State.Get("tools_commandbar_enabled") then
    		Iris.Text({"Prefix: ; | Tab: autocomplete | Up/Down: history"})
    		if Iris.Button({"Test Command"}) then
    			Commands.Execute("speed 50")
    		end
    	end
    end

    Tools.CommandBar = CommandBar

    -- ============================================================================
    -- SERVER INFO
    -- ============================================================================
    local ServerInfo = {
    	name = "Server Info",
    	category = "tools",
    }

    function ServerInfo.onEnable()
    	ServerInfo.enabled = false
    	State.Set("tools_serverinfo_enabled", false)

    	local info = {
    		"Server Info:",
    		"  JobId: " .. game.JobId,
    		"  PlaceId: " .. game.PlaceId,
    		"  Players: " .. #Players:GetPlayers() .. "/" .. Players.MaxPlayers,
    		"  Ping: " .. math.floor(Stats.Network.ServerStatsItem["Data Ping"]:GetValue()) .. "ms",
    	}
    	Notifications.Info("Server Info", table.concat(info, "\n"), 10)
    end

    function ServerInfo.onDisable() end

    function ServerInfo.draw()
    	if Iris.Button({"Show Server Info"}) then
    		ServerInfo.onEnable()
    	end
    end

    Tools.ServerInfo = ServerInfo

    -- ============================================================================
    -- REJOIN
    -- ============================================================================
    local Rejoin = {
    	name = "Rejoin",
    	category = "tools",
    }

    function Rejoin.onEnable()
    	Rejoin.enabled = false
    	State.Set("tools_rejoin_enabled", false)
    	TeleportService:Teleport(game.PlaceId, LocalPlayer)
    end

    function Rejoin.onDisable() end

    function Rejoin.draw()
    	if Iris.Button({"Rejoin Server"}) then
    		Rejoin.onEnable()
    	end
    end

    Tools.Rejoin = Rejoin

    -- Register all tools modules
    Core.Modules.Register("tools", TPTool)
    Core.Modules.Register("tools", Dex)
    Core.Modules.Register("tools", BTools)
    Core.Modules.Register("tools", CommandBar)
    Core.Modules.Register("tools", ServerInfo)
    Core.Modules.Register("tools", Rejoin)

    return Tools
end)()

-- ============================================================================
-- Settings (src/modules/settings.lua)
-- ============================================================================
local Settings = (function()
    local Core = Vokthos
    local Utils = Core.Utils
    local State = Core.State
    local Iris = Core.Iris
    local Notifications = Core.Notifications
    local Connections = Core.Connections
    local SharedTicker = Core.SharedTicker
    local ModuleRegistry = Core.Modules
    local Commands = Core.Commands
    local Config = Core.Config
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local HttpService = game:GetService("HttpService")
    local LocalPlayer = Players.LocalPlayer

    --[[
    	Settings Modules
    	Fixes: No Core references.
    ]]

    local Settings = {}

    -- ============================================================================
    -- UI SETTINGS
    -- ============================================================================
    local UISettings = {
    	name = "UI Settings",
    	category = "settings",
    }

    function UISettings.onEnable() end
    function UISettings.onDisable() end

    function UISettings.draw()
    	Iris.Tree({"Theme"}, function()
    		local themes = {"Dark", "Light", "Violet"}
    		Iris.Combo({"Theme", themes}, {index = Iris.State(State.Get("ui_theme"))})
    	end)

    	Iris.Tree({"Notifications"}, function()
    		State.Set("ui_notifications", Iris.Checkbox({"Enabled"}, {isChecked = Iris.State(State.Get("ui_notifications"))}))
    		if State.Get("ui_notifications") then
    			Iris.SliderNum({"Duration", 1, 10, "%.1fs"}, {number = Iris.State(State.Get("ui_notificationDuration"))})
    			Iris.SliderNum({"Max Visible", 1, 10}, {number = Iris.State(State.Get("ui_maxNotifications"))})
    		end
    	end)

    	Iris.Tree({"Window"}, function()
    		State.Set("ui_auto_save", Iris.Checkbox({"Auto-save Config"}, {isChecked = Iris.State(State.Get("ui_auto_save"))}))
    		if Iris.Button({"Reset Window Position"}) then
    			State.Set("window_pos", Vector2.new(100, 100))
    			Notifications.Info("Settings", "Window position reset")
    		end
    		if Iris.Button({"Reset Window Size"}) then
    			State.Set("window_size", Vector2.new(650, 520))
    			Notifications.Info("Settings", "Window size reset")
    		end
    	end)
    end

    Settings.UISettings = UISettings

    -- ============================================================================
    -- CONFIG MANAGEMENT
    -- ============================================================================
    local ConfigManager = {
    	name = "Config Management",
    	category = "settings",
    }

    function ConfigManager.onEnable() end
    function ConfigManager.onDisable() end

    function ConfigManager.draw()
    	Iris.Text({"Current Config: " .. (State.Get("config_name", "default"))})
    	Iris.Separator()

    	Iris.Tree({"Load Config"}, function()
    		local configs = Config.List()
    		for _, name in ipairs(configs) do
    			if Iris.Selectable({name}, {index = Iris.State(name == State.Get("config_name"))}) then
    				if name == "default" or name == "config" then
    					Config.Load()
    				else
    					Config.LoadPreset(name)
    				end
    				State.Set("config_name", name)
    				Notifications.Success("Config", "Loaded: " .. name)
    			end
    		end
    	end)

    	Iris.Tree({"Save As"}, function()
    		local newName = State.Get("config_newName", "")
    		Iris.InputText({"Name"}, {text = Iris.State(State.Get("config_newName"))})
    		if Iris.Button({"Save"}) and newName ~= "" then
    			Config.SavePreset(newName)
    			State.Set("config_name", newName)
    			Notifications.Success("Config", "Saved as: " .. newName)
    		end
    	end)

    	Iris.Tree({"Delete"}, function()
    		local configs = Config.List()
    		for _, name in ipairs(configs) do
    			if name ~= "default" and name ~= "config" then
    				if Iris.Button({"Delete: " .. name}) then
    					Config.DeletePreset(name)
    					Notifications.Success("Config", "Deleted: " .. name)
    				end
    			end
    		end
    	end)

    	Iris.Separator()

    	if Iris.Button({"Export to Clipboard"}) then
    		local data = {
    			version = 3,
    			metadata = {name = "export", created = Utils.formatTime("!%Y-%m-%dT%H:%M:%SZ")},
    			modules = State.GetAll(),
    		}
    		local json = HttpService:JSONEncode(data)
    		if setclipboard then
    			setclipboard(json)
    			Notifications.Success("Config", "Exported to clipboard")
    		else
    			Notifications.Warning("Config", "Clipboard not supported")
    		end
    	end

    	if Iris.Button({"Import from Clipboard"}) then
    		if getclipboard then
    			local json = getclipboard()
    			local ok, data = pcall(function()
    				return HttpService:JSONDecode(json)
    			end)
    			if ok and data and data.modules then
    				State.LoadFromTable(data.modules)
    				Notifications.Success("Config", "Imported successfully")
    			else
    				Notifications.Error("Config", "Invalid config data")
    			end
    		else
    			Notifications.Error("Config", "Clipboard not supported")
    		end
    	end

    	if Iris.Button({"Save Current"}) then
    		Config.Save()
    		Notifications.Success("Config", "Auto-saved")
    	end
    end

    Settings.ConfigManager = ConfigManager

    -- ============================================================================
    -- ABOUT
    -- ============================================================================
    local About = {
    	name = "About",
    	category = "settings",
    }

    function About.onEnable() end
    function About.onDisable() end

    function About.draw()
    	Iris.Text({"Vokthos NXx Hub - Iris Edition"})
    	Iris.Text({"Version: 2.0.0"})
    	Iris.Text({"UI Framework: SirMallard/Iris (Dear ImGui)"})
    	Iris.Separator()

    	Iris.Text({"Inspired by:"})
    	Iris.BulletText({"Infinite Yield (command system)"})
    	Iris.BulletText({"Nameless Admin (plugin architecture, UI patterns)"})
    	Iris.Separator()

    	Iris.Text({"Features:"})
    	Iris.BulletText({"50+ modules across 7 categories"})
    	Iris.BulletText({"Immediate-mode UI (zero bloat)"})
    	Iris.BulletText({"Persistent JSON config system"})
    	Iris.BulletText({"Command system with aliases/history"})
    	Iris.BulletText({"Plugin architecture"})
    	Iris.BulletText({"Typed notification system"})
    	Iris.Separator()

    	Iris.Text({"Links:"})
    	if Iris.Button({"Discord"}) then
    		if setclipboard then setclipboard("https://discord.gg/zzjYhtMGFD") end
    		Notifications.Info("About", "Discord link copied")
    	end
    	if Iris.Button({"Iris GitHub"}) then
    		if setclipboard then setclipboard("https://github.com/SirMallard/Iris") end
    		Notifications.Info("About", "Iris repo copied")
    	end
    	if Iris.Button({"Vokthos GitHub"}) then
    		if setclipboard then setclipboard("https://github.com/Vokthos") end
    		Notifications.Info("About", "Vokthos repo copied")
    	end
    end

    Settings.About = About

    -- Register all settings modules
    Core.Modules.Register("settings", UISettings)
    Core.Modules.Register("settings", ConfigManager)
    Core.Modules.Register("settings", About)

    return Settings
end)()

-- ============================================================================
-- MAIN ENTRY POINT (main.lua)
-- ============================================================================
--[[
	Vokthos NXx Hub - Iris Edition
	Main entry point with dependency injection
]]

local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local HttpService = game:GetService("HttpService")

-- ============================================================================
-- CORE LOADING (no globals - pass via dependency injection)
-- ============================================================================
local Core = Vokthos

if not Core then
	error("[Vokthos] Core initialization failed")
	return
end

local Utils = Core.Utils
local State = Core.State
local Config = Core.Config
local Notifications = Core.Notifications
local Commands = Core.Commands
local Plugins = Core.Plugins
local Modules = Core.Modules
local Iris = Core.Iris
local Connections = Core.Connections

    -- SharedTicker defined in Core

-- ============================================================================
-- MODULE LOADING (dependency injection - no _G access)
-- ============================================================================
    -- LoadModule removed: modules loaded inline above

-- Load UI module
    -- modules loaded inline above

-- Load all modules with dependency injection
    -- modules loaded inline above
    -- modules loaded inline above
    -- modules loaded inline above
    -- modules loaded inline above
    -- modules loaded inline above
    -- modules loaded inline above
    -- modules loaded inline above

-- ============================================================================
-- UI INITIALIZATION
-- ============================================================================
if Iris then
	UI.Initialize(Core)
	
	local renderConn
	renderConn = Connections.RunServiceConnect("RenderStepped", function()
		if not Iris or not State.Get("ui_open", false) then return end
		local ok, err = pcall(function()
			Iris.Init()
			UI.Render(Core)
			Iris.End()
		end)
		if not ok then
			warn("[Vokthos] Render error:", err)
		end
	end)
	
	-- Auto-start Iris on first frame
	Connections.Spawn(function()
		task.wait(0.5)
		if Iris then
			local ok, err = pcall(function()
				Iris.Init()
				State.Set("ui_initialized", true)
				Iris.End()
			end)
			if not ok then
				warn("[Vokthos] Iris auto-start failed:", err)
			end
		end
	end)
end

-- ============================================================================
-- KEYBIND: INSERT to toggle UI
-- ============================================================================
Connections.Connect(UserInputService.InputBegan, function(input, gameProcessed)
	if gameProcessed then return end
	if input.KeyCode == Enum.KeyCode.Insert then
		local isOpen = State.Toggle("ui_open")
		if isOpen then
			Notifications.Info("Vokthos", "UI opened (INSERT to close)")
		else
			Notifications.Info("Vokthos", "UI closed (INSERT to open)")
		end
	end
	
	-- Command bar toggle with ; key
	if input.KeyCode == Enum.KeyCode.Backtick then
		local isOpen = State.Get("ui_open", false)
		if isOpen and State.Get("tools_commandbar_enabled", false) then
			Notifications.Info("Cmd", "Command bar active")
		end
	end
end)

-- ============================================================================
-- BUILT-IN COMMANDS (registered after core + modules loaded)
-- ============================================================================
local function onModule(moduleName: string)
	for _, cat in pairs(Modules.GetByCategory(moduleName)) do
		return cat
	end
	return nil
end

Commands.Register("speed", {"sp", "ws", "walkspeed"}, function(args)
	local val = tonumber(args[1]) or 50
	State.Set("movement_speed_enabled", true)
	State.Set("movement_speed_value", val)
	if Movement.Speed then
		Movement.Speed.speed = val
		Movement.Speed.onEnable()
	end
	Notifications.Success("Speed", "WalkSpeed: " .. val)
end, "Set walk speed")

Commands.Register("noclip", {"nc"}, function(args)
	State.Set("movement_noclip_enabled", true)
	if Movement.Noclip then
		Movement.Noclip.onEnable()
	end
	Notifications.Success("Noclip", "Enabled")
end, "Enable noclip")

Commands.Register("fly", {"fl"}, function(args)
	local val = tonumber(args[1]) or 50
	State.Set("movement_fly_enabled", true)
	State.Set("movement_fly_speed", val)
	if Movement.Fly then
		Movement.Fly.speed = val
		Movement.Fly.onEnable()
	end
	Notifications.Success("Fly", "Speed: " .. val)
end, "Enable fly")

Commands.Register("god", {"godmode", "gm"}, function(args)
	State.Set("player_godmode_enabled", true)
	if Player.GodMode then Player.GodMode.onEnable() end
	Notifications.Success("God", "Enabled")
end, "Enable god mode")

Commands.Register("invisible", {"invis", "inv"}, function(args)
	State.Set("player_invisible_enabled", true)
	if Player.Invisible then Player.Invisible.onEnable() end
	Notifications.Success("Invisible", "Enabled")
end, "Enable invisible")

Commands.Register("tp", {"teleport"}, function(args)
	local targetName = args[1]
	if not targetName then
		Notifications.Error("TP", "Usage: tp <player>")
		return
	end
	for _, p in ipairs(game:GetService("Players"):GetPlayers()) do
		if p.Name:lower():find(targetName:lower(), 1, true) == 1 then
			local char = Utils.getChar()
			local targetChar = p.Character
			if char and targetChar then
				local hrp = Utils.getRoot(char)
				local targetHrp = Utils.getRoot(targetChar)
				if hrp and targetHrp then
					hrp.CFrame = targetHrp.CFrame + Vector3.new(3, 1, 0)
					Notifications.Success("TP", "Teleported to " .. p.Name)
				end
			end
			return
		end
	end
	Notifications.Error("TP", "Player not found: " .. targetName)
end, "Teleport to player")

Commands.Register("bring", {"br"}, function(args)
	local targetName = args[1]
	if not targetName then
		Notifications.Error("Bring", "Usage: bring <player>")
		return
	end
	for _, p in ipairs(game:GetService("Players"):GetPlayers()) do
		if p.Name:lower():find(targetName:lower(), 1, true) == 1 then
			local char = Utils.getChar()
			local targetChar = p.Character
			if char and targetChar then
				local hrp = Utils.getRoot(char)
				local targetHrp = Utils.getRoot(targetChar)
				if hrp and targetHrp then
					targetHrp.CFrame = hrp.CFrame + Vector3.new(3, 1, 0)
					Notifications.Success("Bring", "Brought " .. p.Name)
				end
			end
			return
		end
	end
	Notifications.Error("Bring", "Player not found: " .. targetName)
end, "Bring player to you")

Commands.Register("kill", {"kl"}, function(args)
	local targetName = args[1]
	if not targetName then
		Notifications.Error("Kill", "Usage: kill <player>")
		return
	end
	for _, p in ipairs(game:GetService("Players"):GetPlayers()) do
		if p.Name:lower():find(targetName:lower(), 1, true) == 1 then
			local hum = Utils.getHumanoid(p.Character)
			if hum then hum.Health = 0 end
			Notifications.Success("Kill", "Killed " .. p.Name)
			return
		end
	end
	Notifications.Error("Kill", "Player not found: " .. targetName)
end, "Kill player")

Commands.Register("reset", {"re", "die"}, function(args)
	if Player.Reset then Player.Reset.onEnable() end
end, "Reset character")

Commands.Register("rejoin", {"rj"}, function(args)
	Tools.Rejoin.onEnable()
end, "Rejoin server")

Commands.Register("cmds", {"commands", "help"}, function(args)
	local cmds = {}
	for name, cmd in pairs(Commands.Commands) do
		table.insert(cmds, name .. " " .. (cmd.info or ""))
	end
	Notifications.Info("Commands", table.concat(cmds, "\n"), 15)
end, "Show commands list")

Commands.Register("config", {"cfg"}, function(args)
	local subcmd = args[1]
	if subcmd == "load" and args[2] then
		if args[2] == "default" then
			Config.Load()
		else
			Config.LoadPreset(args[2])
		end
		Notifications.Success("Config", "Loaded: " .. args[2])
	elseif subcmd == "save" and args[2] then
		Config.SavePreset(args[2])
		Notifications.Success("Config", "Saved as: " .. args[2])
	elseif subcmd == "list" then
		local configs = Config.List()
		Notifications.Info("Configs", table.concat(configs, ", "), 10)
	else
		Notifications.Info("Config", "Usage: config load|save|list <name>")
	end
end, "Config management")

Commands.Register("prefix", function(args)
	Notifications.Info("Prefix", "Current prefix: ; (use prefix command to talk)")
end, "Show current prefix")

-- ============================================================================
-- CLEAN SHUTDOWN
-- ============================================================================
game:GetService("RunService").Heartbeat:Connect(function() end) -- keep alive

-- Cleanup on script shutdown
local function Cleanup()
	Modules.DisableAll()
	Connections.Cleanup()
end

-- ============================================================================
-- READY
-- ============================================================================
State.Set("ui_open", false)
State.Set("ui_initialized", false)
State.Set("ui_auto_save", true)

print("[Vokthos] Iris Edition loaded!")
print("[Vokthos] Press INSERT to toggle UI")
print("[Vokthos] Type ;help for commands")
print("[Vokthos] " .. #Modules.GetAll() .. " modules registered")
print("[Vokthos] " .. #Commands.Commands .. " commands registered")

return Core