Struct JsHost 

pub struct JsHost {
    pub funcs: Vec<FuncDef>,
    pub tries: Vec<TryDef>,
    pub error: Option<String>,
    pub exc: Option<Value>,
    pub signal: Option<Signal>,
    pub nextticks: VecDeque<Task>,
    pub microtasks: VecDeque<Task>,
    pub macrotasks: Vec<Timer>,
    /* private fields */
}

The JavaScript runtime.

Fields

funcs: Vec<FuncDef>

Function templates, indexed by def id.

tries: Vec<TryDef>

try/catch/finally block templates, indexed by try id.

error: Option<String>

exc: Option<Value>

The in-flight thrown value, if any (JS throw).

signal: Option<Signal>

nextticks: VecDeque<Task>

process.nextTick callbacks (drained before promise microtasks).

microtasks: VecDeque<Task>

Promise-reaction / queueMicrotask microtasks.

macrotasks: Vec<Timer>

setTimeout/setInterval/setImmediate macrotasks.

Implementations

impl JsHost

pub fn new() -> JsHost

pub fn proto_of(&self, v: &Value) -> Option<Value>

The [[Prototype]] of a heap value, if explicitly linked.

pub fn set_proto(&mut self, v: &Value, proto: Value)

Set v’s [[Prototype]] to proto. Null links the object as an explicit null-prototype object (recorded so instanceof Object reads false); undefined just clears any link without the null marker.

pub fn has_null_proto(&self, v: &Value) -> bool

Whether v’s [[Prototype]] was explicitly set to null.

pub fn object_proto(&self) -> Value

pub fn tag_proto_class(&mut self, proto: &Value, class_val: Value)

Record that the prototype object proto belongs to the class constructor class_val (so instances can recover their constructor).

pub fn class_of(&self, obj: &Value) -> Option<Value>

The class constructor value nearest in obj’s prototype chain, if any.

pub fn ctor_name(&self, obj: &Value) -> String

The constructor display name of obj for util.inspect (empty ⇒ plain object, no prefix).

pub fn fn_prop(&self, v: &Value, name: &str) -> Option<Value>

A function’s own-property table (created on demand).

pub fn class_static(&self, class_val: &Value, name: &str) -> Option<Value>

A class static member, inherited down the constructor chain: a subclass sees its superclass’s static methods/fields (Sub.create → Base.create).

pub fn set_fn_prop(&mut self, v: &Value, name: &str, val: Value)

pub fn builtin_static(&self, ns: &str, name: &str) -> Option<Value>

A user-assigned static on a builtin namespace (Error.prepareStackTrace).

pub fn set_builtin_static(&mut self, ns: &str, name: &str, val: Value)

Assign a static on a builtin namespace (persists across fresh Builtin handles for the same namespace).

pub fn fn_prop_keys(&self, v: &Value) -> Vec<String>

pub fn set_accessor( &mut self, owner: &Value, key: &str, get: Option<Value>, set: Option<Value>, )

Install an accessor (get, set) for key on the object owner.

pub fn own_accessor( &self, owner: &Value, key: &str, ) -> Option<(Option<Value>, Option<Value>)>

The accessor (get, set) for key directly on owner (no chain walk).

pub fn new_symbol(&mut self, desc: Option<String>) -> Value

A fresh unique Symbol(desc) value.

pub fn symbol_for(&mut self, key: &str) -> Value

The shared Symbol.for(key) value (interned by description).

pub fn well_known_iterator(&mut self) -> Value

The well-known Symbol.iterator (a fixed shared symbol whose internal property key is @@iterator).

pub fn well_known_async_iterator(&mut self) -> Value

The well-known Symbol.asyncIterator (internal key @@asyncIterator).

pub fn property_key(&self, v: &Value) -> String

The internal property-key string for a value used as a key. A Symbol maps to a stable per-symbol string so symbol-keyed props round-trip; Symbol.iterator maps to the sentinel @@iterator.

pub fn null(&self) -> Value

pub fn is_null(&self, v: &Value) -> bool

pub fn program_offsets(&self) -> (usize, usize)

pub fn load_program(&mut self, funcs: Vec<FuncDef>, tries: Vec<TryDef>)

pub fn try_def(&self, id: usize) -> Option<TryDef>

pub fn alloc(&mut self, obj: JsObj) -> Value

pub fn get(&self, v: &Value) -> Option<&JsObj>

pub fn get_mut(&mut self, v: &Value) -> Option<&mut JsObj>

pub fn new_str(&mut self, s: impl Into<String>) -> Value

pub fn new_array(&mut self, items: Vec<Value>) -> Value

pub fn new_object(&mut self, props: IndexMap<String, Value>) -> Value

pub fn as_str(&self, v: &Value) -> Option<String>

pub fn frame_depth(&self) -> usize

Number of active call frames (the debugger’s step-depth reference).

pub fn set_cur_line(&mut self, line: u32)

Record the source line the innermost frame is executing (DAP line hook).

pub fn dbg_stack(&self) -> Vec<(String, u32)>

The call stack as (frame name, line) pairs, innermost first — for the DAP stackTrace. owner carries the function name where known.

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

The innermost frame’s locals as (name, inspect) pairs — for DAP variables.

pub fn read_name(&self, name: &str) -> Option<Value>

Scope-chain read: local + enclosing chain, then globals.

pub fn read_global(&self, name: &str) -> Option<Value>

pub fn set_name(&mut self, name: &str, val: Value)

Assign to an existing binding up the scope chain, else create a global (JS assignment to an undeclared name targets the global object).

pub fn declare_name(&mut self, name: &str, val: Value)

Declare a new binding in the current scope (let/const/var).

pub fn set_global(&mut self, name: &str, val: Value)

