refactor: 统一调用调度并安全化 IC 缓存

crates/oxide_vm/src/bindings/bind_error.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use oxide_kernel::builtin::ErrorMethods;
 use oxide_kernel::kernel::OxideKernel;
 use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
-use oxide_types::object::JsObject;
+use oxide_types::object::{JsObject, NativeFnPtr};
 use oxide_types::value::JsValue;
 
 fn bind_error_subtype_constructor(
@@ -15,7 +15,8 @@ fn bind_error_subtype_constructor(
 
     let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto_ptr)));
     ctor.set_function(true);
-    ctor.set_native_fn(Some(ctor_fn));
+    // SAFETY: ctor_fn is a NativeFn fn-item pointer cast to *const () by callers.
+    ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(ctor_fn) }));
     ctor.set_native_arg_count(1);
 
     let si_prototype = sf.intern("prototype").0;
@@ -112,6 +113,7 @@ pub fn bind_error(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
     {
         let err_ctor_ptr = kernel.builtin_world().error_constructor.as_ptr() as *mut JsObject;
         let err_ctor = unsafe { &mut *err_ctor_ptr };
-        err_ctor.set_native_fn(Some(crate::builtins::error::error_constructor as *const ()));
+        // SAFETY: error_constructor is a NativeFn fn-item.
+        err_ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(crate::builtins::error::error_constructor as *const ()) }));
     }
 }

crates/oxide_vm/src/bindings/bind_number.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use oxide_kernel::bind_methods;
 use oxide_kernel::builtin::NumberMethods;
 use oxide_kernel::kernel::OxideKernel;
-use oxide_types::object::JsObject;
+use oxide_types::object::{JsObject, NativeFnPtr};
 use oxide_types::value::JsValue;
 
 pub fn bind_number(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
@@ -36,7 +36,8 @@ pub fn bind_number(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
     {
         let num_ctor_ptr = kernel.builtin_world().number_constructor.as_ptr() as *mut JsObject;
         let num_ctor = unsafe { &mut *num_ctor_ptr };
-        num_ctor.set_native_fn(Some(crate::builtins::number::number_constructor as *const ()));
+        // SAFETY: number_constructor is a NativeFn fn-item.
+        num_ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(crate::builtins::number::number_constructor as *const ()) }));
         num_ctor.set_native_arg_count(1);
 
         for (name, value) in [

crates/oxide_vm/src/bindings/mod.rs

@@ -17,7 +17,7 @@ use std::sync::Arc;
 
 use oxide_kernel::builtin::BuiltinWorld;
 use oxide_kernel::kernel::OxideKernel;
-use oxide_types::object::JsObject;
+use oxide_types::object::{JsObject, NativeFnPtr};
 use oxide_types::value::JsValue;
 
 #[macro_export]
@@ -29,7 +29,8 @@ macro_rules! bind_constructor {
         $global.set_shape_id(shape);
         $global.push_prop(val);
         let ctor = unsafe { &mut *$ctor_ptr };
-        ctor.set_native_fn(Some($ctor_fn as *const ()));
+        // SAFETY: $ctor_fn is a fn-item expression; casting to *const () preserves validity.
+        ctor.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw($ctor_fn as *const ()) }));
         ctor.set_native_arg_count($nargs);
     }};
 }
@@ -44,13 +45,15 @@ macro_rules! bind_constructor_hash {
         $global.ensure_hash_props().push(Box::new(val));
         $global.bump_generation();
         let ctor = unsafe { &mut *$ctor_ptr };
-        ctor.set_native_fn(Some($ctor_fn as *const ()));
+        // SAFETY: $ctor_fn is a fn-item expression; casting to *const () preserves validity.
+        ctor.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw($ctor_fn as *const ()) }));
         ctor.set_native_arg_count($nargs);
     }};
 }
 
 pub(crate) fn configure_native_constructor(ctor: &mut JsObject, native_fn: *const (), arg_count: u8) {
-    ctor.set_native_fn(Some(native_fn));
+    // SAFETY: native_fn is always a valid NativeFn fn-item pointer cast to *const () by callers.
+    ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(native_fn) }));
     ctor.set_native_arg_count(arg_count);
 }
 
@@ -60,7 +63,9 @@ pub(crate) fn apply_binding_table(
     let shape_forge = kernel.shape_forge().as_ref();
     let string_forge = kernel.string_forge().as_ref();
     for (name, func, nargs) in bindings {
-        let _ = world.bind_method(target, shape_forge, string_forge, name, *func, *nargs);
+        // SAFETY: all entries in the binding table are NativeFn fn-item pointers cast to *const ().
+        let fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(*func) };
+        let _ = world.bind_method(target, shape_forge, string_forge, name, fn_ptr, *nargs);
     }
 }
 

crates/oxide_vm/src/builtins/array.rs

@@ -4,12 +4,15 @@ use oxide_types::value::JsValue;
 
 use crate::coercion;
 use crate::native::{NativeFn, NativeResult};
-use crate::vm::Vm;
+use crate::vm::{native_fn_ptr_to_fn, Vm};
 
 macro_rules! array_ptr {
-    ($vm:expr, $args:expr) => {
-        get_this_array_ref($vm.reg($args[0]))?
-    };
+    ($vm:expr, $args:expr) => {{
+        match get_this_array_ref($vm.reg($args[0])) {
+            Ok(ptr) => ptr,
+            Err(err) => return NativeResult::Err(err),
+        }
+    }};
 }
 
 macro_rules! array_ptr_len {
@@ -43,17 +46,19 @@ fn create_new_array(vm: &mut Vm, n: usize) -> *mut JsObject {
 
 fn invoke_native_callback(vm: &mut Vm, callback_val: JsValue, this_val: JsValue, cb_args: &[JsValue]) -> NativeResult {
     if !callback_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let cb_ptr = callback_val.as_js_object_ptr();
     if cb_ptr.is_null() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let cb = unsafe { &*cb_ptr };
     if !cb.is_function() || cb.native_fn().is_none() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
-    let func: NativeFn = unsafe { std::mem::transmute(cb.native_fn().unwrap()) };
+    // SAFETY: native_fn was set via set_native_fn with a valid NativeFn pointer;
+    // native_fn_ptr_to_fn is the single coercion point for NativeFnPtr → NativeFn.
+    let func: NativeFn = unsafe { native_fn_ptr_to_fn(cb.native_fn().unwrap()) };
 
     let base = 240u8;
     let n = cb_args.len().min(15);
@@ -79,14 +84,14 @@ pub fn array_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
             let arr = vm
                 .epoch()
                 .alloc(JsObject::new_array(EMPTY_SHAPE_ID, proto_val, n, vm.epoch().bump()));
-            return Ok(JsValue::from_js_object(arr));
+            return NativeResult::Ok(JsValue::from_js_object(arr));
         }
         if val.is_double() {
             let n = val.as_double() as usize;
             let arr = vm
                 .epoch()
                 .alloc(JsObject::new_array(EMPTY_SHAPE_ID, proto_val, n, vm.epoch().bump()));
-            return Ok(JsValue::from_js_object(arr));
+            return NativeResult::Ok(JsValue::from_js_object(arr));
         }
     }
 
@@ -102,22 +107,22 @@ pub fn array_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     unsafe {
         (*arr).set_prop_count(n_elems);
     }
-    Ok(JsValue::from_js_object(arr))
+    NativeResult::Ok(JsValue::from_js_object(arr))
 }
 
 pub fn array_is_array(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let val = vm.reg(args[1]);
     if !val.is_object() {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let ptr = val.as_js_object_ptr();
     if ptr.is_null() {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
-    Ok(JsValue::bool(unsafe { &*ptr }.is_array()))
+    NativeResult::Ok(JsValue::bool(unsafe { &*ptr }.is_array()))
 }
 
 pub fn array_push(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -130,7 +135,7 @@ pub fn array_push(vm: &mut Vm, args: &[u8]) -> NativeResult {
         len += 1;
     }
     arr.set_prop_count(len);
-    Ok(JsValue::int(len as i32))
+    NativeResult::Ok(JsValue::int(len as i32))
 }
 
 pub fn array_pop(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -138,11 +143,11 @@ pub fn array_pop(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let arr = unsafe { &mut *arr_ptr };
     let len = arr.prop_count();
     if len == 0 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let last = arr.get_prop_at(len - 1);
     arr.set_prop_count(len - 1);
-    Ok(last)
+    NativeResult::Ok(last)
 }
 
 pub fn array_slice(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -170,7 +175,7 @@ pub fn array_slice(vm: &mut Vm, args: &[u8]) -> NativeResult {
         }
         (*new_arr).set_prop_count(count);
     }
-    Ok(JsValue::from_js_object(new_arr))
+    NativeResult::Ok(JsValue::from_js_object(new_arr))
 }
 
 pub fn array_splice(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -232,7 +237,7 @@ pub fn array_splice(vm: &mut Vm, args: &[u8]) -> NativeResult {
         }
         (*removed_arr).set_prop_count(removed.len());
     }
-    Ok(JsValue::from_js_object(removed_arr))
+    NativeResult::Ok(JsValue::from_js_object(removed_arr))
 }
 
 pub fn array_concat(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -267,7 +272,7 @@ pub fn array_concat(vm: &mut Vm, args: &[u8]) -> NativeResult {
         }
         (*new_arr).set_prop_count(all.len());
     }
-    Ok(JsValue::from_js_object(new_arr))
+    NativeResult::Ok(JsValue::from_js_object(new_arr))
 }
 
 pub fn array_join(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -292,7 +297,7 @@ pub fn array_join(vm: &mut Vm, args: &[u8]) -> NativeResult {
         .collect();
     let joined = parts.join(&sep);
     let result_val = vm.intern(&joined);
-    Ok(result_val)
+    NativeResult::Ok(result_val)
 }
 
 pub fn array_index_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -300,15 +305,15 @@ pub fn array_index_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let arr = unsafe { &*arr_ptr };
     let n = arr.prop_count() as usize;
     if args.len() < 2 {
-        return Ok(JsValue::int(-1));
+        return NativeResult::Ok(JsValue::int(-1));
     }
     let target = vm.reg(args[1]);
     for i in 0..n {
         if coercion::strict_equality(arr.get_prop_at(i), target) {
-            return Ok(JsValue::int(i as i32));
+            return NativeResult::Ok(JsValue::int(i as i32));
         }
     }
-    Ok(JsValue::int(-1))
+    NativeResult::Ok(JsValue::int(-1))
 }
 
 pub fn array_includes(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -316,7 +321,7 @@ pub fn array_includes(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let arr = unsafe { &*arr_ptr };
     let n = arr.prop_count() as usize;
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let target = vm.reg(args[1]);
     for i in 0..n {
@@ -325,14 +330,14 @@ pub fn array_includes(vm: &mut Vm, args: &[u8]) -> NativeResult {
             let ea = elem.as_double();
             let ta = target.as_double();
             if ea.is_nan() && ta.is_nan() {
-                return Ok(JsValue::bool(true));
+                return NativeResult::Ok(JsValue::bool(true));
             }
         }
         if coercion::strict_equality(elem, target) {
-            return Ok(JsValue::bool(true));
+            return NativeResult::Ok(JsValue::bool(true));
         }
     }
-    Ok(JsValue::bool(false))
+    NativeResult::Ok(JsValue::bool(false))
 }
 
 pub fn array_reverse(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -348,7 +353,7 @@ pub fn array_reverse(vm: &mut Vm, args: &[u8]) -> NativeResult {
         i += 1;
         j = j.saturating_sub(1);
     }
-    Ok(vm.reg(args[0]))
+    NativeResult::Ok(vm.reg(args[0]))
 }
 
 pub fn array_flat(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -391,73 +396,73 @@ pub fn array_flat(vm: &mut Vm, args: &[u8]) -> NativeResult {
         }
         (*new_arr).set_prop_count(flat.len());
     }
-    Ok(JsValue::from_js_object(new_arr))
+    NativeResult::Ok(JsValue::from_js_object(new_arr))
 }
 
 pub fn array_for_each(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let callback_val = vm.reg(args[1]);
     if !callback_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     for i in 0..n {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         let _ = invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]);
     }
