pulse-rb 1.2.24

package/pulse/dev/devconfig.lua

@@ -0,0 +1,81 @@
+-- ═══════════════════════════════════════════════════════════════════
+--  DEVELOPER CONFIGURATION  —  the only file you edit per debug session
+--
+--  Scenarios and which tools to use:
+--
+--  "Feature randomly stopped working"
+--    → Pulse.Log.watchSignal(Components.Aimbot.enabled, "aimbot", "enabled")
+--      Logs the exact moment and value every time the toggle changes.
+--
+--  "I don't know if the feature is even running"
+--    → Pulse.Monitor.tick("aimbot") inside the loop body
+--      Counter in monitor bar stops climbing = loop is dead.
+--
+--  "What data does the function receive / return?"
+--    → Pulse.Trace.instrument(func, "globals")
+--      Every func.* call logs actual argument values and return values.
+--
+--  "Something threw but I don't know where"
+--    → Framework errors (Signal, Event, Component) now route to Pulse.Log.error
+--      automatically — check the debug UI, filter level=ERR.
+--
+--  "Narrow to one feature so I'm not overwhelmed"
+--    → Pulse.TestMode.configure({ target = "FeatureName" })
+--      All other toggles start disabled.
+-- ═══════════════════════════════════════════════════════════════════
+
+-- ── 1. Logging ────────────────────────────────────────────────────
+Pulse.Log.configure({
+    level   = "debug",          -- trace | debug | info | warn | error
+    console = true,
+    file    = "pulse_dev.log",
+
+    -- Restrict to specific tags (whitelist):
+    -- tags = { "aimbot", "globals" },
+
+    -- Or exclude noisy tags:
+    -- except = { "component", "loop" },
+})
+
+-- ── 2. Test mode ──────────────────────────────────────────────────
+-- Change target = "FeatureName" to start with only that feature on.
+Pulse.TestMode.configure({
+    all = true,     -- ← change to: target = "ShifterPartsCutter"
+})
+
+-- ── 3. Signal watching — "why did this feature turn off?" ─────────
+-- Logs every value change on the signal, tagged so you can search it.
+-- Uncomment and change to whatever component you're investigating.
+--
+-- Pulse.Log.watchSignal(Components.ShifterPartsCutter.enabled, "cutter", "enabled")
+-- Pulse.Log.watchSignal(Components.Aimbot.enabled, "aimbot", "enabled")
+
+-- ── 4. Function tracing — "what data does it receive/return?" ─────
+-- Shows actual argument values and return values for every func.* call.
+-- Can be noisy — use tags filter to narrow (e.g. tags = { "globals" }).
+-- Uncomment when you need to see data flowing through helpers.
+--
+-- Pulse.Trace.instrument(func, "globals")
+--
+-- Or trace just one function:
+-- func.IsWarrior = Pulse.Trace.wrap(func.IsWarrior, "globals", "IsWarrior")
+
+-- ── 5. Execution probe — "is this loop even running?" ─────────────
+-- Add Pulse.Monitor.tick("featureName") inside any loop body.
+-- The monitor bar shows the counter — stops increasing = loop is dead.
+-- (Done in your component code, not here — this is just a reminder)
+
+-- ── 6. Narration ──────────────────────────────────────────────────
+-- Auto-announces warn+error entries as on-screen toasts + sound.
+Pulse.Narrate.configure({
+    sound     = true,
+    volume    = 0.4,
+    autoLevel = "warn",   -- "error" for less noise
+})
+
+-- ── 7. Initial monitors ───────────────────────────────────────────
+Pulse.Monitor.set("titans",   0)
+Pulse.Monitor.set("shifters", 0)
+Pulse.Monitor.set("players",  0)
+
+Pulse.Log.info("devlog", "dev build active")

package/pulse/dev/ui/9_DevPanel.lua

