pulse-rb 1.2.24

package/templates/AGENTS.md

@@ -0,0 +1,177 @@
+# AGENTS.md — {NAME}
+
+Roblox script project built with the **rb / Pulse** framework.  
+Run `rb docs` (or read `PULSE_DOCS.md` if it exists) for the complete framework reference.
+
+---
+
+## Build
+
+```
+rb build                 # compile + obfuscate → build/script.lua
+rb build --no-obfuscate  # compile only
+rb copy                  # compile + copy to clipboard
+rb lint                  # static analysis: dead signals, ghost refs, orphan funcs
+rb check                 # syntax-check compiled output
+rb docs                  # generate PULSE_DOCS.md full reference
+```
+
+---
+
+## Architecture rules
+
+- Each `.rblua` file = one **component**. Filename = component name.
+- All files in `src/` concatenate into **one flat Lua chunk** — no `require()`, no module system.
+- `local` variables from files compiled earlier are visible in files compiled later.
+- Load order: `globals.lua` → `remotes.lua` → feature modules (alphabetical) → UI files → defaults runner.
+
+---
+
+## Component rules
+
+```rblua
+component {
+    signal enabled = false      -- reactive state
+    shared { Key = "value" }    -- Pulse.Store cross-component entry
+    remote Foo = "Remotes/Foo"  -- FireServer wrapper
+    invoke Bar = "Remotes/Bar"  -- InvokeServer wrapper
+
+    ui {
+        toggle "Enable" -> enabled default=true tip="..."
+        slider "Radius" -> radius [50, 800]
+        dropdown "Mode" -> mode ["A","B"] default="B"
+        button "Reset" -> Reset()
+    }
+
+    init {
+        local _loop = Pulse.Loop.new(1.0, fn)
+        local function privateHelper() ... end  -- PRIVATE
+    }
+
+    on enabled { ... }             -- signal change (v = new value)
+    on Heartbeat when enabled { }  -- service event with guard
+    on CharacterAdded { }          -- fires on spawn/respawn
+    on InputBegan(input, gpe) { }  -- user input
+
+    func Toggle() { enabled(not enabled()) }   -- PUBLIC method
+}
+```
+
+**Private vs public:**
+- `local function` in `init {}` = private (component-scoped)
+- `func Name() {}` DSL = public (`Component:Name()` callable externally)
+- `func.X = function()` inside `init {}` = **BANNED** (global pollution)
+
+---
+
+## Signal access
+
+| Context | Read | Write |
+|---|---|---|
+| `on X {}` handlers | bare name `radius` (auto-mirrored) | `radius(newValue)` |
+| `func {}` / `init {}` | `ComponentName.radius()` | `ComponentName.radius(newValue)` |
+| Other component | `Aimbot.radius()` | `Aimbot.radius(true)` |
+
+---
+
+## Key globals
+
+```lua
+_LocalPlayer                    -- game.Players.LocalPlayer
+_PulseRS                        -- RunService
+_PulseUIS                       -- UserInputService
+_PulseGetChar()                 -- Character (nil-safe)
+_PulseGetHRP()                  -- HumanoidRootPart (nil-safe)
+func.GetCachedPlayers()         -- cached player list (1.5 s TTL)
+Pulse.Notify("msg", secs)       -- in-game toast (preferred over _Library direct call)
+```
+
+---
+
+## Key Pulse helpers
+
+```lua
+-- Tasks / timing
+Pulse.Loop.new(interval, fn)          -- managed repeating task
+Pulse.Cooldown.new(dur)               -- shared cooldown
+Pulse.Cooldown.perEntity(dur)         -- per-entity cooldown with .purge(isDeadFn)
+
+-- Connections / store
+Pulse.Conn.bind("name", conn)         -- named connection manager
+Pulse.Conn.disconnect("name")
+Pulse.Store.define/get/set/watch("key")  -- cross-component reactive KV
+
+-- Combat / targeting
+Pulse.Aim.findNearest(list, opts)     -- nearest entity search
+Pulse.Aim.inFOV(pos, radius)          -- FOV circle check
+Pulse.Hitbox.new("tag")               -- BasePart size-expansion manager
+local r = Pulse.Team.resolver(opts)   -- enemy/ally classifier (.isEnemy/.filter/.partition)
+
+-- Drawing / ESP
+Pulse.Draw.highlight(inst, "tag", opts)
+Pulse.Draw.removeHighlight(inst, "tag")
+
+-- Data / caching
+Pulse.Restore.new()                   -- save/restore instance properties
+Pulse.Cache.wrap(ttl, fn)             -- timed caching of any function
+Pulse.Track.new()                     -- entity lifecycle tracking
+
+-- Notifications (always available)
+Pulse.Notify("msg")                         -- instant toast
+Pulse.Notify.onToggle(signal, "Name")       -- auto on/off toast on signal change
+
+-- Executor capability
+Pulse.Memory.supports("writefile")          -- bool: UNC fn exists
+Pulse.Memory.requireFrom("Mod", "Child")    -- safe Character child require
+
+-- Input simulation
+Pulse.Input.simulateKey(Enum.KeyCode.T)
+
+-- Live debug monitor (always available)
+Pulse.Monitor.set("key", value)       -- track a named value in the debug GUI
+Pulse.Monitor.tick("key")             -- increment counter (stops = loop died)
+
+-- Logging (dev-only; no-ops in prod)
+Pulse.Log.info/warn/error("Tag", "msg")
+Pulse.Log.throttle("Tag", 5, "debug", "msg")   -- at most once per 5 s
+Pulse.Log.watchSignal(signal, "Tag", "name")   -- log every signal change
+```
+
+---
+
+## Game-load guard
+
+Wrap features that use Roblox services in `task.spawn` + load check when injecting before the game finishes loading:
+
+```lua
+task.spawn(function()
+    if not game:IsLoaded() then game.Loaded:Wait() end
+    RS:BindToRenderStep("__Key__", Enum.RenderPriority.Last.Value, fn)
+end)
+-- cleanup bind outside spawn so it always fires
+MyComponent:bind("_rs", { Disconnect = function() RS:UnbindFromRenderStep("__Key__") end })
+```
+
+---
+
+## Obfuscator (Prometheus)
+
+`rb/prometheus_config.lua` overrides the default preset when present. Exclude these steps — they break Roblox runtime:
+
+| Step | Reason |
+|---|---|
+| `Vmify` | Breaks member-access patterns |
+| `AntiTamper` | Requires `debug` library — unavailable in exploits |
+| `EncryptStrings` | Corrupts strings used as service/member names |
+
+Safe: `ConstantArray` (StringsOnly) + `NumbersToExpressions` + `WrapInFunction`.
+
+---
+
+## What NOT to do
+
+- No `require()` — flat compilation
+- No `func.X = function()` inside component `init {}` — use `local function`
+- No `GetChildren()` in tight loops — use `func.GetCachedPlayers()` / cached helpers
+- No game-specific code in `rb/pulse/helpers/` — framework is game-agnostic
+- No `wait()` / `spawn()` — use `task.wait()` / `task.spawn()` / `task.delay()`

