Struct JsHost 

pub struct JsHost {

    pub funcs: Vec<FuncDef>,
    pub scripts: Vec<Arc<str>>,
    pub tries: Vec<TryDef>,
    pub error: Option<String>,
    pub exc: Option<Value>,
    pub signal: Option<Signal>,
    pub pending_rejections: Vec<u32>,
    pub process_listeners: IndexMap<String, Vec<ProcListener>>,
    pub nextticks: VecDeque<Task>,
    pub microtasks: VecDeque<Task>,
    pub macrotasks: Vec<Timer>,
    pub exit_code: Option<i32>,
    pub exiting: bool,
    /* private fields */
}

The JavaScript runtime.

Fields

funcs: Vec<FuncDef>

Function templates, indexed by def id.

scripts: Vec<Arc<str>>

Every script text a loaded program was parsed from; a FuncDef’s script indexes it and its span slices it.

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>

pending_rejections: Vec<u32>

Promises that settled REJECTED this tick. Drained at each microtask checkpoint: any still without a handler is an unhandled rejection.

process_listeners: IndexMap<String, Vec<ProcListener>>

process.on(event, fn) listeners, by event name.

nextticks: VecDeque<Task>

process.nextTick callbacks (drained before promise microtasks).

microtasks: VecDeque<Task>

Promise-reaction / queueMicrotask microtasks.

macrotasks: Vec<Timer>

setTimeout/setInterval/setImmediate macrotasks.

exit_code: Option<i32>

process.exitCode: the code the process exits with when the event loop drains, or None while unset. Separate from an explicit process.exit(n), which exits immediately with n.

exiting: bool

Whether the exit event has already been emitted, so the process.exit path and the end-of-loop path cannot both fire it (Node’s _exiting).

Implementations

impl JsHost

pub fn new() -> JsHost

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

Whether v IS the one globalThis object (not merely an object).

pub fn global_object(&mut self) -> Value

The globalThis object — one per host, so its identity and its properties both survive across reads.

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 inspects_null_proto(&self, v: &Value) -> bool

Whether util.inspect renders v with the [Object: null prototype] tag. That is a question about the object’s ACTUAL [[Prototype]], which for Object.prototype is null even though nothing ever set it so: it is the chain root and was never passed through set_proto, so the explicitly-nulled registry does not hold it and console.log(Object .prototype) printed a bare {} where node prints the tag.

Kept apart from Self::has_null_proto, which nine other call sites ask about whether Object.prototype’s own methods and __proto__ accessor are INHERITED. Object.prototype inherits nothing and still owns all of them.

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_owning_proto(&self, v: &Value) -> Option<Value>

The class whose prototype object IS v, if v is one.

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 owns_prototype(&self, v: &Value) -> bool

Whether a callable owns a prototype property. MakeConstructor (10.2.5) runs for an ordinary function definition and for every generator; an arrow, a MethodDefinition, an async function and a bound function are not constructors and own none.

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 class_builtin_ancestor(&self, class_val: &Value) -> Option<Value>

The first extends ancestor that is NOT a user class — the builtin constructor a class chain bottoms out in (class D extends Array {} → the Array builtin), or None for a chain of user classes only.

class_static walks ClassVal.parent and gives up the moment the parent stops being a Class, so a static declared by the BUILTIN half of the chain was unreachable: D.from read undefined where node inherits Array.from. Returning the ancestor lets the caller finish the lookup with an ordinary property read, which is what reaches a builtin’s statics.

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 remove_builtin_static(&mut self, ns: &str, name: &str) -> bool

delete <ns>.<name> for a script-assigned static. Reports whether the key was there — without this, delete Array.prototype.patch answered true and left the entry in place, so the patch outlived its own removal.

pub fn builtin_static_keys(&self, ns: &str) -> Vec<String>

Every namespace a script has assigned a static onto, with that namespace’s assigned keys — the source of the user-added half of Object.getOwnPropertyNames(Array.prototype).

pub fn remove_fn_prop(&mut self, v: &Value, name: &str) -> bool

Drop an own property from the side table (delete arr.foo, delete fn.tag). Reports whether the key was there.

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 remove_accessor(&mut self, owner: &Value, key: &str)

The accessor (get, set) for key directly on owner (no chain walk). Drop an own accessor property entirely, marker and all.

delete obj.accessorProp used to clear only the property map, and an accessor does not live there — so the delete reported success while the getter kept answering and in kept reporting the key.

