pulse-rb 1.2.24

package/pulse/helpers/world.lua

@@ -0,0 +1,51 @@
+-- ── Pulse.World ──────────────────────────────────────────────────────────────
+-- Safe workspace/service navigation — no nil-index crashes.
+-- Usage:
+--   local folder = Pulse.World.find("Titans", "Alive")
+--   local list   = Pulse.World.children("Titans", "Alive")
+--   local svc    = Pulse.World.service("TweenService")
+--   local child  = Pulse.World.await(model, "HumanoidRootPart", 5)
+
+Pulse.World = (function()
+    local W = {}
+
+    -- Navigate workspace by a sequence of child names.
+    -- Returns the final Instance, or nil if any step is missing.
+    function W.find(...)
+        local node = workspace
+        for _, name in ipairs({...}) do
+            if not node then return nil end
+            local ok, child = pcall(function() return node:FindFirstChild(name) end)
+            if not ok or not child then return nil end
+            node = child
+        end
+        return node
+    end
+
+    -- Like find(), but returns the children of the final node.
+    -- Returns {} if the path doesn't exist.
+    function W.children(...)
+        local node = W.find(...)
+        if not node then return {} end
+        local ok, list = pcall(function() return node:GetChildren() end)
+        return ok and list or {}
+    end
+
+    -- Safely get a game service by name.
+    function W.service(name)
+        local ok, svc = pcall(game.GetService, game, name)
+        return ok and svc or nil
+    end
+
+    -- Wait for a named child to appear (wraps WaitForChild with a timeout).
+    -- Returns the child Instance or nil on timeout / error.
+    function W.await(parent, name, timeout)
+        if typeof(parent) ~= "Instance" then return nil end
+        local ok, result = pcall(function()
+            return parent:WaitForChild(name, timeout or 10)
+        end)
+        return ok and result or nil
+    end
+
+    return W
+end)()

package/pulse/runtime.lua

