Summary of the project: dependencies, plugins and their contributions, assets, last build size.

Run the asset pipeline: every asset id, type, size and importer, plus generated files, warnings and possibly unused ids.

Build for production and return the size report (raw, gzip, brotli per file). leaks lists dev-only code found in the output; it must be empty.

Run the logic tests in tests/**/*.test.ts (keiko): the real game in Node, no browser, in milliseconds. Each failure has its message, the source line, and the game's tick, scene and state when it failed. Use after every change; write a test for each mechanic you add.

Run scenarios/*.json (or the given files) in a headless browser. Returns per-step results, runtime errors, captures and final state.

Play the game headlessly with random but plausible input (movement keys held, action keys tapped) to find runtime errors, stuck states and back-and-forth loops. Each finding includes the explained error (kind, source-mapped file:line, hint) and repro: a scenario file that replays it exactly. Pass that file to run_scenarios to reproduce, then again after fixing to verify. The same seed gives the same inputs.

Connect to the game. auto (default): attach to the human's live game if debuff dev has it open in a browser, else start a private headless copy, paused. Returns the mode, state and how many notes the human has flagged. Replaces any running session.

Current scene, tick, time, renderer, frame stats, the scene's inspect() data and plugin inspect data.

Advance the simulation by fixed steps (60 per second by default) and return the new state.

Keyboard or pointer input. press/release take a KeyboardEvent.code (e.g. Space, ArrowLeft, KeyZ). tap/pointer_down/pointer_move take logical x, y. Input takes effect on the next game_step.

Every tunable param group: schema (type, default, min, max, units, description) and current values.

Set a tunable param live. Values are validated against the param's type and range. Changes last until game_start or a reload.

Screenshot of the current frame as a PNG image.

Pause or resume a live game (headless games are always paused). game_step also pauses first.

Recent frames, oldest first: intervalMs (what the player feels), updateMs, renderMs, steps (>1 means catching up), quads, drawCalls and longTaskMs (browser-reported main-thread stalls). Use it to explain stutter; in headless mode times reflect stepping, not real play.

Why the game stutters, from myaku: frame-time percentiles (p50/p95/p99), hitches per minute, and the worst hitches explained. Each has a cause (script, gc, upload, compile, layout, throttled, hidden, unknown), a confidence, the script and function to look at when known, and a hint. Spans show time in debuff's update and render. Prefer this over game_frames to explain stutter; measure in live mode, since headless stepping doesn't reflect real play.

Moments the human flagged in the overlay (live mode): their words, the tick, the scene's inspect() state then, and the frames leading up to it.

Everything played since the game loaded (keys, pointer, param changes) up to toTick (default: now), saved as a scenario in .debuff/replays/ that replays it exactly. Use a note's tick to reproduce what the human saw when they flagged it, then run_scenarios with the returned file. warnings lists anything a replay can't reproduce (for example slow motion).

Live mode only. Take the human's game back (or forward, within the known session) to tick: the page reloads, replays the session's inputs to that tick and stays paused, so the state is exactly what it was then. Use a note's tick to look at the moment the human flagged. The page needs a second to reload; then use game_state or game_capture.

Runtime errors since the game started, explained: kind (your-code, debuff-usage, debuff-bug, outside), where (source file:line, source-mapped), a hint, the loop phase and tick, and a repeat count. A loop error stops the game; fix it, then game_pause false to resume. For debuff-bug, tell the human and share reportUrl rather than working around it.

Headless: close the browser and dev server. Live: resume the human's game and disconnect.