pub fn accessor_to_data(&mut self, owner: &Value, key: &str, value: Value)

Turn an own accessor property into a data property carrying value, keeping its place in the own-key order.

set_accessor records that order with an @@ord: marker in the property map rather than a real key, so deleting the accessor and inserting the value would append the key at the end instead. Node reports { a: 1, get b() {}, c: 3 } redefined through Object.defineProperty(o, 'b', { value }) as a, b, c.

pub fn move_index_state(&mut self, src: u32, dst: u32)

Move the per-heap-index bookkeeping of src onto dst.

Used when one object becomes another in place (a class extending a builtin exotic). The prototype link is deliberately NOT moved: dst already points at the leaf class’s prototype, which is the one its methods must resolve through.

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

pub fn own_accessor_keys(&self, owner: &Value) -> Vec<String>

The own accessor-property keys of owner, in installation order.

pub fn set_prop_attrs(&mut self, owner: &Value, key: &str, attrs: PropAttrs)

Record non-default attributes for owner[key]. Storing the default shape clears the entry so the table only ever holds deviations.

pub fn copy_prop_attrs(&mut self, from: &Value, to: &Value)

Copy every recorded property attribute from from to to. A pass that rebuilds an object (JSON.stringify’s toJSON walk) must carry them across or the copy silently re-exposes non-enumerable slots.

pub fn prop_attrs(&self, owner: &Value, key: &str) -> PropAttrs

The attributes of own property owner[key] (all-true when unrecorded).

pub fn is_enumerable(&self, owner: &Value, key: &str) -> bool