@@ -0,0 +1,343 @@
+-- ============================================================
+-- Pulse Runtime  v0.1.0
+-- Injected automatically by rb build before all user modules.
+-- Do not require() this file — the compiler handles injection.
+-- Pulse.* helpers are injected from rb/pulse/helpers/ after this.
+-- ============================================================
+
+-- ── Signal ───────────────────────────────────────────────────────────────────
+-- Reactive atom. Call with no args to read, one arg to write.
+-- signal:onChange(fn) → returns unsubscribe function.
+
+local function Signal(default)
+    local _value = default
+    local _subs  = {}
+
+    local s = {}
+
+    function s:get() return _value end
+
+    function s:set(new)
+        if new == _value then return end
+        _value = new
+        for i = #_subs, 1, -1 do
+            local ok, err = pcall(_subs[i], new)
+            if not ok then
+                local msg = "signal subscriber error: " .. tostring(err)
+                if Pulse.Log then
+                    Pulse.Log.error("signal", msg, { signal = s._name or "?" })
+                else
+                    warn("[Pulse] " .. msg)
+                end
+            end
+        end
+    end
+
+    function s:onChange(fn)
+        table.insert(_subs, fn)
+        return function()
+            for i, sub in ipairs(_subs) do
+                if sub == fn then table.remove(_subs, i) return end
+            end
+        end
+    end
+
+    setmetatable(s, {
+        __call = function(_, ...)
+            if select("#", ...) == 0 then return s:get() end
+            s:set(...)
+        end
+    })
+
+    return s
+end
+
+-- ── Computed ─────────────────────────────────────────────────────────────────
+-- Derived cached value. Re-evaluates when :invalidate() is called,
+-- or when any Signal passed via :track(signal) changes.
+
+local function Computed(fn)
+    local _cache = nil
+    local _dirty = true
+    local _unsubs = {}
+
+    local c = {}
+
+    function c:get()
+        if _dirty then
+            _cache = fn()
+            _dirty = false
+        end
+        return _cache
+    end
+
+    function c:track(signal)
+        table.insert(_unsubs, signal:onChange(function()
+            _dirty = true
+        end))
+        return c
+    end
+
+    function c:destroy()
+        for _, unsub in ipairs(_unsubs) do pcall(unsub) end
+        _unsubs = {}
+    end
+
+    setmetatable(c, { __call = function() return c:get() end })
+    return c
+end
+
+-- ── PulseEvent ───────────────────────────────────────────────────────────────
+-- Lightweight event bus. fire(...) notifies all listeners.
+-- connect(fn) → returns disconnect function.
+
+local function PulseEvent(name)
+    local _listeners = {}
+    local e = {}
+    e._isPulseEvent = true
+    e._name = name or "?"
+
+    function e:connect(fn)
+        table.insert(_listeners, fn)
+        return function()
+            for i, l in ipairs(_listeners) do
+                if l == fn then table.remove(_listeners, i) return end
+            end
+        end
+    end
+
+    function e:fire(...)
+        for i = #_listeners, 1, -1 do
+            local ok, err = pcall(_listeners[i], ...)
+            if not ok then
+                local msg = "event listener error: " .. tostring(err)
+                if Pulse.Log then
+                    Pulse.Log.error("event", msg, { event = e._name })
+                else
+                    warn("[Pulse] event '" .. e._name .. "' error: " .. tostring(err))
+                end
+            end
+        end
+    end
+
+    setmetatable(e, { __call = function(_, ...) e:fire(...) end })
+    return e
+end
+
+-- ── Component ────────────────────────────────────────────────────────────────
+-- Behavior service with lifecycle, connection tracking, and task management.
+
+local _Registry    = {}   -- flat: { "Aimbot" = component, ... }
+local _NamespaceReg = {}  -- nested: { "Shifter" = { "Combat" = component } }
+
+local function Component(name)
+    local c = {}
+    c._isComponent  = true
+    c._name         = name
+    c._connections  = {}
+    c._tasks        = {}
+    c._watchers     = {}
+    c._mounted      = false
+
+    -- Connection management
+    function c:bind(key, connection)
+        if self._connections[key] then
+            pcall(function() self._connections[key]:Disconnect() end)
+        end
+        self._connections[key] = connection
+    end
+
+    function c:unbind(key)
+        if self._connections[key] then
+            pcall(function() self._connections[key]:Disconnect() end)
+            self._connections[key] = nil
+        end
+    end
+
+    function c:unbindAll()
+        for _, conn in pairs(self._connections) do
+            pcall(function() conn:Disconnect() end)
+        end
+        self._connections = {}
+    end
+
+    -- Signal watching (auto-cleaned on unmount)
+    function c:watch(signal, fn)
+        local unsub = signal:onChange(fn)
+        table.insert(self._watchers, unsub)
+        return unsub
+    end
+
+    -- Delayed tasks (auto-cancelled on unmount)
+    function c:task(delay, fn)
+        local cancelled = false
+        table.insert(self._tasks, function() cancelled = true end)
+        task.delay(delay, function()
+            if cancelled then return end
+            local ok, err = pcall(fn)
+            if not ok then
+                local msg = "after-block error: " .. tostring(err)
+                if Pulse.Log then
+                    Pulse.Log.error("component", msg, { component = name })
+                else
+                    warn("[Pulse] " .. name .. " " .. msg)
+                end
+            end
+        end)
+    end
+
+    -- Respawn listener (bound to connection tracker)
+    function c:onRespawn(fn)
+        local key = "__respawn_" .. name
+        local existing = self._connections[key]
+        if existing then
+            pcall(function() existing:Disconnect() end)
+        end
+        self._connections[key] = game:GetService("Players").LocalPlayer
+            .CharacterAdded:Connect(fn)
+    end
+
+    -- Lifecycle
+    function c:mount()
+        if self._mounted then return end
+        self._mounted = true
+        if Pulse.Log then Pulse.Log.trace("component", name .. " mounted") end
+    end
+
+    function c:unmount()
+        if not self._mounted then return end
+        self._mounted = false
+        self:unbindAll()
+        for _, unsub in ipairs(self._watchers) do pcall(unsub) end
+        self._watchers = {}
+        for _, cancel in ipairs(self._tasks) do pcall(cancel) end
+        self._tasks = {}
+        if Pulse.Log then Pulse.Log.trace("component", name .. " unmounted") end
+    end
+
+    -- Register: support "Shifter.Combat" style namespace
+    local parts = {}
+    for part in name:gmatch("[^%.]+") do table.insert(parts, part) end
+
+    _Registry[name] = c
+
+    local node = _NamespaceReg
+    for i, part in ipairs(parts) do
+        if i == #parts then
+            node[part] = c
+        else
+            node[part] = node[part] or {}
+            node = node[part]
+        end
+    end
+
+    return c
+end
+
+-- ── Store ────────────────────────────────────────────────────────────────────
+-- Shared state with signals + actions.
+-- Built by transpiler-generated setup calls; this is the constructor.
+
+local _Stores = {}
+
+local function Store(name)
+    local s = {}
+    s._isStore  = true
+    s._name     = name
+    s._signals  = {}
+    s._actions  = {}
+
+    -- Add a signal slice
+    function s:addSignal(key, default)
+        local sig = Signal(default)
+        sig._name = name .. "." .. key
+        self[key]          = sig
+        self._signals[key] = sig
+    end
+
+    -- Register an action (only way to write store state from outside)
+    function s:addAction(key, fn)
+        self[key]          = fn
+        self._actions[key] = fn
+    end
+
+    _Stores[name] = s
+    return s
+end
+
+-- ── Framework character globals ──────────────────────────────────────────────
+-- Always available in on-blocks via transpiler-generated local mirrors.
+-- Live lookups — never cached, always correct across respawn.
+
+local _Players     = game:GetService("Players")
+local _RunService  = game:GetService("RunService")
+local _UIS         = game:GetService("UserInputService")
+local _VIM         = game:GetService("VirtualInputManager")
+local _LocalPlayer = _Players.LocalPlayer
+
+-- ── Destroy ──────────────────────────────────────────────────────────────────
+-- _PulseDestroy()    — stop all components, tear down UI, clear _G entry.
+-- _PulseOnDestroy(fn) — register a teardown callback (UI adapter uses this).
+
+local _destroyCallbacks = {}
+
+local function _PulseRegisterDestroy(fn)
+    table.insert(_destroyCallbacks, fn)
+end
+
+local function _PulseDestroyAll()
+    -- Teardown callbacks first (UI must be destroyed before connections drop)
+    for _, cb in ipairs(_destroyCallbacks) do pcall(cb) end
+    _destroyCallbacks = {}
+    -- Unmount every component: disconnects all Roblox connections + cancels tasks
+    for _, comp in pairs(_Registry) do
+        pcall(function() comp:unmount() end)
+    end
+    _G.__AOT_R_DESTROY = nil
+end
+
+-- ── Pulse namespace ──────────────────────────────────────────────────────────
+-- Pulse.* helpers are injected from rb/pulse/helpers/ immediately after this.
+
+local Pulse = {}
+
+-- ── Global exports ───────────────────────────────────────────────────────────
+
+Signal      = Signal
+Computed    = Computed
+PulseEvent  = PulseEvent
+Component   = Component
+Store       = Store
+Components  = _NamespaceReg     -- Components.Aimbot.enabled()
+Pulse       = Pulse              -- Pulse.Log / .Draw / .Cache / .Track / .World / .Aim / .Memory / …
+
+-- Internal accessors used by transpiler-generated code.
+-- Read _LocalPlayer.Character directly every call — no stale cache after respawn.
+_PulseGetChar     = function()
+    return _LocalPlayer.Character
+end
+_PulseGetHRP      = function()
+    local c = _LocalPlayer.Character
+    return c and c:FindFirstChild("HumanoidRootPart")
+end
+_PulseGetHumanoid = function()
+    local c = _LocalPlayer.Character
+    return c and c:FindFirstChild("Humanoid")
+end
+_PulseGetAlive    = function()
+    local c = _LocalPlayer.Character
+    local h = c and c:FindFirstChild("Humanoid")
+    return h ~= nil and h.Health > 0
+end
+
+-- RS / UIS shortcuts used in transpiler-generated bind calls
+_PulseRS  = _RunService
+_PulseUIS = _UIS
+
+-- Destroy API — used by Settings page button and re-execution guard
+_PulseOnDestroy = _PulseRegisterDestroy
+_PulseDestroy   = _PulseDestroyAll
+
+-- Ordered list of { type, id, value } entries populated by transpiler-generated code.
+-- Consumed by the compiler-generated defaults runner at end of script.
+_PULSE_DEFAULTS = {}