-    Ok(JsValue::undefined())
+    NativeResult::Ok(JsValue::undefined())
 }
 
 pub fn array_map(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let callback_val = vm.reg(args[1]);
     if !callback_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     let new_arr = create_new_array(vm, n);
     for i in 0..n {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) {
-            Ok(mapped) => unsafe {
+            NativeResult::Ok(mapped) => unsafe {
                 (*new_arr).set_prop_at(i, mapped);
             },
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
     unsafe {
         (*new_arr).set_prop_count(n);
     }
-    Ok(JsValue::from_js_object(new_arr))
+    NativeResult::Ok(JsValue::from_js_object(new_arr))
 }
 
 pub fn array_filter(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let callback_val = vm.reg(args[1]);
     if !callback_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     let mut kept: Vec<JsValue> = Vec::new();
     for i in 0..n {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) {
-            Ok(result_val) => {
+            NativeResult::Ok(result_val) => {
                 let sf = vm.kernel().string_forge().as_ref();
                 if coercion::to_boolean(result_val, sf) {
                     kept.push(elem);
                 }
             }
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
     let new_arr = create_new_array(vm, kept.len());
@@ -467,20 +472,20 @@ pub fn array_filter(vm: &mut Vm, args: &[u8]) -> NativeResult {
         }
         (*new_arr).set_prop_count(kept.len());
     }
-    Ok(JsValue::from_js_object(new_arr))
+    NativeResult::Ok(JsValue::from_js_object(new_arr))
 }
 
 pub fn array_reduce(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if n == 0 && args.len() < 3 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     if args.len() < 2 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let callback_val = vm.reg(args[1]);
     if !callback_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let has_initial = args.len() > 2;
     let mut accumulator;
@@ -501,103 +506,103 @@ pub fn array_reduce(vm: &mut Vm, args: &[u8]) -> NativeResult {
             this_val,
             &[accumulator, elem, JsValue::int(i as i32), vm.reg(args[0])],
         ) {
-            Ok(result) => accumulator = result,
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Ok(result) => accumulator = result,
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
-    Ok(accumulator)
+    NativeResult::Ok(accumulator)
 }
 
 pub fn array_find(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let callback_val = vm.reg(args[1]);
     if !callback_val.is_object() {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     for i in 0..n {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) {
-            Ok(result_val) => {
+            NativeResult::Ok(result_val) => {
                 let sf = vm.kernel().string_forge().as_ref();
                 if coercion::to_boolean(result_val, sf) {
-                    return Ok(elem);
+                    return NativeResult::Ok(elem);
                 }
             }
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
-    Ok(JsValue::undefined())
+    NativeResult::Ok(JsValue::undefined())
 }
 
 pub fn array_some(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let callback_val = vm.reg(args[1]);
     if !callback_val.is_object() {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     for i in 0..n {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) {
-            Ok(result_val) => {
+            NativeResult::Ok(result_val) => {
                 let sf = vm.kernel().string_forge().as_ref();
                 if coercion::to_boolean(result_val, sf) {
-                    return Ok(JsValue::bool(true));
+                    return NativeResult::Ok(JsValue::bool(true));
                 }
             }
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
-    Ok(JsValue::bool(false))
+    NativeResult::Ok(JsValue::bool(false))
 }
 
 pub fn array_every(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let callback_val = vm.reg(args[1]);
     if !callback_val.is_object() {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     for i in 0..n {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) {
-            Ok(result_val) => {
+            NativeResult::Ok(result_val) => {
                 let sf = vm.kernel().string_forge().as_ref();
                 if !coercion::to_boolean(result_val, sf) {
-                    return Ok(JsValue::bool(false));
+                    return NativeResult::Ok(JsValue::bool(false));
                 }
             }
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
-    Ok(JsValue::bool(true))
+    NativeResult::Ok(JsValue::bool(true))
 }
 
 pub fn array_flat_map(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let callback_val = vm.reg(args[1]);
     if !callback_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     let mut flat: Vec<JsValue> = Vec::new();
     for i in 0..n {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) {
-            Ok(result) => {
+            NativeResult::Ok(result) => {
                 if result.is_object() {
                     let r_ptr = result.as_js_object_ptr();
                     if !r_ptr.is_null() {
@@ -613,7 +618,7 @@ pub fn array_flat_map(vm: &mut Vm, args: &[u8]) -> NativeResult {
                 }
                 flat.push(result);
             }
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
     let new_arr = create_new_array(vm, flat.len());
@@ -623,7 +628,7 @@ pub fn array_flat_map(vm: &mut Vm, args: &[u8]) -> NativeResult {
         }
         (*new_arr).set_prop_count(flat.len());
     }
-    Ok(JsValue::from_js_object(new_arr))
+    NativeResult::Ok(JsValue::from_js_object(new_arr))
 }
 
 pub fn array_shift(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -631,7 +636,7 @@ pub fn array_shift(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let arr = unsafe { &mut *arr_ptr };
     let len = arr.prop_count();
     if len == 0 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let first = arr.get_prop_at(0);
     for i in 1..len {
@@ -639,7 +644,7 @@ pub fn array_shift(vm: &mut Vm, args: &[u8]) -> NativeResult {
         arr.set_prop_at(i - 1, v);
     }
     arr.set_prop_count(len - 1);
-    Ok(first)
+    NativeResult::Ok(first)
 }
 
 pub fn array_unshift(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -656,7 +661,7 @@ pub fn array_unshift(vm: &mut Vm, args: &[u8]) -> NativeResult {
     }
     let new_len = len as usize + n_items;
     arr.set_prop_count(new_len);
-    Ok(JsValue::int(new_len as i32))
+    NativeResult::Ok(JsValue::int(new_len as i32))
 }
 
 pub fn array_fill(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -678,7 +683,7 @@ pub fn array_fill(vm: &mut Vm, args: &[u8]) -> NativeResult {
     for i in start..end {
         arr.set_prop_at(i, value);
     }
-    Ok(vm.reg(args[0]))
+    NativeResult::Ok(vm.reg(args[0]))
 }
 
 pub fn array_copy_within(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -686,7 +691,7 @@ pub fn array_copy_within(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let arr = unsafe { &mut *arr_ptr };
     let len = arr.prop_count() as usize;
     if len == 0 {
-        return Ok(vm.reg(args[0]));
+        return NativeResult::Ok(vm.reg(args[0]));
     }
     let target = if args.len() > 1 {
         (coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32) as usize
@@ -712,7 +717,7 @@ pub fn array_copy_within(vm: &mut Vm, args: &[u8]) -> NativeResult {
         arr.set_prop_at(to, v);
         to += 1;
     }
-    Ok(vm.reg(args[0]))
+    NativeResult::Ok(vm.reg(args[0]))
 }
 
 pub fn array_at(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -728,9 +733,9 @@ pub fn array_at(vm: &mut Vm, args: &[u8]) -> NativeResult {
         index += len;
     }
     if index < 0 || index >= len {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
-    Ok(arr.get_prop_at(index))
+    NativeResult::Ok(arr.get_prop_at(index))
 }
 
 pub fn array_last_index_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -740,31 +745,31 @@ pub fn array_last_index_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let search = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     for i in (0..len).rev() {
         if coercion::strict_equality(arr.get_prop_at(i), search) {
-            return Ok(JsValue::int(i));
+            return NativeResult::Ok(JsValue::int(i));
         }
     }
-    Ok(JsValue::int(-1))
+    NativeResult::Ok(JsValue::int(-1))
 }
 
 pub fn array_find_index(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Ok(JsValue::int(-1));
+        return NativeResult::Ok(JsValue::int(-1));
     }
     let callback_val = vm.reg(args[1]);
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     for i in 0..n {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) {
-            Ok(r) => {
+            NativeResult::Ok(r) => {
                 if coercion::to_boolean(r, vm.kernel().string_forge().as_ref()) {
-                    return Ok(JsValue::int(i as i32));
+                    return NativeResult::Ok(JsValue::int(i as i32));
                 }
             }
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
-    Ok(JsValue::int(-1))
+    NativeResult::Ok(JsValue::int(-1))
 }
 
 pub fn array_find_last(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -773,35 +778,35 @@ pub fn array_find_last(vm: &mut Vm, args: &[u8]) -> NativeResult {
         (arr_ptr, len as i32)
     };
     if args.len() < 2 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let callback_val = vm.reg(args[1]);
     let this_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
     for i in (0..n).rev() {
         let elem = unsafe { (*arr_ptr).get_prop_at(i) };
         match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i), vm.reg(args[0])]) {
-            Ok(r) => {
+            NativeResult::Ok(r) => {
                 if coercion::to_boolean(r, vm.kernel().string_forge().as_ref()) {
-                    return Ok(elem);
+                    return NativeResult::Ok(elem);
                 }
             }
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
-    Ok(JsValue::undefined())
+    NativeResult::Ok(JsValue::undefined())
 }
 
 pub fn array_reduce_right(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (arr_ptr, n) = array_ptr_len!(vm, args);
     if args.len() < 2 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let callback_val = vm.reg(args[1]);
     let (mut acc, start_idx): (JsValue, i32) = if args.len() > 2 {
         (vm.reg(args[2]), n as i32 - 1)
     } else {
         if n == 0 {
-            return Err(JsValue::undefined());
+            return NativeResult::Err(JsValue::undefined());
         }
         (unsafe { (*arr_ptr).get_prop_at(n - 1) }, n as i32 - 2)
     };
@@ -813,11 +818,11 @@ pub fn array_reduce_right(vm: &mut Vm, args: &[u8]) -> NativeResult {
             JsValue::undefined(),
             &[acc, elem, JsValue::int(i), vm.reg(args[0])],
         ) {
-            Ok(r) => acc = r,
-            Err(_) => return Err(JsValue::undefined()),
+            NativeResult::Ok(r) => acc = r,
+            NativeResult::Err(_) | NativeResult::TailCall { .. } => return NativeResult::Err(JsValue::undefined()),
         }
     }
-    Ok(acc)
+    NativeResult::Ok(acc)
 }
 
 pub fn array_sort(vm: &mut Vm, _args: &[u8]) -> NativeResult {
@@ -833,5 +838,5 @@ pub fn array_sort(vm: &mut Vm, _args: &[u8]) -> NativeResult {
     for (i, &v) in vals.iter().enumerate() {
         arr.set_prop_at(i, v);
     }
-    Ok(vm.reg(_args[0]))
+    NativeResult::Ok(vm.reg(_args[0]))
 }

crates/oxide_vm/src/builtins/boolean.rs

@@ -42,18 +42,18 @@ pub fn boolean_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     };
 
     if !is_ctor {
-        return Ok(JsValue::bool(bool_val));
+        return NativeResult::Ok(JsValue::bool(bool_val));
     }
 
     let obj = unsafe { &mut *this_val.as_js_object_ptr() };
     obj.push_prop(JsValue::bool(bool_val));
-    Ok(this_val)
+    NativeResult::Ok(this_val)
 }
 
 pub fn boolean_prototype_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
     if !this_val.is_object() {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Boolean.prototype.valueOf called on non-Boolean object",
         ));
@@ -62,19 +62,19 @@ pub fn boolean_prototype_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let boolean_proto = vm.kernel().builtin_world().boolean_proto.as_ptr() as *mut JsObject;
     let proto_ptr = obj.proto().as_js_object_ptr();
     if proto_ptr.is_null() || !std::ptr::eq(proto_ptr, boolean_proto) {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Boolean.prototype.valueOf called on non-Boolean object",
         ));
     }
     let val = obj.get_prop_at(0);
-    Ok(val)
+    NativeResult::Ok(val)
 }
 
 pub fn boolean_prototype_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
     if !this_val.is_object() {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Boolean.prototype.toString called on non-Boolean object",
         ));
@@ -83,7 +83,7 @@ pub fn boolean_prototype_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let boolean_proto = vm.kernel().builtin_world().boolean_proto.as_ptr() as *mut JsObject;
     let proto_ptr = obj.proto().as_js_object_ptr();
     if proto_ptr.is_null() || !std::ptr::eq(proto_ptr, boolean_proto) {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Boolean.prototype.toString called on non-Boolean object",
         ));
@@ -95,8 +95,8 @@ pub fn boolean_prototype_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
         !val.is_null() && !val.is_undefined()
     };
     if is_true {
-        Ok(vm.intern("true"))
+        NativeResult::Ok(vm.intern("true"))
     } else {
-        Ok(vm.intern("false"))
+        NativeResult::Ok(vm.intern("false"))
     }
 }

crates/oxide_vm/src/builtins/date.rs

@@ -28,11 +28,20 @@ fn is_date(vm: &Vm, obj: &JsObject) -> bool {
     std::ptr::eq(proto_ptr, date_proto)
 }
 
-fn ensure_date(vm: &mut Vm, obj: &JsObject) -> NativeResult {
+fn ensure_date(vm: &mut Vm, obj: &JsObject) -> Result<(), JsValue> {
     if !is_date(vm, obj) {
         return Err(crate::builtins::error::create_type_error(vm, "called on incompatible receiver"));
     }
-    Ok(JsValue::undefined())
+    Ok(())
+}
+
+macro_rules! native_try {
+    ($expr:expr) => {
+        match $expr {
+            Ok(value) => value,
+            Err(err) => return NativeResult::Err(err),
+        }
+    };
 }
 
 fn date_this_mut(vm: &mut Vm, args: &[u8]) -> Result<*mut JsObject, JsValue> {
@@ -185,7 +194,7 @@ pub fn date_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
         } else {
             "Invalid Date".to_string()
         };
-        return Ok(vm.intern(&s));
+        return NativeResult::Ok(vm.intern(&s));
     }
 
     let mut obj = JsObject::new_empty(
@@ -195,20 +204,20 @@ pub fn date_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     obj.set_prop_at(0, JsValue::float(timestamp));
 
     let ptr = vm.epoch().alloc(obj);
-    Ok(JsValue::from_js_object(ptr))
+    NativeResult::Ok(JsValue::from_js_object(ptr))
 }
 
 pub fn date_now(_vm: &mut Vm, _args: &[u8]) -> NativeResult {
-    Ok(JsValue::float(Utc::now().timestamp_millis() as f64))
+    NativeResult::Ok(JsValue::float(Utc::now().timestamp_millis() as f64))
 }
 
 pub fn date_parse(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let val = vm.reg(args[1]);
     if !val.is_string() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let s = vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default();
     let formats = ["%Y-%m-%dT%H:%M:%S%.fZ", "%Y-%m-%dT%H:%M:%S%.f"];
@@ -226,24 +235,24 @@ pub fn date_parse(vm: &mut Vm, args: &[u8]) -> NativeResult {
             }
         }
     }
-    Ok(JsValue::float(ts))
+    NativeResult::Ok(JsValue::float(ts))
 }
 
 pub fn date_utc(_vm: &mut Vm, _args: &[u8]) -> NativeResult {
-    Ok(JsValue::float(f64::NAN))
+    NativeResult::Ok(JsValue::float(f64::NAN))
 }
 
 macro_rules! make_getter {
     ($name:ident, $f:expr, $df:expr) => {
         pub fn $name(vm: &mut Vm, args: &[u8]) -> NativeResult {
-            let obj = unsafe { &*date_this(vm, args)? };
+            let obj = unsafe { &*native_try!(date_this(vm, args)) };
             let ms = get_timestamp(obj);
             if !ms.is_finite() {
-                return Ok(JsValue::float($df));
+                return NativeResult::Ok(JsValue::float($df));
             }
             match dt_from_ms(ms) {
-                Some(dt) => Ok(JsValue::float(($f)(dt))),
-                None => Ok(JsValue::float($df)),
+                Some(dt) => NativeResult::Ok(JsValue::float(($f)(dt))),
+                None => NativeResult::Ok(JsValue::float($df)),
             }
         }
     };
@@ -252,14 +261,14 @@ macro_rules! make_getter {
 macro_rules! make_utc_getter {
     ($name:ident, $f:expr, $df:expr) => {
         pub fn $name(vm: &mut Vm, args: &[u8]) -> NativeResult {
-            let obj = unsafe { &*date_this(vm, args)? };
+            let obj = unsafe { &*native_try!(date_this(vm, args)) };
             let ms = get_timestamp(obj);
             if !ms.is_finite() {
-                return Ok(JsValue::float($df));
+                return NativeResult::Ok(JsValue::float($df));
             }
             match naive_from_ms(ms) {
-                Some(ndt) => Ok(JsValue::float(($f)(ndt))),
-                None => Ok(JsValue::float($df)),
+                Some(ndt) => NativeResult::Ok(JsValue::float(($f)(ndt))),
+                None => NativeResult::Ok(JsValue::float($df)),
             }
         }
     };
@@ -293,9 +302,9 @@ make_utc_getter!(
 );
 
 pub fn date_get_timezone_offset(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let _obj = unsafe { &*date_this(vm, args)? };
+    let _obj = unsafe { &*native_try!(date_this(vm, args)) };
     let offset_min = local_offset_minutes();
-    Ok(JsValue::float(offset_min as f64))
+    NativeResult::Ok(JsValue::float(offset_min as f64))
 }
 
 fn local_offset_minutes() -> i32 {
@@ -311,27 +320,27 @@ fn get_opt_arg(vm: &Vm, args: &[u8], idx: usize, default: u32) -> u32 {
 }
 
 pub fn date_set_time(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let obj = unsafe { &mut *date_this_mut(vm, args)? };
+    let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
     let val = if args.len() > 1 {
         coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref())
     } else {
         f64::NAN
     };
     set_timestamp(obj, val);
-    Ok(JsValue::float(val))
+    NativeResult::Ok(JsValue::float(val))
 }
 
 pub fn date_set_full_year(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    let obj = unsafe { &mut *date_this_mut(vm, args)? };
+    let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let dt = match dt_from_ms(ms) {
         Some(d) => d,
-        None => return Ok(JsValue::float(f64::NAN)),
+        None => return NativeResult::Ok(JsValue::float(f64::NAN)),
     };
     let m = get_opt_arg(vm, args, 2, dt.month0());
     let d = get_opt_arg(vm, args, 3, dt.day0());
@@ -342,54 +351,54 @@ pub fn date_set_full_year(vm: &mut Vm, args: &[u8]) -> NativeResult {
         .unwrap_or(dt);
     let ts = nd.timestamp_millis() as f64;
     set_timestamp(obj, ts);
-    Ok(JsValue::float(ts))
+    NativeResult::Ok(JsValue::float(ts))
 }
 pub fn date_set_month(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    let obj = unsafe { &mut *date_this_mut(vm, args)? };
+    let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let dt = match dt_from_ms(ms) {
         Some(d) => d,
-        None => return Ok(JsValue::float(f64::NAN)),
+        None => return NativeResult::Ok(JsValue::float(f64::NAN)),
     };
     let d = get_opt_arg(vm, args, 2, dt.day0());
     let nd = dt.with_month0(v as u32).and_then(|x| x.with_day0(d)).unwrap_or(dt);
     let ts = nd.timestamp_millis() as f64;
     set_timestamp(obj, ts);
-    Ok(JsValue::float(ts))
+    NativeResult::Ok(JsValue::float(ts))
 }
 pub fn date_set_date(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    let obj = unsafe { &mut *date_this_mut(vm, args)? };
+    let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let dt = match dt_from_ms(ms) {
         Some(d) => d,
-        None => return Ok(JsValue::float(f64::NAN)),
+        None => return NativeResult::Ok(JsValue::float(f64::NAN)),
     };
     let nd = dt.with_day0(v as u32).unwrap_or(dt);
     let ts = nd.timestamp_millis() as f64;
     set_timestamp(obj, ts);
-    Ok(JsValue::float(ts))
+    NativeResult::Ok(JsValue::float(ts))
 }
 pub fn date_set_hours(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    let obj = unsafe { &mut *date_this_mut(vm, args)? };
+    let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let dt = match dt_from_ms(ms) {
         Some(d) => d,
-        None => return Ok(JsValue::float(f64::NAN)),
+        None => return NativeResult::Ok(JsValue::float(f64::NAN)),
     };
     let min = get_opt_arg(vm, args, 2, dt.minute());
     let sec = get_opt_arg(vm, args, 3, dt.second());
@@ -402,19 +411,19 @@ pub fn date_set_hours(vm: &mut Vm, args: &[u8]) -> NativeResult {
         .unwrap_or(dt);
     let ts = nd.timestamp_millis() as f64;
     set_timestamp(obj, ts);
-    Ok(JsValue::float(ts))
+    NativeResult::Ok(JsValue::float(ts))
 }
 pub fn date_set_minutes(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    let obj = unsafe { &mut *date_this_mut(vm, args)? };
+    let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let dt = match dt_from_ms(ms) {
         Some(d) => d,
-        None => return Ok(JsValue::float(f64::NAN)),
+        None => return NativeResult::Ok(JsValue::float(f64::NAN)),
     };
     let sec = get_opt_arg(vm, args, 2, dt.second());
     let ms_arg = get_opt_arg(vm, args, 3, dt.timestamp_subsec_millis());
@@ -425,19 +434,19 @@ pub fn date_set_minutes(vm: &mut Vm, args: &[u8]) -> NativeResult {
         .unwrap_or(dt);
     let ts = nd.timestamp_millis() as f64;
     set_timestamp(obj, ts);
-    Ok(JsValue::float(ts))
+    NativeResult::Ok(JsValue::float(ts))
 }
 pub fn date_set_seconds(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    let obj = unsafe { &mut *date_this_mut(vm, args)? };
+    let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let dt = match dt_from_ms(ms) {
         Some(d) => d,
-        None => return Ok(JsValue::float(f64::NAN)),
+        None => return NativeResult::Ok(JsValue::float(f64::NAN)),
     };
     let ms_arg = get_opt_arg(vm, args, 2, dt.timestamp_subsec_millis());
     let nd = dt
@@ -446,37 +455,37 @@ pub fn date_set_seconds(vm: &mut Vm, args: &[u8]) -> NativeResult {
         .unwrap_or(dt);
     let ts = nd.timestamp_millis() as f64;
     set_timestamp(obj, ts);
-    Ok(JsValue::float(ts))
+    NativeResult::Ok(JsValue::float(ts))
 }
 pub fn date_set_milliseconds(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    let obj = unsafe { &mut *date_this_mut(vm, args)? };
+    let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let dt = match dt_from_ms(ms) {
         Some(d) => d,
-        None => return Ok(JsValue::float(f64::NAN)),
+        None => return NativeResult::Ok(JsValue::float(f64::NAN)),
     };
     let nd = dt.with_nanosecond(v as u32 * 1_000_000).unwrap_or(dt);
     let ts = nd.timestamp_millis() as f64;
     set_timestamp(obj, ts);
-    Ok(JsValue::float(ts))
+    NativeResult::Ok(JsValue::float(ts))
 }
 
 fn date_to_string_inner(vm: &mut Vm, args: &[u8], format_str: &str, invalid: &str) -> NativeResult {
-    let obj = unsafe { &*date_this(vm, args)? };
+    let obj = unsafe { &*native_try!(date_this(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(vm.intern(invalid));
+        return NativeResult::Ok(vm.intern(invalid));
     }
     let s = match dt_from_ms(ms) {
         Some(dt) => dt.format(format_str).to_string(),
         None => invalid.to_string(),
     };
-    Ok(vm.intern(&s))
+    NativeResult::Ok(vm.intern(&s))
 }
 
 pub fn date_to_iso_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -484,16 +493,16 @@ pub fn date_to_iso_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
 }
 
 pub fn date_to_json(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let obj = unsafe { &*date_this(vm, args)? };
+    let obj = unsafe { &*native_try!(date_this(vm, args)) };
     let ms = get_timestamp(obj);
     if !ms.is_finite() {
-        return Ok(JsValue::null());
+        return NativeResult::Ok(JsValue::null());
     }
     let s = match dt_from_ms(ms) {
         Some(dt) => dt.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string(),
-        None => return Ok(JsValue::null()),
+        None => return NativeResult::Ok(JsValue::null()),
     };
-    Ok(vm.intern(&s))
+    NativeResult::Ok(vm.intern(&s))
 }
 
 pub fn date_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -513,7 +522,7 @@ pub fn date_to_utc_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
 }
 
 pub fn date_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let obj = unsafe { &*date_this(vm, args)? };
+    let obj = unsafe { &*native_try!(date_this(vm, args)) };
     let ms = get_timestamp(obj);
-    Ok(JsValue::float(ms))
+    NativeResult::Ok(JsValue::float(ms))
 }

crates/oxide_vm/src/builtins/error.rs

@@ -72,43 +72,43 @@ fn get_msg(vm: &mut Vm, args: &[u8]) -> String {
 pub fn error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let msg = get_msg(vm, args);
     let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().error_proto) as *mut JsObject;
-    Ok(create_error_object(vm, proto_ptr, "Error", &msg))
+    NativeResult::Ok(create_error_object(vm, proto_ptr, "Error", &msg))
 }
 
 pub fn type_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let msg = get_msg(vm, args);
     let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().type_error_proto) as *mut JsObject;
-    Ok(create_error_object(vm, proto_ptr, "TypeError", &msg))
+    NativeResult::Ok(create_error_object(vm, proto_ptr, "TypeError", &msg))
 }
 
 pub fn reference_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let msg = get_msg(vm, args);
     let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().reference_error_proto) as *mut JsObject;
-    Ok(create_error_object(vm, proto_ptr, "ReferenceError", &msg))
+    NativeResult::Ok(create_error_object(vm, proto_ptr, "ReferenceError", &msg))
 }
 
 pub fn range_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let msg = get_msg(vm, args);
     let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().range_error_proto) as *mut JsObject;
-    Ok(create_error_object(vm, proto_ptr, "RangeError", &msg))
+    NativeResult::Ok(create_error_object(vm, proto_ptr, "RangeError", &msg))
 }
 
 pub fn syntax_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let msg = get_msg(vm, args);
     let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().syntax_error_proto) as *mut JsObject;
-    Ok(create_error_object(vm, proto_ptr, "SyntaxError", &msg))
+    NativeResult::Ok(create_error_object(vm, proto_ptr, "SyntaxError", &msg))
 }
 
 pub fn uri_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let msg = get_msg(vm, args);
     let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().uri_error_proto) as *mut JsObject;
-    Ok(create_error_object(vm, proto_ptr, "URIError", &msg))
+    NativeResult::Ok(create_error_object(vm, proto_ptr, "URIError", &msg))
 }
 
 pub fn eval_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let msg = get_msg(vm, args);
     let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().eval_error_proto) as *mut JsObject;
-    Ok(create_error_object(vm, proto_ptr, "EvalError", &msg))
+    NativeResult::Ok(create_error_object(vm, proto_ptr, "EvalError", &msg))
 }
 
 pub fn error_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -134,7 +134,7 @@ pub fn error_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
     };
     let result = if msg.is_empty() { name } else { format!("{}: {}", name, msg) };
     let si = vm.kernel().string_forge().intern(&result).0;
-    Ok(JsValue::string(si, 0))
+    NativeResult::Ok(JsValue::string(si, 0))
 }
 
 pub fn error_stack_getter(vm: &mut Vm, _args: &[u8]) -> NativeResult {
@@ -150,13 +150,13 @@ pub fn error_stack_getter(vm: &mut Vm, _args: &[u8]) -> NativeResult {
     lines.push("    at <anonymous> (native)".to_string());
     let result = lines.join("\n");
     let si = vm.kernel().string_forge().intern(&result).0;
-    Ok(JsValue::string(si, 0))
+    NativeResult::Ok(JsValue::string(si, 0))
 }
 
 #[cfg(test)]
 mod tests {
     use super::error_stack_getter;
-    use crate::vm::{CallFrame, Vm};
+    use crate::vm::{CallFrame, FrameContinuation, Vm};
     use oxide_types::value::JsValue;
 
     #[test]
@@ -174,6 +174,7 @@ mod tests {
             construct_result_reg: None,
             constructed_this: None,
             is_derived_constructor: false,
+            continuation: FrameContinuation::None,
         });
 
         let stack = error_stack_getter(&mut vm, &[0]).unwrap();

crates/oxide_vm/src/builtins/function.rs

@@ -1,43 +1,17 @@
 use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
-use oxide_types::object::JsObject;
+use oxide_types::object::{JsObject, NativeFnPtr};
 use oxide_types::value::JsValue;
 
 use crate::native::NativeResult;
 use crate::vm::Vm;
 
-/// Rebuild a typed JS error object from `call_function_sync`'s `String` error.
-///
-/// `call_function_sync` collapses thrown exceptions to a `String` shaped like
-/// `"TypeError: message"`. Native builtins must return `Err(JsValue)`, and
-/// test262 negative tests match on the error's `name`, so we parse the prefix
-/// back into the right error kind instead of flattening everything to `Error`.
-fn error_from_text(vm: &mut Vm, text: &str) -> JsValue {
-    use crate::builtins::error;
-    let text = text.strip_prefix("uncaught ").unwrap_or(text);
-    let (kind, msg) = match text.split_once(": ") {
-        Some((k, m)) => (k, m),
-        None => ("", text),
-    };
-    match kind {
-        "TypeError" => error::create_type_error(vm, msg),
-        "ReferenceError" => error::create_reference_error(vm, msg),
-        "RangeError" => error::create_range_error(vm, msg),
-        "SyntaxError" => error::create_syntax_error(vm, msg),
-        _ => error::create_error(vm, text),
-    }
-}
-
-/// Invoke any callee (native or user/bytecode function) with an explicit
-/// receiver and register-sourced arguments.
-///
-/// Delegates to `Vm::call_function_sync`, the engine's unified synchronous call
-/// path (also used by getter/setter dispatch). The previous hand-rolled version
-/// only supported native targets, so `Function.prototype.call/apply/bind` threw
-/// on user functions — a major test262 harness blocker.
 fn invoke_target(vm: &mut Vm, target_val: JsValue, this_val: JsValue, arg_regs: &[u8]) -> NativeResult {
     let args: Vec<JsValue> = arg_regs.iter().map(|&r| vm.reg(r)).collect();
-    vm.call_function_sync(target_val, this_val, &args)
-        .map_err(|msg| error_from_text(vm, &msg))
+    NativeResult::TailCall {
+        callee: target_val,
+        this: this_val,
+        args,
+    }
 }
 
 fn bind_dispatcher(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -59,7 +33,7 @@ fn bind_dispatcher(vm: &mut Vm, args: &[u8]) -> NativeResult {
 
 pub fn function_call(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.is_empty() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let target_val = vm.reg(args[0]);
     let this_val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
@@ -69,7 +43,7 @@ pub fn function_call(vm: &mut Vm, args: &[u8]) -> NativeResult {
 
 pub fn function_apply(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.is_empty() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let target_val = vm.reg(args[0]);
     let this_val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
@@ -82,7 +56,8 @@ pub fn function_apply(vm: &mut Vm, args: &[u8]) -> NativeResult {
             if !arr_ptr.is_null() {
                 let arr = unsafe { &*arr_ptr };
                 if arr.is_array() {
-                    let n = arr.hash_props_vec().map_or(0, |v| v.len());
+                    let max_args = 55usize; // base=200, max safe register is 255.
+                    let n = arr.hash_props_vec().map_or(0, |v| v.len()).min(max_args);
                     let base = 200u8;
                     arg_regs = (0..n).map(|i| base + i as u8).collect();
                     for i in 0..n {
@@ -108,30 +83,31 @@ pub fn function_apply(vm: &mut Vm, args: &[u8]) -> NativeResult {
 
 pub fn function_bind(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.is_empty() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let target_val = vm.reg(args[0]);
     if !target_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let bound_this = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
 
     let wrapper = vm.epoch().alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null()));
     unsafe {
         (*wrapper).set_function(true);
-        (*wrapper).set_native_fn(Some(bind_dispatcher as *const ()));
+        // SAFETY: bind_dispatcher is a NativeFn fn-item; valid to store as NativeFnPtr.
+        (*wrapper).set_native_fn(Some(NativeFnPtr::from_raw(bind_dispatcher as *const ())));
         (*wrapper).set_native_arg_count(0);
         (*wrapper).ensure_hash_props().push(Box::new(target_val));
         (*wrapper).ensure_hash_props().push(Box::new(bound_this));
     }
 
-    Ok(JsValue::from_js_object(wrapper))
+    NativeResult::Ok(JsValue::from_js_object(wrapper))
 }
 
 pub fn function_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
     if !this_val.is_object() {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Function.prototype.toString called on non-function",
         ));
@@ -139,7 +115,7 @@ pub fn function_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
 
     let func = unsafe { &*this_val.as_js_object_ptr() };
     if !func.is_function() {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Function.prototype.toString called on non-function",
         ));
@@ -171,5 +147,5 @@ pub fn function_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
         format!("function {name}() {{ {body} }}")
     };
     let si = vm.kernel().string_forge().intern(&result).0;
-    Ok(JsValue::string(si, 0))
+    NativeResult::Ok(JsValue::string(si, 0))
 }

crates/oxide_vm/src/builtins/json.rs

@@ -11,21 +11,26 @@ use crate::vm::Vm;
 
 pub fn json_parse(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Err(crate::builtins::error::create_syntax_error(vm, "JSON.parse requires 1 argument"));
+        return NativeResult::Err(crate::builtins::error::create_syntax_error(vm, "JSON.parse requires 1 argument"));
     }
     let val = vm.reg(args[1]);
     if !val.is_string() {
-        return Err(crate::builtins::error::create_syntax_error(vm, "JSON.parse: argument is not a string"));
+        return NativeResult::Err(crate::builtins::error::create_syntax_error(
+            vm,
+            "JSON.parse: argument is not a string",
+        ));
     }
     let text = {
         let si = val.as_string_index();
         vm.kernel().string_forge().lookup(si).unwrap_or_default()
     };
 
-    let parsed: serde_json::Value =
-        serde_json::from_str(&text).map_err(|e| crate::builtins::error::create_syntax_error(vm, &format!("{}", e)))?;
+    let parsed: serde_json::Value = match serde_json::from_str(&text) {
+        Ok(v) => v,
+        Err(e) => return NativeResult::Err(crate::builtins::error::create_syntax_error(vm, &format!("{}", e))),
+    };
 
-    Ok(value_to_jsvalue(vm, &parsed))
+    NativeResult::Ok(value_to_jsvalue(vm, &parsed))
 }
 
 fn value_to_jsvalue(vm: &mut Vm, val: &serde_json::Value) -> JsValue {
@@ -75,17 +80,18 @@ fn value_to_jsvalue(vm: &mut Vm, val: &serde_json::Value) -> JsValue {
 
 pub fn json_stringify(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let value = vm.reg(args[1]);
     if value.is_undefined() {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let mut visited = HashSet::new();
     let mut output = String::new();
-    jsvalue_to_json(vm, value, &mut visited, &mut output)
-        .map_err(|_| crate::builtins::error::create_type_error(vm, "cyclic object value"))?;
-    Ok(vm.intern(&output))
+    if jsvalue_to_json(vm, value, &mut visited, &mut output).is_err() {
+        return NativeResult::Err(crate::builtins::error::create_type_error(vm, "cyclic object value"));
+    };
+    NativeResult::Ok(vm.intern(&output))
 }
 
 fn jsvalue_to_json(vm: &Vm, val: JsValue, visited: &mut HashSet<*const u8>, out: &mut String) -> Result<(), ()> {

crates/oxide_vm/src/builtins/map.rs

@@ -8,6 +8,25 @@ use crate::vm::Vm;
 
 const MAP_PROP_INDEX: u8 = 0;
 
+macro_rules! native_try {
+    ($expr:expr) => {
+        match $expr {
+            Ok(value) => value,
+            Err(err) => return NativeResult::Err(err),
+        }
+    };
+}
+
+/// Retrieve the `IndexMap` pointer stored at `MAP_PROP_INDEX` of a Map object.
+///
+/// # Safety contract maintained by callers
+///
+/// The pointer is valid as long as the Map `JsObject` itself is alive, which is guaranteed
+/// because the `JsObject` lives in the current `Epoch` arena and `Epoch::reset()` is never
+/// called while a native builtin is executing. The `Box<IndexMap>` that owns the allocation
+/// is created in `new_map_inner()` and is never freed until the process exits (intentional
+/// leak — lifetime is tied to the epoch). Only one live `*mut` alias exists at a time
+/// per Map object because native calls are single-threaded.
 fn get_map_inner(vm: &mut Vm, this_val: JsValue) -> Result<*mut indexmap::IndexMap<SetKey, JsValue>, JsValue> {
     if !this_val.is_object() {
         return Err(crate::builtins::error::create_type_error(vm, "called on non-Map object"));
@@ -16,11 +35,25 @@ fn get_map_inner(vm: &mut Vm, this_val: JsValue) -> Result<*mut indexmap::IndexM
     if map_ptr.is_null() {
         return Err(crate::builtins::error::create_type_error(vm, "Map internal state invalid"));
     }
+    // SAFETY: map_ptr is a non-null, aligned pointer to a JsObject bump-allocated in the
+    // current Epoch. It remains valid for the duration of this call (epoch is not reset
+    // during native execution).
     let map_obj = unsafe { &*map_ptr };
+    if !map_obj.is_map() {
+        return Err(crate::builtins::error::create_type_error(
+            vm,
+            "Map.prototype method called on incompatible receiver",
+        ));
+    }
     let inner_val = map_obj.get_prop_at(MAP_PROP_INDEX);
     if !inner_val.is_object() {
         return Err(crate::builtins::error::create_type_error(vm, "Map internal state invalid"));
     }
+    // SAFETY: inner_val holds the raw pointer written by `alloc_map` as
+    // `JsValue::object(Box::into_raw(Box::new(IndexMap::new())) as *mut u8)`.
+    // The pointer is a valid, heap-allocated `Box<IndexMap<SetKey, JsValue>>` and is
+    // never freed during the Map object's lifetime (see module safety contract above).
+    // Alignment: IndexMap requires at most 8-byte alignment; the global allocator satisfies this.
     let inner_ptr = inner_val.as_js_object_ptr() as *mut indexmap::IndexMap<SetKey, JsValue>;
     if inner_ptr.is_null() {
         return Err(crate::builtins::error::create_type_error(vm, "Map internal state invalid"));
@@ -28,6 +61,9 @@ fn get_map_inner(vm: &mut Vm, this_val: JsValue) -> Result<*mut indexmap::IndexM
     Ok(inner_ptr)
 }
 
+/// Allocate a new `IndexMap` on the global heap.
+/// The caller is responsible for storing the pointer in the Map `JsObject` at `MAP_PROP_INDEX`
+/// via `JsValue::object(ptr as *mut u8)` and ensuring it is never double-freed.
 fn new_map_inner() -> *mut indexmap::IndexMap<SetKey, JsValue> {
     Box::into_raw(Box::new(indexmap::IndexMap::new()))
 }
@@ -35,6 +71,9 @@ fn new_map_inner() -> *mut indexmap::IndexMap<SetKey, JsValue> {
 fn alloc_map(vm: &mut Vm) -> *mut JsObject {
     let map_proto = vm.kernel().builtin_world().map_proto.as_ptr() as *mut JsObject;
     let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(map_proto));
+    obj.set_map(true);
+    // SAFETY: new_map_inner() returns a valid Box<IndexMap> pointer; stored as a JsValue
+    // object tag so get_map_inner() can retrieve and cast it back (same provenance).
     let inner = new_map_inner();
     obj.set_prop_at(MAP_PROP_INDEX, JsValue::object(inner as *mut u8));
     vm.epoch().alloc(obj)
@@ -42,55 +81,55 @@ fn alloc_map(vm: &mut Vm) -> *mut JsObject {
 
 pub fn map_constructor(vm: &mut Vm, _args: &[u8]) -> NativeResult {
     let map_obj = alloc_map(vm);
-    Ok(JsValue::from_js_object(map_obj))
+    NativeResult::Ok(JsValue::from_js_object(map_obj))
 }
 
 pub fn map_set(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_map_inner(vm, this_val)?;
+    let inner = native_try!(get_map_inner(vm, this_val));
     let key = vm.reg(if args.len() > 1 { args[1] } else { 0 });
     let val = vm.reg(if args.len() > 2 { args[2] } else { 0 });
     unsafe {
         (*inner).insert(SetKey(key), val);
     }
-    Ok(this_val)
+    NativeResult::Ok(this_val)
 }
 
 pub fn map_get(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_map_inner(vm, this_val)?;
+    let inner = native_try!(get_map_inner(vm, this_val));
     let key = vm.reg(if args.len() > 1 { args[1] } else { 0 });
     let found = unsafe { (*inner).get(&SetKey(key)).copied() };
-    Ok(found.unwrap_or(JsValue::undefined()))
+    NativeResult::Ok(found.unwrap_or(JsValue::undefined()))
 }
 
 pub fn map_has(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_map_inner(vm, this_val)?;
+    let inner = native_try!(get_map_inner(vm, this_val));
     let key = vm.reg(if args.len() > 1 { args[1] } else { 0 });
     let found = unsafe { (*inner).contains_key(&SetKey(key)) };
-    Ok(JsValue::bool(found))
+    NativeResult::Ok(JsValue::bool(found))
 }
 
 pub fn map_delete(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_map_inner(vm, this_val)?;
+    let inner = native_try!(get_map_inner(vm, this_val));
     let key = vm.reg(if args.len() > 1 { args[1] } else { 0 });
     let removed = unsafe { (*inner).shift_remove(&SetKey(key)) };
-    Ok(JsValue::bool(removed.is_some()))
+    NativeResult::Ok(JsValue::bool(removed.is_some()))
 }
 
 pub fn map_clear(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_map_inner(vm, this_val)?;
+    let inner = native_try!(get_map_inner(vm, this_val));
     unsafe {
         (*inner).clear();
     }
-    Ok(JsValue::undefined())
+    NativeResult::Ok(JsValue::undefined())
 }
 
 pub fn map_size(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_map_inner(vm, this_val)?;
-    Ok(JsValue::float(unsafe { (*inner).len() } as f64))
+    let inner = native_try!(get_map_inner(vm, this_val));
+    NativeResult::Ok(JsValue::float(unsafe { (*inner).len() } as f64))
 }

crates/oxide_vm/src/builtins/math.rs

@@ -25,20 +25,20 @@ fn arg2(vm: &Vm, args: &[u8]) -> (f64, f64) {
 
 pub fn math_abs(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let x = vm.reg(args[1]);
     if x.is_int() {
-        Ok(JsValue::int(x.as_int().abs()))
+        NativeResult::Ok(JsValue::int(x.as_int().abs()))
     } else {
-        Ok(JsValue::float(num(vm, args[1]).abs()))
+        NativeResult::Ok(JsValue::float(num(vm, args[1]).abs()))
     }
 }
 
 macro_rules! math_unary {
     ($name:ident, $op:ident) => {
         pub fn $name(vm: &mut Vm, args: &[u8]) -> NativeResult {
-            Ok(JsValue::float(arg1(vm, args).$op()))
+            NativeResult::Ok(JsValue::float(arg1(vm, args).$op()))
         }
     };
 }
@@ -69,87 +69,87 @@ math_unary!(math_trunc, trunc);
 
 pub fn math_atan2(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (a, b) = arg2(vm, args);
-    Ok(JsValue::float(a.atan2(b)))
+    NativeResult::Ok(JsValue::float(a.atan2(b)))
 }
 
 pub fn math_round(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let x = arg1(vm, args);
     let r = if x < 0.0 { (x - 0.5).ceil() } else { (x + 0.5).floor() };
-    Ok(JsValue::float(r))
+    NativeResult::Ok(JsValue::float(r))
 }
 
 pub fn math_sign(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let x = arg1(vm, args);
     if x.is_nan() {
-        Ok(JsValue::float(f64::NAN))
+        NativeResult::Ok(JsValue::float(f64::NAN))
     } else if x > 0.0 {
-        Ok(JsValue::int(1))
+        NativeResult::Ok(JsValue::int(1))
     } else if x < 0.0 {
-        Ok(JsValue::int(-1))
+        NativeResult::Ok(JsValue::int(-1))
     } else {
-        Ok(JsValue::float(x))
+        NativeResult::Ok(JsValue::float(x))
     }
 }
 
 pub fn math_clz32(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let n = arg1(vm, args) as u32;
-    Ok(JsValue::int(n.leading_zeros() as i32))
+    NativeResult::Ok(JsValue::int(n.leading_zeros() as i32))
 }
 
 pub fn math_fround(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    Ok(JsValue::float(arg1(vm, args) as f32 as f64))
+    NativeResult::Ok(JsValue::float(arg1(vm, args) as f32 as f64))
 }
 
 pub fn math_hypot(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (a, b) = arg2(vm, args);
-    Ok(JsValue::float(a.hypot(b)))
+    NativeResult::Ok(JsValue::float(a.hypot(b)))
 }
 
 pub fn math_imul(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (a, b) = arg2(vm, args);
-    Ok(JsValue::int((a as i32).wrapping_mul(b as i32)))
+    NativeResult::Ok(JsValue::int((a as i32).wrapping_mul(b as i32)))
 }
 
 pub fn math_pow(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let (a, b) = arg2(vm, args);
-    Ok(JsValue::float(a.powf(b)))
+    NativeResult::Ok(JsValue::float(a.powf(b)))
 }
 
 pub fn math_max(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::float(f64::NEG_INFINITY));
+        return NativeResult::Ok(JsValue::float(f64::NEG_INFINITY));
     }
     let mut m = f64::NEG_INFINITY;
     for &r in args.iter().skip(1) {
         let x = num(vm, r);
         if x.is_nan() {
-            return Ok(JsValue::float(f64::NAN));
+            return NativeResult::Ok(JsValue::float(f64::NAN));
         }
         if x > m {
             m = x;
         }
     }
-    Ok(JsValue::float(m))
+    NativeResult::Ok(JsValue::float(m))
 }
 
 pub fn math_min(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::float(f64::INFINITY));
+        return NativeResult::Ok(JsValue::float(f64::INFINITY));
     }
     let mut m = f64::INFINITY;
     for &r in args.iter().skip(1) {
         let x = num(vm, r);
         if x.is_nan() {
-            return Ok(JsValue::float(f64::NAN));
+            return NativeResult::Ok(JsValue::float(f64::NAN));
         }
         if x < m {
             m = x;
         }
     }
-    Ok(JsValue::float(m))
+    NativeResult::Ok(JsValue::float(m))
 }
 
 pub fn math_random(vm: &mut Vm, _args: &[u8]) -> NativeResult {
     vm.step_rng();
-    Ok(JsValue::float(vm.math_rng_value()))
+    NativeResult::Ok(JsValue::float(vm.math_rng_value()))
 }

crates/oxide_vm/src/builtins/number.rs

@@ -11,49 +11,49 @@ pub fn number_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
         0.0
     };
     if n.fract() == 0.0 && n.is_finite() && n >= i32::MIN as f64 && n <= i32::MAX as f64 {
-        Ok(JsValue::int(n as i32))
+        NativeResult::Ok(JsValue::int(n as i32))
     } else {
-        Ok(JsValue::float(n))
+        NativeResult::Ok(JsValue::float(n))
     }
 }
 
 pub fn number_is_nan(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let val = vm.reg(args[1]);
     if val.is_double() {
-        Ok(JsValue::bool(val.as_double().is_nan()))
+        NativeResult::Ok(JsValue::bool(val.as_double().is_nan()))
     } else {
-        Ok(JsValue::bool(false))
+        NativeResult::Ok(JsValue::bool(false))
     }
 }
 
 pub fn number_is_finite(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let val = vm.reg(args[1]);
     if val.is_int() {
-        return Ok(JsValue::bool(true));
+        return NativeResult::Ok(JsValue::bool(true));
     }
     if val.is_double() {
-        return Ok(JsValue::bool(val.as_double().is_finite()));
+        return NativeResult::Ok(JsValue::bool(val.as_double().is_finite()));
     }
     let n = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    Ok(JsValue::bool(n.is_finite()))
+    NativeResult::Ok(JsValue::bool(n.is_finite()))
 }
 
 pub fn number_parse_int(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let sf = vm.kernel().string_forge().as_ref();
     let s = coercion::to_string(sf, vm.reg(args[1]));
     let s = s.trim();
 
     if s.is_empty() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
 
     let radix = if args.len() > 2 {
@@ -80,27 +80,27 @@ pub fn number_parse_int(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let actual_radix = if hex { 16u32 } else { radix as u32 };
 
     if let Ok(n) = i32::from_str_radix(&rest, actual_radix) {
-        return Ok(JsValue::int(n));
+        return NativeResult::Ok(JsValue::int(n));
     }
 
-    Ok(JsValue::float(f64::NAN))
+    NativeResult::Ok(JsValue::float(f64::NAN))
 }
 
 pub fn number_parse_float(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
     let sf = vm.kernel().string_forge().as_ref();
     let s = coercion::to_string(sf, vm.reg(args[1]));
     let s = s.trim();
 
     if s.is_empty() {
-        return Ok(JsValue::float(f64::NAN));
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
 
     match fast_float::parse::<f64, _>(&s) {
-        Ok(v) => Ok(JsValue::float(v)),
-        Err(_) => Ok(JsValue::float(f64::NAN)),
+        Ok(v) => NativeResult::Ok(JsValue::float(v)),
+        Err(_) => NativeResult::Ok(JsValue::float(f64::NAN)),
     }
 }
 
@@ -115,22 +115,22 @@ pub fn number_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
 
     if radix == 10 {
         if n.is_nan() {
-            return Ok(vm.intern("NaN"));
+            return NativeResult::Ok(vm.intern("NaN"));
         }
         if n.is_infinite() {
             if n.is_sign_positive() {
-                return Ok(vm.intern("Infinity"));
+                return NativeResult::Ok(vm.intern("Infinity"));
             }
-            return Ok(vm.intern("-Infinity"));
+            return NativeResult::Ok(vm.intern("-Infinity"));
         }
         if n.fract() == 0.0 && n >= i32::MIN as f64 && n <= i32::MAX as f64 {
-            return Ok(vm.intern(&(n as i64).to_string()));
+            return NativeResult::Ok(vm.intern(&(n as i64).to_string()));
         }
         let mut buf = ryu::Buffer::new();
-        Ok(vm.intern(buf.format(n)))
+        NativeResult::Ok(vm.intern(buf.format(n)))
     } else {
         if n.is_nan() {
-            return Ok(vm.intern("NaN"));
+            return NativeResult::Ok(vm.intern("NaN"));
         }
         let nn = n as i64;
         let mut result = String::new();
@@ -151,7 +151,7 @@ pub fn number_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
         if nn < 0 {
             result.insert(0, '-');
         }
-        Ok(vm.intern(&result))
+        NativeResult::Ok(vm.intern(&result))
     }
 }
 
@@ -165,20 +165,20 @@ pub fn number_to_fixed(vm: &mut Vm, args: &[u8]) -> NativeResult {
     .min(20);
 
     let formatted = format!("{:.digits$}", n);
-    Ok(vm.intern(&formatted))
+    NativeResult::Ok(vm.intern(&formatted))
 }
 
 pub fn number_is_integer(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = vm.reg(if args.len() > 1 { args[1] } else { args[0] });
     let n = coercion::to_number(val, vm.kernel().string_forge().as_ref());
-    Ok(JsValue::bool(n.trunc() == n && n.is_finite()))
+    NativeResult::Ok(JsValue::bool(n.trunc() == n && n.is_finite()))
 }
 
 pub fn number_is_safe_integer(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let val = vm.reg(if args.len() > 1 { args[1] } else { args[0] });
     let n = coercion::to_number(val, vm.kernel().string_forge().as_ref());
     let safe = n.trunc() == n && n.is_finite() && n >= -9007199254740991i64 as f64 && n <= 9007199254740991i64 as f64;
-    Ok(JsValue::bool(safe))
+    NativeResult::Ok(JsValue::bool(safe))
 }
 
 pub fn number_to_exponential(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -190,13 +190,13 @@ pub fn number_to_exponential(vm: &mut Vm, args: &[u8]) -> NativeResult {
     }
     .min(100);
     if n.is_nan() {
-        return Ok(vm.intern("NaN"));
+        return NativeResult::Ok(vm.intern("NaN"));
     }
     if n.is_infinite() {
-        return Ok(vm.intern(if n.is_sign_positive() { "Infinity" } else { "-Infinity" }));
+        return NativeResult::Ok(vm.intern(if n.is_sign_positive() { "Infinity" } else { "-Infinity" }));
     }
     let formatted = format!("{:.digits$e}", n);
-    Ok(vm.intern(&formatted))
+    NativeResult::Ok(vm.intern(&formatted))
 }
 
 pub fn number_to_precision(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -208,19 +208,19 @@ pub fn number_to_precision(vm: &mut Vm, args: &[u8]) -> NativeResult {
     }
     .min(21);
     if n.is_nan() {
-        return Ok(vm.intern("NaN"));
+        return NativeResult::Ok(vm.intern("NaN"));
     }
     if n.is_infinite() {
-        return Ok(vm.intern(if n.is_sign_positive() { "Infinity" } else { "-Infinity" }));
+        return NativeResult::Ok(vm.intern(if n.is_sign_positive() { "Infinity" } else { "-Infinity" }));
     }
     let formatted = format!("{:.precision$}", n);
-    Ok(vm.intern(&formatted))
+    NativeResult::Ok(vm.intern(&formatted))
 }
 
 pub fn number_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(args[0]);
     if this_val.is_int() || this_val.is_double() {
-        return Ok(this_val);
+        return NativeResult::Ok(this_val);
     }
-    Ok(JsValue::float(f64::NAN))
+    NativeResult::Ok(JsValue::float(f64::NAN))
 }

crates/oxide_vm/src/builtins/object.rs

@@ -39,20 +39,20 @@ pub(crate) fn walk_own_keys(vm: &Vm, obj: &JsObject) -> Vec<(u32, u32)> {
 
 pub fn object_constructor(vm: &mut Vm, _args: &[u8]) -> NativeResult {
     let obj = vm.epoch().alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null()));
-    Ok(JsValue::from_js_object(obj))
+    NativeResult::Ok(JsValue::from_js_object(obj))
 }
 
 pub fn object_keys(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let val = vm.reg(args[1]);
     if !val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let obj_ptr = val.as_js_object_ptr();
     if obj_ptr.is_null() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
 
     let key_names: Vec<String>;
@@ -82,31 +82,33 @@ pub fn object_keys(vm: &mut Vm, args: &[u8]) -> NativeResult {
     unsafe {
         (*arr).set_prop_count(n);
     }
-    Ok(JsValue::from_js_object(arr))
+    NativeResult::Ok(JsValue::from_js_object(arr))
 }
 
 pub fn object_create(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let proto_val = vm.reg(args[1]);
     if !proto_val.is_null() && !proto_val.is_object() {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let obj = vm.epoch().alloc(JsObject::new_empty(EMPTY_SHAPE_ID, proto_val));
-    Ok(JsValue::from_js_object(obj))
+    NativeResult::Ok(JsValue::from_js_object(obj))
 }
 
 pub fn object_assign(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Err(crate::builtins::error::create_type_error(vm, "Object.assign requires a target"));
+        return NativeResult::Err(crate::builtins::error::create_type_error(vm, "Object.assign requires a target"));
     }
     let target_val = vm.reg(args[1]);
-    let target_val =
-        coercion::to_object(target_val, vm).map_err(|msg| crate::builtins::error::create_type_error(vm, msg))?;
+    let target_val = match coercion::to_object(target_val, vm) {
+        Ok(val) => val,
+        Err(msg) => return NativeResult::Err(crate::builtins::error::create_type_error(vm, msg)),
+    };
     let target_ptr = target_val.as_js_object_ptr();
     if target_ptr.is_null() {
-        return Ok(target_val);
+        return NativeResult::Ok(target_val);
     }
     {
         let target = unsafe { &mut *target_ptr };
@@ -127,34 +129,34 @@ pub fn object_assign(vm: &mut Vm, args: &[u8]) -> NativeResult {
             }
         }
     }
-    Ok(target_val)
+    NativeResult::Ok(target_val)
 }
 
 pub fn object_is(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let lhs = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let rhs = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
-    Ok(JsValue::bool(coercion::same_value(lhs, rhs)))
+    NativeResult::Ok(JsValue::bool(coercion::same_value(lhs, rhs)))
 }
 
 pub fn object_define_property(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 4 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let obj_val = vm.reg(args[1]);
     if !obj_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let obj_ptr = obj_val.as_js_object_ptr();
     if obj_ptr.is_null() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let desc_val = vm.reg(args[3]);
     if !desc_val.is_object() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let desc_ptr = desc_val.as_js_object_ptr();
     if desc_ptr.is_null() {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let prop_name_str = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2]));
     let si = vm.kernel().string_forge().intern(&prop_name_str).0;
@@ -181,7 +183,7 @@ pub fn object_define_property(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let has_data = value_field.is_some() || writable_field.is_some();
     let has_accessor = get_field.is_some() || set_field.is_some();
     if has_data && has_accessor {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Invalid property descriptor: cannot mix data and accessor fields",
         ));
@@ -192,35 +194,43 @@ pub fn object_define_property(vm: &mut Vm, args: &[u8]) -> NativeResult {
         let get = get_field.unwrap_or(JsValue::undefined());
         let set = set_field.unwrap_or(JsValue::undefined());
         if (!get.is_undefined() && !is_callable(get)) || (!set.is_undefined() && !is_callable(set)) {
-            return Err(crate::builtins::error::create_type_error(
+            return NativeResult::Err(crate::builtins::error::create_type_error(
                 vm,
                 "accessor descriptor get/set must be callable or undefined",
             ));
         }
-        vm.define_accessor_property(obj, si, get, set, PropAttributes::new(false, enumerable, configurable))
-            .map_err(|_| crate::builtins::error::create_type_error(vm, "Cannot define property"))?;
+        if vm
+            .define_accessor_property(obj, si, get, set, PropAttributes::new(false, enumerable, configurable))
+            .is_err()
+        {
+            return NativeResult::Err(crate::builtins::error::create_type_error(vm, "Cannot define property"));
+        }
     } else {
         let value = value_field.unwrap_or(JsValue::undefined());
         let writable = writable_field
             .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref()))
             .unwrap_or(false);
-        vm.define_data_property(obj, si, value, PropAttributes::new(writable, enumerable, configurable))
-            .map_err(|_| crate::builtins::error::create_type_error(vm, "Cannot define property"))?;
+        if vm
+            .define_data_property(obj, si, value, PropAttributes::new(writable, enumerable, configurable))
+            .is_err()
+        {
+            return NativeResult::Err(crate::builtins::error::create_type_error(vm, "Cannot define property"));
+        }
     }
-    Ok(obj_val)
+    NativeResult::Ok(obj_val)
 }
 
 pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 3 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let obj_val = vm.reg(args[1]);
     if !obj_val.is_object() {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let obj_ptr = obj_val.as_js_object_ptr();
     if obj_ptr.is_null() {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let prop_name_str = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2]));
     let si = vm.kernel().string_forge().intern(&prop_name_str).0;
@@ -243,7 +253,7 @@ pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeRes
     };
 
     if !found {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
 
     let sf_ptr = vm.kernel().string_forge().as_ref() as *const StringForge;
@@ -269,7 +279,7 @@ pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeRes
         push_desc_prop(d, sh, sf.intern("configurable").0, JsValue::bool(meta.attributes.configurable()));
     }
 
-    Ok(JsValue::from_js_object(desc))
+    NativeResult::Ok(JsValue::from_js_object(desc))
 }
 
 fn own_field(vm: &Vm, obj: &JsObject, prop_si: u32) -> Option<JsValue> {
@@ -319,68 +329,77 @@ fn require_obj_arg(vm: &mut Vm, args: &[u8], fn_name: &str) -> Result<*mut JsObj
     Ok(ptr)
 }
 
+macro_rules! native_try {
+    ($expr:expr) => {
+        match $expr {
+            Ok(value) => value,
+            Err(err) => return NativeResult::Err(err),
+        }
+    };
+}
+
 pub fn object_freeze(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let val = vm.reg(args[1]);
     if !val.is_object() || val.as_js_object_ptr().is_null() {
-        return Ok(val);
+        return NativeResult::Ok(val);
     }
-    Ok(val)
+    NativeResult::Ok(val)
 }
 
 pub fn object_seal(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let val = vm.reg(args[1]);
     if !val.is_object() || val.as_js_object_ptr().is_null() {
-        return Ok(val);
+        return NativeResult::Ok(val);
     }
-    Ok(val)
+    NativeResult::Ok(val)
 }
 
 pub fn object_prevent_extensions(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let val = vm.reg(args[1]);
     if !val.is_object() || val.as_js_object_ptr().is_null() {
-        return Ok(val);
+        return NativeResult::Ok(val);
     }
-    Ok(val)
+    NativeResult::Ok(val)
 }
 
 pub fn object_is_frozen(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::bool(true));
+        return NativeResult::Ok(JsValue::bool(true));
     }
     let val = vm.reg(args[1]);
     if !val.is_object() || val.as_js_object_ptr().is_null() {
-        return Ok(JsValue::bool(true));
+        return NativeResult::Ok(JsValue::bool(true));
     }
-    Ok(JsValue::bool(false))
+    NativeResult::Ok(JsValue::bool(false))
 }
 
 pub fn object_is_sealed(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::bool(true));
+        return NativeResult::Ok(JsValue::bool(true));
     }
     let val = vm.reg(args[1]);
     if !val.is_object() || val.as_js_object_ptr().is_null() {
-        return Ok(JsValue::bool(true));
+        return NativeResult::Ok(JsValue::bool(true));
     }