@@ -0,0 +1,384 @@
+-- [pulse/dev/ui/9_DevPanel.lua]
+-- WindUI Developer tab — injected in the UI phase of --dev builds only.
+-- Runs AFTER layout.rblua has created the WindUI window, so _windWindow is live.
+-- Adds Tools (Hydroxide, Dex) and Scanner (context-optimised game intelligence).
+-- Linoria builds: _windWindow is nil → early return, no-op.
+
+if not _windWindow then return end
+
+-- ── Clipboard ─────────────────────────────────────────────────────────────────
+local function _devCopy(text)
+    local ok = false
+    if not ok then pcall(function() setclipboard(text);   ok = true end) end
+    if not ok then pcall(function() toclipboard(text);    ok = true end) end
+    if not ok then pcall(function() writeclipboard(text); ok = true end) end
+    return ok
+end
+
+-- ── Path compression ──────────────────────────────────────────────────────────
+-- Longest prefix first so LP. doesn't match before PG.
+local _ALIASES = {
+    { "Players.LocalPlayer.PlayerGui.", "PG."  },
+    { "Players.LocalPlayer.",           "LP."  },
+    { "ReplicatedStorage.",             "RS."  },
+    { "ReplicatedFirst.",               "RF."  },
+    { "workspace.",                     "WS."  },
+    { "StarterGui.",                    "SG."  },
+    { "ServerScriptService.",           "SSS." },
+}
+
+local function _compress(obj)
+    local parts = {}
+    local cur = obj
+    while cur and cur ~= game do
+        table.insert(parts, 1, cur.Name)
+        cur = cur.Parent
+    end
+    local s = table.concat(parts, ".")
+    for _, pair in ipairs(_ALIASES) do
+        if s:sub(1, #pair[1]) == pair[1] then
+            return pair[2] .. s:sub(#pair[1] + 1)
+        end
+    end
+    return s
+end
+
+-- ── Scanner ───────────────────────────────────────────────────────────────────
+-- Returns: fullText, remoteCount, scriptCount, instanceCount, valueCount
+local function _runScan()
+    local RS = game:GetService("ReplicatedStorage")
+    local PG = game:GetService("Players").LocalPlayer.PlayerGui
+    local RF = game:GetService("ReplicatedFirst")
+    local WS = workspace
+    local out = {}
+
+    -- Header
+    local gameName = "?"
+    pcall(function()
+        gameName = game:GetService("MarketplaceService"):GetProductInfo(game.PlaceId).Name
+    end)
+    table.insert(out, ("[%s]  pid:%d  %s"):format(gameName, game.PlaceId, os.date("%Y-%m-%d %H:%M")))
+
+    -- ── Remotes ───────────────────────────────────────────────────────────────
+    local remotes = {}
+    local function _scanRemotes(inst, depth)
+        if depth > 8 then return end
+        local ok, ch = pcall(function() return inst:GetChildren() end)
+        if not ok then return end
+        for _, c in ipairs(ch) do
+            local cls = c.ClassName
+            if cls == "RemoteEvent" or cls == "RemoteFunction" then
+                table.insert(remotes, { p = _compress(c), t = cls == "RemoteEvent" and "RE" or "RF" })
+            end
+            if c:IsA("Folder") or c:IsA("Configuration") or c:IsA("Model") then
+                _scanRemotes(c, depth + 1)
+            end
+        end
+    end
+    pcall(_scanRemotes, RS, 0)
+    table.sort(remotes, function(a, b) return a.p < b.p end)
+
+    table.insert(out, ("\nREMOTES (%d)"):format(#remotes))
+    for i, r in ipairs(remotes) do
+        if i > 40 then
+            table.insert(out, ("  ...+%d more"):format(#remotes - 40))
+            break
+        end
+        table.insert(out, ("  %-52s %s"):format(r.p, r.t))
+    end
+
+    -- ── LocalScripts ──────────────────────────────────────────────────────────
+    local scripts = {}
+    local function _scanScripts(inst)
+        local ok, ch = pcall(function() return inst:GetChildren() end)
+        if not ok then return end
+        for _, c in ipairs(ch) do
+            if c:IsA("LocalScript") and c.Name ~= "RobloxPromptGui" then
+                table.insert(scripts, _compress(c))
+            end
+            local ok2, gc = pcall(function() return c:GetChildren() end)
+            if ok2 then
+                for _, g in ipairs(gc) do
+                    if g:IsA("LocalScript") then
+                        table.insert(scripts, _compress(g))
+                    end
+                end
+            end
+        end
+    end
+    pcall(_scanScripts, PG)
+    pcall(_scanScripts, RF)
+    table.sort(scripts)
+
+    table.insert(out, ("\nSCRIPTS (%d)"):format(#scripts))
+    for i, s in ipairs(scripts) do
+        if i > 15 then
+            table.insert(out, ("  ...+%d more"):format(#scripts - 15))
+            break
+        end
+        table.insert(out, "  " .. s)
+    end
+
+    -- ── Key instances ─────────────────────────────────────────────────────────
+    local instances = {}
+    local ok1, wsKids = pcall(function() return WS:GetChildren() end)
+    local ok2, rsKids = pcall(function() return RS:GetChildren() end)
+    if ok1 then
+        for _, c in ipairs(wsKids) do
+            if c:IsA("Folder") or c:IsA("Model") then
+                local n = 0
+                pcall(function() n = #c:GetChildren() end)
+                if n > 0 then
+                    table.insert(instances, { p = _compress(c), cls = c.ClassName, n = n })
+                end
+            end
+        end
+    end
+    if ok2 then
+        for _, c in ipairs(rsKids) do
+            if c:IsA("Folder") then
+                local n = 0
+                pcall(function() n = #c:GetChildren() end)
+                if n > 0 then
+                    table.insert(instances, { p = _compress(c), cls = "Folder", n = n })
+                end
+            end
+        end
+    end
+    table.sort(instances, function(a, b) return a.p < b.p end)
+
+    table.insert(out, ("\nKEY INSTANCES (%d)"):format(#instances))
+    for i, inst in ipairs(instances) do
+        if i > 20 then
+            table.insert(out, ("  ...+%d more"):format(#instances - 20))
+            break
+        end
+        table.insert(out, ("  %-48s %s(%d)"):format(
+            inst.p,
+            inst.cls == "Folder" and "Folder " or "Model  ",
+            inst.n
+        ))
+    end
+
+    -- ── Notable values ────────────────────────────────────────────────────────
+    local values = {}
+    if ok2 then
+        for _, c in ipairs(rsKids) do
+            local cls = c.ClassName
+            if cls == "StringValue" or cls == "IntValue" or cls == "BoolValue" or cls == "NumberValue" then
+                local v = "?"
+                pcall(function() v = tostring(c.Value) end)
+                table.insert(values, { p = _compress(c), v = v })
+            end
+        end
+    end
+
+    table.insert(out, ("\nVALUES (%d)"):format(#values))
+    for i, val in ipairs(values) do
+        if i > 12 then
+            table.insert(out, ("  ...+%d more"):format(#values - 12))
+            break
+        end
+        table.insert(out, ("  %-48s %s"):format(val.p, val.v))
+    end
+
+    return table.concat(out, "\n"), #remotes, #scripts, #instances, #values
+end
+
+-- ── State ─────────────────────────────────────────────────────────────────────
+local _lastScanText   = ""
+local _scanRunning    = false
+local _scanStatusPara = nil  -- assigned after UI is built
+
+-- Forward-declared so button callbacks can reference it before the body is defined.
+local _doScan
+
+-- ── Build WindUI Dev tab ───────────────────────────────────────────────────────
+local _devTab
+pcall(function()
+    _devTab = _windWindow:Tab({ Title = "Dev", Icon = "bug" })
+end)
+
+if not _devTab then
+    Pulse.Log.warn("dev-panel", "Dev tab skipped — _windWindow:Tab() failed")
+    return
+end
+
+-- Single-column VStack (no 2-column split needed for dev tools)
+local _col
+pcall(function() _col = _devTab:VStack({}) end)
+_col = _col or _devTab
+
+-- ── Tools section ─────────────────────────────────────────────────────────────
+local _toolSect
+pcall(function()
+    _toolSect = _col:Section({
+        Title     = "Tools",
+        Icon      = "wrench",
+        Box       = true,
+        BoxBorder = true,
+        Opened    = true,
+    })
+end)
+
+local _TOOLS = {
+    {
+        name = "Hydroxide",
+        desc = "Remote spy with web interface",
+        -- Hydroxide is modular — needs two imports from the 'revision' branch.
+        load = function()
+            local owner, branch = "Upbolt", "revision"
+            local function webImport(file)
+                loadstring(
+                    game:HttpGetAsync(("https://raw.githubusercontent.com/%s/Hydroxide/%s/%s.lua"):format(owner, branch, file)),
+                    file .. ".lua"
+                )()
+            end
+            webImport("init")
+            webImport("ui/main")
+        end,
+    },
+    {
+        name = "Infinite Yield",
+        desc = "Admin / exploit command panel",
+        url  = "https://raw.githubusercontent.com/DarkNetworks/Infinite-Yield/main/latest.lua",
+    },
+    {
+        name = "Dex Explorer",
+        desc = "Browse and inspect the live game tree",
+        url  = "https://raw.githubusercontent.com/infyiff/backup/main/dex.lua",
+    },
+}
+
+if _toolSect then
+    for _, tool in ipairs(_TOOLS) do
+        local _launched = false
+        local _btn
+        pcall(function()
+            _btn = _toolSect:Button({
+                Title    = tool.name,
+                Desc     = tool.desc,
+                Callback = function()
+                    if _launched then
+                        _PulseNotify("Already running: " .. tool.name, 2)
+                        return
+                    end
+                    pcall(function() _btn:SetTitle(tool.name .. "  ·  loading…") end)
+                    task.spawn(function()
+                        local ok, err = pcall(function()
+                            if tool.load then
+                                tool.load()
+                            else
+                                local src = game:HttpGet(tool.url)
+                                local fn, ce = loadstring(src)
+                                if not fn then error(ce) end
+                                fn()
+                            end
+                        end)
+                        if ok then
+                            _launched = true
+                            pcall(function() _btn:SetTitle("✓  " .. tool.name) end)
+                            _PulseNotify(tool.name .. " launched", 3)
+                            Pulse.Log.info("dev-tools", tool.name .. " launched")
+                        else
+                            pcall(function() _btn:SetTitle(tool.name .. "  ·  failed") end)
+                            _PulseNotify(tool.name .. " failed — see LOG", 3)
+                            Pulse.Log.error("dev-tools", tool.name .. ": " .. tostring(err))
+                            task.delay(3, function()
+                                if not _launched then
+                                    pcall(function() _btn:SetTitle(tool.name) end)
+                                end
+                            end)
+                        end
+                    end)
+                end,
+            })
+        end)
+    end
+end
+
+-- ── Scanner section ───────────────────────────────────────────────────────────
+local _scanSect
+pcall(function()
+    _scanSect = _col:Section({
+        Title     = "Scanner",
+        Icon      = "scan",
+        Box       = true,
+        BoxBorder = true,
+        Opened    = true,
+    })
+end)
+
+if _scanSect then
+    pcall(function()
+        _scanStatusPara = _scanSect:Paragraph({
+            Title = "Game Scanner",
+            Desc  = "Auto-scan runs on inject. Results copied to clipboard.",
+        })
+    end)
+    pcall(function()
+        _scanSect:Button({
+            Title    = "Scan Now",
+            Desc     = "Re-scan and copy results to clipboard",
+            Callback = function() _doScan() end,
+        })
+    end)
+    pcall(function()
+        _scanSect:Button({
+            Title    = "Copy Last Results",
+            Desc     = "Re-copy the most recent scan to clipboard",
+            Callback = function()
+                if _lastScanText == "" then
+                    _PulseNotify("No scan yet — run Scan Now first", 3)
+                    return
+                end
+                local ok = _devCopy(_lastScanText)
+                _PulseNotify(ok and "Scan results copied" or "No clipboard function found", 3)
+            end,
+        })
+    end)
+end
+
+-- ── Scan logic ────────────────────────────────────────────────────────────────
+_doScan = function()
+    if _scanRunning then return end
+    _scanRunning = true
+    pcall(function()
+        _scanStatusPara:SetTitle("Game Scanner")
+        _scanStatusPara:SetDesc("Scanning…")
+    end)
+    task.spawn(function()
+        local ok, txt, nRem, nScr, nInst, nVal = pcall(_runScan)
+        _scanRunning = false
+        if ok then
+            _lastScanText = txt
+            local summary = ("%d remotes · %d scripts · %d instances · %d values"):format(
+                nRem, nScr, nInst, nVal)
+            local copied = _devCopy(txt)
+            pcall(function()
+                _scanStatusPara:SetTitle("Scan  " .. os.date("%H:%M:%S"))
+                _scanStatusPara:SetDesc(summary .. (copied and " · copied to clipboard" or ""))
+            end)
+            Pulse.Log.info("dev-scanner", summary)
+            if copied then
+                _PulseNotify("Game scan complete · results copied", 4)
+            end
+        else
+            pcall(function()
+                _scanStatusPara:SetTitle("Scan failed")
+                _scanStatusPara:SetDesc("Check LOG tab › dev-scanner tag for details.")
+            end)
+            Pulse.Log.error("dev-scanner", tostring(txt))
+        end
+    end)
+end
+
+-- ── Auto-scan on inject ────────────────────────────────────────────────────────
+-- Fires 2 s after game is loaded so services are fully populated.
+task.spawn(function()
+    if not game:IsLoaded() then game.Loaded:Wait() end
+    task.wait(2)
+    _doScan()
+end)
+
+Pulse.Log.debug("dev-panel", "WindUI Dev tab ready")

package/pulse/helpers/aim.lua

@@ -0,0 +1,193 @@
+-- ── Pulse.Aim ────────────────────────────────────────────────────────────────
+-- Camera targeting helpers for aimbot-style features.
+-- Usage:
+--   if Pulse.Aim.inFOV(nape.Position, radius()) then ... end
+--   local dist = Pulse.Aim.screenDist(nape.Position)
+--   Pulse.Aim.lookAt(nape.Position)         -- snap
+--   Pulse.Aim.smoothTo(nape.Position, 0.95) -- smooth lerp
+--   local nearest = Pulse.Aim.findNearest(titans, { fovRadius = 300 })
+--
+-- Stateful locker (for aimbot components):
+--   local lock = Pulse.Aim.locker({
+--       getPos    = function(e) return e.Nape.Position end,
+--       validate  = function(e) return e.Parent ~= nil end,
+--   })
+--   lock:lock(entity)    -- set target
+--   lock:release()       -- clear
+--   lock:getTarget()     -- current entity or nil
+--   lock:isValid()       -- validates current target via opts.validate
+--   lock:aim()           -- smooth camera move; returns false if target became invalid
+--   lock:aim("snap")     -- snap mode (uses Pulse.Aim.lookAt)
+
+Pulse.Aim = (function()
+    local A = {}
+
+    -- True if worldPos projects within pixelRadius pixels of screen centre.
+    function A.inFOV(worldPos, pixelRadius)
+        local cam = workspace.CurrentCamera
+        if not cam then return false end
+        local sp, onScreen = cam:WorldToViewportPoint(worldPos)
+        if not onScreen then return false end
+        local sz = cam.ViewportSize
+        local dx = sp.X - sz.X * 0.5
+        local dy = sp.Y - sz.Y * 0.5
+        return (dx * dx + dy * dy) <= (pixelRadius * pixelRadius)
+    end
+
+    -- Pixel distance from screen centre to worldPos (math.huge if off-screen).
+    function A.screenDist(worldPos)
+        local cam = workspace.CurrentCamera
+        if not cam then return math.huge end
+        local sp, onScreen = cam:WorldToViewportPoint(worldPos)
+        if not onScreen then return math.huge end
+        local sz = cam.ViewportSize
+        local dx = sp.X - sz.X * 0.5
+        local dy = sp.Y - sz.Y * 0.5
+        return math.sqrt(dx * dx + dy * dy)
+    end
+
+    -- Lock the camera to look at a world position.
+    -- Syncs the VirtualInputManager cursor so the game's camera script agrees,
+    -- then triple-sets CFrame to override any interpolation.
+    function A.lookAt(pos)
+        local cam = workspace.CurrentCamera
+        if not cam then return end
+        local sp, onScreen = cam:WorldToViewportPoint(pos)
+        if onScreen then
+            pcall(function() _VIM:SendMouseMoveEvent(sp.X, sp.Y, game) end)
+        end
+        local cf = CFrame.lookAt(cam.CFrame.Position, pos)
+        cam.CFrame           = cf
+        pcall(function() cam.CoordinateFrame = cf end)
+        cam.CFrame           = cf
+        if onScreen then
+            pcall(function() _VIM:SendMouseMoveEvent(sp.X, sp.Y, game) end)
+        end
+    end
+
+    -- Return the nearest entity from candidates.
+    -- opts:
+    --   origin    — Vector3 (defaults to local HRP position)
+    --   fovRadius — pixel radius; skips entities outside FOV (optional)
+    --   maxDist   — world-space distance cap (optional)
+    --   filter    — function(entity) → bool; return false to skip
+    --   getRoot   — function(entity) → BasePart (defaults to HumanoidRootPart)
+    function A.findNearest(candidates, opts)
+        opts = opts or {}
+        local hrp    = _PulseGetHRP()
+        local origin = opts.origin or (hrp and hrp.Position)
+        if not origin then return nil end
+
+        local getRoot = opts.getRoot or function(e)
+            return e:FindFirstChild("HumanoidRootPart")
+        end
+
+        local nearest  = nil
+        local bestDist = opts.maxDist or math.huge
+        local _sk = { filter = 0, root = 0, fov = 0, dist = 0 }
+
+        for _, entity in ipairs(candidates) do
+            if opts.filter and not opts.filter(entity) then
+                _sk.filter = _sk.filter + 1
+            else
+                local root = getRoot(entity)
+                if not root then
+                    _sk.root = _sk.root + 1
+                elseif opts.fovRadius and not A.inFOV(root.Position, opts.fovRadius) then
+                    _sk.fov = _sk.fov + 1
+                else
+                    local d = (root.Position - origin).Magnitude
+                    if d < bestDist then
+                        bestDist = d
+                        nearest  = entity
+                    else
+                        _sk.dist = _sk.dist + 1
+                    end
+                end
+            end
+        end
+
+        if nearest == nil and #candidates > 0 then
+            Pulse.Log.trace("Aim", "findNearest: no result", {
+                n      = #candidates,
+                filter = _sk.filter,
+                noRoot = _sk.root,
+                fov    = _sk.fov,
+                dist   = _sk.dist,
+            })
+        end
+
+        return nearest
+    end
+
+    -- Smooth-lerp the camera toward a world position (no VIM sync, no triple-set).
+    -- alpha = lerp factor per frame; 0.95 feels like a snappy but smooth lock.
+    function A.smoothTo(pos, alpha)
+        local cam = workspace.CurrentCamera
+        if not cam then return end
+        alpha = alpha or 0.95
+        local origin     = cam.CFrame.Position
+        local currentLook = cam.CFrame.LookVector
+        local desiredLook = (pos - origin).Unit
+        local smoothed    = currentLook:Lerp(desiredLook, alpha)
+        cam.CFrame = CFrame.new(origin, origin + smoothed)
+    end
+
+    -- Create a stateful locker for a single locked target.
+    -- opts:
+    --   getPos(entity)   → Vector3  — where to aim at on the entity (required for aim())
+    --   validate(entity) → bool     — is this entity still a valid target?
+    function A.locker(opts)
+        opts = opts or {}
+        local _target = nil
+        local L = {}
+
+        function L:lock(entity)
+            _target = entity
+        end
+
+        function L:release()
+            _target = nil
+        end
+
+        function L:getTarget()
+            return _target
+        end
+
+        -- Validate the current lock.  Returns false (and clears) if invalid.
+        function L:isValid()
+            if not _target then return false end
+            if opts.validate then
+                if not opts.validate(_target) then _target = nil; return false end
+                return true
+            end
+            if not _target.Parent then _target = nil; return false end
+            return true
+        end
+
+        -- Move camera toward locked target.
+        -- mode = "smooth" (default) | "snap"
+        -- Returns false if the target was invalid (lock cleared).
+        function L:aim(mode, alpha)
+            if not self:isValid() then return false end
+            local pos
+            if opts.getPos then
+                pos = opts.getPos(_target)
+            else
+                local root = _target:FindFirstChild("HumanoidRootPart")
+                pos = root and root.Position
+            end
+            if not pos then _target = nil; return false end
+            if mode == "snap" then
+                A.lookAt(pos)
+            else
+                A.smoothTo(pos, alpha or 0.95)
+            end
+            return true
+        end
+
+        return L
+    end
+
+    return A
+end)()