Struct Session 

pub struct Session<'p> { /* private fields */ }

A VM whose program has run (or is about to), open to calls from the host.

Implementations

impl<'p> Session<'p>

pub fn new(vm: Vm<'p>, interner: &Interner) -> Self

Hold vm open for host calls. Nothing runs until Session::run_main.

pub fn run_main(&mut self) -> Result<(), String>

Run the program’s main code, once. A failure is reported and the session stays callable, exactly as a browser can still call into a module whose main trapped.

pub fn take_unhandled(&mut self) -> Option<(String, Option<u32>)>

The failure a page entry the program took itself contained and no handler absorbed, with its failure site — the host carrying the page on takes it as the page’s failure (Vm::take_unhandled).

pub fn invoke( &mut self, name: &str, args: Vec<RuntimeValue>, ) -> Result<RuntimeValue, String>

Call the function the program names name, with args in parameter order.

pub fn call_value( &mut self, callee: &RuntimeValue, args: Vec<RuntimeValue>, ) -> Result<RuntimeValue, String>

Call a closure the program handed out — a completion, a listener, a route handler.

pub fn reload(&mut self) -> Result<(), String>

A page reload: the program re-instantiated with the same configuration and its main run again. Every global starts over; what lives outside the program (the document recorder, browser storage) is the host’s to keep or clear.

pub fn has(&self, name: &str) -> bool

Whether the program defines a function named name.

pub fn global_text(&self, name: &str) -> Option<String>

The current value of the named global, shown exactly as Show would render it — None when the program declares no such global, or it has not been assigned one yet. The read a host needs for state a lowering writes into a global specifically so the host can see it.

pub fn global_len(&self, name: &str) -> Option<usize>

The number of top-level elements the named global holds, when it is a List/Set ([a, b, c]) or a Map ({k: v, k: v}) — None when the global does not exist, has no value yet, or does not display as one of those two bracket shapes. Reads Session::global_text’s display string rather than the VM’s own value representation (nothing in this crate exposes that to a host), so it walks the string BRACKET-DEPTH-AWARE — counting a comma only at depth 1, never inside a nested collection’s own brackets — the one thing that would otherwise make this indistinguishable from a naive split. It remains unsound only for a leaf value whose OWN display contains an unbracketed ,/[/{/}/] (a Text, which displays raw and unquoted) — exactly why this is a length probe for a table of plain scalars (an Int-keyed listener/site map, the shape a boundedness proof measures), not a general-purpose value parser.

pub fn lines(&self) -> &[String]

Every line the program has shown, main and every call since, in order.

Trait Implementations

impl LoweredCalls for Session<'_>

fn take_unhandled(&mut self) -> Option<(String, Option<u32>)>

A failure the page’s own code contained while it ran — a turn a driving verb the program runs on its own page took (crate::semantics::builtins::BuiltinId::DomDispatchEntry), whose failure door already heard it and no handler absorbed — with its failure site, for the host to hold as the page’s failure. None for an engine whose entries report through this host alone.

fn call( &mut self, name: &str, args: Vec<RuntimeValue>, ) -> Result<RuntimeValue, String>

fn call_value( &mut self, callee: &RuntimeValue, args: Vec<RuntimeValue>, ) -> Result<RuntimeValue, String>

fn has(&self, name: &str) -> bool

fn reload(&mut self) -> Result<(), String>

The page reloaded: a fresh instance of the same program, its main run again.

fn lines(&self) -> &[String]

Every line the engine has shown, main and every call since, in order.

fn failure_site(&self) -> Option<u32>

The failure site (Stmt::Site) in force when the most recent failed call trapped — where in the page’s source it failed — for an engine that tracks one.