package/templates/CLAUDE.md

@@ -0,0 +1,424 @@
+# CLAUDE.md — Pulse Framework Reference
+
+> **Project:** `{NAME}` — Roblox script built with the **rb / Pulse** framework.  
+> **Architecture:** flat-compiled reactive DSL. All `.rblua` and `.lua` files in `src/` are concatenated into one Lua chunk at build time.  
+> Run `rb docs` to generate `PULSE_DOCS.md` in this directory for the full framework reference.
+
+---
+
+## Build commands
+
+| Command | Description |
+|---|---|
+| `rb build` | Compile + obfuscate → `build/script.lua` |
+| `rb build --no-obfuscate` | Compile only, no obfuscation |
+| `rb copy` | Compile and copy to clipboard |
+| `rb watch` | Auto-rebuild on file save |
+| `rb lint` | Dead signals, ghost refs, orphan funcs |
+| `rb docs` | Generate `PULSE_DOCS.md` full reference |
+| `rb check` | Syntax-check compiled output |
+
+---
+
+## Project layout
+
+```
+src/
+  misc/helpers/globals.lua   ← compiled first — defines local func = {}
+  misc/remotes.lua           ← func.Remote_X fire-server wrappers
+  <category>/<Name>.rblua    ← components (one per feature)
+  ui/layout.rblua            ← window title / size / toggle key
+  ui/pages/*.rblua           ← tab layout (mount components)
+build/
+  script.lua                 ← compiled output (never edit directly)
+```
+
+---
+
+## Component structure
+
+```rblua
+component {
+    -- reactive state
+    signal enabled = false
+    signal radius  = 400
+    signal mode    = "Normal"
+
+    -- cross-component reactive store entry
+    shared {
+        GlobalKey = "defaultValue"
+    }
+
+    -- fire-server remote wrapper
+    remote Attack = "Remotes/Combat/Attack"
+
+    -- invoke-server remote wrapper (returns a value)
+    invoke GetStats = "Remotes/Combat/GetStats"
+
+    -- UI widgets (auto-wired to signals, compiled into Linoria)
+    ui {
+        toggle   "Enable"  -> enabled  default=true  tip="Tooltip text"
+        slider   "Radius"  -> radius   [50, 800]
+        dropdown "Mode"    -> mode     ["Normal", "Big"]  default="Big"
+        button   "Reset"   -> Reset()
+        separator
+        label    "Section heading"
+        keybind  "Toggle"  key="F"  -> Toggle()
+    }
+
+    -- constructor: private locals and helper functions
+    init {
+        local lockedTarget = nil
+
+        local function findTarget()
+            -- private: NOT accessible outside this component
+        end
+    }
+
+    -- signal change handler  (v = new value)
+    on enabled {
+        if v then ... else ... end
+    }
+
+    -- service event handlers
+    on Heartbeat when enabled {
+        guard h = humanoid
+        guard r = hrp
+    }
+
+    on Heartbeat when enabled every 0.5 {
+        -- throttled to at most once per 0.5 s
+    }
+
+    on Heartbeat when enabled every interval {
+        -- throttle uses the 'interval' signal value dynamically
+    }
+
+    on CharacterAdded {
+        lockedTarget = nil
+    }
+
+    on CharacterRemoving {
+        -- cleanup before character is removed
+    }
+
+    on InputBegan(input, gpe) when enabled debounce 0.2 {
+        if gpe then return end
+    }
+
+    -- public method (callable as Component:Name() from anywhere)
+    func Toggle() {
+        enabled(not enabled())
+    }
+
+    func GetTarget() {
+        return lockedTarget
+    }
+}
+```
+
+---
+
+## Private vs public — the golden rule
+
+| Pattern | Visibility | Use for |
+|---|---|---|
+| `local function name()` in `init {}` | Component-private | Internal helpers |
+| `func Name() {}` DSL block | Public (Component:Name()) | API for other components |
+| `func.X = function()` in `init {}` | **BANNED** — global pollution | Never |
+
+The `func` table is a shared global used for cross-file helpers defined in `.lua` files.  
+Assigning `func.X` from inside a component's `init {}` pollutes that global. Always use `local function` instead.
+
+---
+
+## Signals — reading and writing
+
+```lua
+-- Inside handlers (on X {}) — read as bare name (transpiler mirrors it)
+on Heartbeat when enabled {
+    if radius > 500 then ... end   -- bare read
+    radius(200)                    -- write (call as function)
+}
+
+-- Inside func {} blocks or init {} — call as function to read
+func PrintState() {
+    print(enabled(), radius())
+}
+
+-- From another component
+Aimbot.enabled(true)          -- write
+local r = Aimbot.radius()     -- read
+Aimbot:Toggle()               -- call public method
+```
+
+---
+
+## Events reference
+
+| Name | Fires |
+|---|---|
+| `Heartbeat` | Every frame (~60 fps) |
+| `RenderStepped` | Before camera renders |
+| `Stepped` | Physics step |
+| `InputBegan` | Key or mouse button pressed |
+| `InputEnded` | Key or mouse button released |
+| `CharacterAdded` | Player spawned or respawned |
+| `CharacterRemoving` | Character about to be removed |
+| `Respawn` | Legacy alias for CharacterAdded |
+| `signalName` | When that signal changes (v = new value) |
+
+**Modifiers:**
+
+```rblua
+on Heartbeat when enabled { }              -- skip if enabled is false
+on Heartbeat every 0.5 { }                 -- throttle: at most once per 0.5 s
+on Heartbeat every interval { }            -- throttle using signal value
+on Heartbeat when enabled debounce 0.3 { } -- cooldown after firing
+on InputBegan(input, gpe) when enabled { } -- pass event params
+after 2.5 { }                              -- delayed task (runs once on load)
+```
+
+---
+
+## Guard — nil-safe early return
+
+```rblua
+guard h = humanoid         -- local h = humanoid; if not h then return end
+guard r = hrp              -- same for HumanoidRootPart
+guard character            -- return if falsy, no capture
+```
+
+**Character refs** (auto-resolved anywhere in handlers):
+
+| Name | Value |
+|---|---|
+| `humanoid` | `Character.Humanoid` |
+| `hrp` | `Character.HumanoidRootPart` |
+| `character` | `LocalPlayer.Character` |
+| `alive` | `true` if Humanoid.Health > 0 |
+
+---
+
+## Pulse helpers
+
+```lua
+-- Managed task loop
+local _loop = Pulse.Loop.new(interval, fn)
+_loop:start()   _loop:stop()   _loop:running()   _loop:setInterval(n)
+-- fn already wrapped in pcall; return false from fn to self-stop
+
+-- Cooldowns
+local cd  = Pulse.Cooldown.new(1.0)         -- single shared cooldown
+cd:ready()  cd:use()  cd:reset()  cd:set(dur)
+
+local pcd = Pulse.Cooldown.perEntity(0.5)   -- one timer per entity key
+pcd:ready(key)  pcd:use(key)  pcd:reset(key)  pcd:set(dur)
+pcd:purge(isDeadFn)                          -- drop entries where fn(key) is true
+
+-- Named connection manager
+Pulse.Conn.bind("Name", connection)          -- registers + auto-disconnects old
+Pulse.Conn.disconnect("Name")
+Pulse.Conn.disconnectAll()
+
+-- Cross-component reactive KV store
+Pulse.Store.define("Key", defaultValue)
+Pulse.Store.get("Key")
+Pulse.Store.set("Key", value)
+Pulse.Store.watch("Key", fn)
+Pulse.Store.signal("Key")                    -- returns the raw Signal
+
+-- Targeting / aiming
+Pulse.Aim.inFOV(worldPos, pixelRadius)       -- bool: is position inside FOV circle?
+Pulse.Aim.lookAt(worldPos)                   -- snap camera to world position
+Pulse.Aim.findNearest(list, {
+    maxDist = 500,
+    fovRadius = radius(),
+    filter  = function(e) return not func.IsDead(e) end,
+    getRoot = function(e) return e:FindFirstChild("HumanoidRootPart") end,
+    origin  = someVector3,                   -- defaults to local player HRP
+})
+
+-- Drawing / ESP
+Pulse.Draw.highlight(instance, "Tag", {
+    fill = Color3.fromRGB(255,255,0), outline = Color3.fromRGB(255,0,0),
+    fillAlpha = 0.5, alwaysOnTop = true,
+})
+Pulse.Draw.removeHighlight(instance, "Tag")
+local circle = Pulse.Draw.circle({ radius=300, color=Color3.new(1,1,1), thickness=2, alpha=0.8 })
+circle.Position = Vector2.new(cx, cy)
+Pulse.Draw.remove(circle)
+
+-- Timed cache
+local getTitans = Pulse.Cache.wrap(1.5, function()
+    return workspace.Titans.Alive:GetChildren()
+end)
+
+-- Save / restore instance properties
+local r = Pulse.Restore.new()
+r:save(part, "Size")         -- store current value
+r:one(part, "Size")          -- restore one property
+r:all()                      -- restore everything
+r:has(part, "Size")          -- bool
+
+-- Entity lifecycle tracking
+local tracker = Pulse.Track.new()
+tracker:apply(entity, cleanupFn)   -- track + register cleanup
+tracker:remove(entity)             -- remove + run cleanup
+tracker:cleanup(isDeadFn)          -- remove all where predicate is true
+tracker:clear()                    -- remove everything
+tracker:has(entity)                -- bool
+tracker:count()
+tracker:each(fn)
+
+-- Logging (dev-only — no-ops in prod; levels: trace < debug < info < warn < error)
+Pulse.Log.trace("Tag", "msg")  Pulse.Log.debug("Tag", "msg")
+Pulse.Log.info("Tag", "msg")   Pulse.Log.warn("Tag", "msg")   Pulse.Log.error("Tag", "msg")
+Pulse.Log.assert(cond, "Tag", "msg")           -- logs ERROR if cond is false
+Pulse.Log.throttle("Tag", 5, "debug", "msg")   -- at most once per 5 s; safe in loops
+Pulse.Log.watchSignal(signal, "Tag", "name")   -- log every signal change
+Pulse.Log.snapshot("Tag", "label", tbl)        -- dump table as debug entry
+Pulse.Log.configure({ level="debug", file="dev.log", tags={"Aimbot"} })
+Pulse.Log.save("pulse_log.txt")  -- write buffer to file
+Pulse.Log.dump()                 -- return buffer as string
+Pulse.Log.clear()
+
+-- Live debug monitor (always available — use in Heartbeat loops to prove execution)
+Pulse.Monitor.set("key", value)    -- set a named live value
+Pulse.Monitor.tick("key")          -- increment counter (stops incrementing = loop died)
+Pulse.Monitor.get("key")           -- read one value
+Pulse.Monitor.getAll()             -- { key=value, ... }
+
+-- Notifications (always available)
+Pulse.Notify("Message")                         -- instant toast (3 s)
+Pulse.Notify("Message", 5)                      -- custom duration
+Pulse.Notify.onToggle(signal, "FeatureName")    -- auto "on"/"off" toast on toggle
+Pulse.Notify.onToggle(signal, "AutoFarm", {
+    on="AutoFarm started", off="AutoFarm stopped", duration=5,
+})                                              -- returns unsubscribe fn
+
+-- Hitbox expansion (game-agnostic BasePart size manager)
+local hm = Pulse.Hitbox.new("tag")
+hm:apply(part, 30)     -- expand to 30×30×30, saves original on first call
+hm:restore(part)       -- restore to saved size
+hm:restoreAll()        -- restore all managed parts
+hm:isExpanded(part)    -- bool
+
+-- Key simulation
+Pulse.Input.simulateKey(Enum.KeyCode.T)
+
+-- Executor capability checks
+Pulse.Memory.supports("writefile")             -- bool: UNC function exists
+Pulse.Memory.testWritable(tbl, key)            -- bool: field is actually writable
+Pulse.Memory.requireFrom("ODMG", "Client", "Memory")  -- safe Character child require
+
+-- Enemy/ally resolver factory
+local r = Pulse.Team.resolver({
+    isSelf    = function(e) return e == _LocalPlayer end,
+    isValid   = function(e) return e.Character ~= nil end,
+    isHostile = function(e) return func.IsEnemy(e) end,
+    exclude   = { func.IsFriendly },
+})
+r:isEnemy(player)       -- bool
+r:isAlly(player)        -- bool
+r:filter(playerList)    -- enemies only
+r:partition(playerList) -- allies, enemies
+
+-- Frame-time sampler (call Pulse.Perf.tick() in a Heartbeat to track perf)
+Pulse.Perf.tick()              -- sample current frame time
+Pulse.Perf.avg()               -- average frame time in seconds
+Pulse.Perf.fps()               -- estimated FPS
+Pulse.Perf.setThreshold(50)    -- warn when avg > 50 ms
+
+-- Workspace navigation
+Pulse.World.find("Folder", "SubFolder")        -- nil if missing
+Pulse.World.children("Folder", "SubFolder")    -- {} on failure
+Pulse.World.await(parent, "ChildName", timeout)
+
+-- Vec helpers
+Pulse.Vec.flatDir(from, to, fallback)   -- XZ-plane normalized direction
+```
+
+---
+
+## Globals available everywhere
+
+```lua
+_LocalPlayer              -- game.Players.LocalPlayer
+_PulseRS                  -- game:GetService("RunService")
+_PulseUIS                 -- game:GetService("UserInputService")
+_PulseGetChar()           -- LocalPlayer.Character  (nil-safe)
+_PulseGetHRP()            -- Character.HumanoidRootPart  (nil-safe)
+_PulseGetHumanoid()       -- Character.Humanoid  (nil-safe)
+_PulseGetAlive()          -- bool: health > 0
+
+func.GetCachedPlayers()   -- cached player list (1.5 s TTL)
+func.GetCachedTitans()    -- cached titan list (game-specific, if defined)
+
+_Library                  -- WindUI library instance (ui_library = "windui" default)
+
+Components.Name           -- access any component by name
+```
+
+---
+
+## Flat compilation order
+
+1. `rb/pulse/runtime.lua` + `rb/pulse/helpers/*.lua` — framework (auto-injected)
+2. `rb/adapters/windui.lua` — UI adapter (auto-injected; controlled by `ui_library` in layout.rblua, defaults to `"windui"`)
+3. `src/misc/helpers/globals.lua` — your bootstrap (`local func = {}` etc.)
+4. `src/misc/remotes.lua` — remote wrappers
+5. All other `src/**/*.rblua|.lua` — alphabetical by path
+6. `src/ui/layout.rblua` then `src/ui/pages/*.rblua` — UI wiring
+7. Generated `_DEFAULTS_RUNNER` — applies all `default=` values after 0.5 s
+
+**Key consequence:** `local` variables from earlier files **are** visible in later files as Lua upvalues. This is intentional — `func.GetCachedPlayers` defined in `globals.lua` is accessible everywhere.
+
+---
+
+## Game-load guard
+
+For features that activate Roblox services that may not be ready when the script is injected early, defer activation with:
+
+```lua
+init {
+    task.spawn(function()
+        if not game:IsLoaded() then game.Loaded:Wait() end
+        -- safe to use RunService, workspace services, etc. here
+        RS:BindToRenderStep("__Key__", Enum.RenderPriority.Last.Value, function()
+            -- ...
+        end)
+    end)
+
+    -- cleanup bind OUTSIDE spawn so it always fires even if load hasn't completed
+    MyComponent:bind("_rs", { Disconnect = function()
+        RS:UnbindFromRenderStep("__Key__")
+    end })
+}
+```
+
+---
+
+## Obfuscator config (Prometheus)
+
+If `rb/prometheus_config.lua` exists it overrides the default `--preset`. Exclude steps that break the runtime:
+
+| Step | Why to exclude |
+|---|---|
+| `Vmify` | Breaks Roblox member-access patterns at runtime |
+| `AntiTamper` | Uses `debug` library — unavailable in exploit environments |
+| `EncryptStrings` | Strings used as service/member names are corrupted → `X is not a valid member` errors |
+
+Minimal safe set: `ConstantArray` (StringsOnly), `NumbersToExpressions`, `WrapInFunction`.
+
+---
+
+## What NOT to do
+
+- **Do not** use `require()` anywhere — flat compilation, no module system
+- **Do not** assign `func.X = function()` inside a component's `init {}` — use `local function`
+- **Do not** call `GetChildren()` in tight loops — use `func.GetCachedPlayers()` / `func.GetCachedTitans()`
+- **Do not** put game-specific code in `rb/pulse/helpers/` — it is a game-agnostic framework library
+- **Do not** use `Components.SomeComponent.x()` to reference your **own** component's signals — use `ComponentName.x()` directly
+- **Do not** use `wait()` or `spawn()` — always use `task.wait()` / `task.spawn()` / `task.delay()`
+- **Do not** nest `WaitForChild` chains inside loops or callbacks — cache at the top of `init {}`