Whether own property owner[key] shows up in for-in/Object.keys. Internal slots (@@…) and private class fields (#…) never do.

pub fn hide_prop(&mut self, owner: &Value, key: &str)

Mark owner[key] non-enumerable, leaving it writable/configurable — the shape of every V8 “hidden but real” own property.

pub fn can_write_prop(&self, owner: &Value, key: &str) -> bool

Whether a plain owner[key] = v assignment is allowed to land. A non-writable data property silently ignores the write in sloppy mode, which is the mode every script here runs in; so does adding a new key to a non-extensible object.

pub fn prevent_extensions(&mut self, v: &Value)

Mark v closed to new properties (Object.preventExtensions).

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

pub fn seal_object(&mut self, v: &Value, freeze: bool)

Apply Object.seal (freeze == false) or Object.freeze (true): close the object and strip configurable — and, when freezing, writable — from every own property, data and accessor alike.

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

Object.isSealed (freeze == false) / Object.isFrozen (true).

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

A fresh unique Symbol(desc) value.

pub fn symbol_of_key(&self, k: &str) -> Option<Value>

The symbol VALUE an internal symbol property key (@@sym:<id> or a well-known @@iterator) came from.

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

The own symbol-keyed property keys of v as SYMBOL values — Object.getOwnPropertySymbols / the symbol half of Reflect.ownKeys.

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

The own SYMBOL-keyed enumerable (internal key, value) pairs of v — what CopyDataProperties (object spread, Object.assign) copies alongside the string keys, and what Object.keys / for-in / JSON.stringify deliberately skip.

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

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

pub fn symbol_registry_key(&mut self, sym: &Value) -> Value

Symbol.keyFor(sym): the registry key Symbol.for interned sym under, or undefined for a symbol that is not in the registry at all.

Matched by symbol IDENTITY, not by description — Symbol.for('k') and Symbol('k') share a description and only the first is registered. The @@Symbol.* well-known entries are registry-internal and never a keyFor answer, matching node: Symbol.keyFor(Symbol.iterator) is undefined there.

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 well_known_symbol(&mut self, name: &str) -> Value

A well-known symbol by its ECMAScript name (toPrimitive, toStringTag, …). Its internal property key is @@<name> — see WELL_KNOWN_SYMBOLS and property_key.

Its DESCRIPTION is Symbol.<name>, so String(Symbol.iterator) prints Symbol(Symbol.iterator) as V8 does, while the registry key keeps the @@ prefix — Symbol.for('Symbol.iterator') therefore stays a different symbol, and identification is by id, so a user-made Symbol('Symbol.iterator') is not mistaken for the well-known one.

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 func_source(&self, def_id: usize) -> Option<&str>

The source text of function def_id, when its program kept one.

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

pub fn try_shape(&self, id: usize) -> Option<(bool, Option<String>, bool)>

What try statement id HAS — (has handler, catch parameter name, has finalizer) — without copying its chunks. Running a try used to clone the whole TryDef, so a try inside a loop deep-copied its block, its handler and its finalizer on every iteration just to learn its shape.

pub fn try_chunk(&self, id: usize, part: u64) -> Option<Chunk>

One try part’s bytecode: 0 = block, 1 = handler body, 2 = finalizer. Reached only when no pooled VM already holds that chunk.

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 kind_of(&self, v: &Value) -> Option<ObjKind>

Which variant v points at, without copying its contents. Use this in place of get(v).cloned() whenever only the tag is needed — see ObjKind.

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

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

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

Record that name was declared as a private method or accessor.

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

Whether name was declared as a private method/accessor by some class, as opposed to a private field.

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

The name of the class whose body the running function belongs to. Only a method of that class can even mention its private names, so this is the class a failed brand check must name. The super binding of the frame now running: the owning class name, whether the method is static, and the home object of an object-literal method. An ARROW captures all three at creation, the way it captures this — super inside an arrow means the enclosing METHOD’s super. Whether the activation now running is strict code. Whether v is a function whose own body is SLOPPY — not an arrow, and with no 'use strict' of its own or inherited from its script. This is the receiver test the arguments/caller poison pill keys on: node decides by the FUNCTION, never by the code doing the reading.

pub fn current_strict(&self) -> bool

pub fn set_current_strict(&mut self)

Mark the frame about to run as STRICT — used for a program whose own top level says 'use strict', which has no FuncDef to carry the flag.

pub fn current_home(&self) -> (Option<String>, bool, Option<Value>)

pub fn current_home_class_name(&self) -> Option<String>

pub fn has_private(&self, recv: &Value, key: &str) -> bool

Whether recv — or anything on its prototype chain — carries the private name key. A private FIELD is an own property of the instance; a private METHOD lives on the class prototype, one link up.

pub fn is_hole(&self, arr: &Value, i: usize) -> bool

Whether element i of array arr is an elided element (a “hole”), as opposed to a stored undefined. false for anything that is not an array, and for every index of a dense one.

pub fn has_holes(&self, arr: &Value) -> bool

Whether arr has any elided element at all — one hash probe, and the guard every hole-aware code path takes before doing anything slower.

pub fn hole_indices(&self, arr: &Value) -> Vec<usize>

arr’s hole positions in ASCENDING order, or an empty vec if dense. Sorted because every consumer (own-key enumeration, util.inspect run-grouping) needs index order, and the backing set has none.

pub fn mark_hole(&mut self, arr: &Value, i: usize)

Record element i of arr as elided.

pub fn mark_hole_range(&mut self, arr: &Value, range: Range<usize>)

Record range of arr as elided (a new Array(n), a length grow, or the gap a write past the end opens).

pub fn clear_hole(&mut self, arr: &Value, i: usize)

Element i now holds a real value: it is no longer a hole. Every write to an array index calls this, which is what keeps a stale hole record from outliving the elision it described.

pub fn clear_holes(&mut self, arr: &Value)

arr is dense from here on (fill over the whole array, a fresh dense assignment into an existing handle).

pub fn copy_holes( &mut self, src: &Value, dst: &Value, f: impl Fn(usize) -> Option<usize>, )

Copy src’s elision set onto dst, optionally shifting each position by f. Used by every method that derives a new array whose holes track the source’s (slice, concat, map).

pub fn remap_holes(&mut self, arr: &Value, f: impl Fn(usize) -> Option<usize>)

Rewrite arr’s own elision set in place: f(i) gives the position each existing hole moves to, or None if the mutation removed it. This is the one primitive behind every structural array mutation — shift is i.checked_sub(1), unshift(k) is i + k, reverse is len-1-i, and splice is the general case.

pub fn install_holes(&mut self, arr: &Value, holes: FxHashSet<usize>)

Replace arr’s elision set outright, dropping the record entirely when the new set is empty so has_holes stays a single negative probe for the dense case.

pub fn truncate_holes(&mut self, arr: &Value, len: usize)

Forget any hole at or past len — what a pop, a length shrink or a truncating splice leaves behind.

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 stack_trace_limit(&self) -> usize

The .stack tail for an error created right now: one at <name> line per live frame, innermost first, ending at the module frame.

These are the REAL user frames — node-js has no file:line:column (the per-frame line is only tracked under --dap) and no Node-internal module-loader frames, so .stack names the call chain but can never be byte-identical to V8’s. The names are what makes a thrown error diagnosable; the missing positions are documented in BUGS.md. V8’s Error.stackTraceLimit — how many frames a captured stack keeps.

The default is 10, it is settable, and setting it to 0 is the documented way to make error construction cheap. It did not exist, so the read was undefined and every stack carried every frame regardless.

pub fn stack_frames(&self) -> String

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 is_tdz_global(&self, name: &str) -> bool

Scope-chain read: local + enclosing chain, then globals. Whether name is a module-top-level binding that has not reached its declaration yet. Separate from JsHost::is_tdz, which answers for a block-scoped one by inspecting the value it holds.

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

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

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

Whether name is bound anywhere on the scope chain or in the globals — read_name(..).is_some() without cloning the value it finds. The strict-mode assignment path asks this and nothing else.

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

Assign to an existing binding up the scope chain, else create a global (JS assignment to an undeclared name targets the global object). Assign to an existing binding, or create a global. Returns false when the nearest binding is an immutable (const) one, which the caller turns into TypeError: Assignment to constant variable. — assigning to a const used to succeed SILENTLY, so code that node rejects ran on with a mutated constant.

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

Declare a const binding: the same placement as Self::declare_name, plus recording the name as immutable in whichever scope received it.

pub fn tdz_marker(&mut self) -> Value

The value a lexical binding holds between entering its scope and reaching its declaration — its TEMPORAL DEAD ZONE. One heap object for the whole process, so the check is a heap-index comparison and the marker cannot be produced by any JavaScript expression. It never escapes: every path that could read it throws first.

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

Whether v is the uninitialized-binding marker.

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

Declare name in the CURRENT scope as uninitialized, unless that scope already binds it. Emitted at the top of every scope for each let, const and class declared directly in it, so a read before the declaration throws instead of finding an OUTER binding of the same name — let x = 1; { x; let x = 2 } used to read the outer 1.

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

Declare a new binding in the current scope (let/const). At the top of the module frame there is no local env, so those names become globals; once a block scope is open the binding belongs to that block.

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

Declare a var (or a hoisted function declaration): FUNCTION-scoped, so it skips every open block scope and lands in the activation’s base env. Create a hoisted var binding, initialised to undefined, only when the name is not already bound in this activation.

var bindings come into existence when the scope is entered, not where the declaration is written — f(){ x; var x = 1 } reads undefined rather than throwing. “If absent” is what keeps a parameter intact: in function f(a) { var a; } the var names a binding that already exists and must not be reset, which is also why a bare var x; emits nothing at its own position.

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

pub fn push_scope(&mut self)

Enter a fresh block scope.

pub fn push_var_scope(&mut self) -> Env

Open a scope that is also the activation’s VARIABLE environment, and return the previous one so the caller can restore it.

A block scope is not enough for a strict direct eval: var and a hoisted function declaration bind to base_env, so they walked straight past a plain push_scope and still landed in the caller’s function scope. Only let/const were contained.

pub fn pop_var_scope(&mut self, prev: Env)

Restore the variable environment a push_var_scope replaced.

pub fn pop_scope(&mut self)

Leave the innermost block scope (never pops past the activation’s base).

pub fn copy_scope(&mut self)

Replace the innermost block scope with a fresh copy of its bindings — the per-iteration environment a for (let i …) loop creates, so a closure made in one iteration keeps that iteration’s value.

pub fn scope_snapshot(&self) -> Env

The current block-scope env, for save/restore across a nested chunk.

pub fn restore_scope(&mut self, env: Env)

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

pub fn begin_capture(&mut self)

Start capturing program output in-process. Any text already captured is discarded, so each run starts clean.

pub fn end_capture(&mut self) -> String

Stop capturing and take everything written since begin_capture, returning the empty string when capture was not on. The captured bytes are rendered lossily: this API hands back a String, so a program that wrote non-UTF-8 gets U+FFFD here even though the same write reaches a real stdout byte-exact. Use end_capture_bytes to keep those bytes.

pub fn end_capture_bytes(&mut self) -> Vec<u8>

Stop capturing and take the raw bytes, without the lossy transcription end_capture applies.

pub fn capturing(&self) -> bool

Whether output is being captured — the one thing a caller needs to know before asking the real stream a question (isTTY, cursor position).

pub fn write_out(&mut self, s: &str, stderr: bool)

Write program output: into the capture buffer when capturing, else to the process stream stderr selects. s is written verbatim — callers add their own line ending, as console.log does and process.stdout.write does not.

pub fn write_out_bytes(&mut self, bytes: &[u8], stderr: bool)

Write program output as raw BYTES. process.stdout.write(buf) hands Node a byte string and Node writes it through untouched, so a Buffer holding ff fe 41 reaches stdout as those three bytes. Routing it through a Rust String first replaced every non-UTF-8 byte with U+FFFD — three bytes became seven — so the byte path exists separately from write_out.

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

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

pub fn this_state(&self) -> ThisState

The running activation’s ThisState.

pub fn mark_next_call_derived_ctor(&mut self)

Mark the next user-function activation as a derived constructor.

pub fn bind_super_this(&mut self) -> bool

BindThisValue (9.1.1.3.1) for a super() that has just returned: the nearest derived-constructor activation becomes Bound. That is the top frame, or — for super() inside an arrow — the constructor below the arrow’s own frame. false when it was already bound: the second call.

pub fn take_super_replacement(&mut self) -> Option<Value>

The object a super() call substituted for the instance, if any.

construct_class allocates the instance up front, so when a base constructor RETURNS an object the substitution happens deep inside the VM, after that allocation. This carries it back out. Each construct_class saves and restores the previous value around its own run, so a new inside a constructor body cannot steal it.

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

pub fn set_current_this(&mut self, v: Value)

Rebind the running activation’s this.

Only super() does this: when the parent constructor RETURNS an object, 15.7.15 makes that object the derived instance, so the rest of the derived constructor has to write to it rather than to the one allocated before the call.

pub fn take_process_listeners(&mut self, event: &str) -> Vec<Value>

The callbacks to run for event, consuming any once registration in the same step — so a listener that re-emits the event cannot re-enter a one-shot handler.

pub fn set_top_this(&mut self, v: Value)

Bind the TOP-LEVEL this — the value a this outside any function sees.

Node answers differently per entry point and both answers are objects: node f.js runs a CommonJS module, so top-level this is module.exports; node -e and node - run a Script, so it is globalThis. Verified on node v26.7.0 — console.log(this === globalThis, this === module.exports) is false true from a file and true false from -e and from stdin. It was undefined at every entry point here, so this.x = 1 at module scope threw instead of populating the exports object.

Only the base frame is touched: a plain function call still gets its own (undefined) binding rather than inheriting this one.

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, bool)>)

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. for-in visits own enumerable keys, then every inherited enumerable key not already seen, walking the whole prototype chain. Class methods and the builtin prototypes are non-enumerable, so in practice this only surfaces keys a script put on a prototype itself (F.prototype.y = 2) — but that is exactly the constructor-function idiom older packages are written in.

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