package/pulse/ui/linoria_settings.lua

@@ -0,0 +1,55 @@
+-- [pulse/ui/linoria_settings.lua]
+-- Framework-managed Settings tab for Linoria builds.
+-- Injected automatically by the compiler when ui_library = "linoria".
+-- Do not copy this file into src/ — edit it here in rb/pulse/ui/.
+do
+    local SettingsTab = _GetTab("Settings")
+
+    _ThemeManager:SetLibrary(_Library)
+    _SaveManager:SetLibrary(_Library)
+
+    _SaveManager:IgnoreThemeSettings()
+    _SaveManager:SetIgnoreIndexes({ "MenuKeybind" })
+
+    -- Folder names come from folder = "..." in layout.rblua
+    _ThemeManager:SetFolder(_PULSE_FOLDER)
+    _SaveManager:SetFolder(_PULSE_FOLDER .. "/configs")
+
+    _ThemeManager:ApplyToTab(SettingsTab)
+    _SaveManager:BuildConfigSection(SettingsTab)
+
+    local gb_menu = SettingsTab:AddLeftGroupbox("Menu Settings")
+    gb_menu:AddButton("Destroy UI", function() _PulseDestroy() end)
+    gb_menu:AddLabel("Menu bind"):AddKeyPicker("MenuKeybind", {
+        Default = _PULSE_TOGGLE_KEY,
+        NoUI    = false,
+        Text    = "Menu keybind",
+    })
+    _Library.ToggleKeybind = Options.MenuKeybind
+
+    -- Performance — rendered directly (multi-dropdown requires a direct Linoria call)
+    local gb_perf = SettingsTab:AddRightGroupbox("Performance")
+    gb_perf:AddLabel("Removes objects every 1 second.")
+    gb_perf:AddLabel("Safe to toggle mid-session.")
+    gb_perf:AddBlank(4)
+    gb_perf:AddToggle("Perf_enabled", {
+        Text     = "Enabled",
+        Default  = false,
+        Tooltip  = "Start/stop all selected cleanups",
+        Callback = function(v) Performance.enabled(v) end,
+    })
+    Performance.enabled:onChange(function(v)
+        local t = Toggles and Toggles["Perf_enabled"]
+        if t then t:SetValue(v) end
+    end)
+    gb_perf:AddDropdown("Perf_selected", {
+        Text     = "Remove",
+        Values   = {"Dead Titans","Decor","HQ Decor","Rocks","Grass","Trees","Civilians","Buildings"},
+        Default  = {"Dead Titans"},
+        Multi    = true,
+        Tooltip  = "Objects removed every second while Enabled is on",
+        Callback = function(v) Performance.selected(v) end,
+    })
+
+    _SaveManager:LoadAutoloadConfig()
+end