-    Ok(JsValue::bool(false))
+    NativeResult::Ok(JsValue::bool(false))
 }
 
 pub fn object_is_extensible(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    require_obj_arg(vm, args, "isExtensible")?;
-    Ok(JsValue::bool(true))
+    native_try!(require_obj_arg(vm, args, "isExtensible"));
+    NativeResult::Ok(JsValue::bool(true))
 }
 
 pub fn object_get_own_property_names(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let obj_ptr = require_obj_arg(vm, args, "getOwnPropertyNames")?;
+    let obj_ptr = native_try!(require_obj_arg(vm, args, "getOwnPropertyNames"));
 
     let key_names: Vec<String> = {
         let obj = unsafe { &*obj_ptr };
@@ -407,74 +426,74 @@ pub fn object_get_own_property_names(vm: &mut Vm, args: &[u8]) -> NativeResult {
     unsafe {
         (*arr).set_prop_count(n);
     }
-    Ok(JsValue::from_js_object(arr))
+    NativeResult::Ok(JsValue::from_js_object(arr))
 }
 
 pub fn object_define_properties(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 3 {
-        return Ok(vm.reg(args[1]));
+        return NativeResult::Ok(vm.reg(args[1]));
     }
-    let _obj_ptr = require_obj_arg(vm, args, "defineProperties")?;
+    let _obj_ptr = native_try!(require_obj_arg(vm, args, "defineProperties"));
     let desc_val = vm.reg(args[2]);
     if !desc_val.is_object() {
-        return Ok(vm.reg(args[1]));
+        return NativeResult::Ok(vm.reg(args[1]));
     }
-    Ok(vm.reg(args[1]))
+    NativeResult::Ok(vm.reg(args[1]))
 }
 
 pub fn object_from_entries(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::null());
+        return NativeResult::Ok(JsValue::null());
     }
     let entries = vm.reg(args[1]);
     if !entries.is_object() {
-        return Ok(JsValue::null());
+        return NativeResult::Ok(JsValue::null());
     }
     let obj_ptr = vm.epoch().alloc(JsObject::new_empty(
         EMPTY_SHAPE_ID,
         JsValue::from_js_object(vm.kernel().builtin_world().object_proto.as_ptr() as *mut JsObject),
     ));
-    Ok(JsValue::from_js_object(obj_ptr))
+    NativeResult::Ok(JsValue::from_js_object(obj_ptr))
 }
 
 pub fn object_get_prototype_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let obj_ptr = require_obj_arg(vm, args, "getPrototypeOf")?;
