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 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.

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 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 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_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 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 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 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 current_home_class_name(&self) -> Option<String>

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.

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_frames(&self) -> String

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.

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

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.

pub fn push_scope(&mut self)

Enter a fresh block scope.

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 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 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 native_proto(&self, ctor: &str) -> Option<Value>

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

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 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.