package/pulse/ui/windui_settings.lua

@@ -0,0 +1,87 @@
+-- [pulse/ui/windui_settings.lua]
+-- Framework-managed Settings tab for Wind UI builds.
+-- Injected automatically by the compiler when ui_library = "windui".
+-- Do not copy this file into src/ — edit it here in rb/pulse/ui/.
+do
+    -- ── Appearance ────────────────────────────────────────────────────────────
+    local gb_appear = _GetGroupbox("Settings", "left", "Appearance")
+
+    -- Theme list: live from WindUI (picks up custom themes from layout too),
+    -- with a static fallback for all 16 built-in names if GetThemes() is unavailable.
+    local _themeValues = _UIAdapter:GetThemeNames()
+        or { "Amber","CottonCandy","Crimson","Dark","Emerald","Indigo","Light",
+             "Mellowsi","Midnight","MonokaiPro","Plant","Rainbow","Red","Rose","Sky","Violet" }
+    gb_appear._container:Dropdown({
+        Title    = "Theme",
+        Values   = _themeValues,
+        Value    = _PULSE_DEFAULT_THEME,
+        Flag     = "Settings_theme",
+        Callback = function(v) _UIAdapter:SetTheme(v) end,
+    })
+
+    -- ── Config ────────────────────────────────────────────────────────────────
+    local gb_cfg = _GetGroupbox("Settings", "left", "Configuration")
+
+    _UIAdapter:addParagraph(gb_cfg,
+        "Config is stored in your executor's filesystem.",
+        "Save writes the current state. Load restores the last saved state."
+    )
+
+    gb_cfg._container:Button({
+        Title    = "Save Config",
+        Icon     = "save",
+        Callback = function()
+            if _UIAdapter.Config then
+                local ok, err = pcall(function() _UIAdapter.Config:Save() end)
+                _PulseNotify(ok and "Config saved." or ("Save failed: " .. tostring(err)), 3)
+            else
+                _PulseNotify("Config manager unavailable.", 3)
+            end
+        end,
+    })
+
+    gb_cfg._container:Button({
+        Title    = "Load Config",
+        Icon     = "folder-open",
+        Callback = function()
+            if _UIAdapter.Config then
+                local ok, err = pcall(function() _UIAdapter.Config:Load() end)
+                _PulseNotify(ok and "Config loaded." or ("Load failed: " .. tostring(err)), 3)
+            else
+                _PulseNotify("Config manager unavailable.", 3)
+            end
+        end,
+    })
+
+    -- ── Menu Settings ─────────────────────────────────────────────────────────
+    local gb_menu = _GetGroupbox("Settings", "right", "Menu Settings")
+
+    _UIAdapter:addButton(gb_menu, {
+        label  = "Destroy UI",
+        action = function() _PulseDestroy() end,
+        tip    = "Unloads the script and removes all UI",
+    })
+
+    _UIAdapter:addKeybind(gb_menu, "Settings_MenuKeybind", {
+        label  = "Menu Toggle",
+        key    = _PULSE_TOGGLE_KEY,
+        action = function() _UIAdapter:ToggleWindow() end,
+    })
+
+    -- ── Auto-load saved config on startup ─────────────────────────────────────
+    task.spawn(function()
+        task.wait(1.5)
+        if _UIAdapter.Config then
+            local ok = pcall(function() _UIAdapter.Config:Load() end)
+            if ok then Pulse.Log.info("settings", "config auto-loaded") end
+        end
+    end)
+
+    -- ── Re-select first tab (Home) — Settings is injected last so WindUI
+    --    leaves it active; defer one frame so all tabs are fully built.
+    task.defer(function()
+        if _UIAdapter._firstTab then
+            pcall(function() _UIAdapter._firstTab:Select() end)
+        end
+    end)
+end