-    Ok(unsafe { (*obj_ptr).proto() })
+    let obj_ptr = native_try!(require_obj_arg(vm, args, "getPrototypeOf"));
+    NativeResult::Ok(unsafe { (*obj_ptr).proto() })
 }
 
 pub fn object_has_own(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 3 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
-    let obj_ptr = require_obj_arg(vm, args, "hasOwn")?;
+    let obj_ptr = native_try!(require_obj_arg(vm, args, "hasOwn"));
     let key_si = vm.property_key_si(vm.reg(args[2]));
     let obj = unsafe { &*obj_ptr };
-    Ok(JsValue::bool(vm.get_own_property_slot(obj, key_si).is_some()))
+    NativeResult::Ok(JsValue::bool(vm.get_own_property_slot(obj, key_si).is_some()))
 }
 
 pub fn object_proto_has_own_property(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let this_val = vm.reg(args[0]);
     if !this_val.is_object() || this_val.as_js_object_ptr().is_null() {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Object.prototype.hasOwnProperty called on non-object",
         ));
     }
     let key_si = vm.property_key_si(vm.reg(args[1]));
     let obj = unsafe { &*this_val.as_js_object_ptr() };
-    Ok(JsValue::bool(vm.get_own_property_slot(obj, key_si).is_some()))
+    NativeResult::Ok(JsValue::bool(vm.get_own_property_slot(obj, key_si).is_some()))
 }
 
 pub fn object_proto_property_is_enumerable(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let this_val = vm.reg(args[0]);
     if !this_val.is_object() || this_val.as_js_object_ptr().is_null() {
-        return Err(crate::builtins::error::create_type_error(
+        return NativeResult::Err(crate::builtins::error::create_type_error(
             vm,
             "Object.prototype.propertyIsEnumerable called on non-object",
         ));
@@ -482,17 +501,17 @@ pub fn object_proto_property_is_enumerable(vm: &mut Vm, args: &[u8]) -> NativeRe
     let key_si = vm.property_key_si(vm.reg(args[1]));
     let obj = unsafe { &*this_val.as_js_object_ptr() };
     let Some(pos) = vm.get_own_property_slot(obj, key_si) else {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     };
     let enumerable = obj
         .prop_meta_at(pos)
         .map(|meta| meta.attributes.enumerable())
         .unwrap_or(PropAttributes::DEFAULT_DATA.enumerable());
-    Ok(JsValue::bool(enumerable))
+    NativeResult::Ok(JsValue::bool(enumerable))
 }
 
 pub fn object_entries(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let obj_ptr = require_obj_arg(vm, args, "entries")?;
+    let obj_ptr = native_try!(require_obj_arg(vm, args, "entries"));
     let obj = unsafe { &*obj_ptr };
     let keys = walk_own_keys(vm, obj);
     let n = keys.len();
@@ -523,11 +542,11 @@ pub fn object_entries(vm: &mut Vm, args: &[u8]) -> NativeResult {
     unsafe {
         (*arr).set_prop_count(n);
     }
-    Ok(JsValue::from_js_object(arr))
+    NativeResult::Ok(JsValue::from_js_object(arr))
 }
 
 pub fn object_values(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let obj_ptr = require_obj_arg(vm, args, "values")?;
+    let obj_ptr = native_try!(require_obj_arg(vm, args, "values"));
     let obj = unsafe { &*obj_ptr };
     let keys = walk_own_keys(vm, obj);
     let n = keys.len();
@@ -547,5 +566,5 @@ pub fn object_values(vm: &mut Vm, args: &[u8]) -> NativeResult {
     unsafe {
         (*arr).set_prop_count(n);
     }
-    Ok(JsValue::from_js_object(arr))
+    NativeResult::Ok(JsValue::from_js_object(arr))
 }

crates/oxide_vm/src/builtins/regexp.rs

@@ -1,5 +1,5 @@
 use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
-use oxide_types::object::JsObject;
+use oxide_types::object::{JsObject, NativeFnPtr};
 use oxide_types::value::JsValue;
 
 use crate::coercion;
@@ -91,11 +91,15 @@ pub fn regexp_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     match compiled {
         Ok(re) => {
             let re_ptr = Box::into_raw(Box::new(re));
-            obj.set_native_fn(Some(re_ptr as *const ()));
+            // SAFETY: re_ptr is a Box<regex::Regex> pointer stored by the constructor via
+            // NativeFnPtr::from_raw(re_ptr as *const ()). RegExp objects repurpose the native_fn
+            // field to hold the compiled Regex — not a NativeFn pointer. Valid for the object's
+            // lifetime because the Box is never freed (intentional leak tied to epoch).
+            obj.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(re_ptr as *const ()) }));
         }
         Err(e) => {
             let msg = format!("SyntaxError: Invalid regular expression: {}", e);
-            return Err(JsValue::string(vm.kernel().string_forge().intern(&msg).0, 0));
+            return NativeResult::Err(JsValue::string(vm.kernel().string_forge().intern(&msg).0, 0));
         }
     }
 
@@ -110,21 +114,28 @@ pub fn regexp_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     set_prop(&mut obj, "unicode", JsValue::bool(false), vm);
 
     let obj_ptr = vm.epoch().alloc(obj);
-    Ok(JsValue::from_js_object(obj_ptr))
+    NativeResult::Ok(JsValue::from_js_object(obj_ptr))
 }
 
 pub fn regexp_test(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let re_ptr = get_regexp_ptr(vm, args)?;
+    let re_ptr = match get_regexp_ptr(vm, args) {
+        Ok(ptr) => ptr,
+        Err(err) => return NativeResult::Err(err),
+    };
     let re = unsafe { &*re_ptr };
 
     let fn_ptr = match re.native_fn() {
         None => {
-            return Err(JsValue::string(vm.kernel().string_forge().intern("TypeError: invalid RegExp").0, 0));
+            return NativeResult::Err(JsValue::string(
+                vm.kernel().string_forge().intern("TypeError: invalid RegExp").0,
+                0,
+            ));
         }
         Some(p) => p,
     };
 
-    let regex = unsafe { &*(fn_ptr as *const regex::Regex) };
+    // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+    let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
     let haystack = coercion::to_string(
         vm.kernel().string_forge().as_ref(),
         vm.reg(if args.len() > 1 { args[1] } else { args[0] }),
@@ -134,26 +145,33 @@ pub fn regexp_test(vm: &mut Vm, args: &[u8]) -> NativeResult {
 
     if is_global {
         let result = regex.find_at(&haystack, last_index).is_some();
-        Ok(JsValue::bool(result))
+        NativeResult::Ok(JsValue::bool(result))
     } else {
-        Ok(JsValue::bool(regex.is_match(&haystack)))
+        NativeResult::Ok(JsValue::bool(regex.is_match(&haystack)))
     }
 }
 
 pub fn regexp_exec(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let re_ptr = get_regexp_ptr(vm, args)?;
+    let re_ptr = match get_regexp_ptr(vm, args) {
+        Ok(ptr) => ptr,
+        Err(err) => return NativeResult::Err(err),
+    };
 
     let fn_ptr = {
         let re = unsafe { &*re_ptr };
         match re.native_fn() {
             None => {
-                return Err(JsValue::string(vm.kernel().string_forge().intern("TypeError: invalid RegExp").0, 0));
+                return NativeResult::Err(JsValue::string(
+                    vm.kernel().string_forge().intern("TypeError: invalid RegExp").0,
+                    0,
+                ));
             }
             Some(p) => p,
         }
     };
 
-    let regex = unsafe { &*(fn_ptr as *const regex::Regex) };
+    // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+    let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
     let haystack = coercion::to_string(
         vm.kernel().string_forge().as_ref(),
         vm.reg(if args.len() > 1 { args[1] } else { args[0] }),
@@ -168,7 +186,7 @@ pub fn regexp_exec(vm: &mut Vm, args: &[u8]) -> NativeResult {
 
     let match_result = if is_global {
         if last_index > haystack.len() {
-            return Ok(JsValue::null());
+            return NativeResult::Ok(JsValue::null());
         }
         regex.find_at(&haystack, last_index)
     } else {
@@ -204,17 +222,20 @@ pub fn regexp_exec(vm: &mut Vm, args: &[u8]) -> NativeResult {
         }
 
         let obj_ptr = vm.epoch().alloc(match_obj);
-        Ok(JsValue::from_js_object(obj_ptr))
+        NativeResult::Ok(JsValue::from_js_object(obj_ptr))
     } else {
         if is_global {
             set_prop_at(re_ptr, 0, JsValue::int(0));
         }
-        Ok(JsValue::null())
+        NativeResult::Ok(JsValue::null())
     }
 }
 
 pub fn regexp_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
-    let re_ptr = get_regexp_ptr(vm, args)?;
+    let re_ptr = match get_regexp_ptr(vm, args) {
+        Ok(ptr) => ptr,
+        Err(err) => return NativeResult::Err(err),
+    };
     let re = unsafe { &*re_ptr };
     let source = {
         let val = get_prop(re, 1);
@@ -226,5 +247,5 @@ pub fn regexp_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
     };
     let result = format!("/{}/{}", source, flags);
     let si = vm.kernel().string_forge().intern(&result).0;
-    Ok(JsValue::string(si, 0))
+    NativeResult::Ok(JsValue::string(si, 0))
 }

crates/oxide_vm/src/builtins/set.rs

@@ -9,6 +9,15 @@ use crate::vm::Vm;
 
 const SET_PROP_INDEX: u8 = 0;
 
+macro_rules! native_try {
+    ($expr:expr) => {
+        match $expr {
+            Ok(value) => value,
+            Err(err) => return NativeResult::Err(err),
+        }
+    };
+}
+
 #[derive(Clone, Copy)]
 pub struct SetKey(pub JsValue);
 
@@ -25,6 +34,7 @@ impl PartialEq for SetKey {
             }
             return a == b;
         }
+        // SAFETY: JsValue is an 8-byte NaN-boxed Copy value; raw bits define non-double identity here.
         unsafe { std::mem::transmute::<JsValue, u64>(self.0) == std::mem::transmute::<JsValue, u64>(other.0) }
     }
 }
@@ -43,11 +53,21 @@ impl Hash for SetKey {
                 d.to_bits().hash(state);
             }
         } else {
+            // SAFETY: JsValue is an 8-byte NaN-boxed Copy value; hashing raw bits matches equality above.
             unsafe { std::mem::transmute::<JsValue, u64>(self.0).hash(state) }
         }
     }
 }
 
