Detect overlapping elements to find layout bugs and broken click targets.

• Interactive overlaps (severity: high): two clickable regions overlap, causing unreliable clicks

• Visual overlaps (severity: low): sibling elements with overlapping bounds (parent-child overlap is normal and ignored) Returns overlap pairs with their bounds, overlap rectangle, and overlap area in pixels.

Directly click an interactive button by its ID, bypassing coordinate-based hit testing. Works even if the button is scrolled off-screen or obscured by other elements. Use list_interactives to discover available button IDs.

Connect to a game instance on a specific port (and optionally host). Sets up both DevBridge and SSE connections. Must be called before using any other tools. Default port is 9001, but the actual port should be obtained from the game's stdout output, e.g.: [DevBridge] Listening on port 9002

Transform coordinates between local and global space relative to a named element. Use to_local to convert scene coords to element-local, to_global to convert element-local to scene coords.

Parse and validate a .manim source snippet. Returns parsed node names and per-node buildErrors[]. Each build error has 'node' (programmable name or '') and 'error' (message); runtime builder failures additionally include 'file', 'line', 'col', and optional 'code' ('not_a_number', 'missing_ref', etc.) for clickable diagnostics.

Hit-test a screen position to find all scene graph objects at the given coordinates, sorted front-to-back by depth

Invoke a game-specific custom query or command registered by the running game. Use list_game_ops to discover available ops and their param shapes. Returns {kind: "query"|"command", op, result}. Errors with code "not_found" for unknown ops, "internal" if the handler throws.

Poll recent hits from DevBridge.debugger(data, pause?) calls placed in the game (JS-debugger-style breakpoint). Each hit has {id, data, paused, file, line, method, timestamp}. Use since_id from a previous call as a cursor to get only new hits. Hits also arrive in real time as SSE 'debugger' events (shown as warning-level log notifications). If paused=true, the game is paused at the hit — resume with pause({paused:false}).

Get accumulated runtime errors/exceptions since last query

Poll custom game events emitted via DevBridge.emitEvent(name, data) on the Haxe side. Events also arrive in real time as SSE "game_event" notifications. Mirrors the get_debugger_hits cursor pattern: use since_id from the previous response to fetch only new events.

Get current parameter values and definitions for a live programmable instance

Get detailed screen manager state: mode, active screens, transition status, pause state, element/interactive counts

Get recent trace() output from the running application (ring buffer of last 200 lines)

Get all active tweens/animations with their targets, duration, elapsed time, and progress

Get detailed info about a named element on a screen (position, size, visibility, text content)

Deep inspection of a live programmable: current parameter values, slots, dynamic refs, named elements, interactives, and settings

List all live incremental-mode programmables currently in the scene. Returns current parameter values, parameter definitions (types), named elements, slots, interactive counts, position, and visibility for each. Only programmables built with incremental:true are tracked.

List all loaded sprite atlases with their tile/sprite names

List all loaded .manim builders with their programmable names and parameter definitions

List all registered font names available for use in .manim files

List game-specific custom operations registered by the running game. Returns {queries, commands, events}, each entry has {op|name, description, params|payload} where params/payload is a schema-lite hint (e.g. {lane: "int", count: "int?"}). Call this first to discover what the current game exposes, then use game_op to invoke a query/command, or get_game_events to poll events.

List all registered interactive hit-test regions on a screen with their IDs, positions, and metadata

List all loaded resources: sprite sheets, fonts, .manim files, .anim files

List all registered screens with their active/failed status

List all slots (swappable containers) on a programmable with their occupied/empty status

Pause or resume the game loop. When paused, all game logic, animations, and rendering stop but the DevBridge remains responsive for inspection. Use step() to advance frame-by-frame while paused.

Get FPS, draw calls, triangle count, object count, and scene dimensions

Health check - returns uptime and port. Lightweight alternative to performance for connection testing.

Cleanly shut down the running game application

Hot-reload a .manim file (or all files if no file specified). On failure, errors[] entries include 'message', 'file', 'line', 'col', 'errorType' ('parse' | 'build' | 'signatureIncompatible'), and 'context' — builder errors now carry accurate file/line/col instead of 0 placeholders.

Dump the scene graph tree showing object types, positions, visibility, and names

Capture the current frame as a PNG image. Provide width and/or height to scale down (aspect ratio is preserved when only one is given; error if both are given with wrong aspect ratio).

Inject an input event into the running application. Event types:

• click: mouse click (push + release) at x,y with button (0=left, 1=middle, 2=right)

• mouse_down / mouse_up: separate push/release at x,y

• move: mouse move to x,y

• key_down / key_up: keyboard key press/release with keyCode (hxd.Key constants)

• key_press: key_down + key_up combined

• text: text input with charCode

• wheel: mouse wheel with delta at x,y

Common key codes: SPACE=32, ENTER=13, ESCAPE=27, TAB=9, A=65, 0=48, UP=38, DOWN=40, LEFT=37, RIGHT=39, F1=112

Send a sequence of input events with game frame steps between them. Enables multi-step interactions (drag-and-drop, slider scrub, card hand drag) in a single call.

Each entry in the events array is either:

• An event: {type, x, y, button, ...} (same params as send_event)

• A frame step: {step: N} — advance N game frames (processes animations, state machines, zone detection)

The game must be paused for frame steps to work. Use auto_pause:true to auto-pause before and resume after.

Example drag: [ {type:"mouse_down", x:100, y:200}, {step:2}, {type:"move", x:200, y:150}, {step:1}, {type:"move", x:300, y:100}, {step:1}, {type:"mouse_up", x:300, y:100} ]

Set a parameter on a live programmable BuilderResult (uses incremental mode)

Toggle visibility of a named element on a screen

Advance the game by N frames while paused, then re-pause. Game must be paused first.

Check if the system is idle (no active tweens, no screen transitions). Returns current state without blocking.