The own enumerable string keys of v, in property order — the single source of truth behind for-in, Object.keys/values/entries, object spread, Object.assign and JSON.stringify. Internal slots (@@…), private fields (#…) and anything marked non-enumerable via prop_attrs are excluded.

pub fn own_key_names(&self, v: &Value, enum_only: bool) -> Vec<String>

Own string keys of v in insertion order. enum_only drops the non-enumerable ones (Object.keys); otherwise every own key is reported (getOwnPropertyNames/Reflect.ownKeys).

pub fn script_global_names(&self) -> Vec<String>

The keys that own a slot in the object’s property map, in insertion order, resolving accessor ordering markers back to their real key. Every global a SCRIPT created, in creation order — the own enumerable keys of the global object that live in the globals map rather than in its property map. x = 1 with no declaration makes one, and Object.keys(globalThis) reports it in node.

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

Drop a global a script created. Reports whether it was there.

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

The own enumerable (key, value) pairs of v. Buffer index keys resolve through the byte store; everything else reads the property map. Own accessor keys come back as Undef here — own_enum_entries_deep runs their getters, which cannot happen under the host borrow.

impl JsHost

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

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

Whether v is an ASYNC generator object — the borrow-free form of is_async_generator, usable from code already holding the host.

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

impl JsHost

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

Error.prototype.toString for an object whose prototype chain reaches Error.prototype: "Name" with an empty message, else "Name: message". None for anything that is not an error, so the caller keeps its own stringification.

impl JsHost

pub fn ensure_native_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. The real Buffer.prototype object, building the Buffer.prototype → Uint8Array.prototype → Object.prototype chain on first use.

A Buffer used to be a bare tagged object with no [[Prototype]] at all, so Object.getPrototypeOf(buf) === Buffer.prototype read false and instanceof had to be special-cased around it. Each prototype is a genuine object carrying @proto:<Ctor>:<method> thunks for its instance methods, so Buffer.prototype.slice.call(buf, 1) still dispatches the way it did when Buffer.prototype was a Builtin namespace.

pub fn ensure_function_kind_protos(&mut self)

String.prototype, Number.prototype and Boolean.prototype as REAL objects.

A wrapper built by new String("a") needs a genuine [[Prototype]] link: Builtin("String.prototype") is a thunk namespace that cannot appear on a prototype chain, so Object.getPrototypeOf(w) === String.prototype and w instanceof String both read false while the wrapper’s methods still resolved through the string funnel. Registering them here puts them on the same footing as Buffer.prototype. GeneratorFunction.prototype, AsyncFunction.prototype and AsyncGeneratorFunction.prototype — the intrinsics a generator or async function’s [[Prototype]] really points at.

None are globals (node exposes them only through Object.getPrototypeOf(function*(){}).constructor), so they live here rather than among the wrapper constructors. Each hangs off Function.prototype and carries the Symbol.toStringTag that names it.

pub fn ensure_wrapper_protos(&mut self)

pub fn template_object(&self, key: (u64, u64)) -> Option<Value>

The cached template object for one tagged-template site, if it has been evaluated before.

pub fn set_template_object(&mut self, key: (u64, u64), v: Value)

Record the template object for one tagged-template site.

pub fn native_proto(&self, ctor: &str) -> Option<Value>

The real prototype object for a builtin exotic, if it has one.

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

The constructor name whose .prototype object IS v, for a prototype this host built as a real object (String.prototype, TypeError .prototype, Buffer.prototype) rather than as a Builtin namespace.

A prototype is an ORDINARY object: it carries no instance’s internal slot, so Object.prototype.toString.call(TypeError.prototype) is [object Object] and not [object Error]. Nothing distinguished the two before, so the brand fell through to the “does it look like an Error” test and answered for the prototype as if it were an instance.

pub fn ensure_ctor_proto(&mut self, ctor: &str) -> Option<Value>

The real .prototype object for a native stdlib constructor (StringDecoder, Hash, URLSearchParams, …), built on first read and cached.

Ctor.prototype used to read undefined for every native class outside the hand-written is_builtin_ctor list, which broke the ES5 subclassing pattern that libraries still use. iconv-lite’s internal codec — reached from raw-body on every express.json() request — does exactly this:

var StringDecoder = require('string_decoder').StringDecoder;
if (!StringDecoder.prototype.end) StringDecoder.prototype.end = function () {};
function InternalDecoder(options, codec) { StringDecoder.call(this, codec.enc); }
InternalDecoder.prototype = StringDecoder.prototype;

The first line threw Cannot read properties of undefined (reading 'end').

Methods come from stdlib::instance_method_lists, the same table a method READ consults, so the prototype can never advertise a name the dispatcher does not implement. Each is the @proto:<Ctor>:<method> thunk that dispatches against its invoke-time this, so a subclass instance whose prototype IS this object gets the native implementation. Returns None for a tag with no instance methods, leaving those constructors as they were.

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

<ErrorClass>.prototype, once JsHost::ensure_error_protos has run. The error prototypes live in their own table, so ensure_ctor_proto — which answers from native_protos — does not find them.

pub fn ensure_error_protos(&mut self)

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>, interval: Option<f64>, ) -> u64

Schedule a macrotask. interval is the repeat period for setInterval (None for the one-shot setTimeout/setImmediate). Returns the timer id, which the Timeout/Immediate handle object carries so clear*, ref/unref and refresh can find this entry again.

pub fn set_timer_refed(&mut self, id: u64, refed: bool)

timeout.ref() / timeout.unref() — set the handle bit on a pending timer. A no-op once the timer has fired or been cleared (Node likewise treats ref/unref on a dead timer as inert).

pub fn timer_has_ref(&self, id: u64) -> bool

timeout.hasRef() — whether a still-pending timer holds the loop open. A fired or cleared timer reports false, matching Node.

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

timeout.refresh() — restart the countdown from now, as if the timer had just been scheduled.

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.