pub fn del_name(&mut self, name: &str)

pub fn current_this(&self) -> Option<Value>

pub fn current_env_capture(&self) -> Env

pub fn current_new_target(&self) -> Option<Value>

pub fn super_context(&self) -> (Option<Value>, Vec<(String, Value)>)

The (parent_ctor, this_class_fields) for a running constructor’s super(...), derived from the frame’s home class.

pub fn super_resolve(&self, name: &str) -> SuperRef

Resolve super.name to either the parent-prototype getter (to be invoked by the caller, outside any host borrow) or a directly-usable value.

pub fn take_error(&mut self) -> Option<String>

pub fn raise_str(&mut self, class: &str, msg: &str) -> String

impl JsHost

pub fn type_of(&self, v: &Value) -> &'static str

The typeof string for v.

pub fn truthy(&self, v: &Value) -> bool

JS truthiness: false / 0 / -0 / NaN / “” / null / undefined are falsy.

pub fn to_number(&self, v: &Value) -> f64

Coerce to a number (ToNumber): the arithmetic-context conversion.

pub fn str_of(&self, v: &Value) -> String

String(v) — the string-coercion form (raw, unquoted).

pub fn console_format(&self, v: &Value) -> String

console.log-style rendering of a top-level argument: bare strings print raw; everything else uses inspect.

pub fn inspect(&self, v: &Value) -> String

util.inspect-style rendering (nested; strings quoted).

pub fn callable_name(&self, v: &Value) -> String

The .name of any callable (function/class/builtin/bound).

pub fn strict_eq(&self, a: &Value, b: &Value) -> bool

Strict equality (===): same type and same value, no coercion.

pub fn is_nullish(&self, v: &Value) -> bool

Whether v is null or undefined.

pub fn loose_eq(&self, a: &Value, b: &Value) -> bool

Loose equality (==) following the ECMAScript Abstract Equality Comparison. Objects reduce via ToPrimitive (which for our heap objects is always their string toString), so [0] == "0" is true (string compare of "0") but [0] == "" is false — never a number coercion of the object.

pub fn arith( &mut self, op: NumOp, a: &Value, b: &Value, ) -> Result<Value, String>

The numeric-hook arithmetic/relational fallback for non-native operands (called by fusevm when at least one operand isn’t Int/Float).

pub fn bitwise( &mut self, tag: i64, a: &Value, b: &Value, ) -> Result<Value, String>

Bitwise/shift ops with JS ToInt32/ToUint32 semantics — or true arbitrary-width BigInt bitwise when both operands are BigInt (mixing a BigInt with a Number throws, matching Node).

pub fn is_bigint_val(&self, v: &Value) -> bool

Whether v is a heap BigInt.

pub fn as_bigint(&self, v: &Value) -> Option<BigInt>

The BigInt value of v (a heap bigint), else None.

pub fn new_bigint(&mut self, b: BigInt) -> Value

Allocate a heap BigInt.

impl JsHost

pub fn iter_vec(&mut self, v: &Value) -> Result<Vec<Value>, String>

Collect an iterable into a vector of values (arrays, strings, Map/Set). Generators and user Symbol.iterator objects go through iter_all, which holds no host borrow across resumes.

pub fn enum_keys(&mut self, v: &Value) -> Vec<Value>

Enumerable string keys of an object/array (for for-in). Internal symbol-keyed props (@@…) are not enumerable.

impl JsHost

pub fn is_generator_val(&self, v: &Value) -> bool

pub fn gen_done(&self, id: u32) -> bool

impl JsHost

pub fn ensure_error_protos(&mut self)

Lazily build the builtin error prototype chain: Error.prototype → Object.prototype, and every specific error’s prototype → Error.prototype. Populated once; instances link to these so e instanceof TypeError and e instanceof Error both hold.

impl JsHost

pub fn func_arity(&self, v: &Value) -> usize

A function’s .length: the count of leading params before the first one with a default or the rest element.

pub fn is_map(&self, v: &Value) -> bool

pub fn is_set(&self, v: &Value) -> bool

impl JsHost

pub fn new_promise(&mut self) -> Value

Allocate a fresh pending promise, returning its heap value.

pub fn promise_id(&self, v: &Value) -> Option<u32>

pub fn promise_state(&self, id: u32) -> PromiseState

pub fn promise_value(&self, id: u32) -> Value

pub fn promise_mark_handled(&mut self, id: u32)

pub fn take_reactions(&mut self, id: u32) -> Vec<PromiseReaction>

Take the pending reactions of a promise (called on settle).

pub fn add_reaction(&mut self, id: u32, r: PromiseReaction)

pub fn settle_promise(&mut self, id: u32, state: PromiseState, value: Value)

pub fn queue_micro(&mut self, cb: Value, args: Vec<Value>)

pub fn queue_nexttick(&mut self, cb: Value, args: Vec<Value>)

pub fn queue_micro_native(&mut self, f: Box<dyn FnOnce() -> Result<(), String>>)

Schedule a native (Rust) microtask — used by Promise reactions and async resumption.

pub fn add_timer( &mut self, delay: f64, callback: Value, args: Vec<Value>, ) -> u64

pub fn io_sender(&self) -> Sender<IoTask>

Clone the I/O sender for a background I/O thread.

pub fn incr_handle(&mut self)

Register a live handle (listener/socket/ref’d resource) keeping the loop alive.

pub fn decr_handle(&mut self)

Release a handle; the loop exits once this reaches 0 with empty queues.

pub fn open_handles(&self) -> usize

pub fn cancel_timer(&mut self, id: u64)

Trait Implementations

impl Default for JsHost

fn default() -> Self

Returns the “default value” for a type.