package/templates/deploy_config.example

@@ -0,0 +1,17 @@
+# .rb-deploy — GitHub deployment config for rb deploy
+# Copy this file to .rb-deploy and fill in your details.
+# .rb-deploy is gitignored — never commit it (it contains your token).
+
+# GitHub Personal Access Token — needs 'repo' and 'contents' scope
+# Create one at: https://github.com/settings/tokens
+GITHUB_TOKEN=ghp_your_token_here
+
+# The GitHub repo to push the obfuscated script to
+# Create a separate empty public repo for this (e.g. "yourname/my-script-release")
+GITHUB_REPO=yourname/my-script-release
+
+# Filename in the repo (default is fine)
+GITHUB_FILE=script.obf.lua
+
+# Branch to push to
+GITHUB_BRANCH=main

package/templates/example_esp.rblua

@@ -0,0 +1,69 @@
+-- PlayerESP — example component. Customize or delete this file.
+component {
+    signal enabled = false
+
+    init {
+        Pulse.Notify.onToggle(PlayerESP.enabled, "Player ESP")
+
+        local _CoreGui  = game:GetService("CoreGui")
+        local _Players  = game:GetService("Players")
+        local _highlights = {}
+
+        local function _addHighlight(player)
+            if not player.Character then return end
+            if _highlights[player] then return end
+            local hl = Instance.new("Highlight")
+            hl.DepthMode        = Enum.HighlightDepthMode.AlwaysOnTop
+            hl.FillColor        = Color3.fromRGB(255, 60, 60)
+            hl.FillTransparency = 0.4
+            hl.OutlineColor     = Color3.fromRGB(255, 60, 60)
+            hl.Adornee          = player.Character
+            hl.Parent           = _CoreGui
+            _highlights[player] = hl
+            Pulse.Log.trace("PlayerESP", "highlighted", { name = player.Name })
+        end
+
+        local function _removeHighlight(player)
+            if _highlights[player] then
+                _highlights[player]:Destroy()
+                _highlights[player] = nil
+            end
+        end
+
+        local function _clearAll()
+            for _, hl in pairs(_highlights) do hl:Destroy() end
+            _highlights = {}
+        end
+
+        local _loop = Pulse.Loop.new(1.0, function()
+            for _, player in ipairs(func.GetCachedPlayers()) do
+                if player ~= _Players.LocalPlayer then
+                    _addHighlight(player)
+                end
+            end
+        end)
+
+        local function espLoop(value)
+            if value then
+                _loop:start()
+                Pulse.Log.info("PlayerESP", "started")
+            else
+                _loop:stop()
+                _clearAll()
+                Pulse.Log.info("PlayerESP", "stopped")
+            end
+        end
+    }
+
+    on enabled { espLoop(v) }
+
+    on CharacterAdded {
+        if not enabled then return end
+        _clearAll()
+        _loop:start()
+    }
+
+    ui {
+        toggle "Player ESP"  -> enabled  tip="Highlight all players through walls"
+    }
+}