Struct Vm 

pub struct Vm {
    pub stack: Vec<VmValue>,
    pub globals: HashMap<String, VmValue>,
    pub output: Vec<String>,
    pub file_path: Option<String>,
    pub public_items: HashSet<String>,
    pub package_roots: HashMap<String, PathBuf>,
    pub project_root: Option<PathBuf>,
    pub schema_registry: SchemaRegistry,
    pub secret_vault: SecretVault,
    pub security_policy: Option<SecurityPolicy>,
    /* private fields */
}

The bytecode virtual machine.

Fields

stack: Vec<VmValue>

Register stack

globals: HashMap<String, VmValue>

Global variables

output: Vec<String>

Captured output (for testing)

file_path: Option<String>

Current file path (for relative imports)

public_items: HashSet<String>

Tracks which globals are public (for module export filtering)

package_roots: HashMap<String, PathBuf>

Package roots: package_name → source directory

project_root: Option<PathBuf>

Project root (where tl.toml lives)

schema_registry: SchemaRegistry

Schema registry for versioned schemas

secret_vault: SecretVault

Secret vault for credential management (zeroed on drop)

security_policy: Option<SecurityPolicy>

Security policy (optional, set via –sandbox)

Implementations

impl Vm

pub fn new() -> Self

pub fn execute(&mut self, proto: &Prototype) -> Result<VmValue, TlError>

Execute a compiled prototype.

pub fn debug_load(&mut self, proto: &Prototype)

Prepare the VM for debug execution by pushing a call frame without running.

pub fn debug_step(&mut self) -> Result<Option<VmValue>, TlError>

Execute a single instruction in debug mode. Returns:

• Ok(None) → instruction executed, more to go
• Ok(Some(val)) → execution completed with return value
• Err → runtime error

pub fn debug_current_line(&self) -> u32

Get the current source line number (1-based) or 0 if unknown.

pub fn debug_current_function(&self) -> String

Get the current function name being executed.

pub fn debug_is_done(&self) -> bool

Check if the VM has finished executing (no more frames).

pub fn debug_get_global(&self, name: &str) -> Option<&VmValue>

Get a global variable by name.

pub fn debug_get_local(&self, name: &str) -> Option<&VmValue>

Get a local variable by name (looks in top_level_locals of current frame).

pub fn debug_locals(&self) -> Vec<(String, &VmValue)>

Get all local variables in the current frame.

pub fn debug_current_ip(&self) -> usize

Get the current IP (instruction pointer).

pub fn debug_step_line(&mut self) -> Result<Option<VmValue>, TlError>

Run until the next source line changes (step over).

pub fn debug_continue( &mut self, breakpoints: &[u32], ) -> Result<Option<VmValue>, TlError>

Continue execution until a breakpoint line is hit or execution completes.

pub fn call_builtin( &mut self, id: u16, args_base: usize, arg_count: usize, ) -> Result<VmValue, TlError>

pub fn dispatch_method( &mut self, obj: VmValue, method: &str, args: &[VmValue], ) -> Result<VmValue, TlError>

pub fn execute_single_instruction( &mut self, inst: u32, proto: &Prototype, base: usize, ) -> Result<Option<VmValue>, TlError>

Execute a single bytecode instruction at the given base offset. Used by the LLVM backend’s Tier 3 fallback to run complex opcodes on the VM.

Trait Implementations

impl Default for Vm

fn default() -> Self

Returns the “default value” for a type.