+/// Retrieve the `IndexSet` pointer stored at `SET_PROP_INDEX` of a Set object.
+///
+/// # Safety contract maintained by callers
+///
+/// The pointer is valid as long as the Set `JsObject` itself is alive. The `JsObject`
+/// lives in the current `Epoch` arena and `Epoch::reset()` is never called while a
+/// native builtin is executing. The `Box<IndexSet>` is allocated in `new_set_inner()`
+/// and is never freed during the Set's lifetime. Only one live `*mut` alias exists per
+/// Set object at a time because native calls are single-threaded.
 fn get_set_inner(vm: &mut Vm, this_val: JsValue) -> Result<*mut indexmap::IndexSet<SetKey>, JsValue> {
     if !this_val.is_object() {
         return Err(crate::builtins::error::create_type_error(vm, "called on non-Set object"));
@@ -56,11 +76,24 @@ fn get_set_inner(vm: &mut Vm, this_val: JsValue) -> Result<*mut indexmap::IndexS
     if set_ptr.is_null() {
         return Err(crate::builtins::error::create_type_error(vm, "Set internal state invalid"));
     }
+    // SAFETY: set_ptr is a non-null, aligned pointer to a JsObject bump-allocated in the
+    // current Epoch. Remains valid for the duration of this call.
     let set_obj = unsafe { &*set_ptr };
+    if !set_obj.is_set() {
+        return Err(crate::builtins::error::create_type_error(
+            vm,
+            "Set.prototype.add called on incompatible receiver",
+        ));
+    }
     let inner_val = set_obj.get_prop_at(SET_PROP_INDEX);
     if !inner_val.is_object() {
         return Err(crate::builtins::error::create_type_error(vm, "Set internal state invalid"));
     }
+    // SAFETY: inner_val holds the raw pointer written by `alloc_set` as
+    // `JsValue::object(Box::into_raw(Box::new(IndexSet::new())) as *mut u8)`.
+    // The pointer is a valid, heap-allocated `Box<IndexSet<SetKey>>` and is never freed
+    // during the Set object's lifetime (see module safety contract above).
+    // Alignment: IndexSet requires at most 8-byte alignment; the global allocator satisfies this.
     let inner_ptr = inner_val.as_js_object_ptr() as *mut indexmap::IndexSet<SetKey>;
     if inner_ptr.is_null() {
         return Err(crate::builtins::error::create_type_error(vm, "Set internal state invalid"));
@@ -68,6 +101,9 @@ fn get_set_inner(vm: &mut Vm, this_val: JsValue) -> Result<*mut indexmap::IndexS
     Ok(inner_ptr)
 }
 
+/// Allocate a new `IndexSet` on the global heap.
+/// The caller is responsible for storing the pointer in the Set `JsObject` at `SET_PROP_INDEX`
+/// via `JsValue::object(ptr as *mut u8)` and ensuring it is never double-freed.
 fn new_set_inner() -> *mut indexmap::IndexSet<SetKey> {
     Box::into_raw(Box::new(indexmap::IndexSet::new()))
 }
@@ -75,6 +111,9 @@ fn new_set_inner() -> *mut indexmap::IndexSet<SetKey> {
 fn alloc_set(vm: &mut Vm) -> *mut JsObject {
     let set_proto = vm.kernel().builtin_world().set_proto.as_ptr() as *mut JsObject;
     let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(set_proto));
+    obj.set_set(true);
+    // SAFETY: new_set_inner() returns a valid Box<IndexSet> pointer; stored as a JsValue
+    // object tag so get_set_inner() can retrieve and cast it back (same provenance).
     let inner = new_set_inner();
     obj.set_prop_at(SET_PROP_INDEX, JsValue::object(inner as *mut u8));
     vm.epoch().alloc(obj)
@@ -82,46 +121,46 @@ fn alloc_set(vm: &mut Vm) -> *mut JsObject {
 
 pub fn set_constructor(vm: &mut Vm, _args: &[u8]) -> NativeResult {
     let set_obj = alloc_set(vm);
-    Ok(JsValue::from_js_object(set_obj))
+    NativeResult::Ok(JsValue::from_js_object(set_obj))
 }
 
 pub fn set_add(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_set_inner(vm, this_val)?;
+    let inner = native_try!(get_set_inner(vm, this_val));
     let val = vm.reg(if args.len() > 1 { args[1] } else { 0 });
     unsafe {
         (*inner).insert(SetKey(val));
     }
-    Ok(this_val)
+    NativeResult::Ok(this_val)
 }
 
 pub fn set_has(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_set_inner(vm, this_val)?;
+    let inner = native_try!(get_set_inner(vm, this_val));
     let val = vm.reg(if args.len() > 1 { args[1] } else { 0 });
     let found = unsafe { (*inner).contains(&SetKey(val)) };
-    Ok(JsValue::bool(found))
+    NativeResult::Ok(JsValue::bool(found))
 }
 
 pub fn set_delete(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_set_inner(vm, this_val)?;
+    let inner = native_try!(get_set_inner(vm, this_val));
     let val = vm.reg(if args.len() > 1 { args[1] } else { 0 });
     let removed = unsafe { (*inner).shift_remove(&SetKey(val)) };
-    Ok(JsValue::bool(removed))
+    NativeResult::Ok(JsValue::bool(removed))
 }
 
 pub fn set_clear(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_set_inner(vm, this_val)?;
+    let inner = native_try!(get_set_inner(vm, this_val));
     unsafe {
         (*inner).clear();
     }
-    Ok(JsValue::undefined())
+    NativeResult::Ok(JsValue::undefined())
 }
 
 pub fn set_size(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
-    let inner = get_set_inner(vm, this_val)?;
-    Ok(JsValue::float(unsafe { (*inner).len() } as f64))
+    let inner = native_try!(get_set_inner(vm, this_val));
+    NativeResult::Ok(JsValue::float(unsafe { (*inner).len() } as f64))
 }

crates/oxide_vm/src/builtins/string.rs

@@ -31,11 +31,15 @@ fn boxed_primitive_value(this_val: JsValue) -> Option<JsValue> {
 pub fn string_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(args[0]);
     if this_val.is_string() {
-        return Ok(this_val);
+        return NativeResult::Ok(this_val);
+    }
+    match boxed_primitive_value(this_val) {
+        Some(v) => NativeResult::Ok(v),
+        None => NativeResult::Err(crate::builtins::error::create_type_error(
+            vm,
+            "String.prototype.valueOf called on non-String object",
+        )),
     }
-    boxed_primitive_value(this_val).ok_or_else(|| {
-        crate::builtins::error::create_type_error(vm, "String.prototype.valueOf called on non-String object")
-    })
 }
 
 fn make_string_array(vm: &mut Vm, parts: &[String]) -> JsValue {
@@ -58,6 +62,27 @@ fn as_string(vm: &Vm, val: JsValue) -> String {
     coercion::to_string(vm.kernel().string_forge().as_ref(), val)
 }
 
+fn char_len(s: &str) -> usize {
+    s.chars().count()
+}
+
+fn byte_index_at_char(s: &str, char_pos: usize) -> usize {
+    if char_pos == 0 {
+        return 0;
+    }
+    s.char_indices().nth(char_pos).map(|(idx, _)| idx).unwrap_or(s.len())
+}
+
+fn char_slice(s: &str, start: usize, end: usize) -> &str {
+    let start_byte = byte_index_at_char(s, start);
+    let end_byte = byte_index_at_char(s, end);
+    &s[start_byte..end_byte]
+}
+
+fn take_chars(s: &str, count: usize) -> String {
+    s.chars().take(count).collect()
+}
+
 fn is_regexp_obj(val: JsValue, vm: &Vm) -> bool {
     if !val.is_object() {
         return false;
@@ -81,52 +106,57 @@ fn is_regexp_obj(val: JsValue, vm: &Vm) -> bool {
 
 pub fn string_index_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
+    let n = char_len(&s);
     if args.len() < 2 {
-        return Ok(JsValue::int(-1));
+        return NativeResult::Ok(JsValue::int(-1));
     }
     let search = as_string(vm, vm.reg(args[1]));
     let pos = if args.len() > 2 {
-        (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(s.len())
+        (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(n)
     } else {
         0
     };
 
     if search.is_empty() {
-        return Ok(JsValue::int(pos as i32));
+        return NativeResult::Ok(JsValue::int(pos as i32));
     }
 
-    let haystack = &s.as_bytes()[pos..];
+    let start_byte = byte_index_at_char(&s, pos);
+    let haystack = &s[start_byte..];
     if search.len() == 1 {
-        if let Some(idx) = memchr(search.as_bytes()[0], haystack) {
-            return Ok(JsValue::int((pos + idx) as i32));
+        if let Some(idx) = memchr(search.as_bytes()[0], haystack.as_bytes()) {
+            let matched_byte = start_byte + idx;
+            return NativeResult::Ok(JsValue::int(char_len(&s[..matched_byte]) as i32));
         }
-    } else if let Some(idx) = s[pos..].find(&search) {
-        return Ok(JsValue::int((pos + idx) as i32));
+    } else if let Some(idx) = haystack.find(&search) {
+        let matched_byte = start_byte + idx;
+        return NativeResult::Ok(JsValue::int(char_len(&s[..matched_byte]) as i32));
     }
-    Ok(JsValue::int(-1))
+    NativeResult::Ok(JsValue::int(-1))
 }
 
 pub fn string_includes(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
+    let n = char_len(&s);
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let search = as_string(vm, vm.reg(args[1]));
     let pos = if args.len() > 2 {
-        (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(s.len())
+        (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(n)
     } else {
         0
     };
 
     if search.is_empty() {
-        return Ok(JsValue::bool(true));
+        return NativeResult::Ok(JsValue::bool(true));
     }
 
-    let haystack = &s.as_bytes()[pos..];
+    let haystack = &s[byte_index_at_char(&s, pos)..];
     if search.len() == 1 {
-        Ok(JsValue::bool(memchr(search.as_bytes()[0], haystack).is_some()))
+        NativeResult::Ok(JsValue::bool(memchr(search.as_bytes()[0], haystack.as_bytes()).is_some()))
     } else {
-        Ok(JsValue::bool(s[pos..].contains(&search)))
+        NativeResult::Ok(JsValue::bool(haystack.contains(&search)))
     }
 }
 
@@ -134,31 +164,31 @@ pub fn string_char_at(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
     if args.len() < 2 {
         if s.is_empty() {
-            return Ok(vm.intern(""));
+            return NativeResult::Ok(vm.intern(""));
         }
-        return Ok(vm.intern(&s[0..1]));
+        return NativeResult::Ok(vm.intern(&take_chars(&s, 1)));
     }
     let idx = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32;
-    if idx < 0 || idx as usize >= s.len() {
-        return Ok(vm.intern(""));
+    if idx < 0 || idx as usize >= char_len(&s) {
+        return NativeResult::Ok(vm.intern(""));
     }
-    let ch = &s[(idx as usize)..(idx as usize + 1)];
-    Ok(vm.intern(ch))
+    let ch = s.chars().nth(idx as usize).map(|c| c.to_string()).unwrap_or_default();
+    NativeResult::Ok(vm.intern(&ch))
 }
 
 pub fn string_char_code_at(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
     if args.len() < 2 {
         if s.is_empty() {
-            return Ok(JsValue::float(f64::NAN));
+            return NativeResult::Ok(JsValue::float(f64::NAN));
         }
-        return Ok(JsValue::int(s.as_bytes()[0] as i32));
+        return NativeResult::Ok(JsValue::int(s.chars().next().unwrap() as i32));
     }
     let idx = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32;
-    if idx < 0 || idx as usize >= s.len() {
-        return Ok(JsValue::float(f64::NAN));
+    if idx < 0 || idx as usize >= char_len(&s) {
+        return NativeResult::Ok(JsValue::float(f64::NAN));
     }
-    Ok(JsValue::int(s.as_bytes()[idx as usize] as i32))
+    NativeResult::Ok(JsValue::int(s.chars().nth(idx as usize).unwrap() as i32))
 }
 
 pub fn string_concat(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -167,12 +197,12 @@ pub fn string_concat(vm: &mut Vm, args: &[u8]) -> NativeResult {
     for &arg_reg in args.iter().skip(1) {
         result.push_str(&coercion::to_string(sf, vm.reg(arg_reg)));
     }
-    Ok(vm.intern(&result))
+    NativeResult::Ok(vm.intern(&result))
 }
 
 pub fn string_slice(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
-    let n = s.len() as i32;
+    let n = char_len(&s) as i32;
     let start = if args.len() > 1 {
         let v = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32;
         if v < 0 {
@@ -195,13 +225,13 @@ pub fn string_slice(vm: &mut Vm, args: &[u8]) -> NativeResult {
     };
     let start = start as usize;
     let end = end as usize;
-    let result = if start < end { &s[start..end] } else { "" };
-    Ok(vm.intern(result))
+    let result = if start < end { char_slice(&s, start, end) } else { "" };
+    NativeResult::Ok(vm.intern(result))
 }
 
 pub fn string_substring(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
-    let n = s.len() as i32;
+    let n = char_len(&s) as i32;
     let mut start = if args.len() > 1 {
         (coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32)
             .max(0)
@@ -219,23 +249,23 @@ pub fn string_substring(vm: &mut Vm, args: &[u8]) -> NativeResult {
     if start > end {
         std::mem::swap(&mut start, &mut end);
     }
-    let result = &s[start as usize..end as usize];
-    Ok(vm.intern(result))
+    let result = char_slice(&s, start as usize, end as usize);
+    NativeResult::Ok(vm.intern(result))
 }
 
 pub fn string_to_upper_case(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
-    Ok(vm.intern(&s.to_uppercase()))
+    NativeResult::Ok(vm.intern(&s.to_uppercase()))
 }
 
 pub fn string_to_lower_case(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
-    Ok(vm.intern(&s.to_lowercase()))
+    NativeResult::Ok(vm.intern(&s.to_lowercase()))
 }
 
 pub fn string_trim(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
-    Ok(vm.intern(s.trim()))
+    NativeResult::Ok(vm.intern(s.trim()))
 }
 
 pub fn string_repeat(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -245,80 +275,84 @@ pub fn string_repeat(vm: &mut Vm, args: &[u8]) -> NativeResult {
     } else {
         1
     };
-    Ok(vm.intern(&s.repeat(n)))
+    NativeResult::Ok(vm.intern(&s.repeat(n)))
 }
 
 pub fn string_pad_start(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
+    let s_len = char_len(&s);
     let target = if args.len() > 1 {
         coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize
     } else {
-        s.len()
+        s_len
     };
     let pad = if args.len() > 2 { as_string(vm, vm.reg(args[2])) } else { " ".to_string() };
-    if s.len() >= target || pad.is_empty() {
-        return Ok(vm.intern(&s));
+    if s_len >= target || pad.is_empty() {
+        return NativeResult::Ok(vm.intern(&s));
     }
-    let needed = target - s.len();
-    let reps = needed.div_ceil(pad.len());
-    let mut out = pad.repeat(reps);
-    out.truncate(needed);
+    let needed = target - s_len;
+    let pad_len = char_len(&pad).max(1);
+    let reps = needed.div_ceil(pad_len);
+    let mut out = take_chars(&pad.repeat(reps), needed);
     out.push_str(&s);
-    Ok(vm.intern(&out))
+    NativeResult::Ok(vm.intern(&out))
 }
 
 pub fn string_pad_end(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
+    let s_len = char_len(&s);
     let target = if args.len() > 1 {
         coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize
     } else {
-        s.len()
+        s_len
     };
     let pad = if args.len() > 2 { as_string(vm, vm.reg(args[2])) } else { " ".to_string() };
-    if s.len() >= target || pad.is_empty() {
-        return Ok(vm.intern(&s));
+    if s_len >= target || pad.is_empty() {
+        return NativeResult::Ok(vm.intern(&s));
     }
-    let needed = target - s.len();
-    let reps = needed.div_ceil(pad.len());
+    let needed = target - s_len;
+    let pad_len = char_len(&pad).max(1);
+    let reps = needed.div_ceil(pad_len);
     let mut out = s;
-    let pad_repeated = pad.repeat(reps);
-    out.push_str(&pad_repeated[..needed]);
-    Ok(vm.intern(&out))
+    out.push_str(&take_chars(&pad.repeat(reps), needed));
+    NativeResult::Ok(vm.intern(&out))
 }
 
 pub fn string_starts_with(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
+    let n = char_len(&s);
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let search = as_string(vm, vm.reg(args[1]));
     let pos = if args.len() > 2 {
-        (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(s.len())
+        (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(n)
     } else {
         0
     };
-    Ok(JsValue::bool(s[pos..].starts_with(&search)))
+    NativeResult::Ok(JsValue::bool(s[byte_index_at_char(&s, pos)..].starts_with(&search)))
 }
 
 pub fn string_ends_with(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
+    let n = char_len(&s);
     if args.len() < 2 {
-        return Ok(JsValue::bool(false));
+        return NativeResult::Ok(JsValue::bool(false));
     }
     let search = as_string(vm, vm.reg(args[1]));
     let end_pos = if args.len() > 2 {
-        (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(s.len())
+        (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(n)
     } else {
-        s.len()
+        n
     };
-    Ok(JsValue::bool(s[..end_pos].ends_with(&search)))
+    NativeResult::Ok(JsValue::bool(s[..byte_index_at_char(&s, end_pos)].ends_with(&search)))
 }
 
 pub fn string_split(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
     if args.len() < 2 {
         let parts = vec![s.clone()];
-        return Ok(make_string_array(vm, &parts));
+        return NativeResult::Ok(make_string_array(vm, &parts));
     }
     let sep_val = vm.reg(args[1]);
     let limit = if args.len() > 2 {
@@ -334,13 +368,14 @@ pub fn string_split(vm: &mut Vm, args: &[u8]) -> NativeResult {
             Some(p) => p,
             None => {
                 let parts = vec![s.clone()];
-                return Ok(make_string_array(vm, &parts));
+                return NativeResult::Ok(make_string_array(vm, &parts));
             }
         };
-        let regex = unsafe { &*(fn_ptr as *const regex::Regex) };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
         let raw: Vec<&str> = regex.split(&s).collect();
         let parts: Vec<String> = raw.iter().map(|p| p.to_string()).take(limit).collect();
-        return Ok(make_string_array(vm, &parts));
+        return NativeResult::Ok(make_string_array(vm, &parts));
     }
 
     let sep = as_string(vm, sep_val);
@@ -349,13 +384,13 @@ pub fn string_split(vm: &mut Vm, args: &[u8]) -> NativeResult {
     } else {
         s.split(&sep).map(|p| p.to_string()).take(limit).collect()
     };
-    Ok(make_string_array(vm, &parts))
+    NativeResult::Ok(make_string_array(vm, &parts))
 }
 
 pub fn string_replace(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
     if args.len() < 2 {
-        return Ok(vm.intern(&s));
+        return NativeResult::Ok(vm.intern(&s));
     }
     let pattern_val = vm.reg(args[1]);
     let replacement = if args.len() > 2 { as_string(vm, vm.reg(args[2])) } else { String::new() };
@@ -365,22 +400,23 @@ pub fn string_replace(vm: &mut Vm, args: &[u8]) -> NativeResult {
         let re = unsafe { &*re_ptr };
         let fn_ptr = match re.native_fn() {
             Some(p) => p,
-            None => return Ok(vm.intern(&s)),
+            None => return NativeResult::Ok(vm.intern(&s)),
         };
-        let regex = unsafe { &*(fn_ptr as *const regex::Regex) };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
         let result = regex.replace_all(&s, replacement.as_str()).to_string();
-        return Ok(vm.intern(&result));
+        return NativeResult::Ok(vm.intern(&result));
     }
 
     let pattern = as_string(vm, pattern_val);
     let result = s.replacen(&pattern, &replacement, 1);
-    Ok(vm.intern(&result))
+    NativeResult::Ok(vm.intern(&result))
 }
 
 pub fn string_match_fn(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
     if args.len() < 2 {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let pattern_val = vm.reg(args[1]);
 
@@ -389,24 +425,25 @@ pub fn string_match_fn(vm: &mut Vm, args: &[u8]) -> NativeResult {
         let re = unsafe { &*re_ptr };
         let fn_ptr = match re.native_fn() {
             Some(p) => p,
-            None => return Ok(JsValue::undefined()),
+            None => return NativeResult::Ok(JsValue::undefined()),
         };
-        let regex = unsafe { &*(fn_ptr as *const regex::Regex) };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
         let matches: Vec<String> = regex.find_iter(&s).map(|m| m.as_str().to_string()).collect();
-        return Ok(make_string_array(vm, &matches));
+        return NativeResult::Ok(make_string_array(vm, &matches));
     }
 
     let pattern = as_string(vm, pattern_val);
     if let Some(pos) = s.find(&pattern) {
-        return Ok(make_string_array(vm, &[s[pos..pos + pattern.len()].to_string()]));
+        return NativeResult::Ok(make_string_array(vm, &[s[pos..pos + pattern.len()].to_string()]));
     }
-    Ok(JsValue::undefined())
+    NativeResult::Ok(JsValue::undefined())
 }
 
 pub fn string_search(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
     if args.len() < 2 {
-        return Ok(JsValue::int(-1));
+        return NativeResult::Ok(JsValue::int(-1));
     }
     let pattern_val = vm.reg(args[1]);
 
@@ -415,30 +452,31 @@ pub fn string_search(vm: &mut Vm, args: &[u8]) -> NativeResult {
         let re = unsafe { &*re_ptr };
         let fn_ptr = match re.native_fn() {
             Some(p) => p,
-            None => return Ok(JsValue::int(-1)),
+            None => return NativeResult::Ok(JsValue::int(-1)),
         };
-        let regex = unsafe { &*(fn_ptr as *const regex::Regex) };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
         if let Some(m) = regex.find(&s) {
-            return Ok(JsValue::int(m.start() as i32));
+            return NativeResult::Ok(JsValue::int(m.start() as i32));
         }
-        return Ok(JsValue::int(-1));
+        return NativeResult::Ok(JsValue::int(-1));
     }
 
     let pattern = as_string(vm, pattern_val);
     if let Some(pos) = s.find(&pattern) {
-        return Ok(JsValue::int(pos as i32));
+        return NativeResult::Ok(JsValue::int(pos as i32));
     }
-    Ok(JsValue::int(-1))
+    NativeResult::Ok(JsValue::int(-1))
 }
 
 pub fn string_trim_start(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
-    Ok(vm.intern(s.trim_start()))
+    NativeResult::Ok(vm.intern(s.trim_start()))
 }
 
 pub fn string_trim_end(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
-    Ok(vm.intern(s.trim_end()))
+    NativeResult::Ok(vm.intern(s.trim_end()))
 }
 
 pub fn string_code_point_at(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -450,17 +488,17 @@ pub fn string_code_point_at(vm: &mut Vm, args: &[u8]) -> NativeResult {
     };
     let chars: Vec<char> = s.chars().collect();
     if pos >= chars.len() {
-        return Ok(JsValue::undefined());
+        return NativeResult::Ok(JsValue::undefined());
     }
     let c = chars[pos] as u32;
     if (0xD800..=0xDBFF).contains(&c) && pos + 1 < chars.len() {
         let next = chars[pos + 1] as u32;
         if (0xDC00..=0xDFFF).contains(&next) {
             let cp = 0x10000 + ((c - 0xD800) << 10) + (next - 0xDC00);
-            return Ok(JsValue::int(cp as i32));
+            return NativeResult::Ok(JsValue::int(cp as i32));
         }
     }
-    Ok(JsValue::int(c as i32))
+    NativeResult::Ok(JsValue::int(c as i32))
 }
 
 pub fn string_normalize(vm: &mut Vm, args: &[u8]) -> NativeResult {
@@ -473,13 +511,13 @@ pub fn string_normalize(vm: &mut Vm, args: &[u8]) -> NativeResult {
         "NFKD" => s.nfkd().collect(),
         _ => s.nfc().collect(),
     };
-    Ok(vm.intern(&result))
+    NativeResult::Ok(vm.intern(&result))
 }
 
 pub fn string_match_all(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
     if args.len() < 2 {
-        return Err(JsValue::undefined());
+        return NativeResult::Err(JsValue::undefined());
     }
     let pattern_val = vm.reg(args[1]);
     if is_regexp_obj(pattern_val, vm) {
@@ -487,19 +525,20 @@ pub fn string_match_all(vm: &mut Vm, args: &[u8]) -> NativeResult {
         let re = unsafe { &*re_ptr };
         let fn_ptr = match re.native_fn() {
             Some(p) => p,
-            None => return Ok(JsValue::undefined()),
+            None => return NativeResult::Ok(JsValue::undefined()),
         };
-        let regex = unsafe { &*(fn_ptr as *const regex::Regex) };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
         let matches: Vec<String> = regex.find_iter(&s).map(|m| m.as_str().to_string()).collect();
-        return Ok(make_string_array(vm, &matches));
+        return NativeResult::Ok(make_string_array(vm, &matches));
     }
-    Ok(JsValue::undefined())
+    NativeResult::Ok(JsValue::undefined())
 }
 
 pub fn string_replace_all(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let s = this_string(vm, args);
     if args.len() < 2 {
-        return Ok(vm.intern(&s));
+        return NativeResult::Ok(vm.intern(&s));
     }
     let pattern_val = vm.reg(args[1]);
     let replacement = if args.len() > 2 { as_string(vm, vm.reg(args[2])) } else { String::new() };
@@ -508,13 +547,14 @@ pub fn string_replace_all(vm: &mut Vm, args: &[u8]) -> NativeResult {
         let re = unsafe { &*re_ptr };
         let fn_ptr = match re.native_fn() {
             Some(p) => p,
-            None => return Ok(vm.intern(&s)),
+            None => return NativeResult::Ok(vm.intern(&s)),
         };
-        let regex = unsafe { &*(fn_ptr as *const regex::Regex) };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
         let result = regex.replace_all(&s, replacement.as_str()).to_string();
-        return Ok(vm.intern(&result));
+        return NativeResult::Ok(vm.intern(&result));
     }
     let pattern = as_string(vm, pattern_val);
     let result = s.replace(&pattern, &replacement);
-    Ok(vm.intern(&result))
+    NativeResult::Ok(vm.intern(&result))
 }

crates/oxide_vm/src/builtins/symbol.rs

@@ -17,7 +17,7 @@ pub fn symbol_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
                 if !proto_ptr.is_null() {
                     let sp = vm.kernel().builtin_world().symbol_proto.as_ptr() as *mut JsObject;
                     if std::ptr::eq(proto_ptr, sp) {
-                        return Err(JsValue::string(
+                        return NativeResult::Err(JsValue::string(
                             vm.kernel().string_forge().intern("TypeError: Symbol is not a constructor").0,
                             0,
                         ));
@@ -36,13 +36,13 @@ pub fn symbol_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     vm.symbol_counter = vm.symbol_counter.wrapping_add(1);
     let idx = vm.symbol_descriptions.len() as u32;
     vm.symbol_descriptions.push(description);
-    Ok(JsValue::symbol(idx))
+    NativeResult::Ok(JsValue::symbol(idx))
 }
 
 pub fn symbol_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(args[0]);
     if !this_val.is_symbol() {
-        return Err(JsValue::string(
+        return NativeResult::Err(JsValue::string(
             vm.kernel()
                 .string_forge()
                 .intern("TypeError: Symbol.prototype.toString requires a Symbol")
@@ -55,5 +55,5 @@ pub fn symbol_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let desc = vm.symbol_descriptions.get(idx as usize).cloned().unwrap_or_default();
     let result = format!("Symbol({})", desc);
     let si = vm.kernel().string_forge().intern(&result).0;
-    Ok(JsValue::string(si, 0))
+    NativeResult::Ok(JsValue::string(si, 0))
 }

crates/oxide_vm/src/dispatch/call.rs

@@ -1,5 +1,5 @@
-use crate::native::NativeFn;
-use crate::vm::Vm;
+use crate::native::{NativeFn, NativeResult};
+use crate::vm::{native_fn_ptr_to_fn, FrameContinuation, Vm};
 use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
@@ -25,16 +25,18 @@ impl Vm {
         let (args_buf, len) = Self::build_native_args(first_arg_reg, arg_count, this_reg);
         let args_slice = &args_buf[..len];
 
-        let func: NativeFn = unsafe { std::mem::transmute(obj.native_fn().unwrap()) };
+        // SAFETY: native_fn was set via set_native_fn with a valid NativeFn pointer;
+        // native_fn_ptr_to_fn is the single coercion point for NativeFnPtr → NativeFn.
+        let func: NativeFn = unsafe { native_fn_ptr_to_fn(obj.native_fn().unwrap()) };
         self.regs[254] = callee;
         self.native_call_depth += 1;
         match func(self, args_slice) {
-            Ok(val) => {
+            NativeResult::Ok(val) => {
                 self.native_call_depth -= 1;
                 self.regs[0] = val;
                 Ok(())
             }
-            Err(err_val) => {
+            NativeResult::Err(err_val) => {
                 self.native_call_depth -= 1;
                 let (error, kind) = if err_val.is_object() {
                     (err_val, self.thrown_error_kind(err_val))
@@ -53,6 +55,18 @@ impl Vm {
                 self.pending_error_kind = Some(kind);
                 self.unwind()
             }
+            NativeResult::TailCall { callee, this, args } => {
+                self.native_call_depth -= 1;
+                if callee.is_object() {
+                    let obj = unsafe { &*callee.as_js_object_ptr() };
+                    if obj.native_fn().is_some() {
+                        let result = self.call_function_sync(callee, this, &args)?;
+                        self.regs[0] = result;
+                        return Ok(());
+                    }
+                }
+                self.push_bytecode_frame(callee, this, &args, None, None, JsValue::undefined(), FrameContinuation::None)
+            }
         }
     }
 }

crates/oxide_vm/src/dispatch/member.rs

@@ -33,11 +33,9 @@ impl Vm {
     }
 
     fn member_target(&mut self, rd: usize, b: usize, error_msg: &str) -> Result<(*mut JsObject, u32), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error(error_msg)?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], error_msg)? else {
             return Err(String::new());
-        }
+        };
         let prop_name_si = self.property_key_si(self.regs[b]);
         Ok((obj_ptr, prop_name_si))
     }
@@ -71,11 +69,9 @@ impl Vm {
     }
 
     fn dispatch_dyn_member_inc(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error("DYN_MEMBER_INC on non-object")?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], "DYN_MEMBER_INC on non-object")? else {
             return Ok(());
-        }
+        };
         let receiver = self.regs[rd];
         let obj = unsafe { &mut *obj_ptr };
         let prop_name_si = self.property_key_si(self.regs[a]);
@@ -88,11 +84,9 @@ impl Vm {
     }
 
     fn dispatch_dyn_member_dec(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error("DYN_MEMBER_DEC on non-object")?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], "DYN_MEMBER_DEC on non-object")? else {
             return Ok(());
-        }
+        };
         let receiver = self.regs[rd];
         let obj = unsafe { &mut *obj_ptr };
         let prop_name_si = self.property_key_si(self.regs[a]);

crates/oxide_vm/src/dispatch/property.rs

@@ -1,7 +1,6 @@
 use oxide_compiler::opcode::OpCode;
 use oxide_kernel::prop_forge::PropTemplate;
 use oxide_types::object::JsObject;
-use oxide_types::value::JsValue;
 
 use crate::vm::Vm;
 
@@ -48,27 +47,35 @@ impl Vm {
             self.raise_type_error("IC_GET_PROP on non-object")?;
             return Ok(());
         }
+        let addr = obj_ptr as usize;
+        if addr < 0x10000 || addr % std::mem::align_of::<JsObject>() != 0 {
+            self.raise_type_error("IC_GET_PROP on non-object")?;
+            return Ok(());
+        }
 
         let obj = unsafe { &*obj_ptr };
         let prop_name_si = self.property_key_si(self.regs[b]);
         let ext0 = self.bytecode[self.pc];
         let ext1 = self.bytecode[self.pc + 1];
-        let ext2 = self.bytecode[self.pc + 2];
+        let _ext2 = self.bytecode[self.pc + 2];
         self.pc += 3;
         if obj.has_prop_meta() {
-            self.regs[a] = self.ordinary_get(obj, prop_name_si, val)?;
+            let val = self.ordinary_get_with_target(obj, prop_name_si, val, a as u8)?;
+            if self.accessor_frame_target_reg.take().is_none() {
+                self.regs[a] = val;
+            }
             return Ok(());
         }
         let cached_shape_id = ext0 & 0x00FF_FFFF;
-        let cached_ptr = ((ext2 as u64) << 32) | (ext1 as u64);
+        let cached_slot = ext1;
 
-        if cached_shape_id != 0 && cached_shape_id == obj.shape_id() && cached_ptr != 0 {
-            self.regs[a] = unsafe { *(cached_ptr as *const JsValue) };
+        if cached_shape_id != 0 && cached_shape_id == obj.shape_id() && cached_slot < obj.prop_vec_len() as u32 {
+            self.regs[a] = obj.get_prop_at(cached_slot);
         } else if let Some(template) = self.kernel.prop_forge().get_template(obj.shape_id()) {
             if template.prop_name == prop_name_si {
-                if let Some(ptr) = self.template_prop_ptr(obj, &template) {
-                    self.write_ic_back(obj.shape_id(), ptr);
-                    self.regs[a] = unsafe { *ptr };
+                if template.position < obj.prop_vec_len() as u32 {
+                    self.write_ic_back(obj.shape_id(), template.position);
+                    self.regs[a] = obj.get_prop_at(template.position);
                 } else {
                     self.regs[a] = self.ordinary_get(obj, prop_name_si, val)?;
                 }
@@ -78,9 +85,7 @@ impl Vm {
         } else {
             let resolved = self.ordinary_get(obj, prop_name_si, val)?;
             if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
-                if let Some(ptr) = obj.prop_ptr_at(pos) {
-                    self.write_ic_back(obj.shape_id(), ptr);
-                }
+                self.write_ic_back(obj.shape_id(), pos);
             }
             self.regs[a] = resolved;
         }
@@ -89,11 +94,9 @@ impl Vm {
     }
 
     fn dispatch_ic_set_prop(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error("IC_SET_PROP on non-object")?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], "IC_SET_PROP on non-object")? else {
             return Ok(());
-        }
+        };
 
         let prop_name_si = self.property_key_si(self.regs[b]);
         if self.kernel.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") {
@@ -111,43 +114,37 @@ impl Vm {
         let obj = unsafe { &mut *obj_ptr };
         let ext0 = self.bytecode[self.pc];
         let ext1 = self.bytecode[self.pc + 1];
-        let ext2 = self.bytecode[self.pc + 2];
+        let _ext2 = self.bytecode[self.pc + 2];
         self.pc += 3;
         let value = self.regs[a];
         let receiver = self.regs[rd];
         if obj.has_prop_meta() {
-            self.ordinary_set(obj, prop_name_si, value, receiver)?;
+            self.ordinary_set_dispatch(obj, prop_name_si, value, receiver)?;
             return Ok(());
         }
         let cached_shape_id = ext0 & 0x00FF_FFFF;
-        let cached_ptr = ((ext2 as u64) << 32) | (ext1 as u64);
+        let cached_slot = ext1;
 
-        if cached_shape_id != 0 && cached_shape_id == obj.shape_id() && cached_ptr != 0 {
-            unsafe {
-                *(cached_ptr as *mut JsValue) = value;
-            }
+        if cached_shape_id != 0 && cached_shape_id == obj.shape_id() && cached_slot < obj.prop_vec_len() as u32 {
+            obj.set_prop_at(cached_slot, value);
         } else if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
             obj.set_prop_at(pos, value);
-            if let Some(ptr) = obj.prop_ptr_at(pos) {
-                self.write_ic_back(obj.shape_id(), ptr);
-            }
+            self.write_ic_back(obj.shape_id(), pos);
         } else {
             let old_shape = obj.shape_id();
-            self.ordinary_set(obj, prop_name_si, value, receiver)?;
+            self.ordinary_set_dispatch(obj, prop_name_si, value, receiver)?;
             if old_shape != obj.shape_id() {
                 if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
-                    if let Some(ptr) = obj.prop_ptr_at(pos) {
-                        self.write_ic_back(obj.shape_id(), ptr);
-                        self.kernel.prop_forge().upsert(
-                            obj.shape_id(),
-                            PropTemplate {
-                                shape_id: obj.shape_id(),
-                                prop_name: prop_name_si,
-                                position: pos,
-                                generation: obj.generation(),
-                            },
-                        );
-                    }
+                    self.write_ic_back(obj.shape_id(), pos);
+                    self.kernel.prop_forge().upsert(
+                        obj.shape_id(),
+                        PropTemplate {
+                            shape_id: obj.shape_id(),
+                            prop_name: prop_name_si,
+                            position: pos,
+                            generation: obj.generation(),
+                        },
+                    );
                 }
             }
         }
@@ -156,23 +153,22 @@ impl Vm {
     }
 
     fn dispatch_get_prop(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error("GET_PROP on non-object")?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], "GET_PROP on non-object")? else {
             return Ok(());
-        }
+        };
         let obj = unsafe { &*obj_ptr };
         let prop_name_si = self.property_key_si(self.regs[b]);
-        self.regs[a] = self.ordinary_get(obj, prop_name_si, self.regs[rd])?;
+        let val = self.ordinary_get_with_target(obj, prop_name_si, self.regs[rd], a as u8)?;
+        if self.accessor_frame_target_reg.take().is_none() {
+            self.regs[a] = val;
+        }
         Ok(())
     }
 
     fn dispatch_set_prop(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error("SET_PROP on non-object")?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], "SET_PROP on non-object")? else {
             return Ok(());
-        }
+        };
         let obj = unsafe { &mut *obj_ptr };
         let prop_name_si = self.property_key_si(self.regs[b]);
         if self.kernel.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") {
@@ -183,28 +179,27 @@ impl Vm {
             obj.set_proto(self.regs[a]).map_err(|e| e.to_string())?;
             return Ok(());
         }
-        self.ordinary_set(obj, prop_name_si, self.regs[a], self.regs[rd])?;
+        self.ordinary_set_dispatch(obj, prop_name_si, self.regs[a], self.regs[rd])?;
         Ok(())
     }
 
     fn dispatch_get_prop_dynamic(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error("GET_PROP_DYNAMIC on non-object")?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], "GET_PROP_DYNAMIC on non-object")? else {
             return Ok(());
-        }
+        };
         let obj = unsafe { &*obj_ptr };
         let prop_name_si = self.property_key_si(self.regs[a]);
-        self.regs[b] = self.ordinary_get(obj, prop_name_si, self.regs[rd])?;
+        let val = self.ordinary_get_with_target(obj, prop_name_si, self.regs[rd], b as u8)?;
+        if self.accessor_frame_target_reg.take().is_none() {
+            self.regs[b] = val;
+        }
         Ok(())
     }
 
     fn dispatch_set_prop_dynamic(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error("SET_PROP_DYNAMIC on non-object")?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], "SET_PROP_DYNAMIC on non-object")? else {
             return Ok(());
-        }
+        };
         let obj = unsafe { &mut *obj_ptr };
         let prop_name_si = self.property_key_si(self.regs[a]);
         if self.kernel.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") {
@@ -215,16 +210,14 @@ impl Vm {
             obj.set_proto(self.regs[b]).map_err(|e| e.to_string())?;
             return Ok(());
         }
-        self.ordinary_set(obj, prop_name_si, self.regs[b], self.regs[rd])?;
+        self.ordinary_set_dispatch(obj, prop_name_si, self.regs[b], self.regs[rd])?;
         Ok(())
     }
 
     fn dispatch_set_elem(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
-        let obj_ptr = self.regs[rd].as_object_ptr() as *mut JsObject;
-        if obj_ptr.is_null() {
-            self.raise_type_error("SET_ELEM on non-object")?;
+        let Some(obj_ptr) = self.checked_object_ptr(self.regs[rd], "SET_ELEM on non-object")? else {
             return Ok(());
-        }
+        };
         let idx = self.regs[a].as_int().max(0) as u32;
         let obj = unsafe { &mut *obj_ptr };
         obj.set_prop_at(idx, self.regs[b]);

crates/oxide_vm/src/native.rs

@@ -1,5 +1,46 @@
 use oxide_types::value::JsValue;
 
-pub type NativeResult = Result<JsValue, JsValue>;
+pub enum NativeResult {
+    Ok(JsValue),
+    Err(JsValue),
+    TailCall { callee: JsValue, this: JsValue, args: Vec<JsValue> },
+}
+
+impl NativeResult {
+    pub fn ok(val: JsValue) -> Self {
+        Self::Ok(val)
+    }
+
+    pub fn err(val: JsValue) -> Self {
+        Self::Err(val)
+    }
+
+    pub fn into_result(self) -> Result<JsValue, JsValue> {
+        match self {
+            Self::Ok(val) => Ok(val),
+            Self::Err(err) => Err(err),
+            Self::TailCall { .. } => panic!("TailCall cannot be converted to Result"),
+        }
+    }
+
+    pub fn unwrap(self) -> JsValue {
+        match self {
+            Self::Ok(val) => val,
+            Self::Err(_) => panic!("called `NativeResult::unwrap()` on an `Err` value"),
+            Self::TailCall { .. } => panic!("called `NativeResult::unwrap()` on a `TailCall` value"),
+        }
+    }
+
+    pub fn map_err<E, F>(self, op: F) -> Result<JsValue, E>
+    where
+        F: FnOnce(JsValue) -> E,
+    {
+        match self {
+            Self::Ok(val) => Ok(val),
+            Self::Err(err) => Err(op(err)),
+            Self::TailCall { .. } => panic!("TailCall cannot be converted to Result"),
+        }
+    }
+}
 
 pub type NativeFn = fn(&mut crate::vm::Vm, args: &[u8]) -> NativeResult;

crates/oxide_vm/src/vm.rs

@@ -9,14 +9,23 @@ use oxide_compiler::opcode::{self, OpCode};
 use crate::bindings;
 pub use crate::bindings::init_kernel_builtins;
 use crate::coercion;
-use crate::native::NativeFn;
+use crate::native::{NativeFn, NativeResult};
 use oxide_kernel::kernel::{KernelConfig, OxideKernel};
-use oxide_kernel::prop_forge::PropTemplate;
 use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
 use oxide_types::mem::{Epoch, P};
-use oxide_types::object::{JsObject, PropAttributes};
+use oxide_types::object::{JsObject, NativeFnPtr, PropAttributes};
 use oxide_types::value::JsValue;
 
+/// Convert a `NativeFnPtr` to a callable `NativeFn`.
+///
+/// # Safety
+/// The pointer stored in `ptr` must have been created from a valid `NativeFn` fn-item.
+/// This is the single point in the codebase where `NativeFnPtr → NativeFn` coercion happens.
+#[inline(always)]
+pub(crate) unsafe fn native_fn_ptr_to_fn(ptr: NativeFnPtr) -> NativeFn {
+    std::mem::transmute::<*const (), NativeFn>(ptr.as_ptr())
+}
+
 #[allow(unused_macros)]
 macro_rules! throw_err {
     ($self:ident, $kind:ident, $msg:expr) => {{
@@ -43,6 +52,13 @@ macro_rules! compound_arith {
     }}
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum FrameContinuation {
+    None,
+    AccessorGet { target_reg: u8 },
+    AccessorSet,
+}
+
 pub struct CallFrame {
     pub return_addr: usize,
     pub function_name: u32,
@@ -54,6 +70,7 @@ pub struct CallFrame {
     pub construct_result_reg: Option<u8>,
     pub constructed_this: Option<JsValue>,
     pub is_derived_constructor: bool,
+    pub continuation: FrameContinuation,
 }
 
 pub struct ForInIter<'bump> {
@@ -73,7 +90,7 @@ pub struct Vm {
     pub(crate) bytecode: Vec<opcode::Instr>,
     pub(crate) constants: Vec<JsValue>,
     pub(crate) frames: Vec<CallFrame>,
-    pub for_in_iters: Vec<*mut u8>,
+    pub for_in_iters: Vec<*mut ForInIter<'static>>,
     pub(crate) kernel: Arc<OxideKernel>,
     pub(crate) interned_strings: Vec<u32>,
     pub epoch: Epoch,
@@ -94,9 +111,29 @@ pub struct Vm {
     pub(crate) root_reg_limit: u8,
     pub(crate) active_reg_limit: u8,
     pub(crate) native_call_depth: usize,
+    /// Set to Some(target_reg) when `ordinary_get` pushes a bytecode accessor frame.
+    /// The dispatch loop checks this flag and skips writing `regs[target_reg]` from the
+    /// call result — the value will be delivered by the RETURN handler instead.
+    pub(crate) accessor_frame_target_reg: Option<u8>,
 }
 
 impl Vm {
+    pub(crate) fn checked_object_ptr(
+        &mut self, val: JsValue, error_msg: &str,
+    ) -> Result<Option<*mut JsObject>, String> {
+        if !val.is_object() {
+            self.raise_type_error(error_msg)?;
+            return Ok(None);
+        }
+        let ptr = val.as_js_object_ptr();
+        let addr = ptr as usize;
+        if ptr.is_null() || addr < 0x10000 || addr % std::mem::align_of::<JsObject>() != 0 {
+            self.raise_type_error(error_msg)?;
+            return Ok(None);
+        }
+        Ok(Some(ptr))
+    }
+
     pub(crate) fn raise_error_kind(&mut self, kind: &'static str, msg: &str) -> Result<(), String> {
         let error = match kind {
             "TypeError" => crate::builtins::error::create_type_error(self, msg),
@@ -143,6 +180,7 @@ impl Vm {
             root_reg_limit: 0,
             active_reg_limit: 0,
             native_call_depth: 0,
+            accessor_frame_target_reg: None,
         }
     }
 
@@ -174,6 +212,7 @@ impl Vm {
             root_reg_limit: 0,
             active_reg_limit: 0,
             native_call_depth: 0,
+            accessor_frame_target_reg: None,
         }
     }
 
@@ -372,7 +411,9 @@ impl Vm {
                 self.regs[0] = JsValue::undefined();
                 self.regs[1] = pat_val;
                 self.regs[2] = flags_val;
-                let func: crate::native::NativeFn = unsafe { std::mem::transmute(native_fn) };
+                // SAFETY: regexp constructor was registered via set_native_fn with a valid NativeFn pointer;
+                // native_fn_ptr_to_fn is the single coercion point for NativeFnPtr → NativeFn.
+                let func: crate::native::NativeFn = unsafe { native_fn_ptr_to_fn(native_fn) };
                 let result = func(self, &[0, 1, 2]);
                 self.regs[0] = saved_0;
                 self.regs[1] = saved_1;
@@ -430,12 +471,6 @@ impl Vm {
         self.kernel.string_forge().intern(&key).0
     }
 
-    pub(crate) fn template_prop_ptr(&self, obj: &JsObject, template: &PropTemplate) -> Option<*const JsValue> {
-        let pos = template.position as usize;
-        obj.hash_props_vec()
-            .and_then(|vec| if pos < vec.len() { Some(&*vec[pos] as *const JsValue) } else { None })
-    }
-
     pub(crate) fn resolve_property(&self, obj: &JsObject, prop_name_si: u32) -> Option<JsValue> {
         let length_si = self.kernel.string_forge().intern("length").0;
         if obj.is_array() && prop_name_si == length_si {
@@ -507,16 +542,31 @@ impl Vm {
             for idx in 0..args.len().min(16) {
                 arg_regs[idx + 1] = 240 + idx as u8;
             }
-            let func: NativeFn = unsafe { std::mem::transmute(native_fn) };
+            // SAFETY: native_fn was set via set_native_fn with a valid NativeFn pointer;
+            // native_fn_ptr_to_fn is the single coercion point for NativeFnPtr → NativeFn.
+            let func: NativeFn = unsafe { native_fn_ptr_to_fn(native_fn) };
             self.native_call_depth += 1;
             let result = func(self, &arg_regs[..args.len().min(16) + 1]);
             self.native_call_depth -= 1;
             self.regs = saved_regs;
             self.regs[254] = saved_this;
             self.regs[253] = saved_callee;
-            return result.map_err(|err| self.error_text(err));
+            return match result {
+                NativeResult::Ok(val) => Ok(val),
+                NativeResult::Err(err) => Err(self.error_text(err)),
+                NativeResult::TailCall { callee, this, args } => self.call_function_sync(callee, this, &args),
+            };
         }
 
+        let mut sub_vm = Vm::with_kernel(Arc::clone(&self.kernel));
+        sub_vm.sub_modules = self.sub_modules.clone();
+        sub_vm.sub_module_constants = self.sub_module_constants.clone();
+        sub_vm.call_function_sync_in_sub_vm(callee, callee_obj, receiver, args)
+    }
+
+    fn call_function_sync_in_sub_vm(
+        &mut self, callee: JsValue, callee_obj: &JsObject, receiver: JsValue, args: &[JsValue],
+    ) -> Result<JsValue, String> {
         if callee_obj.sub_module_index() == 0 {
             return Err("TypeError: accessor is not callable".into());
         }
@@ -528,49 +578,17 @@ impl Vm {
                 self.sub_modules.len()
             ));
         }
-        if self.frames.len() >= self.kernel.config.max_call_depth {
-            return Err("RangeError: Maximum call stack size exceeded".into());
-        }
-
-        let saved_regs = self.regs;
-        let saved_pc = self.pc;
-        let saved_bytecode = std::mem::take(&mut self.bytecode);
-        let saved_constants = std::mem::take(&mut self.constants);
-        let saved_frames = std::mem::take(&mut self.frames);
-        let saved_bytecode_stack = std::mem::take(&mut self.saved_bytecode_stack);
-        let saved_constants_stack = std::mem::take(&mut self.saved_constants_stack);
-        let saved_active_reg_limit = self.active_reg_limit;
-        let saved_exception_value = self.exception_value.take();
-        let saved_pending_exception = self.pending_exception.take();
-        let saved_pending_error_kind = self.pending_error_kind.take();
 
         let sub = self.sub_modules[sub_idx].clone();
-        let sub_param_base = sub.param_base as usize;
-        let sub_arg_count = sub.n_args as usize;
-        for i in 0..sub_arg_count {
-            self.regs[sub_param_base + i] = args.get(i).copied().unwrap_or(JsValue::undefined());
+        self.bytecode = sub.bytecode;
+        self.constants = self.convert_constants(&sub.constants)?;
+        self.active_reg_limit = sub.n_registers.max(1);
+        self.root_reg_limit = self.active_reg_limit;
+        for i in 0..sub.n_args as usize {
+            self.regs[sub.param_base as usize + i] = args.get(i).copied().unwrap_or(JsValue::undefined());
         }
         self.regs[254] = if sub.is_arrow { callee_obj.captured_this() } else { receiver };
         self.regs[255] = JsValue::undefined();
-        self.bytecode = sub.bytecode;
-        let converted_constants = match self.convert_constants(&sub.constants) {
-            Ok(constants) => constants,
-            Err(err) => {
-                self.regs = saved_regs;
-                self.pc = saved_pc;
-                self.bytecode = saved_bytecode;
-                self.constants = saved_constants;
-                self.frames = saved_frames;
-                self.saved_bytecode_stack = saved_bytecode_stack;
-                self.saved_constants_stack = saved_constants_stack;
-                self.active_reg_limit = saved_active_reg_limit;
-                self.exception_value = saved_exception_value;
-                self.pending_exception = saved_pending_exception;
-                self.pending_error_kind = saved_pending_error_kind;
-                return Err(err);
-            }
-        };
-        self.constants = converted_constants;
         for (name, reg) in &sub.builtin_reg_map {
             let si = self.kernel.string_forge().intern(name.as_str()).0;
             let global = self.kernel.global_object();
@@ -578,28 +596,113 @@ impl Vm {
                 self.regs[*reg as usize] = global.get_prop_at(pos);
             }
         }
-        self.active_reg_limit = sub.n_registers.max(1);
+        let _ = callee;
+        self.dispatch()
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn push_bytecode_frame(
+        &mut self, callee: JsValue, this_value: JsValue, args: &[JsValue], construct_result_reg: Option<u8>,
+        constructed_this: Option<JsValue>, new_target: JsValue, continuation: FrameContinuation,
+    ) -> Result<(), String> {
+        if !callee.is_object() {
+            return Err("TypeError: CALL target is not callable".into());
+        }
+        let obj = unsafe { &*callee.as_js_object_ptr() };
+        if !obj.is_function() || obj.sub_module_index() == 0 {
+            return Err("TypeError: CALL target is not callable".into());
+        }
+        let sub_idx = obj.sub_module_index() as usize - 1;
+        if sub_idx >= self.sub_modules.len() {
+            return Err(format!(
+                "CALL: sub_module_index {} out of bounds (max {})",
+                sub_idx,
+                self.sub_modules.len()
+            ));
+        }
+        if self.frames.len() >= self.kernel.config.max_call_depth {
+            return Err("RangeError: Maximum call stack size exceeded".into());
+        }
+
+        let sub_bytecode = self.sub_modules[sub_idx].bytecode.clone();
+        let sub_n_args = self.sub_modules[sub_idx].n_args as usize;
+        let sub_n_registers = self.sub_modules[sub_idx].n_registers;
+        let sub_constants = self.sub_modules[sub_idx].constants.clone();
+        let sub_param_base = self.sub_modules[sub_idx].param_base as usize;
+        let sub_is_arrow = self.sub_modules[sub_idx].is_arrow;
+        let caller_reg_limit = self.active_reg_limit.max(1);
+        let saved_regs = self.regs[..caller_reg_limit as usize].to_vec().into_boxed_slice();
+        let saved_this = self.regs[254];
+        let saved_new_target = self.regs[255];
+
+        for i in 0..sub_n_args {
+            self.regs[sub_param_base + i] = args.get(i).copied().unwrap_or(JsValue::undefined());
+        }
+        self.regs[254] = if sub_is_arrow { obj.captured_this() } else { this_value };
+        self.regs[255] = new_target;
+
+        let converted_sub_constants = self.convert_constants(&sub_constants)?;
+        self.saved_bytecode_stack.push(std::mem::take(&mut self.bytecode));
+        self.saved_constants_stack.push(std::mem::take(&mut self.constants));
+
+        let function_name = self.sub_modules[sub_idx]
+            .function_name
+            .as_deref()
+            .map(|name| self.kernel.string_forge().intern(name).0)
+            .unwrap_or(0);
+
+        self.frames.push(CallFrame {
+            return_addr: self.pc,
+            function_name,
+            caller_reg_limit,
+            saved_regs,
+            saved_this,
+            saved_new_target,
+            callee,
+            construct_result_reg,
+            constructed_this,
+            is_derived_constructor: obj.is_derived_constructor(),
+            continuation,
+        });
+
+        self.bytecode = sub_bytecode;
+        self.constants = converted_sub_constants;
+        for (name, reg) in &self.sub_modules[sub_idx].builtin_reg_map.clone() {
+            let si = self.kernel.string_forge().intern(name.as_str()).0;
+            let global = self.kernel.global_object();
+            if let Some(pos) = self.kernel.shape_forge().lookup_position(global.shape_id(), si) {
+                self.regs[*reg as usize] = global.get_prop_at(pos);
+            }
+        }
+
+        self.active_reg_limit = sub_n_registers.max(1);
         self.pc = 0;
-
-        let result = self.dispatch();
-
-        self.regs = saved_regs;
-        self.pc = saved_pc;
-        self.bytecode = saved_bytecode;
-        self.constants = saved_constants;
-        self.frames = saved_frames;
-        self.saved_bytecode_stack = saved_bytecode_stack;
-        self.saved_constants_stack = saved_constants_stack;
-        self.active_reg_limit = saved_active_reg_limit;
-        self.exception_value = saved_exception_value;
-        self.pending_exception = saved_pending_exception;
-        self.pending_error_kind = saved_pending_error_kind;
-
-        result
+        Ok(())
     }
 
     pub(crate) fn ordinary_get(
         &mut self, obj: &JsObject, prop_name_si: u32, receiver: JsValue,
+    ) -> Result<JsValue, String> {
+        self.ordinary_get_inner(obj, prop_name_si, receiver, None)
+    }
+
+    /// `ordinary_get` with an optional dispatch-loop target register.
+    ///
+    /// When `target_reg` is `Some(r)` and the property is a bytecode accessor getter,
+    /// this method pushes a bytecode frame with `FrameContinuation::AccessorGet { target_reg: r }`
+    /// and sets `self.accessor_frame_target_reg = Some(r)`. The caller must then return
+    /// `Ok(JsValue::undefined())` — the real value will be stored by the `RETURN` handler.
+    ///
+    /// When `target_reg` is `None`, bytecode getters are executed via a sub-VM (safe for callers
+    /// outside the dispatch loop, such as tests).
+    pub(crate) fn ordinary_get_with_target(
+        &mut self, obj: &JsObject, prop_name_si: u32, receiver: JsValue, target_reg: u8,
+    ) -> Result<JsValue, String> {
+        self.ordinary_get_inner(obj, prop_name_si, receiver, Some(target_reg))
+    }
+
+    fn ordinary_get_inner(
+        &mut self, obj: &JsObject, prop_name_si: u32, receiver: JsValue, target_reg: Option<u8>,
     ) -> Result<JsValue, String> {
         let length_si = self.kernel.string_forge().intern("length").0;
         if obj.is_array() && prop_name_si == length_si {
@@ -610,6 +713,15 @@ impl Vm {
                 if meta.is_accessor {
                     return if meta.get.is_undefined() {
                         Ok(JsValue::undefined())
+                    } else if let Some(tr) = target_reg {
+                        // Dispatch loop path: push bytecode frame, return sentinel.
+                        let getter = meta.get;
+                        let pushed = self.push_bytecode_getter_frame(getter, receiver, tr)?;
+                        if pushed {
+                            return Ok(JsValue::undefined()); // RETURN handler delivers value
+                        }
+                        // Native getter — value already written to regs[tr] by push_bytecode_getter_frame
+                        Ok(self.regs[tr as usize])
                     } else {
                         self.call_function_sync(meta.get, receiver, &[])
                     };
@@ -620,11 +732,43 @@ impl Vm {
         let proto = obj.proto();
         if proto.is_object() {
             let proto_obj = unsafe { &*proto.as_js_object_ptr() };
-            return self.ordinary_get(proto_obj, prop_name_si, receiver);
+            return self.ordinary_get_inner(proto_obj, prop_name_si, receiver, target_reg);
         }
         Ok(JsValue::undefined())
     }
 
+    /// Push a bytecode frame for a getter accessor, or call native getters inline.
+    ///
+    /// Returns `true` if a bytecode frame was pushed (dispatch loop must `continue`).
+    /// Returns `false` if the getter was native (result already in `regs[target_reg]`).
+    fn push_bytecode_getter_frame(
+        &mut self, getter: JsValue, receiver: JsValue, target_reg: u8,
+    ) -> Result<bool, String> {
+        if !getter.is_object() {
+            return Err("TypeError: getter is not callable".into());
+        }
+        let getter_obj = unsafe { &*getter.as_js_object_ptr() };
+        if !getter_obj.is_function() {
+            return Err("TypeError: getter is not callable".into());
+        }
+
+        if getter_obj.native_fn().is_some() {
+            // Native getter — call inline, store result
+            let result = self.call_function_sync(getter, receiver, &[])?;
+            self.regs[target_reg as usize] = result;
+            return Ok(false);
+        }
+
+        // Bytecode getter — push frame
+        self.push_bytecode_frame(
+            getter, receiver, &[], None, None,
+            JsValue::undefined(),
+            FrameContinuation::AccessorGet { target_reg },
+        )?;
+        self.accessor_frame_target_reg = Some(target_reg);
+        Ok(true)
+    }
+
     fn inherited_property_meta(&self, obj: &JsObject, prop_name_si: u32) -> Option<oxide_types::object::PropMetaEntry> {
         let mut proto = obj.proto();
         while proto.is_object() {
@@ -639,6 +783,21 @@ impl Vm {
 
     pub(crate) fn ordinary_set(
         &mut self, obj: &mut JsObject, prop_name_si: u32, val: JsValue, receiver: JsValue,
+    ) -> Result<(), String> {
+        self.ordinary_set_inner(obj, prop_name_si, val, receiver, false)
+    }
+
+    /// `ordinary_set` variant for the dispatch loop: bytecode setters push a frame instead
+    /// of spawning a sub-VM.
+    pub(crate) fn ordinary_set_dispatch(
+        &mut self, obj: &mut JsObject, prop_name_si: u32, val: JsValue, receiver: JsValue,
+    ) -> Result<(), String> {
+        self.ordinary_set_inner(obj, prop_name_si, val, receiver, true)
+    }
+
+    fn ordinary_set_inner(
+        &mut self, obj: &mut JsObject, prop_name_si: u32, val: JsValue, receiver: JsValue,
+        use_frame_push: bool,
     ) -> Result<(), String> {
         if let Some(pos) = self.get_own_property_slot(obj, prop_name_si) {
             if let Some(meta) = obj.prop_meta_at(pos) {
@@ -646,8 +805,7 @@ impl Vm {
                     if meta.set.is_undefined() {
                         return self.raise_type_error("property has no setter");
                     }
-                    self.call_function_sync(meta.set, receiver, &[val])?;
-                    return Ok(());
+                    return self.call_or_push_setter(meta.set, receiver, val, use_frame_push);
                 }
                 if !meta.attributes.writable() {
                     return self.raise_type_error("cannot assign to read-only property");
@@ -662,8 +820,7 @@ impl Vm {
                 if meta.set.is_undefined() {
                     return self.raise_type_error("property has no setter");
                 }
-                self.call_function_sync(meta.set, receiver, &[val])?;
-                return Ok(());
+                return self.call_or_push_setter(meta.set, receiver, val, use_frame_push);
             }
             if !meta.attributes.writable() {
                 return self.raise_type_error("cannot assign to read-only property");
@@ -674,41 +831,70 @@ impl Vm {
         Ok(())
     }
 
+    /// Call a setter — either inline (for native setters or sub-VM path) or via frame push
+    /// (for bytecode setters inside the dispatch loop).
+    fn call_or_push_setter(
+        &mut self, setter: JsValue, receiver: JsValue, val: JsValue, use_frame_push: bool,
+    ) -> Result<(), String> {
+        if !use_frame_push {
+            self.call_function_sync(setter, receiver, &[val])?;
+            return Ok(());
+        }
+        if !setter.is_object() {
+            return self.raise_type_error("setter is not callable");
+        }
+        let setter_obj = unsafe { &*setter.as_js_object_ptr() };
+        if !setter_obj.is_function() {
+            return self.raise_type_error("setter is not callable");
+        }
+        if setter_obj.native_fn().is_some() {
+            // Native setter — call inline
+            self.call_function_sync(setter, receiver, &[val])?;
+            return Ok(());
+        }
+        // Bytecode setter — push frame; result is discarded via AccessorSet
+        self.push_bytecode_frame(
+            setter, receiver, &[val], None, None,
+            JsValue::undefined(),
+            FrameContinuation::AccessorSet,
+        )?;
+        Ok(())
+    }
+
     pub(crate) fn read_member_prop(
         &mut self, obj: &JsObject, prop_name_si: u32, receiver: JsValue,
     ) -> Result<JsValue, String> {
         let ext0 = self.bytecode[self.pc];
         let ext1 = self.bytecode[self.pc + 1];
-        let ext2 = self.bytecode[self.pc + 2];
+        let _ext2 = self.bytecode[self.pc + 2];
         self.pc += 3;
         if obj.has_prop_meta() {
             return self.ordinary_get(obj, prop_name_si, receiver);
         }
         let cached_shape_id = ext0 & 0x00FF_FFFF;
-        let cached_ptr = ((ext2 as u64) << 32) | (ext1 as u64);
+        let cached_slot = ext1;
 
-        let val = if cached_shape_id != 0 && cached_shape_id == obj.shape_id() && cached_ptr != 0 {
-            unsafe { *(cached_ptr as *const JsValue) }
-        } else if let Some(template) = self.kernel.prop_forge().get_template(obj.shape_id()) {
-            if template.prop_name != prop_name_si {
-                self.ordinary_get(obj, prop_name_si, receiver)?
-            } else if let Some(ptr) = self.template_prop_ptr(obj, &template) {
-                self.write_ic_back(obj.shape_id(), ptr);
-                unsafe { *ptr }
+        let val =
+            if cached_shape_id != 0 && cached_shape_id == obj.shape_id() && cached_slot < obj.prop_vec_len() as u32 {
+                obj.get_prop_at(cached_slot)
+            } else if let Some(template) = self.kernel.prop_forge().get_template(obj.shape_id()) {
+                if template.prop_name != prop_name_si {
+                    self.ordinary_get(obj, prop_name_si, receiver)?
+                } else if template.position < obj.prop_vec_len() as u32 {
+                    self.write_ic_back(obj.shape_id(), template.position);
+                    obj.get_prop_at(template.position)
+                } else {
+                    self.ordinary_get(obj, prop_name_si, receiver)?
+                }
             } else {
-                self.ordinary_get(obj, prop_name_si, receiver)?
-            }
-        } else {
-            let resolved = self.ordinary_get(obj, prop_name_si, receiver)?;
-            if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
-                if !obj.is_accessor_meta(pos) {
-                    if let Some(ptr) = obj.prop_ptr_at(pos) {
-                        self.write_ic_back(obj.shape_id(), ptr);
+                let resolved = self.ordinary_get(obj, prop_name_si, receiver)?;
+                if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
+                    if !obj.is_accessor_meta(pos) {
+                        self.write_ic_back(obj.shape_id(), pos);
                     }
                 }
-            }
-            resolved
-        };
+                resolved
+            };
         Ok(val)
     }
 
@@ -721,10 +907,8 @@ impl Vm {
                 return Ok(());
             }
             obj.set_prop_at(pos, val);
-            // IC write-back: 3 extension words (shape_id + ptr_lo + ptr_hi)
-            if let Some(ptr) = obj.prop_ptr_at(pos) {
-                self.write_ic_back(obj.shape_id(), ptr);
-            }
+            // IC write-back: 3 extension words (shape_id + slot_index + reserved)
+            self.write_ic_back(obj.shape_id(), pos);
         } else {
             self.ordinary_set(obj, prop_name_si, val, receiver)?;
         }
@@ -803,11 +987,11 @@ impl Vm {
         Ok(())
     }
 
-    pub(crate) fn write_ic_back(&mut self, shape_id: u32, ptr: *const JsValue) {
+    pub(crate) fn write_ic_back(&mut self, shape_id: u32, slot_index: u32) {
         debug_assert!(self.pc >= 3, "IC write-back requires 3 extension words before pc");
         self.bytecode[self.pc - 3] = shape_id & 0x00FF_FFFF;
-        self.bytecode[self.pc - 2] = ptr as u32;
-        self.bytecode[self.pc - 1] = (ptr as u64 >> 32) as u32;
+        self.bytecode[self.pc - 2] = slot_index;
+        self.bytecode[self.pc - 1] = 0;
     }
 
     fn restore_frame(&mut self, frame: CallFrame) {
@@ -1097,84 +1281,18 @@ impl Vm {
                                         Err(e) => return Err(e),
                                     }
                                 } else if obj.sub_module_index() > 0 {
-                                    // 1-indexed sub_module_index (0 = not a bytecode function)
-                                    let sub_idx = obj.sub_module_index() as usize - 1;
-                                    if sub_idx >= self.sub_modules.len() {
-                                        return Err(format!(
-                                            "CALL: sub_module_index {} out of bounds (max {})",
-                                            sub_idx,
-                                            self.sub_modules.len()
-                                        ));
-                                    }
-
-                                    if self.frames.len() >= self.kernel.config.max_call_depth {
-                                        return Err("RangeError: Maximum call stack size exceeded".into());
-                                    }
-
-                                    // Clone sub_module data before mutably borrowing self
-                                    let sub_bytecode = self.sub_modules[sub_idx].bytecode.clone();
-                                    let sub_n_args = self.sub_modules[sub_idx].n_args as usize;
-                                    let sub_n_registers = self.sub_modules[sub_idx].n_registers;
-                                    let sub_constants = self.sub_modules[sub_idx].constants.clone();
-                                    let sub_param_base = self.sub_modules[sub_idx].param_base as usize;
-                                    let sub_is_arrow = self.sub_modules[sub_idx].is_arrow;
-                                    let caller_reg_limit = self.active_reg_limit.max(1);
-                                    let saved_regs = self.regs[..caller_reg_limit as usize].to_vec().into_boxed_slice();
-                                    let saved_this = self.regs[254];
-                                    let saved_new_target = self.regs[255];
-
-                                    // Copy args into the callee's parameter register window.
-                                    for i in 0..sub_n_args {
-                                        let src_reg = first_arg_reg.wrapping_add(i as u8) as usize;
-                                        self.regs[sub_param_base + i] = self.regs[src_reg];
-                                    }
-                                    // Set this (reg 254 convention).
-                                    // Arrow functions use captured lexical `this` (D-01).
-                                    self.regs[254] =
-                                        if sub_is_arrow { obj.captured_this() } else { self.regs[this_reg as usize] };
-                                    self.regs[255] = JsValue::undefined();
-
-                                    let converted_sub_constants = self.convert_constants(&sub_constants)?;
-
-                                    // Save current bytecode/constants
-                                    self.saved_bytecode_stack.push(std::mem::take(&mut self.bytecode));
-                                    self.saved_constants_stack.push(std::mem::take(&mut self.constants));
-
-                                    // Push call frame
-                                    self.frames.push(CallFrame {
-                                        return_addr: self.pc,
-                                        function_name: self.sub_modules[sub_idx]
-                                            .function_name
-                                            .as_deref()
-                                            .map(|name| self.kernel.string_forge().intern(name).0)
-                                            .unwrap_or(0),
-                                        caller_reg_limit,
-                                        saved_regs,
-                                        saved_this,
-                                        saved_new_target,
+                                    let args: Vec<JsValue> = (0..arg_count)
+                                        .map(|i| self.regs[first_arg_reg.wrapping_add(i as u8) as usize])
+                                        .collect();
+                                    self.push_bytecode_frame(
                                         callee,
-                                        construct_result_reg: None,
-                                        constructed_this: None,
-                                        is_derived_constructor: false,
-                                    });
-
-                                    self.bytecode = sub_bytecode;
-                                    self.constants = converted_sub_constants;
-
-                                    // Pre-fill builtin registers from the global object
-                                    // (same as Vm::run does for the main module).
-                                    for (name, reg) in &self.sub_modules[sub_idx].builtin_reg_map {
-                                        let si = self.kernel.string_forge().intern(name.as_str()).0;
-                                        let global = self.kernel.global_object();
-                                        if let Some(pos) =
-                                            self.kernel.shape_forge().lookup_position(global.shape_id(), si)
-                                        {
-                                            self.regs[*reg as usize] = global.get_prop_at(pos);
-                                        }
-                                    }
-
-                                    self.active_reg_limit = sub_n_registers.max(1);
-                                    self.pc = 0;
+                                        self.regs[this_reg as usize],
+                                        &args,
+                                        None,
+                                        None,
+                                        JsValue::undefined(),
+                                        FrameContinuation::None,
+                                    )?;
                                     continue;
                                 }
                             }
@@ -1264,17 +1382,19 @@ impl Vm {
                         }
                         let args_slice = &args_buf[..arg_count + 1];
 
-                        let func: NativeFn = unsafe { std::mem::transmute(ctor_obj.native_fn().unwrap()) };
+                        // SAFETY: native_fn was set via set_native_fn with a valid NativeFn pointer;
+                        // native_fn_ptr_to_fn is the single coercion point for NativeFnPtr → NativeFn.
+                        let func: NativeFn = unsafe { native_fn_ptr_to_fn(ctor_obj.native_fn().unwrap()) };
                         self.regs[254] = constructor;
                         match func(self, args_slice) {
-                            Ok(val) => {
+                            NativeResult::Ok(val) => {
                                 if val.is_object() {
                                     self.regs[rd] = val;
                                 } else {
                                     self.regs[rd] = new_obj_val;
                                 }
                             }
-                            Err(err_val) => {
+                            NativeResult::Err(err_val) => {
                                 self.exception_value = Some(err_val);
                                 self.pending_error_kind = Some("Error");
                                 match self.unwind() {
@@ -1282,6 +1402,9 @@ impl Vm {
                                     Err(e) => return Err(e),
                                 }
                             }
+                            NativeResult::TailCall { .. } => {
+                                throw_err!(self, TypeError, "constructor tail call not supported");
+                            }
                         }
                     } else if ctor_obj.sub_module_index() > 0 {
                         let sub_idx = ctor_obj.sub_module_index() as usize - 1;
@@ -1339,6 +1462,7 @@ impl Vm {
                             construct_result_reg: Some(rd as u8),
                             constructed_this: Some(new_obj_val),
                             is_derived_constructor: ctor_obj.is_derived_constructor(),
+                            continuation: FrameContinuation::None,
                         });
 
                         self.bytecode = sub_bytecode;
@@ -1405,13 +1529,15 @@ impl Vm {
                     if super_obj.native_fn().is_some() {
                         self.regs[253] = derived_this;
                         let (args_buf, len) = Self::build_native_args(first_arg_reg, arg_count, 253);
-                        let func: NativeFn = unsafe { std::mem::transmute(super_obj.native_fn().unwrap()) };
+                        // SAFETY: native_fn was set via set_native_fn with a valid NativeFn pointer;
+                        // native_fn_ptr_to_fn is the single coercion point for NativeFnPtr → NativeFn.
+                        let func: NativeFn = unsafe { native_fn_ptr_to_fn(super_obj.native_fn().unwrap()) };
                         match func(self, &args_buf[..len]) {
-                            Ok(val) => {
+                            NativeResult::Ok(val) => {
                                 self.regs[254] = if val.is_object() { val } else { derived_this };
                                 self.regs[rd] = self.regs[254];
                             }
-                            Err(err_val) => {
+                            NativeResult::Err(err_val) => {
                                 self.exception_value = Some(err_val);
                                 self.pending_error_kind = Some("Error");
                                 match self.unwind() {
@@ -1419,6 +1545,9 @@ impl Vm {
                                     Err(e) => return Err(e),
                                 }
                             }
+                            NativeResult::TailCall { .. } => {
+                                throw_err!(self, TypeError, "super constructor tail call not supported");
+                            }
                         }
                     } else if super_obj.sub_module_index() > 0 {
                         let sub_idx = super_obj.sub_module_index() as usize - 1;
@@ -1468,6 +1597,7 @@ impl Vm {
                             construct_result_reg: Some(254),
                             constructed_this: Some(derived_this),
                             is_derived_constructor: super_obj.is_derived_constructor(),
+                            continuation: FrameContinuation::None,
                         });
 
                         self.bytecode = sub_bytecode;
@@ -1507,7 +1637,10 @@ impl Vm {
                         self.regs[rd] = JsValue::undefined();
                     } else {
                         let super_obj = unsafe { &*super_base.as_js_object_ptr() };
-                        self.regs[rd] = self.ordinary_get(super_obj, prop_name_si, self.regs[a])?;
+                        let val = self.ordinary_get_with_target(super_obj, prop_name_si, self.regs[a], rd as u8)?;
+                        if self.accessor_frame_target_reg.take().is_none() {
+                            self.regs[rd] = val;
+                        }
                     }
                 }
 
@@ -1561,6 +1694,7 @@ impl Vm {
                         let construct_result_reg = frame.construct_result_reg;
                         let constructed_this = frame.constructed_this;
                         let is_derived_constructor = frame.is_derived_constructor;
+                        let continuation = frame.continuation;
                         let callee_this = self.regs[254];
                         self.restore_frame(frame);
                         if let (Some(target_reg), Some(constructed_this)) = (construct_result_reg, constructed_this) {
@@ -1570,7 +1704,15 @@ impl Vm {
                             self.regs[target_reg as usize] = if result.is_object() { result } else { constructed_this };
                             self.regs[0] = self.regs[target_reg as usize];
                         } else {
-                            self.regs[0] = result;
+                            match continuation {
+                                FrameContinuation::None => {
+                                    self.regs[0] = result;
+                                }
+                                FrameContinuation::AccessorGet { target_reg } => {
+                                    self.regs[target_reg as usize] = result;
+                                }
+                                FrameContinuation::AccessorSet => {}
+                            }
                         }
                     } else {
                         return Ok(result);
@@ -1874,16 +2016,13 @@ impl Vm {
                     }
 
                     let iter = self.epoch.alloc(ForInIter { keys: keys_vec, index: 0 });
-                    self.for_in_iters.push(iter as *mut u8);
+                    // SAFETY: ForInIter is arena-allocated and valid until `epoch.reset()`;
+                    // dispatch clears `for_in_iters` before resetting the epoch.
+                    self.for_in_iters.push(iter.cast::<ForInIter<'static>>());
                 }
 
                 OpCode::FOR_IN_NEXT => {
-                    let iter_ptr = self
-                        .for_in_iters
-                        .last()
-                        .copied()
-                        .map(|p| p as *mut ForInIter)
-                        .unwrap_or(std::ptr::null_mut());
+                    let iter_ptr = self.for_in_iters.last().copied().unwrap_or(std::ptr::null_mut());
                     if iter_ptr.is_null() {
                         return Err("FOR_IN_NEXT without active iterator".into());
                     }
@@ -1897,12 +2036,7 @@ impl Vm {
                 }
 
                 OpCode::FOR_IN_DONE => {
-                    let iter_ptr = self
-                        .for_in_iters
-                        .last()
-                        .copied()
-                        .map(|p| p as *mut ForInIter)
-                        .unwrap_or(std::ptr::null_mut());
+                    let iter_ptr = self.for_in_iters.last().copied().unwrap_or(std::ptr::null_mut());
                     if iter_ptr.is_null() {
                         self.regs[rd] = JsValue::bool(true);
                     } else {
@@ -1999,40 +2133,42 @@ impl Default for Vm {
 mod tests {
     use super::{opcode, JsValue, TryHandler, Vm};
     use crate::native::NativeResult;
+    use oxide_types::object::NativeFnPtr;
     use oxide_compiler::module::{CompiledModule, Constant};
     use oxide_types::object::{JsObject, PropAttributes};
 
     fn native_return_7(_vm: &mut Vm, _args: &[u8]) -> NativeResult {
-        Ok(JsValue::int(7))
+        NativeResult::Ok(JsValue::int(7))
     }
 
     fn native_get_marker(vm: &mut Vm, args: &[u8]) -> NativeResult {
         let this_val = vm.reg(args[0]);
         if !this_val.is_object() {
-            return Ok(JsValue::undefined());
+            return NativeResult::Ok(JsValue::undefined());
         }
         let marker_si = vm.kernel.string_forge().intern("marker").0;
         let obj = unsafe { &*this_val.as_js_object_ptr() };
-        Ok(vm.resolve_property(obj, marker_si).unwrap_or(JsValue::undefined()))
+        NativeResult::Ok(vm.resolve_property(obj, marker_si).unwrap_or(JsValue::undefined()))
     }
 
     fn native_set_marker(vm: &mut Vm, args: &[u8]) -> NativeResult {
         let this_val = vm.reg(args[0]);
         let value = vm.reg(args[1]);
         if !this_val.is_object() {
-            return Ok(JsValue::undefined());
+            return NativeResult::Ok(JsValue::undefined());
         }
         let marker_si = vm.kernel.string_forge().intern("marker").0;
         let obj = unsafe { &mut *this_val.as_js_object_ptr() };
         vm.set_or_create_prop_value(obj, marker_si, value);
-        Ok(JsValue::undefined())
+        NativeResult::Ok(JsValue::undefined())
     }
 
     fn native_function(vm: &mut Vm, f: crate::native::NativeFn) -> JsValue {
         let proto = vm.kernel.builtin_world().function_proto.as_ptr() as *mut JsObject;
         let mut obj = JsObject::new_empty(oxide_kernel::shape_forge::EMPTY_SHAPE_ID, JsValue::from_js_object(proto));
         obj.set_function(true);
-        obj.set_native_fn(Some(f as *const ()));
+        // SAFETY: f is a NativeFn fn-item; valid to store as NativeFnPtr.
+        obj.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(f as *const ()) }));
         JsValue::object(vm.epoch.alloc(obj) as *mut u8)
     }
 
@@ -2074,8 +2210,9 @@ mod tests {
             construct_result_reg: None,
             constructed_this: None,
             is_derived_constructor: false,
+            continuation: super::FrameContinuation::None,
         });
-        vm.for_in_iters.push(std::ptr::dangling_mut::<u8>());
+        vm.for_in_iters.push(std::ptr::dangling_mut::<super::ForInIter<'static>>());
         vm.for_of_iters.push(std::ptr::dangling_mut::<u8>());
         vm.saved_bytecode_stack
             .push(vec![opcode::encode(opcode::OpCode::HALT, 0, 0, 0)]);
@@ -2170,12 +2307,10 @@ mod tests {
         let mut vm = Vm::new();
         vm.bytecode = vec![0, 0, 0];
         vm.pc = 3;
-        let boxed = Box::new(JsValue::int(42));
-        let ptr = &*boxed as *const JsValue;
-        vm.write_ic_back(0x1234_5678, ptr);
+        vm.write_ic_back(0x1234_5678, 7);
         assert_eq!(vm.bytecode[0], 0x0034_5678);
-        assert_eq!(vm.bytecode[1], ptr as u32);
-        assert_eq!(vm.bytecode[2], (ptr as u64 >> 32) as u32);
+        assert_eq!(vm.bytecode[1], 7);
+        assert_eq!(vm.bytecode[2], 0);
     }
 
     #[test]