Struct Debugger 

pub struct Debugger { /* private fields */ }

A self-contained stepping debugger over one compiled program.

Execution is deterministic, so history is the single execution prefix explored so far and cursor is simply where you are looking. Step / step-back / seek / restart all just move the cursor; a new VM op is only ever computed when the cursor reaches the unexplored frontier. That makes step-back, restart, redo, and the time-travel scrubber instant, and reverse-continue a pure cursor walk.

Implementations

impl Debugger

pub fn from_source(src: &str) -> Result<Debugger, String>

Compile src (exactly as the Studio “Run” path does) and arm a debugger at the program’s entry. The program is debugged on the bytecode tier with no JIT, so stepping is per-op and output matches a normal run.

pub fn step(&mut self)

Execute exactly one op (Step Into).

pub fn step_over(&mut self)

Execute one op, but run any function it calls to completion (Step Over).

pub fn step_out(&mut self)

Run until the current function returns (Step Out); from Main, runs to the end.

pub fn resume(&mut self)

Run until the next breakpoint, a block, completion, or the step limit (Continue).

pub fn reverse_resume(&mut self)

Run BACKWARD to the previous breakpoint, or the program entry — reverse continue. Pure cursor motion over the recorded history, a time-travel feature almost no debugger has.

pub fn step_back(&mut self)

Undo the last executed op — time-travel one step backwards.

pub fn seek(&mut self, step: usize)

Jump the time-travel cursor to any already-explored step (the scrubber).

pub fn restart(&mut self)

Rewind to the program entry, keeping the explored history (re-stepping is then instant) and the breakpoints.

pub fn toggle_breakpoint(&mut self, pc: usize)

Toggle a breakpoint on a bytecode pc.

pub fn set_breakpoint(&mut self, pc: usize)

pub fn clear_breakpoint(&mut self, pc: usize)

pub fn breakpoints(&self) -> Vec<usize>

pub fn disassembly(&self) -> &[DisasmLine]

The full disassembly (the bytecode tape).

pub fn is_running(&self) -> bool

Whether the program is still paused mid-execution at the current cursor (cheap, no snapshot build). false once it has finished, blocked, or errored here.

pub fn snapshot(&self) -> DebugSnapshot

Build a serde snapshot of the current paused state for the UI.

pub fn variable_timeline(&self) -> VarTimeline

The variable oscilloscope: every Main-frame variable’s value across the recorded execution, with a playhead at the cursor. On-demand (only the Timeline tab calls it), tail-windowed to the most recent [TIMELINE_MAX_STEPS] steps so a long loop stays cheap and viewable.

pub fn observed_invariants(&self) -> Vec<VarInsight>

Observed invariants (Daikon-style dynamic detection): for each variable, reduce its recorded trace into the facts that held over this run — constant, monotonic, value range, distinct count. Dynamic, not a static proof (the formally-proven counterpart comes from the Oracle), but exact for what happened.

pub fn proven_invariants(&self) -> Vec<ProvenInsight>

Proven invariants: the Oracle’s statically-verified facts per variable (range, non-negativity, scalar type) — guarantees that hold on every run, not just this one. The formal companion to Debugger::observed_invariants. Only variables with at least one non-trivial proven fact are returned, sorted by name.

pub fn assert_at_cursor(&self, predicate: &str) -> AssertionResult

Live proof at a breakpoint: assert a comparison predicate (x < y, x >= 0, sum == 13) and get both lenses — whether it holds now (concretely, from the live values) and whether it is proven for every run (from the Oracle’s proven ranges, by sound interval entailment; pure Rust, no Z3). The dual answer is the point: a thing can be true now yet unproven in general, or proven yet about a value not yet reached.

pub fn provenance(&self, reg: u16) -> Option<CausalNode>

Causal provenance: trace the value currently in innermost-frame register reg back to the exact op that produced it, and recursively the ops that produced that op’s inputs — the precise answer to “why is this value here?”. Returns None only if the register holds nothing at the cursor.