mustardscript 0.1.0 → 0.1.1

package/crates/mustard/src/runtime/vm.rs

@@ -1,1016 +0,0 @@
-use super::*;
-use num_bigint::BigInt;
-
-impl Runtime {
-    pub(super) fn run_root(&mut self) -> MustardResult<ExecutionStep> {
-        self.check_cancellation()?;
-        self.collect_garbage()?;
-        self.check_call_depth()?;
-        let root_env = self.new_env(Some(self.globals))?;
-        self.push_frame(
-            self.program.root,
-            root_env,
-            &[],
-            Value::Object(
-                self.global_object_key()
-                    .ok_or_else(|| MustardError::runtime("missing global object"))?,
-            ),
-            None,
-        )?;
-        self.run()
-    }
-
-    pub(super) fn step_active_frame(&mut self) -> MustardResult<StepAction> {
-        let frame_index = self
-            .frames
-            .len()
-            .checked_sub(1)
-            .ok_or_else(|| MustardError::runtime("vm lost all frames"))?;
-        let function_id = self.frames[frame_index].function_id;
-        let ip = self.frames[frame_index].ip;
-        let instruction = self
-            .program
-            .functions
-            .get(function_id)
-            .and_then(|function| function.code.get(ip))
-            .cloned()
-            .ok_or_else(|| MustardError::runtime("instruction pointer out of range"))?;
-        self.frames[frame_index].ip += 1;
-        self.bump_instruction_budget()?;
-        self.collect_garbage_before_instruction(&instruction)?;
-        match instruction {
-            Instruction::PushUndefined => {
-                self.frames[frame_index].stack.push(Value::Undefined);
-            }
-            Instruction::PushNull => self.frames[frame_index].stack.push(Value::Null),
-            Instruction::PushBool(value) => self.frames[frame_index].stack.push(Value::Bool(value)),
-            Instruction::PushNumber(value) => {
-                self.frames[frame_index].stack.push(Value::Number(value))
-            }
-            Instruction::PushBigInt(value) => {
-                let value = BigInt::parse_bytes(value.as_bytes(), 10)
-                    .ok_or_else(|| MustardError::runtime("invalid BigInt literal in bytecode"))?;
-                self.frames[frame_index].stack.push(Value::BigInt(value));
-            }
-            Instruction::PushString(value) => {
-                self.frames[frame_index].stack.push(Value::String(value))
-            }
-            Instruction::PushRegExp { pattern, flags } => {
-                let value = self.make_regexp_value(pattern, flags)?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::LoadName(name) => {
-                let env = self.frames[frame_index].env;
-                let value = self.lookup_name(env, &name)?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::LoadGlobalObject => {
-                let value = Value::Object(
-                    self.global_object_key()
-                        .ok_or_else(|| MustardError::runtime("missing global object"))?,
-                );
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::StoreName(name) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let env = self.frames[frame_index].env;
-                self.assign_name(env, &name, value.clone())?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::InitializePattern(pattern) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let env = self.frames[frame_index].env;
-                self.initialize_pattern(env, &pattern, value)?;
-            }
-            Instruction::PushEnv => {
-                let current_env = self.frames[frame_index].env;
-                let env = self.new_env(Some(current_env))?;
-                self.frames[frame_index].scope_stack.push(current_env);
-                self.frames[frame_index].env = env;
-            }
-            Instruction::PopEnv => {
-                let restored = self.frames[frame_index]
-                    .scope_stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("scope stack underflow"))?;
-                self.frames[frame_index].env = restored;
-            }
-            Instruction::DeclareName { name, mutable } => {
-                let env = self.frames[frame_index].env;
-                self.declare_name(env, name, mutable)?;
-            }
-            Instruction::MakeClosure { function_id } => {
-                let env = self.frames[frame_index].env;
-                let this_value = self.lookup_name(env, "this").unwrap_or(Value::Undefined);
-                let closure = self.insert_closure(function_id, env, this_value)?;
-                self.frames[frame_index].stack.push(Value::Closure(closure));
-            }
-            Instruction::MakeArray { count } => {
-                let values = pop_many(&mut self.frames[frame_index].stack, count)?;
-                let array = self.insert_array(values, IndexMap::new())?;
-                self.frames[frame_index].stack.push(Value::Array(array));
-            }
-            Instruction::ArrayPush => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let target = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let Value::Array(array) = target else {
-                    return Err(MustardError::runtime(
-                        "array builder target is not an array",
-                    ));
-                };
-                self.arrays
-                    .get_mut(array)
-                    .ok_or_else(|| MustardError::runtime("array missing"))?
-                    .elements
-                    .push(Some(value));
-                self.refresh_array_accounting(array)?;
-                self.frames[frame_index].stack.push(Value::Array(array));
-            }
-            Instruction::ArrayPushHole => {
-                let target = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let Value::Array(array) = target else {
-                    return Err(MustardError::runtime(
-                        "array builder target is not an array",
-                    ));
-                };
-                self.arrays
-                    .get_mut(array)
-                    .ok_or_else(|| MustardError::runtime("array missing"))?
-                    .elements
-                    .push(None);
-                self.refresh_array_accounting(array)?;
-                self.frames[frame_index].stack.push(Value::Array(array));
-            }
-            Instruction::ArrayExtend => {
-                let iterable = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let target = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let target = self.expand_iterable_into_array(target, iterable)?;
-                self.frames[frame_index].stack.push(target);
-            }
-            Instruction::MakeObject { keys } => {
-                let values = pop_many(&mut self.frames[frame_index].stack, keys.len())?;
-                let mut properties = IndexMap::new();
-                for (key, value) in keys.into_iter().zip(values.into_iter()) {
-                    properties.insert(property_name_to_key(&key), value);
-                }
-                let object = self.insert_object(properties, ObjectKind::Plain)?;
-                self.frames[frame_index].stack.push(Value::Object(object));
-            }
-            Instruction::CopyDataProperties => {
-                let source = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let target = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                self.copy_data_properties(target.clone(), source)?;
-                self.frames[frame_index].stack.push(target);
-            }
-            Instruction::CreateIterator => {
-                let iterable = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let iterator = self.create_iterator(iterable)?;
-                self.frames[frame_index].stack.push(iterator);
-            }
-            Instruction::IteratorNext => {
-                let iterator = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let (value, done) = self.iterator_next(iterator)?;
-                self.frames[frame_index].stack.push(value);
-                self.frames[frame_index].stack.push(Value::Bool(done));
-            }
-            Instruction::GetPropStatic { name, optional } => {
-                let object = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let value = self.get_property(object, Value::String(name), optional)?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::GetPropComputed { optional } => {
-                let property = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let object = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let value = self.get_property(object, property, optional)?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::SetPropStatic { name } => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let object = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                self.set_property(object, Value::String(name), value.clone())?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::SetPropComputed => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let property = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let object = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                self.set_property(object, property, value.clone())?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::Unary(operator) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let result = self.apply_unary(operator, value)?;
-                self.frames[frame_index].stack.push(result);
-            }
-            Instruction::Binary(operator) => {
-                let right = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let left = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let result = self.apply_binary(operator, left, right)?;
-                self.frames[frame_index].stack.push(result);
-            }
-            Instruction::Update(operator) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let result = self.apply_update(operator, value)?;
-                self.frames[frame_index].stack.push(result);
-            }
-            Instruction::PatternArrayIndex(index) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let result = self.pattern_array_index(value, index)?;
-                self.frames[frame_index].stack.push(result);
-            }
-            Instruction::PatternArrayRest(start) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let result = self.pattern_array_rest(value, start)?;
-                self.frames[frame_index].stack.push(result);
-            }
-            Instruction::PatternObjectRest(excluded) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let result = self.pattern_object_rest(value, &excluded)?;
-                self.frames[frame_index].stack.push(result);
-            }
-            Instruction::Pop => {
-                self.frames[frame_index].stack.pop();
-            }
-            Instruction::Dup => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .last()
-                    .cloned()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::Dup2 => {
-                let len = self.frames[frame_index].stack.len();
-                if len < 2 {
-                    return Err(MustardError::runtime("stack underflow"));
-                }
-                let a = self.frames[frame_index].stack[len - 2].clone();
-                let b = self.frames[frame_index].stack[len - 1].clone();
-                self.frames[frame_index].stack.push(a);
-                self.frames[frame_index].stack.push(b);
-            }
-            Instruction::PushHandler { catch, finally } => {
-                let frame = &mut self.frames[frame_index];
-                frame.handlers.push(ExceptionHandler {
-                    catch,
-                    finally,
-                    env: frame.env,
-                    scope_stack_len: frame.scope_stack.len(),
-                    stack_len: frame.stack.len(),
-                });
-            }
-            Instruction::PopHandler => {
-                self.frames[frame_index]
-                    .handlers
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("handler stack underflow"))?;
-            }
-            Instruction::EnterFinally { exit } => {
-                let completion_index = self.frames[frame_index]
-                    .pending_completions
-                    .len()
-                    .checked_sub(1)
-                    .ok_or_else(|| MustardError::runtime("missing pending completion"))?;
-                self.frames[frame_index]
-                    .active_finally
-                    .push(ActiveFinallyState {
-                        completion_index,
-                        exit,
-                    });
-            }
-            Instruction::BeginCatch => {
-                let value = self.frames[frame_index]
-                    .pending_exception
-                    .take()
-                    .ok_or_else(|| MustardError::runtime("missing pending exception"))?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::Throw { span } => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                return self.raise_exception(value, Some(span));
-            }
-            Instruction::PushPendingJump {
-                target,
-                target_handler_depth,
-                target_scope_depth,
-            } => {
-                self.store_completion(
-                    frame_index,
-                    CompletionRecord::Jump {
-                        target,
-                        target_handler_depth,
-                        target_scope_depth,
-                    },
-                )?;
-            }
-            Instruction::PushPendingReturn => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                self.store_completion(frame_index, CompletionRecord::Return(value))?;
-            }
-            Instruction::PushPendingThrow => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                self.store_completion(frame_index, CompletionRecord::Throw(value))?;
-            }
-            Instruction::ContinuePending => {
-                let marker = self.frames[frame_index]
-                    .active_finally
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("missing active finally state"))?;
-                if marker.completion_index >= self.frames[frame_index].pending_completions.len() {
-                    return Err(MustardError::runtime(
-                        "active finally references missing completion",
-                    ));
-                }
-                let completion = self.frames[frame_index]
-                    .pending_completions
-                    .remove(marker.completion_index);
-                return self.resume_completion(completion);
-            }
-            Instruction::Jump(target) => self.frames[frame_index].ip = target,
-            Instruction::JumpIfFalse(target) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .last()
-                    .cloned()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                if !is_truthy(&value) {
-                    self.frames[frame_index].ip = target;
-                }
-            }
-            Instruction::JumpIfTrue(target) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .last()
-                    .cloned()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                if is_truthy(&value) {
-                    self.frames[frame_index].ip = target;
-                }
-            }
-            Instruction::JumpIfNullish(target) => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .last()
-                    .cloned()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                if matches!(value, Value::Null | Value::Undefined) {
-                    self.frames[frame_index].ip = target;
-                }
-            }
-            Instruction::Call {
-                argc,
-                with_this,
-                optional,
-            } => {
-                let args = pop_many(&mut self.frames[frame_index].stack, argc)?;
-                let callee = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let this_value = if with_this {
-                    self.frames[frame_index]
-                        .stack
-                        .pop()
-                        .ok_or_else(|| MustardError::runtime("stack underflow"))?
-                } else {
-                    Value::Undefined
-                };
-                if optional && matches!(callee, Value::Undefined | Value::Null) {
-                    self.frames[frame_index].stack.push(Value::Undefined);
-                    return Ok(StepAction::Continue);
-                }
-                match self.call_callable(callee, this_value, &args)? {
-                    RunState::Completed(value) => {
-                        self.frames[frame_index].stack.push(value);
-                    }
-                    RunState::PushedFrame => {}
-                    RunState::StartedAsync(value) => {
-                        self.frames[frame_index].stack.push(value);
-                    }
-                    RunState::Suspended {
-                        capability,
-                        args,
-                        resume_behavior,
-                    } => {
-                        self.pending_resume_behavior = resume_behavior;
-                        self.suspended_host_call = Some(PendingHostCall {
-                            capability: capability.clone(),
-                            args: args.clone(),
-                            promise: None,
-                            resume_behavior,
-                            traceback: self.traceback_snapshots(),
-                        });
-                        self.snapshot_nonce = next_snapshot_nonce();
-                        return Ok(StepAction::Return(ExecutionStep::Suspended(Box::new(
-                            Suspension {
-                                capability,
-                                args,
-                                snapshot: ExecutionSnapshot {
-                                    runtime: self.clone(),
-                                },
-                            },
-                        ))));
-                    }
-                }
-            }
-            Instruction::Await => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                self.suspend_async_await(value)?;
-            }
-            Instruction::CallWithArray {
-                with_this,
-                optional,
-            } => {
-                let args = self.pop_argument_array(frame_index)?;
-                let callee = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let this_value = if with_this {
-                    self.frames[frame_index]
-                        .stack
-                        .pop()
-                        .ok_or_else(|| MustardError::runtime("stack underflow"))?
-                } else {
-                    Value::Undefined
-                };
-                if optional && matches!(callee, Value::Undefined | Value::Null) {
-                    self.frames[frame_index].stack.push(Value::Undefined);
-                    return Ok(StepAction::Continue);
-                }
-                match self.call_callable(callee, this_value, &args)? {
-                    RunState::Completed(value) => {
-                        self.frames[frame_index].stack.push(value);
-                    }
-                    RunState::PushedFrame => {}
-                    RunState::StartedAsync(value) => {
-                        self.frames[frame_index].stack.push(value);
-                    }
-                    RunState::Suspended {
-                        capability,
-                        args,
-                        resume_behavior,
-                    } => {
-                        self.pending_resume_behavior = resume_behavior;
-                        self.suspended_host_call = Some(PendingHostCall {
-                            capability: capability.clone(),
-                            args: args.clone(),
-                            promise: None,
-                            resume_behavior,
-                            traceback: self.traceback_snapshots(),
-                        });
-                        self.snapshot_nonce = next_snapshot_nonce();
-                        return Ok(StepAction::Return(ExecutionStep::Suspended(Box::new(
-                            Suspension {
-                                capability,
-                                args,
-                                snapshot: ExecutionSnapshot {
-                                    runtime: self.clone(),
-                                },
-                            },
-                        ))));
-                    }
-                }
-            }
-            Instruction::Construct { argc } => {
-                let args = pop_many(&mut self.frames[frame_index].stack, argc)?;
-                let callee = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let value = self.construct(callee, &args)?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::ConstructWithArray => {
-                let args = self.pop_argument_array(frame_index)?;
-                let callee = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-                let value = self.construct(callee, &args)?;
-                self.frames[frame_index].stack.push(value);
-            }
-            Instruction::Return => {
-                let value = self.frames[frame_index]
-                    .stack
-                    .pop()
-                    .unwrap_or(Value::Undefined);
-                return self.complete_return(value);
-            }
-        }
-        Ok(StepAction::Continue)
-    }
-
-    pub(super) fn run(&mut self) -> MustardResult<ExecutionStep> {
-        loop {
-            self.check_cancellation()
-                .map_err(|error| self.annotate_runtime_error(error))?;
-            if self.frames.is_empty() {
-                match self.process_idle_state() {
-                    Ok(Some(step)) => return Ok(step),
-                    Ok(None) => continue,
-                    Err(error) => return Err(self.annotate_runtime_error(error)),
-                }
-            }
-            let action = match self.step_active_frame() {
-                Ok(action) => action,
-                Err(error) => match self.handle_runtime_fault(error) {
-                    Ok(action) => action,
-                    Err(error) => return Err(self.annotate_runtime_error(error)),
-                },
-            };
-
-            match action {
-                StepAction::Continue => {}
-                StepAction::Return(step) => return Ok(step),
-            }
-        }
-    }
-
-    pub(super) fn run_until_frame_depth(
-        &mut self,
-        target_depth: usize,
-        host_suspension_message: &str,
-    ) -> MustardResult<()> {
-        while self.frames.len() > target_depth {
-            self.check_cancellation()?;
-            let action = match self.step_active_frame() {
-                Ok(action) => action,
-                Err(error) => self.handle_runtime_fault(error)?,
-            };
-            match action {
-                StepAction::Continue => {}
-                StepAction::Return(ExecutionStep::Suspended(_)) => {
-                    return Err(MustardError::runtime(host_suspension_message));
-                }
-                StepAction::Return(ExecutionStep::Completed(_)) => {
-                    return Err(MustardError::runtime(
-                        "nested callback execution unexpectedly completed the program",
-                    ));
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub(super) fn check_call_depth(&self) -> MustardResult<()> {
-        if self.frames.len() >= self.limits.call_depth_limit {
-            return Err(limit_error("call depth limit exceeded"));
-        }
-        Ok(())
-    }
-
-    pub(super) fn push_frame(
-        &mut self,
-        function_id: usize,
-        env: EnvKey,
-        args: &[Value],
-        this_value: Value,
-        async_promise: Option<PromiseKey>,
-    ) -> MustardResult<()> {
-        self.check_call_depth()?;
-        let (params, rest) = self
-            .program
-            .functions
-            .get(function_id)
-            .map(|function| (function.params.clone(), function.rest.clone()))
-            .ok_or_else(|| MustardError::runtime("function not found"))?;
-        let this_cell = self.insert_cell(this_value, true, true)?;
-        self.envs
-            .get_mut(env)
-            .ok_or_else(|| MustardError::runtime("environment missing"))?
-            .bindings
-            .insert("this".to_string(), this_cell);
-        self.refresh_env_accounting(env)?;
-        for pattern in &params {
-            for (name, _) in pattern_bindings(pattern) {
-                self.declare_name(env, name, true)?;
-            }
-        }
-        for (index, pattern) in params.iter().enumerate() {
-            let arg = args.get(index).cloned().unwrap_or(Value::Undefined);
-            self.initialize_pattern(env, pattern, arg)?;
-        }
-        if let Some(rest) = &rest {
-            for (name, _) in pattern_bindings(rest) {
-                self.declare_name(env, name, true)?;
-            }
-            let rest_array = self.insert_array(
-                args.iter().skip(params.len()).cloned().collect(),
-                IndexMap::new(),
-            )?;
-            self.initialize_pattern(env, rest, Value::Array(rest_array))?;
-        }
-        self.frames.push(Frame {
-            function_id,
-            ip: 0,
-            env,
-            scope_stack: Vec::new(),
-            stack: Vec::new(),
-            handlers: Vec::new(),
-            pending_exception: None,
-            pending_completions: Vec::new(),
-            active_finally: Vec::new(),
-            async_promise,
-        });
-        Ok(())
-    }
-
-    pub(super) fn call_callable(
-        &mut self,
-        callee: Value,
-        this_value: Value,
-        args: &[Value],
-    ) -> MustardResult<RunState> {
-        match callee {
-            Value::Closure(closure) => {
-                let closure = self
-                    .closures
-                    .get(closure)
-                    .cloned()
-                    .ok_or_else(|| MustardError::runtime("closure not found"))?;
-                let env = self.new_env(Some(closure.env))?;
-                let (is_async, is_arrow) = self
-                    .program
-                    .functions
-                    .get(closure.function_id)
-                    .map(|function| (function.is_async, function.is_arrow))
-                    .ok_or_else(|| MustardError::runtime("function not found"))?;
-                let frame_this = if is_arrow {
-                    closure.this_value.clone()
-                } else {
-                    this_value
-                };
-                if is_async {
-                    let promise = self.insert_promise(PromiseState::Pending)?;
-                    self.push_frame(closure.function_id, env, args, frame_this, Some(promise))?;
-                    Ok(RunState::StartedAsync(Value::Promise(promise)))
-                } else {
-                    self.push_frame(closure.function_id, env, args, frame_this, None)?;
-                    Ok(RunState::PushedFrame)
-                }
-            }
-            Value::BuiltinFunction(function) => match function {
-                BuiltinFunction::FunctionCall => self.call_function_call(this_value, args),
-                BuiltinFunction::FunctionApply => self.call_function_apply(this_value, args),
-                BuiltinFunction::FunctionBind => Ok(RunState::Completed(
-                    self.call_function_bind(this_value, args)?,
-                )),
-                _ => Ok(RunState::Completed(
-                    self.call_builtin(function, this_value, args)?,
-                )),
-            },
-            Value::Object(object)
-                if self
-                    .objects
-                    .get(object)
-                    .is_some_and(|object| matches!(object.kind, ObjectKind::BoundFunction(_))) =>
-            {
-                let bound = match &self
-                    .objects
-                    .get(object)
-                    .ok_or_else(|| MustardError::runtime("object missing"))?
-                    .kind
-                {
-                    ObjectKind::BoundFunction(bound) => bound.clone(),
-                    _ => unreachable!(),
-                };
-                let mut combined = bound.args;
-                combined.extend(args.iter().cloned());
-                self.call_callable(bound.target, bound.this_value, &combined)
-            }
-            Value::HostFunction(capability) => {
-                let resume_behavior = resume_behavior_for_capability(&capability);
-                let args = args
-                    .iter()
-                    .cloned()
-                    .map(|value| self.value_to_structured(value))
-                    .collect::<MustardResult<Vec<_>>>()?;
-                if self.current_async_boundary_index().is_some() {
-                    let outstanding = self.pending_host_calls.len()
-                        + usize::from(self.suspended_host_call.is_some());
-                    if outstanding >= self.limits.max_outstanding_host_calls {
-                        return Err(limit_error("outstanding host-call limit exhausted"));
-                    }
-                    let promise = self.insert_promise(PromiseState::Pending)?;
-                    self.pending_host_calls.push_back(PendingHostCall {
-                        capability,
-                        args,
-                        promise: Some(promise),
-                        resume_behavior,
-                        traceback: self.traceback_snapshots(),
-                    });
-                    Ok(RunState::Completed(Value::Promise(promise)))
-                } else {
-                    Ok(RunState::Suspended {
-                        resume_behavior,
-                        capability,
-                        args,
-                    })
-                }
-            }
-            _ => Err(MustardError::runtime("value is not callable")),
-        }
-    }
-
-    fn call_function_call(&mut self, target: Value, args: &[Value]) -> MustardResult<RunState> {
-        if !self.is_callable_value(&target)? {
-            return Err(MustardError::runtime(
-                "TypeError: Function.prototype.call called on incompatible receiver",
-            ));
-        }
-        let this_arg = args.first().cloned().unwrap_or(Value::Undefined);
-        self.call_callable(target, this_arg, &args[1..])
-    }
-
-    fn call_function_apply(&mut self, target: Value, args: &[Value]) -> MustardResult<RunState> {
-        if !self.is_callable_value(&target)? {
-            return Err(MustardError::runtime(
-                "TypeError: Function.prototype.apply called on incompatible receiver",
-            ));
-        }
-        let this_arg = args.first().cloned().unwrap_or(Value::Undefined);
-        let arg_list = match args.get(1).cloned().unwrap_or(Value::Undefined) {
-            Value::Undefined | Value::Null => Vec::new(),
-            Value::Array(array) => self.array_argument_values(Value::Array(array))?,
-            _ => {
-                return Err(MustardError::runtime(
-                    "TypeError: Function.prototype.apply expects an array or undefined argument list in the supported surface",
-                ));
-            }
-        };
-        self.call_callable(target, this_arg, &arg_list)
-    }
-
-    fn call_function_bind(&mut self, target: Value, args: &[Value]) -> MustardResult<Value> {
-        if !self.is_callable_value(&target)? {
-            return Err(MustardError::runtime(
-                "TypeError: Function.prototype.bind called on incompatible receiver",
-            ));
-        }
-        let bound_this = args.first().cloned().unwrap_or(Value::Undefined);
-        let bound_args = args.iter().skip(1).cloned().collect();
-        Ok(Value::Object(self.insert_object(
-            IndexMap::new(),
-            ObjectKind::BoundFunction(BoundFunctionData {
-                target,
-                this_value: bound_this,
-                args: bound_args,
-            }),
-        )?))
-    }
-
-    fn is_callable_value(&self, value: &Value) -> MustardResult<bool> {
-        Ok(match value {
-            Value::Closure(_) | Value::BuiltinFunction(_) | Value::HostFunction(_) => true,
-            Value::Object(object) => matches!(
-                self.objects
-                    .get(*object)
-                    .ok_or_else(|| MustardError::runtime("object missing"))?
-                    .kind,
-                ObjectKind::BoundFunction(_)
-            ),
-            _ => false,
-        })
-    }
-
-    pub(super) fn construct(&mut self, callee: Value, args: &[Value]) -> MustardResult<Value> {
-        match callee {
-            Value::BuiltinFunction(
-                BuiltinFunction::FunctionCtor
-                | BuiltinFunction::ArrayCtor
-                | BuiltinFunction::DateCtor
-                | BuiltinFunction::ObjectCtor
-                | BuiltinFunction::MapCtor
-                | BuiltinFunction::SetCtor
-                | BuiltinFunction::PromiseCtor
-                | BuiltinFunction::RegExpCtor
-                | BuiltinFunction::ErrorCtor
-                | BuiltinFunction::TypeErrorCtor
-                | BuiltinFunction::ReferenceErrorCtor
-                | BuiltinFunction::RangeErrorCtor
-                | BuiltinFunction::SyntaxErrorCtor
-                | BuiltinFunction::NumberCtor
-                | BuiltinFunction::StringCtor
-                | BuiltinFunction::BooleanCtor
-                | BuiltinFunction::IntlDateTimeFormatCtor
-                | BuiltinFunction::IntlNumberFormatCtor,
-            ) => match callee {
-                Value::BuiltinFunction(BuiltinFunction::FunctionCtor) => {
-                    Err(MustardError::runtime(
-                        "TypeError: Function constructor is unavailable in the supported surface",
-                    ))
-                }
-                Value::BuiltinFunction(BuiltinFunction::MapCtor) => self.construct_map(args),
-                Value::BuiltinFunction(BuiltinFunction::SetCtor) => self.construct_set(args),
-                Value::BuiltinFunction(BuiltinFunction::DateCtor) => self.construct_date(args),
-                Value::BuiltinFunction(BuiltinFunction::PromiseCtor) => {
-                    self.construct_promise(args)
-                }
-                Value::BuiltinFunction(BuiltinFunction::RegExpCtor) => self.construct_regexp(args),
-                Value::BuiltinFunction(BuiltinFunction::NumberCtor) => self.construct_number(args),
-                Value::BuiltinFunction(BuiltinFunction::StringCtor) => self.construct_string(args),
-                Value::BuiltinFunction(BuiltinFunction::BooleanCtor) => {
-                    self.construct_boolean(args)
-                }
-                Value::BuiltinFunction(BuiltinFunction::IntlDateTimeFormatCtor) => {
-                    self.construct_intl_date_time_format(args)
-                }
-                Value::BuiltinFunction(BuiltinFunction::IntlNumberFormatCtor) => {
-                    self.construct_intl_number_format(args)
-                }
-                Value::BuiltinFunction(kind) => self.call_builtin(kind, Value::Undefined, args),
-                _ => unreachable!(),
-            },
-            _ => Err(MustardError::runtime(
-                "only conservative built-in constructors are supported in v1",
-            )),
-        }
-    }
-
-    fn pop_argument_array(&mut self, frame_index: usize) -> MustardResult<Vec<Value>> {
-        let args = self.frames[frame_index]
-            .stack
-            .pop()
-            .ok_or_else(|| MustardError::runtime("stack underflow"))?;
-        self.array_argument_values(args)
-    }
-
-    fn array_argument_values(&self, value: Value) -> MustardResult<Vec<Value>> {
-        let Value::Array(array) = value else {
-            return Err(MustardError::runtime(
-                "argument builder target is not an array",
-            ));
-        };
-        let elements = &self
-            .arrays
-            .get(array)
-            .ok_or_else(|| MustardError::runtime("array missing"))?
-            .elements;
-        Ok(elements
-            .iter()
-            .map(|value| value.clone().unwrap_or(Value::Undefined))
-            .collect())
-    }
-
-    fn expand_iterable_into_array(
-        &mut self,
-        target: Value,
-        iterable: Value,
-    ) -> MustardResult<Value> {
-        let Value::Array(array) = target else {
-            return Err(MustardError::runtime(
-                "array builder target is not an array",
-            ));
-        };
-        self.with_temporary_roots(&[Value::Array(array), iterable.clone()], |runtime| {
-            let iterator = runtime.create_iterator(iterable.clone())?;
-            runtime.with_temporary_roots(
-                &[Value::Array(array), iterable, iterator.clone()],
-                |runtime| {
-                    loop {
-                        runtime.charge_native_helper_work(1)?;
-                        let (value, done) = runtime.iterator_next(iterator.clone())?;
-                        if done {
-                            break;
-                        }
-                        runtime
-                            .arrays
-                            .get_mut(array)
-                            .ok_or_else(|| MustardError::runtime("array missing"))?
-                            .elements
-                            .push(Some(value));
-                        runtime.refresh_array_accounting(array)?;
-                    }
-                    Ok(Value::Array(array))
-                },
-            )
-        })
-    }
-
-    fn pattern_array_index(&self, value: Value, index: usize) -> MustardResult<Value> {
-        let items = self.to_array_items(value)?;
-        Ok(items.get(index).cloned().unwrap_or(Value::Undefined))
-    }
-
-    fn pattern_array_rest(&mut self, value: Value, start: usize) -> MustardResult<Value> {
-        let items = self.to_array_items(value)?;
-        let array = self.insert_array(items.into_iter().skip(start).collect(), IndexMap::new())?;
-        Ok(Value::Array(array))
-    }
-
-    fn pattern_object_rest(&mut self, value: Value, excluded: &[String]) -> MustardResult<Value> {
-        let excluded: std::collections::HashSet<_> = excluded.iter().cloned().collect();
-        let mut rest_object = IndexMap::new();
-        match value {
-            Value::Object(object) => {
-                if let Some(object) = self.objects.get(object) {
-                    for (key, value) in &object.properties {
-                        if !excluded.contains(key) {
-                            rest_object.insert(key.clone(), value.clone());
-                        }
-                    }
-                }
-            }
-            Value::Null | Value::Undefined => {
-                return Err(MustardError::runtime(
-                    "cannot destructure object pattern from nullish value",
-                ));
-            }
-            _ => {}
-        }
-        Ok(Value::Object(
-            self.insert_object(rest_object, ObjectKind::Plain)?,
-        ))
-    }
-}