stator_jse 0.2.3

//! Pre-populates the interpreter's global environment with all built-in
//! constructors, namespace objects, and global functions.
//!
//! Call [`install_globals`] when creating a fresh top-level
//! [`InterpreterFrame`][crate::interpreter::InterpreterFrame] so that
//! JavaScript code can access `Math`, `console`, `JSON`, `parseInt`, etc.
//!
//! # Example
//!
//! ```rust,ignore
//! use std::collections::HashMap;
//! use stator_jse::builtins::install_globals::install_globals;
//! use stator_jse::objects::value::JsValue;
//!
//! let mut globals = HashMap::new();
//! install_globals(&mut globals);
//! assert!(matches!(globals.get("Math"), Some(JsValue::PlainObject(_))));
//! ```

use std::cell::RefCell;
use std::collections::HashMap;
use std::fmt::Write as _;
use std::time::{SystemTime, UNIX_EPOCH};

use crate::builtins::proxy::proxy_get;
use crate::builtins::typed_array::{
    arraybuffer_byte_length, dataview_byte_length, dataview_byte_offset,
};
use std::rc::Rc;

use crate::builtins::date::{
    date_construct_components, date_construct_now, date_construct_value, date_get_date,
    date_get_day, date_get_full_year, date_get_hours, date_get_milliseconds, date_get_minutes,
    date_get_month, date_get_seconds, date_get_time, date_get_timezone_offset, date_get_utc_date,
    date_get_utc_day, date_get_utc_full_year, date_get_utc_hours, date_get_utc_milliseconds,
    date_get_utc_minutes, date_get_utc_month, date_get_utc_seconds, date_now, date_parse,
    date_set_date, date_set_full_year, date_set_hours, date_set_milliseconds, date_set_minutes,
    date_set_month, date_set_seconds, date_set_time, date_set_utc_date, date_set_utc_full_year,
    date_set_utc_hours, date_set_utc_milliseconds, date_set_utc_minutes, date_set_utc_month,
    date_set_utc_seconds, date_to_date_string, date_to_iso_string, date_to_locale_date_string,
    date_to_locale_string, date_to_locale_time_string, date_to_primitive, date_to_string,
    date_to_time_string, date_to_utc_string, date_utc, date_value_of,
};
use crate::builtins::error::{
    ErrorKind, JsError, error_capture_stack_trace, get_stack_trace_limit,
};
use crate::builtins::finalization_registry::{
    TokenKey, finalization_registry_drain, finalization_registry_new, finalization_registry_notify,
    finalization_registry_register_plain_with_token_key,
    finalization_registry_register_with_token_key, finalization_registry_sweep_plain,
    finalization_registry_unregister, finalization_registry_unregister_by_key,
    finalization_registry_unregister_plain,
};
use crate::builtins::function::{
    function_apply, function_bound_name, function_call, function_constructor,
    function_has_instance, function_length, function_to_string,
};
use crate::builtins::global::{
    GLOBAL_INFINITY, GLOBAL_NAN, global_decode_uri, global_decode_uri_component, global_encode_uri,
    global_encode_uri_component, global_escape, global_eval, global_is_finite, global_is_nan,
    global_parse_float, global_parse_int, global_unescape,
};
use crate::builtins::intl::{
    collator_compare_js, date_time_format_js, date_time_format_to_parts_js, display_names_of_typed,
    list_format_js, list_format_to_parts_js, locale_base_name, locale_language, locale_maximize,
    locale_minimize, locale_region, locale_script, number_format_js, number_format_range_js,
    number_format_range_to_parts_js, number_format_to_parts_js, plural_rules_select_js,
    plural_rules_select_range_js, relative_time_format_js, relative_time_format_to_parts_js,
    segmenter_segment_objects,
};
use crate::builtins::iterator::{
    async_iterator_drop, async_iterator_every, async_iterator_filter, async_iterator_find,
    async_iterator_flat_map, async_iterator_for_each, async_iterator_from, async_iterator_map,
    async_iterator_reduce, async_iterator_some, async_iterator_take, async_iterator_to_array,
    iterator_drop, iterator_every, iterator_filter, iterator_find, iterator_flat_map,
    iterator_for_each, iterator_from, iterator_map, iterator_next, iterator_reduce, iterator_some,
    iterator_take, iterator_to_array, iterator_to_vec,
};
use crate::builtins::map::{
    MapIteratorKind, map_clear, map_delete, map_from_iterable, map_get, map_has, map_new,
    map_next_entry, map_next_iteration_item, map_set, map_size,
};
use crate::builtins::math::{
    MATH_E, MATH_LN2, MATH_LN10, MATH_LOG2E, MATH_LOG10E, MATH_PI, MATH_SQRT1_2, MATH_SQRT2,
    math_abs, math_acos, math_acosh, math_asin, math_asinh, math_atan, math_atan2, math_atanh,
    math_cbrt, math_ceil, math_clz32, math_cos, math_cosh, math_exp, math_expm1, math_floor,
    math_fround, math_hypot, math_imul, math_log, math_log1p, math_log2, math_log10, math_max,
    math_min, math_pow, math_random, math_round, math_sign, math_sin, math_sinh, math_sqrt,
    math_tan, math_tanh, math_trunc,
};
use crate::builtins::number::{
    number_is_safe_integer, number_reformat_exponential, number_to_exponential, number_to_fixed,
    number_to_precision,
};
use crate::builtins::proxy::{
    ProxyHandler, proxy_define_property, proxy_delete_property, proxy_get_own_property_descriptor,
    proxy_get_prototype_of, proxy_get_with_receiver, proxy_has, proxy_is_extensible, proxy_new,
    proxy_new_callable, proxy_own_keys, proxy_prevent_extensions, proxy_revocable, proxy_revoke,
    proxy_set_prototype_of, proxy_set_with_receiver,
};
use crate::builtins::regexp::{regexp_construct, regexp_static_get};
use crate::builtins::set::{
    SetIteratorKind, set_add, set_clear, set_delete, set_from_iterable, set_has, set_new,
    set_next_iteration_item, set_next_value, set_size, set_values,
};
use crate::builtins::string::{
    string_anchor, string_at, string_big, string_blink, string_bold, string_char_at,
    string_char_code_at, string_code_point_at, string_concat, string_ends_with, string_fixed,
    string_fontcolor, string_fontsize, string_from_char_code, string_from_code_point,
    string_includes, string_index_of, string_is_well_formed, string_italics, string_iter,
    string_last_index_of, string_link, string_locale_compare, string_match, string_normalize,
    string_pad_end, string_pad_start, string_raw, string_repeat, string_replace,
    string_replace_all, string_search, string_slice, string_small, string_split,
    string_starts_with, string_strike, string_sub, string_substr, string_substring, string_sup,
    string_to_locale_lower_case, string_to_locale_upper_case, string_to_lower_case,
    string_to_upper_case, string_to_well_formed, string_trim, string_trim_end, string_trim_start,
    utf16_len,
};
use crate::builtins::symbol::{
    SYMBOL_ASYNC_DISPOSE, SYMBOL_ASYNC_ITERATOR, SYMBOL_DISPOSE, SYMBOL_HAS_INSTANCE,
    SYMBOL_IS_CONCAT_SPREADABLE, SYMBOL_ITERATOR, SYMBOL_MATCH, SYMBOL_MATCH_ALL, SYMBOL_REPLACE,
    SYMBOL_SEARCH, SYMBOL_SPECIES, SYMBOL_SPLIT, SYMBOL_TO_PRIMITIVE, SYMBOL_TO_STRING_TAG,
    SYMBOL_UNSCOPABLES, property_key_to_symbol, symbol_create, symbol_description, symbol_for,
    symbol_key_for,
};
use crate::builtins::typed_array::{
    JsArrayBuffer, TypedArrayKind, arraybuffer_detached, arraybuffer_max_byte_length,
    arraybuffer_new, arraybuffer_new_resizable, arraybuffer_resizable, arraybuffer_resize,
    arraybuffer_slice, arraybuffer_transfer, dataview_get_bigint64, dataview_get_biguint64,
    dataview_get_float32, dataview_get_float64, dataview_get_int8, dataview_get_int16,
    dataview_get_int32, dataview_get_uint8, dataview_get_uint16, dataview_get_uint32, dataview_new,
    dataview_set_bigint64, dataview_set_biguint64, dataview_set_float32, dataview_set_float64,
    dataview_set_int8, dataview_set_int16, dataview_set_int32, dataview_set_uint8,
    dataview_set_uint16, dataview_set_uint32, shared_arraybuffer_grow, shared_arraybuffer_growable,
    shared_arraybuffer_new, shared_arraybuffer_new_growable, typed_array_byte_length,
    typed_array_copy_within, typed_array_entries, typed_array_fill, typed_array_from_values,
    typed_array_get, typed_array_includes, typed_array_index_of, typed_array_join,
    typed_array_keys, typed_array_last_index_of, typed_array_new_from_buffer,
    typed_array_new_from_length, typed_array_reverse, typed_array_set, typed_array_set_from,
    typed_array_slice, typed_array_sort, typed_array_subarray, typed_array_values,
};
use crate::builtins::weak_ref::{
    weak_ref_deref, weak_ref_new, weak_ref_new_plain, weak_ref_new_symbol,
};
use crate::error::{StatorError, StatorResult};
use crate::interpreter::{
    current_global_env, dispatch_call_value, dispatch_call_with_this, dispatch_construct_call,
    dispatch_get_property_value, dispatch_set_property_value, function_display_name,
    function_length_value, function_to_string_value, get_object_prototype, has_prototype_in_chain,
    ordinary_set_prototype_of, plain_object_has_own_property,
};
use crate::objects::js_object::JsObject;
use crate::objects::map::PropertyAttributes;
use crate::objects::property_map::PropertyMap;
use crate::objects::value::{JsValue, NativeIterator, ToPrimitiveHint, number_to_string};
use std::collections::HashSet;

// ── Helpers ──────────────────────────────────────────────────────────────────

/// Wrap a Rust closure as a `JsValue::NativeFunction`.
fn native(f: impl Fn(Vec<JsValue>) -> StatorResult<JsValue> + 'static) -> JsValue {
    JsValue::NativeFunction(Rc::new(f))
}

/// Extract a stable identity key from a JsValue for use in weak collections.
///
/// Returns `Some(usize)` for object-like values (`Object`, `PlainObject`,
/// `Function`, `NativeFunction`) that have heap identity, and for
/// **non-registered** symbols (ES2023).  Registered symbols created via
/// `Symbol.for()` are rejected (returns `None`) because they are shared
/// across realms and thus violate weak-collection invariants.
///
/// Returns `None` for all other primitives.
fn weak_collection_key(val: &JsValue) -> Option<usize> {
    match val {
        JsValue::Object(ptr) => Some(*ptr as usize),
        JsValue::PlainObject(rc) => Some(Rc::as_ptr(rc) as usize),
        JsValue::Function(rc) => Some(Rc::as_ptr(rc) as usize),
        JsValue::NativeFunction(rc) => Some(Rc::as_ptr(rc) as *const () as usize),
        // ES2023: non-registered symbols are valid weak collection keys.
        // Registered symbols (Symbol.for) are shared/immortal — reject them.
        JsValue::Symbol(id) => {
            if symbol_key_for(*id).is_some() {
                None
            } else {
                // Tag with high bit to avoid collision with pointer addresses.
                Some((*id as usize) | (1usize << (usize::BITS - 1)))
            }
        }
        _ => None,
    }
}

fn get_hidden_method(
    receiver: &JsValue,
    marker: &str,
    method_slot: &str,
    display_name: &str,
) -> StatorResult<JsValue> {
    let JsValue::PlainObject(map) = receiver else {
        return Err(StatorError::TypeError(format!(
            "{display_name} called on incompatible receiver"
        )));
    };
    let borrow = map.borrow();
    if !matches!(borrow.get(marker), Some(JsValue::Boolean(true))) {
        return Err(StatorError::TypeError(format!(
            "{display_name} called on incompatible receiver"
        )));
    }
    borrow.get(method_slot).cloned().ok_or_else(|| {
        StatorError::TypeError(format!("{display_name} called on incompatible receiver"))
    })
}

/// Wire up the spec-mandated `.name` and `.prototype.constructor` properties
/// on a built-in constructor `PlainObject`.
///
/// Per ES §20.2.3.1 and §20.2.3.2:
/// - `Ctor.name` = *name* (configurable, non-writable, non-enumerable)
/// - `Ctor.prototype.constructor` = *Ctor* (writable, configurable, non-enumerable)
fn finalize_ctor(ctor: JsValue, name: &str) -> JsValue {
    if let JsValue::PlainObject(ref rc) = ctor {
        // .name — §20.2.3.1 (configurable only)
        rc.borrow_mut().insert_with_attrs(
            "name".into(),
            JsValue::String(name.into()),
            PropertyAttributes::CONFIGURABLE,
        );
        // .prototype.constructor — §20.2.3.2 (writable | configurable)
        let proto = rc.borrow().get("prototype").cloned();
        if let Some(JsValue::PlainObject(proto_rc)) = proto {
            proto_rc.borrow_mut().insert_with_attrs(
                "constructor".into(),
                ctor.clone(),
                PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
            );
        }
    }
    ctor
}

/// Create a built-in function object with `.name` and `.length` properties.
///
/// Per the ES spec, every built-in function should expose a non-enumerable,
/// configurable `.name` (string) and `.length` (expected argument count).
/// The returned `PlainObject` carries a `__call__` slot so the dispatch
/// layer invokes the closure, plus the two metadata properties.
fn builtin_fn(
    name: &str,
    length: i32,
    f: impl Fn(Vec<JsValue>) -> StatorResult<JsValue> + 'static,
) -> JsValue {
    let mut props = PropertyMap::new();
    let attrs = PropertyAttributes::CONFIGURABLE;
    props.insert_with_attrs("name".into(), JsValue::String(name.into()), attrs);
    props.insert_with_attrs("length".into(), JsValue::Smi(length), attrs);
    props.insert("__call__".into(), JsValue::NativeFunction(Rc::new(f)));
    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

fn materialize_array_holes(items: &[JsValue]) -> Vec<JsValue> {
    items
        .iter()
        .cloned()
        .map(|value| {
            if value.is_the_hole() {
                JsValue::Undefined
            } else {
                value
            }
        })
        .collect()
}

/// Extract elements from an array-like value, preserving holes as `undefined`.
fn try_to_array_like_elements(val: &JsValue) -> StatorResult<(Vec<JsValue>, usize)> {
    let len = array_like_length(val)?;
    let mut elements = Vec::with_capacity(len);
    for i in 0..len {
        elements.push(array_like_get_index(val, i));
    }
    Ok((elements, len))
}

/// Non-throwing wrapper around [`try_to_array_like_elements`].
fn to_array_like_elements(val: &JsValue) -> (Vec<JsValue>, usize) {
    try_to_array_like_elements(val).unwrap_or_default()
}

#[inline]
fn parse_integer_index_key(key: &str) -> Option<u32> {
    if key.is_empty() || (key.len() > 1 && key.as_bytes()[0] == b'0') {
        return None;
    }
    let n: u32 = key.parse().ok()?;
    if n < u32::MAX { Some(n) } else { None }
}

fn visible_string_property_name(raw_key: &str) -> Option<String> {
    let visible = if let Some(prop) = raw_key
        .strip_prefix("__get_")
        .and_then(|s| s.strip_suffix("__"))
    {
        prop
    } else if let Some(prop) = raw_key
        .strip_prefix("__set_")
        .and_then(|s| s.strip_suffix("__"))
    {
        prop
    } else {
        if raw_key.starts_with("__") || raw_key.starts_with('#') {
            return None;
        }
        raw_key
    };

    if property_key_to_symbol(visible).is_some() {
        return None;
    }

    Some(visible.to_string())
}

#[allow(dead_code)]
fn utf16_code_unit_len(s: &str) -> usize {
    s.encode_utf16().count()
}

fn own_string_property_keys(map: &PropertyMap, enumerable_only: bool) -> Vec<String> {
    let mut ordered = Vec::new();
    let mut seen = HashSet::new();

    for raw_key in map.keys() {
        if enumerable_only && !map.is_enumerable(raw_key) {
            continue;
        }

        if let Some(visible) = visible_string_property_name(raw_key)
            && seen.insert(visible.clone())
        {
            ordered.push(visible);
        }
    }

    let mut integer_keys = Vec::new();
    let mut string_keys = Vec::new();
    for key in ordered {
        if let Some(index) = parse_integer_index_key(&key) {
            integer_keys.push((index, key));
        } else {
            string_keys.push(key);
        }
    }
    integer_keys.sort_by_key(|(index, _)| *index);

    integer_keys
        .into_iter()
        .map(|(_, key)| key)
        .chain(string_keys)
        .collect()
}

fn enumerable_own_string_keys(value: &JsValue) -> Vec<String> {
    match value {
        JsValue::PlainObject(map) => own_string_property_keys(&map.borrow(), true),
        JsValue::Error(error) => own_string_property_keys(&error.props.borrow(), true),
        JsValue::Array(items) => items
            .borrow()
            .iter()
            .enumerate()
            .filter_map(|(index, value)| (!value.is_the_hole()).then_some(index.to_string()))
            .collect(),
        JsValue::String(s) => (0..utf16_len(s)).map(|i| i.to_string()).collect(),
        _ => Vec::new(),
    }
}

fn error_own_string_keys(error: &JsError) -> Vec<String> {
    let overlay = error.props.borrow();
    let mut keys = Vec::new();
    let mut seen = HashSet::new();
    for builtin in ["message", "stack"] {
        if seen.insert(builtin.to_string()) {
            keys.push(builtin.to_string());
        }
    }
    if error.cause.is_some() && seen.insert("cause".to_string()) {
        keys.push("cause".to_string());
    }
    if error.kind == ErrorKind::AggregateError && seen.insert("errors".to_string()) {
        keys.push("errors".to_string());
    }
    for key in own_string_property_keys(&overlay, false) {
        if seen.insert(key.clone()) {
            keys.push(key);
        }
    }
    keys
}

fn error_descriptor_value_and_attrs(
    error: &JsError,
    key: &str,
) -> Option<(JsValue, PropertyAttributes)> {
    let overlay = error.props.borrow();
    if let Some(value) = overlay.get(key) {
        let mut attrs = PropertyAttributes::empty();
        if overlay.is_writable(key) {
            attrs |= PropertyAttributes::WRITABLE;
        }
        if overlay.is_enumerable(key) {
            attrs |= PropertyAttributes::ENUMERABLE;
        }
        if overlay.is_configurable(key) {
            attrs |= PropertyAttributes::CONFIGURABLE;
        }
        return Some((value.clone(), attrs));
    }
    let attrs = PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE;
    match key {
        "message" => Some((JsValue::String(error.message().to_string().into()), attrs)),
        "stack" => Some((JsValue::String(error.stack().to_string().into()), attrs)),
        "cause" => error.cause().cloned().map(|cause| (cause, attrs)),
        "errors" if error.kind == ErrorKind::AggregateError => {
            Some((JsValue::new_array(error.errors.clone()), attrs))
        }
        _ => None,
    }
}

fn constructor_prototype(name: &str) -> Option<JsValue> {
    current_global_env().and_then(|globals| {
        let ctor = globals.borrow().get(name).cloned()?;
        match ctor {
            JsValue::PlainObject(map) => map.borrow().get("prototype").cloned(),
            _ => None,
        }
    })
}

fn get_prototype_of_value(value: &JsValue) -> Option<JsValue> {
    match value {
        JsValue::PlainObject(_) | JsValue::Error(_) => get_object_prototype(value),
        JsValue::Array(_) => constructor_prototype("Array"),
        JsValue::Function(_) | JsValue::NativeFunction(_) => constructor_prototype("Function"),
        JsValue::Boolean(_) => constructor_prototype("Boolean"),
        JsValue::Smi(_) | JsValue::HeapNumber(_) => constructor_prototype("Number"),
        JsValue::String(_) => constructor_prototype("String"),
        JsValue::Symbol(_) => constructor_prototype("Symbol"),
        JsValue::BigInt(_) => constructor_prototype("BigInt"),
        _ => None,
    }
}

/// Extract raw template segments for `String.raw`.
fn string_raw_segments(raw: &JsValue) -> StatorResult<Vec<String>> {
    match raw {
        JsValue::Undefined | JsValue::Null => Err(StatorError::TypeError(
            "String.raw requires a template object with a raw property".into(),
        )),
        JsValue::String(s) => Ok(crate::builtins::string::encode_utf16(s)
            .into_iter()
            .map(|unit| crate::builtins::string::decode_utf16(&[unit]))
            .collect()),
        JsValue::Array(items) => Ok(items
            .borrow()
            .iter()
            .map(JsValue::to_js_string)
            .collect::<StatorResult<Vec<_>>>()?),
        JsValue::PlainObject(map) => {
            let borrow = map.borrow();
            let len = borrow
                .get("length")
                .map(JsValue::to_length)
                .transpose()?
                .unwrap_or(0)
                .min(usize::MAX as u64) as usize;
            let values: Vec<JsValue> = (0..len)
                .map(|i| {
                    borrow
                        .get(&i.to_string())
                        .cloned()
                        .unwrap_or(JsValue::Undefined)
                })
                .collect();
            drop(borrow);
            values
                .iter()
                .map(JsValue::to_js_string)
                .collect::<StatorResult<Vec<_>>>()
        }
        _ => Ok(Vec::new()),
    }
}

/// Return the spec-visible `length` of an array-like value.
fn array_like_length(val: &JsValue) -> StatorResult<usize> {
    match val {
        JsValue::Array(items) => Ok(items.borrow().len()),
        JsValue::PlainObject(map) => {
            let borrow = map.borrow();
            let len = borrow
                .get("length")
                .map(JsValue::to_length)
                .transpose()?
                .unwrap_or(0);
            Ok(len.min(usize::MAX as u64) as usize)
        }
        JsValue::Proxy(proxy) => {
            let len = proxy_get(&proxy.borrow(), "length")?
                .to_length()?
                .min(usize::MAX as u64);
            Ok(len as usize)
        }
        _ => Ok(0),
    }
}

/// Return whether an array-like value has an own indexed property at `index`.
fn array_like_has_index(val: &JsValue, index: usize) -> bool {
    match val {
        JsValue::Array(items) => {
            let borrow = items.borrow();
            index < borrow.len() && !borrow[index].is_the_hole()
        }
        JsValue::PlainObject(map) => map.borrow().contains_key(&index.to_string()),
        JsValue::Proxy(proxy) => proxy_has(&proxy.borrow(), &index.to_string()).unwrap_or(false),
        _ => false,
    }
}

/// Read an indexed property from an array-like value.
fn array_like_get_index(val: &JsValue, index: usize) -> JsValue {
    match val {
        JsValue::Array(items) => match items.borrow().get(index).cloned() {
            Some(value) if !value.is_the_hole() => value,
            _ => JsValue::Undefined,
        },
        JsValue::PlainObject(map) => map
            .borrow()
            .get(&index.to_string())
            .cloned()
            .unwrap_or(JsValue::Undefined),
        JsValue::Proxy(proxy) => {
            proxy_get(&proxy.borrow(), &index.to_string()).unwrap_or(JsValue::Undefined)
        }
        _ => JsValue::Undefined,
    }
}

/// Write an indexed property to an array-like value.
fn array_like_set_index(val: &JsValue, index: usize, value: JsValue) {
    match val {
        JsValue::Array(items) => {
            let mut borrow = items.borrow_mut();
            if index >= borrow.len() {
                borrow.resize(index + 1, JsValue::TheHole);
            }
            borrow[index] = value;
        }
        JsValue::PlainObject(map) => {
            let mut borrow = map.borrow_mut();
            borrow.insert(index.to_string(), value);
            let new_len = index + 1;
            let current_len = borrow
                .get("length")
                .and_then(|v| v.to_length().ok())
                .unwrap_or(0)
                .min(usize::MAX as u64) as usize;
            if new_len > current_len {
                borrow.insert("length".to_string(), JsValue::Smi(new_len as i32));
            }
        }
        JsValue::Proxy(proxy) => {
            let receiver = val.clone();
            let _ = proxy_set_with_receiver(
                &mut proxy.borrow_mut(),
                &index.to_string(),
                value,
                &receiver,
            );
        }
        _ => {}
    }
}

/// Delete an indexed property from an array-like value.
fn array_like_delete_index(val: &JsValue, index: usize) {
    match val {
        JsValue::Array(items) => {
            let mut borrow = items.borrow_mut();
            if index < borrow.len() {
                borrow[index] = JsValue::TheHole;
            }
        }
        JsValue::PlainObject(map) => {
            map.borrow_mut().remove(&index.to_string());
        }
        JsValue::Proxy(proxy) => {
            let _ = proxy_delete_property(&mut proxy.borrow_mut(), &index.to_string());
        }
        _ => {}
    }
}

/// Set the `length` of an array-like value, truncating indexed properties when
/// the new length is smaller.
fn array_like_set_length(val: &JsValue, new_len: usize) {
    match val {
        JsValue::Array(items) => {
            let mut borrow = items.borrow_mut();
            if new_len < borrow.len() {
                borrow.truncate(new_len);
            } else {
                borrow.resize(new_len, JsValue::TheHole);
            }
        }
        JsValue::PlainObject(map) => {
            let mut borrow = map.borrow_mut();
            let current_len = borrow
                .get("length")
                .and_then(|v| v.to_length().ok())
                .unwrap_or(0)
                .min(usize::MAX as u64) as usize;
            if new_len < current_len {
                for index in new_len..current_len {
                    borrow.remove(&index.to_string());
                }
            }
            borrow.insert("length".to_string(), JsValue::Smi(new_len as i32));
        }
        JsValue::Proxy(proxy) => {
            let receiver = val.clone();
            let _ = proxy_set_with_receiver(
                &mut proxy.borrow_mut(),
                "length",
                JsValue::Smi(new_len as i32),
                &receiver,
            );
        }
        _ => {}
    }
}

/// Apply a hole-aware indexed layout back onto an array-like value.
fn apply_array_like_slots(target: &JsValue, slots: &[Option<JsValue>]) {
    array_like_set_length(target, slots.len());
    for (index, slot) in slots.iter().enumerate() {
        match slot {
            Some(value) => array_like_set_index(target, index, value.clone()),
            None => array_like_delete_index(target, index),
        }
    }
}

/// Check whether a value is a JavaScript array — either a native
/// `JsValue::Array` or a `PlainObject` carrying the `__is_array__` marker.
fn is_js_array(val: &JsValue) -> StatorResult<bool> {
    match val {
        JsValue::Array(_) => Ok(true),
        JsValue::PlainObject(map) => Ok(map
            .borrow()
            .get("__is_array__")
            .is_some_and(|v| matches!(v, JsValue::Boolean(true)))),
        JsValue::Proxy(proxy) => {
            // §7.2.2 IsArray step 3: if proxy is revoked, throw TypeError.
            let borrowed = proxy.borrow();
            if borrowed.is_revoked() {
                return Err(StatorError::TypeError(
                    "Cannot perform 'IsArray' on a proxy that has been revoked".to_string(),
                ));
            }
            if let Some(tv) = &borrowed.target_value {
                return is_js_array(tv);
            }
            // Fallback: check __is_array__ marker on the internal target.
            Ok(borrowed
                .target
                .get_own_property_descriptor("__is_array__")
                .is_some_and(|(value, _)| matches!(value, JsValue::Boolean(true))))
        }
        _ => Ok(false),
    }
}

/// Invoke a JS callback (NativeFunction, bytecode Function, or PlainObject
/// with `__call__`) with the given arguments.  This is the bridge between
/// native built-in implementations and user-defined JS callbacks.
fn call_callback(cb: &JsValue, args: Vec<JsValue>) -> StatorResult<JsValue> {
    dispatch_call_value(cb, args)
}

/// Invoke a callback with an explicit `this` binding.
fn call_callback_with_this(
    cb: &JsValue,
    this_arg: JsValue,
    args: Vec<JsValue>,
) -> StatorResult<JsValue> {
    dispatch_call_with_this(cb, this_arg, args)
}

fn flatten_array_like_into(
    source: &JsValue,
    depth: usize,
    out: &mut Vec<JsValue>,
) -> StatorResult<()> {
    let len = array_like_length(source)?;
    for index in 0..len {
        if !array_like_has_index(source, index) {
            continue;
        }
        let item = array_like_get_index(source, index);
        if depth > 0 && is_js_array(&item)? {
            flatten_array_like_into(&item, depth - 1, out)?;
        } else {
            out.push(item);
        }
    }
    Ok(())
}

/// ECMAScript §7.2.1 RequireObjectCoercible — throws TypeError for null/undefined.
fn require_object_coercible(val: &JsValue) -> StatorResult<()> {
    match val {
        JsValue::Undefined => Err(StatorError::TypeError(
            "Cannot convert undefined or null to object".to_string(),
        )),
        JsValue::Null => Err(StatorError::TypeError(
            "Cannot convert undefined or null to object".to_string(),
        )),
        _ => Ok(()),
    }
}

/// ES §22.1.3 step 1: RequireObjectCoercible then ToString for String.prototype methods.
///
/// This ensures `String.prototype.foo.call(null)` and
/// `String.prototype.foo.call(undefined)` throw TypeError as required by spec.
fn require_coercible_string(args: &[JsValue]) -> StatorResult<String> {
    let this_val = args.first().unwrap_or(&JsValue::Undefined);
    require_object_coercible(this_val)?;
    this_val.to_js_string()
}

/// Returns `true` when `val` is callable (Function, NativeFunction, or PlainObject
/// with a `__call__` slot).
fn is_callable(val: &JsValue) -> bool {
    match val {
        JsValue::Function(_) | JsValue::NativeFunction(_) => true,
        JsValue::PlainObject(map) => map.borrow().contains_key("__call__"),
        JsValue::Proxy(proxy) => proxy.borrow().is_callable(),
        _ => false,
    }
}

fn attach_constructor_prototype(obj: &JsValue, ctor_name: &str) -> StatorResult<()> {
    if let Some(proto) = constructor_prototype(ctor_name) {
        ordinary_set_prototype_of(obj, proto)?;
    }
    Ok(())
}

fn iterator_method(value: &JsValue) -> StatorResult<JsValue> {
    let method = dispatch_get_property_value(value, JsValue::Symbol(SYMBOL_ITERATOR))?;
    if is_callable(&method) {
        Ok(method)
    } else {
        Err(StatorError::TypeError("value is not iterable".into()))
    }
}

fn iterable_to_items(value: &JsValue) -> StatorResult<Vec<JsValue>> {
    let method = iterator_method(value)?;
    let iterator = dispatch_call_with_this(&method, value.clone(), vec![])?;
    let mut items = Vec::new();
    loop {
        let step = iterator_next(&iterator)?;
        if step.done {
            break;
        }
        items.push(step.value);
    }
    Ok(items)
}

fn iterable_to_map_pairs(value: &JsValue) -> StatorResult<Vec<(JsValue, JsValue)>> {
    iterable_to_items(value)?
        .into_iter()
        .map(|item| {
            if !item.is_object_like() {
                return Err(StatorError::TypeError(
                    "Map iterable value is not an object".into(),
                ));
            }
            let key = dispatch_get_property_value(&item, JsValue::Smi(0))?;
            let value = dispatch_get_property_value(&item, JsValue::Smi(1))?;
            Ok((key, value))
        })
        .collect()
}

fn make_self_iterating_object(next_fn: JsValue) -> JsValue {
    let obj_rc = Rc::new(RefCell::new(PropertyMap::new()));
    let iterator = JsValue::PlainObject(Rc::clone(&obj_rc));
    {
        let mut obj = obj_rc.borrow_mut();
        obj.insert("next".into(), next_fn);
        let iterator_value = iterator.clone();
        obj.insert(
            "@@iterator".into(),
            native(move |_| Ok(iterator_value.clone())),
        );
        obj.make_all_non_enumerable();
    }
    iterator
}

fn build_map_iterator_object(
    inner: Rc<RefCell<crate::builtins::map::JsMap>>,
    kind: MapIteratorKind,
) -> JsValue {
    let cursor = Rc::new(RefCell::new(0usize));
    make_self_iterating_object(native(move |_| {
        let mut cursor = cursor.borrow_mut();
        let next = {
            let map = inner.borrow();
            map_next_iteration_item(&map, &mut cursor, kind)
        };
        Ok(match next {
            Some(value) => crate::interpreter::make_iterator_result(value, false),
            None => crate::interpreter::make_iterator_result(JsValue::Undefined, true),
        })
    }))
}

fn build_set_iterator_object(
    inner: Rc<RefCell<crate::builtins::set::JsSet>>,
    kind: SetIteratorKind,
) -> JsValue {
    let cursor = Rc::new(RefCell::new(0usize));
    make_self_iterating_object(native(move |_| {
        let mut cursor = cursor.borrow_mut();
        let next = {
            let set = inner.borrow();
            set_next_iteration_item(&set, &mut cursor, kind)
        };
        Ok(match next {
            Some(value) => crate::interpreter::make_iterator_result(value, false),
            None => crate::interpreter::make_iterator_result(JsValue::Undefined, true),
        })
    }))
}

fn is_internal_accessor_key(key: &str) -> bool {
    (key.starts_with("__get_") || key.starts_with("__set_")) && key.ends_with("__")
}

fn accessor_property_name(key: &str) -> Option<&str> {
    if let Some(rest) = key
        .strip_prefix("__get_")
        .or_else(|| key.strip_prefix("__set_"))
    {
        rest.strip_suffix("__")
    } else {
        None
    }
}

fn value_to_reflect_args_list(value: Option<&JsValue>) -> StatorResult<Vec<JsValue>> {
    match value.unwrap_or(&JsValue::Undefined) {
        JsValue::Undefined | JsValue::Null => Ok(vec![]),
        JsValue::Array(arr) => Ok(arr.borrow().clone()),
        JsValue::PlainObject(map) => {
            let borrow = map.borrow();
            let len = borrow.get("length").map_or(Ok(0usize), |v| {
                Ok(crate::builtins::util::clamped_f64_to_usize(v.to_number()?))
            })?;
            Ok((0..len)
                .map(|index| {
                    borrow
                        .get(&index.to_string())
                        .cloned()
                        .unwrap_or(JsValue::Undefined)
                })
                .collect())
        }
        _ => Err(StatorError::TypeError(
            "Reflect argumentsList must be an object".to_string(),
        )),
    }
}

fn define_plain_own_property(
    map: &Rc<RefCell<PropertyMap>>,
    key: &str,
    desc: &PropertyMap,
) -> StatorResult<()> {
    let has_get = desc.contains_key("get");
    let has_set = desc.contains_key("set");
    let has_value = desc.contains_key("value");
    let has_writable = desc.contains_key("writable");

    if (has_get || has_set) && (has_value || has_writable) {
        return Err(crate::error::StatorError::TypeError(
            "Invalid property descriptor. Cannot both specify accessors and a value or writable attribute"
                .into(),
        ));
    }

    {
        let borrow = map.borrow();
        let getter_key = format!("__get_{key}__");
        let setter_key = format!("__set_{key}__");
        let is_existing_accessor =
            borrow.contains_key(&getter_key) || borrow.contains_key(&setter_key);
        let property_exists = borrow.contains_key(key) || is_existing_accessor;

        if property_exists {
            let currently_configurable = if borrow.contains_key(key) {
                borrow.is_configurable(key)
            } else if borrow.contains_key(&getter_key) {
                borrow.is_configurable(&getter_key)
            } else {
                borrow.is_configurable(&setter_key)
            };

            if !currently_configurable {
                if (has_get || has_set) && !is_existing_accessor {
                    return Err(crate::error::StatorError::TypeError(format!(
                        "Cannot redefine property: {key}"
                    )));
                }
                if !has_get
                    && !has_set
                    && is_existing_accessor
                    && (desc.contains_key("value") || desc.contains_key("writable"))
                {
                    return Err(crate::error::StatorError::TypeError(format!(
                        "Cannot redefine property: {key}"
                    )));
                }
                if !is_existing_accessor
                    && !borrow.is_writable(key)
                    && desc.get("writable").is_some_and(|v| v.to_boolean())
                {
                    return Err(crate::error::StatorError::TypeError(format!(
                        "Cannot redefine property: {key}"
                    )));
                }
                if !is_existing_accessor
                    && !borrow.is_writable(key)
                    && desc
                        .get("value")
                        .and_then(|new_val| {
                            borrow.get(key).map(|old_val| !new_val.same_value(old_val))
                        })
                        .unwrap_or(false)
                {
                    return Err(crate::error::StatorError::TypeError(format!(
                        "Cannot redefine property: {key}"
                    )));
                }
                if desc.contains_key("enumerable") {
                    let new_e = desc.get("enumerable").is_some_and(|v| v.to_boolean());
                    let current_e = if borrow.contains_key(key) {
                        borrow.is_enumerable(key)
                    } else if borrow.contains_key(&getter_key) {
                        borrow.is_enumerable(&getter_key)
                    } else {
                        borrow.is_enumerable(&setter_key)
                    };
                    if new_e != current_e {
                        return Err(crate::error::StatorError::TypeError(format!(
                            "Cannot redefine property: {key}"
                        )));
                    }
                }
                if desc.get("configurable").is_some_and(|v| v.to_boolean()) {
                    return Err(crate::error::StatorError::TypeError(format!(
                        "Cannot redefine property: {key}"
                    )));
                }
                if is_existing_accessor && (has_get || has_set) {
                    if has_get {
                        let new_get = desc.get("get").cloned().unwrap_or(JsValue::Undefined);
                        let cur_get = borrow
                            .get(&getter_key)
                            .cloned()
                            .unwrap_or(JsValue::Undefined);
                        if !new_get.same_value(&cur_get) {
                            return Err(crate::error::StatorError::TypeError(format!(
                                "Cannot redefine property: {key}"
                            )));
                        }
                    }
                    if has_set {
                        let new_set = desc.get("set").cloned().unwrap_or(JsValue::Undefined);
                        let cur_set = borrow
                            .get(&setter_key)
                            .cloned()
                            .unwrap_or(JsValue::Undefined);
                        if !new_set.same_value(&cur_set) {
                            return Err(crate::error::StatorError::TypeError(format!(
                                "Cannot redefine property: {key}"
                            )));
                        }
                    }
                }
            }
        }
    }

    if has_get || has_set {
        {
            let borrow = map.borrow();
            let getter_key = format!("__get_{key}__");
            let setter_key = format!("__set_{key}__");
            if !borrow.extensible
                && !borrow.contains_key(key)
                && !borrow.contains_key(&getter_key)
                && !borrow.contains_key(&setter_key)
            {
                return Err(crate::error::StatorError::TypeError(format!(
                    "Cannot define property {key}, object is not extensible"
                )));
            }
        }
        let getter_key = format!("__get_{key}__");
        let setter_key = format!("__set_{key}__");
        let enumerable = desc.get("enumerable").is_some_and(|v| v.to_boolean());
        let configurable = desc.get("configurable").is_some_and(|v| v.to_boolean());
        let mut accessor_attrs = PropertyAttributes::empty();
        if enumerable {
            accessor_attrs |= PropertyAttributes::ENUMERABLE;
        }
        if configurable {
            accessor_attrs |= PropertyAttributes::CONFIGURABLE;
        }
        if let Some(getter) = desc.get("get").cloned() {
            map.borrow_mut()
                .insert_with_attrs(getter_key, getter, accessor_attrs);
        }
        if let Some(setter) = desc.get("set").cloned() {
            map.borrow_mut()
                .insert_with_attrs(setter_key, setter, accessor_attrs);
        }
        map.borrow_mut().remove(key);
    } else {
        let writable_val = desc.get("writable").map(|v| v.to_boolean());
        let enumerable_val = desc.get("enumerable").map(|v| v.to_boolean());
        let configurable_val = desc.get("configurable").map(|v| v.to_boolean());

        if !map.borrow().contains_key(key) {
            let getter_key = format!("__get_{key}__");
            let setter_key = format!("__set_{key}__");
            let is_existing_accessor = {
                let borrow = map.borrow();
                borrow.contains_key(&getter_key) || borrow.contains_key(&setter_key)
            };
            if !map.borrow().extensible && !is_existing_accessor {
                return Err(crate::error::StatorError::TypeError(format!(
                    "Cannot define property {key}, object is not extensible"
                )));
            }
            let value = if has_value {
                desc.get("value").cloned().unwrap_or(JsValue::Undefined)
            } else {
                JsValue::Undefined
            };
            map.borrow_mut().remove(&getter_key);
            map.borrow_mut().remove(&setter_key);
            let mut attrs = PropertyAttributes::empty();
            if writable_val.unwrap_or(false) {
                attrs |= PropertyAttributes::WRITABLE;
            }
            if enumerable_val.unwrap_or(false) {
                attrs |= PropertyAttributes::ENUMERABLE;
            }
            if configurable_val.unwrap_or(false) {
                attrs |= PropertyAttributes::CONFIGURABLE;
            }
            map.borrow_mut()
                .insert_with_attrs(key.to_string(), value, attrs);
        } else {
            if has_value {
                let value = desc.get("value").cloned().unwrap_or(JsValue::Undefined);
                let getter_key = format!("__get_{key}__");
                let setter_key = format!("__set_{key}__");
                map.borrow_mut().remove(&getter_key);
                map.borrow_mut().remove(&setter_key);
                map.borrow_mut().insert(key.to_string(), value);
            }
            if let Some(w) = writable_val {
                map.borrow_mut().set_writable(key, w);
            }
            if let Some(e) = enumerable_val {
                map.borrow_mut().set_enumerable(key, e);
            }
            if let Some(c) = configurable_val {
                map.borrow_mut().set_configurable(key, c);
            }
        }
    }
    Ok(())
}

fn plain_descriptor_as_object(map: &Rc<RefCell<PropertyMap>>, key: &str) -> JsValue {
    let borrowed = map.borrow();
    let getter_key = format!("__get_{key}__");
    let setter_key = format!("__set_{key}__");
    let has_getter = borrowed.contains_key(&getter_key);
    let has_setter = borrowed.contains_key(&setter_key);
    if has_getter || has_setter {
        let mut desc = PropertyMap::new();
        desc.insert(
            "get".into(),
            borrowed
                .get(&getter_key)
                .cloned()
                .unwrap_or(JsValue::Undefined),
        );
        desc.insert(
            "set".into(),
            borrowed
                .get(&setter_key)
                .cloned()
                .unwrap_or(JsValue::Undefined),
        );
        let attr_key = if has_getter { &getter_key } else { &setter_key };
        desc.insert(
            "enumerable".into(),
            JsValue::Boolean(borrowed.is_enumerable(attr_key)),
        );
        desc.insert(
            "configurable".into(),
            JsValue::Boolean(borrowed.is_configurable(attr_key)),
        );
        JsValue::PlainObject(Rc::new(RefCell::new(desc)))
    } else if let Some(value) = borrowed.get(key).cloned() {
        let mut desc = PropertyMap::new();
        desc.insert("value".into(), value);
        desc.insert(
            "writable".into(),
            JsValue::Boolean(borrowed.is_writable(key)),
        );
        desc.insert(
            "enumerable".into(),
            JsValue::Boolean(borrowed.is_enumerable(key)),
        );
        desc.insert(
            "configurable".into(),
            JsValue::Boolean(borrowed.is_configurable(key)),
        );
        JsValue::PlainObject(Rc::new(RefCell::new(desc)))
    } else {
        JsValue::Undefined
    }
}

fn plain_get(target: &JsValue, key: &str, receiver: &JsValue) -> StatorResult<JsValue> {
    let mut current = target.clone();
    for _ in 0..256 {
        if let JsValue::PlainObject(map) = &current {
            let borrow = map.borrow();
            let getter_key = format!("__get_{key}__");
            if let Some(getter) = borrow.get(&getter_key).cloned() {
                drop(borrow);
                return dispatch_call_with_this(&getter, receiver.clone(), vec![]);
            }
            if let Some(value) = borrow.get(key).cloned() {
                return Ok(value);
            }
            if let Some(proto) = borrow.get("__proto__").cloned() {
                drop(borrow);
                current = proto;
                continue;
            }
        }
        break;
    }
    Ok(JsValue::Undefined)
}

fn plain_set_on_receiver(receiver: &JsValue, key: &str, value: JsValue) -> StatorResult<bool> {
    match receiver {
        JsValue::PlainObject(map) => {
            let setter_key = format!("__set_{key}__");
            let getter_key = format!("__get_{key}__");
            {
                let borrow = map.borrow();
                if let Some(setter) = borrow.get(&setter_key).cloned() {
                    drop(borrow);
                    dispatch_call_with_this(&setter, receiver.clone(), vec![value])?;
                    return Ok(true);
                }
                if borrow.contains_key(&getter_key) {
                    return Ok(false);
                }
                if borrow.contains_key(key) && !borrow.is_writable(key) {
                    return Ok(false);
                }
                if !borrow.extensible && !borrow.contains_key(key) {
                    return Ok(false);
                }
            }
            dispatch_set_property_value(receiver, JsValue::String(key.to_string().into()), value)?;
            Ok(true)
        }
        JsValue::Proxy(proxy) => {
            proxy_set_with_receiver(&mut proxy.borrow_mut(), key, value, receiver)
        }
        _ => Ok(false),
    }
}

fn plain_set(
    target: &JsValue,
    key: &str,
    value: JsValue,
    receiver: &JsValue,
) -> StatorResult<bool> {
    let mut current = target.clone();
    for _ in 0..256 {
        if let JsValue::PlainObject(map) = &current {
            let borrow = map.borrow();
            let setter_key = format!("__set_{key}__");
            let getter_key = format!("__get_{key}__");
            if let Some(setter) = borrow.get(&setter_key).cloned() {
                drop(borrow);
                dispatch_call_with_this(&setter, receiver.clone(), vec![value])?;
                return Ok(true);
            }
            if borrow.contains_key(&getter_key) {
                return Ok(false);
            }
            if borrow.contains_key(key) {
                if !borrow.is_writable(key) {
                    return Ok(false);
                }
                drop(borrow);
                return plain_set_on_receiver(receiver, key, value);
            }
            if let Some(proto) = borrow.get("__proto__").cloned() {
                drop(borrow);
                current = proto;
                continue;
            }
        }
        break;
    }
    plain_set_on_receiver(receiver, key, value)
}

fn plain_has(target: &JsValue, key: &str) -> bool {
    let mut current = target.clone();
    for _ in 0..256 {
        if let JsValue::PlainObject(map) = &current {
            let borrow = map.borrow();
            if borrow.contains_key(key)
                || borrow.contains_key(&format!("__get_{key}__"))
                || borrow.contains_key(&format!("__set_{key}__"))
            {
                return true;
            }
            if let Some(proto) = borrow.get("__proto__").cloned() {
                drop(borrow);
                current = proto;
                continue;
            }
        }
        break;
    }
    false
}

fn plain_delete_property(map: &Rc<RefCell<PropertyMap>>, key: &str) -> bool {
    let getter_key = format!("__get_{key}__");
    let setter_key = format!("__set_{key}__");
    let mut borrow = map.borrow_mut();
    let has_accessor = borrow.contains_key(&getter_key) || borrow.contains_key(&setter_key);
    if has_accessor {
        let configurable = if borrow.contains_key(&getter_key) {
            borrow.is_configurable(&getter_key)
        } else {
            borrow.is_configurable(&setter_key)
        };
        if !configurable {
            return false;
        }
        borrow.remove(&getter_key);
        borrow.remove(&setter_key);
        borrow.remove(key);
        true
    } else if borrow.contains_key(key) {
        if !borrow.is_configurable(key) {
            return false;
        }
        borrow.remove(key);
        true
    } else {
        true
    }
}

fn plain_own_keys(map: &PropertyMap) -> Vec<JsValue> {
    let mut string_parts: Vec<JsValue> = Vec::new();
    let mut symbols: Vec<JsValue> = Vec::new();
    let mut seen = HashSet::new();
    for key in map.keys() {
        if key.as_ref() == "__proto__" {
            continue;
        }
        if let Some(symbol) = property_key_to_symbol(key) {
            symbols.push(JsValue::Symbol(symbol));
            continue;
        }
        if let Some(name) = accessor_property_name(key) {
            if seen.insert(name.to_string()) {
                string_parts.push(JsValue::String(name.to_string().into()));
            }
            continue;
        }
        if is_internal_accessor_key(key) {
            continue;
        }
        string_parts.push(JsValue::String(key.clone()));
    }
    // ES spec ordering: integer indices ascending, then string keys in
    // insertion order, then symbols in insertion order.
    let mut integer_keys: Vec<(u32, JsValue)> = Vec::new();
    let mut rest_keys: Vec<JsValue> = Vec::new();
    for k in string_parts {
        if let JsValue::String(ref s) = k
            && let Some(idx) = parse_integer_index_key(s)
        {
            integer_keys.push((idx, k));
            continue;
        }
        rest_keys.push(k);
    }
    integer_keys.sort_by_key(|(idx, _)| *idx);
    integer_keys
        .into_iter()
        .map(|(_, v)| v)
        .chain(rest_keys)
        .chain(symbols)
        .collect()
}

/// ECMAScript §23.1.3.1 step 5.b — check `@@isConcatSpreadable`.
///
/// Returns `true` when the value should be spread by `Array.prototype.concat`:
/// arrays are spreadable by default unless `@@isConcatSpreadable` is `false`;
/// other objects are spreadable only when `@@isConcatSpreadable` is `true`.
fn is_concat_spreadable(value: &JsValue) -> bool {
    match value {
        JsValue::PlainObject(map) => {
            let borrow = map.borrow();
            match borrow.get("@@isConcatSpreadable").cloned() {
                Some(v) => v.to_boolean(),
                None => matches!(borrow.get("__is_array__"), Some(JsValue::Boolean(true))),
            }
        }
        JsValue::Array(items) => {
            // If the array was wrapped in an object with @@isConcatSpreadable,
            // we can't see it here.  Bare arrays are always spreadable unless
            // they carry an internal property override — our representation
            // does not support per-value internal slots, so default to `true`.
            let _ = items;
            true
        }
        _ => false,
    }
}

/// ECMAScript §9.4.2.3 ArraySpeciesCreate(originalArray, length).
///
/// Determines which constructor to use when Array methods like `slice` or
/// `map` need to create a new array.  For plain `JsValue::Array` values
/// this always falls back to the default `Array` constructor (returns
/// `None`).  For `PlainObject`-based arrays (subclasses) it inspects
/// `this.constructor[@@species]` and, if callable, invokes it with
/// `[length]` to produce the result.
fn array_species_create(original: &JsValue, length: usize) -> StatorResult<Option<JsValue>> {
    // Only PlainObject arrays can carry a custom `constructor`.
    let map = match original {
        JsValue::PlainObject(m) => m,
        _ => return Ok(None),
    };
    let ctor = {
        let borrow = map.borrow();
        match borrow.get("constructor").cloned() {
            Some(c) if !c.is_undefined() => c,
            _ => return Ok(None),
        }
    };
    // §9.4.2.3 step 6: Get species from constructor.
    let species = match &ctor {
        JsValue::PlainObject(ctor_map) => {
            let borrow = ctor_map.borrow();
            // Check for the @@species getter first.
            if let Some(getter) = borrow.get("__get_@@species__").cloned() {
                drop(borrow);
                dispatch_call_value(&getter, vec![ctor.clone()])?
            } else if let Some(v) = borrow.get("@@species").cloned() {
                v
            } else {
                return Ok(None);
            }
        }
        _ => return Ok(None),
    };
    // §9.4.2.3 step 7: if species is null or undefined, fall back.
    if species.is_undefined() || matches!(species, JsValue::Null) {
        return Ok(None);
    }
    // §9.4.2.3 step 9: construct using species.
    if is_callable(&species) {
        let result = dispatch_call_value(&species, vec![JsValue::Smi(length as i32)])?;
        Ok(Some(result))
    } else {
        Err(StatorError::TypeError(
            "Species constructor is not callable".into(),
        ))
    }
}

fn to_integer_or_infinity_arg(value: Option<&JsValue>, default: f64) -> StatorResult<f64> {
    match value {
        Some(value) => value.to_integer_or_infinity(),
        None => Ok(default),
    }
}

fn clamp_relative_integer_index(len: usize, index: f64) -> usize {
    if index == f64::NEG_INFINITY {
        0
    } else if index < 0.0 {
        ((len as f64) + index).max(0.0) as usize
    } else {
        index.min(len as f64) as usize
    }
}

fn clamp_nonnegative_integer_index(len: usize, index: f64) -> usize {
    if index <= 0.0 {
        0
    } else {
        index.min(len as f64) as usize
    }
}

fn normalize_string_index(len: usize, index: Option<&JsValue>) -> StatorResult<Option<usize>> {
    let index = to_integer_or_infinity_arg(index, 0.0)?;
    if index < 0.0 || index == f64::INFINITY || index >= len as f64 {
        Ok(None)
    } else {
        Ok(Some(index as usize))
    }
}

/// ECMAScript `ToIntegerOrInfinity` index normalization for forward searches.
fn normalize_from_index(len: usize, from: Option<&JsValue>) -> StatorResult<usize> {
    Ok(clamp_relative_integer_index(
        len,
        to_integer_or_infinity_arg(from, 0.0)?,
    ))
}

/// ECMAScript `ToIntegerOrInfinity` index normalization for reverse searches.
fn normalize_last_from_index(len: usize, from: Option<&JsValue>) -> StatorResult<Option<usize>> {
    if len == 0 {
        return Ok(None);
    }
    let from = to_integer_or_infinity_arg(from, (len - 1) as f64)?;
    if from == f64::NEG_INFINITY {
        return Ok(None);
    }
    let index = if from < 0.0 {
        (len as f64) + from
    } else {
        from.min((len - 1) as f64)
    };
    if index < 0.0 {
        Ok(None)
    } else {
        Ok(Some(index as usize))
    }
}

/// ECMAScript `ToIntegerOrInfinity` index normalization for `.at(...)`.
fn normalize_at_index(len: usize, index: Option<&JsValue>) -> StatorResult<Option<usize>> {
    let index = to_integer_or_infinity_arg(index, 0.0)?;
    if index == f64::INFINITY {
        return Ok(None);
    }
    let len_f = len as f64;
    let actual = if index < 0.0 { len_f + index } else { index };
    if actual < 0.0 || actual >= len_f {
        Ok(None)
    } else {
        Ok(Some(actual as usize))
    }
}

/// Collect values from supported iterable forms used by built-ins.
fn collect_iterable_values(iterable: &JsValue) -> StatorResult<Vec<JsValue>> {
    match iterable {
        JsValue::Array(arr) => Ok(materialize_array_holes(&arr.borrow())),
        JsValue::Iterator(_) | JsValue::Generator(_) => iterator_to_vec(iterable),
        JsValue::String(s) => Ok(s
            .chars()
            .map(|c| JsValue::String(c.to_string().into()))
            .collect()),
        JsValue::PlainObject(_) if is_js_array(iterable)? => Ok(to_array_like_elements(iterable).0),
        JsValue::PlainObject(_) | JsValue::Proxy(_) => {
            for key in ["@@iterator", "entries"] {
                let method = dispatch_get_property_value(iterable, JsValue::String(key.into()))?;
                if is_callable(&method) {
                    let iterator = dispatch_call_with_this(&method, iterable.clone(), vec![])?;
                    return iterator_to_vec(&iterator);
                }
            }
            if array_like_length(iterable)? > 0
                || !matches!(
                    dispatch_get_property_value(iterable, JsValue::String("length".into()))?,
                    JsValue::Undefined
                )
            {
                return try_to_array_like_elements(iterable).map(|(elements, _)| elements);
            }
            Err(StatorError::TypeError("value is not iterable".into()))
        }
        _ => Err(StatorError::TypeError("value is not iterable".into())),
    }
}

/// Extract a `[key, value]` pair from an Object.fromEntries iterator value.
fn from_entries_pair(entry: &JsValue) -> StatorResult<(String, JsValue)> {
    match entry {
        JsValue::Array(pair) => {
            let pair = pair.borrow();
            let key = pair
                .first()
                .cloned()
                .unwrap_or(JsValue::Undefined)
                .to_js_string()?;
            let value = pair.get(1).cloned().unwrap_or(JsValue::Undefined);
            Ok((key, value))
        }
        JsValue::PlainObject(obj) => {
            let borrow = obj.borrow();
            let key = borrow
                .get("0")
                .cloned()
                .unwrap_or(JsValue::Undefined)
                .to_js_string()?;
            let value = borrow.get("1").cloned().unwrap_or(JsValue::Undefined);
            Ok((key, value))
        }
        _ => Err(StatorError::TypeError(
            "Object.fromEntries: iterator value is not an entry object".into(),
        )),
    }
}

/// If `value` exposes a string-protocol symbol method, invoke it with `value`
/// as `this` and the supplied arguments.
///
/// The engine stores built-in RegExp methods in hidden `__symbol_*__` slots,
/// while user code can define the corresponding well-known symbol property
/// (`Symbol.match`, `Symbol.replace`, …). This helper checks both forms so
/// `String.prototype.*` can delegate to built-ins and custom objects alike.
///
/// Returns `None` when the protocol method is absent or explicitly
/// `undefined`/`null`, so callers can fall back to the plain-string path.
fn try_string_protocol_method(
    value: &JsValue,
    symbol: u64,
    hidden_symbol_key: &str,
    args: Vec<JsValue>,
) -> Option<StatorResult<JsValue>> {
    if matches!(value, JsValue::Undefined | JsValue::Null) {
        return None;
    }

    match dispatch_get_property_value(value, JsValue::Symbol(symbol)) {
        Ok(method) if !matches!(method, JsValue::Undefined | JsValue::Null) => {
            return Some(dispatch_call_with_this(&method, value.clone(), args));
        }
        Ok(_) => {}
        Err(err) => return Some(Err(err)),
    }

    match dispatch_get_property_value(value, JsValue::String(hidden_symbol_key.into())) {
        Ok(method) if !matches!(method, JsValue::Undefined | JsValue::Null) => {
            Some(dispatch_call_with_this(&method, value.clone(), args))
        }
        Ok(_) => None,
        Err(err) => Some(Err(err)),
    }
}

/// ES2025 §7.3.45 `GetSetRecord` materialised for Set composition methods.
#[derive(Clone)]
struct SetLikeRecord {
    object: JsValue,
    size: usize,
    has: JsValue,
    keys: JsValue,
}

fn invalid_set_like_arg() -> StatorError {
    StatorError::TypeError("argument is not a Set-like object".into())
}

fn get_set_like_property(arg: &JsValue, key: &str) -> StatorResult<JsValue> {
    dispatch_get_property_value(arg, JsValue::String(key.into()))
}

fn get_set_like_record(arg: &JsValue) -> StatorResult<SetLikeRecord> {
    let has = get_set_like_property(arg, "has")?;
    if !is_callable(&has) {
        return Err(invalid_set_like_arg());
    }

    let size_value = get_set_like_property(arg, "size")?;
    if matches!(size_value, JsValue::Undefined) {
        return Err(invalid_set_like_arg());
    }
    let size = size_value.to_length()?.min(usize::MAX as u64) as usize;

    let keys = ["keys", "values", "@@iterator"]
        .into_iter()
        .map(|name| get_set_like_property(arg, name).map(|value| (name, value)))
        .find_map(|result| match result {
            Ok((_, value)) if is_callable(&value) => Some(Ok(value)),
            Ok(_) => None,
            Err(err) => Some(Err(err)),
        })
        .transpose()?
        .ok_or_else(invalid_set_like_arg)?;

    Ok(SetLikeRecord {
        object: arg.clone(),
        size,
        has,
        keys,
    })
}

fn iterate_set_like_keys(record: &SetLikeRecord) -> StatorResult<Vec<JsValue>> {
    let iter = dispatch_call_with_this(&record.keys, record.object.clone(), vec![])?;
    iterator_to_vec(&iter)
}

fn set_like_has(record: &SetLikeRecord, value: &JsValue) -> StatorResult<bool> {
    Ok(
        dispatch_call_with_this(&record.has, record.object.clone(), vec![value.clone()])?
            .to_boolean(),
    )
}

/// Build a full `Map` instance (PlainObject with map methods) from a [`JsMap`].
fn build_map_instance(m: crate::builtins::map::JsMap) -> StatorResult<JsValue> {
    let inner = Rc::new(RefCell::new(m));
    let obj_rc: Rc<RefCell<PropertyMap>> = Rc::new(RefCell::new(PropertyMap::new()));
    {
        let mut obj = obj_rc.borrow_mut();
        obj.insert_with_attrs(
            "__is_map__".into(),
            JsValue::Boolean(true),
            PropertyAttributes::empty(),
        );
        {
            let inner = Rc::clone(&inner);
            obj.insert_with_attrs(
                "__get_size__".into(),
                native(move |_| Ok(JsValue::Smi(map_size(&inner.borrow()) as i32))),
                PropertyAttributes::CONFIGURABLE,
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_get__".into(),
                native(move |a| {
                    let key = a.first().unwrap_or(&JsValue::Undefined);
                    Ok(map_get(&inner.borrow(), key))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let self_ref = Rc::clone(&obj_rc);
            obj.insert(
                "__map_set__".into(),
                native(move |a| {
                    let key = a.first().cloned().unwrap_or(JsValue::Undefined);
                    let val = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    map_set(&mut inner.borrow_mut(), key, val);
                    Ok(JsValue::PlainObject(Rc::clone(&self_ref)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_has__".into(),
                native(move |a| {
                    let key = a.first().unwrap_or(&JsValue::Undefined);
                    Ok(JsValue::Boolean(map_has(&inner.borrow(), key)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_delete__".into(),
                native(move |a| {
                    let key = a.first().unwrap_or(&JsValue::Undefined);
                    Ok(JsValue::Boolean(map_delete(&mut inner.borrow_mut(), key)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_clear__".into(),
                native(move |_| {
                    map_clear(&mut inner.borrow_mut());
                    Ok(JsValue::Undefined)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let self_ref = Rc::clone(&obj_rc);
            obj.insert(
                "__map_for_each__".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let receiver = JsValue::PlainObject(Rc::clone(&self_ref));
                    let mut cursor = 0;
                    loop {
                        let next = {
                            let map = inner.borrow();
                            map_next_entry(&map, &mut cursor)
                        };
                        let Some((k, v)) = next else {
                            break;
                        };
                        call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![v, k, receiver.clone()],
                        )?;
                    }
                    Ok(JsValue::Undefined)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_keys__".into(),
                native(move |_| {
                    Ok(build_map_iterator_object(
                        Rc::clone(&inner),
                        MapIteratorKind::Keys,
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_values__".into(),
                native(move |_| {
                    Ok(build_map_iterator_object(
                        Rc::clone(&inner),
                        MapIteratorKind::Values,
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_entries__".into(),
                native(move |_| {
                    Ok(build_map_iterator_object(
                        Rc::clone(&inner),
                        MapIteratorKind::Entries,
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_get_or_insert__".into(),
                native(move |a| {
                    let key = a.first().cloned().unwrap_or(JsValue::Undefined);
                    let default_val = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let existing = map_get(&inner.borrow(), &key);
                    if existing != JsValue::Undefined {
                        Ok(existing)
                    } else {
                        map_set(&mut inner.borrow_mut(), key, default_val.clone());
                        Ok(default_val)
                    }
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__map_get_or_insert_computed__".into(),
                native(move |a| {
                    let key = a.first().cloned().unwrap_or(JsValue::Undefined);
                    let callback = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let existing = map_get(&inner.borrow(), &key);
                    if existing != JsValue::Undefined {
                        Ok(existing)
                    } else {
                        let computed = dispatch_call_value(&callback, vec![key.clone()])?;
                        map_set(&mut inner.borrow_mut(), key, computed.clone());
                        Ok(computed)
                    }
                }),
            );
        }
        obj.make_all_non_enumerable();
    }
    let instance = JsValue::PlainObject(obj_rc);
    attach_constructor_prototype(&instance, "Map")?;
    Ok(instance)
}

/// Build a full `Set` instance (PlainObject with prototype methods) from a
/// [`JsSet`].  Used by ES2025 Set composition methods that return new sets.
fn build_set_instance(s: crate::builtins::set::JsSet) -> StatorResult<JsValue> {
    let inner = Rc::new(RefCell::new(s));
    let obj_rc: Rc<RefCell<PropertyMap>> = Rc::new(RefCell::new(PropertyMap::new()));
    {
        let mut obj = obj_rc.borrow_mut();
        obj.insert_with_attrs(
            "__is_set__".into(),
            JsValue::Boolean(true),
            PropertyAttributes::empty(),
        );
        {
            let inner = Rc::clone(&inner);
            obj.insert_with_attrs(
                "__get_size__".into(),
                native(move |_| Ok(JsValue::Smi(set_size(&inner.borrow()) as i32))),
                PropertyAttributes::CONFIGURABLE,
            );
        }
        {
            let inner = Rc::clone(&inner);
            let self_ref = Rc::clone(&obj_rc);
            obj.insert(
                "__set_add__".into(),
                native(move |a| {
                    let val = a.first().cloned().unwrap_or(JsValue::Undefined);
                    set_add(&mut inner.borrow_mut(), val);
                    Ok(JsValue::PlainObject(Rc::clone(&self_ref)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__set_has__".into(),
                native(move |a| {
                    let val = a.first().unwrap_or(&JsValue::Undefined);
                    Ok(JsValue::Boolean(set_has(&inner.borrow(), val)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__set_delete__".into(),
                native(move |a| {
                    let val = a.first().unwrap_or(&JsValue::Undefined);
                    Ok(JsValue::Boolean(set_delete(&mut inner.borrow_mut(), val)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__set_clear__".into(),
                native(move |_| {
                    set_clear(&mut inner.borrow_mut());
                    Ok(JsValue::Undefined)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let self_ref = Rc::clone(&obj_rc);
            obj.insert(
                "__set_for_each__".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let receiver = JsValue::PlainObject(Rc::clone(&self_ref));
                    let mut cursor = 0;
                    loop {
                        let next = {
                            let set = inner.borrow();
                            set_next_value(&set, &mut cursor)
                        };
                        let Some(v) = next else {
                            break;
                        };
                        call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![v.clone(), v, receiver.clone()],
                        )?;
                    }
                    Ok(JsValue::Undefined)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__set_values__".into(),
                native(move |_| {
                    Ok(build_set_iterator_object(
                        Rc::clone(&inner),
                        SetIteratorKind::Values,
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__set_entries__".into(),
                native(move |_| {
                    Ok(build_set_iterator_object(
                        Rc::clone(&inner),
                        SetIteratorKind::Entries,
                    ))
                }),
            );
        }
    }
    // ── ES2025 Set composition methods on returned instances ─────────
    // union(other)
    {
        let inner = Rc::clone(&inner);
        obj_rc.borrow_mut().insert(
            "union".into(),
            native(move |a| {
                let other_val = a.first().unwrap_or(&JsValue::Undefined);
                let other = get_set_like_record(other_val)?;
                let mut result = inner.borrow().clone();
                for value in iterate_set_like_keys(&other)? {
                    if !set_has(&result, &value) {
                        set_add(&mut result, value);
                    }
                }
                build_set_instance(result)
            }),
        );
    }
    // intersection(other)
    {
        let inner = Rc::clone(&inner);
        obj_rc.borrow_mut().insert(
            "intersection".into(),
            native(move |a| {
                let other_val = a.first().unwrap_or(&JsValue::Undefined);
                let other = get_set_like_record(other_val)?;
                let this_set = inner.borrow();
                let mut result = set_new();
                if other.size != 0 {
                    for value in set_values(&this_set) {
                        if set_like_has(&other, &value)? {
                            set_add(&mut result, value);
                        }
                    }
                }
                build_set_instance(result)
            }),
        );
    }
    // difference(other)
    {
        let inner = Rc::clone(&inner);
        obj_rc.borrow_mut().insert(
            "difference".into(),
            native(move |a| {
                let other_val = a.first().unwrap_or(&JsValue::Undefined);
                let other = get_set_like_record(other_val)?;
                let this_set = inner.borrow();
                let mut result = set_new();
                for value in set_values(&this_set) {
                    if !set_like_has(&other, &value)? {
                        set_add(&mut result, value);
                    }
                }
                build_set_instance(result)
            }),
        );
    }
    // symmetricDifference(other)
    {
        let inner = Rc::clone(&inner);
        obj_rc.borrow_mut().insert(
            "symmetricDifference".into(),
            native(move |a| {
                let other_val = a.first().unwrap_or(&JsValue::Undefined);
                let other = get_set_like_record(other_val)?;
                let this_set = inner.borrow();
                let this_values = set_values(&this_set);
                let mut result = set_new();
                for value in &this_values {
                    if !set_like_has(&other, value)? {
                        set_add(&mut result, value.clone());
                    }
                }
                for value in iterate_set_like_keys(&other)? {
                    if !set_has(&this_set, &value) {
                        set_add(&mut result, value);
                    }
                }
                build_set_instance(result)
            }),
        );
    }
    // isSubsetOf(other)
    {
        let inner = Rc::clone(&inner);
        obj_rc.borrow_mut().insert(
            "isSubsetOf".into(),
            native(move |a| {
                let other_val = a.first().unwrap_or(&JsValue::Undefined);
                let other = get_set_like_record(other_val)?;
                let this_set = inner.borrow();
                if set_size(&this_set) > other.size {
                    return Ok(JsValue::Boolean(false));
                }
                for value in set_values(&this_set) {
                    if !set_like_has(&other, &value)? {
                        return Ok(JsValue::Boolean(false));
                    }
                }
                Ok(JsValue::Boolean(true))
            }),
        );
    }
    // isSupersetOf(other)
    {
        let inner = Rc::clone(&inner);
        obj_rc.borrow_mut().insert(
            "isSupersetOf".into(),
            native(move |a| {
                let other_val = a.first().unwrap_or(&JsValue::Undefined);
                let other = get_set_like_record(other_val)?;
                let this_set = inner.borrow();
                if set_size(&this_set) < other.size {
                    return Ok(JsValue::Boolean(false));
                }
                for value in iterate_set_like_keys(&other)? {
                    if !set_has(&this_set, &value) {
                        return Ok(JsValue::Boolean(false));
                    }
                }
                Ok(JsValue::Boolean(true))
            }),
        );
    }
    // isDisjointFrom(other)
    {
        let inner = Rc::clone(&inner);
        obj_rc.borrow_mut().insert(
            "isDisjointFrom".into(),
            native(move |a| {
                let other_val = a.first().unwrap_or(&JsValue::Undefined);
                let other = get_set_like_record(other_val)?;
                let this_set = inner.borrow();
                if set_size(&this_set) <= other.size {
                    for value in set_values(&this_set) {
                        if set_like_has(&other, &value)? {
                            return Ok(JsValue::Boolean(false));
                        }
                    }
                } else {
                    for value in iterate_set_like_keys(&other)? {
                        if set_has(&this_set, &value) {
                            return Ok(JsValue::Boolean(false));
                        }
                    }
                }
                Ok(JsValue::Boolean(true))
            }),
        );
    }
    // §24.2.3.12 Set.prototype[@@toStringTag] = "Set"
    {
        let mut obj = obj_rc.borrow_mut();
        obj.insert_with_attrs(
            "@@toStringTag".into(),
            JsValue::String("Set".into()),
            PropertyAttributes::CONFIGURABLE,
        );
        obj.make_all_non_enumerable();
    }
    let instance = JsValue::PlainObject(obj_rc);
    attach_constructor_prototype(&instance, "Set")?;
    Ok(instance)
}

/// §20.5.3.4 `Error.prototype.toString()` algorithm.
///
/// Works for both `JsValue::Error` and `JsValue::PlainObject` `this` values.
/// Returns the spec-mandated `"name: message"` string, with special-casing
/// for empty or undefined `name` / `message`.
fn error_prototype_to_string(this: &JsValue) -> StatorResult<JsValue> {
    match this {
        JsValue::Error(e) => Ok(JsValue::String(e.to_error_string().into())),
        JsValue::PlainObject(_) => {
            let name_value = dispatch_get_property_value(this, JsValue::String("name".into()))
                .unwrap_or(JsValue::Undefined);
            let name = match name_value {
                JsValue::String(s) => s.to_string(),
                JsValue::Undefined => "Error".to_string(),
                value => value.to_js_string().unwrap_or_else(|_| "Error".to_string()),
            };
            let message_value =
                dispatch_get_property_value(this, JsValue::String("message".into()))
                    .unwrap_or(JsValue::Undefined);
            let message = match message_value {
                JsValue::String(s) => s.to_string(),
                JsValue::Undefined => String::new(),
                value => value.to_js_string().unwrap_or_default(),
            };
            if name.is_empty() {
                Ok(JsValue::String(message.into()))
            } else if message.is_empty() {
                Ok(JsValue::String(name.into()))
            } else {
                Ok(JsValue::String(format!("{name}: {message}").into()))
            }
        }
        _ => Ok(JsValue::String("Error".to_string().into())),
    }
}

/// Build a NativeFunction that constructs a `JsValue::Error` of the given `ErrorKind`.
///
/// Supports the ES2022 options parameter: `new Error(message, { cause })`.
fn current_derived_constructor_this() -> Option<Rc<RefCell<PropertyMap>>> {
    let globals = current_global_env()?;
    let borrow = globals.borrow();
    if !borrow.contains_key(".class_pending_this") {
        return None;
    }
    match borrow.get("this") {
        Some(JsValue::PlainObject(map)) => Some(Rc::clone(map)),
        _ => None,
    }
}

fn current_native_receiver_this() -> Option<JsValue> {
    let globals = current_global_env()?;
    globals.borrow().get("this").cloned()
}

fn default_promise_constructor() -> Option<JsValue> {
    let globals = current_global_env()?;
    globals.borrow().get("Promise").cloned()
}

fn promise_static_constructor() -> Option<JsValue> {
    current_native_receiver_this()
        .filter(is_callable)
        .or_else(default_promise_constructor)
}

fn promise_static_species_constructor(constructor: &JsValue) -> StatorResult<JsValue> {
    let species = match constructor {
        JsValue::PlainObject(map) => {
            let borrow = map.borrow();
            if let Some(getter) = borrow.get("__get_@@species__").cloned() {
                drop(borrow);
                dispatch_call_value(&getter, vec![constructor.clone()])?
            } else {
                borrow
                    .get("@@species")
                    .cloned()
                    .unwrap_or(JsValue::Undefined)
            }
        }
        JsValue::Function(_) | JsValue::NativeFunction(_) | JsValue::Proxy(_) => JsValue::Undefined,
        _ => {
            return Err(StatorError::TypeError(
                "Promise constructor is not an object".into(),
            ));
        }
    };

    if species.is_undefined() || matches!(species, JsValue::Null) {
        return Ok(constructor.clone());
    }
    if !is_callable(&species) {
        return Err(StatorError::TypeError(
            "Promise species constructor is not callable".into(),
        ));
    }
    Ok(species)
}

fn promise_static_result(
    constructor: Option<&JsValue>,
) -> StatorResult<crate::builtins::promise::JsPromise> {
    let result = crate::builtins::promise::promise_pending();
    let Some(constructor) = constructor else {
        return Ok(result);
    };
    let species = promise_static_species_constructor(constructor)?;
    let prototype = dispatch_get_property_value(&species, JsValue::String("prototype".into()))?;
    if prototype.is_object_like() {
        result.set_prototype(Some(prototype));
    } else if !matches!(prototype, JsValue::Undefined | JsValue::Null) {
        return Err(StatorError::TypeError(
            "Promise species prototype is not an object".into(),
        ));
    }
    Ok(result)
}

fn promise_static_input_promises(
    arg: Option<&JsValue>,
    constructor: Option<&JsValue>,
    queue: &crate::builtins::promise::MicrotaskQueue,
) -> Result<Vec<crate::builtins::promise::JsPromise>, String> {
    use crate::builtins::promise::promise_resolve;

    let values = extract_promise_values(arg)?;
    let Some(constructor) = constructor else {
        return Ok(values
            .into_iter()
            .map(|value| match value {
                JsValue::Promise(promise) => promise,
                other => promise_resolve(other, queue),
            })
            .collect());
    };

    let resolve = dispatch_get_property_value(constructor, JsValue::String("resolve".into()))
        .map_err(|error| error.to_string())?;
    if !is_callable(&resolve) {
        return Err("TypeError: Promise resolve is not callable".to_string());
    }

    values
        .into_iter()
        .map(|value| {
            let resolved = dispatch_call_with_this(&resolve, constructor.clone(), vec![value])
                .map_err(|error| error.to_string())?;
            match resolved {
                JsValue::Promise(promise) => Ok(promise),
                _ => Err("TypeError: Promise resolve must return a promise".to_string()),
            }
        })
        .collect()
}

fn promise_species_constructor(
    promise: &crate::builtins::promise::JsPromise,
) -> StatorResult<Option<JsValue>> {
    let promise_value = JsValue::Promise(promise.clone());
    let constructor =
        dispatch_get_property_value(&promise_value, JsValue::String("constructor".into()))?;
    if constructor.is_undefined() {
        return Ok(None);
    }

    let species = match &constructor {
        JsValue::PlainObject(map) => {
            let borrow = map.borrow();
            if let Some(getter) = borrow.get("__get_@@species__").cloned() {
                drop(borrow);
                dispatch_call_value(&getter, vec![constructor.clone()])?
            } else {
                borrow
                    .get("@@species")
                    .cloned()
                    .unwrap_or(JsValue::Undefined)
            }
        }
        JsValue::Function(_) | JsValue::NativeFunction(_) | JsValue::Proxy(_) => JsValue::Undefined,
        _ => {
            return Err(StatorError::TypeError(
                "Promise constructor is not an object".into(),
            ));
        }
    };

    if species.is_undefined() || matches!(species, JsValue::Null) {
        return Ok(None);
    }
    if !is_callable(&species) {
        return Err(StatorError::TypeError(
            "Promise species constructor is not callable".into(),
        ));
    }
    Ok(Some(species))
}

fn promise_species_result(
    promise: &crate::builtins::promise::JsPromise,
) -> StatorResult<crate::builtins::promise::JsPromise> {
    let result = crate::builtins::promise::promise_pending();
    if let Some(species) = promise_species_constructor(promise)? {
        let prototype = dispatch_get_property_value(&species, JsValue::String("prototype".into()))?;
        if prototype.is_object_like() {
            result.set_prototype(Some(prototype));
        } else if !matches!(prototype, JsValue::Undefined | JsValue::Null) {
            return Err(StatorError::TypeError(
                "Promise species prototype is not an object".into(),
            ));
        }
    }
    Ok(result)
}

fn promise_then_method(queue: &crate::builtins::promise::MicrotaskQueue) -> JsValue {
    let q = queue.clone();
    builtin_fn("then", 2, move |args: Vec<JsValue>| {
        let promise = match args.first() {
            Some(JsValue::Promise(p)) => p.clone(),
            _ => {
                return Err(StatorError::TypeError(
                    "Promise.prototype.then called on non-Promise".into(),
                ));
            }
        };
        let on_fulfilled = args.get(1).and_then(extract_handler);
        let on_rejected = args.get(2).and_then(extract_handler);
        let result_promise = promise_species_result(&promise)?;
        Ok(JsValue::Promise(
            crate::builtins::promise::promise_then_with_result(
                &promise,
                on_fulfilled,
                on_rejected,
                result_promise,
                &q,
            ),
        ))
    })
}

fn promise_catch_method(queue: &crate::builtins::promise::MicrotaskQueue) -> JsValue {
    let q = queue.clone();
    builtin_fn("catch", 1, move |args: Vec<JsValue>| {
        let promise = match args.first() {
            Some(JsValue::Promise(p)) => p.clone(),
            _ => {
                return Err(StatorError::TypeError(
                    "Promise.prototype.catch called on non-Promise".into(),
                ));
            }
        };
        let handler = args
            .get(1)
            .and_then(extract_handler)
            .unwrap_or_else(|| Box::new(Err));
        let result_promise = promise_species_result(&promise)?;
        Ok(JsValue::Promise(
            crate::builtins::promise::promise_catch_with_result(
                &promise,
                handler,
                result_promise,
                &q,
            ),
        ))
    })
}

fn promise_finally_method(queue: &crate::builtins::promise::MicrotaskQueue) -> JsValue {
    let q = queue.clone();
    builtin_fn("finally", 1, move |args: Vec<JsValue>| {
        let promise = match args.first() {
            Some(JsValue::Promise(p)) => p.clone(),
            _ => {
                return Err(StatorError::TypeError(
                    "Promise.prototype.finally called on non-Promise".into(),
                ));
            }
        };
        let callback: crate::builtins::promise::PromiseFinallyHandler = match args.get(1) {
            Some(JsValue::NativeFunction(f)) => {
                let f = Rc::clone(f);
                Box::new(move || match f(vec![]) {
                    Ok(value) => Ok(value),
                    Err(e) => Err(JsValue::String(e.to_string().into())),
                })
            }
            Some(v @ JsValue::Function(_)) | Some(v @ JsValue::Proxy(_)) => {
                let callee = v.clone();
                Box::new(move || match dispatch_call_value(&callee, vec![]) {
                    Ok(value) => Ok(value),
                    Err(e) => Err(JsValue::String(e.to_string().into())),
                })
            }
            Some(JsValue::PlainObject(map)) if map.borrow().contains_key("__call__") => {
                let callee = JsValue::PlainObject(Rc::clone(map));
                Box::new(move || match dispatch_call_value(&callee, vec![]) {
                    Ok(value) => Ok(value),
                    Err(e) => Err(JsValue::String(e.to_string().into())),
                })
            }
            _ => Box::new(|| Ok(JsValue::Undefined)),
        };
        let result_promise = promise_species_result(&promise)?;
        Ok(JsValue::Promise(
            crate::builtins::promise::promise_finally_with_result(
                &promise,
                callback,
                result_promise,
                &q,
            ),
        ))
    })
}

fn initialize_error_plain_object(
    target: &Rc<RefCell<PropertyMap>>,
    kind: ErrorKind,
    message: &str,
    cause: Option<JsValue>,
    errors: Option<Vec<JsValue>>,
) -> JsValue {
    let stack_name = match kind {
        ErrorKind::AggregateError => "AggregateError",
        _ => kind.as_name(),
    };
    let mut borrow = target.borrow_mut();
    borrow.insert(
        "message".into(),
        JsValue::String(message.to_string().into()),
    );
    borrow.insert(
        "stack".into(),
        JsValue::String(crate::builtins::error::capture_stack_trace(stack_name, message).into()),
    );
    if let Some(cause) = cause {
        borrow.insert("cause".into(), cause);
    }
    if let Some(errors) = errors {
        borrow.insert("errors".into(), JsValue::new_array(errors));
    }
    drop(borrow);
    JsValue::PlainObject(Rc::clone(target))
}

fn error_instanceof(value: &JsValue, prototype: &JsValue, kind: Option<ErrorKind>) -> bool {
    match (value, kind) {
        (JsValue::Error(_), None) => true,
        (JsValue::Error(err), Some(kind)) if err.kind == kind => true,
        _ => has_prototype_in_chain(value, prototype),
    }
}

#[inline(never)]
fn make_error_constructor(kind: ErrorKind) -> JsValue {
    native(move |args| {
        let message = match args.first() {
            Some(JsValue::Undefined) | None => String::new(),
            Some(v) => v.to_js_string()?,
        };
        let cause = extract_cause(args.get(1));
        if let Some(this_obj) = current_derived_constructor_this() {
            return Ok(initialize_error_plain_object(
                &this_obj, kind, &message, cause, None,
            ));
        }
        let mut err = JsError::new(kind, message);
        if let Some(ref cause_val) = cause {
            err.props
                .borrow_mut()
                .insert("cause".to_string(), cause_val.clone());
        }
        err.cause = cause;
        Ok(JsValue::Error(Rc::new(err)))
    })
}

/// Build a PlainObject error constructor with `__call__`, `name`, and
/// `@@hasInstance` for a specific `ErrorKind`.
///
/// This allows `instanceof` checks (via `@@hasInstance`) and name-based
/// detection in the Test262 harness (via the `name` property).
///
/// `error_proto` is `Error.prototype` and `error_ctor` is the `Error`
/// constructor so that the correct prototype chains are established:
///   - `NativeError.prototype.__proto__` → `Error.prototype`
///   - `NativeError.__proto__` → `Error`
#[inline(never)]
fn make_error_constructor_object(
    kind: ErrorKind,
    error_proto: &JsValue,
    error_ctor: &JsValue,
) -> JsValue {
    let mut props = PropertyMap::new();
    let mut proto = PropertyMap::new();
    proto.insert(
        "name".into(),
        JsValue::String(kind.as_name().to_string().into()),
    );
    proto.insert("message".into(), JsValue::String(String::new().into()));
    proto.insert(
        "toString".into(),
        native(move |args| {
            let this = args.first().unwrap_or(&JsValue::Undefined);
            error_prototype_to_string(this)
        }),
    );
    proto.insert("__proto__".into(), error_proto.clone());
    proto.make_all_non_enumerable();
    let err_proto_rc = Rc::new(RefCell::new(proto));
    let err_proto_val = JsValue::PlainObject(err_proto_rc.clone());

    props.insert("__call__".into(), make_error_constructor(kind));
    props.insert(
        "name".into(),
        JsValue::String(kind.as_name().to_string().into()),
    );
    props.insert("@@hasInstance".into(), {
        let proto_for_instanceof = err_proto_val.clone();
        native(move |args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            Ok(JsValue::Boolean(error_instanceof(
                val,
                &proto_for_instanceof,
                Some(kind),
            )))
        })
    });
    // §20.5.6.1 NativeError.__proto__ → Error (constructor chain)
    props.insert("__proto__".into(), error_ctor.clone());
    props.insert("prototype".into(), err_proto_val);
    props.make_all_non_enumerable();
    let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
    // §20.5.6.2 NativeError.prototype.constructor
    err_proto_rc.borrow_mut().insert_with_attrs(
        "constructor".into(),
        ctor.clone(),
        PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
    );
    ctor
}

/// Extract the `cause` value from an options argument, if present.
fn extract_cause(options: Option<&JsValue>) -> Option<JsValue> {
    if let Some(JsValue::PlainObject(map)) = options {
        map.borrow().get("cause").cloned()
    } else {
        None
    }
}

/// Build the `AggregateError` constructor object.
///
/// Signature: `AggregateError(errors, message [, options])`.
///
/// The `errors` argument is consumed as an `Array`; the optional `options`
/// object may contain a `cause` property (ES2022).
///
/// Returns a `PlainObject` with `__call__`, `name`, `@@hasInstance`, and a
/// `prototype` that carries `name`, `message`, `toString`, and `constructor`.
#[inline(never)]
fn make_aggregate_error_constructor(error_proto: &JsValue, error_ctor: &JsValue) -> JsValue {
    let call = native(|args| {
        // First arg: errors (iterable / array-like).
        let errors_val = args.first().unwrap_or(&JsValue::Undefined);
        let (inner_errors, _) = to_array_like_elements(errors_val);
        // Second arg: message.
        let message = match args.get(1) {
            Some(JsValue::Undefined) | None => String::new(),
            Some(v) => v.to_js_string()?,
        };
        let cause = extract_cause(args.get(2));
        if let Some(this_obj) = current_derived_constructor_this() {
            return Ok(initialize_error_plain_object(
                &this_obj,
                ErrorKind::AggregateError,
                &message,
                cause,
                Some(inner_errors),
            ));
        }
        let mut err = JsError::new_aggregate(inner_errors, message);
        err.props
            .borrow_mut()
            .insert("errors".to_string(), JsValue::new_array(err.errors.clone()));
        if let Some(ref cause_val) = cause {
            err.props
                .borrow_mut()
                .insert("cause".to_string(), cause_val.clone());
        }
        err.cause = cause;
        Ok(JsValue::Error(Rc::new(err)))
    });

    let mut proto = PropertyMap::new();
    proto.insert(
        "name".into(),
        JsValue::String("AggregateError".to_string().into()),
    );
    proto.insert("message".into(), JsValue::String(String::new().into()));
    proto.insert(
        "toString".into(),
        native(|args| {
            let this = args.first().unwrap_or(&JsValue::Undefined);
            error_prototype_to_string(this)
        }),
    );
    proto.insert("__proto__".into(), error_proto.clone());
    proto.make_all_non_enumerable();
    let proto_rc = Rc::new(RefCell::new(proto));
    let proto_val = JsValue::PlainObject(proto_rc.clone());

    let mut props = PropertyMap::new();
    props.insert("__call__".into(), call);
    props.insert(
        "name".into(),
        JsValue::String("AggregateError".to_string().into()),
    );
    props.insert("@@hasInstance".into(), {
        let proto_for_instanceof = proto_val.clone();
        native(move |args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            Ok(JsValue::Boolean(error_instanceof(
                val,
                &proto_for_instanceof,
                Some(ErrorKind::AggregateError),
            )))
        })
    });
    props.insert("__proto__".into(), error_ctor.clone());
    props.insert("prototype".into(), proto_val);
    props.make_all_non_enumerable();
    let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));

    // §20.5.6.2 AggregateError.prototype.constructor
    proto_rc.borrow_mut().insert_with_attrs(
        "constructor".into(),
        ctor.clone(),
        PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
    );
    ctor
}

/// Build the `SuppressedError` constructor (TC39 explicit resource management).
///
/// `SuppressedError(error, suppressed, message)` creates an Error with
/// `.error`, `.suppressed`, and `.message` properties.
#[inline(never)]
fn make_suppressed_error_constructor() -> JsValue {
    native(|args| {
        let error_val = args.first().cloned().unwrap_or(JsValue::Undefined);
        let suppressed_val = args.get(1).cloned().unwrap_or(JsValue::Undefined);
        let message = match args.get(2) {
            Some(JsValue::Undefined) | None => String::new(),
            Some(v) => v.to_js_string()?,
        };
        let mut props = PropertyMap::new();
        props.insert("name".into(), JsValue::String("SuppressedError".into()));
        props.insert("message".into(), JsValue::String(message.into()));
        props.insert("error".into(), error_val);
        props.insert("suppressed".into(), suppressed_val);
        Ok(JsValue::PlainObject(Rc::new(RefCell::new(props))))
    })
}

/// Register all ECMAScript error constructors in the global environment.
///
/// The `Error` constructor additionally exposes the V8-compatible
/// `Error.captureStackTrace(target)` and `Error.stackTraceLimit` extensions.
#[inline(never)]
fn install_error_constructors(globals: &mut HashMap<String, JsValue>) {
    // The `Error` constructor is a PlainObject so it can carry static methods.
    let mut error_props = PropertyMap::new();
    error_props.insert("__call__".into(), make_error_constructor(ErrorKind::Error));
    error_props.insert("name".into(), JsValue::String("Error".into()));
    // V8 extension: Error.captureStackTrace(targetObject [, constructorOpt])
    // Adds a `.stack` property to the target and returns undefined.
    error_props.insert(
        "captureStackTrace".into(),
        native(|args| {
            let target = args.first().cloned().unwrap_or(JsValue::Undefined);
            match target {
                JsValue::Error(e) => {
                    let mut cloned = (*e).clone();
                    error_capture_stack_trace(&mut cloned, None);
                    // V8 mutates in-place; we cannot mutate Rc so this is
                    // best-effort.  Return undefined per the V8 API contract.
                }
                JsValue::PlainObject(ref map) => {
                    // V8: set `.stack` on the plain object.
                    let stack_str = crate::builtins::error::capture_stack_trace("Error", "");
                    map.borrow_mut()
                        .insert("stack".to_string(), JsValue::String(stack_str.into()));
                }
                _ => {}
            }
            Ok(JsValue::Undefined)
        }),
    );
    // V8 extension: Error.stackTraceLimit (getter/setter via property)
    error_props.insert(
        "stackTraceLimit".into(),
        JsValue::Smi(get_stack_trace_limit() as i32),
    );
    // §20.5.4.3 Error.isError(arg)  — ES2026
    error_props.insert(
        "isError".into(),
        builtin_fn("isError", 1, |args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            Ok(JsValue::Boolean(matches!(val, JsValue::Error(_))))
        }),
    );

    // ── Error.prototype ─────────────────────────────────────────────────
    // Build as a shared Rc so error subtype prototypes can link to it via
    // __proto__, forming the correct prototype chain.
    let error_proto_rc = {
        let mut proto = PropertyMap::new();
        proto.insert("name".into(), JsValue::String("Error".into()));
        proto.insert("message".into(), JsValue::String(String::new().into()));
        proto.insert(
            "toString".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                error_prototype_to_string(this)
            }),
        );
        proto.insert("@@toStringTag".into(), JsValue::String("Error".into()));
        proto.make_all_non_enumerable();
        Rc::new(RefCell::new(proto))
    };
    error_props.insert("@@hasInstance".into(), {
        let error_proto_for_instanceof = JsValue::PlainObject(error_proto_rc.clone());
        native(move |args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            Ok(JsValue::Boolean(error_instanceof(
                val,
                &error_proto_for_instanceof,
                None,
            )))
        })
    });
    error_props.insert(
        "prototype".into(),
        JsValue::PlainObject(error_proto_rc.clone()),
    );

    error_props.make_all_non_enumerable();
    let error_val = JsValue::PlainObject(Rc::new(RefCell::new(error_props)));
    let error_ctor = finalize_ctor(error_val, "Error");
    globals.insert("Error".into(), error_ctor.clone());

    let error_proto_val = JsValue::PlainObject(error_proto_rc);

    globals.insert(
        "TypeError".into(),
        finalize_ctor(
            make_error_constructor_object(ErrorKind::TypeError, &error_proto_val, &error_ctor),
            "TypeError",
        ),
    );
    globals.insert(
        "RangeError".into(),
        finalize_ctor(
            make_error_constructor_object(ErrorKind::RangeError, &error_proto_val, &error_ctor),
            "RangeError",
        ),
    );
    globals.insert(
        "ReferenceError".into(),
        finalize_ctor(
            make_error_constructor_object(ErrorKind::ReferenceError, &error_proto_val, &error_ctor),
            "ReferenceError",
        ),
    );
    globals.insert(
        "SyntaxError".into(),
        finalize_ctor(
            make_error_constructor_object(ErrorKind::SyntaxError, &error_proto_val, &error_ctor),
            "SyntaxError",
        ),
    );
    globals.insert(
        "URIError".into(),
        finalize_ctor(
            make_error_constructor_object(ErrorKind::URIError, &error_proto_val, &error_ctor),
            "URIError",
        ),
    );
    globals.insert(
        "EvalError".into(),
        finalize_ctor(
            make_error_constructor_object(ErrorKind::EvalError, &error_proto_val, &error_ctor),
            "EvalError",
        ),
    );
    globals.insert(
        "AggregateError".into(),
        finalize_ctor(
            make_aggregate_error_constructor(&error_proto_val, &error_ctor),
            "AggregateError",
        ),
    );
    globals.insert(
        "SuppressedError".into(),
        finalize_ctor(make_suppressed_error_constructor(), "SuppressedError"),
    );
}

/// Convert an `f64` to the most compact `JsValue` representation.
///
/// Returns `Smi` for values that are exact integers in the `i32` range,
/// `HeapNumber` for everything else (fractions, NaN, infinities, large ints,
/// and negative zero).
fn num(n: f64) -> JsValue {
    let is_negative_zero = n == 0.0 && n.is_sign_negative();
    if n.fract() == 0.0
        && !n.is_nan()
        && !n.is_infinite()
        && !is_negative_zero
        && n >= f64::from(i32::MIN)
        && n <= f64::from(i32::MAX)
    {
        JsValue::Smi(n as i32)
    } else {
        JsValue::HeapNumber(n)
    }
}

/// Extract the argument at `idx` as `f64`, defaulting to `NaN` when absent.
fn arg_f64(args: &[JsValue], idx: usize) -> StatorResult<f64> {
    args.get(idx).unwrap_or(&JsValue::Undefined).to_number()
}

fn is_callable_value(value: &JsValue) -> bool {
    matches!(value, JsValue::Function(_) | JsValue::NativeFunction(_))
        || matches!(
            value,
            JsValue::PlainObject(map)
                if matches!(
                    map.borrow().get("__call__"),
                    Some(JsValue::NativeFunction(_)) | Some(JsValue::Function(_))
                )
        )
}

/// Deep-clone a `JsValue`, recursing into plain objects and arrays.
fn structured_clone(val: &JsValue) -> StatorResult<JsValue> {
    match val {
        JsValue::Undefined
        | JsValue::Null
        | JsValue::Boolean(_)
        | JsValue::Smi(_)
        | JsValue::HeapNumber(_)
        | JsValue::String(_)
        | JsValue::BigInt(_) => Ok(val.clone()),
        JsValue::Symbol(_) | JsValue::Function(_) | JsValue::NativeFunction(_) => Err(
            StatorError::TypeError("structuredClone: value is not cloneable".into()),
        ),
        JsValue::PlainObject(map) => {
            let mut cloned = PropertyMap::new();
            for (k, v) in map.borrow().iter() {
                cloned.insert(k.to_string(), structured_clone(v)?);
            }
            Ok(JsValue::PlainObject(Rc::new(RefCell::new(cloned))))
        }
        JsValue::Array(arr) => {
            let cloned: StatorResult<Vec<JsValue>> =
                arr.borrow().iter().map(structured_clone).collect();
            Ok(JsValue::new_array(cloned?))
        }
        JsValue::Error(e) => Ok(JsValue::Error(Rc::new(JsError::clone(e)))),
        _ => Err(StatorError::TypeError(
            "structuredClone: value is not cloneable".into(),
        )),
    }
}

fn pseudo_random_bytes(len: usize) -> Vec<u8> {
    let seed = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|duration| duration.as_nanos() as u64)
        .unwrap_or(0x9E37_79B9_7F4A_7C15)
        ^ ((len as u64).wrapping_mul(0xA076_1D64_78BD_642F));
    let mut state = seed | 1;
    let mut bytes = Vec::with_capacity(len);
    for index in 0..len {
        state ^= state << 13;
        state ^= state >> 7;
        state ^= state << 17;
        bytes.push(((state as u8) & 0xFE) ^ ((index as u8).wrapping_add(1)));
    }
    bytes
}

#[inline(never)]
fn make_crypto() -> JsValue {
    let mut props = PropertyMap::new();
    props.insert(
        "getRandomValues".into(),
        builtin_fn("getRandomValues", 1, |args| {
            let target = args.first().unwrap_or(&JsValue::Undefined);
            match target {
                JsValue::TypedArray(typed_array) => {
                    let typed_array = typed_array.borrow();
                    let random_bytes = pseudo_random_bytes(typed_array.length);
                    for (index, byte) in random_bytes.into_iter().enumerate() {
                        typed_array_set(&typed_array, index, &JsValue::Smi(i32::from(byte)))?;
                    }
                    Ok(target.clone())
                }
                _ => Err(StatorError::TypeError(
                    "crypto.getRandomValues: argument must be a TypedArray".into(),
                )),
            }
        }),
    );
    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── Math ─────────────────────────────────────────────────────────────────────

/// Build the `Math` namespace object with all constants and methods.
#[inline(never)]
fn make_math() -> JsValue {
    let mut props = PropertyMap::new();

    // ── Constants (non-writable, non-enumerable, non-configurable) ─────
    props.insert_with_attrs(
        "E".into(),
        JsValue::HeapNumber(MATH_E),
        PropertyAttributes::empty(),
    );
    props.insert_with_attrs(
        "LN2".into(),
        JsValue::HeapNumber(MATH_LN2),
        PropertyAttributes::empty(),
    );
    props.insert_with_attrs(
        "LN10".into(),
        JsValue::HeapNumber(MATH_LN10),
        PropertyAttributes::empty(),
    );
    props.insert_with_attrs(
        "LOG2E".into(),
        JsValue::HeapNumber(MATH_LOG2E),
        PropertyAttributes::empty(),
    );
    props.insert_with_attrs(
        "LOG10E".into(),
        JsValue::HeapNumber(MATH_LOG10E),
        PropertyAttributes::empty(),
    );
    props.insert_with_attrs(
        "PI".into(),
        JsValue::HeapNumber(MATH_PI),
        PropertyAttributes::empty(),
    );
    props.insert_with_attrs(
        "SQRT1_2".into(),
        JsValue::HeapNumber(MATH_SQRT1_2),
        PropertyAttributes::empty(),
    );
    props.insert_with_attrs(
        "SQRT2".into(),
        JsValue::HeapNumber(MATH_SQRT2),
        PropertyAttributes::empty(),
    );

    // ── @@toStringTag ────────────────────────────────────────────────────
    props.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String("Math".into()),
        PropertyAttributes::CONFIGURABLE,
    );

    // ── Single-argument methods ──────────────────────────────────────────
    props.insert(
        "abs".into(),
        builtin_fn("abs", 1, |args| Ok(num(math_abs(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "ceil".into(),
        builtin_fn("ceil", 1, |args| Ok(num(math_ceil(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "floor".into(),
        builtin_fn("floor", 1, |args| Ok(num(math_floor(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "round".into(),
        builtin_fn("round", 1, |args| Ok(num(math_round(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "trunc".into(),
        builtin_fn("trunc", 1, |args| Ok(num(math_trunc(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "sign".into(),
        builtin_fn("sign", 1, |args| Ok(num(math_sign(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "sqrt".into(),
        builtin_fn("sqrt", 1, |args| Ok(num(math_sqrt(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "cbrt".into(),
        builtin_fn("cbrt", 1, |args| Ok(num(math_cbrt(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "log".into(),
        builtin_fn("log", 1, |args| Ok(num(math_log(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "log2".into(),
        builtin_fn("log2", 1, |args| Ok(num(math_log2(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "log10".into(),
        builtin_fn("log10", 1, |args| Ok(num(math_log10(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "sin".into(),
        builtin_fn("sin", 1, |args| Ok(num(math_sin(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "cos".into(),
        builtin_fn("cos", 1, |args| Ok(num(math_cos(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "tan".into(),
        builtin_fn("tan", 1, |args| Ok(num(math_tan(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "asin".into(),
        builtin_fn("asin", 1, |args| Ok(num(math_asin(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "acos".into(),
        builtin_fn("acos", 1, |args| Ok(num(math_acos(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "atan".into(),
        builtin_fn("atan", 1, |args| Ok(num(math_atan(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "sinh".into(),
        builtin_fn("sinh", 1, |args| Ok(num(math_sinh(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "cosh".into(),
        builtin_fn("cosh", 1, |args| Ok(num(math_cosh(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "tanh".into(),
        builtin_fn("tanh", 1, |args| Ok(num(math_tanh(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "asinh".into(),
        builtin_fn("asinh", 1, |args| Ok(num(math_asinh(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "acosh".into(),
        builtin_fn("acosh", 1, |args| Ok(num(math_acosh(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "atanh".into(),
        builtin_fn("atanh", 1, |args| Ok(num(math_atanh(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "exp".into(),
        builtin_fn("exp", 1, |args| Ok(num(math_exp(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "expm1".into(),
        builtin_fn("expm1", 1, |args| Ok(num(math_expm1(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "log1p".into(),
        builtin_fn("log1p", 1, |args| Ok(num(math_log1p(arg_f64(&args, 0)?)))),
    );
    props.insert(
        "fround".into(),
        builtin_fn("fround", 1, |args| {
            Ok(JsValue::HeapNumber(math_fround(arg_f64(&args, 0)?)))
        }),
    );

    // ── Two-argument methods ─────────────────────────────────────────────
    props.insert(
        "atan2".into(),
        builtin_fn("atan2", 2, |args| {
            let y = arg_f64(&args, 0)?;
            let x = arg_f64(&args, 1)?;
            Ok(num(math_atan2(y, x)))
        }),
    );
    props.insert(
        "pow".into(),
        builtin_fn("pow", 2, |args| {
            let base = arg_f64(&args, 0)?;
            let exp = arg_f64(&args, 1)?;
            Ok(num(math_pow(base, exp)))
        }),
    );
    props.insert(
        "imul".into(),
        builtin_fn("imul", 2, |args| {
            let a = arg_f64(&args, 0)?;
            let b = arg_f64(&args, 1)?;
            Ok(JsValue::Smi(math_imul(a, b)))
        }),
    );

    // ── Variadic methods ─────────────────────────────────────────────────
    props.insert(
        "max".into(),
        builtin_fn("max", 2, |args| {
            let nums: StatorResult<Vec<f64>> = args.iter().map(|a| a.to_number()).collect();
            Ok(num(math_max(&nums?)))
        }),
    );
    props.insert(
        "min".into(),
        builtin_fn("min", 2, |args| {
            let nums: StatorResult<Vec<f64>> = args.iter().map(|a| a.to_number()).collect();
            Ok(num(math_min(&nums?)))
        }),
    );
    props.insert(
        "hypot".into(),
        builtin_fn("hypot", 2, |args| {
            let nums: StatorResult<Vec<f64>> = args.iter().map(|a| a.to_number()).collect();
            Ok(num(math_hypot(&nums?)))
        }),
    );

    // ── Zero-argument / special ──────────────────────────────────────────
    props.insert(
        "random".into(),
        builtin_fn("random", 0, |_args| Ok(JsValue::HeapNumber(math_random()))),
    );
    props.insert(
        "clz32".into(),
        builtin_fn("clz32", 1, |args| {
            let x = arg_f64(&args, 0)?;
            Ok(JsValue::Smi(math_clz32(x) as i32))
        }),
    );

    // §21.3.2.42 Math.sumPrecise(items)  — ES2025
    props.insert(
        "sumPrecise".into(),
        builtin_fn("sumPrecise", 1, |args| {
            let items = args.first().unwrap_or(&JsValue::Undefined);
            let elems = match items {
                JsValue::Array(arr) => arr.borrow().clone(),
                _ => {
                    return Err(StatorError::TypeError(
                        "Math.sumPrecise: argument must be iterable".into(),
                    ));
                }
            };
            // Use compensated (Kahan) summation for extra precision.
            let mut sum: f64 = 0.0;
            let mut comp: f64 = 0.0;
            for v in &elems {
                let n = v.to_number()?;
                if n.is_nan() {
                    return Ok(JsValue::HeapNumber(f64::NAN));
                }
                if n.is_infinite() {
                    // Check for +∞ and −∞ in same list → NaN.
                    let mut has_pos = false;
                    let mut has_neg = false;
                    for v2 in &elems {
                        let n2 = v2.to_number()?;
                        if n2 == f64::INFINITY {
                            has_pos = true;
                        } else if n2 == f64::NEG_INFINITY {
                            has_neg = true;
                        }
                    }
                    return Ok(JsValue::HeapNumber(if has_pos && has_neg {
                        f64::NAN
                    } else if has_pos {
                        f64::INFINITY
                    } else {
                        f64::NEG_INFINITY
                    }));
                }
                let y = n - comp;
                let t = sum + y;
                comp = (t - sum) - y;
                sum = t;
            }
            // Normalise −0 to +0 per spec.
            if sum == 0.0 {
                sum = 0.0;
            }
            Ok(num(sum))
        }),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── console ──────────────────────────────────────────────────────────────────

/// Build the `console` namespace object.
#[inline(never)]
fn make_console() -> JsValue {
    let mut props = PropertyMap::new();

    props.insert(
        "log".into(),
        builtin_fn("log", 0, |args: Vec<JsValue>| {
            let parts: Vec<String> = args.iter().map(|a| a.to_display_string()).collect();
            println!("{}", parts.join(" "));
            Ok(JsValue::Undefined)
        }),
    );
    props.insert(
        "warn".into(),
        builtin_fn("warn", 0, |args: Vec<JsValue>| {
            let parts: Vec<String> = args.iter().map(|a| a.to_display_string()).collect();
            eprintln!("{}", parts.join(" "));
            Ok(JsValue::Undefined)
        }),
    );
    props.insert(
        "error".into(),
        builtin_fn("error", 0, |args: Vec<JsValue>| {
            let parts: Vec<String> = args.iter().map(|a| a.to_display_string()).collect();
            eprintln!("{}", parts.join(" "));
            Ok(JsValue::Undefined)
        }),
    );
    props.insert(
        "info".into(),
        builtin_fn("info", 0, |args: Vec<JsValue>| {
            let parts: Vec<String> = args.iter().map(|a| a.to_display_string()).collect();
            println!("{}", parts.join(" "));
            Ok(JsValue::Undefined)
        }),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── JSON ─────────────────────────────────────────────────────────────────────

/// Convert a [`JsonValue`] to the corresponding [`JsValue`].
fn json_value_to_js_value(jv: &crate::builtins::json::JsonValue) -> JsValue {
    use crate::builtins::json::JsonValue;
    match jv {
        JsonValue::Null => JsValue::Null,
        JsonValue::Bool(b) => JsValue::Boolean(*b),
        JsonValue::Number(n) => num(*n),
        JsonValue::Str(s) => JsValue::String(s.clone().into()),
        JsonValue::Array(arr) => {
            let items: Vec<JsValue> = arr.borrow().iter().map(json_value_to_js_value).collect();
            JsValue::new_array(items)
        }
        JsonValue::Object(entries) => {
            let mut map = PropertyMap::new();
            for (k, v) in entries.borrow().iter() {
                map.insert(k.clone(), json_value_to_js_value(v));
            }
            JsValue::PlainObject(Rc::new(RefCell::new(map)))
        }
    }
}

/// Return the JSON string representation of `s`.
fn json_stringify_string(s: &str) -> String {
    let mut out = String::with_capacity(s.len() + 2);
    out.push('"');
    for c in s.chars() {
        match c {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\x08' => out.push_str("\\b"),
            '\x0C' => out.push_str("\\f"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            c if (c as u32) < 0x20 => {
                let _ = write!(&mut out, "\\u{:04X}", c as u32);
            }
            c => out.push(c),
        }
    }
    out.push('"');
    out
}

/// Resolve `JSON.stringify` indentation from the `space` argument.
fn json_stringify_indent(space: Option<&JsValue>) -> String {
    const MAX_GAP: usize = 10;

    match space {
        Some(JsValue::Smi(n)) => " "
            .repeat((*n).max(0) as usize)
            .chars()
            .take(MAX_GAP)
            .collect(),
        Some(JsValue::HeapNumber(n)) => {
            let count = n.clamp(0.0, MAX_GAP as f64).trunc() as usize;
            " ".repeat(count)
        }
        Some(JsValue::String(s)) => s.chars().take(MAX_GAP).collect(),
        _ => String::new(),
    }
}

/// Collect the property allow-list from a replacer array.
fn json_stringify_property_list(replacer: Option<&JsValue>) -> StatorResult<Vec<String>> {
    let Some(replacer) = replacer else {
        return Ok(Vec::new());
    };
    if !is_js_array(replacer)? {
        return Ok(Vec::new());
    }

    let (elements, _) = to_array_like_elements(replacer);
    let mut properties = Vec::new();
    for element in elements {
        let property = match element {
            JsValue::String(s) => Some(s.to_string()),
            JsValue::Smi(n) => Some(n.to_string()),
            JsValue::HeapNumber(n) if n.is_finite() => Some(number_to_string(n)),
            _ => None,
        };
        if let Some(property) = property
            && !properties.iter().any(|existing| existing == &property)
        {
            properties.push(property);
        }
    }
    Ok(properties)
}

/// Read a JSON-visible property from `holder`.
fn json_get_property(holder: &JsValue, key: &str) -> StatorResult<JsValue> {
    dispatch_get_property_value(holder, JsValue::String(key.to_string().into()))
}

/// Return a stable identity key for circular JSON detection.
fn json_identity_key(value: &JsValue) -> Option<usize> {
    match value {
        JsValue::Array(items) => Some(Rc::as_ptr(items) as usize),
        JsValue::PlainObject(map) => Some(Rc::as_ptr(map) as usize),
        JsValue::Object(ptr) => Some(*ptr as usize),
        _ => None,
    }
}

/// Return the callable `toJSON` method for `value`, if present.
fn json_get_to_json(value: &JsValue) -> StatorResult<Option<JsValue>> {
    if matches!(value, JsValue::Undefined | JsValue::Null | JsValue::TheHole) {
        return Ok(None);
    }
    let candidate = json_get_property(value, "toJSON")?;
    Ok(is_callable(&candidate).then_some(candidate))
}

/// Serialize a property using the ECMAScript `JSON.stringify` algorithm.
fn json_serialize_property(
    holder: &JsValue,
    key: &str,
    replacer_fn: Option<&JsValue>,
    property_list: Option<&[String]>,
    indent: &str,
    depth: usize,
    in_progress: &mut HashSet<usize>,
) -> StatorResult<Option<String>> {
    let mut value = json_get_property(holder, key)?;

    if let Some(to_json) = json_get_to_json(&value)? {
        value = call_callback_with_this(
            &to_json,
            value.clone(),
            vec![JsValue::String(key.to_string().into())],
        )?;
    }

    if let Some(replacer_fn) = replacer_fn {
        value = call_callback_with_this(
            replacer_fn,
            holder.clone(),
            vec![JsValue::String(key.to_string().into()), value],
        )?;
    }

    json_serialize_value(
        &value,
        replacer_fn,
        property_list,
        indent,
        depth,
        in_progress,
    )
}

/// Serialize a JavaScript value to a JSON string fragment.
fn json_serialize_value(
    value: &JsValue,
    replacer_fn: Option<&JsValue>,
    property_list: Option<&[String]>,
    indent: &str,
    depth: usize,
    in_progress: &mut HashSet<usize>,
) -> StatorResult<Option<String>> {
    match value {
        JsValue::Undefined
        | JsValue::TheHole
        | JsValue::Symbol(_)
        | JsValue::Function(_)
        | JsValue::NativeFunction(_)
        | JsValue::Generator(_)
        | JsValue::Iterator(_)
        | JsValue::Error(_)
        | JsValue::Promise(_)
        | JsValue::Context(_)
        | JsValue::ArrayBuffer(_)
        | JsValue::TypedArray(_)
        | JsValue::DataView(_) => Ok(None),
        JsValue::Null => Ok(Some("null".to_string())),
        JsValue::Boolean(b) => Ok(Some(if *b { "true" } else { "false" }.to_string())),
        JsValue::Smi(n) => Ok(Some(n.to_string())),
        JsValue::HeapNumber(n) => Ok(Some(if n.is_finite() {
            number_to_string(*n)
        } else {
            "null".to_string()
        })),
        JsValue::String(s) => Ok(Some(json_stringify_string(s))),
        JsValue::BigInt(_) => Err(StatorError::TypeError(
            "Do not know how to serialize a BigInt".to_string(),
        )),
        // §25.5.2: Proxy objects are serialized through their traps, like
        // regular objects.  We read ownKeys via the trap, then get each
        // property through the get trap, producing the same output as a
        // PlainObject with those enumerable properties.
        JsValue::Proxy(proxy) => {
            let identity = Rc::as_ptr(proxy) as usize;
            if !in_progress.insert(identity) {
                return Err(StatorError::TypeError(
                    "Converting circular structure to JSON".to_string(),
                ));
            }

            let result = (|| {
                let holder = JsValue::Proxy(Rc::clone(proxy));
                let keys = proxy_own_keys(&proxy.borrow())?;
                let key_strings: Vec<String> = keys
                    .iter()
                    .filter_map(|k| match k {
                        JsValue::String(s) => Some(s.to_string()),
                        JsValue::Smi(n) => Some(n.to_string()),
                        _ => None,
                    })
                    .collect();
                let use_indent = !indent.is_empty();
                let inner_indent = indent.repeat(depth + 1);
                let outer_indent = indent.repeat(depth);

                let keys = if let Some(property_list) = property_list {
                    property_list.to_vec()
                } else {
                    key_strings
                };

                let mut parts = Vec::new();
                for key in keys {
                    let child = json_serialize_property(
                        &holder,
                        &key,
                        replacer_fn,
                        property_list,
                        indent,
                        depth + 1,
                        in_progress,
                    )?;
                    if let Some(item) = child {
                        let key_str = json_stringify_string(&key);
                        if use_indent {
                            parts.push(format!("{key_str}: {item}"));
                        } else {
                            parts.push(format!("{key_str}:{item}"));
                        }
                    }
                }

                if parts.is_empty() {
                    Ok(Some("{}".to_string()))
                } else if use_indent {
                    let joined = parts.join(&format!(",\n{inner_indent}"));
                    Ok(Some(format!(
                        "{{\n{inner_indent}{joined}\n{outer_indent}}}"
                    )))
                } else {
                    Ok(Some(format!("{{{}}}", parts.join(","))))
                }
            })();

            in_progress.remove(&identity);
            result
        }
        JsValue::Array(items) => {
            let Some(identity) = json_identity_key(value) else {
                unreachable!("arrays must have an identity key");
            };
            if !in_progress.insert(identity) {
                return Err(StatorError::TypeError(
                    "Converting circular structure to JSON".to_string(),
                ));
            }

            let result = (|| {
                let len = items.borrow().len();
                if len == 0 {
                    return Ok(Some("[]".to_string()));
                }

                let holder = JsValue::Array(Rc::clone(items));
                let use_indent = !indent.is_empty();
                let inner_indent = indent.repeat(depth + 1);
                let outer_indent = indent.repeat(depth);
                let mut parts = Vec::with_capacity(len);

                for index in 0..len {
                    let item = json_serialize_property(
                        &holder,
                        &index.to_string(),
                        replacer_fn,
                        property_list,
                        indent,
                        depth + 1,
                        in_progress,
                    )?;
                    parts.push(item.unwrap_or_else(|| "null".to_string()));
                }

                if use_indent {
                    let joined = parts.join(&format!(",\n{inner_indent}"));
                    Ok(Some(format!("[\n{inner_indent}{joined}\n{outer_indent}]")))
                } else {
                    Ok(Some(format!("[{}]", parts.join(","))))
                }
            })();

            in_progress.remove(&identity);
            result
        }
        JsValue::PlainObject(map) => {
            let Some(identity) = json_identity_key(value) else {
                unreachable!("plain objects must have an identity key");
            };
            if !in_progress.insert(identity) {
                return Err(StatorError::TypeError(
                    "Converting circular structure to JSON".to_string(),
                ));
            }

            let result = (|| {
                let holder = JsValue::PlainObject(Rc::clone(map));
                let use_indent = !indent.is_empty();
                let inner_indent = indent.repeat(depth + 1);
                let outer_indent = indent.repeat(depth);
                let keys: Vec<String> = if let Some(property_list) = property_list {
                    property_list.to_vec()
                } else {
                    map.borrow()
                        .enumerable_keys()
                        .map(|k| k.to_string())
                        .collect()
                };

                let mut parts = Vec::new();
                for key in keys {
                    let item = json_serialize_property(
                        &holder,
                        &key,
                        replacer_fn,
                        property_list,
                        indent,
                        depth + 1,
                        in_progress,
                    )?;
                    if let Some(item) = item {
                        let key = json_stringify_string(&key);
                        if use_indent {
                            parts.push(format!("{key}: {item}"));
                        } else {
                            parts.push(format!("{key}:{item}"));
                        }
                    }
                }

                if parts.is_empty() {
                    Ok(Some("{}".to_string()))
                } else if use_indent {
                    let joined = parts.join(&format!(",\n{inner_indent}"));
                    Ok(Some(format!(
                        "{{\n{inner_indent}{joined}\n{outer_indent}}}"
                    )))
                } else {
                    Ok(Some(format!("{{{}}}", parts.join(","))))
                }
            })();

            in_progress.remove(&identity);
            result
        }
        JsValue::Object(_) => Ok(Some("{}".to_string())),
    }
}

/// Stringify a JavaScript value using ECMAScript `JSON.stringify`.
fn json_stringify_runtime(
    value: &JsValue,
    replacer: Option<&JsValue>,
    space: Option<&JsValue>,
) -> StatorResult<Option<String>> {
    let replacer_fn = replacer.filter(|candidate| is_callable(candidate));
    let property_list_storage = json_stringify_property_list(replacer)?;
    let property_list =
        (!property_list_storage.is_empty()).then_some(property_list_storage.as_slice());
    let indent = json_stringify_indent(space);

    let mut wrapper = PropertyMap::new();
    wrapper.insert(String::new(), value.clone());
    let wrapper = JsValue::PlainObject(Rc::new(RefCell::new(wrapper)));
    let mut in_progress = HashSet::new();

    json_serialize_property(
        &wrapper,
        "",
        replacer_fn,
        property_list,
        &indent,
        0,
        &mut in_progress,
    )
}

/// Build the `JSON` namespace object.
#[inline(never)]
fn make_json() -> JsValue {
    use crate::builtins::json::json_parse;

    let mut props = PropertyMap::new();

    props.insert(
        "parse".into(),
        native(|args| {
            let text = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
            let json_val = json_parse(&text, None)?;
            let js_val = json_value_to_js_value(&json_val);

            // §25.5.1 — apply the optional reviver function bottom-up.
            match args.get(1) {
                Some(reviver) if is_callable(reviver) => {
                    let mut wrapper = PropertyMap::new();
                    wrapper.insert(String::new(), js_val);
                    let wrapper = JsValue::PlainObject(Rc::new(RefCell::new(wrapper)));
                    apply_js_reviver(&wrapper, "", reviver)
                }
                _ => Ok(js_val),
            }
        }),
    );
    props.insert(
        "stringify".into(),
        native(|args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);

            match json_stringify_runtime(val, args.get(1), args.get(2))? {
                Some(s) => Ok(JsValue::String(s.into())),
                None => Ok(JsValue::Undefined),
            }
        }),
    );

    // §25.5.3 JSON[@@toStringTag] = "JSON"
    props.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String("JSON".into()),
        PropertyAttributes::CONFIGURABLE,
    );

    // §25.5.2.2 JSON.rawJSON(string)  — ES2025
    // Returns a "raw JSON" object with a single `rawJSON` property.
    props.insert(
        "rawJSON".into(),
        builtin_fn("rawJSON", 1, |args| {
            let text = args.first().unwrap_or(&JsValue::Undefined);
            let s = text.to_js_string()?;
            let mut obj = PropertyMap::new();
            obj.insert("rawJSON".into(), JsValue::String(s.into()));
            obj.insert("__is_raw_json__".into(), JsValue::Boolean(true));
            Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
        }),
    );

    // §25.5.2.1 JSON.isRawJSON(value)  — ES2025
    // Returns true if `value` is a raw JSON object created by `JSON.rawJSON`.
    props.insert(
        "isRawJSON".into(),
        builtin_fn("isRawJSON", 1, |args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            let is_raw = match val {
                JsValue::PlainObject(map) => map
                    .borrow()
                    .get("__is_raw_json__")
                    .is_some_and(|v| matches!(v, JsValue::Boolean(true))),
                _ => false,
            };
            Ok(JsValue::Boolean(is_raw))
        }),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Walk a `JsValue` tree bottom-up, calling `reviver(key, value)` at each
/// node — the ECMAScript `InternalizeJSONProperty` algorithm (§25.5.1.1).
fn apply_js_reviver(holder: &JsValue, key: &str, reviver: &JsValue) -> StatorResult<JsValue> {
    let value = json_get_property(holder, key)?;
    let value = match value {
        JsValue::PlainObject(map) => {
            let keys: Vec<String> = map.borrow().keys().map(|k| k.to_string()).collect();
            let object = JsValue::PlainObject(Rc::clone(&map));
            for property in keys {
                let revived = apply_js_reviver(&object, &property, reviver)?;
                if revived.is_undefined() {
                    map.borrow_mut().remove(&property);
                } else {
                    map.borrow_mut().insert(property, revived);
                }
            }
            object
        }
        JsValue::Array(items) => {
            let array = JsValue::Array(Rc::clone(&items));
            let len = items.borrow().len();
            for index in 0..len {
                let revived = apply_js_reviver(&array, &index.to_string(), reviver)?;
                if revived.is_undefined() {
                    array_like_delete_index(&array, index);
                } else {
                    array_like_set_index(&array, index, revived);
                }
            }
            array
        }
        other => other,
    };
    call_callback_with_this(
        reviver,
        holder.clone(),
        vec![JsValue::String(key.to_string().into()), value],
    )
}

// ── Date constructor ─────────────────────────────────────────────────────────

/// Create a Date prototype method that delegates to the instance's own method.
///
/// When `Date.prototype.<method>.call(dateInstance, ...)` is invoked, the
/// generated closure locates the same-named `NativeFunction` on the Date
/// instance and forwards the remaining arguments.
fn date_proto_delegate(name: &str) -> JsValue {
    let name = name.to_string();
    native(move |args| {
        let this = args.first().cloned().unwrap_or(JsValue::Undefined);
        if name == "toJSON" {
            let primitive = this.to_primitive(ToPrimitiveHint::Number)?;
            if matches!(primitive, JsValue::HeapNumber(n) if !n.is_finite()) {
                return Ok(JsValue::Null);
            }

            let to_iso = dispatch_get_property_value(&this, JsValue::String("toISOString".into()))?;
            if !is_callable(&to_iso) {
                return Err(StatorError::TypeError(
                    "toISOString is not callable".to_string(),
                ));
            }
            return dispatch_call_with_this(&to_iso, this, Vec::new());
        }

        if let JsValue::PlainObject(map) = &this
            && let Some(JsValue::NativeFunction(f)) = map.borrow().get(&name).cloned()
        {
            let rest: Vec<JsValue> = args.get(1..).unwrap_or(&[]).to_vec();
            return f(rest);
        }
        Err(StatorError::TypeError(
            "this is not a Date object".to_string(),
        ))
    })
}

/// Build the `Date` constructor/namespace object.
///
/// The returned `PlainObject` has:
/// - `__call__`: the constructor (`new Date(...)` / `Date()`)
/// - `now`: `Date.now()`
/// - `parse`: `Date.parse(string)`
/// - `UTC`: `Date.UTC(year, month, ...)`
#[inline(never)]
fn make_date() -> JsValue {
    let mut props = PropertyMap::new();

    // ── Constructor: new Date() / Date(value) / Date(y, m, d, ...) ──────
    props.insert(
        "__call__".into(),
        native(|args| {
            let timestamp = match args.len() {
                0 => date_construct_now(),
                1 => {
                    let arg = args.first().unwrap();
                    if let JsValue::PlainObject(map) = arg
                        && matches!(
                            map.borrow().get("__is_date__"),
                            Some(JsValue::Boolean(true))
                        )
                    {
                        let get_time = map.borrow().get("getTime").cloned();
                        match get_time {
                            Some(get_time) => {
                                let copied =
                                    dispatch_call_with_this(&get_time, arg.clone(), Vec::new())?;
                                date_construct_value(copied.to_number()?)
                            }
                            None => f64::NAN,
                        }
                    } else {
                        let primitive = arg.to_primitive(ToPrimitiveHint::Default)?;
                        match primitive {
                            JsValue::String(s) => date_parse(&s),
                            _ => date_construct_value(primitive.to_number()?),
                        }
                    }
                }
                _ => {
                    let year = args[0].to_number()?;
                    let month = args[1].to_number()?;
                    let date_val = args
                        .get(2)
                        .map(|v| v.to_number())
                        .transpose()?
                        .unwrap_or(1.0);
                    let hours = args
                        .get(3)
                        .map(|v| v.to_number())
                        .transpose()?
                        .unwrap_or(0.0);
                    let minutes = args
                        .get(4)
                        .map(|v| v.to_number())
                        .transpose()?
                        .unwrap_or(0.0);
                    let seconds = args
                        .get(5)
                        .map(|v| v.to_number())
                        .transpose()?
                        .unwrap_or(0.0);
                    let ms = args
                        .get(6)
                        .map(|v| v.to_number())
                        .transpose()?
                        .unwrap_or(0.0);
                    date_construct_components(year, month, date_val, hours, minutes, seconds, ms)
                }
            };
            Ok(make_date_instance(timestamp))
        }),
    );

    // ── Date.now() ──────────────────────────────────────────────────────
    props.insert("now".into(), native(|_| Ok(num(date_now()))));

    // ── Date.parse(string) ──────────────────────────────────────────────
    props.insert(
        "parse".into(),
        native(|args| {
            let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
            Ok(num(date_parse(&s)))
        }),
    );

    // ── Date.UTC(year, month, ...) ──────────────────────────────────────
    props.insert(
        "UTC".into(),
        native(|args| {
            let year = arg_f64(&args, 0)?;
            let month = if args.len() > 1 {
                args[1].to_number()?
            } else {
                0.0
            };
            let date_val = if args.len() > 2 {
                args[2].to_number()?
            } else {
                1.0
            };
            let hours = if args.len() > 3 {
                args[3].to_number()?
            } else {
                0.0
            };
            let minutes = if args.len() > 4 {
                args[4].to_number()?
            } else {
                0.0
            };
            let seconds = if args.len() > 5 {
                args[5].to_number()?
            } else {
                0.0
            };
            let ms = if args.len() > 6 {
                args[6].to_number()?
            } else {
                0.0
            };
            Ok(num(date_utc(
                year, month, date_val, hours, minutes, seconds, ms,
            )))
        }),
    );

    // ── Date.prototype ──────────────────────────────────────────────────
    {
        let mut proto = PropertyMap::new();
        let date_methods: &[&str] = &[
            "getTime",
            "valueOf",
            "getFullYear",
            "getMonth",
            "getDate",
            "getDay",
            "getHours",
            "getMinutes",
            "getSeconds",
            "getMilliseconds",
            "getTimezoneOffset",
            "getUTCFullYear",
            "getUTCMonth",
            "getUTCDate",
            "getUTCDay",
            "getUTCHours",
            "getUTCMinutes",
            "getUTCSeconds",
            "getUTCMilliseconds",
            "setTime",
            "setMilliseconds",
            "setSeconds",
            "setMinutes",
            "setHours",
            "setDate",
            "setMonth",
            "setFullYear",
            "setUTCMilliseconds",
            "setUTCSeconds",
            "setUTCMinutes",
            "setUTCHours",
            "setUTCDate",
            "setUTCMonth",
            "setUTCFullYear",
            "toString",
            "toDateString",
            "toTimeString",
            "toISOString",
            "toUTCString",
            "toGMTString",
            "toJSON",
            "toLocaleDateString",
            "toLocaleString",
            "toLocaleTimeString",
            "@@toPrimitive",
        ];
        for method in date_methods {
            proto.insert((*method).into(), date_proto_delegate(method));
        }
        proto.insert("@@toStringTag".into(), JsValue::String("Date".into()));
        proto.make_all_non_enumerable();
        let proto_rc = Rc::new(RefCell::new(proto));
        props.insert("prototype".into(), JsValue::PlainObject(proto_rc.clone()));
    }

    props.make_all_non_enumerable();
    let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
    // §20.4.3.3 Date.prototype.constructor
    if let JsValue::PlainObject(ref ctor_map) = ctor
        && let Some(JsValue::PlainObject(ref proto_map)) =
            ctor_map.borrow().get("prototype").cloned()
    {
        proto_map.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
    }
    ctor
}

/// Create a Date instance object with all prototype methods.
///
/// The returned `PlainObject` holds a shared `Rc<RefCell<f64>>` timestamp
/// that all getter/setter methods close over.
#[inline(never)]
fn make_date_instance(t: f64) -> JsValue {
    let inner = Rc::new(RefCell::new(t));
    let obj = Rc::new(RefCell::new(PropertyMap::new()));

    // §20.1.3.6 — identify as Date for Object.prototype.toString.
    obj.borrow_mut()
        .insert("@@toStringTag".into(), JsValue::String("Date".into()));

    // Mark as Date instance for instanceof checks.
    obj.borrow_mut().insert_with_attrs(
        "__is_date__".into(),
        JsValue::Boolean(true),
        PropertyAttributes::empty(),
    );

    // ── getTime / valueOf ────────────────────────────────────────────────
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getTime".into(),
            native(move |_| Ok(num(date_get_time(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "valueOf".into(),
            native(move |_| Ok(num(date_value_of(*inner.borrow())))),
        );
    }

    // ── Local getters ───────────────────────────────────────────────────
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getFullYear".into(),
            native(move |_| Ok(num(date_get_full_year(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getMonth".into(),
            native(move |_| Ok(num(date_get_month(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getDate".into(),
            native(move |_| Ok(num(date_get_date(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getDay".into(),
            native(move |_| Ok(num(date_get_day(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getHours".into(),
            native(move |_| Ok(num(date_get_hours(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getMinutes".into(),
            native(move |_| Ok(num(date_get_minutes(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getSeconds".into(),
            native(move |_| Ok(num(date_get_seconds(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getMilliseconds".into(),
            native(move |_| Ok(num(date_get_milliseconds(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getTimezoneOffset".into(),
            native(move |_| Ok(num(date_get_timezone_offset(*inner.borrow())))),
        );
    }

    // ── UTC getters ─────────────────────────────────────────────────────
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getUTCFullYear".into(),
            native(move |_| Ok(num(date_get_utc_full_year(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getUTCMonth".into(),
            native(move |_| Ok(num(date_get_utc_month(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getUTCDate".into(),
            native(move |_| Ok(num(date_get_utc_date(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getUTCDay".into(),
            native(move |_| Ok(num(date_get_utc_day(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getUTCHours".into(),
            native(move |_| Ok(num(date_get_utc_hours(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getUTCMinutes".into(),
            native(move |_| Ok(num(date_get_utc_minutes(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getUTCSeconds".into(),
            native(move |_| Ok(num(date_get_utc_seconds(*inner.borrow())))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "getUTCMilliseconds".into(),
            native(move |_| Ok(num(date_get_utc_milliseconds(*inner.borrow())))),
        );
    }

    // ── Local setters ───────────────────────────────────────────────────
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setTime".into(),
            native(move |args| {
                let v = arg_f64(&args, 0)?;
                let result = date_set_time(v);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setMilliseconds".into(),
            native(move |args| {
                let ms = arg_f64(&args, 0)?;
                let result = date_set_milliseconds(*inner.borrow(), ms);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setSeconds".into(),
            native(move |args| {
                let sec = arg_f64(&args, 0)?;
                let ms = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let result = date_set_seconds(*inner.borrow(), sec, ms);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setMinutes".into(),
            native(move |args| {
                let min = arg_f64(&args, 0)?;
                let sec = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let ms = if args.len() > 2 {
                    Some(args[2].to_number()?)
                } else {
                    None
                };
                let result = date_set_minutes(*inner.borrow(), min, sec, ms);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setHours".into(),
            native(move |args| {
                let hour = arg_f64(&args, 0)?;
                let min = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let sec = if args.len() > 2 {
                    Some(args[2].to_number()?)
                } else {
                    None
                };
                let ms = if args.len() > 3 {
                    Some(args[3].to_number()?)
                } else {
                    None
                };
                let result = date_set_hours(*inner.borrow(), hour, min, sec, ms);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setDate".into(),
            native(move |args| {
                let date_val = arg_f64(&args, 0)?;
                let result = date_set_date(*inner.borrow(), date_val);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setMonth".into(),
            native(move |args| {
                let month = arg_f64(&args, 0)?;
                let date_val = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let result = date_set_month(*inner.borrow(), month, date_val);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setFullYear".into(),
            native(move |args| {
                let year = arg_f64(&args, 0)?;
                let month = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let date_val = if args.len() > 2 {
                    Some(args[2].to_number()?)
                } else {
                    None
                };
                let result = date_set_full_year(*inner.borrow(), year, month, date_val);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }

    // ── UTC setters ─────────────────────────────────────────────────────
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setUTCMilliseconds".into(),
            native(move |args| {
                let ms = arg_f64(&args, 0)?;
                let result = date_set_utc_milliseconds(*inner.borrow(), ms);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setUTCSeconds".into(),
            native(move |args| {
                let sec = arg_f64(&args, 0)?;
                let ms = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let result = date_set_utc_seconds(*inner.borrow(), sec, ms);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setUTCMinutes".into(),
            native(move |args| {
                let min = arg_f64(&args, 0)?;
                let sec = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let ms = if args.len() > 2 {
                    Some(args[2].to_number()?)
                } else {
                    None
                };
                let result = date_set_utc_minutes(*inner.borrow(), min, sec, ms);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setUTCHours".into(),
            native(move |args| {
                let hour = arg_f64(&args, 0)?;
                let min = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let sec = if args.len() > 2 {
                    Some(args[2].to_number()?)
                } else {
                    None
                };
                let ms = if args.len() > 3 {
                    Some(args[3].to_number()?)
                } else {
                    None
                };
                let result = date_set_utc_hours(*inner.borrow(), hour, min, sec, ms);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setUTCDate".into(),
            native(move |args| {
                let date_val = arg_f64(&args, 0)?;
                let result = date_set_utc_date(*inner.borrow(), date_val);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setUTCMonth".into(),
            native(move |args| {
                let month = arg_f64(&args, 0)?;
                let date_val = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let result = date_set_utc_month(*inner.borrow(), month, date_val);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "setUTCFullYear".into(),
            native(move |args| {
                let year = arg_f64(&args, 0)?;
                let month = if args.len() > 1 {
                    Some(args[1].to_number()?)
                } else {
                    None
                };
                let date_val = if args.len() > 2 {
                    Some(args[2].to_number()?)
                } else {
                    None
                };
                let result = date_set_utc_full_year(*inner.borrow(), year, month, date_val);
                *inner.borrow_mut() = result;
                Ok(num(result))
            }),
        );
    }

    // ── String conversion methods ───────────────────────────────────────
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toString".into(),
            native(move |_| Ok(JsValue::String(date_to_string(*inner.borrow()).into()))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toDateString".into(),
            native(move |_| Ok(JsValue::String(date_to_date_string(*inner.borrow()).into()))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toTimeString".into(),
            native(move |_| Ok(JsValue::String(date_to_time_string(*inner.borrow()).into()))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toISOString".into(),
            native(move |_| Ok(JsValue::String(date_to_iso_string(*inner.borrow())?.into()))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toUTCString".into(),
            native(move |_| Ok(JsValue::String(date_to_utc_string(*inner.borrow()).into()))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toGMTString".into(),
            native(move |_| Ok(JsValue::String(date_to_utc_string(*inner.borrow()).into()))),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toLocaleDateString".into(),
            native(move |_| {
                Ok(JsValue::String(
                    date_to_locale_date_string(*inner.borrow()).into(),
                ))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toLocaleString".into(),
            native(move |_| {
                Ok(JsValue::String(
                    date_to_locale_string(*inner.borrow()).into(),
                ))
            }),
        );
    }
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "toLocaleTimeString".into(),
            native(move |_| {
                Ok(JsValue::String(
                    date_to_locale_time_string(*inner.borrow()).into(),
                ))
            }),
        );
    }

    // §20.4.4.45 Date.prototype[@@toPrimitive](hint)
    {
        let inner = Rc::clone(&inner);
        obj.borrow_mut().insert(
            "@@toPrimitive".into(),
            native(move |args| {
                let hint = match args.get(1).or_else(|| args.first()) {
                    Some(JsValue::String(s)) => s.to_string(),
                    _ => "default".to_string(),
                };
                date_to_primitive(*inner.borrow(), &hint)
            }),
        );
    }

    obj.borrow_mut().make_all_non_enumerable();
    JsValue::PlainObject(obj)
}

// ── Number constructor ───────────────────────────────────────────────────────

/// Build the `Number` constructor/namespace object.
/// §20.3 Boolean constructor – `Boolean(value)` performs `ToBoolean`.
#[inline(never)]
fn make_boolean() -> JsValue {
    let mut props = PropertyMap::new();

    // Boolean(value) — type conversion when called as a function / constructor
    props.insert(
        "__call__".into(),
        native(|args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            Ok(JsValue::Boolean(val.to_boolean()))
        }),
    );

    let mut proto = PropertyMap::new();
    proto.insert(
        "toString".into(),
        native(|args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            match val {
                JsValue::Boolean(b) => Ok(JsValue::String(b.to_string().into())),
                JsValue::PlainObject(map) => match map.borrow().get("[[PrimitiveValue]]") {
                    Some(JsValue::Boolean(b)) => Ok(JsValue::String(b.to_string().into())),
                    _ => Err(StatorError::TypeError(
                        "Boolean.prototype.toString requires that 'this' be a Boolean".into(),
                    )),
                },
                _ => Err(StatorError::TypeError(
                    "Boolean.prototype.toString requires that 'this' be a Boolean".into(),
                )),
            }
        }),
    );
    proto.insert(
        "valueOf".into(),
        native(|args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            match val {
                JsValue::Boolean(b) => Ok(JsValue::Boolean(*b)),
                JsValue::PlainObject(map) => match map.borrow().get("[[PrimitiveValue]]") {
                    Some(JsValue::Boolean(b)) => Ok(JsValue::Boolean(*b)),
                    _ => Err(StatorError::TypeError(
                        "Boolean.prototype.valueOf requires that 'this' be a Boolean".into(),
                    )),
                },
                _ => Err(StatorError::TypeError(
                    "Boolean.prototype.valueOf requires that 'this' be a Boolean".into(),
                )),
            }
        }),
    );
    proto.make_all_non_enumerable();
    let proto_rc = Rc::new(RefCell::new(proto));
    props.insert("prototype".into(), JsValue::PlainObject(proto_rc.clone()));

    props.make_all_non_enumerable();
    let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
    // §20.1.3.2 Boolean.prototype.constructor
    proto_rc.borrow_mut().insert_with_attrs(
        "constructor".into(),
        ctor.clone(),
        PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
    );
    ctor
}

#[inline(never)]
fn make_number() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // Number(value) — type conversion when called as a function
        props.insert(
            "__call__".into(),
            native(|args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                if matches!(val, JsValue::Undefined) && args.is_empty() {
                    return Ok(JsValue::Smi(0));
                }
                Ok(num(val.to_number()?))
            }),
        );

        // Number.isNaN — does NOT coerce (unlike global isNaN)
        props.insert(
            "isNaN".into(),
            builtin_fn("isNaN", 1, |args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                let result = match val {
                    JsValue::HeapNumber(n) => n.is_nan(),
                    _ => false,
                };
                Ok(JsValue::Boolean(result))
            }),
        );
        // Number.isFinite — does NOT coerce
        props.insert(
            "isFinite".into(),
            builtin_fn("isFinite", 1, |args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                let result = match val {
                    JsValue::Smi(_) => true,
                    JsValue::HeapNumber(n) => n.is_finite(),
                    _ => false,
                };
                Ok(JsValue::Boolean(result))
            }),
        );
        // Number.isInteger
        props.insert(
            "isInteger".into(),
            native(|args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                let result = match val {
                    JsValue::Smi(_) => true,
                    JsValue::HeapNumber(n) => n.is_finite() && n.fract() == 0.0,
                    _ => false,
                };
                Ok(JsValue::Boolean(result))
            }),
        );
        // Number.isSafeInteger
        props.insert(
            "isSafeInteger".into(),
            native(|args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                let result = match val {
                    JsValue::Smi(_) => true,
                    JsValue::HeapNumber(n) => number_is_safe_integer(*n),
                    _ => false,
                };
                Ok(JsValue::Boolean(result))
            }),
        );
        // Number.parseInt
        props.insert(
            "parseInt".into(),
            builtin_fn("parseInt", 2, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                let radix = if args.len() > 1 {
                    let r = args[1].to_number()?;
                    if r.is_nan() || r == 0.0 {
                        0
                    } else {
                        r.floor() as i32
                    }
                } else {
                    0
                };
                Ok(num(global_parse_int(&s, radix)))
            }),
        );
        // Number.parseFloat
        props.insert(
            "parseFloat".into(),
            builtin_fn("parseFloat", 1, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(num(global_parse_float(&s)))
            }),
        );

        // Constants
        props.insert(
            "MAX_SAFE_INTEGER".into(),
            JsValue::HeapNumber(9_007_199_254_740_991.0),
        );
        props.insert(
            "MIN_SAFE_INTEGER".into(),
            JsValue::HeapNumber(-9_007_199_254_740_991.0),
        );
        props.insert("MAX_VALUE".into(), JsValue::HeapNumber(f64::MAX));
        props.insert("MIN_VALUE".into(), JsValue::HeapNumber(5e-324));
        props.insert("EPSILON".into(), JsValue::HeapNumber(f64::EPSILON));
        props.insert(
            "POSITIVE_INFINITY".into(),
            JsValue::HeapNumber(f64::INFINITY),
        );
        props.insert(
            "NEGATIVE_INFINITY".into(),
            JsValue::HeapNumber(f64::NEG_INFINITY),
        );
        props.insert("NaN".into(), JsValue::HeapNumber(f64::NAN));

        // ── Number.prototype ─────────────────────────────────────────────────
        let num_proto_rc = {
            let mut proto = PropertyMap::new();

            // Helper: extract the numeric value from `this` (args[0]).
            fn this_number_value(args: &[JsValue]) -> StatorResult<f64> {
                match args.first().unwrap_or(&JsValue::Undefined) {
                    JsValue::Smi(n) => Ok(*n as f64),
                    JsValue::HeapNumber(n) => Ok(*n),
                    JsValue::PlainObject(map) => match map.borrow().get("[[PrimitiveValue]]") {
                        Some(JsValue::Smi(n)) => Ok(*n as f64),
                        Some(JsValue::HeapNumber(n)) => Ok(*n),
                        _ => Err(crate::error::StatorError::TypeError(
                            "Number.prototype method requires that 'this' be a Number".to_string(),
                        )),
                    },
                    _ => Err(crate::error::StatorError::TypeError(
                        "Number.prototype method requires that 'this' be a Number".to_string(),
                    )),
                }
            }

            // Number.prototype.toString([radix])
            proto.insert(
                "toString".into(),
                native(|args| {
                    let n = this_number_value(&args)?;
                    let radix = match args.get(1) {
                        None | Some(JsValue::Undefined) => 10u32,
                        Some(v) => {
                            let r = v.to_number()?;
                            let ri = r.floor() as i64;
                            if !(2..=36).contains(&ri) {
                                return Err(StatorError::RangeError(
                                    "toString() radix must be between 2 and 36".to_string(),
                                ));
                            }
                            ri as u32
                        }
                    };
                    if radix == 10 {
                        if n.fract() == 0.0
                            && !n.is_nan()
                            && !n.is_infinite()
                            && n.abs() < i64::MAX as f64
                        {
                            return Ok(JsValue::String((n as i64).to_string().into()));
                        }
                        return Ok(JsValue::String(format!("{n}").into()));
                    }
                    if n.fract() == 0.0
                        && !n.is_nan()
                        && !n.is_infinite()
                        && n.abs() < i64::MAX as f64
                    {
                        Ok(JsValue::String(
                            crate::builtins::util::i64_to_radix_string(n as i64, radix).into(),
                        ))
                    } else {
                        Ok(JsValue::String(
                            crate::builtins::util::f64_to_radix_string(n, radix).into(),
                        ))
                    }
                }),
            );

            // Number.prototype.valueOf()
            proto.insert(
                "valueOf".into(),
                native(|args| {
                    let n = this_number_value(&args)?;
                    Ok(num(n))
                }),
            );

            // Number.prototype.toFixed([digits])
            // ES2023 §21.1.3.3
            proto.insert(
                "toFixed".into(),
                native(|args| {
                    let n = this_number_value(&args)?;
                    let digits = match args.get(1) {
                        None | Some(JsValue::Undefined) => 0.0,
                        Some(value) => value.to_integer_or_infinity()?,
                    };
                    if !digits.is_finite() || !(0.0..=100.0).contains(&digits) {
                        return Err(StatorError::RangeError(
                            "toFixed() digits argument must be between 0 and 100".to_string(),
                        ));
                    }
                    Ok(JsValue::String(number_to_fixed(n, digits as u32)?.into()))
                }),
            );

            // Number.prototype.toExponential([fractionDigits])
            proto.insert(
                "toExponential".into(),
                native(|args| {
                    let n = this_number_value(&args)?;
                    let digits = match args.get(1) {
                        None | Some(JsValue::Undefined) => None,
                        Some(value) => {
                            let digits = value.to_integer_or_infinity()?;
                            if !digits.is_finite() || !(0.0..=100.0).contains(&digits) {
                                return Err(StatorError::RangeError(
                                    "toExponential() fractionDigits must be between 0 and 100"
                                        .to_string(),
                                ));
                            }
                            Some(digits as u32)
                        }
                    };
                    match digits {
                        Some(d) => Ok(JsValue::String(number_to_exponential(n, d)?.into())),
                        None => {
                            if n.is_nan() {
                                return Ok(JsValue::String("NaN".into()));
                            }
                            if n.is_infinite() {
                                return Ok(JsValue::String(
                                    if n > 0.0 { "Infinity" } else { "-Infinity" }.into(),
                                ));
                            }
                            // No argument: let Rust pick minimal fraction digits,
                            // then reformat to ECMAScript style.
                            let raw = format!("{n:e}");
                            Ok(JsValue::String(number_reformat_exponential(&raw).into()))
                        }
                    }
                }),
            );

            // Number.prototype.toPrecision([precision])
            proto.insert(
                "toPrecision".into(),
                native(|args| {
                    let n = this_number_value(&args)?;
                    match args.get(1) {
                        None | Some(JsValue::Undefined) => {
                            // No argument: return ToString(n).
                            Ok(JsValue::String(
                                JsValue::HeapNumber(n).to_js_string()?.into(),
                            ))
                        }
                        Some(v) => {
                            let precision = v.to_integer_or_infinity()?;
                            if !precision.is_finite() || !(1.0..=100.0).contains(&precision) {
                                return Err(StatorError::RangeError(
                                    "toPrecision() argument must be between 1 and 100".to_string(),
                                ));
                            }
                            Ok(JsValue::String(
                                number_to_precision(n, precision as u32)?.into(),
                            ))
                        }
                    }
                }),
            );

            // Number.prototype.toLocaleString()
            proto.insert(
                "toLocaleString".into(),
                native(|args| {
                    let n = this_number_value(&args)?;
                    if n.fract() == 0.0
                        && !n.is_nan()
                        && !n.is_infinite()
                        && n.abs() < i64::MAX as f64
                    {
                        Ok(JsValue::String((n as i64).to_string().into()))
                    } else {
                        Ok(JsValue::String(format!("{n}").into()))
                    }
                }),
            );

            proto.make_all_non_enumerable();
            let num_proto_rc = Rc::new(RefCell::new(proto));
            props.insert(
                "prototype".into(),
                JsValue::PlainObject(num_proto_rc.clone()),
            );
            num_proto_rc
        };

        props.make_all_non_enumerable();
        let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
        // §21.1.3.1 Number.prototype.constructor
        num_proto_rc.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
        ctor
    })
}

// ── Object constructor ───────────────────────────────────────────────────────

/// Build the `Object` constructor/namespace object.
#[inline(never)]
fn make_object() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // Object(value) — type conversion / wrapping when called as a function or constructor.
        // §20.1.1.1: Object ( [ value ] )
        props.insert(
            "__call__".into(),
            native(|args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                match val {
                    // If value is undefined or null, return a new ordinary object.
                    JsValue::Undefined | JsValue::Null => Ok(JsValue::PlainObject(Rc::new(
                        RefCell::new(PropertyMap::new()),
                    ))),
                    // Otherwise, return ToObject(value) — wrapping primitives and
                    // returning object-like inputs as-is.
                    _ => val.to_object(),
                }
            }),
        );

        props.insert(
            "keys".into(),
            builtin_fn("keys", 1, |args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                if matches!(val, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }
                let keys = enumerable_own_string_keys(val)
                    .into_iter()
                    .map(|key| JsValue::String(key.into()))
                    .collect();
                Ok(JsValue::new_array(keys))
            }),
        );
        props.insert(
            "values".into(),
            builtin_fn("values", 1, |args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                if matches!(val, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }
                let mut values = Vec::new();
                for key in enumerable_own_string_keys(val) {
                    values.push(dispatch_get_property_value(
                        val,
                        JsValue::String(key.into()),
                    )?);
                }
                Ok(JsValue::new_array(values))
            }),
        );
        props.insert(
            "entries".into(),
            builtin_fn("entries", 1, |args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                if matches!(val, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }
                let mut entries = Vec::new();
                for key in enumerable_own_string_keys(val) {
                    let value =
                        dispatch_get_property_value(val, JsValue::String(key.clone().into()))?;
                    entries.push(JsValue::new_array(vec![JsValue::String(key.into()), value]));
                }
                Ok(JsValue::new_array(entries))
            }),
        );

        // ── Object.is(x, y) — SameValue comparison (ECMAScript §19.1.2.10) ──
        props.insert(
            "is".into(),
            builtin_fn("is", 2, |args| {
                let x = args.first().unwrap_or(&JsValue::Undefined);
                let y = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(JsValue::Boolean(x.same_value(y)))
            }),
        );

        /// Helper: apply a single property descriptor to a PlainObject.
        fn define_own_property(
            map: &Rc<RefCell<PropertyMap>>,
            key: &str,
            desc: &PropertyMap,
        ) -> StatorResult<()> {
            let has_get = desc.contains_key("get");
            let has_set = desc.contains_key("set");
            let has_value = desc.contains_key("value");
            let has_writable = desc.contains_key("writable");

            // §6.2.6.1 step 8: cannot have both accessor and data fields.
            if (has_get || has_set) && (has_value || has_writable) {
                return Err(crate::error::StatorError::TypeError(
                    "Invalid property descriptor. Cannot both specify accessors \
                     and a value or writable attribute"
                        .into(),
                ));
            }

            // Validate non-configurable invariants.
            // Accessor properties are stored as `__get_X__`/`__set_X__` keys, so
            // we must check those when the regular key `X` has been removed.
            {
                let borrow = map.borrow();
                let getter_key = format!("__get_{key}__");
                let setter_key = format!("__set_{key}__");
                let is_existing_accessor =
                    borrow.contains_key(&getter_key) || borrow.contains_key(&setter_key);
                let property_exists = borrow.contains_key(key) || is_existing_accessor;

                if property_exists {
                    // Resolve configurability from the correct backing key.
                    let currently_configurable = if borrow.contains_key(key) {
                        borrow.is_configurable(key)
                    } else if borrow.contains_key(&getter_key) {
                        borrow.is_configurable(&getter_key)
                    } else {
                        borrow.is_configurable(&setter_key)
                    };

                    if !currently_configurable {
                        // §10.1.6.3 step 6: cannot convert data↔accessor.
                        if (has_get || has_set) && !is_existing_accessor {
                            return Err(crate::error::StatorError::TypeError(format!(
                                "Cannot redefine property: {key}"
                            )));
                        }
                        if !has_get
                            && !has_set
                            && is_existing_accessor
                            && (desc.contains_key("value") || desc.contains_key("writable"))
                        {
                            return Err(crate::error::StatorError::TypeError(format!(
                                "Cannot redefine property: {key}"
                            )));
                        }
                        // §10.1.6.3 step 7: non-configurable, non-writable data
                        // property cannot be made writable.
                        if !is_existing_accessor
                            && !borrow.is_writable(key)
                            && desc.get("writable").is_some_and(|v| v.to_boolean())
                        {
                            return Err(crate::error::StatorError::TypeError(format!(
                                "Cannot redefine property: {key}"
                            )));
                        }
                        // Cannot change value of non-writable, non-configurable
                        // data property.
                        if !is_existing_accessor
                            && !borrow.is_writable(key)
                            && desc
                                .get("value")
                                .and_then(|new_val| {
                                    borrow.get(key).map(|old_val| !new_val.same_value(old_val))
                                })
                                .unwrap_or(false)
                        {
                            return Err(crate::error::StatorError::TypeError(format!(
                                "Cannot redefine property: {key}"
                            )));
                        }
                        // §10.1.6.3 step 4b: cannot change enumerable of
                        // non-configurable property.
                        if desc.contains_key("enumerable") {
                            let new_e = desc.get("enumerable").is_some_and(|v| v.to_boolean());
                            let current_e = if borrow.contains_key(key) {
                                borrow.is_enumerable(key)
                            } else if borrow.contains_key(&getter_key) {
                                borrow.is_enumerable(&getter_key)
                            } else {
                                borrow.is_enumerable(&setter_key)
                            };
                            if new_e != current_e {
                                return Err(crate::error::StatorError::TypeError(format!(
                                    "Cannot redefine property: {key}"
                                )));
                            }
                        }
                        // §10.1.6.3 step 4a: cannot change configurable false→true.
                        if desc.get("configurable").is_some_and(|v| v.to_boolean()) {
                            return Err(crate::error::StatorError::TypeError(format!(
                                "Cannot redefine property: {key}"
                            )));
                        }
                        // §10.1.6.3 step 8: non-configurable accessor — cannot
                        // change getter or setter.
                        if is_existing_accessor && (has_get || has_set) {
                            if has_get {
                                let new_get =
                                    desc.get("get").cloned().unwrap_or(JsValue::Undefined);
                                let cur_get = borrow
                                    .get(&getter_key)
                                    .cloned()
                                    .unwrap_or(JsValue::Undefined);
                                if !new_get.same_value(&cur_get) {
                                    return Err(crate::error::StatorError::TypeError(format!(
                                        "Cannot redefine property: {key}"
                                    )));
                                }
                            }
                            if has_set {
                                let new_set =
                                    desc.get("set").cloned().unwrap_or(JsValue::Undefined);
                                let cur_set = borrow
                                    .get(&setter_key)
                                    .cloned()
                                    .unwrap_or(JsValue::Undefined);
                                if !new_set.same_value(&cur_set) {
                                    return Err(crate::error::StatorError::TypeError(format!(
                                        "Cannot redefine property: {key}"
                                    )));
                                }
                            }
                        }
                    }
                }
            }

            if has_get || has_set {
                // Non-extensible: cannot add new accessor property on objects that
                // don't already have this key as an accessor.
                {
                    let borrow = map.borrow();
                    let getter_key = format!("__get_{key}__");
                    let setter_key = format!("__set_{key}__");
                    if !borrow.extensible
                        && !borrow.contains_key(key)
                        && !borrow.contains_key(&getter_key)
                        && !borrow.contains_key(&setter_key)
                    {
                        return Err(crate::error::StatorError::TypeError(format!(
                            "Cannot define property {key}, object is not extensible"
                        )));
                    }
                }
                let getter_key = format!("__get_{key}__");
                let setter_key = format!("__set_{key}__");
                let enumerable = desc.get("enumerable").is_some_and(|v| v.to_boolean());
                let configurable = desc.get("configurable").is_some_and(|v| v.to_boolean());
                let mut accessor_attrs = PropertyAttributes::empty();
                if enumerable {
                    accessor_attrs |= PropertyAttributes::ENUMERABLE;
                }
                if configurable {
                    accessor_attrs |= PropertyAttributes::CONFIGURABLE;
                }
                if let Some(getter) = desc.get("get").cloned() {
                    map.borrow_mut()
                        .insert_with_attrs(getter_key, getter, accessor_attrs);
                }
                if let Some(setter) = desc.get("set").cloned() {
                    map.borrow_mut()
                        .insert_with_attrs(setter_key, setter, accessor_attrs);
                }
                map.borrow_mut().remove(key);
            } else {
                let writable_val = desc.get("writable").map(|v| v.to_boolean());
                let enumerable_val = desc.get("enumerable").map(|v| v.to_boolean());
                let configurable_val = desc.get("configurable").map(|v| v.to_boolean());

                if !map.borrow().contains_key(key) {
                    // Check whether the property already exists as an accessor
                    // (stored under `__get_X__`/`__set_X__`).  Redefining an
                    // existing accessor as a data property is allowed even on
                    // non-extensible objects; only truly new properties are
                    // blocked.
                    let getter_key = format!("__get_{key}__");
                    let setter_key = format!("__set_{key}__");
                    let is_existing_accessor = {
                        let borrow = map.borrow();
                        borrow.contains_key(&getter_key) || borrow.contains_key(&setter_key)
                    };
                    if !map.borrow().extensible && !is_existing_accessor {
                        return Err(crate::error::StatorError::TypeError(format!(
                            "Cannot define property {key}, object is not extensible"
                        )));
                    }
                    let value = if has_value {
                        desc.get("value").cloned().unwrap_or(JsValue::Undefined)
                    } else {
                        JsValue::Undefined
                    };
                    map.borrow_mut().remove(&getter_key);
                    map.borrow_mut().remove(&setter_key);
                    let mut attrs = PropertyAttributes::empty();
                    if writable_val.unwrap_or(false) {
                        attrs |= PropertyAttributes::WRITABLE;
                    }
                    if enumerable_val.unwrap_or(false) {
                        attrs |= PropertyAttributes::ENUMERABLE;
                    }
                    if configurable_val.unwrap_or(false) {
                        attrs |= PropertyAttributes::CONFIGURABLE;
                    }
                    map.borrow_mut()
                        .insert_with_attrs(key.to_string(), value, attrs);
                } else {
                    if has_value {
                        let value = desc.get("value").cloned().unwrap_or(JsValue::Undefined);
                        let getter_key = format!("__get_{key}__");
                        let setter_key = format!("__set_{key}__");
                        map.borrow_mut().remove(&getter_key);
                        map.borrow_mut().remove(&setter_key);
                        map.borrow_mut().insert(key.to_string(), value);
                    }
                    if let Some(w) = writable_val {
                        map.borrow_mut().set_writable(key, w);
                    }
                    if let Some(e) = enumerable_val {
                        map.borrow_mut().set_enumerable(key, e);
                    }
                    if let Some(c) = configurable_val {
                        map.borrow_mut().set_configurable(key, c);
                    }
                }
            }
            Ok(())
        }

        // ── Object.defineProperty(obj, prop, descriptor) ─────────────────────
        props.insert(
            "defineProperty".into(),
            builtin_fn("defineProperty", 3, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined).clone();
                let prop = args.get(1).unwrap_or(&JsValue::Undefined);
                let descriptor = args.get(2).unwrap_or(&JsValue::Undefined);

                // §20.1.2.4 step 1: target must be an object.
                if obj.is_primitive() {
                    return Err(crate::error::StatorError::TypeError(
                        "Object.defineProperty called on non-object".into(),
                    ));
                }

                let key = prop.to_property_key()?;

                // §20.1.2.4 step 3: descriptor must be an object.
                if descriptor.is_primitive() {
                    return Err(crate::error::StatorError::TypeError(
                        "Property description must be an object".into(),
                    ));
                }

                if let JsValue::PlainObject(map) = &obj {
                    if let JsValue::PlainObject(desc_map) = descriptor {
                        let desc = desc_map.borrow();
                        define_own_property(map, &key, &desc)?;
                    }
                    Ok(obj)
                } else if let JsValue::Array(items) = &obj {
                    // §10.4.2 Array Exotic Objects [[DefineOwnProperty]].
                    let items = Rc::clone(items);
                    if let JsValue::PlainObject(desc_map) = descriptor {
                        let desc = desc_map.borrow();
                        let has_value = desc.contains_key("value");
                        let has_writable = desc.contains_key("writable");
                        let has_get = desc.contains_key("get");
                        let has_set = desc.contains_key("set");

                        // Reject accessor descriptors on arrays (not supported
                        // without a full exotic-object wrapper).
                        if has_get || has_set {
                            return Err(crate::error::StatorError::TypeError(
                                "Cannot define accessor property on array".into(),
                            ));
                        }

                        if key == "length" {
                            // §10.4.2.4 ArraySetLength: apply length changes
                            // and writable narrowing on the compact Vec.
                            if has_writable {
                                let w = desc.get("writable").is_some_and(|v| v.to_boolean());
                                if !w && has_value {
                                    let new_len = desc
                                        .get("value")
                                        .unwrap_or(&JsValue::Undefined)
                                        .to_number()
                                        .unwrap_or(0.0)
                                        as usize;
                                    items.borrow_mut().truncate(new_len);
                                }
                            }
                            if has_value && !has_writable {
                                let new_len = desc
                                    .get("value")
                                    .unwrap_or(&JsValue::Undefined)
                                    .to_number()
                                    .unwrap_or(0.0)
                                    as usize;
                                let mut arr = items.borrow_mut();
                                if new_len < arr.len() {
                                    arr.truncate(new_len);
                                } else {
                                    arr.resize(new_len, JsValue::Undefined);
                                }
                            }
                        } else if let Ok(idx) = key.parse::<usize>() {
                            // Indexed property: update or extend the backing
                            // Vec with the provided value.
                            let value = if has_value {
                                desc.get("value").cloned().unwrap_or(JsValue::Undefined)
                            } else {
                                JsValue::Undefined
                            };
                            let mut arr = items.borrow_mut();
                            if idx < arr.len() {
                                arr[idx] = value;
                            } else {
                                arr.resize(idx, JsValue::Undefined);
                                arr.push(value);
                            }
                        }
                        // Non-index, non-length: no-op (compact Vec has no
                        // named-property storage).
                    }
                    Ok(obj)
                } else {
                    // Other non-PlainObject objects: return as-is.
                    Ok(obj)
                }
            }),
        );

        // ── Object.getOwnPropertyDescriptor(obj, prop) ──────────────────────
        props.insert(
            "getOwnPropertyDescriptor".into(),
            builtin_fn("getOwnPropertyDescriptor", 2, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                // §20.1.2.6 step 1: throw TypeError for null/undefined.
                if matches!(obj, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }
                let prop = args.get(1).unwrap_or(&JsValue::Undefined);

                let key = prop.to_property_key()?;

                // Helper to build a data descriptor.
                fn data_desc(
                    value: JsValue,
                    writable: bool,
                    enumerable: bool,
                    configurable: bool,
                ) -> JsValue {
                    let mut desc = PropertyMap::new();
                    desc.insert("value".into(), value);
                    desc.insert("writable".into(), JsValue::Boolean(writable));
                    desc.insert("enumerable".into(), JsValue::Boolean(enumerable));
                    desc.insert("configurable".into(), JsValue::Boolean(configurable));
                    JsValue::PlainObject(Rc::new(RefCell::new(desc)))
                }

                match obj {
                    JsValue::PlainObject(map) => {
                        let borrowed = map.borrow();
                        // Check for accessor property first
                        let getter_key = format!("__get_{key}__");
                        let setter_key = format!("__set_{key}__");
                        let has_getter = borrowed.contains_key(&getter_key);
                        let has_setter = borrowed.contains_key(&setter_key);
                        if has_getter || has_setter {
                            let mut desc = PropertyMap::new();
                            desc.insert(
                                "get".into(),
                                borrowed
                                    .get(&getter_key)
                                    .cloned()
                                    .unwrap_or(JsValue::Undefined),
                            );
                            desc.insert(
                                "set".into(),
                                borrowed
                                    .get(&setter_key)
                                    .cloned()
                                    .unwrap_or(JsValue::Undefined),
                            );
                            // Read attributes from the getter key (or setter
                            // key as fallback) where defineProperty stores them.
                            let attr_key = if has_getter { &getter_key } else { &setter_key };
                            desc.insert(
                                "enumerable".into(),
                                JsValue::Boolean(borrowed.is_enumerable(attr_key)),
                            );
                            desc.insert(
                                "configurable".into(),
                                JsValue::Boolean(borrowed.is_configurable(attr_key)),
                            );
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(desc))))
                        } else if let Some(value) = borrowed.get(&key) {
                            Ok(data_desc(
                                value.clone(),
                                borrowed.is_writable(&key),
                                borrowed.is_enumerable(&key),
                                borrowed.is_configurable(&key),
                            ))
                        } else {
                            Ok(JsValue::Undefined)
                        }
                    }
                    JsValue::Proxy(proxy) => {
                        match proxy_get_own_property_descriptor(&proxy.borrow(), &key)? {
                            Some((val, attrs)) => Ok(data_desc(
                                val,
                                attrs.contains(PropertyAttributes::WRITABLE),
                                attrs.contains(PropertyAttributes::ENUMERABLE),
                                attrs.contains(PropertyAttributes::CONFIGURABLE),
                            )),
                            None => Ok(JsValue::Undefined),
                        }
                    }
                    JsValue::Array(items) => {
                        if key == "length" {
                            Ok(data_desc(
                                JsValue::Smi(items.borrow().len() as i32),
                                true,
                                false,
                                false,
                            ))
                        } else if let Ok(idx) = key.parse::<usize>() {
                            let borrow = items.borrow();
                            if idx < borrow.len() {
                                Ok(data_desc(borrow[idx].clone(), true, true, true))
                            } else {
                                Ok(JsValue::Undefined)
                            }
                        } else {
                            Ok(JsValue::Undefined)
                        }
                    }
                    JsValue::Error(error) => match error_descriptor_value_and_attrs(error, &key) {
                        Some((value, attrs)) => Ok(data_desc(
                            value,
                            attrs.contains(PropertyAttributes::WRITABLE),
                            attrs.contains(PropertyAttributes::ENUMERABLE),
                            attrs.contains(PropertyAttributes::CONFIGURABLE),
                        )),
                        None => Ok(JsValue::Undefined),
                    },
                    JsValue::Function(ba) => {
                        if key == "length" {
                            Ok(data_desc(
                                JsValue::Smi(ba.parameter_count() as i32),
                                false,
                                false,
                                true,
                            ))
                        } else if key == "name" {
                            Ok(data_desc(JsValue::String("".into()), false, false, true))
                        } else {
                            Ok(JsValue::Undefined)
                        }
                    }
                    JsValue::String(s) => {
                        let length = utf16_len(s);
                        if key == "length" {
                            Ok(data_desc(JsValue::Smi(length as i32), false, false, false))
                        } else if let Ok(idx) = key.parse::<usize>() {
                            if idx < length {
                                let ch = string_char_at(s, idx as i64);
                                Ok(data_desc(JsValue::String(ch.into()), false, true, false))
                            } else {
                                Ok(JsValue::Undefined)
                            }
                        } else {
                            Ok(JsValue::Undefined)
                        }
                    }
                    _ => Ok(JsValue::Undefined),
                }
            }),
        );

        // ── Object.defineProperties(obj, props) ──────────────────────────────
        props.insert(
            "defineProperties".into(),
            builtin_fn("defineProperties", 2, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined).clone();
                let descriptors = args.get(1).unwrap_or(&JsValue::Undefined);

                // §20.1.2.3 step 1: target must be an object.
                if obj.is_primitive() {
                    return Err(crate::error::StatorError::TypeError(
                        "Object.defineProperties called on non-object".into(),
                    ));
                }

                if let JsValue::PlainObject(map) = &obj {
                    if let JsValue::PlainObject(desc_map) = descriptors {
                        // Collect keys first to avoid borrow conflicts.
                        let entries: Vec<(String, JsValue)> = desc_map
                            .borrow()
                            .iter()
                            .filter(|(k, _)| !k.starts_with("__"))
                            .map(|(k, v)| (k.to_string(), v.clone()))
                            .collect();
                        for (key, desc_val) in &entries {
                            if let JsValue::PlainObject(single_desc) = desc_val {
                                let sd = single_desc.borrow();
                                define_own_property(map, key, &sd)?;
                            }
                        }
                    }
                    Ok(obj)
                } else {
                    Err(crate::error::StatorError::TypeError(
                        "Object.defineProperties called on non-object".into(),
                    ))
                }
            }),
        );

        // ── Object.getOwnPropertyNames(obj) ──────────────────────────────────
        props.insert(
            "getOwnPropertyNames".into(),
            builtin_fn("getOwnPropertyNames", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                // §20.1.2.7 step 1: throw TypeError for null/undefined.
                if matches!(obj, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }
                match obj {
                    JsValue::PlainObject(map) => {
                        let borrow = map.borrow();
                        let mut names: Vec<String> = Vec::new();
                        let mut seen = std::collections::HashSet::new();
                        for k in borrow.keys() {
                            if let Some(prop) =
                                k.strip_prefix("__get_").and_then(|s| s.strip_suffix("__"))
                            {
                                if seen.insert(prop.to_string()) {
                                    names.push(prop.to_string());
                                }
                                continue;
                            }
                            if let Some(prop) =
                                k.strip_prefix("__set_").and_then(|s| s.strip_suffix("__"))
                            {
                                if seen.insert(prop.to_string()) {
                                    names.push(prop.to_string());
                                }
                                continue;
                            }
                            if k.starts_with("__") || k.starts_with('#') {
                                continue;
                            }
                            if seen.insert(k.to_string()) {
                                names.push(k.to_string());
                            }
                        }
                        // ES spec ordering: integer indices ascending, then
                        // string keys in insertion order.
                        let mut integer_keys: Vec<(u32, String)> = Vec::new();
                        let mut string_keys: Vec<String> = Vec::new();
                        for name in names {
                            if let Some(idx) = parse_integer_index_key(&name) {
                                integer_keys.push((idx, name));
                            } else {
                                string_keys.push(name);
                            }
                        }
                        integer_keys.sort_by_key(|(idx, _)| *idx);
                        let sorted: Vec<JsValue> = integer_keys
                            .into_iter()
                            .map(|(_, s)| JsValue::String(s.into()))
                            .chain(string_keys.into_iter().map(|s| JsValue::String(s.into())))
                            .collect();
                        Ok(JsValue::new_array(sorted))
                    }
                    JsValue::Array(items) => {
                        let len = items.borrow().len();
                        let mut keys: Vec<JsValue> = (0..len)
                            .map(|i| JsValue::String(i.to_string().into()))
                            .collect();
                        keys.push(JsValue::String("length".into()));
                        Ok(JsValue::new_array(keys))
                    }
                    JsValue::Error(error) => Ok(JsValue::new_array(
                        error_own_string_keys(error)
                            .into_iter()
                            .map(|name| JsValue::String(name.into()))
                            .collect(),
                    )),
                    JsValue::Function(_) => Ok(JsValue::new_array(vec![
                        JsValue::String("length".into()),
                        JsValue::String("name".into()),
                    ])),
                    JsValue::String(s) => {
                        let mut keys: Vec<JsValue> = (0..utf16_len(s))
                            .map(|i| JsValue::String(i.to_string().into()))
                            .collect();
                        keys.push(JsValue::String("length".into()));
                        Ok(JsValue::new_array(keys))
                    }
                    _ => Ok(JsValue::new_array(vec![])),
                }
            }),
        );

        // ── Object.assign(target, ...sources) ────────────────────────────────
        props.insert(
            "assign".into(),
            builtin_fn("assign", 2, |args| {
                let target = args.first().unwrap_or(&JsValue::Undefined).clone();
                if matches!(target, JsValue::Null | JsValue::Undefined) {
                    return Err(crate::error::StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }

                for source in args.iter().skip(1) {
                    if matches!(source, JsValue::Null | JsValue::Undefined) {
                        continue;
                    }
                    // Copy enumerable own string-keyed properties.
                    for key in enumerable_own_string_keys(source) {
                        let value = dispatch_get_property_value(
                            source,
                            JsValue::String(key.clone().into()),
                        )?;
                        dispatch_set_property_value(&target, JsValue::String(key.into()), value)?;
                    }
                    // Copy enumerable own symbol-keyed properties.
                    if let JsValue::PlainObject(map) = source {
                        let borrow = map.borrow();
                        for sym_id in borrow.own_symbol_keys() {
                            let prop_key = crate::builtins::symbol::symbol_to_property_key(sym_id);
                            if borrow.is_enumerable(&prop_key)
                                && let Some(val) = borrow.get(&prop_key)
                            {
                                dispatch_set_property_value(
                                    &target,
                                    JsValue::Symbol(sym_id),
                                    val.clone(),
                                )?;
                            }
                        }
                    }
                }
                Ok(target)
            }),
        );

        // ── Object.freeze(obj) ───────────────────────────────────────────────
        props.insert(
            "freeze".into(),
            builtin_fn("freeze", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined).clone();
                match &obj {
                    JsValue::PlainObject(map) => map.borrow_mut().freeze(),
                    JsValue::Error(e) => e.props.borrow_mut().freeze(),
                    _ => {}
                }
                Ok(obj)
            }),
        );

        // ── Object.seal(obj) ─────────────────────────────────────────────────
        props.insert(
            "seal".into(),
            builtin_fn("seal", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined).clone();
                match &obj {
                    JsValue::PlainObject(map) => map.borrow_mut().seal(),
                    JsValue::Error(e) => e.props.borrow_mut().seal(),
                    _ => {}
                }
                Ok(obj)
            }),
        );

        // ── Object.isFrozen(obj) ─────────────────────────────────────────────
        props.insert(
            "isFrozen".into(),
            builtin_fn("isFrozen", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                match obj {
                    JsValue::PlainObject(map) => Ok(JsValue::Boolean(map.borrow().is_frozen())),
                    JsValue::Error(e) => Ok(JsValue::Boolean(e.props.borrow().is_frozen())),
                    _ if obj.is_primitive() => Ok(JsValue::Boolean(true)),
                    // Other object types (Array, Function, etc.) are not
                    // frozen unless the engine explicitly froze them.
                    _ => Ok(JsValue::Boolean(false)),
                }
            }),
        );

        // ── Object.isSealed(obj) ─────────────────────────────────────────────
        props.insert(
            "isSealed".into(),
            builtin_fn("isSealed", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                match obj {
                    JsValue::PlainObject(map) => Ok(JsValue::Boolean(map.borrow().is_sealed())),
                    JsValue::Error(e) => Ok(JsValue::Boolean(e.props.borrow().is_sealed())),
                    _ if obj.is_primitive() => Ok(JsValue::Boolean(true)),
                    _ => Ok(JsValue::Boolean(false)),
                }
            }),
        );

        // ── Object.create(proto, [propertiesObject]) ──────────────────────────
        props.insert(
            "create".into(),
            builtin_fn("create", 2, |args| {
                let proto = args.first().cloned().unwrap_or(JsValue::Undefined);
                let mut map = PropertyMap::new();
                match &proto {
                    JsValue::Null => {
                        map.insert("__proto__".to_string(), JsValue::Null);
                    }
                    _ if proto.is_object_like() => {
                        map.insert("__proto__".to_string(), proto.clone());
                    }
                    _ => {
                        return Err(StatorError::TypeError(
                            "Object prototype may only be an Object or null".to_string(),
                        ));
                    }
                }
                let result = Rc::new(RefCell::new(map));
                // Handle second argument (property descriptors)
                if let Some(JsValue::PlainObject(desc_obj)) = args.get(1) {
                    let entries: Vec<(String, JsValue)> = desc_obj
                        .borrow()
                        .iter()
                        .filter(|(k, _)| !k.starts_with("__"))
                        .map(|(k, v)| (k.to_string(), v.clone()))
                        .collect();
                    for (key, desc_val) in &entries {
                        if let JsValue::PlainObject(desc) = desc_val {
                            let desc_borrow = desc.borrow();
                            define_own_property(&result, key, &desc_borrow)?;
                        }
                    }
                }
                Ok(JsValue::PlainObject(result))
            }),
        );

        // ── Object.is(x, y) ─────────────────────────────────────────────────
        props.insert(
            "is".into(),
            builtin_fn("is", 2, |args| {
                let x = args.first().unwrap_or(&JsValue::Undefined);
                let y = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(JsValue::Boolean(x.same_value(y)))
            }),
        );

        // ── Object.fromEntries(iterable) ─────────────────────────────────────
        props.insert(
            "fromEntries".into(),
            builtin_fn("fromEntries", 1, |args| {
                let iterable = args.first().unwrap_or(&JsValue::Undefined);
                if matches!(iterable, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }
                let mut result = PropertyMap::new();

                for entry in collect_iterable_values(iterable)? {
                    let (key, val) = from_entries_pair(&entry)?;
                    result.insert(key, val);
                }
                Ok(JsValue::PlainObject(Rc::new(RefCell::new(result))))
            }),
        );

        // ── Object.hasOwn(obj, key) — ES2022 §20.1.2.14 ──────────────────
        props.insert(
            "hasOwn".into(),
            builtin_fn("hasOwn", 2, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                let prop = args.get(1).unwrap_or(&JsValue::Undefined);
                let key = prop.to_js_string()?;

                match obj {
                    JsValue::PlainObject(map) => {
                        let borrow = map.borrow();
                        let has_data = borrow.contains_key(&key) && key != "__proto__";
                        let has_accessor = borrow.contains_key(&format!("__get_{key}__"))
                            || borrow.contains_key(&format!("__set_{key}__"));
                        Ok(JsValue::Boolean(has_data || has_accessor))
                    }
                    JsValue::Array(items) => {
                        if key == "length" {
                            Ok(JsValue::Boolean(true))
                        } else if let Ok(idx) = key.parse::<usize>() {
                            let borrow = items.borrow();
                            Ok(JsValue::Boolean(
                                idx < borrow.len() && !borrow[idx].is_the_hole(),
                            ))
                        } else {
                            Ok(JsValue::Boolean(false))
                        }
                    }
                    JsValue::String(s) => {
                        if key == "length" {
                            Ok(JsValue::Boolean(true))
                        } else if let Ok(idx) = key.parse::<usize>() {
                            Ok(JsValue::Boolean(idx < utf16_len(s)))
                        } else {
                            Ok(JsValue::Boolean(false))
                        }
                    }
                    _ => Ok(JsValue::Boolean(false)),
                }
            }),
        );

        // ── Object.groupBy(items, callbackFn) — ES2024 §22.1.2.5 ─────────
        props.insert(
            "groupBy".into(),
            builtin_fn("groupBy", 2, |args| {
                let items = args.first().unwrap_or(&JsValue::Undefined).clone();
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);

                // §22.1.2.5 step 2: callbackFn must be callable.
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Object.groupBy: callbackFn is not a function".into(),
                    ));
                }

                // Collect elements from iterable (Array, String, Iterator,
                // or array-like PlainObject).
                let elements: Vec<JsValue> = match &items {
                    JsValue::Array(a) => a.borrow().clone(),
                    JsValue::String(s) => s
                        .chars()
                        .map(|c| JsValue::String(c.to_string().into()))
                        .collect(),
                    JsValue::Iterator(iter) => {
                        let mut v = Vec::new();
                        while let Some(item) = iter.borrow_mut().next_item() {
                            v.push(item);
                        }
                        v
                    }
                    JsValue::PlainObject(map) => {
                        let borrow = map.borrow();
                        if let Some(len_val) = borrow.get("length") {
                            let len = match len_val {
                                JsValue::Smi(n) => *n as usize,
                                JsValue::HeapNumber(n) => n.trunc() as usize,
                                _ => 0,
                            };
                            (0..len)
                                .map(|i| {
                                    borrow
                                        .get(&i.to_string())
                                        .cloned()
                                        .unwrap_or(JsValue::Undefined)
                                })
                                .collect()
                        } else {
                            vec![]
                        }
                    }
                    _ => {
                        return Err(StatorError::TypeError(
                            "Object.groupBy: first argument is not iterable".into(),
                        ));
                    }
                };

                let mut result = PropertyMap::new();
                result.insert("__proto__".to_string(), JsValue::Null);
                let result_rc = Rc::new(RefCell::new(result));
                for (i, item) in elements.iter().enumerate() {
                    let key = dispatch_call_value(&cb, vec![item.clone(), JsValue::Smi(i as i32)])?;
                    let group_key = key.to_js_string()?;
                    let mut borrow = result_rc.borrow_mut();
                    if let Some(JsValue::Array(existing)) = borrow.get(&group_key).cloned() {
                        existing.borrow_mut().push(item.clone());
                    } else {
                        borrow.insert(group_key, JsValue::new_array(vec![item.clone()]));
                    }
                }
                Ok(JsValue::PlainObject(result_rc))
            }),
        );

        // ── Object.getPrototypeOf(obj) ───────────────────────────────────────
        props.insert(
            "getPrototypeOf".into(),
            builtin_fn("getPrototypeOf", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                if matches!(obj, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }
                Ok(get_prototype_of_value(obj).unwrap_or(JsValue::Null))
            }),
        );

        // ── Object.setPrototypeOf(obj, proto) ────────────────────────────────
        props.insert(
            "setPrototypeOf".into(),
            builtin_fn("setPrototypeOf", 2, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined).clone();
                let proto = args.get(1).unwrap_or(&JsValue::Undefined).clone();
                if matches!(&obj, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".to_string(),
                    ));
                }
                if !matches!(&proto, JsValue::Null) && !proto.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Object prototype may only be an Object or null".to_string(),
                    ));
                }
                ordinary_set_prototype_of(&obj, proto)?;
                Ok(obj)
            }),
        );

        // ── Object.preventExtensions(obj) ────────────────────────────────────
        props.insert(
            "preventExtensions".into(),
            builtin_fn("preventExtensions", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined).clone();
                match &obj {
                    JsValue::PlainObject(map) => map.borrow_mut().extensible = false,
                    JsValue::Error(e) => e.props.borrow_mut().extensible = false,
                    _ => {}
                }
                Ok(obj)
            }),
        );

        // ── Object.isExtensible(obj) ─────────────────────────────────────────
        props.insert(
            "isExtensible".into(),
            builtin_fn("isExtensible", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                match obj {
                    JsValue::PlainObject(map) => Ok(JsValue::Boolean(map.borrow().extensible)),
                    JsValue::Error(e) => Ok(JsValue::Boolean(e.props.borrow().extensible)),
                    _ if obj.is_primitive() => Ok(JsValue::Boolean(false)),
                    // Other object types are extensible by default.
                    _ => Ok(JsValue::Boolean(true)),
                }
            }),
        );

        // ── Object.getOwnPropertyDescriptors(obj) ────────────────────────────
        props.insert(
            "getOwnPropertyDescriptors".into(),
            builtin_fn("getOwnPropertyDescriptors", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                // §20.1.2.8 step 1: throw TypeError for null/undefined.
                if matches!(obj, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }

                fn make_data_desc(
                    value: JsValue,
                    writable: bool,
                    enumerable: bool,
                    configurable: bool,
                ) -> JsValue {
                    let mut desc = PropertyMap::new();
                    desc.insert("value".into(), value);
                    desc.insert("writable".into(), JsValue::Boolean(writable));
                    desc.insert("enumerable".into(), JsValue::Boolean(enumerable));
                    desc.insert("configurable".into(), JsValue::Boolean(configurable));
                    JsValue::PlainObject(Rc::new(RefCell::new(desc)))
                }

                match obj {
                    JsValue::PlainObject(map) => {
                        let mut result = PropertyMap::new();
                        let borrow = map.borrow();
                        let visible_keys: Vec<String> = borrow
                            .keys()
                            .filter(|k| !k.starts_with("__"))
                            .map(|k| k.to_string())
                            .collect();
                        let mut accessor_names: Vec<String> = Vec::new();
                        for k in borrow.keys() {
                            if let Some(name) = k.strip_prefix("__get_")
                                && let Some(name) = name.strip_suffix("__")
                                && !accessor_names.contains(&name.to_string())
                            {
                                accessor_names.push(name.to_string());
                            } else if let Some(name) = k.strip_prefix("__set_")
                                && let Some(name) = name.strip_suffix("__")
                                && !accessor_names.contains(&name.to_string())
                            {
                                accessor_names.push(name.to_string());
                            }
                        }
                        for key in &visible_keys {
                            if accessor_names.contains(key) {
                                continue;
                            }
                            // Skip symbol keys from the data descriptor list.
                            if crate::builtins::symbol::is_symbol_property_key(key) {
                                continue;
                            }
                            let mut desc = PropertyMap::new();
                            if let Some(val) = borrow.get(key) {
                                desc.insert("value".into(), val.clone());
                            }
                            desc.insert(
                                "writable".into(),
                                JsValue::Boolean(borrow.is_writable(key)),
                            );
                            desc.insert(
                                "enumerable".into(),
                                JsValue::Boolean(borrow.is_enumerable(key)),
                            );
                            desc.insert(
                                "configurable".into(),
                                JsValue::Boolean(borrow.is_configurable(key)),
                            );
                            result.insert(
                                key.clone(),
                                JsValue::PlainObject(Rc::new(RefCell::new(desc))),
                            );
                        }
                        for name in &accessor_names {
                            let getter_key = format!("__get_{name}__");
                            let setter_key = format!("__set_{name}__");
                            let mut desc = PropertyMap::new();
                            desc.insert(
                                "get".into(),
                                borrow
                                    .get(&getter_key)
                                    .cloned()
                                    .unwrap_or(JsValue::Undefined),
                            );
                            desc.insert(
                                "set".into(),
                                borrow
                                    .get(&setter_key)
                                    .cloned()
                                    .unwrap_or(JsValue::Undefined),
                            );
                            let attr_key = if borrow.contains_key(&getter_key) {
                                &getter_key
                            } else {
                                &setter_key
                            };
                            desc.insert(
                                "enumerable".into(),
                                JsValue::Boolean(borrow.is_enumerable(attr_key)),
                            );
                            desc.insert(
                                "configurable".into(),
                                JsValue::Boolean(borrow.is_configurable(attr_key)),
                            );
                            result.insert(
                                name.clone(),
                                JsValue::PlainObject(Rc::new(RefCell::new(desc))),
                            );
                        }
                        Ok(JsValue::PlainObject(Rc::new(RefCell::new(result))))
                    }
                    JsValue::Array(items) => {
                        let mut result = PropertyMap::new();
                        let borrow = items.borrow();
                        for (i, val) in borrow.iter().enumerate() {
                            result.insert(
                                i.to_string(),
                                make_data_desc(val.clone(), true, true, true),
                            );
                        }
                        result.insert(
                            "length".into(),
                            make_data_desc(JsValue::Smi(borrow.len() as i32), true, false, false),
                        );
                        Ok(JsValue::PlainObject(Rc::new(RefCell::new(result))))
                    }
                    JsValue::String(s) => {
                        let mut result = PropertyMap::new();
                        let len = utf16_len(s);
                        for i in 0..len {
                            let ch = string_char_at(s, i as i64);
                            result.insert(
                                i.to_string(),
                                make_data_desc(JsValue::String(ch.into()), false, true, false),
                            );
                        }
                        result.insert(
                            "length".into(),
                            make_data_desc(JsValue::Smi(len as i32), false, false, false),
                        );
                        Ok(JsValue::PlainObject(Rc::new(RefCell::new(result))))
                    }
                    _ => Ok(JsValue::PlainObject(Rc::new(RefCell::new(
                        PropertyMap::new(),
                    )))),
                }
            }),
        );

        // ── Object.getOwnPropertySymbols(obj) ────────────────────────────────
        props.insert(
            "getOwnPropertySymbols".into(),
            builtin_fn("getOwnPropertySymbols", 1, |args| {
                let obj = args.first().unwrap_or(&JsValue::Undefined);
                // §20.1.2.9 step 1: throw TypeError for null/undefined.
                if matches!(obj, JsValue::Null | JsValue::Undefined) {
                    return Err(StatorError::TypeError(
                        "Cannot convert undefined or null to object".into(),
                    ));
                }
                if let JsValue::PlainObject(map) = obj {
                    let symbols = map
                        .borrow()
                        .own_symbol_keys()
                        .into_iter()
                        .map(JsValue::Symbol)
                        .collect();
                    Ok(JsValue::new_array(symbols))
                } else {
                    Ok(JsValue::new_array(vec![]))
                }
            }),
        );

        // ── Object.prototype ─────────────────────────────────────────────────
        let mut obj_proto = PropertyMap::new();

        // Object.prototype.hasOwnProperty(key)
        obj_proto.insert(
            "hasOwnProperty".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                let key = args.get(1).unwrap_or(&JsValue::Undefined);
                let prop = key.to_property_key()?;
                match this {
                    JsValue::PlainObject(map) => {
                        let has = plain_object_has_own_property(&map.borrow(), &prop);
                        Ok(JsValue::Boolean(has))
                    }
                    _ => Ok(JsValue::Boolean(false)),
                }
            }),
        );

        // Object.prototype.isPrototypeOf(obj)
        obj_proto.insert(
            "isPrototypeOf".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                let target = args.get(1).unwrap_or(&JsValue::Undefined);
                if let JsValue::PlainObject(_) = this
                    && target.is_object_like()
                {
                    return Ok(JsValue::Boolean(has_prototype_in_chain(target, this)));
                }
                Ok(JsValue::Boolean(false))
            }),
        );

        // Object.prototype.propertyIsEnumerable(key)
        obj_proto.insert(
            "propertyIsEnumerable".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                let key = args.get(1).unwrap_or(&JsValue::Undefined);
                let prop = key.to_property_key()?;
                match this {
                    JsValue::PlainObject(map) => {
                        let borrow = map.borrow();
                        let exists = borrow.contains_key(&prop) && prop != "__proto__";
                        let enumerable = exists && borrow.is_enumerable(&prop);
                        Ok(JsValue::Boolean(enumerable))
                    }
                    _ => Ok(JsValue::Boolean(false)),
                }
            }),
        );

        // Annex B §B.2.2.4 — Object.prototype.__lookupGetter__(key)
        obj_proto.insert(
            "__lookupGetter__".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                let key = args.get(1).unwrap_or(&JsValue::Undefined);
                let prop = key.to_property_key()?;
                let getter_key = format!("__getter_{prop}__");
                if let JsValue::PlainObject(map) = this {
                    if let Some(g) = map.borrow().get(&getter_key) {
                        return Ok(g.clone());
                    }
                    // Walk the prototype chain.
                    let mut current = map.borrow().get("__proto__").cloned();
                    for _ in 0..256 {
                        match current {
                            Some(JsValue::PlainObject(p)) => {
                                if let Some(g) = p.borrow().get(&getter_key) {
                                    return Ok(g.clone());
                                }
                                current = p.borrow().get("__proto__").cloned();
                            }
                            _ => break,
                        }
                    }
                }
                Ok(JsValue::Undefined)
            }),
        );

        // Annex B §B.2.2.5 — Object.prototype.__lookupSetter__(key)
        obj_proto.insert(
            "__lookupSetter__".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                let key = args.get(1).unwrap_or(&JsValue::Undefined);
                let prop = key.to_property_key()?;
                let setter_key = format!("__setter_{prop}__");
                if let JsValue::PlainObject(map) = this {
                    if let Some(s) = map.borrow().get(&setter_key) {
                        return Ok(s.clone());
                    }
                    // Walk the prototype chain.
                    let mut current = map.borrow().get("__proto__").cloned();
                    for _ in 0..256 {
                        match current {
                            Some(JsValue::PlainObject(p)) => {
                                if let Some(s) = p.borrow().get(&setter_key) {
                                    return Ok(s.clone());
                                }
                                current = p.borrow().get("__proto__").cloned();
                            }
                            _ => break,
                        }
                    }
                }
                Ok(JsValue::Undefined)
            }),
        );

        // Annex B §B.2.2.2 — Object.prototype.__defineGetter__(key, getter)
        obj_proto.insert(
            "__defineGetter__".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                let key = args.get(1).unwrap_or(&JsValue::Undefined);
                let getter = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let prop = key.to_property_key()?;
                if let JsValue::PlainObject(map) = this {
                    map.borrow_mut()
                        .insert(format!("__getter_{prop}__"), getter);
                }
                Ok(JsValue::Undefined)
            }),
        );

        // Annex B §B.2.2.3 — Object.prototype.__defineSetter__(key, setter)
        obj_proto.insert(
            "__defineSetter__".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                let key = args.get(1).unwrap_or(&JsValue::Undefined);
                let setter = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let prop = key.to_property_key()?;
                if let JsValue::PlainObject(map) = this {
                    map.borrow_mut()
                        .insert(format!("__setter_{prop}__"), setter);
                }
                Ok(JsValue::Undefined)
            }),
        );

        // Annex B §B.2.2.1 — Object.prototype.__proto__ (terminal null)
        obj_proto.insert("__proto__".into(), JsValue::Null);

        // Object.prototype.toString()
        // ECMAScript §20.1.3.6 — returns "[object X]" classification.
        obj_proto.insert(
            "toString".into(),
            builtin_fn("toString", 0, |args| {
                // When called via .call(value), args[0] is the value.
                if let Some(value) = args.first() {
                    return Ok(JsValue::String(value.obj_to_string_tag().into()));
                }
                Ok(JsValue::String("[object Object]".to_string().into()))
            }),
        );

        // Object.prototype.valueOf()
        // ECMAScript §20.1.3.7 — returns the `this` value.
        obj_proto.insert(
            "valueOf".into(),
            native(|args| {
                let this = args.first().cloned().unwrap_or(JsValue::Undefined);
                Ok(this)
            }),
        );

        // Object.prototype.toLocaleString()
        // ECMAScript §20.1.3.5 — delegates to this.toString().
        obj_proto.insert(
            "toLocaleString".into(),
            native(|args| {
                let this = args.first().cloned().unwrap_or(JsValue::Undefined);
                if let JsValue::PlainObject(ref map) = this {
                    let to_str = map.borrow().get("toString").cloned();
                    if let Some(to_str) = to_str {
                        return dispatch_call_value(&to_str, vec![this]);
                    }
                }
                Ok(JsValue::String("[object Object]".to_string().into()))
            }),
        );

        obj_proto.make_all_non_enumerable();
        let obj_proto_rc = Rc::new(RefCell::new(obj_proto));
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(obj_proto_rc.clone()),
        );

        props.make_all_non_enumerable();
        let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
        // §20.1.3.1 Object.prototype.constructor
        obj_proto_rc.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
        ctor
    })
}

// ── Array constructor ────────────────────────────────────────────────────────

/// Build the `Array` constructor/namespace object.
///
/// The returned `PlainObject` carries:
/// - `isArray` — `Array.isArray(value)`.
/// - `from` — `Array.from(iterable)`.
/// - `of` — `Array.of(...items)`.
/// - `prototype` — an object with all `Array.prototype.*` methods.
#[inline(never)]
fn make_array() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // ── Static methods ──────────────────────────────────────────────────

        // Array.isArray(value)
        props.insert(
            "isArray".into(),
            builtin_fn("isArray", 1, |args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                Ok(JsValue::Boolean(is_js_array(val)?))
            }),
        );

        // Array.from(iterable, mapFn?, thisArg?)
        props.insert(
            "from".into(),
            builtin_fn("from", 1, |args| {
                let iterable = args.first().unwrap_or(&JsValue::Undefined);
                let map_fn = args.get(1).cloned();
                // §23.1.2.1 step 3: if mapFn is provided and not undefined, it must be callable.
                if let Some(ref mf) = map_fn
                    && !matches!(mf, JsValue::Undefined)
                    && !is_callable(mf)
                {
                    return Err(StatorError::TypeError(
                        "Array.from: mapFn is not a function".into(),
                    ));
                }
                let items = collect_iterable_values(iterable)?;
                // §23.1.2.1 step 5: thisArg for mapFn.
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                // Apply mapFn if provided.
                let mapped = if let Some(ref mf) = map_fn {
                    if !matches!(mf, JsValue::Undefined) {
                        items
                            .into_iter()
                            .enumerate()
                            .map(|(i, v)| {
                                dispatch_call_with_this(
                                    mf,
                                    this_arg.clone(),
                                    vec![v, JsValue::Smi(i as i32)],
                                )
                            })
                            .collect::<Result<Vec<_>, _>>()?
                    } else {
                        items
                    }
                } else {
                    items
                };
                Ok(JsValue::new_array(mapped))
            }),
        );

        // Array.of(...items) — §23.1.2.3
        // Creates a new Array from a variable number of arguments,
        // regardless of number or type.  Unlike `Array(n)` which creates
        // an array of length n, `Array.of(n)` creates `[n]`.
        props.insert(
            "of".into(),
            builtin_fn("of", 0, |args| Ok(JsValue::new_array(args))),
        );

        // Array.fromAsync(arrayLike, mapFn?, thisArg?) — ES2024 §23.1.2.1.1
        //
        // Creates a new Array from an async iterable, sync iterable, or
        // array-like object.  Returns a Promise that resolves to the new
        // array.  This simplified implementation handles the common synchronous
        // collection cases and wraps the result in a resolved promise.
        props.insert(
            "fromAsync".into(),
            builtin_fn("fromAsync", 1, |args| {
                use crate::builtins::promise::{MicrotaskQueue, promise_resolve};

                let iterable = args.first().unwrap_or(&JsValue::Undefined);
                let map_fn = args.get(1).cloned();
                // Validate mapFn.
                if let Some(ref mf) = map_fn
                    && !matches!(mf, JsValue::Undefined)
                    && !is_callable(mf)
                {
                    return Err(StatorError::TypeError(
                        "Array.fromAsync: mapFn is not a function".into(),
                    ));
                }
                // Collect items synchronously (covers sync iterables / array-like).
                let items: Vec<JsValue> = match iterable {
                    JsValue::Array(arr) => arr.borrow().clone(),
                    JsValue::String(s) => s
                        .chars()
                        .map(|c| JsValue::String(c.to_string().into()))
                        .collect(),
                    JsValue::PlainObject(map) => {
                        let borrow = map.borrow();
                        if let Some(len_val) = borrow.get("length") {
                            let len = match len_val {
                                JsValue::Smi(n) => *n as usize,
                                JsValue::HeapNumber(n) => n.trunc() as usize,
                                _ => 0,
                            };
                            (0..len)
                                .map(|i| {
                                    borrow
                                        .get(&i.to_string())
                                        .cloned()
                                        .unwrap_or(JsValue::Undefined)
                                })
                                .collect()
                        } else {
                            vec![]
                        }
                    }
                    JsValue::Iterator(iter) => {
                        let mut v = Vec::new();
                        while let Some(item) = iter.borrow_mut().next_item() {
                            v.push(item);
                        }
                        v
                    }
                    _ => Vec::new(),
                };
                // Apply mapFn if provided.
                let mapped = if let Some(ref mf) = map_fn {
                    if !matches!(mf, JsValue::Undefined) {
                        items
                            .into_iter()
                            .enumerate()
                            .map(|(i, v)| dispatch_call_value(mf, vec![v, JsValue::Smi(i as i32)]))
                            .collect::<Result<Vec<_>, _>>()?
                    } else {
                        items
                    }
                } else {
                    items
                };
                let result_arr = JsValue::new_array(mapped);
                // Wrap in a resolved Promise.
                let queue = MicrotaskQueue::new();
                Ok(JsValue::Promise(promise_resolve(result_arr, &queue)))
            }),
        );

        // ── Prototype methods ───────────────────────────────────────────────
        //
        // Each method receives `(this_array, ...args)` where the first argument is
        // the array instance (`this`), and the remaining arguments are the method's
        // parameters.  The interpreter rewrites `arr.borrow_mut().push(x)` into
        // `Array.prototype.push(arr, x)` at the bytecode level.

        let mut proto = PropertyMap::new();
        proto.insert_with_attrs(
            "length".into(),
            JsValue::Smi(0),
            PropertyAttributes::WRITABLE,
        );
        proto.insert_with_attrs(
            "__is_array__".into(),
            JsValue::Boolean(true),
            PropertyAttributes::empty(),
        );

        // push(...items)
        proto.insert(
            "push".into(),
            builtin_fn("push", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                match arr {
                    JsValue::Array(items) => {
                        let mut vec = items.borrow_mut();
                        vec.extend_from_slice(&args[1..]);
                        Ok(JsValue::Smi(vec.len() as i32))
                    }
                    JsValue::PlainObject(map) => {
                        let mut borrow = map.borrow_mut();
                        let len = match borrow.get("length") {
                            Some(JsValue::Smi(n)) => *n as usize,
                            Some(JsValue::HeapNumber(n)) => *n as usize,
                            _ => 0,
                        };
                        for (i, item) in args.iter().skip(1).enumerate() {
                            borrow.insert((len + i).to_string(), item.clone());
                        }
                        let new_len = len + args.len() - 1;
                        borrow.insert("length".to_string(), JsValue::Smi(new_len as i32));
                        Ok(JsValue::Smi(new_len as i32))
                    }
                    _ => Ok(JsValue::Undefined),
                }
            }),
        );

        // pop()
        proto.insert(
            "pop".into(),
            builtin_fn("pop", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                if let JsValue::Array(items) = arr {
                    Ok(items.borrow_mut().pop().unwrap_or(JsValue::Undefined))
                } else {
                    Ok(JsValue::Undefined)
                }
            }),
        );

        // shift()
        proto.insert(
            "shift".into(),
            builtin_fn("shift", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                if let JsValue::Array(items) = arr {
                    if items.borrow().is_empty() {
                        Ok(JsValue::Undefined)
                    } else {
                        Ok(items.borrow_mut().remove(0))
                    }
                } else {
                    Ok(JsValue::Undefined)
                }
            }),
        );

        // unshift(...items)
        proto.insert(
            "unshift".into(),
            builtin_fn("unshift", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                if let JsValue::Array(items) = arr {
                    let new_items = &args[1..];
                    let mut vec = items.borrow_mut();
                    for (i, item) in new_items.iter().enumerate() {
                        vec.insert(i, item.clone());
                    }
                    Ok(JsValue::Smi(vec.len() as i32))
                } else {
                    Ok(JsValue::Undefined)
                }
            }),
        );

        // indexOf(searchElement, fromIndex?)
        proto.insert(
            "indexOf".into(),
            builtin_fn("indexOf", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let search = args.get(1).unwrap_or(&JsValue::Undefined);
                let len = array_like_length(arr)?;
                let start = normalize_from_index(len, args.get(2))?;
                // §23.1.3.14 uses Strict Equality (===) — NaN !== NaN, +0 === -0,
                // and Smi/HeapNumber cross-type comparison must work.
                for i in start..len {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    if array_like_get_index(arr, i).is_strictly_equal(search) {
                        return Ok(JsValue::Smi(i as i32));
                    }
                }
                Ok(JsValue::Smi(-1))
            }),
        );

        // lastIndexOf(searchElement, fromIndex?)
        proto.insert(
            "lastIndexOf".into(),
            builtin_fn("lastIndexOf", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let search = args.get(1).unwrap_or(&JsValue::Undefined);
                let len = array_like_length(arr)?;
                let Some(start) = normalize_last_from_index(len, args.get(2))? else {
                    return Ok(JsValue::Smi(-1));
                };
                // §23.1.3.17 uses Strict Equality (===).
                for i in (0..=start).rev() {
                    if array_like_has_index(arr, i)
                        && array_like_get_index(arr, i).is_strictly_equal(search)
                    {
                        return Ok(JsValue::Smi(i as i32));
                    }
                }
                Ok(JsValue::Smi(-1))
            }),
        );

        // includes(searchElement, fromIndex?)
        proto.insert(
            "includes".into(),
            builtin_fn("includes", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let search = args.get(1).unwrap_or(&JsValue::Undefined);
                let len = array_like_length(arr)?;
                let start = normalize_from_index(len, args.get(2))?;
                // §23.1.3.13 uses SameValueZero — NaN equals NaN, +0 equals -0.
                for i in start..len {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    if array_like_get_index(arr, i).same_value_zero(search) {
                        return Ok(JsValue::Boolean(true));
                    }
                }
                Ok(JsValue::Boolean(false))
            }),
        );

        // join(separator?)
        proto.insert(
            "join".into(),
            builtin_fn("join", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let sep = match args.get(1) {
                    Some(JsValue::Undefined) | None => ",".to_string(),
                    Some(v) => v.to_js_string()?,
                };
                let (elements, _len) = to_array_like_elements(arr);
                let parts: Vec<String> = elements
                    .iter()
                    .map(|v| match v {
                        JsValue::Undefined | JsValue::Null => Ok(String::new()),
                        other => other.to_js_string(),
                    })
                    .collect::<StatorResult<_>>()?;
                Ok(JsValue::String(parts.join(&sep).into()))
            }),
        );

        // concat(...arrays) — §23.1.3.1, respects @@isConcatSpreadable & @@species
        proto.insert(
            "concat".into(),
            builtin_fn("concat", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let mut result = Vec::new();
                for value in std::iter::once(arr).chain(args.iter().skip(1)) {
                    if is_concat_spreadable(value) {
                        let len = array_like_length(value)?;
                        for i in 0..len {
                            result.push(array_like_get_index(value, i));
                        }
                    } else {
                        result.push(value.clone());
                    }
                }
                // §23.1.3.1 step 5: ArraySpeciesCreate
                if let Some(species_result) = array_species_create(arr, result.len())? {
                    return Ok(species_result);
                }
                Ok(JsValue::new_array(result))
            }),
        );

        // slice(start?, end?)
        proto.insert(
            "slice".into(),
            builtin_fn("slice", 2, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let (elements, len) = to_array_like_elements(arr);
                let s = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(1), 0.0)?,
                );
                let e = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(2), len as f64)?,
                );
                let sliced: Vec<JsValue> = elements[s..e].to_vec();
                // §23.1.3.25 ArraySpeciesCreate
                if let Some(result) = array_species_create(arr, sliced.len())? {
                    return Ok(result);
                }
                Ok(JsValue::new_array(sliced))
            }),
        );

        // reverse()
        proto.insert(
            "reverse".into(),
            builtin_fn("reverse", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                if let JsValue::Array(items) = arr {
                    items.borrow_mut().reverse();
                    Ok(arr.clone())
                } else {
                    Ok(JsValue::Undefined)
                }
            }),
        );

        // sort(compareFn?)
        proto.insert(
            "sort".into(),
            builtin_fn("sort", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cmp_fn = args.get(1).cloned();
                if let Some(cb) = &cmp_fn
                    && !cb.is_undefined()
                    && !is_callable(cb)
                {
                    return Err(StatorError::TypeError(
                        "Array.prototype.sort comparator must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let mut defined = Vec::new();
                let mut undefined_count = 0usize;
                for index in 0..len {
                    if !array_like_has_index(arr, index) {
                        continue;
                    }
                    let value = array_like_get_index(arr, index);
                    if value.is_undefined() {
                        undefined_count += 1;
                    } else {
                        defined.push((index, value));
                    }
                }
                if let Some(cb) = cmp_fn.filter(|v| !v.is_undefined()) {
                    let mut sort_err: Option<StatorError> = None;
                    defined.sort_by(|(_, a), (_, b)| {
                        if sort_err.is_some() {
                            return std::cmp::Ordering::Equal;
                        }
                        match call_callback_with_this(
                            &cb,
                            JsValue::Undefined,
                            vec![a.clone(), b.clone()],
                        ) {
                            Ok(result) => match result.to_number() {
                                Ok(number) => number
                                    .partial_cmp(&0.0)
                                    .unwrap_or(std::cmp::Ordering::Equal),
                                Err(err) => {
                                    sort_err = Some(err);
                                    std::cmp::Ordering::Equal
                                }
                            },
                            Err(err) => {
                                sort_err = Some(err);
                                std::cmp::Ordering::Equal
                            }
                        }
                    });
                    if let Some(err) = sort_err {
                        return Err(err);
                    }
                } else {
                    let mut sortable = Vec::with_capacity(defined.len());
                    for (index, value) in defined {
                        let key = value.to_js_string()?;
                        sortable.push((index, value, key));
                    }
                    sortable.sort_by(|(_, _, a_key), (_, _, b_key)| a_key.cmp(b_key));
                    defined = sortable
                        .into_iter()
                        .map(|(index, value, _)| (index, value))
                        .collect();
                }
                let defined_count = defined.len();
                let mut slots = vec![None; len];
                for (slot_index, (_, value)) in defined.into_iter().enumerate() {
                    slots[slot_index] = Some(value);
                }
                for slot in slots.iter_mut().skip(defined_count).take(undefined_count) {
                    *slot = Some(JsValue::Undefined);
                }
                apply_array_like_slots(arr, &slots);
                Ok(arr.clone())
            }),
        );

        // fill(value, start?, end?) — §23.1.3.7
        // Works on both native JsValue::Array and PlainObject array-like
        // values.  Negative start/end are resolved relative to length.
        proto.insert(
            "fill".into(),
            builtin_fn("fill", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let value = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                let len = array_like_length(arr)?;
                let s = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(2), 0.0)?,
                );
                let e = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(3), len as f64)?,
                );
                // Fast path: fill a native Array slice in one borrow
                if let JsValue::Array(items) = arr {
                    let mut borrow = items.borrow_mut();
                    if e > borrow.len() {
                        borrow.resize(e, JsValue::TheHole);
                    }
                    for slot in &mut borrow[s..e] {
                        *slot = value.clone();
                    }
                } else {
                    for i in s..e {
                        array_like_set_index(arr, i, value.clone());
                    }
                }
                Ok(arr.clone())
            }),
        );

        // at(index)
        proto.insert(
            "at".into(),
            builtin_fn("at", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let len = array_like_length(arr)?;
                match normalize_at_index(len, args.get(1))? {
                    Some(index) => Ok(array_like_get_index(arr, index)),
                    None => Ok(JsValue::Undefined),
                }
            }),
        );

        // flat(depth?) — §23.1.3.11
        // Handles `Infinity` depth and negative/NaN values.
        proto.insert(
            "flat".into(),
            builtin_fn("flat", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let depth_f = args
                    .get(1)
                    .unwrap_or(&JsValue::Smi(1))
                    .to_number()
                    .unwrap_or(1.0);
                let depth: usize = if depth_f.is_infinite() && depth_f > 0.0 {
                    usize::MAX
                } else if depth_f < 0.0 || depth_f.is_nan() {
                    0
                } else {
                    depth_f as usize
                };
                let mut result = Vec::new();
                flatten_array_like_into(arr, depth, &mut result)?;
                Ok(JsValue::new_array(result))
            }),
        );

        // flatMap(callback, thisArg?) — §23.1.3.12
        // Validates callback, supports thisArg, and skips holes.
        proto.insert(
            "flatMap".into(),
            builtin_fn("flatMap", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.flatMap callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                let mut result = Vec::new();
                for i in 0..len {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    let mapped = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr_val.clone(),
                        ],
                    )?;
                    if is_js_array(&mapped)? {
                        flatten_array_like_into(&mapped, 1, &mut result)?;
                    } else {
                        result.push(mapped);
                    }
                }
                Ok(JsValue::new_array(result))
            }),
        );

        // copyWithin(target, start, end?) — §23.1.3.4
        // Works on both native JsValue::Array and PlainObject array-like
        // values.  Copies a region within the array, preserving holes.
        proto.insert(
            "copyWithin".into(),
            builtin_fn("copyWithin", 2, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let len = array_like_length(arr)?;
                let to = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(1), 0.0)?,
                );
                let from = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(2), 0.0)?,
                );
                let fin = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(3), len as f64)?,
                );
                let count = fin.saturating_sub(from).min(len.saturating_sub(to));
                // Buffer source elements first to handle overlapping regions.
                let buf: Vec<(bool, JsValue)> = (0..count)
                    .map(|i| {
                        let idx = from + i;
                        if array_like_has_index(arr, idx) {
                            (true, array_like_get_index(arr, idx))
                        } else {
                            (false, JsValue::Undefined)
                        }
                    })
                    .collect();
                for (i, (present, val)) in buf.into_iter().enumerate() {
                    if present {
                        array_like_set_index(arr, to + i, val);
                    } else {
                        array_like_delete_index(arr, to + i);
                    }
                }
                Ok(arr.clone())
            }),
        );

        // splice(start, deleteCount?, ...items)
        proto.insert(
            "splice".into(),
            builtin_fn("splice", 2, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let len = array_like_length(arr)?;
                let start = args
                    .get(1)
                    .unwrap_or(&JsValue::Smi(0))
                    .to_integer_or_infinity()?;
                let s = if start == f64::NEG_INFINITY {
                    0
                } else if start < 0.0 {
                    ((len as f64) + start).max(0.0) as usize
                } else {
                    start.min(len as f64) as usize
                };
                let max_del = len.saturating_sub(s);
                let del = match args.get(2) {
                    None => max_del,
                    Some(value) => {
                        let delete_count = value.to_integer_or_infinity()?;
                        if delete_count <= 0.0 {
                            0
                        } else if delete_count.is_infinite() {
                            max_del
                        } else {
                            (delete_count as usize).min(max_del)
                        }
                    }
                };
                let new_items = if args.len() > 3 { &args[3..] } else { &[] };
                let mut deleted = Vec::with_capacity(del);
                for index in s..(s + del) {
                    deleted.push(array_like_get_index(arr, index));
                }
                let mut slots =
                    Vec::with_capacity(s + new_items.len() + len.saturating_sub(s + del));
                for index in 0..s {
                    if array_like_has_index(arr, index) {
                        slots.push(Some(array_like_get_index(arr, index)));
                    } else {
                        slots.push(None);
                    }
                }
                for item in new_items {
                    slots.push(Some(item.clone()));
                }
                for index in (s + del)..len {
                    if array_like_has_index(arr, index) {
                        slots.push(Some(array_like_get_index(arr, index)));
                    } else {
                        slots.push(None);
                    }
                }
                apply_array_like_slots(arr, &slots);
                // §23.1.3.31 step 12: ArraySpeciesCreate for deleted elements
                if let Some(species_result) = array_species_create(arr, deleted.len())? {
                    return Ok(species_result);
                }
                Ok(JsValue::new_array(deleted))
            }),
        );

        // map(callback, thisArg?) — §23.1.3.18
        // Validates callback, supports thisArg, skips holes in array-like.
        proto.insert(
            "map".into(),
            builtin_fn("map", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.map callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                let mut result = Vec::with_capacity(len);
                for i in 0..len {
                    if !array_like_has_index(arr, i) {
                        result.push(JsValue::TheHole);
                        continue;
                    }
                    let mapped = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr_val.clone(),
                        ],
                    )?;
                    result.push(mapped);
                }
                // §23.1.3.20 ArraySpeciesCreate
                if let Some(species_result) = array_species_create(arr, result.len())? {
                    return Ok(species_result);
                }
                Ok(JsValue::new_array(result))
            }),
        );

        // filter(callback)
        proto.insert(
            "filter".into(),
            builtin_fn("filter", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.filter callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                let mut result = Vec::new();
                for i in 0..len {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    let item = array_like_get_index(arr, i);
                    let keep = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![item.clone(), JsValue::Smi(i as i32), arr_val.clone()],
                    )?;
                    if keep.to_boolean() {
                        result.push(item);
                    }
                }
                // §23.1.3.8 step 9: ArraySpeciesCreate
                if let Some(species_result) = array_species_create(arr, result.len())? {
                    return Ok(species_result);
                }
                Ok(JsValue::new_array(result))
            }),
        );

        // reduce(callback, initialValue?)
        proto.insert(
            "reduce".into(),
            builtin_fn("reduce", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.reduce callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let (mut acc, start) = if let Some(init) = args.get(2) {
                    (init.clone(), 0usize)
                } else {
                    let mut first_present = None;
                    for i in 0..len {
                        if array_like_has_index(arr, i) {
                            first_present = Some(i);
                            break;
                        }
                    }
                    let Some(first_present) = first_present else {
                        return Err(StatorError::TypeError(
                            "Reduce of empty array with no initial value".into(),
                        ));
                    };
                    (array_like_get_index(arr, first_present), first_present + 1)
                };
                for i in start..len {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    acc = call_callback(
                        &cb,
                        vec![
                            acc,
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr.clone(),
                        ],
                    )?;
                }
                Ok(acc)
            }),
        );

        // reduceRight(callback, initialValue?)
        proto.insert(
            "reduceRight".into(),
            builtin_fn("reduceRight", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.reduceRight callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let (mut acc, end_exclusive) = if let Some(init) = args.get(2) {
                    (init.clone(), len)
                } else {
                    let mut last_present = None;
                    for i in (0..len).rev() {
                        if array_like_has_index(arr, i) {
                            last_present = Some(i);
                            break;
                        }
                    }
                    let Some(last_present) = last_present else {
                        return Err(StatorError::TypeError(
                            "Reduce of empty array with no initial value".into(),
                        ));
                    };
                    (array_like_get_index(arr, last_present), last_present)
                };
                for i in (0..end_exclusive).rev() {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    acc = call_callback(
                        &cb,
                        vec![
                            acc,
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr.clone(),
                        ],
                    )?;
                }
                Ok(acc)
            }),
        );

        // forEach(callback, thisArg?) — §23.1.3.13
        // Validates callback, supports thisArg, skips holes.
        proto.insert(
            "forEach".into(),
            builtin_fn("forEach", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.forEach callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                for i in 0..len {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr_val.clone(),
                        ],
                    )?;
                }
                Ok(JsValue::Undefined)
            }),
        );

        // find(callback)
        proto.insert(
            "find".into(),
            builtin_fn("find", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.find callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                for i in 0..len {
                    let item = array_like_get_index(arr, i);
                    let v = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![item.clone(), JsValue::Smi(i as i32), arr_val.clone()],
                    )?;
                    if v.to_boolean() {
                        return Ok(item);
                    }
                }
                Ok(JsValue::Undefined)
            }),
        );

        // findIndex(callback)
        proto.insert(
            "findIndex".into(),
            builtin_fn("findIndex", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.findIndex callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                for i in 0..len {
                    let v = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr_val.clone(),
                        ],
                    )?;
                    if v.to_boolean() {
                        return Ok(JsValue::Smi(i as i32));
                    }
                }
                Ok(JsValue::Smi(-1))
            }),
        );

        // findLast(callback)
        proto.insert(
            "findLast".into(),
            builtin_fn("findLast", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.findLast callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                for i in (0..len).rev() {
                    let v = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr_val.clone(),
                        ],
                    )?;
                    if v.to_boolean() {
                        return Ok(array_like_get_index(arr, i));
                    }
                }
                Ok(JsValue::Undefined)
            }),
        );

        // findLastIndex(callback)
        proto.insert(
            "findLastIndex".into(),
            builtin_fn("findLastIndex", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.findLastIndex callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                for i in (0..len).rev() {
                    let v = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr_val.clone(),
                        ],
                    )?;
                    if v.to_boolean() {
                        return Ok(JsValue::Smi(i as i32));
                    }
                }
                Ok(JsValue::Smi(-1))
            }),
        );

        // some(callback)
        proto.insert(
            "some".into(),
            builtin_fn("some", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.some callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                for i in 0..len {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    let v = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr_val.clone(),
                        ],
                    )?;
                    if v.to_boolean() {
                        return Ok(JsValue::Boolean(true));
                    }
                }
                Ok(JsValue::Boolean(false))
            }),
        );

        // every(callback)
        proto.insert(
            "every".into(),
            builtin_fn("every", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Array.prototype.every callback must be callable".into(),
                    ));
                }
                let len = array_like_length(arr)?;
                let this_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let arr_val = arr.clone();
                for i in 0..len {
                    if !array_like_has_index(arr, i) {
                        continue;
                    }
                    let v = call_callback_with_this(
                        &cb,
                        this_arg.clone(),
                        vec![
                            array_like_get_index(arr, i),
                            JsValue::Smi(i as i32),
                            arr_val.clone(),
                        ],
                    )?;
                    if !v.to_boolean() {
                        return Ok(JsValue::Boolean(false));
                    }
                }
                Ok(JsValue::Boolean(true))
            }),
        );

        // keys()
        proto.insert(
            "keys".into(),
            builtin_fn("keys", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let keys: Vec<JsValue> = (0..array_like_length(arr)?)
                    .map(|i| JsValue::Smi(i as i32))
                    .collect();
                Ok(JsValue::Iterator(NativeIterator::from_items(keys)))
            }),
        );

        // values()
        proto.insert(
            "values".into(),
            builtin_fn("values", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let values = try_to_array_like_elements(arr)?.0;
                Ok(JsValue::Iterator(NativeIterator::from_items(values)))
            }),
        );

        // entries()
        proto.insert(
            "entries".into(),
            builtin_fn("entries", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let len = array_like_length(arr)?;
                let entries: Vec<JsValue> = (0..len)
                    .map(|i| {
                        JsValue::new_array(vec![
                            JsValue::Smi(i as i32),
                            array_like_get_index(arr, i),
                        ])
                    })
                    .collect();
                Ok(JsValue::Iterator(NativeIterator::from_items(entries)))
            }),
        );

        // [Symbol.iterator]() — same as values() per §23.1.3.34
        proto.insert(
            "@@iterator".into(),
            builtin_fn("values", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let values = try_to_array_like_elements(arr)?.0;
                Ok(JsValue::Iterator(NativeIterator::from_items(values)))
            }),
        );

        // toReversed()
        proto.insert(
            "toReversed".into(),
            builtin_fn("toReversed", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let (mut elements, _) = try_to_array_like_elements(arr)?;
                elements.reverse();
                Ok(JsValue::new_array(elements))
            }),
        );

        // toSorted(compareFn?)
        proto.insert(
            "toSorted".into(),
            builtin_fn("toSorted", 1, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let (mut elements, _) = try_to_array_like_elements(arr)?;
                let cmp_fn = args.get(1).cloned();
                if let Some(cb) = cmp_fn.as_ref()
                    && !matches!(cb, JsValue::Undefined)
                    && !is_callable(cb)
                {
                    return Err(StatorError::TypeError(
                        "Array.prototype.toSorted compareFn must be callable".into(),
                    ));
                }
                match &cmp_fn {
                    Some(cb) if !matches!(cb, JsValue::Undefined) => {
                        let mut sort_err: Option<StatorError> = None;
                        elements.sort_by(|a, b| {
                            if sort_err.is_some() {
                                return std::cmp::Ordering::Equal;
                            }
                            match call_callback(cb, vec![a.clone(), b.clone()]) {
                                Ok(result) => {
                                    let n = match result {
                                        JsValue::Smi(n) => n as f64,
                                        JsValue::HeapNumber(n) => n,
                                        _ => 0.0,
                                    };
                                    n.partial_cmp(&0.0).unwrap_or(std::cmp::Ordering::Equal)
                                }
                                Err(e) => {
                                    sort_err = Some(e);
                                    std::cmp::Ordering::Equal
                                }
                            }
                        });
                        if let Some(e) = sort_err {
                            return Err(e);
                        }
                    }
                    _ => {
                        elements.sort_by(|a, b| {
                            let sa = a.to_js_string().unwrap_or_default();
                            let sb = b.to_js_string().unwrap_or_default();
                            sa.cmp(&sb)
                        });
                    }
                }
                Ok(JsValue::new_array(elements))
            }),
        );

        // toSpliced(start, deleteCount, ...items)
        proto.insert(
            "toSpliced".into(),
            builtin_fn("toSpliced", 2, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let (elements, _) = try_to_array_like_elements(arr)?;
                let len = elements.len();
                let s = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(1), 0.0)?,
                );
                let max_del = len.saturating_sub(s);
                let del = args
                    .get(2)
                    .map(|v| {
                        let delete_count = v.to_integer_or_infinity()?;
                        Ok(if delete_count <= 0.0 {
                            0
                        } else if delete_count == f64::INFINITY {
                            max_del
                        } else {
                            (delete_count as usize).min(max_del)
                        })
                    })
                    .transpose()?
                    .unwrap_or(max_del);
                let new_items = if args.len() > 3 { &args[3..] } else { &[] };
                let mut v: Vec<JsValue> = elements[..s].to_vec();
                v.extend_from_slice(new_items);
                v.extend_from_slice(&elements[s + del..]);
                Ok(JsValue::new_array(v))
            }),
        );

        // with(index, value)
        proto.insert(
            "with".into(),
            builtin_fn("with", 2, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let index = args
                    .get(1)
                    .unwrap_or(&JsValue::Smi(0))
                    .to_integer_or_infinity()?;
                let value = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let (mut elements, len) = try_to_array_like_elements(arr)?;
                let len_f = len as f64;
                let actual = if index < 0.0 { len_f + index } else { index };
                if actual < 0.0 || actual >= len_f {
                    return Err(StatorError::RangeError(format!(
                        "Invalid index : {}",
                        args.get(1).unwrap_or(&JsValue::Smi(0)).to_js_string()?
                    )));
                }
                elements[actual as usize] = value;
                Ok(JsValue::new_array(elements))
            }),
        );

        // NOTE: Array.prototype.group and Array.prototype.groupToMap were
        // removed — they were a Stage 3 TC39 proposal that shipped as
        // `Object.groupBy` / `Map.groupBy` instead (ES2024 §22.1.2.5 /
        // §24.1.2.1).  The instance methods are intentionally absent.

        // §23.1.3.36 Array.prototype.toString()
        // Equivalent to calling this.join() — produces a comma-separated string
        // of elements (undefined/null become empty strings).
        proto.insert(
            "toString".into(),
            builtin_fn("toString", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let (elements, _len) = to_array_like_elements(arr);
                let parts: Vec<String> = elements
                    .iter()
                    .map(|v| match v {
                        JsValue::Undefined | JsValue::Null => Ok(String::new()),
                        other => other.to_js_string(),
                    })
                    .collect::<StatorResult<_>>()?;
                Ok(JsValue::String(parts.join(",").into()))
            }),
        );

        // §23.1.3.35 Array.prototype.toLocaleString()
        // Calls toLocaleString() on each element (falling back to toString()),
        // then joins results with ",".
        proto.insert(
            "toLocaleString".into(),
            builtin_fn("toLocaleString", 0, |args| {
                let arr = args.first().unwrap_or(&JsValue::Undefined);
                require_object_coercible(arr)?;
                let (elements, _len) = to_array_like_elements(arr);
                let parts: Vec<String> = elements
                    .iter()
                    .map(|v| match v {
                        JsValue::Undefined | JsValue::Null => Ok(String::new()),
                        JsValue::PlainObject(map) => {
                            if let Some(func) = map.borrow().get("toLocaleString").cloned() {
                                let result = dispatch_call_value(&func, vec![v.clone()])?;
                                result.to_js_string()
                            } else {
                                v.to_js_string()
                            }
                        }
                        other => other.to_js_string(),
                    })
                    .collect::<StatorResult<_>>()?;
                Ok(JsValue::String(parts.join(",").into()))
            }),
        );

        // §23.1.3.38 Array.prototype[@@toStringTag] is NOT defined by spec,
        // but we set @@unscopables. Skip toStringTag for Array.

        // §23.1.3.39 Array.prototype[@@unscopables]
        {
            let mut unscopables = PropertyMap::new();
            for name in &[
                "at",
                "copyWithin",
                "entries",
                "fill",
                "find",
                "findIndex",
                "findLast",
                "findLastIndex",
                "flat",
                "flatMap",
                "includes",
                "keys",
                "toReversed",
                "toSorted",
                "toSpliced",
                "values",
                "with",
            ] {
                unscopables.insert((*name).into(), JsValue::Boolean(true));
            }
            unscopables.freeze();
            proto.insert_with_attrs(
                "@@unscopables".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(unscopables))),
                PropertyAttributes::CONFIGURABLE,
            );
        }

        proto.make_all_non_enumerable();
        let arr_proto_rc = Rc::new(RefCell::new(proto));
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(arr_proto_rc.clone()),
        );

        // Array constructor: `Array()`, `Array(len)`, `Array(a, b, …)`
        props.insert(
            "__call__".into(),
            native(|args| {
                if args.is_empty() {
                    return Ok(JsValue::Array(Rc::new(RefCell::new(Vec::new()))));
                }
                if args.len() == 1 {
                    // §23.1.1.1: if the single argument is numeric, treat it
                    // as the array length — throw RangeError for invalid values
                    // (negative, fractional, NaN, ±Infinity).
                    match &args[0] {
                        JsValue::Smi(n) => {
                            let len = crate::builtins::util::checked_f64_to_length(*n as f64)?;
                            let v: Vec<JsValue> = vec![JsValue::TheHole; len];
                            return Ok(JsValue::Array(Rc::new(RefCell::new(v))));
                        }
                        JsValue::HeapNumber(n) => {
                            // Fractional, NaN, or ±Infinity → invalid array length.
                            if n.fract() != 0.0 {
                                return Err(crate::error::StatorError::RangeError(
                                    "Invalid array length".to_string(),
                                ));
                            }
                            let len = crate::builtins::util::checked_f64_to_length(*n)?;
                            let v: Vec<JsValue> = vec![JsValue::TheHole; len];
                            return Ok(JsValue::Array(Rc::new(RefCell::new(v))));
                        }
                        _ => {
                            // Single non-numeric arg → Array with one element.
                            return Ok(JsValue::Array(Rc::new(RefCell::new(args))));
                        }
                    }
                }
                Ok(JsValue::Array(Rc::new(RefCell::new(args))))
            }),
        );

        // §23.1.2.5 get Array[@@species] — returns `this`.
        props.insert(
            "__get_@@species__".into(),
            native(|args| Ok(args.first().cloned().unwrap_or(JsValue::Undefined))),
        );

        props.make_all_non_enumerable();
        let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
        // §23.1.3.1 Array.prototype.constructor
        arr_proto_rc.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
        ctor
    })
}
// ── Symbol constructor ────────────────────────────────────────────────────────────

/// Build the `Symbol` constructor/namespace object.
///
/// The returned `PlainObject` acts both as a callable (`Symbol()` /
/// `Symbol("desc")`) — handled by the interpreter when it sees a
/// `NativeFunction` stored under the `"Symbol"` key — and as a namespace
/// carrying static methods (`for`, `keyFor`) and well-known symbol
/// constants (`iterator`, `toPrimitive`, etc.).
///
/// Because JavaScript’s `Symbol` is *not* a constructor (i.e. `new Symbol()`
/// is a `TypeError`), the top-level value is a `NativeFunction` that
/// creates symbols, and the static properties are patched onto the
/// surrounding `PlainObject` wrapper.
#[inline(never)]
fn make_symbol() -> JsValue {
    let mut props = PropertyMap::new();

    // ── Static methods ────────────────────────────────────────────────────

    // Symbol.for(key) — global symbol registry
    props.insert(
        "for".into(),
        native(|args| {
            let key = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
            Ok(JsValue::Symbol(symbol_for(&key)))
        }),
    );

    // Symbol.keyFor(sym) — reverse lookup in the global registry
    props.insert(
        "keyFor".into(),
        native(|args| {
            let sym = args.first().unwrap_or(&JsValue::Undefined);
            if let JsValue::Symbol(id) = sym {
                match symbol_key_for(*id) {
                    Some(key) => Ok(JsValue::String(key.into())),
                    None => Ok(JsValue::Undefined),
                }
            } else {
                Err(crate::error::StatorError::TypeError(
                    "Symbol.keyFor requires a symbol argument".into(),
                ))
            }
        }),
    );

    // ── Well-known symbols ───────────────────────────────────────────────

    props.insert("iterator".into(), JsValue::Symbol(SYMBOL_ITERATOR));
    props.insert("toPrimitive".into(), JsValue::Symbol(SYMBOL_TO_PRIMITIVE));
    props.insert("hasInstance".into(), JsValue::Symbol(SYMBOL_HAS_INSTANCE));
    props.insert("toStringTag".into(), JsValue::Symbol(SYMBOL_TO_STRING_TAG));
    props.insert(
        "isConcatSpreadable".into(),
        JsValue::Symbol(SYMBOL_IS_CONCAT_SPREADABLE),
    );
    props.insert("species".into(), JsValue::Symbol(SYMBOL_SPECIES));
    props.insert("match".into(), JsValue::Symbol(SYMBOL_MATCH));
    props.insert("replace".into(), JsValue::Symbol(SYMBOL_REPLACE));
    props.insert("search".into(), JsValue::Symbol(SYMBOL_SEARCH));
    props.insert("split".into(), JsValue::Symbol(SYMBOL_SPLIT));
    props.insert("unscopables".into(), JsValue::Symbol(SYMBOL_UNSCOPABLES));
    props.insert(
        "asyncIterator".into(),
        JsValue::Symbol(SYMBOL_ASYNC_ITERATOR),
    );
    props.insert("matchAll".into(), JsValue::Symbol(SYMBOL_MATCH_ALL));
    props.insert("dispose".into(), JsValue::Symbol(SYMBOL_DISPOSE));
    props.insert("asyncDispose".into(), JsValue::Symbol(SYMBOL_ASYNC_DISPOSE));

    // ── Symbol.prototype ─────────────────────────────────────────────────
    {
        fn symbol_this_id(this: &JsValue) -> Option<u64> {
            match this {
                JsValue::Symbol(id) => Some(*id),
                JsValue::PlainObject(map) => {
                    let borrow = map.borrow();
                    match borrow
                        .get("__wrapped__")
                        .or_else(|| borrow.get("[[PrimitiveValue]]"))
                    {
                        Some(JsValue::Symbol(id)) => Some(*id),
                        _ => None,
                    }
                }
                _ => None,
            }
        }

        let mut proto = PropertyMap::new();

        // Symbol.prototype.description — getter returning the description.
        proto.insert(
            "__get_description__".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                if let Some(id) = symbol_this_id(this) {
                    match symbol_description(id) {
                        Some(desc) => Ok(JsValue::String(desc.into())),
                        None => Ok(JsValue::Undefined),
                    }
                } else {
                    Err(crate::error::StatorError::TypeError(
                        "Symbol.prototype.description requires a symbol".into(),
                    ))
                }
            }),
        );

        // Symbol.prototype.toString()
        proto.insert(
            "toString".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                if let Some(id) = symbol_this_id(this) {
                    match symbol_description(id) {
                        Some(desc) => Ok(JsValue::String(format!("Symbol({desc})").into())),
                        None => Ok(JsValue::String("Symbol()".to_string().into())),
                    }
                } else {
                    Err(crate::error::StatorError::TypeError(
                        "Symbol.prototype.toString requires a symbol".into(),
                    ))
                }
            }),
        );

        // Symbol.prototype.valueOf()
        proto.insert(
            "valueOf".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                if let Some(id) = symbol_this_id(this) {
                    Ok(JsValue::Symbol(id))
                } else {
                    Err(crate::error::StatorError::TypeError(
                        "Symbol.prototype.valueOf requires a symbol".into(),
                    ))
                }
            }),
        );

        // Symbol.prototype[@@toPrimitive](hint) — returns the symbol itself.
        // Per §20.4.3.4 the hint argument is accepted but ignored.
        proto.insert(
            "@@toPrimitive".into(),
            native(|args| {
                let this = args.first().unwrap_or(&JsValue::Undefined);
                if let Some(id) = symbol_this_id(this) {
                    Ok(JsValue::Symbol(id))
                } else {
                    Err(crate::error::StatorError::TypeError(
                        "Symbol.prototype[@@toPrimitive] requires a symbol".into(),
                    ))
                }
            }),
        );

        // Symbol.prototype[@@toStringTag] = "Symbol"
        proto.insert("@@toStringTag".into(), JsValue::String("Symbol".into()));

        proto.make_all_non_enumerable();
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(Rc::new(RefCell::new(proto))),
        );
    }

    // ── The callable Symbol(desc?) ────────────────────────────────────────
    //
    // We store the callable itself under the reserved key "__call__" so the
    // interpreter can invoke `Symbol("desc")` while still allowing property
    // access on `Symbol.iterator` etc.
    props.insert(
        "__call__".into(),
        native(|args| {
            let desc = match args.first() {
                Some(JsValue::Undefined) | None => None,
                Some(v) => Some(v.to_js_string()?),
            };
            Ok(JsValue::Symbol(symbol_create(desc)))
        }),
    );

    // Symbol is NOT a constructor — `new Symbol()` must throw TypeError.
    props.insert("__no_construct__".into(), JsValue::Boolean(true));

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── Iterator (ES2025 §27.1.4) ────────────────────────────────────────────────

/// Build the `Iterator` constructor/namespace object with prototype helpers.
#[inline(never)]
fn make_iterator() -> JsValue {
    let mut props = PropertyMap::new();

    // ── Static method: Iterator.from ──────────────────────────────────────
    props.insert(
        "from".into(),
        native(|args| {
            let iterable = args.first().unwrap_or(&JsValue::Undefined);
            iterator_from(iterable)
        }),
    );

    // ── Static method: Iterator.concat(...iterables) — ES2025 §27.1.2.1 ──
    props.insert(
        "concat".into(),
        native(|args| {
            let mut all_items: Vec<JsValue> = Vec::new();
            for arg in &args {
                match arg {
                    JsValue::Array(arr) => {
                        all_items.extend(arr.borrow().iter().cloned());
                    }
                    JsValue::Iterator(iter) => {
                        let mut it = iter.borrow_mut();
                        while let Some(val) = it.next_item() {
                            all_items.push(val);
                        }
                    }
                    JsValue::String(s) => {
                        for ch in s.chars() {
                            all_items.push(JsValue::String(ch.to_string().into()));
                        }
                    }
                    _ => {
                        return Err(StatorError::TypeError(format!(
                            "Iterator.concat: value is not iterable (got {:?})",
                            arg
                        )));
                    }
                }
            }
            Ok(JsValue::Iterator(NativeIterator::from_items(all_items)))
        }),
    );

    // ── Prototype (instance) methods ─────────────────────────────────────
    //
    // In a full engine these would live on Iterator.prototype.  Here we
    // attach them as own properties so that `Iterator.prototype.map(…)` is
    // accessible as `Iterator.map(iter, mapper)` for direct testing and for
    // the bytecode to call via property lookup.
    let mut proto = PropertyMap::new();

    proto.insert(
        "map".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let mapper = args.get(1).unwrap_or(&JsValue::Undefined);
            iterator_map(iter, mapper)
        }),
    );
    proto.insert(
        "filter".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let predicate = args.get(1).unwrap_or(&JsValue::Undefined);
            iterator_filter(iter, predicate)
        }),
    );
    proto.insert(
        "take".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let limit = args
                .get(1)
                .unwrap_or(&JsValue::Undefined)
                .to_number()
                .unwrap_or(0.0);
            if limit.is_sign_negative() {
                return Err(StatorError::RangeError(
                    "Iterator.prototype.take limit must be non-negative".into(),
                ));
            }
            iterator_take(iter, limit as usize)
        }),
    );
    proto.insert(
        "drop".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let count = args
                .get(1)
                .unwrap_or(&JsValue::Undefined)
                .to_number()
                .unwrap_or(0.0);
            if count.is_sign_negative() {
                return Err(StatorError::RangeError(
                    "Iterator.prototype.drop count must be non-negative".into(),
                ));
            }
            iterator_drop(iter, count as usize)
        }),
    );
    proto.insert(
        "flatMap".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let mapper = args.get(1).unwrap_or(&JsValue::Undefined);
            iterator_flat_map(iter, mapper)
        }),
    );
    proto.insert(
        "reduce".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let reducer = args.get(1).unwrap_or(&JsValue::Undefined);
            let initial = args.get(2).cloned();
            iterator_reduce(iter, reducer, initial)
        }),
    );
    proto.insert(
        "toArray".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            iterator_to_array(iter)
        }),
    );
    proto.insert(
        "forEach".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let callback = args.get(1).unwrap_or(&JsValue::Undefined);
            iterator_for_each(iter, callback)
        }),
    );
    proto.insert(
        "some".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let predicate = args.get(1).unwrap_or(&JsValue::Undefined);
            iterator_some(iter, predicate)
        }),
    );
    proto.insert(
        "every".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let predicate = args.get(1).unwrap_or(&JsValue::Undefined);
            iterator_every(iter, predicate)
        }),
    );
    proto.insert(
        "find".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined);
            let predicate = args.get(1).unwrap_or(&JsValue::Undefined);
            iterator_find(iter, predicate)
        }),
    );

    // §27.1.2 %IteratorPrototype%[@@iterator]() — returns `this`.
    proto.insert(
        "@@iterator".into(),
        native(|args| {
            let iter = args.first().unwrap_or(&JsValue::Undefined).clone();
            Ok(iter)
        }),
    );

    // §27.1.2 Iterator.prototype[@@toStringTag] = "Iterator"
    proto.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String("Iterator".into()),
        PropertyAttributes::CONFIGURABLE,
    );

    proto.make_all_non_enumerable();
    props.insert(
        "prototype".into(),
        JsValue::PlainObject(Rc::new(RefCell::new(proto))),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── AsyncIterator (ES2025 §27.1.4.2) ─────────────────────────────────────────

/// Build the `AsyncIterator` constructor/namespace object with prototype
/// helpers mirroring [`make_iterator`].  Each method returns a `Promise`.
#[inline(never)]
fn make_async_iterator() -> JsValue {
    use crate::builtins::promise::MicrotaskQueue;

    let mut props = PropertyMap::new();
    let queue = MicrotaskQueue::new();

    // ── Static method: AsyncIterator.from ─────────────────────────────────
    {
        let q = queue.clone();
        props.insert(
            "from".into(),
            native(move |args| {
                let iterable = args.first().unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_from(iterable, &q))
            }),
        );
    }

    // ── Prototype (instance) methods ─────────────────────────────────────
    let mut proto = PropertyMap::new();

    {
        let q = queue.clone();
        proto.insert(
            "map".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let mapper = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_map(iter, mapper, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "filter".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let predicate = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_filter(iter, predicate, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "take".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let limit = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_number()
                    .unwrap_or(0.0);
                Ok(async_iterator_take(iter, limit.max(0.0) as usize, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "drop".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let count = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_number()
                    .unwrap_or(0.0);
                Ok(async_iterator_drop(iter, count.max(0.0) as usize, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "flatMap".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let mapper = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_flat_map(iter, mapper, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "reduce".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let reducer = args.get(1).unwrap_or(&JsValue::Undefined);
                let initial = args.get(2).cloned();
                Ok(async_iterator_reduce(iter, reducer, initial, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "toArray".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_to_array(iter, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "forEach".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let callback = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_for_each(iter, callback, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "some".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let predicate = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_some(iter, predicate, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "every".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let predicate = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_every(iter, predicate, &q))
            }),
        );
    }
    {
        let q = queue.clone();
        proto.insert(
            "find".into(),
            native(move |args| {
                let iter = args.first().unwrap_or(&JsValue::Undefined);
                let predicate = args.get(1).unwrap_or(&JsValue::Undefined);
                Ok(async_iterator_find(iter, predicate, &q))
            }),
        );
    }

    // §27.1.4.2 AsyncIterator.prototype[@@toStringTag] = "AsyncIterator"
    proto.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String("AsyncIterator".into()),
        PropertyAttributes::CONFIGURABLE,
    );

    proto.make_all_non_enumerable();
    props.insert(
        "prototype".into(),
        JsValue::PlainObject(Rc::new(RefCell::new(proto))),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── Map constructor (ES2025 §24.1) ───────────────────────────────────────────

/// Build the `Map` constructor/namespace object.
///
/// The returned `PlainObject` provides a `__call__` constructor that
/// optionally accepts an iterable of `[key, value]` pairs, plus prototype
/// methods (`get`, `set`, `has`, `delete`, `clear`, `forEach`, `keys`,
/// `values`, `entries`, `size`).
#[inline(never)]
fn make_map_builtin() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // ── Constructor: new Map() / new Map(iterable) ───────────────────────
        props.insert(
            "__call__".into(),
            native(|args| {
                let arg = args.first().cloned().unwrap_or(JsValue::Undefined);
                let m = match &arg {
                    JsValue::Undefined | JsValue::Null => map_new(),
                    _ => {
                        map_from_iterable(iterable_to_map_pairs(&arg).map_err(|err| match err {
                            StatorError::TypeError(message)
                                if message == "value is not iterable" =>
                            {
                                StatorError::TypeError("Map: argument is not iterable".into())
                            }
                            other => other,
                        })?)
                    }
                };
                build_map_instance(m)
            }),
        );

        // ── Map.groupBy(items, callbackFn) — ES2024 §24.1.2.1 ──────────────
        props.insert(
            "groupBy".into(),
            builtin_fn("groupBy", 2, |args| {
                let items = args.first().unwrap_or(&JsValue::Undefined).clone();
                let cb = args.get(1).cloned().unwrap_or(JsValue::Undefined);

                // §24.1.2.1 step 2: callbackFn must be callable.
                if !is_callable(&cb) {
                    return Err(StatorError::TypeError(
                        "Map.groupBy: callbackFn is not a function".into(),
                    ));
                }

                // Collect elements from iterable.
                let elements: Vec<JsValue> = match &items {
                    JsValue::Array(a) => a.borrow().clone(),
                    JsValue::String(s) => s
                        .chars()
                        .map(|c| JsValue::String(c.to_string().into()))
                        .collect(),
                    JsValue::Iterator(iter) => {
                        let mut v = Vec::new();
                        while let Some(item) = iter.borrow_mut().next_item() {
                            v.push(item);
                        }
                        v
                    }
                    JsValue::PlainObject(map) => {
                        let borrow = map.borrow();
                        if let Some(len_val) = borrow.get("length") {
                            let len = match len_val {
                                JsValue::Smi(n) => *n as usize,
                                JsValue::HeapNumber(n) => n.trunc() as usize,
                                _ => 0,
                            };
                            (0..len)
                                .map(|i| {
                                    borrow
                                        .get(&i.to_string())
                                        .cloned()
                                        .unwrap_or(JsValue::Undefined)
                                })
                                .collect()
                        } else {
                            vec![]
                        }
                    }
                    _ => {
                        return Err(StatorError::TypeError(
                            "Map.groupBy: first argument is not iterable".into(),
                        ));
                    }
                };

                let result_map = Rc::new(RefCell::new(map_new()));
                for (i, item) in elements.iter().enumerate() {
                    let key = dispatch_call_value(&cb, vec![item.clone(), JsValue::Smi(i as i32)])?;
                    let existing = map_get(&result_map.borrow(), &key);
                    if let JsValue::Array(existing_arr) = existing {
                        existing_arr.borrow_mut().push(item.clone());
                    } else {
                        map_set(
                            &mut result_map.borrow_mut(),
                            key,
                            JsValue::new_array(vec![item.clone()]),
                        );
                    }
                }
                build_map_instance(result_map.borrow().clone())
            }),
        );

        // ── Map.prototype ─────────────────────────────────────────────────
        let map_proto_rc = {
            let mut proto = PropertyMap::new();
            for (method_name, hidden_name) in [
                ("has", "__map_has__"),
                ("get", "__map_get__"),
                ("set", "__map_set__"),
                ("delete", "__map_delete__"),
                ("clear", "__map_clear__"),
                ("forEach", "__map_for_each__"),
                ("keys", "__map_keys__"),
                ("values", "__map_values__"),
                ("entries", "__map_entries__"),
                ("getOrInsert", "__map_get_or_insert__"),
                ("getOrInsertComputed", "__map_get_or_insert_computed__"),
            ] {
                let name = method_name.to_string();
                let hidden = hidden_name.to_string();
                proto.insert(
                    name.clone(),
                    native(move |args| {
                        let receiver = args.first().unwrap_or(&JsValue::Undefined);
                        let rest: Vec<JsValue> = args.get(1..).unwrap_or(&[]).to_vec();
                        let method = get_hidden_method(
                            receiver,
                            "__is_map__",
                            &hidden,
                            &format!("Map.prototype.{name}"),
                        )?;
                        dispatch_call_value(&method, rest)
                    }),
                );
            }
            let entries_fn = native(|args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let method = get_hidden_method(
                    receiver,
                    "__is_map__",
                    "__map_entries__",
                    "Map.prototype.entries",
                )?;
                dispatch_call_value(&method, vec![])
            });
            proto.insert("entries".into(), entries_fn.clone());
            proto.insert("@@iterator".into(), entries_fn);
            proto.insert_with_attrs(
                "__get_size__".into(),
                native(|args| {
                    let receiver = args.first().unwrap_or(&JsValue::Undefined);
                    let getter = get_hidden_method(
                        receiver,
                        "__is_map__",
                        "__get_size__",
                        "get Map.prototype.size",
                    )?;
                    dispatch_call_value(&getter, vec![])
                }),
                PropertyAttributes::CONFIGURABLE,
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Map".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            proto.make_all_non_enumerable();
            let map_proto_rc = Rc::new(RefCell::new(proto));
            props.insert(
                "prototype".into(),
                JsValue::PlainObject(map_proto_rc.clone()),
            );
            map_proto_rc
        };

        // §24.1.2.2 get Map[@@species] — returns `this`.
        props.insert(
            "__get_@@species__".into(),
            native(|args| Ok(args.first().cloned().unwrap_or(JsValue::Undefined))),
        );

        props.make_all_non_enumerable();
        let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
        // §24.1.3.1 Map.prototype.constructor
        map_proto_rc.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
        ctor
    })
}

// ── Set constructor (ES2025 §24.2) ───────────────────────────────────────────

/// Build the `Set` constructor/namespace object.
///
/// The returned `PlainObject` provides a `__call__` constructor that
/// optionally accepts an iterable of values, plus prototype methods
/// (`add`, `has`, `delete`, `clear`, `forEach`, `keys`, `values`,
/// `entries`, `size`).
#[inline(never)]
fn make_set_builtin() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // ── Constructor: new Set() / new Set(iterable) ───────────────────────
        props.insert(
            "__call__".into(),
            native(|args| {
                let arg = args.first().cloned().unwrap_or(JsValue::Undefined);
                let s = match &arg {
                    JsValue::Undefined | JsValue::Null => set_new(),
                    _ => set_from_iterable(iterable_to_items(&arg).map_err(|err| match err {
                        StatorError::TypeError(message) if message == "value is not iterable" => {
                            StatorError::TypeError("Set: argument is not iterable".into())
                        }
                        other => other,
                    })?),
                };
                build_set_instance(s)
            }),
        );

        // ── Set.prototype ──────────────────────────────────────────────────
        let set_proto_rc = {
            let mut proto = PropertyMap::new();
            for (method_name, hidden_name) in [
                ("has", "__set_has__"),
                ("add", "__set_add__"),
                ("delete", "__set_delete__"),
                ("clear", "__set_clear__"),
                ("forEach", "__set_for_each__"),
                ("entries", "__set_entries__"),
                ("union", "union"),
                ("intersection", "intersection"),
                ("difference", "difference"),
                ("symmetricDifference", "symmetricDifference"),
                ("isSubsetOf", "isSubsetOf"),
                ("isSupersetOf", "isSupersetOf"),
                ("isDisjointFrom", "isDisjointFrom"),
            ] {
                let name = method_name.to_string();
                let hidden = hidden_name.to_string();
                proto.insert(
                    name.clone(),
                    native(move |args| {
                        let receiver = args.first().unwrap_or(&JsValue::Undefined);
                        let rest: Vec<JsValue> = args.get(1..).unwrap_or(&[]).to_vec();
                        let method = get_hidden_method(
                            receiver,
                            "__is_set__",
                            &hidden,
                            &format!("Set.prototype.{name}"),
                        )?;
                        dispatch_call_value(&method, rest)
                    }),
                );
            }
            let values_fn = native(|args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let method = get_hidden_method(
                    receiver,
                    "__is_set__",
                    "__set_values__",
                    "Set.prototype.values",
                )?;
                dispatch_call_value(&method, vec![])
            });
            proto.insert("values".into(), values_fn.clone());
            proto.insert("keys".into(), values_fn.clone());
            proto.insert("@@iterator".into(), values_fn);
            proto.insert_with_attrs(
                "__get_size__".into(),
                native(|args| {
                    let receiver = args.first().unwrap_or(&JsValue::Undefined);
                    let getter = get_hidden_method(
                        receiver,
                        "__is_set__",
                        "__get_size__",
                        "get Set.prototype.size",
                    )?;
                    dispatch_call_value(&getter, vec![])
                }),
                PropertyAttributes::CONFIGURABLE,
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Set".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            proto.make_all_non_enumerable();
            let set_proto_rc_inner = Rc::new(RefCell::new(proto));
            props.insert(
                "prototype".into(),
                JsValue::PlainObject(set_proto_rc_inner.clone()),
            );
            set_proto_rc_inner
        };

        // §24.2.2.2 get Set[@@species] — returns `this`.
        props.insert(
            "__get_@@species__".into(),
            native(|args| Ok(args.first().cloned().unwrap_or(JsValue::Undefined))),
        );

        props.make_all_non_enumerable();
        let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
        // §24.2.3.1 Set.prototype.constructor
        set_proto_rc.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
        ctor
    })
}

// ── WeakMap constructor (ES2025 §24.3) ───────────────────────────────────────

/// Build the `WeakMap` constructor/namespace object.
///
/// The returned `PlainObject` provides a `__call__` constructor that creates
/// a new `WeakMap` instance with prototype methods (`get`, `set`, `has`,
/// `delete`).  Keys must be `Object` pointers; non-object keys cause a
/// `TypeError`.
#[inline(never)]
fn make_weak_map_builtin() -> JsValue {
    let mut props = PropertyMap::new();

    props.insert(
        "__call__".into(),
        native(|args| {
            let inner: Rc<RefCell<HashMap<usize, JsValue>>> = Rc::new(RefCell::new(HashMap::new()));
            let obj_rc: Rc<RefCell<PropertyMap>> = Rc::new(RefCell::new(PropertyMap::new()));
            {
                let mut obj = obj_rc.borrow_mut();
                obj.insert_with_attrs(
                    "__is_weakmap__".into(),
                    JsValue::Boolean(true),
                    PropertyAttributes::empty(),
                );

                // get(key)
                {
                    let inner = Rc::clone(&inner);
                    obj.insert(
                        "get".into(),
                        native(move |a| {
                            let key = a.first().unwrap_or(&JsValue::Undefined);
                            if let Some(id) = weak_collection_key(key) {
                                Ok(inner
                                    .borrow()
                                    .get(&id)
                                    .cloned()
                                    .unwrap_or(JsValue::Undefined))
                            } else {
                                Ok(JsValue::Undefined)
                            }
                        }),
                    );
                }
                // set(key, value) — returns the WeakMap per ES §24.3.3.5
                {
                    let inner = Rc::clone(&inner);
                    let self_ref = Rc::clone(&obj_rc);
                    obj.insert(
                        "set".into(),
                        native(move |a| {
                            let key = a.first().unwrap_or(&JsValue::Undefined);
                            let val = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                            if let Some(id) = weak_collection_key(key) {
                                inner.borrow_mut().insert(id, val);
                                Ok(JsValue::PlainObject(Rc::clone(&self_ref)))
                            } else {
                                Err(StatorError::TypeError(
                                    "Invalid value used as weak map key".into(),
                                ))
                            }
                        }),
                    );
                }
                // has(key)
                {
                    let inner = Rc::clone(&inner);
                    obj.insert(
                        "has".into(),
                        native(move |a| {
                            let key = a.first().unwrap_or(&JsValue::Undefined);
                            if let Some(id) = weak_collection_key(key) {
                                Ok(JsValue::Boolean(inner.borrow().contains_key(&id)))
                            } else {
                                Ok(JsValue::Boolean(false))
                            }
                        }),
                    );
                }
                // delete(key)
                {
                    let inner = Rc::clone(&inner);
                    obj.insert(
                        "delete".into(),
                        native(move |a| {
                            let key = a.first().unwrap_or(&JsValue::Undefined);
                            if let Some(id) = weak_collection_key(key) {
                                Ok(JsValue::Boolean(inner.borrow_mut().remove(&id).is_some()))
                            } else {
                                Ok(JsValue::Boolean(false))
                            }
                        }),
                    );
                }

                // §24.3.3.2.1 WeakMap.prototype.getOrInsert(key, value)  — ES2025
                {
                    let inner = Rc::clone(&inner);
                    obj.insert(
                        "getOrInsert".into(),
                        native(move |a| {
                            let key = a.first().unwrap_or(&JsValue::Undefined);
                            let default_val = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                            if let Some(id) = weak_collection_key(key) {
                                if let Some(existing) = inner.borrow().get(&id).cloned() {
                                    Ok(existing)
                                } else {
                                    inner.borrow_mut().insert(id, default_val.clone());
                                    Ok(default_val)
                                }
                            } else {
                                Err(StatorError::TypeError(
                                    "Invalid value used as weak map key".into(),
                                ))
                            }
                        }),
                    );
                }
                // §24.3.3.2.2 WeakMap.prototype.getOrInsertComputed(key, callbackFn)  — ES2025
                {
                    let inner = Rc::clone(&inner);
                    obj.insert(
                        "getOrInsertComputed".into(),
                        native(move |a| {
                            let key = a.first().unwrap_or(&JsValue::Undefined);
                            let callback = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                            if let Some(id) = weak_collection_key(key) {
                                if let Some(existing) = inner.borrow().get(&id).cloned() {
                                    Ok(existing)
                                } else {
                                    let computed =
                                        dispatch_call_value(&callback, vec![key.clone()])?;
                                    inner.borrow_mut().insert(id, computed.clone());
                                    Ok(computed)
                                }
                            } else {
                                Err(StatorError::TypeError(
                                    "Invalid value used as weak map key".into(),
                                ))
                            }
                        }),
                    );
                }

                // §24.3.3.6 WeakMap.prototype[@@toStringTag] = "WeakMap"
                obj.insert_with_attrs(
                    "@@toStringTag".into(),
                    JsValue::String("WeakMap".into()),
                    PropertyAttributes::CONFIGURABLE,
                );
                obj.make_all_non_enumerable();
            }

            // §24.3.1.1 step 5–8: populate from iterable argument
            let iterable = args.first().cloned().unwrap_or(JsValue::Undefined);
            if !matches!(iterable, JsValue::Undefined | JsValue::Null) {
                let (elements, _) = to_array_like_elements(&iterable);
                for item in &elements {
                    let (pair, _) = to_array_like_elements(item);
                    let k = pair.first().cloned().unwrap_or(JsValue::Undefined);
                    let v = pair.get(1).cloned().unwrap_or(JsValue::Undefined);
                    if let Some(id) = weak_collection_key(&k) {
                        inner.borrow_mut().insert(id, v);
                    } else {
                        return Err(StatorError::TypeError(
                            "Invalid value used as weak map key".into(),
                        ));
                    }
                }
            }

            Ok(JsValue::PlainObject(obj_rc))
        }),
    );

    // ── WeakMap.prototype ──────────────────────────────────────────────
    {
        let mut proto = PropertyMap::new();
        for method_name in &[
            "has",
            "get",
            "set",
            "delete",
            "getOrInsert",
            "getOrInsertComputed",
        ] {
            let name = method_name.to_string();
            proto.insert(
                name.clone(),
                native(move |args| {
                    let receiver = args.first().unwrap_or(&JsValue::Undefined);
                    let rest: Vec<JsValue> = args.get(1..).unwrap_or(&[]).to_vec();
                    if let JsValue::PlainObject(map) = receiver
                        && let Some(JsValue::NativeFunction(f)) = map.borrow().get(&name).cloned()
                    {
                        return f(rest);
                    }
                    Ok(JsValue::Undefined)
                }),
            );
        }
        proto.insert("constructor".into(), JsValue::Undefined);
        proto.insert_with_attrs(
            "@@toStringTag".into(),
            JsValue::String("WeakMap".into()),
            PropertyAttributes::CONFIGURABLE,
        );
        proto.make_all_non_enumerable();
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(Rc::new(RefCell::new(proto))),
        );
    }

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── WeakSet constructor (ES2025 §24.4) ───────────────────────────────────────

/// Build the `WeakSet` constructor/namespace object.
///
/// The returned `PlainObject` provides a `__call__` constructor that creates
/// a new `WeakSet` instance with prototype methods (`add`, `has`, `delete`).
/// Values must be `Object` pointers; non-object values cause a `TypeError`.
#[inline(never)]
fn make_weak_set_builtin() -> JsValue {
    let mut props = PropertyMap::new();

    props.insert(
        "__call__".into(),
        native(|args| {
            let inner: Rc<RefCell<HashSet<usize>>> = Rc::new(RefCell::new(HashSet::new()));
            let obj_rc: Rc<RefCell<PropertyMap>> = Rc::new(RefCell::new(PropertyMap::new()));
            {
                let mut obj = obj_rc.borrow_mut();
                obj.insert_with_attrs(
                    "__is_weakset__".into(),
                    JsValue::Boolean(true),
                    PropertyAttributes::empty(),
                );

                // add(value) — returns the WeakSet per ES §24.4.3.1
                {
                    let inner = Rc::clone(&inner);
                    let self_ref = Rc::clone(&obj_rc);
                    obj.insert(
                        "add".into(),
                        native(move |a| {
                            let val = a.first().unwrap_or(&JsValue::Undefined);
                            if let Some(key) = weak_collection_key(val) {
                                inner.borrow_mut().insert(key);
                                Ok(JsValue::PlainObject(Rc::clone(&self_ref)))
                            } else {
                                Err(StatorError::TypeError(
                                    "Invalid value used in weak set".into(),
                                ))
                            }
                        }),
                    );
                }
                // has(value)
                {
                    let inner = Rc::clone(&inner);
                    obj.insert(
                        "has".into(),
                        native(move |a| {
                            let val = a.first().unwrap_or(&JsValue::Undefined);
                            if let Some(key) = weak_collection_key(val) {
                                Ok(JsValue::Boolean(inner.borrow().contains(&key)))
                            } else {
                                Ok(JsValue::Boolean(false))
                            }
                        }),
                    );
                }
                // delete(value)
                {
                    let inner = Rc::clone(&inner);
                    obj.insert(
                        "delete".into(),
                        native(move |a| {
                            let val = a.first().unwrap_or(&JsValue::Undefined);
                            if let Some(key) = weak_collection_key(val) {
                                Ok(JsValue::Boolean(inner.borrow_mut().remove(&key)))
                            } else {
                                Ok(JsValue::Boolean(false))
                            }
                        }),
                    );
                }

                // §24.4.3.5 WeakSet.prototype[@@toStringTag] = "WeakSet"
                obj.insert_with_attrs(
                    "@@toStringTag".into(),
                    JsValue::String("WeakSet".into()),
                    PropertyAttributes::CONFIGURABLE,
                );
                obj.make_all_non_enumerable();
            }

            // §24.4.1.1 step 5–8: populate from iterable argument
            let iterable = args.first().cloned().unwrap_or(JsValue::Undefined);
            if !matches!(iterable, JsValue::Undefined | JsValue::Null) {
                let (elements, _) = to_array_like_elements(&iterable);
                for item in &elements {
                    if let Some(key) = weak_collection_key(item) {
                        inner.borrow_mut().insert(key);
                    } else {
                        return Err(StatorError::TypeError(
                            "Invalid value used in weak set".into(),
                        ));
                    }
                }
            }

            Ok(JsValue::PlainObject(obj_rc))
        }),
    );

    // ── WeakSet.prototype ─────────────────────────────────────────────
    {
        let mut proto = PropertyMap::new();
        for method_name in &["has", "add", "delete"] {
            let name = method_name.to_string();
            proto.insert(
                name.clone(),
                native(move |args| {
                    let receiver = args.first().unwrap_or(&JsValue::Undefined);
                    let rest: Vec<JsValue> = args.get(1..).unwrap_or(&[]).to_vec();
                    if let JsValue::PlainObject(map) = receiver
                        && let Some(JsValue::NativeFunction(f)) = map.borrow().get(&name).cloned()
                    {
                        return f(rest);
                    }
                    Ok(JsValue::Undefined)
                }),
            );
        }
        proto.insert("constructor".into(), JsValue::Undefined);
        proto.insert_with_attrs(
            "@@toStringTag".into(),
            JsValue::String("WeakSet".into()),
            PropertyAttributes::CONFIGURABLE,
        );
        proto.make_all_non_enumerable();
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(Rc::new(RefCell::new(proto))),
        );
    }

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── WeakRef constructor (ES2025 §26.1) ───────────────────────────────────────

/// Build the `WeakRef` constructor/namespace object.
///
/// The returned `PlainObject` provides a `__call__` constructor that creates
/// a new `WeakRef` instance with hidden per-instance state and a shared
/// `WeakRef.prototype.deref` method. The target must be an object or a
/// non-registered symbol; other values cause a `TypeError`.
#[inline(never)]
fn make_weak_ref_builtin() -> JsValue {
    let mut props = PropertyMap::new();

    props.insert(
        "__call__".into(),
        native(|args| {
            let target = args.first().unwrap_or(&JsValue::Undefined);
            let wr = match target {
                JsValue::Object(ptr) => weak_ref_new(*ptr)?,
                JsValue::PlainObject(rc) => weak_ref_new_plain(rc),
                JsValue::Symbol(id) => weak_ref_new_symbol(*id)?,
                _ => {
                    return Err(StatorError::TypeError(
                        "WeakRef target must be an object or non-registered symbol".into(),
                    ));
                }
            };
            let inner = Rc::new(RefCell::new(wr));
            let mut obj = PropertyMap::new();
            obj.insert_with_attrs(
                "__is_weakref__".into(),
                JsValue::Boolean(true),
                PropertyAttributes::empty(),
            );

            // Hidden per-instance deref implementation used by WeakRef.prototype.deref.
            {
                let inner = Rc::clone(&inner);
                obj.insert(
                    "__weakref_deref__".into(),
                    native(move |_a| Ok(weak_ref_deref(&inner.borrow()))),
                );
            }

            obj.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("WeakRef".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            obj.make_all_non_enumerable();
            Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
        }),
    );

    // ── WeakRef.prototype ─────────────────────────────────────────────
    {
        let mut proto = PropertyMap::new();
        proto.insert(
            "deref".into(),
            native(|args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let method = get_hidden_method(
                    receiver,
                    "__is_weakref__",
                    "__weakref_deref__",
                    "WeakRef.prototype.deref",
                )?;
                dispatch_call_value(&method, vec![])
            }),
        );
        proto.insert("constructor".into(), JsValue::Undefined);
        proto.insert_with_attrs(
            "@@toStringTag".into(),
            JsValue::String("WeakRef".into()),
            PropertyAttributes::CONFIGURABLE,
        );
        proto.make_all_non_enumerable();
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(Rc::new(RefCell::new(proto))),
        );
    }

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── FinalizationRegistry constructor (ES2025 §26.2) ─────────────────────────

/// Build the `FinalizationRegistry` constructor/namespace object.
///
/// The returned `PlainObject` provides a `__call__` constructor that creates
/// a new `FinalizationRegistry` instance with hidden per-instance state and
/// shared prototype methods. The cleanup callback is stored as a JS-level value;
/// actual invocation happens when the GC integration is complete.
#[inline(never)]
fn make_finalization_registry_builtin() -> JsValue {
    let mut props = PropertyMap::new();

    props.insert(
        "__call__".into(),
        native(|args| {
            let callback = args.first().cloned().unwrap_or(JsValue::Undefined);
            if !is_callable(&callback) {
                return Err(StatorError::TypeError(
                    "FinalizationRegistry requires a callable cleanup callback".into(),
                ));
            }

            let inner = Rc::new(RefCell::new(finalization_registry_new()));
            let callback = Rc::new(callback);
            let mut obj = PropertyMap::new();

            obj.insert_with_attrs(
                "__is_finalization_registry__".into(),
                JsValue::Boolean(true),
                PropertyAttributes::empty(),
            );

            // register(target, heldValue [, unregisterToken])
            {
                let inner = Rc::clone(&inner);
                obj.insert(
                    "__finalization_registry_register__".into(),
                    native(move |a| {
                        let target = a.first().unwrap_or(&JsValue::Undefined);
                        let held_value = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                        let token = a.get(2).unwrap_or(&JsValue::Undefined);

                        match target {
                            JsValue::Object(ptr) => {
                                if matches!(&held_value, JsValue::Object(held_ptr) if *held_ptr == *ptr) {
                                    return Err(StatorError::TypeError(
                                        "FinalizationRegistry held value must not be the target"
                                            .into(),
                                    ));
                                }
                                let unregister_token = match token {
                                    JsValue::Object(tok_ptr) => {
                                        Some(TokenKey::Address(*tok_ptr as usize))
                                    }
                                    JsValue::PlainObject(tok_rc) => {
                                        Some(TokenKey::Address(Rc::as_ptr(tok_rc) as usize))
                                    }
                                    JsValue::Symbol(id) => Some(TokenKey::Symbol(*id)),
                                    JsValue::Undefined => None,
                                    _ => {
                                        return Err(StatorError::TypeError(
                                            "unregister token must be an object, symbol, or undefined"
                                                .into(),
                                        ));
                                    }
                                };
                                finalization_registry_register_with_token_key(
                                    &mut inner.borrow_mut(),
                                    *ptr,
                                    held_value,
                                    unregister_token,
                                )?;
                                Ok(JsValue::Undefined)
                            }
                            JsValue::PlainObject(rc) => {
                                if matches!(&held_value, JsValue::PlainObject(held_rc) if Rc::ptr_eq(held_rc, rc))
                                {
                                    return Err(StatorError::TypeError(
                                        "FinalizationRegistry held value must not be the target"
                                            .into(),
                                    ));
                                }
                                let unregister_token = match token {
                                    JsValue::Object(tok_ptr) => {
                                        Some(TokenKey::Address(*tok_ptr as usize))
                                    }
                                    JsValue::PlainObject(tok_rc) => {
                                        Some(TokenKey::Address(Rc::as_ptr(tok_rc) as usize))
                                    }
                                    JsValue::Symbol(id) => Some(TokenKey::Symbol(*id)),
                                    JsValue::Undefined => None,
                                    _ => {
                                        return Err(StatorError::TypeError(
                                            "unregister token must be an object, symbol, or undefined"
                                                .into(),
                                        ));
                                    }
                                };
                                finalization_registry_register_plain_with_token_key(
                                    &mut inner.borrow_mut(),
                                    rc,
                                    held_value,
                                    unregister_token,
                                );
                                Ok(JsValue::Undefined)
                            }
                            _ => Err(StatorError::TypeError(
                                "FinalizationRegistry target must be an object".into(),
                            )),
                        }
                    }),
                );
            }

            // unregister(unregisterToken)
            {
                let inner = Rc::clone(&inner);
                obj.insert(
                    "__finalization_registry_unregister__".into(),
                    native(move |a| {
                        let token = a.first().unwrap_or(&JsValue::Undefined);
                        match token {
                            JsValue::Object(ptr) => Ok(JsValue::Boolean(
                                finalization_registry_unregister(&mut inner.borrow_mut(), *ptr)?,
                            )),
                            JsValue::PlainObject(rc) => Ok(JsValue::Boolean(
                                finalization_registry_unregister_plain(&mut inner.borrow_mut(), rc),
                            )),
                            JsValue::Symbol(id) => Ok(JsValue::Boolean(
                                finalization_registry_unregister_by_key(
                                    &mut inner.borrow_mut(),
                                    TokenKey::Symbol(*id),
                                ),
                            )),
                            _ => Err(StatorError::TypeError(
                                "unregister token must be an object or symbol".into(),
                            )),
                        }
                    }),
                );
            }

            // cleanupSome() — sweep plain targets, then drain the queue
            {
                let inner = Rc::clone(&inner);
                let cb = Rc::clone(&callback);
                obj.insert(
                    "__finalization_registry_cleanup_some__".into(),
                    native(move |_a| {
                        finalization_registry_sweep_plain(&mut inner.borrow_mut());
                        let held_values = finalization_registry_drain(&mut inner.borrow_mut());
                        for held in held_values {
                            dispatch_call_value(cb.as_ref(), vec![held])?;
                        }
                        Ok(JsValue::Undefined)
                    }),
                );
            }

            // __notify__ — internal GC hook exposed for testing
            {
                let inner = Rc::clone(&inner);
                let cb = Rc::clone(&callback);
                obj.insert(
                    "__finalization_registry_notify__".into(),
                    native(move |a| {
                        let target = a.first().unwrap_or(&JsValue::Undefined);
                        if let JsValue::Object(ptr) = target {
                            finalization_registry_notify(&mut inner.borrow_mut(), *ptr);
                            let registry = Rc::clone(&inner);
                            let callback = Rc::clone(&cb);
                            if !crate::builtins::promise::enqueue_active_microtask(Box::new(
                                move || {
                                    let held_values =
                                        finalization_registry_drain(&mut registry.borrow_mut());
                                    for held in held_values {
                                        let _ = dispatch_call_value(callback.as_ref(), vec![held]);
                                    }
                                },
                            )) {
                                let held_values =
                                    finalization_registry_drain(&mut inner.borrow_mut());
                                for held in held_values {
                                    let _ = dispatch_call_value(cb.as_ref(), vec![held]);
                                }
                            }
                        }
                        Ok(JsValue::Undefined)
                    }),
                );
            }

            obj.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("FinalizationRegistry".into()),
                PropertyAttributes::CONFIGURABLE,
            );

            obj.make_all_non_enumerable();
            Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
        }),
    );

    // ── FinalizationRegistry.prototype ────────────────────────────────
    {
        let mut proto = PropertyMap::new();
        for (method_name, hidden_name) in [
            ("register", "__finalization_registry_register__"),
            ("unregister", "__finalization_registry_unregister__"),
            ("cleanupSome", "__finalization_registry_cleanup_some__"),
            ("__notify__", "__finalization_registry_notify__"),
        ] {
            let name = method_name.to_string();
            let hidden = hidden_name.to_string();
            proto.insert(
                name.clone(),
                native(move |args| {
                    let receiver = args.first().unwrap_or(&JsValue::Undefined);
                    let rest: Vec<JsValue> = args.get(1..).unwrap_or(&[]).to_vec();
                    let method = get_hidden_method(
                        receiver,
                        "__is_finalization_registry__",
                        &hidden,
                        &format!("FinalizationRegistry.prototype.{name}"),
                    )?;
                    dispatch_call_value(&method, rest)
                }),
            );
        }
        proto.insert("constructor".into(), JsValue::Undefined);
        proto.insert_with_attrs(
            "@@toStringTag".into(),
            JsValue::String("FinalizationRegistry".into()),
            PropertyAttributes::CONFIGURABLE,
        );
        proto.make_all_non_enumerable();
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(Rc::new(RefCell::new(proto))),
        );
    }

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

// ── String constructor ───────────────────────────────────────────────────────

// ── Function constructor (ES2025 §20.2) ──────────────────────────────────────

fn function_prototype_value() -> Option<JsValue> {
    current_global_env().and_then(|globals| match globals.borrow().get("Function").cloned() {
        Some(JsValue::PlainObject(map)) => map.borrow().get("prototype").cloned(),
        _ => None,
    })
}

fn create_bound_function_object(call_fn: JsValue, name: String, length: i32) -> JsValue {
    let mut props = PropertyMap::new();
    props.insert("__call__".to_string(), call_fn);
    props.insert("name".to_string(), JsValue::String(name.into()));
    props.insert("length".to_string(), JsValue::Smi(length));
    props.insert(
        "source".to_string(),
        JsValue::String(function_to_string("").into()),
    );
    if let Some(function_proto) = function_prototype_value() {
        props.insert("__proto__".to_string(), function_proto);
    }
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Build the `Function` constructor/namespace object.
///
/// The returned `PlainObject` carries:
/// - `__call__` — the `Function(…args, body)` dynamic constructor.
/// - `prototype` — an object with `bind`, `call`, `apply`, `toString`,
///   `Symbol.hasInstance`, `name`, and `length`.
#[inline(never)]
fn make_function() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // ── Constructor: new Function(…args, body) ──────────────────────────
        props.insert(
            "__call__".into(),
            native(|args| function_constructor(&args)),
        );

        // ── Function.prototype ──────────────────────────────────────────────
        let mut proto = PropertyMap::new();

        // §20.2.3 Function.prototype is itself callable and returns undefined.
        proto.insert("__call__".into(), native(|_args| Ok(JsValue::Undefined)));

        // Function.prototype.call(thisArg, ...args)
        proto.insert(
            "call".into(),
            native(|args| {
                let func = args.first().cloned().unwrap_or(JsValue::Undefined);
                let this_arg = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                let call_args: Vec<JsValue> = args.get(2..).unwrap_or(&[]).to_vec();
                match &func {
                    JsValue::NativeFunction(f) => function_call(f, &this_arg, &call_args),
                    JsValue::Function(_) | JsValue::PlainObject(_) => {
                        dispatch_call_with_this(&func, this_arg, call_args)
                    }
                    _ => Err(StatorError::TypeError(
                        "Function.prototype.call requires a callable".into(),
                    )),
                }
            }),
        );

        // Function.prototype.apply(thisArg, argsArray)
        proto.insert(
            "apply".into(),
            native(|args| {
                let func = args.first().cloned().unwrap_or(JsValue::Undefined);
                let this_arg = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                let args_array = match args.get(2) {
                    Some(JsValue::Array(arr)) => Some(arr.borrow().clone()),
                    Some(JsValue::PlainObject(map)) => {
                        let borrow = map.borrow();
                        let len = match borrow.get("length") {
                            Some(JsValue::Smi(n)) => *n as usize,
                            Some(JsValue::HeapNumber(n)) => *n as usize,
                            _ => 0,
                        };
                        Some(
                            (0..len)
                                .map(|i| {
                                    borrow
                                        .get(&i.to_string())
                                        .cloned()
                                        .unwrap_or(JsValue::Undefined)
                                })
                                .collect(),
                        )
                    }
                    Some(JsValue::Null) | Some(JsValue::Undefined) | None => None,
                    _ => {
                        return Err(StatorError::TypeError(
                            "CreateListFromArrayLike called on non-object".into(),
                        ));
                    }
                };
                match &func {
                    JsValue::NativeFunction(f) => function_apply(f, &this_arg, &args_array),
                    JsValue::Function(_) | JsValue::PlainObject(_) => {
                        let spread = args_array.unwrap_or_default();
                        dispatch_call_with_this(&func, this_arg, spread)
                    }
                    _ => Err(StatorError::TypeError(
                        "Function.prototype.apply requires a callable".into(),
                    )),
                }
            }),
        );

        // Function.prototype.bind(thisArg, ...args)
        proto.insert(
            "bind".into(),
            native(|args| {
                let func = args.first().cloned().unwrap_or(JsValue::Undefined);
                let this_arg = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                let bound_args: Vec<JsValue> = args.get(2..).unwrap_or(&[]).to_vec();
                let result_len =
                    function_length(function_length_value(&func) as u32, bound_args.len() as u32)
                        as i32;
                let bound_name = function_bound_name(&function_display_name(&func));

                match &func {
                    JsValue::NativeFunction(f) => Ok(create_bound_function_object(
                        JsValue::NativeFunction(Rc::new({
                            let f = Rc::clone(f);
                            move |call_args: Vec<JsValue>| {
                                let mut all_args = vec![this_arg.clone()];
                                all_args.extend(bound_args.clone());
                                all_args.extend(call_args);
                                f(all_args)
                            }
                        })),
                        bound_name,
                        result_len,
                    )),
                    JsValue::Function(_) | JsValue::PlainObject(_) => {
                        let call_fn =
                            JsValue::NativeFunction(Rc::new(move |call_args: Vec<JsValue>| {
                                let mut all_args = bound_args.clone();
                                all_args.extend(call_args);
                                dispatch_call_with_this(&func, this_arg.clone(), all_args)
                            }));
                        Ok(create_bound_function_object(
                            call_fn, bound_name, result_len,
                        ))
                    }
                    _ => Err(StatorError::TypeError(
                        "Function.prototype.bind requires a callable".into(),
                    )),
                }
            }),
        );

        // Function.prototype.toString()
        proto.insert(
            "toString".into(),
            native(|args| {
                let func = args.first().cloned().unwrap_or(JsValue::Undefined);
                Ok(JsValue::String(function_to_string_value(&func).into()))
            }),
        );

        // Function.prototype[Symbol.hasInstance](V)
        proto.insert(
            "@@hasInstance".into(),
            native(|args| {
                let constructor = args.first().cloned().unwrap_or(JsValue::Undefined);
                let value = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                Ok(JsValue::Boolean(function_has_instance(
                    &constructor,
                    &value,
                )))
            }),
        );

        // Function.prototype.name (empty string for the prototype itself)
        proto.insert("name".into(), JsValue::String(String::new().into()));

        // Function.prototype.length (0 for the prototype itself)
        proto.insert("length".into(), JsValue::Smi(0));

        // Function.length = 1 (the constructor expects 1 argument)
        props.insert("length".into(), JsValue::Smi(1));

        // Function.name = "Function"
        props.insert("name".into(), JsValue::String("Function".into()));

        proto.make_all_non_enumerable();
        let fn_proto_rc = Rc::new(RefCell::new(proto));
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(fn_proto_rc.clone()),
        );

        props.make_all_non_enumerable();
        let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
        // §20.2.3.1 Function.prototype.constructor
        fn_proto_rc.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
        ctor
    })
}

/// Build the `GeneratorFunction` constructor and `Generator.prototype`.
///
/// Per §27.3 / §27.5:
/// - `GeneratorFunction` is a constructor (rarely used directly).
/// - `GeneratorFunction.prototype` === `Generator` (the %Generator% intrinsic).
/// - `Generator.prototype` carries `.next()`, `.return()`, `.throw()` and
///   `@@iterator`.
///
/// The returned `PlainObject` is registered as `"GeneratorFunction"` in the
/// global environment so that conformance tests can access it.
fn make_generator_function() -> JsValue {
    use crate::interpreter::Interpreter;
    use crate::objects::value::GeneratorStep;

    let mut props = PropertyMap::new();

    // ── GeneratorFunction is not directly callable in most code ──────────
    props.insert(
        "__call__".into(),
        native(|_args| {
            Err(StatorError::TypeError(
                "GeneratorFunction is not a constructor".into(),
            ))
        }),
    );

    // ── Generator.prototype (the %GeneratorPrototype% intrinsic) ────────
    let mut gen_proto = PropertyMap::new();

    // Generator.prototype.next(value)  §27.5.1.2
    gen_proto.insert(
        "next".into(),
        builtin_fn("next", 1, |args| {
            let this = args.first().cloned().unwrap_or(JsValue::Undefined);
            let input = args.get(1).cloned().unwrap_or(JsValue::Undefined);
            match this {
                JsValue::Generator(gs) => match Interpreter::run_generator_step(&gs, input)? {
                    GeneratorStep::Yield(v) => Ok(make_iter_result(v, false)),
                    GeneratorStep::Return(v) => Ok(make_iter_result(v, true)),
                },
                _ => Err(StatorError::TypeError(
                    "Generator.prototype.next requires a generator receiver".into(),
                )),
            }
        }),
    );

    // Generator.prototype.return(value)  §27.5.1.3
    gen_proto.insert(
        "return".into(),
        builtin_fn("return", 1, |args| {
            let this = args.first().cloned().unwrap_or(JsValue::Undefined);
            let value = args.get(1).cloned().unwrap_or(JsValue::Undefined);
            match this {
                JsValue::Generator(gs) => Interpreter::generator_return(&gs, value),
                _ => Err(StatorError::TypeError(
                    "Generator.prototype.return requires a generator receiver".into(),
                )),
            }
        }),
    );

    // Generator.prototype.throw(exception)  §27.5.1.4
    gen_proto.insert(
        "throw".into(),
        builtin_fn("throw", 1, |args| {
            let this = args.first().cloned().unwrap_or(JsValue::Undefined);
            let value = args.get(1).cloned().unwrap_or(JsValue::Undefined);
            match this {
                JsValue::Generator(gs) => Interpreter::generator_throw(&gs, value),
                _ => Err(StatorError::TypeError(
                    "Generator.prototype.throw requires a generator receiver".into(),
                )),
            }
        }),
    );

    // Generator.prototype[@@toStringTag] = "Generator"  §27.5.1.5
    gen_proto.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String("Generator".into()),
        PropertyAttributes::CONFIGURABLE,
    );
    gen_proto.insert_with_attrs(
        format!("Symbol({})", SYMBOL_TO_STRING_TAG),
        JsValue::String("Generator".into()),
        PropertyAttributes::CONFIGURABLE,
    );

    // Generator.prototype[@@iterator]()  §27.5.1.6
    // Generators are their own iterator: [Symbol.iterator]() returns `this`.
    gen_proto.insert(
        "@@iterator".into(),
        builtin_fn("[Symbol.iterator]", 0, |args| {
            let this = args.first().cloned().unwrap_or(JsValue::Undefined);
            Ok(this)
        }),
    );
    gen_proto.insert(
        format!("Symbol({})", SYMBOL_ITERATOR),
        builtin_fn("[Symbol.iterator]", 0, |args| {
            let this = args.first().cloned().unwrap_or(JsValue::Undefined);
            Ok(this)
        }),
    );

    gen_proto.make_all_non_enumerable();
    let gen_proto_rc = Rc::new(RefCell::new(gen_proto));

    // ── Generator (the %Generator% intrinsic = GeneratorFunction.prototype) ──
    let mut generator_obj = PropertyMap::new();
    generator_obj.insert(
        "prototype".into(),
        JsValue::PlainObject(gen_proto_rc.clone()),
    );
    generator_obj.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String("GeneratorFunction".into()),
        PropertyAttributes::CONFIGURABLE,
    );
    generator_obj.insert_with_attrs(
        format!("Symbol({})", SYMBOL_TO_STRING_TAG),
        JsValue::String("GeneratorFunction".into()),
        PropertyAttributes::CONFIGURABLE,
    );
    generator_obj.make_all_non_enumerable();
    let generator_obj_rc = Rc::new(RefCell::new(generator_obj));

    // GeneratorFunction.prototype = %Generator%
    props.insert(
        "prototype".into(),
        JsValue::PlainObject(generator_obj_rc.clone()),
    );

    // Wire constructor links:
    // Generator.prototype.constructor = %Generator%
    gen_proto_rc.borrow_mut().insert_with_attrs(
        "constructor".into(),
        JsValue::PlainObject(generator_obj_rc.clone()),
        PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
    );

    props.insert("name".into(), JsValue::String("GeneratorFunction".into()));
    props.insert("length".into(), JsValue::Smi(1));
    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Helper: create a `{value, done}` iterator result object.
fn make_iter_result(value: JsValue, done: bool) -> JsValue {
    let mut map = PropertyMap::new();
    map.insert("value".to_string(), value);
    map.insert("done".to_string(), JsValue::Boolean(done));
    JsValue::PlainObject(Rc::new(RefCell::new(map)))
}

/// Build the `String` constructor/namespace object with static and prototype
/// methods.
///
/// The returned `PlainObject` carries:
/// - `__call__` — the callable `String(value)` conversion.
/// - Static methods: `fromCharCode`, `fromCodePoint`, `raw`.
/// - `prototype` — an object with all `String.prototype.*` methods.
#[inline(never)]
fn make_string() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // ── Callable: String(value) ─────────────────────────────────────────
        props.insert(
            "__call__".into(),
            native(|args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                // §22.1.1.1: If value is a Symbol, return SymbolDescriptiveString.
                if let JsValue::Symbol(id) = val {
                    let desc = symbol_description(*id).unwrap_or_default();
                    return Ok(JsValue::String(format!("Symbol({desc})").into()));
                }
                // For objects (e.g. Object(Symbol('x'))), ToPrimitive may
                // return a Symbol.  String() must still produce the
                // descriptive string rather than throwing a TypeError.
                if !val.is_primitive() {
                    let prim = val.to_primitive(ToPrimitiveHint::String)?;
                    if let JsValue::Symbol(id) = &prim {
                        let desc = symbol_description(*id).unwrap_or_default();
                        return Ok(JsValue::String(format!("Symbol({desc})").into()));
                    }
                    return Ok(JsValue::String(prim.to_js_string()?.into()));
                }
                Ok(JsValue::String(val.to_js_string()?.into()))
            }),
        );

        // ── Static methods ──────────────────────────────────────────────────

        // String.fromCharCode(...codes)
        props.insert(
            "fromCharCode".into(),
            native(|args| {
                let codes: Vec<u32> = args
                    .iter()
                    .map(|a| a.to_number().unwrap_or(0.0) as u32)
                    .collect();
                Ok(JsValue::String(string_from_char_code(&codes).into()))
            }),
        );

        // String.fromCodePoint(...codePoints)
        props.insert(
            "fromCodePoint".into(),
            native(|args| {
                let mut codes = Vec::with_capacity(args.len());
                for value in args {
                    let code_point = value.to_number()?;
                    let integer = if code_point.is_nan() {
                        0.0
                    } else {
                        code_point.trunc()
                    };
                    if !code_point.is_finite() || integer != code_point {
                        return Err(StatorError::RangeError(format!(
                            "Invalid code point {code_point}"
                        )));
                    }
                    codes.push(integer as u32);
                }
                Ok(JsValue::String(string_from_code_point(&codes)?.into()))
            }),
        );

        // String.raw(strings, ...substitutions)
        props.insert(
            "raw".into(),
            native(|args| {
                // First arg is the template object with a `raw` property.
                let template = args.first().unwrap_or(&JsValue::Undefined);
                let raw_value = match template {
                    JsValue::PlainObject(map) => {
                        let borrowed = map.borrow();
                        borrowed.get("raw").cloned().unwrap_or(JsValue::Undefined)
                    }
                    _ => JsValue::Undefined,
                };
                let raw_strings = string_raw_segments(&raw_value)?;
                let subs: Vec<String> = args
                    .iter()
                    .skip(1)
                    .map(|v| v.to_js_string().unwrap_or_default())
                    .collect();
                let raw_refs: Vec<&str> = raw_strings.iter().map(String::as_str).collect();
                let sub_refs: Vec<&str> = subs.iter().map(String::as_str).collect();
                Ok(JsValue::String(string_raw(&raw_refs, &sub_refs).into()))
            }),
        );

        // ── Prototype methods ───────────────────────────────────────────────
        let mut proto = PropertyMap::new();

        // charAt(pos)
        proto.insert(
            "charAt".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(match normalize_string_index(utf16_len(&s), args.get(1))? {
                    Some(pos) => JsValue::String(string_char_at(&s, pos as i64).into()),
                    None => JsValue::String(String::new().into()),
                })
            }),
        );

        // charCodeAt(pos)
        proto.insert(
            "charCodeAt".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(match normalize_string_index(utf16_len(&s), args.get(1))? {
                    Some(pos) => num(string_char_code_at(&s, pos as i64)),
                    None => num(f64::NAN),
                })
            }),
        );

        // codePointAt(pos)
        proto.insert(
            "codePointAt".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let Some(pos) = normalize_string_index(utf16_len(&s), args.get(1))? else {
                    return Ok(JsValue::Undefined);
                };
                match string_code_point_at(&s, pos as i64) {
                    Some(cp) => Ok(num(cp as f64)),
                    None => Ok(JsValue::Undefined),
                }
            }),
        );

        // concat(...strings)
        proto.insert(
            "concat".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let parts: StatorResult<Vec<String>> =
                    args.iter().skip(1).map(|a| a.to_js_string()).collect();
                let parts = parts?;
                let refs: Vec<&str> = parts.iter().map(String::as_str).collect();
                Ok(JsValue::String(string_concat(&s, &refs).into()))
            }),
        );

        // slice(start, end?)
        proto.insert(
            "slice".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let len = utf16_len(&s);
                let start = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(1), 0.0)?,
                ) as i64;
                let end = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => {
                        Some(clamp_relative_integer_index(len, v.to_integer_or_infinity()?) as i64)
                    }
                };
                Ok(JsValue::String(string_slice(&s, start, end).into()))
            }),
        );

        // substring(start, end?)
        proto.insert(
            "substring".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let len = utf16_len(&s);
                let start = clamp_nonnegative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(1), 0.0)?,
                ) as i64;
                let end = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(clamp_nonnegative_integer_index(
                        len,
                        v.to_integer_or_infinity()?,
                    ) as i64),
                };
                Ok(JsValue::String(string_substring(&s, start, end).into()))
            }),
        );

        // indexOf(searchString, position?)
        proto.insert(
            "indexOf".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let search = args.get(1).unwrap_or(&JsValue::Undefined).to_js_string()?;
                let len = utf16_len(&s);
                let pos = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(clamp_nonnegative_integer_index(
                        len,
                        v.to_integer_or_infinity()?,
                    ) as i64),
                };
                Ok(num(string_index_of(&s, &search, pos) as f64))
            }),
        );

        // lastIndexOf(searchString, position?)
        proto.insert(
            "lastIndexOf".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let search = args.get(1).unwrap_or(&JsValue::Undefined).to_js_string()?;
                let len = utf16_len(&s);
                let pos = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(clamp_nonnegative_integer_index(
                        len,
                        v.to_integer_or_infinity()?,
                    ) as i64),
                };
                Ok(num(string_last_index_of(&s, &search, pos) as f64))
            }),
        );

        // includes(searchString, position?)
        proto.insert(
            "includes".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                // §22.1.3.7 step 4: throw TypeError if searchString is a RegExp
                let search_arg = args.get(1).unwrap_or(&JsValue::Undefined);
                if let JsValue::PlainObject(map) = search_arg
                    && matches!(
                        map.borrow().get("__is_regexp__"),
                        Some(JsValue::Boolean(true))
                    )
                {
                    return Err(crate::error::StatorError::TypeError(
                        "First argument to String.prototype.includes must not be a regular expression".to_string(),
                    ));
                }
                let search = search_arg.to_js_string()?;
                let len = utf16_len(&s);
                let pos = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(clamp_nonnegative_integer_index(len, v.to_integer_or_infinity()?) as i64),
                };
                Ok(JsValue::Boolean(string_includes(&s, &search, pos)))
            }),
        );

        // startsWith(searchString, position?)
        proto.insert(
        "startsWith".into(),
        native(|args| {
            let s = require_coercible_string(&args)?;
            // §22.1.3.22 step 4: throw TypeError if searchString is a RegExp
            let search_arg = args.get(1).unwrap_or(&JsValue::Undefined);
            if let JsValue::PlainObject(map) = search_arg
                && matches!(
                    map.borrow().get("__is_regexp__"),
                    Some(JsValue::Boolean(true))
                )
            {
                    return Err(crate::error::StatorError::TypeError(
                        "First argument to String.prototype.startsWith must not be a regular expression".to_string(),
                    ));
            }
            let search = search_arg.to_js_string()?;
            let len = utf16_len(&s);
            let pos = match args.get(2) {
                Some(JsValue::Undefined) | None => None,
                Some(v) => Some(clamp_nonnegative_integer_index(len, v.to_integer_or_infinity()?) as i64),
            };
            Ok(JsValue::Boolean(string_starts_with(&s, &search, pos)))
        }),
    );

        // endsWith(searchString, endPosition?)
        proto.insert(
            "endsWith".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                // §22.1.3.7 step 4: throw TypeError if searchString is a RegExp
                let search_arg = args.get(1).unwrap_or(&JsValue::Undefined);
                if let JsValue::PlainObject(map) = search_arg
                    && matches!(
                        map.borrow().get("__is_regexp__"),
                        Some(JsValue::Boolean(true))
                    )
                {
                    return Err(crate::error::StatorError::TypeError(
                    "First argument to String.prototype.endsWith must not be a regular expression"
                        .to_string(),
                ));
                }
                let search = search_arg.to_js_string()?;
                let len = utf16_len(&s);
                let end = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(clamp_nonnegative_integer_index(
                        len,
                        v.to_integer_or_infinity()?,
                    ) as i64),
                };
                Ok(JsValue::Boolean(string_ends_with(&s, &search, end)))
            }),
        );

        // toUpperCase()
        proto.insert(
            "toUpperCase".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_to_upper_case(&s).into()))
            }),
        );

        // toLowerCase()
        proto.insert(
            "toLowerCase".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_to_lower_case(&s).into()))
            }),
        );

        // trim()
        proto.insert(
            "trim".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_trim(&s).into()))
            }),
        );

        // trimStart()/trimLeft() — §B.2.3.1 legacy aliases of the same function object.
        let trim_start_fn = builtin_fn("trimStart", 0, |args| {
            let s = require_coercible_string(&args)?;
            Ok(JsValue::String(string_trim_start(&s).into()))
        });
        proto.insert("trimStart".into(), trim_start_fn.clone());
        proto.insert("trimLeft".into(), trim_start_fn);

        // trimEnd()/trimRight() — §B.2.3.2 legacy aliases of the same function object.
        let trim_end_fn = builtin_fn("trimEnd", 0, |args| {
            let s = require_coercible_string(&args)?;
            Ok(JsValue::String(string_trim_end(&s).into()))
        });
        proto.insert("trimEnd".into(), trim_end_fn.clone());
        proto.insert("trimRight".into(), trim_end_fn);

        // split(separator?, limit?)
        proto.insert(
            "split".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let sep_arg = args.get(1).unwrap_or(&JsValue::Undefined);
                // Delegate to `separator[@@split]` when present.
                if let Some(result) =
                    try_string_protocol_method(sep_arg, SYMBOL_SPLIT, "__symbol_split__", {
                        let mut a = vec![JsValue::String(s.clone().into())];
                        if let Some(lim) = args.get(2) {
                            a.push(lim.clone());
                        }
                        a
                    })
                {
                    return result;
                }
                let sep = match sep_arg {
                    JsValue::Undefined => None,
                    v => Some(v.to_js_string()?),
                };
                let limit = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(v.to_uint32()?),
                };
                let parts = string_split(&s, sep.as_deref(), limit);
                let arr: Vec<JsValue> = parts
                    .into_iter()
                    .map(|s| JsValue::String(s.into()))
                    .collect();
                Ok(JsValue::new_array(arr))
            }),
        );

        // replace(searchValue, replaceValue)
        proto.insert(
            "replace".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let search_arg = args.get(1).unwrap_or(&JsValue::Undefined);
                // Delegate to `searchValue[@@replace]` when present.
                if let Some(result) = try_string_protocol_method(
                    search_arg,
                    SYMBOL_REPLACE,
                    "__symbol_replace__",
                    vec![
                        JsValue::String(s.clone().into()),
                        args.get(2).unwrap_or(&JsValue::Undefined).clone(),
                    ],
                ) {
                    return result;
                }
                let search = search_arg.to_js_string()?;
                let replace_arg = args.get(2).unwrap_or(&JsValue::Undefined);
                // §22.1.3.17 step 7: if replaceValue is callable, call it.
                if is_callable(replace_arg) {
                    if let Some(byte_pos) = s.find(&*search) {
                        let utf16_pos = crate::builtins::string::encode_utf16(&s[..byte_pos]).len();
                        let result_val = call_callback(
                            replace_arg,
                            vec![
                                JsValue::String(search.clone().into()),
                                num(utf16_pos as f64),
                                JsValue::String(s.clone().into()),
                            ],
                        )?;
                        let rep = result_val.to_js_string()?;
                        let mut result = s[..byte_pos].to_string();
                        result.push_str(&rep);
                        result.push_str(&s[byte_pos + search.len()..]);
                        return Ok(JsValue::String(result.into()));
                    }
                    return Ok(JsValue::String(s.into()));
                }
                let replacement = replace_arg.to_js_string()?;
                Ok(JsValue::String(
                    string_replace(&s, &search, &replacement).into(),
                ))
            }),
        );

        // replaceAll(searchValue, replaceValue)
        proto.insert(
            "replaceAll".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let search_arg = args.get(1).unwrap_or(&JsValue::Undefined);
                // Delegate to RegExp[@@replace] when searchValue is a regexp.
                // Per spec, replaceAll with a non-global regexp throws TypeError.
                if let JsValue::PlainObject(map) = search_arg {
                    let borrow = map.borrow();
                    if matches!(borrow.get("__is_regexp__"), Some(JsValue::Boolean(true))) {
                        let is_global =
                            matches!(borrow.get("global"), Some(JsValue::Boolean(true)));
                        if !is_global {
                            return Err(crate::error::StatorError::TypeError(
                            "String.prototype.replaceAll called with a non-global RegExp argument"
                                .to_string(),
                        ));
                        }
                        if let Some(JsValue::NativeFunction(f)) =
                            borrow.get("__symbol_replace__").cloned()
                        {
                            drop(borrow);
                            return f(vec![
                                JsValue::String(s.into()),
                                args.get(2).unwrap_or(&JsValue::Undefined).clone(),
                            ]);
                        }
                    }
                }
                let search = search_arg.to_js_string()?;
                let replace_arg = args.get(2).unwrap_or(&JsValue::Undefined);
                // §22.1.3.18 step 7: if replaceValue is callable, call it.
                if is_callable(replace_arg) {
                    if search.is_empty() {
                        // Empty search: insert between every UTF-16 code unit.
                        let units = crate::builtins::string::encode_utf16(&s);
                        let mut result = String::new();
                        for (idx, u) in units.iter().enumerate() {
                            let rep = call_callback(
                                replace_arg,
                                vec![
                                    JsValue::String("".into()),
                                    num(idx as f64),
                                    JsValue::String(s.clone().into()),
                                ],
                            )?;
                            result.push_str(&rep.to_js_string()?);
                            result.push_str(&crate::builtins::string::decode_utf16(&[*u]));
                        }
                        let rep = call_callback(
                            replace_arg,
                            vec![
                                JsValue::String("".into()),
                                num(units.len() as f64),
                                JsValue::String(s.clone().into()),
                            ],
                        )?;
                        result.push_str(&rep.to_js_string()?);
                        return Ok(JsValue::String(result.into()));
                    }
                    let mut result = String::new();
                    let mut last_end = 0usize;
                    let mut start = 0usize;
                    while start <= s.len() {
                        match s[start..].find(&*search) {
                            Some(relative_pos) => {
                                let byte_pos = start + relative_pos;
                                let utf16_pos =
                                    crate::builtins::string::encode_utf16(&s[..byte_pos]).len();
                                let rep = call_callback(
                                    replace_arg,
                                    vec![
                                        JsValue::String(search.clone().into()),
                                        num(utf16_pos as f64),
                                        JsValue::String(s.clone().into()),
                                    ],
                                )?;
                                result.push_str(&s[last_end..byte_pos]);
                                result.push_str(&rep.to_js_string()?);
                                last_end = byte_pos + search.len();
                                start = last_end;
                            }
                            None => break,
                        }
                    }
                    result.push_str(&s[last_end..]);
                    return Ok(JsValue::String(result.into()));
                }
                let replacement = replace_arg.to_js_string()?;
                Ok(JsValue::String(
                    string_replace_all(&s, &search, &replacement).into(),
                ))
            }),
        );

        // match(regexp)
        proto.insert(
            "match".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let pattern_arg = args.get(1).unwrap_or(&JsValue::Undefined);
                // Delegate to `regexp[@@match]` when present.
                if let Some(result) = try_string_protocol_method(
                    pattern_arg,
                    SYMBOL_MATCH,
                    "__symbol_match__",
                    vec![JsValue::String(s.clone().into())],
                ) {
                    return result;
                }
                let pattern = pattern_arg.to_js_string()?;
                match string_match(&s, &pattern) {
                    Some(groups) => {
                        let arr: Vec<JsValue> = groups
                            .into_iter()
                            .map(|s| JsValue::String(s.into()))
                            .collect();
                        Ok(JsValue::new_array(arr))
                    }
                    None => Ok(JsValue::Null),
                }
            }),
        );

        // matchAll(regexp) — §22.1.3.13
        proto.insert(
            "matchAll".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let pattern_arg = args.get(1).unwrap_or(&JsValue::Undefined);

                // §22.1.3.13 step 2: if the argument is a RegExp, it must
                // have the global flag — otherwise throw TypeError.
                if let JsValue::PlainObject(map) = pattern_arg
                    && matches!(
                        map.borrow().get("__is_regexp__"),
                        Some(JsValue::Boolean(true))
                    )
                    && !matches!(map.borrow().get("global"), Some(JsValue::Boolean(true)))
                {
                    return Err(StatorError::TypeError(
                        "String.prototype.matchAll called with a non-global RegExp argument".into(),
                    ));
                }

                // Delegate to `regexp[@@matchAll]` when present.
                if let Some(result) = try_string_protocol_method(
                    pattern_arg,
                    SYMBOL_MATCH_ALL,
                    "__symbol_match_all__",
                    vec![JsValue::String(s.clone().into())],
                ) {
                    return result;
                }

                // Non-regexp fallback: wrap in a global RegExp and delegate
                // to its [@@matchAll] so we return a proper iterator of match
                // objects (with index, input, and groups).
                let pattern = pattern_arg.to_js_string()?;
                let re_val = regexp_construct(&[
                    JsValue::String(pattern.into()),
                    JsValue::String("g".into()),
                ])?;
                if let Some(result) = try_string_protocol_method(
                    &re_val,
                    SYMBOL_MATCH_ALL,
                    "__symbol_match_all__",
                    vec![JsValue::String(s.into())],
                ) {
                    return result;
                }
                Ok(JsValue::Iterator(NativeIterator::from_items(vec![])))
            }),
        );

        // repeat(count)
        proto.insert(
            "repeat".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let n = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_number()
                    .unwrap_or(0.0);
                if n.is_infinite() || n < 0.0 {
                    return Err(crate::error::StatorError::RangeError(
                        "Invalid count value".to_string(),
                    ));
                }
                Ok(JsValue::String(string_repeat(&s, n as i64)?.into()))
            }),
        );

        // padStart(targetLength, padString?)
        proto.insert(
            "padStart".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let raw = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_number()
                    .unwrap_or(0.0);
                let target_len = if raw.is_nan() || raw < 0.0 {
                    0usize
                } else {
                    crate::builtins::util::clamped_f64_to_usize(raw)
                };
                let pad = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(v.to_js_string()?),
                };
                Ok(JsValue::String(
                    string_pad_start(&s, target_len, pad.as_deref())?.into(),
                ))
            }),
        );

        // padEnd(targetLength, padString?)
        proto.insert(
            "padEnd".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let raw = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_number()
                    .unwrap_or(0.0);
                let target_len = if raw.is_nan() || raw < 0.0 {
                    0usize
                } else {
                    crate::builtins::util::clamped_f64_to_usize(raw)
                };
                let pad = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(v.to_js_string()?),
                };
                Ok(JsValue::String(
                    string_pad_end(&s, target_len, pad.as_deref())?.into(),
                ))
            }),
        );

        // at(index)
        proto.insert(
            "at".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let idx = normalize_at_index(utf16_len(&s), args.get(1))?;
                match idx.and_then(|idx| string_at(&s, idx as i64)) {
                    Some(ch) => Ok(JsValue::String(ch.into())),
                    None => Ok(JsValue::Undefined),
                }
            }),
        );

        // normalize(form?)
        proto.insert(
            "normalize".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let form = match args.get(1) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(v.to_js_string()?),
                };
                Ok(JsValue::String(
                    string_normalize(&s, form.as_deref())?.into(),
                ))
            }),
        );

        // search(regexp)
        proto.insert(
            "search".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let pattern_arg = args.get(1).unwrap_or(&JsValue::Undefined);
                // Delegate to `regexp[@@search]` when present.
                if let Some(result) = try_string_protocol_method(
                    pattern_arg,
                    SYMBOL_SEARCH,
                    "__symbol_search__",
                    vec![JsValue::String(s.clone().into())],
                ) {
                    return result;
                }
                let pattern = pattern_arg.to_js_string()?;
                Ok(num(string_search(&s, &pattern) as f64))
            }),
        );

        // isWellFormed()
        proto.insert(
            "isWellFormed".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::Boolean(string_is_well_formed(&s)))
            }),
        );

        // toWellFormed()
        proto.insert(
            "toWellFormed".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_to_well_formed(&s).into()))
            }),
        );

        // localeCompare(that)
        proto.insert(
            "localeCompare".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let that = args.get(1).unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(num(string_locale_compare(&s, &that) as f64))
            }),
        );

        // toLocaleLowerCase()
        proto.insert(
            "toLocaleLowerCase".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_to_locale_lower_case(&s).into()))
            }),
        );

        // toLocaleUpperCase()
        proto.insert(
            "toLocaleUpperCase".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_to_locale_upper_case(&s).into()))
            }),
        );

        // toString()
        proto.insert(
            "toString".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(s.into()))
            }),
        );

        // valueOf()
        proto.insert(
            "valueOf".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(s.into()))
            }),
        );

        // [Symbol.iterator]() — returns an iterator over Unicode code points.
        proto.insert(
            "@@iterator".into(),
            native(|args| {
                let s = require_coercible_string(&args)?;
                let chars: Vec<JsValue> = string_iter(&s)
                    .into_iter()
                    .map(|s| JsValue::String(s.into()))
                    .collect();
                Ok(JsValue::Iterator(NativeIterator::from_items(chars)))
            }),
        );

        // ── Annex B prototype methods ───────────────────────────────────────

        // substr(start, length?)
        proto.insert(
            "substr".into(),
            builtin_fn("substr", 2, |args| {
                let s = require_coercible_string(&args)?;
                let len = utf16_len(&s);
                let start = clamp_relative_integer_index(
                    len,
                    to_integer_or_infinity_arg(args.get(1), 0.0)?,
                ) as i64;
                let length = match args.get(2) {
                    Some(JsValue::Undefined) | None => None,
                    Some(v) => Some(clamp_nonnegative_integer_index(
                        len,
                        v.to_integer_or_infinity()?,
                    ) as i64),
                };
                Ok(JsValue::String(string_substr(&s, start, length).into()))
            }),
        );

        // anchor(name)
        proto.insert(
            "anchor".into(),
            builtin_fn("anchor", 1, |args| {
                let s = require_coercible_string(&args)?;
                let name = args.get(1).unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(string_anchor(&s, &name).into()))
            }),
        );

        // big()
        proto.insert(
            "big".into(),
            builtin_fn("big", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_big(&s).into()))
            }),
        );

        // blink()
        proto.insert(
            "blink".into(),
            builtin_fn("blink", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_blink(&s).into()))
            }),
        );

        // bold()
        proto.insert(
            "bold".into(),
            builtin_fn("bold", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_bold(&s).into()))
            }),
        );

        // fixed()
        proto.insert(
            "fixed".into(),
            builtin_fn("fixed", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_fixed(&s).into()))
            }),
        );

        // fontcolor(color)
        proto.insert(
            "fontcolor".into(),
            builtin_fn("fontcolor", 1, |args| {
                let s = require_coercible_string(&args)?;
                let color = args.get(1).unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(string_fontcolor(&s, &color).into()))
            }),
        );

        // fontsize(size)
        proto.insert(
            "fontsize".into(),
            builtin_fn("fontsize", 1, |args| {
                let s = require_coercible_string(&args)?;
                let size = args.get(1).unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(string_fontsize(&s, &size).into()))
            }),
        );

        // italics()
        proto.insert(
            "italics".into(),
            builtin_fn("italics", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_italics(&s).into()))
            }),
        );

        // link(url)
        proto.insert(
            "link".into(),
            builtin_fn("link", 1, |args| {
                let s = require_coercible_string(&args)?;
                let url = args.get(1).unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(string_link(&s, &url).into()))
            }),
        );

        // small()
        proto.insert(
            "small".into(),
            builtin_fn("small", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_small(&s).into()))
            }),
        );

        // strike()
        proto.insert(
            "strike".into(),
            builtin_fn("strike", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_strike(&s).into()))
            }),
        );

        // sub()
        proto.insert(
            "sub".into(),
            builtin_fn("sub", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_sub(&s).into()))
            }),
        );

        // sup()
        proto.insert(
            "sup".into(),
            builtin_fn("sup", 0, |args| {
                let s = require_coercible_string(&args)?;
                Ok(JsValue::String(string_sup(&s).into()))
            }),
        );

        // §22.1.3 String.prototype[@@toStringTag] is NOT defined by spec.

        proto.make_all_non_enumerable();
        let str_proto_rc = Rc::new(RefCell::new(proto));
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(str_proto_rc.clone()),
        );

        props.make_all_non_enumerable();
        let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
        // §22.1.3.1 String.prototype.constructor
        str_proto_rc.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
        ctor
    })
}

// ── Promise ─────────────────────────────────────────────────────────────────

/// Build the `Promise` constructor/namespace object.
///
/// Creates an internal [`MicrotaskQueue`] shared by all promise operations
/// created through this global.  The constructor (`__call__`) corresponds to
/// `new Promise(executor)`, and static methods (`resolve`, `reject`, `all`,
/// `allSettled`, `any`, `race`, `withResolvers`) are available as properties.
#[inline(never)]
fn make_promise() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        use crate::builtins::promise::{
            MicrotaskQueue, install_active_microtask_queue, promise_all_settled_with_result,
            promise_all_with_result, promise_any_with_result, promise_new,
            promise_race_with_result, promise_reject, promise_reject_with_result, promise_resolve,
            promise_try, promise_with_resolvers,
        };

        let mut props = PropertyMap::new();
        let queue = MicrotaskQueue::new();
        install_active_microtask_queue(&queue);

        // ── Constructor: new Promise(executor) ─────────────────────────────────
        //
        // §27.2.3.1: The executor is called synchronously with (resolve, reject).
        // Supports any callable type (NativeFunction, bytecode Function, Proxy,
        // PlainObject with __call__).  Resolve/reject are idempotent — only the
        // first invocation takes effect.
        {
            let q = queue.clone();
            props.insert(
                "__call__".into(),
                native(move |args| {
                    let executor = args.first().cloned().unwrap_or(JsValue::Undefined);
                    let derived_proto = current_derived_constructor_this()
                        .and_then(|target| target.borrow().get("__proto__").cloned());
                    let p = promise_new(
                        |resolve_box, reject_box| {
                            let resolve_box = Rc::new(RefCell::new(Some(resolve_box)));
                            let reject_box = Rc::new(RefCell::new(Some(reject_box)));
                            let resolve_fn = JsValue::NativeFunction(Rc::new({
                                let rb = Rc::clone(&resolve_box);
                                move |a: Vec<JsValue>| {
                                    if let Some(f) = rb.borrow_mut().take() {
                                        f(a.first().cloned().unwrap_or(JsValue::Undefined));
                                    }
                                    Ok(JsValue::Undefined)
                                }
                            }));
                            let reject_fn = JsValue::NativeFunction(Rc::new({
                                let rb = Rc::clone(&reject_box);
                                move |a: Vec<JsValue>| {
                                    if let Some(f) = rb.borrow_mut().take() {
                                        f(a.first().cloned().unwrap_or(JsValue::Undefined));
                                    }
                                    Ok(JsValue::Undefined)
                                }
                            }));
                            // Call the executor with any callable type via the
                            // interpreter dispatch, not just NativeFunction.
                            if let Err(e) =
                                dispatch_call_value(&executor, vec![resolve_fn, reject_fn])
                            {
                                // §27.2.3.1 step 10: If executor throws, reject.
                                if let Some(rej) = reject_box.borrow_mut().take() {
                                    rej(JsValue::String(e.to_string().into()));
                                }
                            }
                        },
                        &q,
                    );
                    p.set_prototype(derived_proto);
                    Ok(JsValue::Promise(p))
                }),
            );
        }

        // ── Promise.resolve(value) ────────────────────────────────────────────
        // §27.2.4.5: If value is already a Promise, return it as-is.
        // If value is a thenable (has `.then` method), unwrap it.
        {
            let q = queue.clone();
            props.insert(
                "resolve".into(),
                native(move |args| {
                    let val = args.first().cloned().unwrap_or(JsValue::Undefined);
                    Ok(JsValue::Promise(promise_resolve(val, &q)))
                }),
            );
        }

        // ── Promise.reject(reason) ────────────────────────────────────────────
        {
            let q = queue.clone();
            props.insert(
                "reject".into(),
                native(move |args| {
                    let reason = args.first().cloned().unwrap_or(JsValue::Undefined);
                    Ok(JsValue::Promise(promise_reject(reason, &q)))
                }),
            );
        }

        // ── Promise.try(fn, ...args) ──────────────────────────────────────────
        {
            let q = queue.clone();
            props.insert(
                "try".into(),
                native(move |args| {
                    let callable = args.first().cloned().unwrap_or(JsValue::Undefined);
                    let call_args = args.get(1..).map_or_else(Vec::new, |rest| rest.to_vec());
                    Ok(JsValue::Promise(promise_try(
                        move |call_args| match dispatch_call_value(&callable, call_args) {
                            Ok(value) => Ok(value),
                            Err(error) => Err(JsValue::String(error.to_string().into())),
                        },
                        call_args,
                        &q,
                    )))
                }),
            );
        }

        // ── Promise.all(promises) ─────────────────────────────────────────────
        {
            let q = queue.clone();
            props.insert(
                "all".into(),
                native(move |args| {
                    let constructor = promise_static_constructor();
                    let result = match promise_static_result(constructor.as_ref()) {
                        Ok(result) => result,
                        Err(error) => {
                            return Ok(JsValue::Promise(promise_reject(
                                JsValue::String(error.to_string().into()),
                                &q,
                            )));
                        }
                    };
                    match promise_static_input_promises(args.first(), constructor.as_ref(), &q) {
                        Ok(promises) => Ok(JsValue::Promise(promise_all_with_result(
                            promises, result, &q,
                        ))),
                        Err(msg) => Ok(JsValue::Promise(promise_reject_with_result(
                            JsValue::String(msg.into()),
                            result,
                            &q,
                        ))),
                    }
                }),
            );
        }

        // ── Promise.allSettled(promises) ──────────────────────────────────────
        {
            let q = queue.clone();
            props.insert(
                "allSettled".into(),
                native(move |args| {
                    let constructor = promise_static_constructor();
                    let result = match promise_static_result(constructor.as_ref()) {
                        Ok(result) => result,
                        Err(error) => {
                            return Ok(JsValue::Promise(promise_reject(
                                JsValue::String(error.to_string().into()),
                                &q,
                            )));
                        }
                    };
                    match promise_static_input_promises(args.first(), constructor.as_ref(), &q) {
                        Ok(promises) => Ok(JsValue::Promise(promise_all_settled_with_result(
                            promises, result, &q,
                        ))),
                        Err(msg) => Ok(JsValue::Promise(promise_reject_with_result(
                            JsValue::String(msg.into()),
                            result,
                            &q,
                        ))),
                    }
                }),
            );
        }

        // ── Promise.any(promises) ─────────────────────────────────────────────
        {
            let q = queue.clone();
            props.insert(
                "any".into(),
                native(move |args| {
                    let constructor = promise_static_constructor();
                    let result = match promise_static_result(constructor.as_ref()) {
                        Ok(result) => result,
                        Err(error) => {
                            return Ok(JsValue::Promise(promise_reject(
                                JsValue::String(error.to_string().into()),
                                &q,
                            )));
                        }
                    };
                    match promise_static_input_promises(args.first(), constructor.as_ref(), &q) {
                        Ok(promises) => Ok(JsValue::Promise(promise_any_with_result(
                            promises, result, &q,
                        ))),
                        Err(msg) => Ok(JsValue::Promise(promise_reject_with_result(
                            JsValue::String(msg.into()),
                            result,
                            &q,
                        ))),
                    }
                }),
            );
        }

        // ── Promise.race(promises) ────────────────────────────────────────────
        {
            let q = queue.clone();
            props.insert(
                "race".into(),
                native(move |args| {
                    let constructor = promise_static_constructor();
                    let result = match promise_static_result(constructor.as_ref()) {
                        Ok(result) => result,
                        Err(error) => {
                            return Ok(JsValue::Promise(promise_reject(
                                JsValue::String(error.to_string().into()),
                                &q,
                            )));
                        }
                    };
                    match promise_static_input_promises(args.first(), constructor.as_ref(), &q) {
                        Ok(promises) => Ok(JsValue::Promise(promise_race_with_result(
                            promises, result, &q,
                        ))),
                        Err(msg) => Ok(JsValue::Promise(promise_reject_with_result(
                            JsValue::String(msg.into()),
                            result,
                            &q,
                        ))),
                    }
                }),
            );
        }

        // ── Promise.withResolvers() ──────────────────────────────────────────
        {
            let q = queue.clone();
            props.insert(
                "withResolvers".into(),
                native(move |_args| {
                    let wr = promise_with_resolvers(&q);
                    let resolve_box = Rc::new(RefCell::new(Some(wr.resolve)));
                    let reject_box = Rc::new(RefCell::new(Some(wr.reject)));
                    let mut obj = PropertyMap::new();
                    obj.insert("promise".into(), JsValue::Promise(wr.promise));
                    obj.insert(
                        "resolve".into(),
                        JsValue::NativeFunction(Rc::new({
                            let rb = Rc::clone(&resolve_box);
                            move |a: Vec<JsValue>| {
                                if let Some(f) = rb.borrow_mut().take() {
                                    f(a.first().cloned().unwrap_or(JsValue::Undefined));
                                }
                                Ok(JsValue::Undefined)
                            }
                        })),
                    );
                    obj.insert(
                        "reject".into(),
                        JsValue::NativeFunction(Rc::new({
                            let rb = Rc::clone(&reject_box);
                            move |a: Vec<JsValue>| {
                                if let Some(f) = rb.borrow_mut().take() {
                                    f(a.first().cloned().unwrap_or(JsValue::Undefined));
                                }
                                Ok(JsValue::Undefined)
                            }
                        })),
                    );
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
        }

        // ── Promise.prototype.then / catch / finally ─────────────────────────
        // These are stored on the namespace so the interpreter can look them up
        // when called as `promise.then(...)`.

        // prototype.then(onFulfilled, onRejected)
        let prototype_then = promise_then_method(&queue);
        let prototype_catch = promise_catch_method(&queue);
        let prototype_finally = promise_finally_method(&queue);
        let mut prototype = PropertyMap::new();
        prototype.insert("then".into(), prototype_then.clone());
        prototype.insert("catch".into(), prototype_catch.clone());
        prototype.insert("finally".into(), prototype_finally.clone());
        // §27.2.5.5 Promise.prototype[@@toStringTag] = "Promise"
        prototype.insert_with_attrs(
            "@@toStringTag".into(),
            JsValue::String("Promise".into()),
            PropertyAttributes::CONFIGURABLE,
        );
        prototype.make_all_non_enumerable();
        let prototype_rc = Rc::new(RefCell::new(prototype));
        props.insert(
            "prototype".into(),
            JsValue::PlainObject(Rc::clone(&prototype_rc)),
        );
        props.insert("prototype_then".into(), prototype_then);
        props.insert("prototype_catch".into(), prototype_catch);
        props.insert("prototype_finally".into(), prototype_finally);

        // §27.2.4.7 get Promise[@@species] — returns `this`.
        props.insert(
            "__get_@@species__".into(),
            native(|args| Ok(args.first().cloned().unwrap_or(JsValue::Undefined))),
        );

        props.make_all_non_enumerable();
        JsValue::PlainObject(Rc::new(RefCell::new(props)))
    })
}

// ── RegExp ────────────────────────────────────────────────────────────────────

/// Build the `RegExp` constructor.
#[inline(never)]
fn make_regexp() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // Callable: new RegExp(pattern, flags)
        props.insert("__call__".into(), native(|args| regexp_construct(&args)));

        // Annex B legacy static properties — live getters backed by
        // thread-local state updated after every successful exec/test.
        for i in 1..=9 {
            let key = format!("${i}");
            let getter_key = format!("__get_{key}__");
            props.insert(
                getter_key,
                native(move |_args| Ok(regexp_static_get(&format!("${i}")))),
            );
            // Placeholder so `"$1" in RegExp` is true.
            props.insert(key, JsValue::String(String::new().into()));
        }
        for &name in &[
            "input",
            "lastMatch",
            "lastParen",
            "leftContext",
            "rightContext",
        ] {
            let getter_key = format!("__get_{name}__");
            let name_owned = name.to_string();
            props.insert(
                getter_key,
                native(move |_args| Ok(regexp_static_get(&name_owned))),
            );
            props.insert(name.into(), JsValue::String(String::new().into()));
        }

        // Annex B §B.2.4 — short alias getters: $_, $&, $+, $`, $'
        for &(alias, canonical) in &[
            ("$_", "input"),
            ("$&", "lastMatch"),
            ("$+", "lastParen"),
            ("$`", "leftContext"),
            ("$'", "rightContext"),
        ] {
            let getter_key = format!("__get_{alias}__");
            let canon = canonical.to_string();
            props.insert(
                getter_key,
                native(move |_args| Ok(regexp_static_get(&canon))),
            );
            props.insert(alias.into(), JsValue::String(String::new().into()));
        }

        // §22.2.4.2 RegExp.escape(string)  — ES2025
        props.insert(
            "escape".into(),
            builtin_fn("escape", 1, |args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                let s = val.to_js_string()?;
                let mut result = String::with_capacity(s.len() * 2);
                for ch in s.chars() {
                    match ch {
                        // SyntaxCharacter: ^ $ \ . * + ? ( ) [ ] { } |
                        '^' | '$' | '\\' | '.' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{'
                        | '}' | '|' | '/' => {
                            result.push('\\');
                            result.push(ch);
                        }
                        // Characters that could be special at the start of a pattern.
                        _ if result.is_empty()
                            && (ch.is_ascii_whitespace()
                                || ch.is_ascii_digit()
                                || ch == ','
                                || ch == '-'
                                || ch == '='
                                || ch == '<'
                                || ch == '>'
                                || ch == '#'
                                || ch == '&'
                                || ch == '!'
                                || ch == '%'
                                || ch == ':'
                                || ch == ';'
                                || ch == '@'
                                || ch == '~'
                                || ch == '`'
                                || ch == '\u{200D}'
                                || ch == '\u{FEFF}') =>
                        {
                            // Escape via unicode escape sequence.
                            write!(result, "\\x{:02X}", ch as u32).unwrap_or_default();
                        }
                        _ => result.push(ch),
                    }
                }
                Ok(JsValue::String(result.into()))
            }),
        );

        // ── RegExp.prototype ────────────────────────────────────────────────
        let regexp_proto_rc = {
            let mut proto = PropertyMap::new();

            // RegExp.prototype.exec(string) — delegates to instance exec.
            proto.insert(
                "exec".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this
                        && let Some(JsValue::NativeFunction(f)) = map.borrow().get("exec").cloned()
                    {
                        let input = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        return f(vec![input]);
                    }
                    Ok(JsValue::Null)
                }),
            );

            // RegExp.prototype.test(string) — delegates to instance test.
            proto.insert(
                "test".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this
                        && let Some(JsValue::NativeFunction(f)) = map.borrow().get("test").cloned()
                    {
                        let input = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        return f(vec![input]);
                    }
                    Ok(JsValue::Boolean(false))
                }),
            );

            // RegExp.prototype.toString() — returns "/source/flags".
            proto.insert(
                "toString".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        let source = if let Some(JsValue::NativeFunction(f)) =
                            map.borrow().get("__get_source__").cloned()
                        {
                            f(vec![this.clone()])?.to_js_string()?
                        } else {
                            match map.borrow().get("source").cloned() {
                                Some(JsValue::Undefined) | None => "(?:)".to_string(),
                                Some(value) => value.to_js_string()?,
                            }
                        };
                        let flags = if let Some(JsValue::NativeFunction(f)) =
                            map.borrow().get("__get_flags__").cloned()
                        {
                            f(vec![this.clone()])?.to_js_string()?
                        } else {
                            match map.borrow().get("flags").cloned() {
                                Some(JsValue::Undefined) | None => String::new(),
                                Some(value) => value.to_js_string()?,
                            }
                        };
                        Ok(JsValue::String(format!("/{source}/{flags}").into()))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.toString requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );

            // §22.2.6.11 RegExp.prototype.source — accessor that returns the
            // escaped source text for `this`.
            proto.insert(
                "__get_source__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        let borrow = map.borrow();
                        let raw = match borrow.get("source") {
                            Some(JsValue::String(s)) => s.to_string(),
                            _ => String::new(),
                        };
                        let source = if raw.is_empty() {
                            "(?:)".to_string()
                        } else {
                            raw.replace('/', "\\/")
                        };
                        Ok(JsValue::String(source.into()))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.source requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );

            proto.insert(
                "__get_global__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        Ok(JsValue::Boolean(matches!(
                            map.borrow().get("global"),
                            Some(JsValue::Boolean(true))
                        )))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.global requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );
            proto.insert(
                "__get_ignoreCase__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        Ok(JsValue::Boolean(matches!(
                            map.borrow().get("ignoreCase"),
                            Some(JsValue::Boolean(true))
                        )))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.ignoreCase requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );
            proto.insert(
                "__get_multiline__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        Ok(JsValue::Boolean(matches!(
                            map.borrow().get("multiline"),
                            Some(JsValue::Boolean(true))
                        )))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.multiline requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );
            proto.insert(
                "__get_dotAll__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        Ok(JsValue::Boolean(matches!(
                            map.borrow().get("dotAll"),
                            Some(JsValue::Boolean(true))
                        )))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.dotAll requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );
            proto.insert(
                "__get_sticky__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        Ok(JsValue::Boolean(matches!(
                            map.borrow().get("sticky"),
                            Some(JsValue::Boolean(true))
                        )))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.sticky requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );
            proto.insert(
                "__get_unicode__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        Ok(JsValue::Boolean(
                            matches!(map.borrow().get("unicode"), Some(JsValue::Boolean(true)))
                                || matches!(
                                    map.borrow().get("unicodeSets"),
                                    Some(JsValue::Boolean(true))
                                ),
                        ))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.unicode requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );
            proto.insert(
                "__get_unicodeSets__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        Ok(JsValue::Boolean(matches!(
                            map.borrow().get("unicodeSets"),
                            Some(JsValue::Boolean(true))
                        )))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.unicodeSets requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );
            proto.insert(
                "__get_hasIndices__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        Ok(JsValue::Boolean(matches!(
                            map.borrow().get("hasIndices"),
                            Some(JsValue::Boolean(true))
                        )))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.hasIndices requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );

            // §22.2.6.8 RegExp.prototype.flags — accessor that computes
            // the flag string from individual boolean flag properties on
            // `this`.  Instances have their own "flags" data property so the
            // getter only fires for RegExp.prototype itself or duck-typed
            // objects in the prototype chain.
            proto.insert(
                "__get_flags__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this {
                        let borrow = map.borrow();
                        // Fast path: instance already has a precomputed flags string.
                        if let Some(JsValue::String(s)) = borrow.get("flags") {
                            return Ok(JsValue::String(s.clone()));
                        }
                        // Compute from individual boolean flag properties (spec order).
                        let mut f = String::with_capacity(8);
                        if matches!(borrow.get("hasIndices"), Some(JsValue::Boolean(true))) {
                            f.push('d');
                        }
                        if matches!(borrow.get("global"), Some(JsValue::Boolean(true))) {
                            f.push('g');
                        }
                        if matches!(borrow.get("ignoreCase"), Some(JsValue::Boolean(true))) {
                            f.push('i');
                        }
                        if matches!(borrow.get("multiline"), Some(JsValue::Boolean(true))) {
                            f.push('m');
                        }
                        if matches!(borrow.get("dotAll"), Some(JsValue::Boolean(true))) {
                            f.push('s');
                        }
                        if matches!(borrow.get("unicode"), Some(JsValue::Boolean(true))) {
                            f.push('u');
                        }
                        if matches!(borrow.get("unicodeSets"), Some(JsValue::Boolean(true))) {
                            f.push('v');
                        }
                        if matches!(borrow.get("sticky"), Some(JsValue::Boolean(true))) {
                            f.push('y');
                        }
                        Ok(JsValue::String(f.into()))
                    } else {
                        Err(crate::error::StatorError::TypeError(
                            "RegExp.prototype.flags requires that 'this' be an Object".into(),
                        ))
                    }
                }),
            );

            // §22.2.6.10 RegExp.prototype[@@match] — prototype-level delegator.
            proto.insert(
                "__symbol_match__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this
                        && let Some(JsValue::NativeFunction(f)) =
                            map.borrow().get("__symbol_match__").cloned()
                    {
                        let input = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        return f(vec![input]);
                    }
                    Ok(JsValue::Null)
                }),
            );

            // §22.2.6.12 RegExp.prototype[@@replace] — prototype-level delegator.
            proto.insert(
                "__symbol_replace__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this
                        && let Some(JsValue::NativeFunction(f)) =
                            map.borrow().get("__symbol_replace__").cloned()
                    {
                        let input = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        let repl = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                        return f(vec![input, repl]);
                    }
                    Ok(JsValue::String(String::new().into()))
                }),
            );

            // §22.2.6.13 RegExp.prototype[@@search] — prototype-level delegator.
            proto.insert(
                "__symbol_search__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this
                        && let Some(JsValue::NativeFunction(f)) =
                            map.borrow().get("__symbol_search__").cloned()
                    {
                        let input = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        return f(vec![input]);
                    }
                    Ok(JsValue::Smi(-1))
                }),
            );

            // §22.2.6.14 RegExp.prototype[@@split] — prototype-level delegator.
            proto.insert(
                "__symbol_split__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this
                        && let Some(JsValue::NativeFunction(f)) =
                            map.borrow().get("__symbol_split__").cloned()
                    {
                        let input = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        let limit = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                        return f(vec![input, limit]);
                    }
                    Ok(JsValue::new_array(vec![]))
                }),
            );

            // §22.2.6.9 RegExp.prototype[@@matchAll] — prototype-level delegator.
            proto.insert(
                "__symbol_match_all__".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    if let JsValue::PlainObject(map) = this
                        && let Some(JsValue::NativeFunction(f)) =
                            map.borrow().get("__symbol_match_all__").cloned()
                    {
                        let input = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        return f(vec![input]);
                    }
                    Ok(JsValue::Undefined)
                }),
            );

            // Annex B §B.2.5.1 RegExp.prototype.compile(pattern, flags)
            //
            // Deprecated legacy method that reinitialises a regexp in place.
            // We create a fresh regexp from the new pattern/flags and then
            // overwrite the properties on `this`.
            proto.insert(
                "compile".into(),
                native(|args| {
                    let this = args.first().unwrap_or(&JsValue::Undefined);
                    let pattern_arg = args.get(1).unwrap_or(&JsValue::Undefined);
                    let flags_arg = args.get(2).unwrap_or(&JsValue::Undefined);

                    let pattern = match pattern_arg {
                        JsValue::Undefined => String::new(),
                        v => v.to_js_string()?,
                    };
                    let flags = match flags_arg {
                        JsValue::Undefined => String::new(),
                        v => v.to_js_string()?,
                    };

                    let new_re = regexp_construct(&[
                        JsValue::String(pattern.into()),
                        JsValue::String(flags.into()),
                    ])?;

                    if let (JsValue::PlainObject(target), JsValue::PlainObject(source)) =
                        (this, &new_re)
                    {
                        let src = source.borrow();
                        let mut tgt = target.borrow_mut();
                        // Copy key properties from the freshly-created regexp.
                        for key in &[
                            "source",
                            "flags",
                            "global",
                            "ignoreCase",
                            "multiline",
                            "dotAll",
                            "unicode",
                            "unicodeSets",
                            "sticky",
                            "hasIndices",
                            "lastIndex",
                            "test",
                            "exec",
                            "toString",
                            "__symbol_match__",
                            "__symbol_replace__",
                            "__symbol_search__",
                            "__symbol_split__",
                            "__symbol_match_all__",
                            "__get_source__",
                            "__get_flags__",
                            "__get_global__",
                            "__get_ignoreCase__",
                            "__get_multiline__",
                            "__get_dotAll__",
                            "__get_unicode__",
                            "__get_unicodeSets__",
                            "__get_sticky__",
                            "__get_hasIndices__",
                        ] {
                            if let Some(val) = src.get(key) {
                                tgt.insert(key.to_string(), val.clone());
                            }
                        }
                    }

                    Ok(this.clone())
                }),
            );

            // Static property defaults for the prototype object itself.
            proto.insert("source".into(), JsValue::String("(?:)".to_string().into()));
            proto.insert("flags".into(), JsValue::String(String::new().into()));
            proto.insert("global".into(), JsValue::Boolean(false));
            proto.insert("ignoreCase".into(), JsValue::Boolean(false));
            proto.insert("multiline".into(), JsValue::Boolean(false));
            proto.insert("dotAll".into(), JsValue::Boolean(false));
            proto.insert("sticky".into(), JsValue::Boolean(false));
            proto.insert("unicode".into(), JsValue::Boolean(false));
            proto.insert("unicodeSets".into(), JsValue::Boolean(false));
            proto.insert("hasIndices".into(), JsValue::Boolean(false));
            proto.insert("lastIndex".into(), JsValue::Smi(0));

            proto.insert("@@toStringTag".into(), JsValue::String("RegExp".into()));
            proto.make_all_non_enumerable();
            let re_proto_rc = Rc::new(RefCell::new(proto));
            props.insert(
                "prototype".into(),
                JsValue::PlainObject(re_proto_rc.clone()),
            );
            re_proto_rc
        };

        // §22.2.5.2 get RegExp[@@species] — returns `this`.
        props.insert(
            "__get_@@species__".into(),
            native(|args| Ok(args.first().cloned().unwrap_or(JsValue::Undefined))),
        );

        props.make_all_non_enumerable();
        let ctor = JsValue::PlainObject(Rc::new(RefCell::new(props)));
        // §22.2.4.1 RegExp.prototype.constructor
        regexp_proto_rc.borrow_mut().insert_with_attrs(
            "constructor".into(),
            ctor.clone(),
            PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE,
        );
        ctor
    })
}

/// Build the `BigInt` global constructor with `asIntN` and `asUintN` static methods.
#[inline(never)]
fn make_bigint() -> JsValue {
    let mut props = PropertyMap::new();

    // BigInt(value) — callable constructor (must not be called with `new`)
    props.insert(
        "__call__".into(),
        native(|args| {
            let val = args.first().unwrap_or(&JsValue::Undefined);
            match val {
                JsValue::BigInt(n) => Ok(JsValue::BigInt(n.clone())),
                JsValue::Smi(n) => Ok(JsValue::BigInt(Box::new(i128::from(*n)))),
                JsValue::HeapNumber(n) => {
                    if n.is_nan() || n.is_infinite() || n.fract() != 0.0 {
                        Err(StatorError::RangeError(format!(
                            "The number {n} cannot be converted to a BigInt because it is not an integer"
                        )))
                    } else {
                        Ok(JsValue::BigInt(Box::new(*n as i128)))
                    }
                }
                JsValue::Boolean(b) => Ok(JsValue::BigInt(Box::new(if *b { 1 } else { 0 }))),
                JsValue::String(s) => {
                    let trimmed = s.trim();
                    if trimmed.is_empty() {
                        return Err(StatorError::SyntaxError(
                            "Cannot convert  to a BigInt".to_string(),
                        ));
                    }
                    let parsed = if let Some(hex) =
                        trimmed.strip_prefix("0x").or_else(|| trimmed.strip_prefix("0X"))
                    {
                        i128::from_str_radix(hex, 16)
                    } else if let Some(oct) =
                        trimmed.strip_prefix("0o").or_else(|| trimmed.strip_prefix("0O"))
                    {
                        i128::from_str_radix(oct, 8)
                    } else if let Some(bin) =
                        trimmed.strip_prefix("0b").or_else(|| trimmed.strip_prefix("0B"))
                    {
                        i128::from_str_radix(bin, 2)
                    } else {
                        trimmed.parse::<i128>()
                    };
                    parsed.map(|v| JsValue::BigInt(Box::new(v))).map_err(|_| {
                        StatorError::SyntaxError(format!(
                            "Cannot convert {s} to a BigInt"
                        ))
                    })
                }
                _ => Err(StatorError::TypeError(format!(
                    "Cannot convert {} to a BigInt",
                    val.to_js_string().unwrap_or_default()
                ))),
            }
        }),
    );

    // BigInt.asIntN(bits, bigint)
    props.insert(
        "asIntN".into(),
        native(|args| {
            let bits = args.first().unwrap_or(&JsValue::Undefined).to_number()? as u32;
            let bigint = match args.get(1) {
                Some(JsValue::BigInt(n)) => **n,
                _ => {
                    return Err(StatorError::TypeError(
                        "Cannot convert a non-BigInt value to a BigInt".to_string(),
                    ));
                }
            };
            if bits == 0 {
                return Ok(JsValue::BigInt(Box::new(0)));
            }
            if bits >= 128 {
                return Ok(JsValue::BigInt(Box::new(bigint)));
            }
            let mask = (1i128 << bits) - 1;
            let truncated = bigint & mask;
            // Sign extension
            if truncated & (1i128 << (bits - 1)) != 0 {
                Ok(JsValue::BigInt(Box::new(truncated | !mask)))
            } else {
                Ok(JsValue::BigInt(Box::new(truncated)))
            }
        }),
    );

    // BigInt.asUintN(bits, bigint)
    props.insert(
        "asUintN".into(),
        native(|args| {
            let bits = args.first().unwrap_or(&JsValue::Undefined).to_number()? as u32;
            let bigint = match args.get(1) {
                Some(JsValue::BigInt(n)) => **n,
                _ => {
                    return Err(StatorError::TypeError(
                        "Cannot convert a non-BigInt value to a BigInt".to_string(),
                    ));
                }
            };
            if bits == 0 {
                return Ok(JsValue::BigInt(Box::new(0)));
            }
            if bits >= 128 {
                return Ok(JsValue::BigInt(Box::new(bigint)));
            }
            let mask = (1i128 << bits) - 1;
            Ok(JsValue::BigInt(Box::new(bigint & mask)))
        }),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Extract iterable input values for Promise combinators.
fn extract_promise_values(arg: Option<&JsValue>) -> Result<Vec<JsValue>, String> {
    match arg {
        Some(value) => collect_iterable_values(value).map_err(|error| match error {
            StatorError::TypeError(message) if message == "value is not iterable" => {
                let type_name = match value {
                    JsValue::Null => "null",
                    JsValue::Undefined => "undefined",
                    JsValue::Boolean(_) => "boolean",
                    JsValue::Smi(_) | JsValue::HeapNumber(_) => "number",
                    _ => "object",
                };
                format!(
                    "TypeError: {type_name} is not iterable (cannot read property Symbol(Symbol.iterator))"
                )
            }
            other => other.to_string(),
        }),
        None => Err(
            "TypeError: undefined is not iterable (cannot read property Symbol(Symbol.iterator))"
                .to_string(),
        ),
    }
}

/// Convert a callable [`JsValue`] into a [`PromiseHandler`].
///
/// Supports `NativeFunction`, bytecode `Function`, `Proxy` and `PlainObject`
/// with `__call__` — all types that `dispatch_call_value` can invoke.
fn extract_handler(val: &JsValue) -> Option<crate::builtins::promise::PromiseHandler> {
    match val {
        JsValue::NativeFunction(f) => {
            let f = Rc::clone(f);
            Some(Box::new(move |v: JsValue| match f(vec![v.clone()]) {
                Ok(result) => Ok(result),
                Err(e) => Err(JsValue::String(e.to_string().into())),
            }))
        }
        JsValue::Function(_) | JsValue::Proxy(_) => {
            let callee = val.clone();
            Some(Box::new(move |v: JsValue| {
                match dispatch_call_value(&callee, vec![v.clone()]) {
                    Ok(result) => Ok(result),
                    Err(e) => Err(JsValue::String(e.to_string().into())),
                }
            }))
        }
        JsValue::PlainObject(map) if map.borrow().contains_key("__call__") => {
            let callee = val.clone();
            Some(Box::new(move |v: JsValue| {
                match dispatch_call_value(&callee, vec![v.clone()]) {
                    Ok(result) => Ok(result),
                    Err(e) => Err(JsValue::String(e.to_string().into())),
                }
            }))
        }
        _ => None,
    }
}

// ── Intl ─────────────────────────────────────────────────────────────────────

/// Create a `supportedLocalesOf` native function shared by all Intl constructors.
///
/// Stub: returns all requested locales (we fall back to en-US for everything).
#[inline(never)]
fn make_supported_locales_of() -> JsValue {
    native(|args| {
        let locales: Vec<JsValue> = match args.first() {
            Some(JsValue::Array(arr)) => arr.borrow().iter().cloned().collect(),
            Some(JsValue::String(s)) => vec![JsValue::String(s.clone())],
            _ => Vec::new(),
        };
        Ok(JsValue::new_array(locales))
    })
}

/// Build the `Intl` namespace object (ECMA-402).
///
/// Each property is a constructor-like `PlainObject` with a `__call__` method
/// that returns an instance (another `PlainObject`) carrying a `format` (or
/// `compare` / `select`) method.
#[inline(never)]
fn make_intl() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut ns = PropertyMap::new();

        // ── Intl.NumberFormat ────────────────────────────────────────────────
        ns.insert("NumberFormat".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|_args| {
                    let mut obj = PropertyMap::new();
                    obj.insert("format".into(), native(|a| number_format_js(&a)));
                    obj.insert(
                        "formatToParts".into(),
                        native(|a| number_format_to_parts_js(&a)),
                    );
                    obj.insert("formatRange".into(), native(|a| number_format_range_js(&a)));
                    obj.insert(
                        "formatRangeToParts".into(),
                        native(|a| number_format_range_to_parts_js(&a)),
                    );
                    obj.insert(
                        "resolvedOptions".into(),
                        native(|_| {
                            let mut opts = PropertyMap::new();
                            opts.insert("locale".into(), JsValue::String("en-US".into()));
                            opts.insert("numberingSystem".into(), JsValue::String("latn".into()));
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                        }),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            let mut proto = PropertyMap::new();
            proto.insert("format".into(), native(|a| number_format_js(&a)));
            proto.insert(
                "formatToParts".into(),
                native(|a| number_format_to_parts_js(&a)),
            );
            proto.insert("formatRange".into(), native(|a| number_format_range_js(&a)));
            proto.insert(
                "formatRangeToParts".into(),
                native(|a| number_format_range_to_parts_js(&a)),
            );
            proto.insert(
                "resolvedOptions".into(),
                native(|_| {
                    let mut opts = PropertyMap::new();
                    opts.insert("locale".into(), JsValue::String("en-US".into()));
                    opts.insert("numberingSystem".into(), JsValue::String("latn".into()));
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                }),
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Intl.NumberFormat".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            ctor.insert(
                "prototype".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(proto))),
            );
            finalize_ctor(
                JsValue::PlainObject(Rc::new(RefCell::new(ctor))),
                "NumberFormat",
            )
        });

        // ── Intl.DateTimeFormat ──────────────────────────────────────────────
        ns.insert("DateTimeFormat".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|_args| {
                    let mut obj = PropertyMap::new();
                    obj.insert("format".into(), native(|a| date_time_format_js(&a)));
                    obj.insert(
                        "formatToParts".into(),
                        native(|a| date_time_format_to_parts_js(&a)),
                    );
                    obj.insert(
                        "resolvedOptions".into(),
                        native(|_| {
                            let mut opts = PropertyMap::new();
                            opts.insert("locale".into(), JsValue::String("en-US".into()));
                            opts.insert("calendar".into(), JsValue::String("gregory".into()));
                            opts.insert("timeZone".into(), JsValue::String("UTC".into()));
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                        }),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            let mut proto = PropertyMap::new();
            proto.insert("format".into(), native(|a| date_time_format_js(&a)));
            proto.insert(
                "formatToParts".into(),
                native(|a| date_time_format_to_parts_js(&a)),
            );
            proto.insert(
                "resolvedOptions".into(),
                native(|_| {
                    let mut opts = PropertyMap::new();
                    opts.insert("locale".into(), JsValue::String("en-US".into()));
                    opts.insert("calendar".into(), JsValue::String("gregory".into()));
                    opts.insert("timeZone".into(), JsValue::String("UTC".into()));
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                }),
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Intl.DateTimeFormat".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            ctor.insert(
                "prototype".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(proto))),
            );
            finalize_ctor(
                JsValue::PlainObject(Rc::new(RefCell::new(ctor))),
                "DateTimeFormat",
            )
        });

        // ── Intl.Collator ───────────────────────────────────────────────────
        ns.insert("Collator".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|_args| {
                    let mut obj = PropertyMap::new();
                    obj.insert("compare".into(), native(|a| collator_compare_js(&a)));
                    obj.insert(
                        "resolvedOptions".into(),
                        native(|_| {
                            let mut opts = PropertyMap::new();
                            opts.insert("locale".into(), JsValue::String("en-US".into()));
                            opts.insert("sensitivity".into(), JsValue::String("variant".into()));
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                        }),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            let mut proto = PropertyMap::new();
            proto.insert("compare".into(), native(|a| collator_compare_js(&a)));
            proto.insert(
                "resolvedOptions".into(),
                native(|_| {
                    let mut opts = PropertyMap::new();
                    opts.insert("locale".into(), JsValue::String("en-US".into()));
                    opts.insert("sensitivity".into(), JsValue::String("variant".into()));
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                }),
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Intl.Collator".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            ctor.insert(
                "prototype".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(proto))),
            );
            finalize_ctor(
                JsValue::PlainObject(Rc::new(RefCell::new(ctor))),
                "Collator",
            )
        });

        // ── Intl.PluralRules ────────────────────────────────────────────────
        ns.insert("PluralRules".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|_args| {
                    let mut obj = PropertyMap::new();
                    obj.insert("select".into(), native(|a| plural_rules_select_js(&a)));
                    obj.insert(
                        "selectRange".into(),
                        native(|a| plural_rules_select_range_js(&a)),
                    );
                    obj.insert(
                        "resolvedOptions".into(),
                        native(|_| {
                            let mut opts = PropertyMap::new();
                            opts.insert("locale".into(), JsValue::String("en-US".into()));
                            opts.insert("type".into(), JsValue::String("cardinal".into()));
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                        }),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            let mut proto = PropertyMap::new();
            proto.insert("select".into(), native(|a| plural_rules_select_js(&a)));
            proto.insert(
                "selectRange".into(),
                native(|a| plural_rules_select_range_js(&a)),
            );
            proto.insert(
                "resolvedOptions".into(),
                native(|_| {
                    let mut opts = PropertyMap::new();
                    opts.insert("locale".into(), JsValue::String("en-US".into()));
                    opts.insert("type".into(), JsValue::String("cardinal".into()));
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                }),
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Intl.PluralRules".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            ctor.insert(
                "prototype".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(proto))),
            );
            finalize_ctor(
                JsValue::PlainObject(Rc::new(RefCell::new(ctor))),
                "PluralRules",
            )
        });

        // ── Intl.ListFormat ─────────────────────────────────────────────────
        ns.insert("ListFormat".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|args| {
                    let list_type = if let Some(JsValue::PlainObject(opts)) = args.get(1) {
                        opts.borrow()
                            .get("type")
                            .and_then(|v| {
                                if let JsValue::String(s) = v {
                                    Some(s.to_string())
                                } else {
                                    None
                                }
                            })
                            .unwrap_or_else(|| "conjunction".to_string())
                    } else {
                        "conjunction".to_string()
                    };
                    let lt = list_type.clone();
                    let mut obj = PropertyMap::new();
                    obj.insert(
                        "format".into(),
                        native(move |a| list_format_js(&a, &list_type)),
                    );
                    obj.insert(
                        "formatToParts".into(),
                        native(move |a| list_format_to_parts_js(&a, &lt)),
                    );
                    obj.insert(
                        "resolvedOptions".into(),
                        native(|_| {
                            let mut opts = PropertyMap::new();
                            opts.insert("locale".into(), JsValue::String("en-US".into()));
                            opts.insert("type".into(), JsValue::String("conjunction".into()));
                            opts.insert("style".into(), JsValue::String("long".into()));
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                        }),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            let mut proto = PropertyMap::new();
            proto.insert(
                "format".into(),
                native(|a| list_format_js(&a, "conjunction")),
            );
            proto.insert(
                "formatToParts".into(),
                native(|a| list_format_to_parts_js(&a, "conjunction")),
            );
            proto.insert(
                "resolvedOptions".into(),
                native(|_| {
                    let mut opts = PropertyMap::new();
                    opts.insert("locale".into(), JsValue::String("en-US".into()));
                    opts.insert("type".into(), JsValue::String("conjunction".into()));
                    opts.insert("style".into(), JsValue::String("long".into()));
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                }),
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Intl.ListFormat".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            ctor.insert(
                "prototype".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(proto))),
            );
            finalize_ctor(
                JsValue::PlainObject(Rc::new(RefCell::new(ctor))),
                "ListFormat",
            )
        });

        // ── Intl.RelativeTimeFormat ─────────────────────────────────────────
        ns.insert("RelativeTimeFormat".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|_args| {
                    let mut obj = PropertyMap::new();
                    obj.insert("format".into(), native(|a| relative_time_format_js(&a)));
                    obj.insert(
                        "formatToParts".into(),
                        native(|a| relative_time_format_to_parts_js(&a)),
                    );
                    obj.insert(
                        "resolvedOptions".into(),
                        native(|_| {
                            let mut opts = PropertyMap::new();
                            opts.insert("locale".into(), JsValue::String("en-US".into()));
                            opts.insert("style".into(), JsValue::String("long".into()));
                            opts.insert("numeric".into(), JsValue::String("always".into()));
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                        }),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            let mut proto = PropertyMap::new();
            proto.insert("format".into(), native(|a| relative_time_format_js(&a)));
            proto.insert(
                "formatToParts".into(),
                native(|a| relative_time_format_to_parts_js(&a)),
            );
            proto.insert(
                "resolvedOptions".into(),
                native(|_| {
                    let mut opts = PropertyMap::new();
                    opts.insert("locale".into(), JsValue::String("en-US".into()));
                    opts.insert("style".into(), JsValue::String("long".into()));
                    opts.insert("numeric".into(), JsValue::String("always".into()));
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                }),
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Intl.RelativeTimeFormat".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            ctor.insert(
                "prototype".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(proto))),
            );
            finalize_ctor(
                JsValue::PlainObject(Rc::new(RefCell::new(ctor))),
                "RelativeTimeFormat",
            )
        });

        // ── Intl.Segmenter ──────────────────────────────────────────────────
        ns.insert("Segmenter".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|_args| {
                    let mut obj = PropertyMap::new();
                    obj.insert(
                        "segment".into(),
                        native(|a| {
                            let s = a.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                            segmenter_segment_objects(&s)
                        }),
                    );
                    obj.insert(
                        "resolvedOptions".into(),
                        native(|_| {
                            let mut opts = PropertyMap::new();
                            opts.insert("locale".into(), JsValue::String("en-US".into()));
                            opts.insert("granularity".into(), JsValue::String("grapheme".into()));
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                        }),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            let mut proto = PropertyMap::new();
            proto.insert(
                "segment".into(),
                native(|a| {
                    let s = a.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                    segmenter_segment_objects(&s)
                }),
            );
            proto.insert(
                "resolvedOptions".into(),
                native(|_| {
                    let mut opts = PropertyMap::new();
                    opts.insert("locale".into(), JsValue::String("en-US".into()));
                    opts.insert("granularity".into(), JsValue::String("grapheme".into()));
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                }),
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Intl.Segmenter".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            ctor.insert(
                "prototype".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(proto))),
            );
            finalize_ctor(
                JsValue::PlainObject(Rc::new(RefCell::new(ctor))),
                "Segmenter",
            )
        });

        // ── Intl.DisplayNames ───────────────────────────────────────────────
        ns.insert("DisplayNames".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|args| {
                    let dn_type = if let Some(JsValue::PlainObject(opts)) = args.get(1) {
                        opts.borrow()
                            .get("type")
                            .and_then(|v| {
                                if let JsValue::String(s) = v {
                                    Some(s.to_string())
                                } else {
                                    None
                                }
                            })
                            .unwrap_or_else(|| "language".to_string())
                    } else {
                        "language".to_string()
                    };
                    let dt = dn_type.clone();
                    let mut obj = PropertyMap::new();
                    obj.insert(
                        "of".into(),
                        native(move |a| {
                            let code = a.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                            Ok(JsValue::String(
                                display_names_of_typed(&code, &dn_type).into(),
                            ))
                        }),
                    );
                    obj.insert(
                        "resolvedOptions".into(),
                        native(move |_| {
                            let mut opts = PropertyMap::new();
                            opts.insert("locale".into(), JsValue::String("en-US".into()));
                            opts.insert("type".into(), JsValue::String(dt.clone().into()));
                            opts.insert("style".into(), JsValue::String("long".into()));
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                        }),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            let mut proto = PropertyMap::new();
            proto.insert(
                "of".into(),
                native(|a| {
                    let code = a.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                    Ok(JsValue::String(
                        display_names_of_typed(&code, "language").into(),
                    ))
                }),
            );
            proto.insert(
                "resolvedOptions".into(),
                native(|_| {
                    let mut opts = PropertyMap::new();
                    opts.insert("locale".into(), JsValue::String("en-US".into()));
                    opts.insert("type".into(), JsValue::String("language".into()));
                    opts.insert("style".into(), JsValue::String("long".into()));
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(opts))))
                }),
            );
            proto.insert_with_attrs(
                "@@toStringTag".into(),
                JsValue::String("Intl.DisplayNames".into()),
                PropertyAttributes::CONFIGURABLE,
            );
            ctor.insert(
                "prototype".into(),
                JsValue::PlainObject(Rc::new(RefCell::new(proto))),
            );
            finalize_ctor(
                JsValue::PlainObject(Rc::new(RefCell::new(ctor))),
                "DisplayNames",
            )
        });

        // ── Intl.Locale ─────────────────────────────────────────────────────
        ns.insert("Locale".into(), {
            let mut ctor = PropertyMap::new();
            ctor.insert(
                "__call__".into(),
                native(|args| {
                    let tag = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                    let mut obj = PropertyMap::new();
                    obj.insert(
                        "language".into(),
                        JsValue::String(locale_language(&tag).into()),
                    );
                    obj.insert(
                        "baseName".into(),
                        JsValue::String(locale_base_name(&tag).into()),
                    );
                    obj.insert("region".into(), JsValue::String(locale_region(&tag).into()));
                    obj.insert("script".into(), JsValue::String(locale_script(&tag).into()));
                    let tag_max = tag.clone();
                    obj.insert(
                        "maximize".into(),
                        native(move |_| {
                            let maximized = locale_maximize(&tag_max);
                            // Return a new Locale-like object
                            let mut m = PropertyMap::new();
                            m.insert(
                                "language".into(),
                                JsValue::String(locale_language(&maximized).into()),
                            );
                            m.insert("baseName".into(), JsValue::String(maximized.clone().into()));
                            m.insert(
                                "region".into(),
                                JsValue::String(locale_region(&maximized).into()),
                            );
                            m.insert(
                                "script".into(),
                                JsValue::String(locale_script(&maximized).into()),
                            );
                            let ms = maximized.clone();
                            m.insert(
                                "toString".into(),
                                native(move |_| Ok(JsValue::String(ms.clone().into()))),
                            );
                            m.make_all_non_enumerable();
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(m))))
                        }),
                    );
                    let tag_min = tag.clone();
                    obj.insert(
                        "minimize".into(),
                        native(move |_| {
                            let minimized = locale_minimize(&tag_min);
                            let mut m = PropertyMap::new();
                            m.insert(
                                "language".into(),
                                JsValue::String(locale_language(&minimized).into()),
                            );
                            m.insert("baseName".into(), JsValue::String(minimized.clone().into()));
                            let ms = minimized.clone();
                            m.insert(
                                "toString".into(),
                                native(move |_| Ok(JsValue::String(ms.clone().into()))),
                            );
                            m.make_all_non_enumerable();
                            Ok(JsValue::PlainObject(Rc::new(RefCell::new(m))))
                        }),
                    );
                    obj.insert(
                        "toString".into(),
                        native(move |_| Ok(JsValue::String(tag.clone().into()))),
                    );
                    obj.make_all_non_enumerable();
                    Ok(JsValue::PlainObject(Rc::new(RefCell::new(obj))))
                }),
            );
            ctor.insert("supportedLocalesOf".into(), make_supported_locales_of());
            {
                let mut locale_proto = PropertyMap::new();
                locale_proto.insert_with_attrs(
                    "@@toStringTag".into(),
                    JsValue::String("Intl.Locale".into()),
                    PropertyAttributes::CONFIGURABLE,
                );
                ctor.insert(
                    "prototype".into(),
                    JsValue::PlainObject(Rc::new(RefCell::new(locale_proto))),
                );
            }
            finalize_ctor(JsValue::PlainObject(Rc::new(RefCell::new(ctor))), "Locale")
        });

        // ── Intl.getCanonicalLocales ────────────────────────────────────────
        ns.insert(
            "getCanonicalLocales".into(),
            native(|args| {
                let locales: Vec<JsValue> = match args.first() {
                    Some(JsValue::Array(arr)) => arr
                        .borrow()
                        .iter()
                        .map(|v| match v {
                            JsValue::String(s) => Ok(JsValue::String(s.clone())),
                            other => Ok(JsValue::String(other.to_js_string()?.into())),
                        })
                        .collect::<StatorResult<Vec<_>>>()?,
                    Some(JsValue::String(s)) => vec![JsValue::String(s.clone())],
                    _ => Vec::new(),
                };
                Ok(JsValue::new_array(locales))
            }),
        );

        // ── Intl.supportedValuesOf ──────────────────────────────────────────
        ns.insert(
            "supportedValuesOf".into(),
            native(|args| {
                let key = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                let values: Vec<JsValue> = match key.as_str() {
                    "calendar" => vec![JsValue::String("gregory".into())],
                    "collation" => vec![JsValue::String("default".into())],
                    "currency" => vec![JsValue::String("USD".into())],
                    "numberingSystem" => vec![JsValue::String("latn".into())],
                    "timeZone" => vec![JsValue::String("UTC".into())],
                    "unit" => vec![],
                    _ => Vec::new(),
                };
                Ok(JsValue::new_array(values))
            }),
        );

        ns.insert_with_attrs(
            "@@toStringTag".into(),
            JsValue::String("Intl".into()),
            PropertyAttributes::CONFIGURABLE,
        );
        ns.make_all_non_enumerable();
        JsValue::PlainObject(Rc::new(RefCell::new(ns)))
    })
}

// ── Proxy ────────────────────────────────────────────────────────────────────

/// Build the `Proxy` constructor namespace.
///
/// Provides `Proxy(target, handler)` as a callable constructor and
/// `Proxy.revocable(target, handler)` as a static method.
#[inline(never)]
fn make_proxy() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        // Proxy as a constructor: new Proxy(target, handler)
        props.insert(
            "__call__".into(),
            native(|args| {
                let target_val = args.first().cloned().unwrap_or(JsValue::Undefined);
                let handler_val = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                // target must be an object-like value; detect callability
                let (target, callable) = match &target_val {
                    JsValue::PlainObject(map) => {
                        let mut obj = JsObject::new();
                        for (k, v) in map.borrow().iter() {
                            obj.set_property(k, v.clone()).ok();
                        }
                        (obj, false)
                    }
                    JsValue::Array(arr) => {
                        let mut obj = JsObject::new();
                        let borrow = arr.borrow();
                        for (idx, val) in borrow.iter().enumerate() {
                            if !val.is_the_hole() {
                                obj.set_property(&idx.to_string(), val.clone()).ok();
                            }
                        }
                        obj.set_property("length", JsValue::Smi(borrow.len() as i32))
                            .ok();
                        obj.set_property("__is_array__", JsValue::Boolean(true))
                            .ok();
                        (obj, false)
                    }
                    JsValue::Function(_) | JsValue::NativeFunction(_) => (JsObject::new(), true),
                    _ => {
                        return Err(StatorError::TypeError(
                            "Proxy: target must be an object".to_string(),
                        ));
                    }
                };
                // Build a ProxyHandler from the handler PlainObject's trap functions
                let handler = build_proxy_handler(&handler_val, &target_val);
                let mut proxy = if callable {
                    proxy_new_callable(target, handler)
                } else {
                    proxy_new(target, handler)
                };
                proxy.target_value = Some(target_val.clone());
                Ok(JsValue::Proxy(Rc::new(RefCell::new(proxy))))
            }),
        );

        // Proxy.revocable(target, handler)
        props.insert(
            "revocable".into(),
            native(|args| {
                let target_val = args.first().cloned().unwrap_or(JsValue::Undefined);
                let handler_val = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                let (target, callable) = match &target_val {
                    JsValue::PlainObject(map) => {
                        let mut obj = JsObject::new();
                        for (k, v) in map.borrow().iter() {
                            obj.set_property(k, v.clone()).ok();
                        }
                        (obj, false)
                    }
                    JsValue::Array(arr) => {
                        let mut obj = JsObject::new();
                        let borrow = arr.borrow();
                        for (idx, val) in borrow.iter().enumerate() {
                            if !val.is_the_hole() {
                                obj.set_property(&idx.to_string(), val.clone()).ok();
                            }
                        }
                        obj.set_property("length", JsValue::Smi(borrow.len() as i32))
                            .ok();
                        obj.set_property("__is_array__", JsValue::Boolean(true))
                            .ok();
                        (obj, false)
                    }
                    JsValue::Function(_) | JsValue::NativeFunction(_) => (JsObject::new(), true),
                    _ => {
                        return Err(StatorError::TypeError(
                            "Proxy.revocable: target must be an object".to_string(),
                        ));
                    }
                };
                let handler = build_proxy_handler(&handler_val, &target_val);
                let mut proxy = proxy_revocable(target, handler);
                proxy.target_value = Some(target_val.clone());
                if callable {
                    proxy.callable = true;
                }
                let proxy_rc = Rc::new(RefCell::new(proxy));
                let proxy_val = JsValue::Proxy(Rc::clone(&proxy_rc));
                let revoke_fn = JsValue::NativeFunction(Rc::new(move |_args| {
                    proxy_revoke(&mut proxy_rc.borrow_mut());
                    Ok(JsValue::Undefined)
                }));
                let mut result = PropertyMap::new();
                result.insert("proxy".to_string(), proxy_val);
                result.insert("revoke".to_string(), revoke_fn);
                Ok(JsValue::PlainObject(Rc::new(RefCell::new(result))))
            }),
        );

        props.make_all_non_enumerable();
        JsValue::PlainObject(Rc::new(RefCell::new(props)))
    })
}

/// Extract proxy handler traps from a JS handler object.
///
/// `target_val` is the original JS target value passed to the Proxy
/// constructor so that handler traps receive the correct `target` argument
/// per ECMAScript §10.5.
fn call_proxy_handler_trap(
    trap: &JsValue,
    handler_this: &JsValue,
    args: Vec<JsValue>,
) -> StatorResult<JsValue> {
    dispatch_call_with_this(trap, handler_this.clone(), args)
}

fn descriptor_value_to_parts(result: &JsValue) -> Option<(JsValue, PropertyAttributes)> {
    if result.is_undefined() || result.is_null() {
        return None;
    }
    let JsValue::PlainObject(desc) = result else {
        return None;
    };
    let desc_borrow = desc.borrow();
    let value = desc_borrow
        .get("value")
        .cloned()
        .unwrap_or(JsValue::Undefined);
    let mut attrs = PropertyAttributes::empty();
    if desc_borrow.get("writable").is_some_and(|v| v.to_boolean()) {
        attrs |= PropertyAttributes::WRITABLE;
    }
    if desc_borrow
        .get("enumerable")
        .is_some_and(|v| v.to_boolean())
    {
        attrs |= PropertyAttributes::ENUMERABLE;
    }
    if desc_borrow
        .get("configurable")
        .is_some_and(|v| v.to_boolean())
    {
        attrs |= PropertyAttributes::CONFIGURABLE;
    }
    Some((value, attrs))
}

#[allow(dead_code)]
fn plain_object_to_js_object(map: &Rc<RefCell<PropertyMap>>) -> JsObject {
    let mut obj = JsObject::new();
    let borrow = map.borrow();
    for (k, v) in borrow.iter() {
        if k.as_ref() == "__proto__" || is_internal_accessor_key(k) {
            continue;
        }
        let mut attrs = PropertyAttributes::empty();
        if borrow.is_writable(k) {
            attrs |= PropertyAttributes::WRITABLE;
        }
        if borrow.is_enumerable(k) {
            attrs |= PropertyAttributes::ENUMERABLE;
        }
        if borrow.is_configurable(k) {
            attrs |= PropertyAttributes::CONFIGURABLE;
        }
        obj.define_own_property(k, v.clone(), attrs).ok();
    }
    if !borrow.extensible {
        obj.prevent_extensions();
    }
    obj
}

fn build_proxy_handler(handler_val: &JsValue, target_val: &JsValue) -> ProxyHandler {
    let mut handler = ProxyHandler::default();
    let handler_this = handler_val.clone();
    let handler_map = match handler_val {
        JsValue::PlainObject(map) => Some(Rc::clone(map)),
        _ => None,
    };

    let get_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("get").cloned());
    let set_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("set").cloned());
    let has_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("has").cloned());
    let delete_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("deleteProperty").cloned());
    let define_property_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("defineProperty").cloned());
    let get_own_property_descriptor_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("getOwnPropertyDescriptor").cloned());
    let get_prototype_of_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("getPrototypeOf").cloned());
    let set_prototype_of_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("setPrototypeOf").cloned());
    let is_extensible_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("isExtensible").cloned());
    let prevent_extensions_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("preventExtensions").cloned());
    let own_keys_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("ownKeys").cloned());
    let apply_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("apply").cloned());
    let construct_trap = handler_map
        .as_ref()
        .and_then(|map| map.borrow().get("construct").cloned());

    {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.get = Some(Box::new(move |_target, key, receiver| {
            if let Some(trap) = &get_trap {
                return call_proxy_handler_trap(
                    trap,
                    &handler_this,
                    vec![
                        target.clone(),
                        JsValue::String(key.to_string().into()),
                        receiver.clone(),
                    ],
                );
            }
            match &target {
                JsValue::PlainObject(_) => plain_get(&target, key, receiver),
                _ => dispatch_get_property_value(&target, JsValue::String(key.to_string().into())),
            }
        }));
    }

    {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.set = Some(Box::new(move |_target, key, value, receiver| {
            if let Some(trap) = &set_trap {
                let result = call_proxy_handler_trap(
                    trap,
                    &handler_this,
                    vec![
                        target.clone(),
                        JsValue::String(key.to_string().into()),
                        value,
                        receiver.clone(),
                    ],
                )?;
                return Ok(result.to_boolean());
            }
            match &target {
                JsValue::PlainObject(_) => plain_set(&target, key, value, receiver),
                _ => {
                    dispatch_set_property_value(
                        &target,
                        JsValue::String(key.to_string().into()),
                        value,
                    )?;
                    Ok(true)
                }
            }
        }));
    }

    {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.has = Some(Box::new(move |_target, key| {
            if let Some(trap) = &has_trap {
                let result = call_proxy_handler_trap(
                    trap,
                    &handler_this,
                    vec![target.clone(), JsValue::String(key.to_string().into())],
                )?;
                return Ok(result.to_boolean());
            }
            Ok(match &target {
                JsValue::PlainObject(_) => plain_has(&target, key),
                _ => !matches!(
                    dispatch_get_property_value(&target, JsValue::String(key.to_string().into())),
                    Ok(JsValue::Undefined) | Err(_)
                ),
            })
        }));
    }

    {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.delete_property = Some(Box::new(move |_target, key| {
            if let Some(trap) = &delete_trap {
                let result = call_proxy_handler_trap(
                    trap,
                    &handler_this,
                    vec![target.clone(), JsValue::String(key.to_string().into())],
                )?;
                return Ok(result.to_boolean());
            }
            Ok(match &target {
                JsValue::PlainObject(map) => plain_delete_property(map, key),
                _ => true,
            })
        }));
    }

    if let Some(trap) = define_property_trap {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.define_property = Some(Box::new(move |_target, key, value, _attrs| {
            let result = call_proxy_handler_trap(
                &trap,
                &handler_this,
                vec![
                    target.clone(),
                    JsValue::String(key.to_string().into()),
                    value,
                ],
            )?;
            Ok(result.to_boolean())
        }));
    }

    {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.get_own_property_descriptor = Some(Box::new(move |_target, key| {
            if let Some(trap) = &get_own_property_descriptor_trap {
                let result = call_proxy_handler_trap(
                    trap,
                    &handler_this,
                    vec![target.clone(), JsValue::String(key.to_string().into())],
                )?;
                return Ok(descriptor_value_to_parts(&result));
            }
            match &target {
                JsValue::PlainObject(map) => Ok(descriptor_value_to_parts(
                    &plain_descriptor_as_object(map, key),
                )),
                _ => Ok(None),
            }
        }));
    }

    if let Some(trap) = get_prototype_of_trap {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.get_prototype_of = Some(Box::new(move |_target| {
            let result = call_proxy_handler_trap(&trap, &handler_this, vec![target.clone()])?;
            if result.is_null() || result.is_undefined() {
                Ok(JsValue::Null)
            } else {
                Ok(result)
            }
        }));
    }

    if let Some(trap) = set_prototype_of_trap {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.set_prototype_of = Some(Box::new(move |_target, proto| {
            let result =
                call_proxy_handler_trap(&trap, &handler_this, vec![target.clone(), proto])?;
            Ok(result.to_boolean())
        }));
    }

    if let Some(trap) = is_extensible_trap {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.is_extensible = Some(Box::new(move |_target| {
            let result = call_proxy_handler_trap(&trap, &handler_this, vec![target.clone()])?;
            Ok(result.to_boolean())
        }));
    }

    if let Some(trap) = prevent_extensions_trap {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.prevent_extensions = Some(Box::new(move |_target| {
            let result = call_proxy_handler_trap(&trap, &handler_this, vec![target.clone()])?;
            Ok(result.to_boolean())
        }));
    }

    {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.own_keys = Some(Box::new(move |_target| {
            if let Some(trap) = &own_keys_trap {
                let result = call_proxy_handler_trap(trap, &handler_this, vec![target.clone()])?;
                let JsValue::Array(items) = result else {
                    return Err(StatorError::TypeError(
                        "ownKeys trap must return an array".to_string(),
                    ));
                };
                return items
                    .borrow()
                    .iter()
                    .map(|value| match value {
                        JsValue::String(_) | JsValue::Symbol(_) => Ok(value.clone()),
                        _ => Err(StatorError::TypeError(
                            "ownKeys trap must return only strings or symbols".to_string(),
                        )),
                    })
                    .collect();
            }
            Ok(match &target {
                JsValue::PlainObject(map) => plain_own_keys(&map.borrow()),
                _ => vec![],
            })
        }));
    }

    if is_callable(target_val) {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.apply = Some(Box::new(move |this, args| {
            if let Some(trap) = &apply_trap {
                return call_proxy_handler_trap(
                    trap,
                    &handler_this,
                    vec![target.clone(), this, JsValue::new_array(args)],
                );
            }
            dispatch_call_with_this(&target, this, args)
        }));
    }

    if is_callable(target_val) {
        let target = target_val.clone();
        let handler_this = handler_this.clone();
        handler.construct = Some(Box::new(move |args, new_target| {
            if let Some(trap) = &construct_trap {
                let result = call_proxy_handler_trap(
                    trap,
                    &handler_this,
                    vec![target.clone(), JsValue::new_array(args), new_target],
                )?;
                return match &result {
                    JsValue::PlainObject(_) | JsValue::Function(_) | JsValue::Error(_) => {
                        Ok(result)
                    }
                    _ => Err(StatorError::TypeError(
                        "construct trap must return an object".to_string(),
                    )),
                };
            }

            let ctor_proto =
                dispatch_get_property_value(&target, JsValue::String("prototype".into()))?;
            let this_obj = JsValue::PlainObject(Rc::new(RefCell::new(PropertyMap::new())));
            if !matches!(ctor_proto, JsValue::Undefined | JsValue::Null)
                && let JsValue::PlainObject(map) = &this_obj
            {
                map.borrow_mut().insert("__proto__".to_string(), ctor_proto);
            }
            let result = dispatch_call_with_this(&target, this_obj.clone(), args)?;
            match result {
                JsValue::PlainObject(_) | JsValue::Function(_) => Ok(result),
                _ => Ok(this_obj),
            }
        }));
    }

    handler
}

// ── Reflect ──────────────────────────────────────────────────────────────────

/// Build the `Reflect` namespace object with all 13 static methods.
#[inline(never)]
fn make_reflect() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        let mut props = PropertyMap::new();

        props.insert(
            "get".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.get: argument is not an object".to_string(),
                    ));
                }
                let key = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_property_key()?;
                let receiver = args.get(2).cloned().unwrap_or_else(|| target.clone());
                match &target {
                    JsValue::PlainObject(_) => plain_get(&target, &key, &receiver),
                    JsValue::Proxy(proxy) => {
                        proxy_get_with_receiver(&proxy.borrow(), &key, &receiver)
                    }
                    _ => dispatch_get_property_value(&target, JsValue::String(key.into())),
                }
            }),
        );

        props.insert(
            "set".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.set: argument is not an object".to_string(),
                    ));
                }
                let key = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_property_key()?;
                let value = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let receiver = args.get(3).cloned().unwrap_or_else(|| target.clone());
                let result = match &target {
                    JsValue::PlainObject(_) => plain_set(&target, &key, value, &receiver)?,
                    JsValue::Proxy(proxy) => {
                        proxy_set_with_receiver(&mut proxy.borrow_mut(), &key, value, &receiver)?
                    }
                    _ => {
                        dispatch_set_property_value(&target, JsValue::String(key.into()), value)?;
                        true
                    }
                };
                Ok(JsValue::Boolean(result))
            }),
        );

        props.insert(
            "has".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.has: argument is not an object".to_string(),
                    ));
                }
                let key = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_property_key()?;
                let result = match &target {
                    JsValue::PlainObject(_) => plain_has(&target, &key),
                    JsValue::Proxy(proxy) => proxy_has(&proxy.borrow(), &key)?,
                    JsValue::Array(items) => {
                        if key == "length" {
                            true
                        } else if let Ok(idx) = key.parse::<usize>() {
                            let arr = items.borrow();
                            idx < arr.len() && !arr[idx].is_the_hole()
                        } else {
                            false
                        }
                    }
                    _ => false,
                };
                Ok(JsValue::Boolean(result))
            }),
        );

        props.insert(
            "deleteProperty".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.deleteProperty: argument is not an object".to_string(),
                    ));
                }
                let key = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_property_key()?;
                let result = match &target {
                    JsValue::PlainObject(map) => plain_delete_property(map, &key),
                    JsValue::Proxy(proxy) => proxy_delete_property(&mut proxy.borrow_mut(), &key)?,
                    _ => false,
                };
                Ok(JsValue::Boolean(result))
            }),
        );

        props.insert(
            "defineProperty".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.defineProperty: argument is not an object".to_string(),
                    ));
                }
                let key = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_property_key()?;
                let desc_arg = args.get(2).cloned().unwrap_or(JsValue::Undefined);
                let result = match &target {
                    JsValue::PlainObject(map) => match &desc_arg {
                        JsValue::PlainObject(desc_map) => {
                            match define_plain_own_property(map, &key, &desc_map.borrow()) {
                                Ok(()) => true,
                                Err(StatorError::TypeError(message))
                                    if !message.starts_with("Invalid property descriptor") =>
                                {
                                    false
                                }
                                Err(err) => return Err(err),
                            }
                        }
                        _ => {
                            return Err(StatorError::TypeError(
                                "Property description must be an object".into(),
                            ));
                        }
                    },
                    JsValue::Proxy(proxy) => {
                        let desc_map = match &desc_arg {
                            JsValue::PlainObject(desc_map) => desc_map,
                            _ => {
                                return Err(StatorError::TypeError(
                                    "Property description must be an object".into(),
                                ));
                            }
                        };
                        let desc_borrow = desc_map.borrow();
                        let value = desc_borrow
                            .get("value")
                            .cloned()
                            .unwrap_or(JsValue::Undefined);
                        let mut attrs = PropertyAttributes::empty();
                        if desc_borrow.get("writable").is_some_and(|v| v.to_boolean()) {
                            attrs |= PropertyAttributes::WRITABLE;
                        }
                        if desc_borrow
                            .get("enumerable")
                            .is_some_and(|v| v.to_boolean())
                        {
                            attrs |= PropertyAttributes::ENUMERABLE;
                        }
                        if desc_borrow
                            .get("configurable")
                            .is_some_and(|v| v.to_boolean())
                        {
                            attrs |= PropertyAttributes::CONFIGURABLE;
                        }
                        proxy_define_property(&mut proxy.borrow_mut(), &key, value, attrs)?
                    }
                    _ => false,
                };
                Ok(JsValue::Boolean(result))
            }),
        );

        props.insert(
            "getOwnPropertyDescriptor".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.getOwnPropertyDescriptor: argument is not an object".to_string(),
                    ));
                }
                let key = args
                    .get(1)
                    .unwrap_or(&JsValue::Undefined)
                    .to_property_key()?;
                let result = match &target {
                    JsValue::PlainObject(map) => plain_descriptor_as_object(map, &key),
                    JsValue::Proxy(proxy) => {
                        match proxy_get_own_property_descriptor(&proxy.borrow(), &key)? {
                            Some((val, attrs)) => {
                                let mut desc = PropertyMap::new();
                                desc.insert("value".to_string(), val);
                                desc.insert(
                                    "writable".to_string(),
                                    JsValue::Boolean(attrs.contains(PropertyAttributes::WRITABLE)),
                                );
                                desc.insert(
                                    "enumerable".to_string(),
                                    JsValue::Boolean(
                                        attrs.contains(PropertyAttributes::ENUMERABLE),
                                    ),
                                );
                                desc.insert(
                                    "configurable".to_string(),
                                    JsValue::Boolean(
                                        attrs.contains(PropertyAttributes::CONFIGURABLE),
                                    ),
                                );
                                JsValue::PlainObject(Rc::new(RefCell::new(desc)))
                            }
                            None => JsValue::Undefined,
                        }
                    }
                    _ => JsValue::Undefined,
                };
                Ok(result)
            }),
        );

        props.insert(
            "getPrototypeOf".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.getPrototypeOf: argument is not an object".to_string(),
                    ));
                }
                let proto = match &target {
                    JsValue::Proxy(proxy) => {
                        let result = proxy_get_prototype_of(&proxy.borrow())?;
                        if result.is_null() || result.is_undefined() {
                            None
                        } else {
                            Some(result)
                        }
                    }
                    _ => get_object_prototype(&target),
                };
                Ok(proto.unwrap_or(JsValue::Null))
            }),
        );

        props.insert(
            "setPrototypeOf".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.setPrototypeOf: argument is not an object".to_string(),
                    ));
                }
                let proto_arg = args.get(1).cloned().unwrap_or(JsValue::Null);
                if !matches!(
                    proto_arg,
                    JsValue::Null | JsValue::PlainObject(_) | JsValue::Function(_)
                ) {
                    return Err(StatorError::TypeError(
                        "Object prototype may only be an Object or null".to_string(),
                    ));
                }
                let result = match &target {
                    JsValue::PlainObject(_) | JsValue::Error(_) => {
                        ordinary_set_prototype_of(&target, proto_arg.clone()).is_ok()
                    }
                    JsValue::Proxy(proxy) => {
                        proxy_set_prototype_of(&mut proxy.borrow_mut(), proto_arg)?
                    }
                    _ => false,
                };
                Ok(JsValue::Boolean(result))
            }),
        );

        props.insert(
            "isExtensible".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.isExtensible: argument is not an object".to_string(),
                    ));
                }
                let result = match &target {
                    JsValue::PlainObject(map) => map.borrow().extensible,
                    JsValue::Proxy(proxy) => proxy_is_extensible(&proxy.borrow())?,
                    _ => true,
                };
                Ok(JsValue::Boolean(result))
            }),
        );

        props.insert(
            "preventExtensions".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.preventExtensions: argument is not an object".to_string(),
                    ));
                }
                let result = match &target {
                    JsValue::PlainObject(map) => {
                        map.borrow_mut().extensible = false;
                        true
                    }
                    JsValue::Proxy(proxy) => proxy_prevent_extensions(&mut proxy.borrow_mut())?,
                    _ => true,
                };
                Ok(JsValue::Boolean(result))
            }),
        );

        props.insert(
            "ownKeys".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !target.is_object_like() {
                    return Err(StatorError::TypeError(
                        "Reflect.ownKeys: argument is not an object".to_string(),
                    ));
                }
                let keys = match &target {
                    JsValue::PlainObject(map) => plain_own_keys(&map.borrow()),
                    JsValue::Array(items) => {
                        let mut keys: Vec<JsValue> = (0..items.borrow().len())
                            .map(|index| JsValue::String(index.to_string().into()))
                            .collect();
                        keys.push(JsValue::String("length".into()));
                        keys
                    }
                    JsValue::Error(error) => {
                        let mut keys: Vec<JsValue> = error_own_string_keys(error)
                            .into_iter()
                            .map(|name| JsValue::String(name.into()))
                            .collect();
                        keys.extend(
                            error
                                .props
                                .borrow()
                                .own_symbol_keys()
                                .into_iter()
                                .map(JsValue::Symbol),
                        );
                        keys
                    }
                    JsValue::Proxy(proxy) => proxy_own_keys(&proxy.borrow())?,
                    _ => vec![],
                };
                Ok(JsValue::new_array(keys))
            }),
        );

        props.insert(
            "apply".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                let this_arg = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                let arg_list = value_to_reflect_args_list(args.get(2))?;
                if let JsValue::Proxy(proxy) = &target {
                    return crate::builtins::proxy::proxy_apply(
                        &mut proxy.borrow_mut(),
                        this_arg,
                        arg_list,
                    );
                }
                dispatch_call_with_this(&target, this_arg, arg_list)
            }),
        );

        props.insert(
            "construct".into(),
            native(|args| {
                let target = args.first().cloned().unwrap_or(JsValue::Undefined);
                if !is_callable(&target) {
                    return Err(StatorError::TypeError(
                        "Reflect.construct: target is not a constructor".to_string(),
                    ));
                }
                let arg_list = value_to_reflect_args_list(args.get(1))?;
                let new_target = args.get(2).cloned().unwrap_or_else(|| target.clone());
                if !is_callable(&new_target) {
                    return Err(StatorError::TypeError(
                        "Reflect.construct: newTarget is not a constructor".to_string(),
                    ));
                }
                let ctor_proto =
                    dispatch_get_property_value(&new_target, JsValue::String("prototype".into()))?;
                let this_obj = JsValue::PlainObject(Rc::new(RefCell::new(PropertyMap::new())));
                if !matches!(ctor_proto, JsValue::Undefined | JsValue::Null)
                    && let JsValue::PlainObject(map) = &this_obj
                {
                    map.borrow_mut().insert("__proto__".to_string(), ctor_proto);
                }
                let result =
                    dispatch_construct_call(&target, this_obj.clone(), arg_list, new_target)?;
                match result {
                    JsValue::PlainObject(_)
                    | JsValue::Array(_)
                    | JsValue::Function(_)
                    | JsValue::NativeFunction(_)
                    | JsValue::Error(_)
                    | JsValue::Proxy(_)
                    | JsValue::ArrayBuffer(_)
                    | JsValue::TypedArray(_)
                    | JsValue::DataView(_)
                    | JsValue::Promise(_)
                    | JsValue::Generator(_)
                    | JsValue::Iterator(_)
                    | JsValue::Context(_)
                    | JsValue::Object(_) => Ok(result),
                    _ => Ok(this_obj),
                }
            }),
        );

        // §26.1.14 Reflect[@@toStringTag] = "Reflect"
        props.insert_with_attrs(
            "@@toStringTag".into(),
            JsValue::String("Reflect".into()),
            PropertyAttributes::CONFIGURABLE,
        );

        props.make_all_non_enumerable();
        JsValue::PlainObject(Rc::new(RefCell::new(props)))
    })
}

// ── ArrayBuffer / DataView / TypedArray constructors ─────────────────────────

/// Extract the `Rc<RefCell<JsArrayBuffer>>` from a raw `JsValue::ArrayBuffer`
/// *or* from a PlainObject wrapper produced by `make_arraybuffer_instance`.
fn extract_arraybuffer(v: &JsValue) -> Option<Rc<RefCell<JsArrayBuffer>>> {
    match v {
        JsValue::ArrayBuffer(b) => Some(Rc::clone(b)),
        JsValue::PlainObject(map) => {
            if let Some(JsValue::ArrayBuffer(b)) = map.borrow().get("__arraybuffer__") {
                Some(Rc::clone(b))
            } else {
                None
            }
        }
        _ => None,
    }
}

/// Extract the `Rc<RefCell<JsTypedArray>>` from a raw `JsValue::TypedArray`
/// *or* from a PlainObject wrapper produced by `make_typed_array_instance`.
fn extract_typed_array(
    v: &JsValue,
) -> Option<Rc<RefCell<crate::builtins::typed_array::JsTypedArray>>> {
    match v {
        JsValue::TypedArray(inner) => Some(Rc::clone(inner)),
        JsValue::PlainObject(map) => {
            if let Some(JsValue::TypedArray(inner)) = map.borrow().get("__typed_array__") {
                Some(Rc::clone(inner))
            } else {
                None
            }
        }
        _ => None,
    }
}

/// Extract the `Rc<RefCell<JsDataView>>` from a raw `JsValue::DataView`
/// *or* from a PlainObject wrapper produced by `make_dataview_instance`.
fn extract_dataview(v: &JsValue) -> Option<Rc<RefCell<crate::builtins::typed_array::JsDataView>>> {
    match v {
        JsValue::DataView(inner) => Some(Rc::clone(inner)),
        JsValue::PlainObject(map) => {
            if let Some(JsValue::DataView(inner)) = map.borrow().get("__dataview__") {
                Some(Rc::clone(inner))
            } else {
                None
            }
        }
        _ => None,
    }
}

/// Collect source values for typed-array constructors and static methods.
fn collect_typed_array_source_values(source: &JsValue) -> StatorResult<Vec<JsValue>> {
    if let Some(inner) = extract_typed_array(source) {
        let typed_array = inner.borrow();
        return Ok((0..typed_array.length)
            .map(|index| typed_array_get(&typed_array, index))
            .collect());
    }
    match source {
        JsValue::Array(_) | JsValue::Iterator(_) | JsValue::Generator(_) | JsValue::String(_) => {
            collect_iterable_values(source)
        }
        JsValue::PlainObject(_) | JsValue::Proxy(_) => collect_iterable_values(source)
            .or_else(|_| try_to_array_like_elements(source).map(|(elements, _)| elements)),
        _ => Err(StatorError::TypeError("value is not iterable".into())),
    }
}

fn incompatible_receiver(display_name: &str) -> StatorError {
    StatorError::TypeError(format!("{display_name} called on incompatible receiver"))
}

fn dataview_bigint_argument(value: &JsValue) -> StatorResult<i128> {
    match value.to_numeric()? {
        JsValue::BigInt(n) => Ok(*n),
        _ => Err(StatorError::TypeError(
            "Cannot convert a non-BigInt value to a BigInt".to_string(),
        )),
    }
}

fn buffer_option_max_byte_length(options: Option<&JsValue>) -> StatorResult<Option<usize>> {
    let Some(options) = options.filter(|value| !value.is_undefined()) else {
        return Ok(None);
    };
    let max = dispatch_get_property_value(options, JsValue::String("maxByteLength".into()))?;
    if max.is_undefined() {
        return Ok(None);
    }
    Ok(Some(crate::builtins::util::checked_f64_to_index(
        max.to_number()?,
    )?))
}

fn arraybuffer_display_name(buf: &JsArrayBuffer) -> &'static str {
    if buf.shared {
        "SharedArrayBuffer"
    } else {
        "ArrayBuffer"
    }
}

fn arraybuffer_display_name_for_rc(buf_rc: &Rc<RefCell<JsArrayBuffer>>) -> &'static str {
    arraybuffer_display_name(&buf_rc.borrow())
}

fn make_arraybuffer_prototype_impl(shared: bool) -> JsValue {
    let display_name = if shared {
        "SharedArrayBuffer"
    } else {
        "ArrayBuffer"
    };
    let mut proto = PropertyMap::new();
    proto.insert(
        "__get_byteLength__".into(),
        native(move |args| {
            let receiver = args.first().unwrap_or(&JsValue::Undefined);
            let Some(buf_rc) = extract_arraybuffer(receiver) else {
                return Err(incompatible_receiver(&format!(
                    "{display_name}.prototype.byteLength"
                )));
            };
            if buf_rc.borrow().shared != shared {
                return Err(incompatible_receiver(&format!(
                    "{display_name}.prototype.byteLength"
                )));
            }
            Ok(JsValue::Smi(
                arraybuffer_byte_length(&buf_rc.borrow()) as i32
            ))
        }),
    );
    if shared {
        proto.insert(
            "__get_maxByteLength__".into(),
            native(move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver(
                        "SharedArrayBuffer.prototype.maxByteLength",
                    ));
                };
                if !buf_rc.borrow().shared {
                    return Err(incompatible_receiver(
                        "SharedArrayBuffer.prototype.maxByteLength",
                    ));
                }
                Ok(JsValue::Smi(
                    arraybuffer_max_byte_length(&buf_rc.borrow()) as i32
                ))
            }),
        );
        proto.insert(
            "__get_growable__".into(),
            native(move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver(
                        "SharedArrayBuffer.prototype.growable",
                    ));
                };
                if !buf_rc.borrow().shared {
                    return Err(incompatible_receiver(
                        "SharedArrayBuffer.prototype.growable",
                    ));
                }
                Ok(JsValue::Boolean(shared_arraybuffer_growable(
                    &buf_rc.borrow(),
                )))
            }),
        );
        proto.insert(
            "grow".into(),
            builtin_fn("grow", 1, move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver("SharedArrayBuffer.prototype.grow"));
                };
                if !buf_rc.borrow().shared {
                    return Err(incompatible_receiver("SharedArrayBuffer.prototype.grow"));
                }
                let new_len = match args.get(1) {
                    Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
                    None => 0,
                };
                shared_arraybuffer_grow(&mut buf_rc.borrow_mut(), new_len)?;
                Ok(JsValue::Undefined)
            }),
        );
    } else {
        proto.insert(
            "__get_resizable__".into(),
            native(move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.resizable"));
                };
                if buf_rc.borrow().shared {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.resizable"));
                }
                Ok(JsValue::Boolean(arraybuffer_resizable(&buf_rc.borrow())))
            }),
        );
        proto.insert(
            "__get_maxByteLength__".into(),
            native(move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.maxByteLength"));
                };
                if buf_rc.borrow().shared {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.maxByteLength"));
                }
                Ok(JsValue::Smi(
                    arraybuffer_max_byte_length(&buf_rc.borrow()) as i32
                ))
            }),
        );
        proto.insert(
            "__get_detached__".into(),
            native(move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.detached"));
                };
                if buf_rc.borrow().shared {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.detached"));
                }
                Ok(JsValue::Boolean(arraybuffer_detached(&buf_rc.borrow())))
            }),
        );
        proto.insert(
            "resize".into(),
            builtin_fn("resize", 1, move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.resize"));
                };
                if buf_rc.borrow().shared {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.resize"));
                }
                let new_len = match args.get(1) {
                    Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
                    None => 0,
                };
                arraybuffer_resize(&mut buf_rc.borrow_mut(), new_len)?;
                Ok(JsValue::Undefined)
            }),
        );
        proto.insert(
            "transfer".into(),
            builtin_fn("transfer", 0, move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.transfer"));
                };
                if buf_rc.borrow().shared {
                    return Err(incompatible_receiver("ArrayBuffer.prototype.transfer"));
                }
                let new_len = match args.get(1) {
                    Some(v) if !v.is_undefined() => {
                        Some(crate::builtins::util::checked_f64_to_index(v.to_number()?)?)
                    }
                    _ => None,
                };
                let transferred = arraybuffer_transfer(&mut buf_rc.borrow_mut(), new_len, false)?;
                Ok(make_arraybuffer_instance(Rc::new(RefCell::new(
                    transferred,
                ))))
            }),
        );
        proto.insert(
            "transferToFixedLength".into(),
            builtin_fn("transferToFixedLength", 0, move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                let Some(buf_rc) = extract_arraybuffer(receiver) else {
                    return Err(incompatible_receiver(
                        "ArrayBuffer.prototype.transferToFixedLength",
                    ));
                };
                if buf_rc.borrow().shared {
                    return Err(incompatible_receiver(
                        "ArrayBuffer.prototype.transferToFixedLength",
                    ));
                }
                let new_len = match args.get(1) {
                    Some(v) if !v.is_undefined() => {
                        Some(crate::builtins::util::checked_f64_to_index(v.to_number()?)?)
                    }
                    _ => None,
                };
                let transferred = arraybuffer_transfer(&mut buf_rc.borrow_mut(), new_len, true)?;
                Ok(make_arraybuffer_instance(Rc::new(RefCell::new(
                    transferred,
                ))))
            }),
        );
    }
    proto.insert(
        "slice".into(),
        builtin_fn("slice", 2, move |args| {
            let receiver = args.first().unwrap_or(&JsValue::Undefined);
            let Some(buf_rc) = extract_arraybuffer(receiver) else {
                return Err(incompatible_receiver(&format!(
                    "{display_name}.prototype.slice"
                )));
            };
            if buf_rc.borrow().shared != shared {
                return Err(incompatible_receiver(&format!(
                    "{display_name}.prototype.slice"
                )));
            }
            let buffer = buf_rc.borrow();
            let len = buffer.data.len();
            let begin =
                clamp_relative_integer_index(len, to_integer_or_infinity_arg(args.get(1), 0.0)?)
                    as i64;
            let end = clamp_relative_integer_index(
                len,
                to_integer_or_infinity_arg(args.get(2), len as f64)?,
            ) as i64;
            let sliced = arraybuffer_slice(&buffer, begin, end);
            Ok(make_buffer_instance(Rc::new(RefCell::new(sliced))))
        }),
    );
    // §25.1.6.14 / §25.2.5.7 ArrayBuffer.prototype[@@toStringTag]
    proto.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String(display_name.into()),
        PropertyAttributes::CONFIGURABLE,
    );
    proto.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(proto)))
}

fn make_arraybuffer_prototype() -> JsValue {
    make_arraybuffer_prototype_impl(false)
}

fn make_shared_arraybuffer_prototype() -> JsValue {
    make_arraybuffer_prototype_impl(true)
}

/// Wrap a raw `JsArrayBuffer` in a `PlainObject` so that property access works
/// from JavaScript.
fn make_buffer_instance(buf_rc: Rc<RefCell<JsArrayBuffer>>) -> JsValue {
    let display_name = arraybuffer_display_name_for_rc(&buf_rc);
    let mut obj = PropertyMap::new();

    // __arraybuffer__: identity marker for extract_arraybuffer()
    obj.insert(
        "__arraybuffer__".into(),
        JsValue::ArrayBuffer(Rc::clone(&buf_rc)),
    );
    obj.insert(
        "__proto__".into(),
        constructor_prototype(display_name).unwrap_or(JsValue::Null),
    );
    obj.insert("@@toStringTag".into(), JsValue::String(display_name.into()));
    obj.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(obj)))
}

fn make_arraybuffer_instance(buf_rc: Rc<RefCell<JsArrayBuffer>>) -> JsValue {
    make_buffer_instance(buf_rc)
}

fn make_shared_arraybuffer_instance(buf_rc: Rc<RefCell<JsArrayBuffer>>) -> JsValue {
    make_buffer_instance(buf_rc)
}

fn make_dataview_instance(
    inner: Rc<RefCell<crate::builtins::typed_array::JsDataView>>,
    buffer_object: JsValue,
) -> JsValue {
    let mut obj = PropertyMap::new();
    obj.insert("__dataview__".into(), JsValue::DataView(Rc::clone(&inner)));
    obj.insert("__buffer_object__".into(), buffer_object);
    obj.insert(
        "__proto__".into(),
        constructor_prototype("DataView").unwrap_or(JsValue::Null),
    );
    obj.insert("@@toStringTag".into(), JsValue::String("DataView".into()));
    obj.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(obj)))
}

/// Implementation of `ArrayBuffer.isView(arg)` that checks for PlainObject
/// wrappers containing `__typed_array__` or `__dataview__` markers, as well
/// as raw `JsValue::TypedArray` / `JsValue::DataView` variants.
fn arraybuffer_is_view_rt(value: &JsValue) -> bool {
    match value {
        JsValue::TypedArray(_) | JsValue::DataView(_) => true,
        JsValue::PlainObject(map) => {
            let m = map.borrow();
            m.get("__typed_array__").is_some() || m.get("__dataview__").is_some()
        }
        _ => false,
    }
}

/// Build the `ArrayBuffer` constructor object.
#[inline(never)]
fn make_arraybuffer() -> JsValue {
    let mut props = PropertyMap::new();
    props.insert("prototype".into(), make_arraybuffer_prototype());

    // ArrayBuffer(byteLength)
    props.insert(
        "__call__".into(),
        native(|args| {
            let len = match args.first() {
                Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
                None => 0,
            };
            let max_byte_length = buffer_option_max_byte_length(args.get(1))?;
            let buf = match max_byte_length {
                Some(max_byte_length) => {
                    if max_byte_length < len {
                        return Err(StatorError::RangeError(
                            "maxByteLength must be at least byteLength".into(),
                        ));
                    }
                    arraybuffer_new_resizable(len, max_byte_length)
                }
                None => arraybuffer_new(len),
            };
            Ok(make_arraybuffer_instance(Rc::new(RefCell::new(buf))))
        }),
    );

    // ArrayBuffer.isView(arg)
    props.insert(
        "isView".into(),
        native(|args| {
            let arg = args.first().unwrap_or(&JsValue::Undefined);
            Ok(JsValue::Boolean(arraybuffer_is_view_rt(arg)))
        }),
    );

    // §25.1.4.3 get ArrayBuffer[@@species] — returns `this`.
    props.insert(
        "__get_@@species__".into(),
        native(|args| Ok(args.first().cloned().unwrap_or(JsValue::Undefined))),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Build the `DataView` constructor object.
#[inline(never)]
fn make_dataview() -> JsValue {
    let mut prototype = PropertyMap::new();
    prototype.insert(
        "__get_buffer__".into(),
        native(|args| {
            let receiver = args.first().unwrap_or(&JsValue::Undefined);
            let Some(inner) = extract_dataview(receiver) else {
                return Err(incompatible_receiver("DataView.prototype.buffer"));
            };
            if let JsValue::PlainObject(map) = receiver
                && let Some(buffer_object) = map.borrow().get("__buffer_object__").cloned()
            {
                return Ok(buffer_object);
            }
            Ok(make_arraybuffer_instance(Rc::clone(&inner.borrow().buffer)))
        }),
    );
    prototype.insert(
        "__get_byteLength__".into(),
        native(|args| {
            let receiver = args.first().unwrap_or(&JsValue::Undefined);
            let Some(inner) = extract_dataview(receiver) else {
                return Err(incompatible_receiver("DataView.prototype.byteLength"));
            };
            Ok(JsValue::Smi(dataview_byte_length(&inner.borrow())? as i32))
        }),
    );
    prototype.insert(
        "__get_byteOffset__".into(),
        native(|args| {
            let receiver = args.first().unwrap_or(&JsValue::Undefined);
            let Some(inner) = extract_dataview(receiver) else {
                return Err(incompatible_receiver("DataView.prototype.byteOffset"));
            };
            Ok(JsValue::Smi(dataview_byte_offset(&inner.borrow())? as i32))
        }),
    );

    macro_rules! dataview_proto_getter {
        ($name:expr, $length:expr, $fn_get:expr) => {
            prototype.insert(
                $name.into(),
                builtin_fn($name, $length, move |args| {
                    let receiver = args.first().unwrap_or(&JsValue::Undefined);
                    let Some(inner) = extract_dataview(receiver) else {
                        return Err(incompatible_receiver(concat!("DataView.prototype.", $name)));
                    };
                    let offset = match args.get(1) {
                        Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
                        None => 0,
                    };
                    let little_endian = args.get(2).is_some_and(JsValue::to_boolean);
                    let value = $fn_get(&inner.borrow(), offset, little_endian)?;
                    Ok(num_value(value))
                }),
            );
        };
    }

    macro_rules! dataview_proto_setter {
        ($name:expr, $length:expr, $fn_set:expr, $conv:expr) => {
            prototype.insert(
                $name.into(),
                builtin_fn($name, $length, move |args| {
                    let receiver = args.first().unwrap_or(&JsValue::Undefined);
                    let Some(inner) = extract_dataview(receiver) else {
                        return Err(incompatible_receiver(concat!("DataView.prototype.", $name)));
                    };
                    let offset = match args.get(1) {
                        Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
                        None => 0,
                    };
                    let value = $conv(args.get(2).unwrap_or(&JsValue::Undefined))?;
                    let little_endian = args.get(3).is_some_and(JsValue::to_boolean);
                    $fn_set(&inner.borrow(), offset, value, little_endian)?;
                    Ok(JsValue::Undefined)
                }),
            );
        };
    }

    dataview_proto_getter!("getInt8", 1, dataview_get_int8);
    dataview_proto_getter!("getUint8", 1, dataview_get_uint8);
    dataview_proto_getter!("getInt16", 1, dataview_get_int16);
    dataview_proto_getter!("getUint16", 1, dataview_get_uint16);
    dataview_proto_getter!("getInt32", 1, dataview_get_int32);
    dataview_proto_getter!("getUint32", 1, dataview_get_uint32);
    dataview_proto_getter!("getFloat32", 1, dataview_get_float32);
    dataview_proto_getter!("getFloat64", 1, dataview_get_float64);
    prototype.insert(
        "getBigInt64".into(),
        builtin_fn("getBigInt64", 1, |args| {
            let receiver = args.first().unwrap_or(&JsValue::Undefined);
            let Some(inner) = extract_dataview(receiver) else {
                return Err(incompatible_receiver("DataView.prototype.getBigInt64"));
            };
            let offset = match args.get(1) {
                Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
                None => 0,
            };
            let little_endian = args.get(2).is_some_and(JsValue::to_boolean);
            let value = dataview_get_bigint64(&inner.borrow(), offset, little_endian)?;
            Ok(JsValue::BigInt(Box::new(i128::from(value))))
        }),
    );
    prototype.insert(
        "getBigUint64".into(),
        builtin_fn("getBigUint64", 1, |args| {
            let receiver = args.first().unwrap_or(&JsValue::Undefined);
            let Some(inner) = extract_dataview(receiver) else {
                return Err(incompatible_receiver("DataView.prototype.getBigUint64"));
            };
            let offset = match args.get(1) {
                Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
                None => 0,
            };
            let little_endian = args.get(2).is_some_and(JsValue::to_boolean);
            let value = dataview_get_biguint64(&inner.borrow(), offset, little_endian)?;
            Ok(JsValue::BigInt(Box::new(i128::from(value))))
        }),
    );
    dataview_proto_setter!("setInt8", 2, dataview_set_int8, |v: &JsValue| Ok::<
        i8,
        StatorError,
    >(
        v.to_int32()? as i8
    ));
    dataview_proto_setter!("setUint8", 2, dataview_set_uint8, |v: &JsValue| Ok::<
        u8,
        StatorError,
    >(
        v.to_int32()? as u8
    ));
    dataview_proto_setter!("setInt16", 2, dataview_set_int16, |v: &JsValue| Ok::<
        i16,
        StatorError,
    >(
        v.to_int32()? as i16
    ));
    dataview_proto_setter!("setUint16", 2, dataview_set_uint16, |v: &JsValue| Ok::<
        u16,
        StatorError,
    >(
        v.to_int32()? as u16
    ));
    dataview_proto_setter!("setInt32", 2, dataview_set_int32, |v: &JsValue| v
        .to_int32());
    dataview_proto_setter!("setUint32", 2, dataview_set_uint32, |v: &JsValue| v
        .to_uint32());
    dataview_proto_setter!("setFloat32", 2, dataview_set_float32, |v: &JsValue| {
        Ok::<f32, StatorError>(v.to_number()? as f32)
    });
    dataview_proto_setter!("setFloat64", 2, dataview_set_float64, |v: &JsValue| {
        v.to_number()
    });
    dataview_proto_setter!("setBigInt64", 2, dataview_set_bigint64, |v: &JsValue| {
        Ok::<i64, StatorError>(dataview_bigint_argument(v)? as i64)
    });
    dataview_proto_setter!("setBigUint64", 2, dataview_set_biguint64, |v: &JsValue| {
        Ok::<u64, StatorError>(dataview_bigint_argument(v)? as u64)
    });
    // §25.3.4.4 DataView.prototype[@@toStringTag] = "DataView"
    prototype.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String("DataView".into()),
        PropertyAttributes::CONFIGURABLE,
    );
    prototype.make_all_non_enumerable();

    let mut props = PropertyMap::new();
    props.insert(
        "prototype".into(),
        JsValue::PlainObject(Rc::new(RefCell::new(prototype))),
    );

    props.insert(
        "__call__".into(),
        native(|args| {
            let buffer_arg = args.first().unwrap_or(&JsValue::Undefined);
            let buf_rc = match extract_arraybuffer(buffer_arg) {
                Some(b) => b,
                None => {
                    return Err(StatorError::TypeError(
                        "First argument must be an ArrayBuffer or SharedArrayBuffer".into(),
                    ));
                }
            };
            let offset = match args.get(1) {
                Some(v) if !v.is_undefined() => {
                    crate::builtins::util::checked_f64_to_index(v.to_number()?)?
                }
                _ => 0,
            };
            let length = match args.get(2) {
                Some(v) if !v.is_undefined() => {
                    Some(crate::builtins::util::checked_f64_to_index(v.to_number()?)?)
                }
                _ => None,
            };
            let dv = dataview_new(buf_rc, offset, length)?;
            let inner = Rc::new(RefCell::new(dv));
            let buffer_object = match buffer_arg {
                JsValue::PlainObject(map) if map.borrow().get("__arraybuffer__").is_some() => {
                    buffer_arg.clone()
                }
                _ => make_arraybuffer_instance(Rc::clone(&inner.borrow().buffer)),
            };
            Ok(make_dataview_instance(inner, buffer_object))
        }),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Helper to convert a numeric value to `JsValue`.
fn num_value<T: Into<f64>>(v: T) -> JsValue {
    let f: f64 = v.into();
    if f.fract() == 0.0 && f >= f64::from(i32::MIN) && f <= f64::from(i32::MAX) {
        JsValue::Smi(f as i32)
    } else {
        JsValue::HeapNumber(f)
    }
}

/// Build a typed-array constructor for the given `TypedArrayKind`.
#[inline(never)]
fn make_typed_array_constructor(kind: TypedArrayKind) -> JsValue {
    let mut props = PropertyMap::new();

    // BYTES_PER_ELEMENT
    props.insert(
        "BYTES_PER_ELEMENT".into(),
        JsValue::Smi(kind.bytes_per_element() as i32),
    );

    let mut prototype = PropertyMap::new();
    // §23.2.3.32 %TypedArray%.prototype[@@toStringTag]
    prototype.insert_with_attrs(
        "@@toStringTag".into(),
        JsValue::String(kind.name().into()),
        PropertyAttributes::CONFIGURABLE,
    );
    prototype.make_all_non_enumerable();
    props.insert(
        "prototype".into(),
        JsValue::PlainObject(Rc::new(RefCell::new(prototype))),
    );

    // Constructor: TypedArray(length) | TypedArray(array) | TypedArray(buffer, offset?, length?)
    props.insert(
        "__call__".into(),
        native(move |args| {
            let mut buffer_object = None;
            let ta = match args.first() {
                // From ArrayBuffer (raw or wrapped PlainObject)
                Some(v) if extract_arraybuffer(v).is_some() => {
                    let buf = extract_arraybuffer(v).expect("checked above");
                    buffer_object = Some(match v {
                        JsValue::PlainObject(map)
                            if map.borrow().get("__arraybuffer__").is_some() =>
                        {
                            v.clone()
                        }
                        _ => make_buffer_instance(Rc::clone(&buf)),
                    });
                    let offset = match args.get(1) {
                        Some(v) if !v.is_undefined() => {
                            crate::builtins::util::checked_f64_to_index(v.to_number()?)?
                        }
                        _ => 0,
                    };
                    let length = match args.get(2) {
                        Some(v) if !v.is_undefined() => {
                            Some(crate::builtins::util::checked_f64_to_index(v.to_number()?)?)
                        }
                        _ => None,
                    };
                    typed_array_new_from_buffer(kind, buf, offset, length)?
                }
                // From another TypedArray / Array / iterable / array-like
                Some(
                    source @ (JsValue::TypedArray(_)
                    | JsValue::Array(_)
                    | JsValue::Iterator(_)
                    | JsValue::Generator(_)
                    | JsValue::String(_)
                    | JsValue::PlainObject(_)
                    | JsValue::Proxy(_)),
                ) => {
                    let values = collect_typed_array_source_values(source)?;
                    typed_array_from_values(kind, &values)?
                }
                // From length (number)
                Some(v) => {
                    let len = crate::builtins::util::checked_f64_to_index(v.to_number()?)?;
                    typed_array_new_from_length(kind, len)
                }
                None => typed_array_new_from_length(kind, 0),
            };
            let inner = Rc::new(RefCell::new(ta));
            Ok(make_typed_array_instance(kind, inner, buffer_object))
        }),
    );

    // TypedArray.from(source)
    props.insert(
        "from".into(),
        native(move |args| {
            let source = args.first().ok_or_else(|| {
                StatorError::TypeError("TypedArray.from requires a source value".into())
            })?;
            let source = collect_typed_array_source_values(source)?;
            let ta = typed_array_from_values(kind, &source)?;
            let inner = Rc::new(RefCell::new(ta));
            Ok(make_typed_array_instance(kind, inner, None))
        }),
    );

    // TypedArray.of(...items)
    props.insert(
        "of".into(),
        native(move |args| {
            let ta = typed_array_from_values(kind, &args)?;
            let inner = Rc::new(RefCell::new(ta));
            Ok(make_typed_array_instance(kind, inner, None))
        }),
    );

    // §23.2.2.2 get %TypedArray%[@@species] — returns `this`.
    props.insert(
        "__get_@@species__".into(),
        native(|args| Ok(args.first().cloned().unwrap_or(JsValue::Undefined))),
    );

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Build the prototype methods for a `JsValue::TypedArray` instance.
#[inline(never)]
fn typed_array_buffer_object(receiver: &JsValue) -> Option<JsValue> {
    let JsValue::PlainObject(map) = receiver else {
        return None;
    };
    map.borrow().get("__buffer_object__").cloned()
}

/// Build the prototype methods for a `JsValue::TypedArray` instance.
#[inline(never)]
fn make_typed_array_instance(
    kind: TypedArrayKind,
    inner: Rc<RefCell<crate::builtins::typed_array::JsTypedArray>>,
    buffer_object: Option<JsValue>,
) -> JsValue {
    let _ = kind;
    let typed_array_val = JsValue::TypedArray(Rc::clone(&inner));
    let obj = Rc::new(RefCell::new(PropertyMap::new()));
    let instance_value = JsValue::PlainObject(Rc::clone(&obj));

    {
        let mut obj = obj.borrow_mut();
        obj.insert(
            "__proto__".into(),
            constructor_prototype(inner.borrow().kind.name()).unwrap_or(JsValue::Null),
        );
        obj.insert(
            "BYTES_PER_ELEMENT".into(),
            JsValue::Smi(inner.borrow().kind.bytes_per_element() as i32),
        );
        let buffer_object = buffer_object
            .unwrap_or_else(|| make_buffer_instance(Rc::clone(&inner.borrow().buffer)));
        obj.insert("__buffer_object__".into(), buffer_object.clone());
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__get_length__".into(),
                native(move |_| Ok(JsValue::Smi(inner.borrow().effective_length() as i32))),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__get_byteLength__".into(),
                native(move |_| Ok(JsValue::Smi(typed_array_byte_length(&inner.borrow()) as i32))),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "__get_byteOffset__".into(),
                native(move |_| Ok(JsValue::Smi(inner.borrow().byte_offset as i32))),
            );
        }
        obj.insert(
            "__get_buffer__".into(),
            native(move |args| {
                let receiver = args.first().unwrap_or(&JsValue::Undefined);
                Ok(typed_array_buffer_object(receiver).unwrap_or(JsValue::Undefined))
            }),
        );
        obj.insert(
            "@@toStringTag".into(),
            JsValue::String(inner.borrow().kind.name().into()),
        );
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "at".into(),
                native(move |a| {
                    let ta = inner.borrow();
                    match normalize_at_index(ta.effective_length(), a.first())? {
                        Some(idx) => Ok(typed_array_get(&ta, idx)),
                        None => Ok(JsValue::Undefined),
                    }
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "copyWithin".into(),
                native(move |a| {
                    let len = inner.borrow().effective_length();
                    let target = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.first(), 0.0)?,
                    ) as i64;
                    let start = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.get(1), 0.0)?,
                    ) as i64;
                    let end = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.get(2), len as f64)?,
                    ) as i64;
                    typed_array_copy_within(&inner.borrow(), target, start, end);
                    Ok(instance.clone())
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "entries".into(),
                native(move |_| {
                    let items = typed_array_entries(&inner.borrow());
                    Ok(JsValue::Iterator(NativeIterator::from_items(items)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "every".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.every callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    for i in 0..ta.effective_length() {
                        let result = call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![
                                typed_array_get(&ta, i),
                                JsValue::Smi(i as i32),
                                instance.clone(),
                            ],
                        )?;
                        if !result.to_boolean() {
                            return Ok(JsValue::Boolean(false));
                        }
                    }
                    Ok(JsValue::Boolean(true))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "fill".into(),
                native(move |a| {
                    let val = a.first().unwrap_or(&JsValue::Undefined).clone();
                    let ta = inner.borrow();
                    let len = ta.effective_length();
                    let start = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.get(1), 0.0)?,
                    ) as i64;
                    let end = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.get(2), len as f64)?,
                    ) as i64;
                    typed_array_fill(&ta, &val, start, end)?;
                    Ok(instance.clone())
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "filter".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.filter callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    let mut kept = Vec::new();
                    for i in 0..ta.effective_length() {
                        let value = typed_array_get(&ta, i);
                        let result = call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![value.clone(), JsValue::Smi(i as i32), instance.clone()],
                        )?;
                        if result.to_boolean() {
                            kept.push(value);
                        }
                    }
                    let result = typed_array_from_values(ta.kind, &kept)?;
                    let inner = Rc::new(RefCell::new(result));
                    Ok(make_typed_array_instance(ta.kind, inner, None))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "find".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.find callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    for i in 0..ta.effective_length() {
                        let value = typed_array_get(&ta, i);
                        let result = call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![value.clone(), JsValue::Smi(i as i32), instance.clone()],
                        )?;
                        if result.to_boolean() {
                            return Ok(value);
                        }
                    }
                    Ok(JsValue::Undefined)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "findIndex".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.findIndex callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    for i in 0..ta.effective_length() {
                        let result = call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![
                                typed_array_get(&ta, i),
                                JsValue::Smi(i as i32),
                                instance.clone(),
                            ],
                        )?;
                        if result.to_boolean() {
                            return Ok(JsValue::Smi(i as i32));
                        }
                    }
                    Ok(JsValue::Smi(-1))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "findLast".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.findLast callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    for i in (0..ta.effective_length()).rev() {
                        let value = typed_array_get(&ta, i);
                        let result = call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![value.clone(), JsValue::Smi(i as i32), instance.clone()],
                        )?;
                        if result.to_boolean() {
                            return Ok(value);
                        }
                    }
                    Ok(JsValue::Undefined)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "findLastIndex".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.findLastIndex callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    for i in (0..ta.effective_length()).rev() {
                        let result = call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![
                                typed_array_get(&ta, i),
                                JsValue::Smi(i as i32),
                                instance.clone(),
                            ],
                        )?;
                        if result.to_boolean() {
                            return Ok(JsValue::Smi(i as i32));
                        }
                    }
                    Ok(JsValue::Smi(-1))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "forEach".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.forEach callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    for i in 0..ta.effective_length() {
                        call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![
                                typed_array_get(&ta, i),
                                JsValue::Smi(i as i32),
                                instance.clone(),
                            ],
                        )?;
                    }
                    Ok(JsValue::Undefined)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "includes".into(),
                native(move |a| {
                    let search = a.first().unwrap_or(&JsValue::Undefined);
                    let from =
                        normalize_from_index(inner.borrow().effective_length(), a.get(1))? as i64;
                    Ok(JsValue::Boolean(typed_array_includes(
                        &inner.borrow(),
                        search,
                        from,
                    )))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "indexOf".into(),
                native(move |a| {
                    let search = a.first().unwrap_or(&JsValue::Undefined);
                    let from =
                        normalize_from_index(inner.borrow().effective_length(), a.get(1))? as i64;
                    Ok(JsValue::Smi(
                        typed_array_index_of(&inner.borrow(), search, from) as i32,
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "join".into(),
                native(move |a| {
                    let sep = match a.first() {
                        Some(v) if !v.is_undefined() => v.to_js_string()?,
                        _ => ",".to_string(),
                    };
                    Ok(JsValue::String(
                        typed_array_join(&inner.borrow(), &sep)?.into(),
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "keys".into(),
                native(move |_| {
                    let items = typed_array_keys(&inner.borrow());
                    Ok(JsValue::Iterator(NativeIterator::from_items(items)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "lastIndexOf".into(),
                native(move |a| {
                    let search = a.first().unwrap_or(&JsValue::Undefined);
                    let ta = inner.borrow();
                    let Some(from) = normalize_last_from_index(ta.effective_length(), a.get(1))?
                    else {
                        return Ok(JsValue::Smi(-1));
                    };
                    Ok(JsValue::Smi(
                        typed_array_last_index_of(&ta, search, from as i64) as i32,
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "map".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.map callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    let mut mapped = Vec::with_capacity(ta.effective_length());
                    for i in 0..ta.effective_length() {
                        let mapped_value = call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![
                                typed_array_get(&ta, i),
                                JsValue::Smi(i as i32),
                                instance.clone(),
                            ],
                        )?;
                        mapped.push(mapped_value);
                    }
                    let result = typed_array_from_values(ta.kind, &mapped)?;
                    let inner = Rc::new(RefCell::new(result));
                    Ok(make_typed_array_instance(ta.kind, inner, None))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "reduce".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.reduce callback must be callable".into(),
                        ));
                    }
                    let ta = inner.borrow();
                    let mut start = 0;
                    let mut acc = if a.len() > 1 {
                        a[1].clone()
                    } else {
                        if ta.effective_length() == 0 {
                            return Err(StatorError::TypeError(
                                "Reduce of empty array with no initial value".into(),
                            ));
                        }
                        start = 1;
                        typed_array_get(&ta, 0)
                    };
                    for i in start..ta.effective_length() {
                        acc = call_callback(
                            &cb,
                            vec![
                                acc,
                                typed_array_get(&ta, i),
                                JsValue::Smi(i as i32),
                                instance.clone(),
                            ],
                        )?;
                    }
                    Ok(acc)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "reduceRight".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.reduceRight callback must be callable".into(),
                        ));
                    }
                    let ta = inner.borrow();
                    let len = ta.effective_length();
                    let mut acc = if a.len() > 1 {
                        a[1].clone()
                    } else {
                        if len == 0 {
                            return Err(StatorError::TypeError(
                                "Reduce of empty array with no initial value".into(),
                            ));
                        }
                        typed_array_get(&ta, len - 1)
                    };
                    let end = if a.len() <= 1 && len > 0 {
                        len - 1
                    } else {
                        len
                    };
                    for i in (0..end).rev() {
                        acc = call_callback(
                            &cb,
                            vec![
                                acc,
                                typed_array_get(&ta, i),
                                JsValue::Smi(i as i32),
                                instance.clone(),
                            ],
                        )?;
                    }
                    Ok(acc)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "reverse".into(),
                native(move |_| {
                    typed_array_reverse(&inner.borrow());
                    Ok(instance.clone())
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "set".into(),
                native(move |a| {
                    let source = match a.first() {
                        Some(source) => collect_typed_array_source_values(source)?,
                        None => Vec::new(),
                    };
                    let offset = a
                        .get(1)
                        .map(|v| {
                            crate::builtins::util::clamped_f64_to_usize(
                                v.to_number().unwrap_or(0.0),
                            )
                        })
                        .unwrap_or(0);
                    typed_array_set_from(&inner.borrow(), &source, offset)?;
                    Ok(JsValue::Undefined)
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "slice".into(),
                native(move |a| {
                    let ta = inner.borrow();
                    let len = ta.effective_length();
                    let start = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.first(), 0.0)?,
                    ) as i64;
                    let end = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.get(1), len as f64)?,
                    ) as i64;
                    let result = typed_array_slice(&ta, start, end)?;
                    let inner = Rc::new(RefCell::new(result));
                    Ok(make_typed_array_instance(ta.kind, inner, None))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "some".into(),
                native(move |a| {
                    let cb = a.first().cloned().unwrap_or(JsValue::Undefined);
                    if !is_callable(&cb) {
                        return Err(StatorError::TypeError(
                            "TypedArray.prototype.some callback must be callable".into(),
                        ));
                    }
                    let this_arg = a.get(1).cloned().unwrap_or(JsValue::Undefined);
                    let ta = inner.borrow();
                    for i in 0..ta.effective_length() {
                        let result = call_callback_with_this(
                            &cb,
                            this_arg.clone(),
                            vec![
                                typed_array_get(&ta, i),
                                JsValue::Smi(i as i32),
                                instance.clone(),
                            ],
                        )?;
                        if result.to_boolean() {
                            return Ok(JsValue::Boolean(true));
                        }
                    }
                    Ok(JsValue::Boolean(false))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "sort".into(),
                native(move |_| {
                    typed_array_sort(&inner.borrow(), None)?;
                    Ok(instance.clone())
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            let instance = instance_value.clone();
            obj.insert(
                "subarray".into(),
                native(move |a| {
                    let ta = inner.borrow();
                    let len = ta.effective_length();
                    let begin = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.first(), 0.0)?,
                    ) as i64;
                    let end = clamp_relative_integer_index(
                        len,
                        to_integer_or_infinity_arg(a.get(1), len as f64)?,
                    ) as i64;
                    let sub = typed_array_subarray(&ta, begin, end);
                    let sub_inner = Rc::new(RefCell::new(sub));
                    Ok(make_typed_array_instance(
                        ta.kind,
                        sub_inner,
                        typed_array_buffer_object(&instance),
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "toLocaleString".into(),
                native(move |_| {
                    Ok(JsValue::String(
                        typed_array_join(&inner.borrow(), ",")?.into(),
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "toString".into(),
                native(move |_| {
                    Ok(JsValue::String(
                        typed_array_join(&inner.borrow(), ",")?.into(),
                    ))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "values".into(),
                native(move |_| {
                    let items = typed_array_values(&inner.borrow());
                    Ok(JsValue::Iterator(NativeIterator::from_items(items)))
                }),
            );
        }
        {
            let inner = Rc::clone(&inner);
            obj.insert(
                "@@iterator".into(),
                native(move |_| {
                    let items = typed_array_values(&inner.borrow());
                    Ok(JsValue::Iterator(NativeIterator::from_items(items)))
                }),
            );
        }
        obj.insert("__typed_array__".into(), typed_array_val);
        obj.make_all_non_enumerable();
    }

    instance_value
}

// ── install_globals ──────────────────────────────────────────────────────────

/// Build the `ShadowRealm` constructor.
///
/// Each `new ShadowRealm()` creates an isolated evaluation environment with
/// its own set of global builtins.  `evaluate(code)` parses and runs code
/// inside the realm.
#[inline(never)]
fn make_shadow_realm() -> JsValue {
    use crate::bytecode::bytecode_generator::BytecodeGenerator;
    use crate::interpreter::{GlobalEnv, Interpreter, InterpreterFrame};
    native(|_args| {
        // Create a fresh set of globals for this realm.
        let mut realm_globals = GlobalEnv::new();
        install_globals(&mut realm_globals.vars);
        realm_globals.rebuild_slots();
        let realm_globals = Rc::new(RefCell::new(realm_globals));

        let mut props = PropertyMap::new();

        // evaluate(sourceText)
        {
            let globals = Rc::clone(&realm_globals);
            props.insert(
                "evaluate".into(),
                native(move |args| {
                    let source = args
                        .first()
                        .map(|v| v.to_js_string())
                        .transpose()?
                        .unwrap_or_default();
                    let program = crate::parser::recursive_descent::parse(&source)?;
                    let bc = BytecodeGenerator::compile_program(&program)?;
                    let mut frame = InterpreterFrame::new_with_globals(
                        Rc::new(bc),
                        vec![],
                        Rc::clone(&globals),
                    );
                    let result = Interpreter::run(&mut frame)?;
                    // ShadowRealm boundary: only primitives pass through.
                    match &result {
                        JsValue::Smi(_)
                        | JsValue::HeapNumber(_)
                        | JsValue::String(_)
                        | JsValue::Boolean(_)
                        | JsValue::Null
                        | JsValue::Undefined
                        | JsValue::BigInt(_)
                        | JsValue::Symbol(_) => Ok(result),
                        _ => Err(StatorError::TypeError(
                            "ShadowRealm evaluate: cannot pass non-primitive across realm boundary"
                                .into(),
                        )),
                    }
                }),
            );
        }

        // importValue(specifier, exportName) — stub returning undefined
        props.insert("importValue".into(), native(|_args| Ok(JsValue::Undefined)));

        props.make_all_non_enumerable();
        Ok(JsValue::PlainObject(Rc::new(RefCell::new(props))))
    })
}

/// Build the `SharedArrayBuffer` constructor.
#[inline(never)]
fn make_shared_arraybuffer() -> JsValue {
    let mut props = PropertyMap::new();
    props.insert("prototype".into(), make_shared_arraybuffer_prototype());
    props.insert(
        "__call__".into(),
        native(|args| {
            let len = match args.first() {
                Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
                None => 0,
            };
            let max_byte_length = buffer_option_max_byte_length(args.get(1))?;
            let buf = match max_byte_length {
                Some(max_byte_length) => {
                    if max_byte_length < len {
                        return Err(StatorError::RangeError(
                            "maxByteLength must be at least byteLength".into(),
                        ));
                    }
                    shared_arraybuffer_new_growable(len, max_byte_length)
                }
                None => shared_arraybuffer_new(len),
            };
            Ok(make_shared_arraybuffer_instance(Rc::new(RefCell::new(buf))))
        }),
    );
    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Helper: read an integer value from a buffer at a given byte offset.
fn atomics_kind_is_integer(kind: TypedArrayKind) -> bool {
    matches!(
        kind,
        TypedArrayKind::Int8
            | TypedArrayKind::Uint8
            | TypedArrayKind::Int16
            | TypedArrayKind::Uint16
            | TypedArrayKind::Int32
            | TypedArrayKind::Uint32
            | TypedArrayKind::BigInt64
            | TypedArrayKind::BigUint64
    )
}

fn atomics_kind_is_bigint(kind: TypedArrayKind) -> bool {
    matches!(kind, TypedArrayKind::BigInt64 | TypedArrayKind::BigUint64)
}

fn atomics_extract_bigint(value: &JsValue) -> StatorResult<i128> {
    match value {
        JsValue::BigInt(n) => Ok(**n),
        _ => Err(StatorError::TypeError(
            "Atomics operation requires a BigInt value".into(),
        )),
    }
}

fn atomics_coerce_value(kind: TypedArrayKind, value: &JsValue) -> StatorResult<JsValue> {
    if atomics_kind_is_bigint(kind) {
        let numeric = value.to_numeric()?;
        let bigint = atomics_extract_bigint(&numeric)?;
        return Ok(JsValue::BigInt(Box::new(match kind {
            TypedArrayKind::BigInt64 => (bigint as i64) as i128,
            TypedArrayKind::BigUint64 => (bigint as u64) as i128,
            _ => bigint,
        })));
    }

    match value.to_numeric()? {
        JsValue::BigInt(_) => Err(StatorError::TypeError(
            "Atomics operation requires a Number value".into(),
        )),
        other => match kind {
            TypedArrayKind::Int8
            | TypedArrayKind::Uint8
            | TypedArrayKind::Int16
            | TypedArrayKind::Uint16
            | TypedArrayKind::Int32 => Ok(JsValue::Smi(other.to_int32()?)),
            TypedArrayKind::Uint32 => Ok(JsValue::HeapNumber(f64::from(other.to_uint32()?))),
            _ => Err(StatorError::TypeError(
                "Atomics operation requires an integer TypedArray".into(),
            )),
        },
    }
}

/// Extract the buffer, kind, and element index from the first two Atomics args.
fn atomics_extract_ta(
    args: &[JsValue],
) -> StatorResult<(
    Rc<RefCell<crate::builtins::typed_array::JsTypedArray>>,
    usize,
)> {
    let ta = args.first().ok_or_else(|| {
        StatorError::TypeError("Atomics: first argument must be a TypedArray".into())
    })?;
    let Some(inner) = extract_typed_array(ta) else {
        return Err(StatorError::TypeError(
            "Atomics: first argument must be a TypedArray".into(),
        ));
    };

    {
        let inner_ref = inner.borrow();
        if !atomics_kind_is_integer(inner_ref.kind) {
            return Err(StatorError::TypeError(
                "Atomics: TypedArray argument must be an integer TypedArray".into(),
            ));
        }
        if !inner_ref.buffer.borrow().shared {
            return Err(StatorError::TypeError(
                "Atomics: TypedArray argument must be backed by SharedArrayBuffer".into(),
            ));
        }
    }

    let index = match args.get(1) {
        Some(v) => crate::builtins::util::checked_f64_to_index(v.to_number()?)?,
        None => 0,
    };
    if index >= inner.borrow().effective_length() {
        return Err(StatorError::RangeError(
            "Atomics: index out of range".into(),
        ));
    }
    Ok((inner, index))
}

fn atomics_read(ta: &crate::builtins::typed_array::JsTypedArray, index: usize) -> JsValue {
    typed_array_get(ta, index)
}

fn atomics_write(
    ta: &crate::builtins::typed_array::JsTypedArray,
    index: usize,
    value: &JsValue,
) -> StatorResult<JsValue> {
    typed_array_set(ta, index, value)?;
    Ok(typed_array_get(ta, index))
}

fn atomics_apply_binary_number(
    kind: TypedArrayKind,
    old: &JsValue,
    operand: &JsValue,
    op: impl FnOnce(i128, i128) -> i128,
) -> StatorResult<JsValue> {
    if atomics_kind_is_bigint(kind) {
        return Ok(JsValue::BigInt(Box::new(op(
            atomics_extract_bigint(old)?,
            atomics_extract_bigint(operand)?,
        ))));
    }

    let lhs = match kind {
        TypedArrayKind::Uint32 => i128::from(old.to_uint32()?),
        _ => i128::from(old.to_int32()?),
    };
    let rhs = match kind {
        TypedArrayKind::Uint32 => i128::from(operand.to_uint32()?),
        _ => i128::from(operand.to_int32()?),
    };
    let result = op(lhs, rhs);
    Ok(match kind {
        TypedArrayKind::Uint32 => JsValue::HeapNumber(result as f64),
        _ => JsValue::Smi(result as i32),
    })
}

fn atomics_value_equals(a: &JsValue, b: &JsValue) -> bool {
    match (a, b) {
        (JsValue::Smi(lhs), JsValue::Smi(rhs)) => lhs == rhs,
        (JsValue::HeapNumber(lhs), JsValue::HeapNumber(rhs)) => lhs == rhs,
        (JsValue::Smi(lhs), JsValue::HeapNumber(rhs))
        | (JsValue::HeapNumber(rhs), JsValue::Smi(lhs)) => f64::from(*lhs) == *rhs,
        (JsValue::BigInt(lhs), JsValue::BigInt(rhs)) => lhs == rhs,
        _ => false,
    }
}

/// Build the `Atomics` namespace object.
///
/// Since stator is single-threaded, all atomic operations are plain
/// reads/writes — sequentially consistent by default.
#[inline(never)]
fn make_atomics() -> JsValue {
    let mut props = PropertyMap::new();

    // Atomics.load(typedArray, index)
    props.insert(
        "load".into(),
        builtin_fn("load", 2, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            Ok(atomics_read(&ta.borrow(), index))
        }),
    );

    // Atomics.store(typedArray, index, value)
    props.insert(
        "store".into(),
        builtin_fn("store", 3, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let value = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            atomics_write(&ta.borrow(), index, &value)
        }),
    );

    // Atomics.add(typedArray, index, value)
    props.insert(
        "add".into(),
        builtin_fn("add", 3, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let old = atomics_read(&ta.borrow(), index);
            let operand = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            let next = if atomics_kind_is_bigint(kind) {
                JsValue::BigInt(Box::new(
                    atomics_extract_bigint(&old)? + atomics_extract_bigint(&operand)?,
                ))
            } else {
                JsValue::HeapNumber(old.to_number()? + operand.to_number()?)
            };
            atomics_write(&ta.borrow(), index, &next)?;
            Ok(old)
        }),
    );

    // Atomics.sub(typedArray, index, value)
    props.insert(
        "sub".into(),
        builtin_fn("sub", 3, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let old = atomics_read(&ta.borrow(), index);
            let operand = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            let next = if atomics_kind_is_bigint(kind) {
                JsValue::BigInt(Box::new(
                    atomics_extract_bigint(&old)? - atomics_extract_bigint(&operand)?,
                ))
            } else {
                JsValue::HeapNumber(old.to_number()? - operand.to_number()?)
            };
            atomics_write(&ta.borrow(), index, &next)?;
            Ok(old)
        }),
    );

    // Atomics.and(typedArray, index, value)
    props.insert(
        "and".into(),
        builtin_fn("and", 3, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let old = atomics_read(&ta.borrow(), index);
            let operand = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            let next = atomics_apply_binary_number(kind, &old, &operand, |lhs, rhs| lhs & rhs)?;
            atomics_write(&ta.borrow(), index, &next)?;
            Ok(old)
        }),
    );

    // Atomics.or(typedArray, index, value)
    props.insert(
        "or".into(),
        builtin_fn("or", 3, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let old = atomics_read(&ta.borrow(), index);
            let operand = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            let next = atomics_apply_binary_number(kind, &old, &operand, |lhs, rhs| lhs | rhs)?;
            atomics_write(&ta.borrow(), index, &next)?;
            Ok(old)
        }),
    );

    // Atomics.xor(typedArray, index, value)
    props.insert(
        "xor".into(),
        builtin_fn("xor", 3, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let old = atomics_read(&ta.borrow(), index);
            let operand = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            let next = atomics_apply_binary_number(kind, &old, &operand, |lhs, rhs| lhs ^ rhs)?;
            atomics_write(&ta.borrow(), index, &next)?;
            Ok(old)
        }),
    );

    // Atomics.exchange(typedArray, index, value)
    props.insert(
        "exchange".into(),
        builtin_fn("exchange", 3, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let old = atomics_read(&ta.borrow(), index);
            let value = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            atomics_write(&ta.borrow(), index, &value)?;
            Ok(old)
        }),
    );

    // Atomics.compareExchange(typedArray, index, expected, replacement)
    props.insert(
        "compareExchange".into(),
        builtin_fn("compareExchange", 4, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let old = atomics_read(&ta.borrow(), index);
            let expected = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            if atomics_value_equals(&old, &expected) {
                let replacement =
                    atomics_coerce_value(kind, args.get(3).unwrap_or(&JsValue::Undefined))?;
                atomics_write(&ta.borrow(), index, &replacement)?;
            }
            Ok(old)
        }),
    );

    // Atomics.isLockFree(size)
    props.insert(
        "isLockFree".into(),
        builtin_fn("isLockFree", 1, |args| {
            let size = args
                .first()
                .map(|v| crate::builtins::util::clamped_f64_to_usize(v.to_number().unwrap_or(0.0)))
                .unwrap_or(0);
            Ok(JsValue::Boolean(matches!(size, 1 | 2 | 4 | 8)))
        }),
    );

    // Atomics.wait — single-threaded, always returns "not-equal" or "timed-out"
    props.insert(
        "wait".into(),
        builtin_fn("wait", 4, |args| {
            let (ta, index) = atomics_extract_ta(&args)?;
            let kind = ta.borrow().kind;
            let current = atomics_read(&ta.borrow(), index);
            let expected = atomics_coerce_value(kind, args.get(2).unwrap_or(&JsValue::Undefined))?;
            if !atomics_value_equals(&current, &expected) {
                Ok(JsValue::String("not-equal".into()))
            } else {
                Ok(JsValue::String("timed-out".into()))
            }
        }),
    );

    // Atomics.notify — single-threaded no-op, returns 0
    props.insert(
        "notify".into(),
        builtin_fn("notify", 3, |args| {
            let _ = atomics_extract_ta(&args)?;
            Ok(JsValue::Smi(0))
        }),
    );

    // Atomics.waitAsync — returns { async: false, value: "timed-out" }
    props.insert(
        "waitAsync".into(),
        builtin_fn("waitAsync", 4, |args| {
            let _ = atomics_extract_ta(&args)?;
            let mut props = PropertyMap::new();
            props.insert("async".into(), JsValue::Boolean(false));
            props.insert("value".into(), JsValue::String("timed-out".into()));
            Ok(JsValue::PlainObject(Rc::new(RefCell::new(props))))
        }),
    );

    // §25.4.12 Atomics.pause([iterationNumber])  — ES2025
    // Performance hint for spin-wait loops; no-op in single-threaded engines.
    props.insert(
        "pause".into(),
        builtin_fn("pause", 0, |_args| Ok(JsValue::Undefined)),
    );

    // @@toStringTag
    props.insert("@@toStringTag".into(), JsValue::String("Atomics".into()));

    props.make_all_non_enumerable();
    JsValue::PlainObject(Rc::new(RefCell::new(props)))
}

/// Build the `DisposableStack` constructor.
///
/// `DisposableStack` manages a stack of disposable resources and calls their
/// `[Symbol.dispose]()` methods in reverse order when `.dispose()` is called.
#[inline(never)]
fn make_disposable_stack() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        native(|_args| {
            let resources: Rc<RefCell<Vec<JsValue>>> = Rc::new(RefCell::new(Vec::new()));
            let disposed: Rc<RefCell<bool>> = Rc::new(RefCell::new(false));
            let mut props = PropertyMap::new();

            // use(value) — add a disposable resource.
            {
                let res = Rc::clone(&resources);
                props.insert(
                    "use".into(),
                    native(move |args| {
                        let val = args.first().cloned().unwrap_or(JsValue::Undefined);
                        res.borrow_mut().push(val.clone());
                        Ok(val)
                    }),
                );
            }

            // disposed — whether the stack has been disposed.
            {
                let d = Rc::clone(&disposed);
                props.insert(
                    "disposed".into(),
                    native(move |_args| Ok(JsValue::Boolean(*d.borrow()))),
                );
            }

            // dispose() — dispose all resources in reverse order.
            {
                let res = Rc::clone(&resources);
                let d = Rc::clone(&disposed);
                props.insert(
                    "dispose".into(),
                    native(move |_args| {
                        if *d.borrow() {
                            return Ok(JsValue::Undefined);
                        }
                        *d.borrow_mut() = true;
                        let items: Vec<JsValue> = res.borrow_mut().drain(..).rev().collect();
                        for item in &items {
                            if let JsValue::PlainObject(obj) = item
                                && let Some(JsValue::NativeFunction(f)) =
                                    obj.borrow().get("@@dispose").cloned()
                            {
                                let _ = f(vec![item.clone()]);
                            }
                        }
                        Ok(JsValue::Undefined)
                    }),
                );
            }

            // adopt(value, onDispose) — register a value with a custom callback.
            {
                let res = Rc::clone(&resources);
                props.insert(
                    "adopt".into(),
                    native(move |args| {
                        let val = args.first().cloned().unwrap_or(JsValue::Undefined);
                        let on_dispose = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        // Wrap in an object that carries @@dispose → onDispose(value).
                        let adopted_val = val.clone();
                        let mut wrapper = PropertyMap::new();
                        wrapper.insert(
                            "@@dispose".into(),
                            native(move |_| {
                                if let JsValue::NativeFunction(f) = &on_dispose {
                                    let _ = f(vec![adopted_val.clone()]);
                                }
                                Ok(JsValue::Undefined)
                            }),
                        );
                        res.borrow_mut()
                            .push(JsValue::PlainObject(Rc::new(RefCell::new(wrapper))));
                        Ok(val)
                    }),
                );
            }

            // [Symbol.dispose]() — aliases dispose() for using protocol.
            {
                let res2 = Rc::clone(&resources);
                let d2 = Rc::clone(&disposed);
                props.insert(
                    "@@dispose".into(),
                    native(move |_args| {
                        if *d2.borrow() {
                            return Ok(JsValue::Undefined);
                        }
                        *d2.borrow_mut() = true;
                        let items: Vec<JsValue> = res2.borrow_mut().drain(..).rev().collect();
                        for item in &items {
                            if let JsValue::PlainObject(obj) = item
                                && let Some(JsValue::NativeFunction(f)) =
                                    obj.borrow().get("@@dispose").cloned()
                            {
                                let _ = f(vec![item.clone()]);
                            }
                        }
                        Ok(JsValue::Undefined)
                    }),
                );
            }

            Ok(JsValue::PlainObject(Rc::new(RefCell::new(props))))
        })
    })
}

/// Build the `AsyncDisposableStack` constructor.
///
/// `AsyncDisposableStack` manages a stack of async-disposable resources and
/// calls their `[Symbol.asyncDispose]()` methods in reverse order when
/// `.disposeAsync()` is called.
#[inline(never)]
fn make_async_disposable_stack() -> JsValue {
    stacker::maybe_grow(512 * 1024, 2 * 1024 * 1024, || {
        native(|_args| {
            let resources: Rc<RefCell<Vec<JsValue>>> = Rc::new(RefCell::new(Vec::new()));
            let disposed: Rc<RefCell<bool>> = Rc::new(RefCell::new(false));
            let mut props = PropertyMap::new();

            // use(value) — add an async-disposable resource.
            {
                let res = Rc::clone(&resources);
                props.insert(
                    "use".into(),
                    native(move |args| {
                        let val = args.first().cloned().unwrap_or(JsValue::Undefined);
                        res.borrow_mut().push(val.clone());
                        Ok(val)
                    }),
                );
            }

            // disposed — whether the stack has been disposed.
            {
                let d = Rc::clone(&disposed);
                props.insert(
                    "disposed".into(),
                    native(move |_args| Ok(JsValue::Boolean(*d.borrow()))),
                );
            }

            // adopt(value, onDispose) — register a value with a custom callback.
            {
                let res = Rc::clone(&resources);
                props.insert(
                    "adopt".into(),
                    native(move |args| {
                        let val = args.first().cloned().unwrap_or(JsValue::Undefined);
                        let on_dispose = args.get(1).cloned().unwrap_or(JsValue::Undefined);
                        let adopted_val = val.clone();
                        let mut wrapper = PropertyMap::new();
                        wrapper.insert(
                            "@@asyncDispose".into(),
                            native(move |_| {
                                if let JsValue::NativeFunction(f) = &on_dispose {
                                    let _ = f(vec![adopted_val.clone()]);
                                }
                                Ok(JsValue::Undefined)
                            }),
                        );
                        res.borrow_mut()
                            .push(JsValue::PlainObject(Rc::new(RefCell::new(wrapper))));
                        Ok(val)
                    }),
                );
            }

            // disposeAsync() — dispose all resources in reverse order.
            {
                let res = Rc::clone(&resources);
                let d = Rc::clone(&disposed);
                props.insert(
                    "disposeAsync".into(),
                    native(move |_args| {
                        if *d.borrow() {
                            return Ok(JsValue::Undefined);
                        }
                        *d.borrow_mut() = true;
                        let items: Vec<JsValue> = res.borrow_mut().drain(..).rev().collect();
                        for item in &items {
                            if let JsValue::PlainObject(obj) = item
                                && let Some(JsValue::NativeFunction(f)) =
                                    obj.borrow().get("@@asyncDispose").cloned()
                            {
                                let _ = f(vec![item.clone()]);
                            }
                        }
                        Ok(JsValue::Undefined)
                    }),
                );
            }

            // [Symbol.asyncDispose]() — aliases disposeAsync() for protocol.
            {
                let res2 = Rc::clone(&resources);
                let d2 = Rc::clone(&disposed);
                props.insert(
                    "@@asyncDispose".into(),
                    native(move |_args| {
                        if *d2.borrow() {
                            return Ok(JsValue::Undefined);
                        }
                        *d2.borrow_mut() = true;
                        let items: Vec<JsValue> = res2.borrow_mut().drain(..).rev().collect();
                        for item in &items {
                            if let JsValue::PlainObject(obj) = item
                                && let Some(JsValue::NativeFunction(f)) =
                                    obj.borrow().get("@@asyncDispose").cloned()
                            {
                                let _ = f(vec![item.clone()]);
                            }
                        }
                        Ok(JsValue::Undefined)
                    }),
                );
            }

            Ok(JsValue::PlainObject(Rc::new(RefCell::new(props))))
        })
    })
}

/// Pre-populate `globals` with all ECMAScript built-in names.
///
/// This includes namespace objects (`Math`, `console`, `JSON`), constructor
/// objects (`Number`, `Object`, `Array`), global functions (`parseInt`,
/// `parseFloat`, `isNaN`, `isFinite`, URI helpers), and well-known constants
/// (`undefined`, `NaN`, `Infinity`).
#[inline(never)]
pub fn install_globals(globals: &mut HashMap<String, JsValue>) {
    // Phase 1: Namespace objects & core constructors
    stacker::maybe_grow(512 * 1024, 4 * 1024 * 1024, || {
        // ── Namespace objects ────────────────────────────────────────────────
        globals.insert("Math".into(), make_math());
        globals.insert("console".into(), make_console());
        globals.insert("JSON".into(), make_json());
        globals.insert("Intl".into(), make_intl());

        // ── Constructor / namespace objects ──────────────────────────────────
        globals.insert("Number".into(), finalize_ctor(make_number(), "Number"));
        globals.insert("Boolean".into(), finalize_ctor(make_boolean(), "Boolean"));
        globals.insert("Date".into(), finalize_ctor(make_date(), "Date"));
        globals.insert("Object".into(), finalize_ctor(make_object(), "Object"));
        globals.insert("Array".into(), finalize_ctor(make_array(), "Array"));
        globals.insert("Symbol".into(), finalize_ctor(make_symbol(), "Symbol"));
    });

    // Phase 2: Collections & async
    stacker::maybe_grow(512 * 1024, 4 * 1024 * 1024, || {
        globals.insert(
            "Iterator".into(),
            finalize_ctor(make_iterator(), "Iterator"),
        );
        globals.insert(
            "AsyncIterator".into(),
            finalize_ctor(make_async_iterator(), "AsyncIterator"),
        );
        globals.insert("Map".into(), finalize_ctor(make_map_builtin(), "Map"));
        globals.insert("Set".into(), finalize_ctor(make_set_builtin(), "Set"));
        globals.insert(
            "WeakMap".into(),
            finalize_ctor(make_weak_map_builtin(), "WeakMap"),
        );
        globals.insert(
            "WeakSet".into(),
            finalize_ctor(make_weak_set_builtin(), "WeakSet"),
        );
        globals.insert(
            "WeakRef".into(),
            finalize_ctor(make_weak_ref_builtin(), "WeakRef"),
        );
        globals.insert(
            "FinalizationRegistry".into(),
            finalize_ctor(make_finalization_registry_builtin(), "FinalizationRegistry"),
        );
        globals.insert("Promise".into(), finalize_ctor(make_promise(), "Promise"));
        globals.insert("RegExp".into(), finalize_ctor(make_regexp(), "RegExp"));
        globals.insert("BigInt".into(), finalize_ctor(make_bigint(), "BigInt"));
    });

    // Phase 3: Function, Proxy, Reflect, Error, String
    stacker::maybe_grow(512 * 1024, 4 * 1024 * 1024, || {
        globals.insert(
            "Function".into(),
            finalize_ctor(make_function(), "Function"),
        );
        globals.insert(
            "GeneratorFunction".into(),
            finalize_ctor(make_generator_function(), "GeneratorFunction"),
        );
        globals.insert(
            "AsyncGeneratorFunction".into(),
            finalize_ctor(
                crate::builtins::async_generator::make_async_generator_function(),
                "AsyncGeneratorFunction",
            ),
        );
        globals.insert("Proxy".into(), finalize_ctor(make_proxy(), "Proxy"));
        globals.insert("Reflect".into(), make_reflect());
        // ── Atomics / SharedArrayBuffer ─────────────────────────────────────
        globals.insert("Atomics".into(), make_atomics());
        globals.insert(
            "SharedArrayBuffer".into(),
            finalize_ctor(make_shared_arraybuffer(), "SharedArrayBuffer"),
        );

        // ── ShadowRealm ────────────────────────────────────────────────────
        globals.insert(
            "ShadowRealm".into(),
            finalize_ctor(make_shadow_realm(), "ShadowRealm"),
        );

        // ── Error constructors ────────────────────────────────────────────────
        install_error_constructors(globals);

        // ── Explicit resource management ────────────────────────────────────
        globals.insert(
            "DisposableStack".into(),
            finalize_ctor(make_disposable_stack(), "DisposableStack"),
        );
        globals.insert(
            "AsyncDisposableStack".into(),
            finalize_ctor(make_async_disposable_stack(), "AsyncDisposableStack"),
        );
        globals.insert("String".into(), finalize_ctor(make_string(), "String"));
    });

    // Phase 4: TypedArray / ArrayBuffer / DataView constructors
    stacker::maybe_grow(512 * 1024, 4 * 1024 * 1024, || {
        globals.insert(
            "ArrayBuffer".into(),
            finalize_ctor(make_arraybuffer(), "ArrayBuffer"),
        );
        globals.insert(
            "DataView".into(),
            finalize_ctor(make_dataview(), "DataView"),
        );
        globals.insert(
            "Int8Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Int8),
                "Int8Array",
            ),
        );
        globals.insert(
            "Uint8Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Uint8),
                "Uint8Array",
            ),
        );
        globals.insert(
            "Uint8ClampedArray".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Uint8Clamped),
                "Uint8ClampedArray",
            ),
        );
        globals.insert(
            "Int16Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Int16),
                "Int16Array",
            ),
        );
        globals.insert(
            "Uint16Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Uint16),
                "Uint16Array",
            ),
        );
        globals.insert(
            "Int32Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Int32),
                "Int32Array",
            ),
        );
        globals.insert(
            "Uint32Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Uint32),
                "Uint32Array",
            ),
        );
        globals.insert(
            "Float32Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Float32),
                "Float32Array",
            ),
        );
        globals.insert(
            "Float64Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::Float64),
                "Float64Array",
            ),
        );
        globals.insert(
            "BigInt64Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::BigInt64),
                "BigInt64Array",
            ),
        );
        globals.insert(
            "BigUint64Array".into(),
            finalize_ctor(
                make_typed_array_constructor(TypedArrayKind::BigUint64),
                "BigUint64Array",
            ),
        );
    });

    // Phase 5: Global constants, functions, and globalThis
    stacker::maybe_grow(512 * 1024, 4 * 1024 * 1024, || {
        // ── Global constants ────────────────────────────────────────────────
        globals.insert("undefined".into(), JsValue::Undefined);
        globals.insert("NaN".into(), JsValue::HeapNumber(GLOBAL_NAN));
        globals.insert("Infinity".into(), JsValue::HeapNumber(GLOBAL_INFINITY));
        globals.insert("null".into(), JsValue::Null);
        globals.insert("true".into(), JsValue::Boolean(true));
        globals.insert("false".into(), JsValue::Boolean(false));

        // ── Global functions ────────────────────────────────────────────────
        globals.insert(
            "parseInt".into(),
            builtin_fn("parseInt", 2, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                let radix = if args.len() > 1 {
                    let r = args[1].to_number()?;
                    if r.is_nan() || r == 0.0 {
                        0
                    } else {
                        r.floor() as i32
                    }
                } else {
                    0
                };
                Ok(num(global_parse_int(&s, radix)))
            }),
        );
        globals.insert(
            "parseFloat".into(),
            builtin_fn("parseFloat", 1, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(num(global_parse_float(&s)))
            }),
        );
        globals.insert(
            "isNaN".into(),
            builtin_fn("isNaN", 1, |args| {
                let n = args.first().unwrap_or(&JsValue::Undefined).to_number()?;
                Ok(JsValue::Boolean(global_is_nan(n)))
            }),
        );
        globals.insert(
            "isFinite".into(),
            builtin_fn("isFinite", 1, |args| {
                let n = args.first().unwrap_or(&JsValue::Undefined).to_number()?;
                Ok(JsValue::Boolean(global_is_finite(n)))
            }),
        );
        globals.insert(
            "encodeURI".into(),
            builtin_fn("encodeURI", 1, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(global_encode_uri(&s).into()))
            }),
        );
        globals.insert(
            "decodeURI".into(),
            builtin_fn("decodeURI", 1, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(global_decode_uri(&s)?.into()))
            }),
        );
        globals.insert(
            "encodeURIComponent".into(),
            builtin_fn("encodeURIComponent", 1, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(global_encode_uri_component(&s).into()))
            }),
        );
        globals.insert(
            "decodeURIComponent".into(),
            builtin_fn("decodeURIComponent", 1, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(global_decode_uri_component(&s)?.into()))
            }),
        );
        globals.insert(
            "eval".into(),
            native(|args| {
                // Indirect eval: non-string arguments are returned as-is (§19.2.1 step 2).
                let source = match args.first() {
                    Some(JsValue::String(s)) => s.clone(),
                    Some(other) => return Ok(other.clone()),
                    None => return Ok(JsValue::Undefined),
                };
                global_eval(&source)
            }),
        );

        // ── Annex B global functions ─────────────────────────────────────────
        globals.insert(
            "escape".into(),
            builtin_fn("escape", 1, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(global_escape(&s).into()))
            }),
        );
        globals.insert(
            "unescape".into(),
            builtin_fn("unescape", 1, |args| {
                let s = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                Ok(JsValue::String(global_unescape(&s).into()))
            }),
        );

        // ── btoa(stringToEncode) ─────────────────────────────────────────────
        // HTML spec — encodes a binary string to Base64.
        globals.insert(
            "btoa".into(),
            builtin_fn("btoa", 1, |args| {
                let input = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                // Validate: btoa only accepts Latin-1 (each char code < 256).
                for ch in input.chars() {
                    if ch as u32 > 255 {
                        return Err(StatorError::TypeError(
                            "btoa: string contains characters outside of the Latin1 range".into(),
                        ));
                    }
                }
                let bytes: Vec<u8> = input.chars().map(|c| c as u8).collect();
                const B64: &[u8; 64] =
                    b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
                let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
                for chunk in bytes.chunks(3) {
                    let b0 = chunk[0] as u32;
                    let b1 = if chunk.len() > 1 { chunk[1] as u32 } else { 0 };
                    let b2 = if chunk.len() > 2 { chunk[2] as u32 } else { 0 };
                    let n = (b0 << 16) | (b1 << 8) | b2;
                    out.push(B64[((n >> 18) & 0x3F) as usize] as char);
                    out.push(B64[((n >> 12) & 0x3F) as usize] as char);
                    if chunk.len() > 1 {
                        out.push(B64[((n >> 6) & 0x3F) as usize] as char);
                    } else {
                        out.push('=');
                    }
                    if chunk.len() > 2 {
                        out.push(B64[(n & 0x3F) as usize] as char);
                    } else {
                        out.push('=');
                    }
                }
                Ok(JsValue::String(out.into()))
            }),
        );

        // ── atob(encodedData) ───────────────────────────────────────────────
        // HTML spec — decodes a Base64 string back to a binary string.
        globals.insert(
            "atob".into(),
            builtin_fn("atob", 1, |args| {
                let input = args.first().unwrap_or(&JsValue::Undefined).to_js_string()?;
                // Strip whitespace per spec.
                let clean: String = input.chars().filter(|c| !c.is_ascii_whitespace()).collect();
                fn b64_val(c: u8) -> Option<u32> {
                    match c {
                        b'A'..=b'Z' => Some((c - b'A') as u32),
                        b'a'..=b'z' => Some((c - b'a' + 26) as u32),
                        b'0'..=b'9' => Some((c - b'0' + 52) as u32),
                        b'+' => Some(62),
                        b'/' => Some(63),
                        b'=' => Some(0),
                        _ => None,
                    }
                }
                let bytes = clean.as_bytes();
                if !bytes.len().is_multiple_of(4) {
                    return Err(StatorError::TypeError("atob: invalid character".into()));
                }
                let mut out = Vec::with_capacity(bytes.len() / 4 * 3);
                for chunk in bytes.chunks(4) {
                    let a = b64_val(chunk[0])
                        .ok_or_else(|| StatorError::TypeError("atob: invalid character".into()))?;
                    let b = b64_val(chunk[1])
                        .ok_or_else(|| StatorError::TypeError("atob: invalid character".into()))?;
                    let c = b64_val(chunk[2])
                        .ok_or_else(|| StatorError::TypeError("atob: invalid character".into()))?;
                    let d = b64_val(chunk[3])
                        .ok_or_else(|| StatorError::TypeError("atob: invalid character".into()))?;
                    let n = (a << 18) | (b << 12) | (c << 6) | d;
                    out.push(((n >> 16) & 0xFF) as u8);
                    if chunk[2] != b'=' {
                        out.push(((n >> 8) & 0xFF) as u8);
                    }
                    if chunk[3] != b'=' {
                        out.push((n & 0xFF) as u8);
                    }
                }
                let result: String = out.iter().map(|&b| b as char).collect();
                Ok(JsValue::String(result.into()))
            }),
        );

        // ── structuredClone(value) ──────────────────────────────────────────
        globals.insert(
            "structuredClone".into(),
            native(|args| {
                let val = args.first().unwrap_or(&JsValue::Undefined);
                structured_clone(val)
            }),
        );

        // ── queueMicrotask(callback) ────────────────────────────────────────
        globals.insert(
            "queueMicrotask".into(),
            native(|args| {
                let cb = args.first().unwrap_or(&JsValue::Undefined);
                if !is_callable_value(cb) {
                    return Err(StatorError::TypeError(
                        "queueMicrotask: argument must be a function".into(),
                    ));
                }
                dispatch_call_value(cb, vec![])?;
                Ok(JsValue::Undefined)
            }),
        );

        globals.insert(
            "setTimeout".into(),
            builtin_fn("setTimeout", 1, |_args| Ok(JsValue::Smi(1))),
        );
        globals.insert(
            "clearTimeout".into(),
            builtin_fn("clearTimeout", 1, |_args| Ok(JsValue::Undefined)),
        );
        globals.insert("crypto".into(), make_crypto());

        // ── globalThis (ECMAScript §19.1) ───────────────────────────────────
        // `globalThis` is a self-referential property of the global object.
        // The inner map is shared via `Rc` so that `globalThis.globalThis`
        // resolves back to the same object.
        //
        // Per the ES spec, global properties have specific descriptor
        // attributes:
        //  - Value properties (undefined, NaN, Infinity): {W:0, E:0, C:0}
        //  - Everything else (constructors, functions, namespaces,
        //    globalThis): {W:1, E:0, C:1}
        let non_writable_non_configurable = PropertyAttributes::empty();
        let builtin_attrs = PropertyAttributes::WRITABLE | PropertyAttributes::CONFIGURABLE;
        let mut inner_props = PropertyMap::new();
        for (k, v) in globals.iter() {
            let attrs = match k.as_str() {
                "undefined" | "NaN" | "Infinity" => non_writable_non_configurable,
                _ => builtin_attrs,
            };
            inner_props.insert_with_attrs(k.clone(), v.clone(), attrs);
        }
        let inner = Rc::new(RefCell::new(inner_props));
        let global_object = JsValue::PlainObject(Rc::clone(&inner));
        {
            let mut inner_borrow = inner.borrow_mut();
            inner_borrow.insert_with_attrs(
                "globalThis".into(),
                global_object.clone(),
                builtin_attrs,
            );
            inner_borrow.insert_with_attrs("this".into(), global_object.clone(), builtin_attrs);
        }
        globals.insert("globalThis".into(), global_object.clone());
        globals.insert("this".into(), global_object);
    });
}

// ── Tests ────────────────────────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use super::*;

    fn assert_eval_true(script: &str) {
        assert_eq!(global_eval(script).unwrap(), JsValue::Boolean(true));
    }

    fn assert_eval_type_error(script: &str) {
        assert!(matches!(
            global_eval(script),
            Err(StatorError::TypeError(_))
        ));
    }

    fn assert_eval_range_error(script: &str) {
        assert!(matches!(
            global_eval(script),
            Err(StatorError::RangeError(_))
        ));
    }

    fn assert_eval_syntax_error(script: &str) {
        assert!(matches!(
            global_eval(script),
            Err(StatorError::SyntaxError(_))
        ));
    }

    fn assert_eval_fulfilled_promise_value(script: &str, expected: JsValue) {
        match eval_with_microtasks(script) {
            JsValue::Promise(promise) => {
                assert!(
                    promise.is_fulfilled(),
                    "expected fulfilled promise for {script:?}"
                );
                assert_eq!(promise.value(), Some(expected));
            }
            other => panic!("expected Promise for {script:?}, got {other:?}"),
        }
    }

    fn assert_eval_fulfilled_promise_true(script: &str) {
        assert_eval_fulfilled_promise_value(script, JsValue::Boolean(true));
    }

    fn assert_eval_rejected_promise_reason(script: &str, expected: JsValue) {
        match eval_with_microtasks(script) {
            JsValue::Promise(promise) => {
                assert!(
                    promise.is_rejected(),
                    "expected rejected promise for {script:?}"
                );
                assert_eq!(promise.reason(), Some(expected));
            }
            other => panic!("expected Promise for {script:?}, got {other:?}"),
        }
    }

    /// Verify that `install_globals` populates the expected keys.
    #[test]
    fn test_install_globals_keys() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(globals.contains_key("Math"));
        assert!(globals.contains_key("console"));
        assert!(globals.contains_key("JSON"));
        assert!(globals.contains_key("Number"));
        assert!(globals.contains_key("Date"));
        assert!(globals.contains_key("Object"));
        assert!(globals.contains_key("Array"));
        assert!(globals.contains_key("parseInt"));
        assert!(globals.contains_key("parseFloat"));
        assert!(globals.contains_key("isNaN"));
        assert!(globals.contains_key("isFinite"));
        assert!(globals.contains_key("undefined"));
        assert!(globals.contains_key("NaN"));
        assert!(globals.contains_key("Infinity"));
        assert!(globals.contains_key("Symbol"));
        assert!(globals.contains_key("Iterator"));
        assert!(globals.contains_key("Map"));
        assert!(globals.contains_key("Set"));
        assert!(globals.contains_key("WeakMap"));
        assert!(globals.contains_key("WeakSet"));
        assert!(globals.contains_key("WeakRef"));
        assert!(globals.contains_key("FinalizationRegistry"));
        assert!(globals.contains_key("Promise"));
        assert!(globals.contains_key("RegExp"));
        assert!(globals.contains_key("BigInt"));
        assert!(globals.contains_key("Function"));
        assert!(globals.contains_key("Proxy"));
        assert!(globals.contains_key("Reflect"));
        assert!(globals.contains_key("globalThis"));
        assert!(globals.contains_key("Intl"));
        // Error constructors
        assert!(globals.contains_key("Error"));
        assert!(globals.contains_key("TypeError"));
        assert!(globals.contains_key("RangeError"));
        assert!(globals.contains_key("ReferenceError"));
        assert!(globals.contains_key("SyntaxError"));
        assert!(globals.contains_key("URIError"));
        assert!(globals.contains_key("EvalError"));
        assert!(globals.contains_key("AggregateError"));
        // TypedArray family
        assert!(globals.contains_key("ArrayBuffer"));
        assert!(globals.contains_key("DataView"));
        assert!(globals.contains_key("Int8Array"));
        assert!(globals.contains_key("Uint8Array"));
        assert!(globals.contains_key("Uint8ClampedArray"));
        assert!(globals.contains_key("Int16Array"));
        assert!(globals.contains_key("Uint16Array"));
        assert!(globals.contains_key("Int32Array"));
        assert!(globals.contains_key("Uint32Array"));
        assert!(globals.contains_key("Float32Array"));
        assert!(globals.contains_key("Float64Array"));
        assert!(globals.contains_key("BigInt64Array"));
        assert!(globals.contains_key("BigUint64Array"));
        // Base64 encoding/decoding
        assert!(globals.contains_key("btoa"));
        assert!(globals.contains_key("atob"));
        assert!(globals.contains_key("structuredClone"));
        assert!(globals.contains_key("queueMicrotask"));
        assert!(globals.contains_key("setTimeout"));
        assert!(globals.contains_key("clearTimeout"));
        assert!(globals.contains_key("crypto"));
    }

    #[test]
    fn e2e_intl_exists_object() {
        assert_eval_true("typeof Intl === 'object' && Intl !== null");
    }

    #[test]
    fn e2e_intl_to_string_tag() {
        assert_eval_true("Intl[Symbol.toStringTag] === 'Intl'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_object_to_string_uses_tag() {
        assert_eval_true("Object.prototype.toString.call(Intl) === '[object Intl]'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_number_format_exists() {
        assert_eval_true("typeof Intl.NumberFormat === 'object'");
    }

    #[test]
    fn e2e_intl_number_format_name() {
        assert_eval_true("Intl.NumberFormat.name === 'NumberFormat'");
    }

    #[test]
    fn e2e_intl_number_format_prototype_constructor() {
        assert_eval_true("Intl.NumberFormat.prototype.constructor === Intl.NumberFormat");
    }

    #[test]
    fn e2e_intl_number_format_new_returns_string() {
        assert_eval_true("typeof new Intl.NumberFormat().format(123) === 'string'");
    }

    #[test]
    fn e2e_intl_number_format_formats_integer() {
        assert_eval_true("new Intl.NumberFormat().format(123) === '123'");
    }

    #[test]
    fn e2e_intl_number_format_call_without_new_formats() {
        assert_eval_true("Intl.NumberFormat().format(7) === '7'");
    }

    #[test]
    fn e2e_intl_number_format_nan() {
        assert_eval_true("Intl.NumberFormat().format(NaN) === 'NaN'");
    }

    #[test]
    fn e2e_intl_number_format_resolved_options_locale() {
        assert_eval_true("Intl.NumberFormat().resolvedOptions().locale === 'en-US'");
    }

    #[test]
    fn e2e_intl_number_format_supported_locales_of() {
        assert_eval_true(
            "Intl.NumberFormat.supportedLocalesOf('en-US').length === 1 && Intl.NumberFormat.supportedLocalesOf('en-US')[0] === 'en-US'",
        );
    }

    #[test]
    fn e2e_intl_number_format_to_parts_length() {
        assert_eval_true("Intl.NumberFormat().formatToParts(12.5).length === 3");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_date_time_format_exists() {
        assert_eval_true("typeof Intl.DateTimeFormat === 'object'");
    }

    #[test]
    fn e2e_intl_date_time_format_name() {
        assert_eval_true("Intl.DateTimeFormat.name === 'DateTimeFormat'");
    }

    #[test]
    fn e2e_intl_date_time_format_prototype_constructor() {
        assert_eval_true("Intl.DateTimeFormat.prototype.constructor === Intl.DateTimeFormat");
    }

    #[test]
    fn e2e_intl_date_time_format_new_returns_string() {
        assert_eval_true("typeof new Intl.DateTimeFormat().format(0) === 'string'");
    }

    #[test]
    fn e2e_intl_date_time_format_epoch_contains_1970() {
        assert_eval_true("new Intl.DateTimeFormat().format(0).indexOf('1970') !== -1");
    }

    #[test]
    fn e2e_intl_date_time_format_call_without_new_formats() {
        assert_eval_true("Intl.DateTimeFormat().format(0).length > 0");
    }

    #[test]
    fn e2e_intl_date_time_format_resolved_options_time_zone() {
        assert_eval_true("Intl.DateTimeFormat().resolvedOptions().timeZone === 'UTC'");
    }

    #[test]
    fn e2e_intl_date_time_format_to_parts_has_month() {
        assert_eval_true(
            "Intl.DateTimeFormat().formatToParts(0).length > 0 && Intl.DateTimeFormat().formatToParts(0)[0].type === 'month'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_collator_exists() {
        assert_eval_true("typeof Intl.Collator === 'object'");
    }

    #[test]
    fn e2e_intl_collator_name() {
        assert_eval_true("Intl.Collator.name === 'Collator'");
    }

    #[test]
    fn e2e_intl_collator_prototype_constructor() {
        assert_eval_true("Intl.Collator.prototype.constructor === Intl.Collator");
    }

    #[test]
    fn e2e_intl_collator_new_returns_object() {
        assert_eval_true("typeof new Intl.Collator() === 'object'");
    }

    #[test]
    fn e2e_intl_collator_compare_less() {
        assert_eval_true("new Intl.Collator().compare('a', 'b') === -1");
    }

    #[test]
    fn e2e_intl_collator_compare_equal() {
        assert_eval_true("new Intl.Collator().compare('same', 'same') === 0");
    }

    #[test]
    fn e2e_intl_collator_call_without_new_compare() {
        assert_eval_true("Intl.Collator().compare('b', 'a') === 1");
    }

    #[test]
    fn e2e_intl_collator_resolved_options_locale() {
        assert_eval_true("Intl.Collator().resolvedOptions().locale === 'en-US'");
    }

    #[test]
    fn e2e_intl_get_canonical_locales() {
        assert_eval_true(
            "Intl.getCanonicalLocales('en-US').length === 1 && Intl.getCanonicalLocales('en-US')[0] === 'en-US'",
        );
    }

    #[test]
    fn e2e_intl_supported_values_of_time_zone() {
        assert_eval_true(
            "Intl.supportedValuesOf('timeZone').length === 1 && Intl.supportedValuesOf('timeZone')[0] === 'UTC'",
        );
    }

    #[test]
    fn e2e_intl_locale_language() {
        assert_eval_true("Intl.Locale('en-US').language === 'en'");
    }

    #[test]
    fn e2e_intl_locale_base_name() {
        assert_eval_true("new Intl.Locale('en-US').baseName === 'en-US'");
    }

    #[test]
    fn e2e_intl_locale_name() {
        assert_eval_true("Intl.Locale.name === 'Locale'");
    }

    // ── PluralRules e2e ─────────────────────────────────────────────────────

    #[test]
    #[ignore] // TODO: Intl.PluralRules typeof check fails in release mode
    fn e2e_intl_plural_rules_exists() {
        assert_eval_true("typeof Intl.PluralRules === 'object'");
    }

    #[test]
    fn e2e_intl_plural_rules_name() {
        assert_eval_true("Intl.PluralRules.name === 'PluralRules'");
    }

    #[test]
    fn e2e_intl_plural_rules_prototype_constructor() {
        assert_eval_true("Intl.PluralRules.prototype.constructor === Intl.PluralRules");
    }

    #[test]
    fn e2e_intl_plural_rules_select_one() {
        assert_eval_true("new Intl.PluralRules().select(1) === 'one'");
    }

    #[test]
    fn e2e_intl_plural_rules_select_other() {
        assert_eval_true("new Intl.PluralRules().select(5) === 'other'");
    }

    #[test]
    fn e2e_intl_plural_rules_resolved_options_type() {
        assert_eval_true("Intl.PluralRules().resolvedOptions().type === 'cardinal'");
    }

    // ── ListFormat e2e ──────────────────────────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_list_format_exists() {
        assert_eval_true("typeof Intl.ListFormat === 'object'");
    }

    #[test]
    fn e2e_intl_list_format_name() {
        assert_eval_true("Intl.ListFormat.name === 'ListFormat'");
    }

    #[test]
    fn e2e_intl_list_format_prototype_constructor() {
        assert_eval_true("Intl.ListFormat.prototype.constructor === Intl.ListFormat");
    }

    #[test]
    fn e2e_intl_list_format_format_returns_string() {
        assert_eval_true("typeof new Intl.ListFormat().format(['a','b']) === 'string'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_list_format_format_two_items() {
        assert_eval_true("new Intl.ListFormat().format(['A','B']) === 'A and B'");
    }

    #[test]
    fn e2e_intl_list_format_resolved_options_locale() {
        assert_eval_true("Intl.ListFormat().resolvedOptions().locale === 'en-US'");
    }

    // ── RelativeTimeFormat e2e ──────────────────────────────────────────────

    #[test]
    #[ignore] // TODO: Intl.RelativeTimeFormat existence check fails
    fn e2e_intl_relative_time_format_exists() {
        assert_eval_true("typeof Intl.RelativeTimeFormat === 'object'");
    }

    #[test]
    fn e2e_intl_relative_time_format_name() {
        assert_eval_true("Intl.RelativeTimeFormat.name === 'RelativeTimeFormat'");
    }

    #[test]
    fn e2e_intl_relative_time_format_prototype_constructor() {
        assert_eval_true(
            "Intl.RelativeTimeFormat.prototype.constructor === Intl.RelativeTimeFormat",
        );
    }

    #[test]
    fn e2e_intl_relative_time_format_format_returns_string() {
        assert_eval_true("typeof new Intl.RelativeTimeFormat().format(-1, 'day') === 'string'");
    }

    #[test]
    fn e2e_intl_relative_time_format_resolved_options_locale() {
        assert_eval_true("Intl.RelativeTimeFormat().resolvedOptions().locale === 'en-US'");
    }

    // ── Segmenter e2e ───────────────────────────────────────────────────────

    #[test]
    #[ignore] // TODO: Intl.Segmenter existence check fails
    fn e2e_intl_segmenter_exists() {
        assert_eval_true("typeof Intl.Segmenter === 'object'");
    }

    #[test]
    fn e2e_intl_segmenter_name() {
        assert_eval_true("Intl.Segmenter.name === 'Segmenter'");
    }

    #[test]
    fn e2e_intl_segmenter_prototype_constructor() {
        assert_eval_true("Intl.Segmenter.prototype.constructor === Intl.Segmenter");
    }

    #[test]
    fn e2e_intl_segmenter_segment_returns_object() {
        assert_eval_true("typeof new Intl.Segmenter().segment('hi') === 'object'");
    }

    #[test]
    fn e2e_intl_segmenter_segment_length() {
        assert_eval_true("new Intl.Segmenter().segment('abc').length === 3");
    }

    #[test]
    fn e2e_intl_segmenter_resolved_options_granularity() {
        assert_eval_true("Intl.Segmenter().resolvedOptions().granularity === 'grapheme'");
    }

    // ── Symbol.toStringTag on all constructor prototypes ────────────────────

    #[test]
    fn e2e_intl_number_format_to_string_tag() {
        assert_eval_true("Intl.NumberFormat.prototype[Symbol.toStringTag] === 'Intl.NumberFormat'");
    }

    #[test]
    fn e2e_intl_date_time_format_to_string_tag() {
        assert_eval_true(
            "Intl.DateTimeFormat.prototype[Symbol.toStringTag] === 'Intl.DateTimeFormat'",
        );
    }

    #[test]
    fn e2e_intl_collator_to_string_tag() {
        assert_eval_true("Intl.Collator.prototype[Symbol.toStringTag] === 'Intl.Collator'");
    }

    #[test]
    fn e2e_intl_plural_rules_to_string_tag() {
        assert_eval_true("Intl.PluralRules.prototype[Symbol.toStringTag] === 'Intl.PluralRules'");
    }

    #[test]
    fn e2e_intl_list_format_to_string_tag() {
        assert_eval_true("Intl.ListFormat.prototype[Symbol.toStringTag] === 'Intl.ListFormat'");
    }

    #[test]
    fn e2e_intl_relative_time_format_to_string_tag() {
        assert_eval_true(
            "Intl.RelativeTimeFormat.prototype[Symbol.toStringTag] === 'Intl.RelativeTimeFormat'",
        );
    }

    #[test]
    fn e2e_intl_segmenter_to_string_tag() {
        assert_eval_true("Intl.Segmenter.prototype[Symbol.toStringTag] === 'Intl.Segmenter'");
    }

    #[test]
    fn e2e_intl_locale_to_string_tag() {
        assert_eval_true("Intl.Locale.prototype[Symbol.toStringTag] === 'Intl.Locale'");
    }

    // ── Additional coverage ─────────────────────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_get_canonical_locales_array() {
        assert_eval_true("Intl.getCanonicalLocales(['en-US','fr']).length === 2");
    }

    #[test]
    fn e2e_intl_supported_values_of_calendar() {
        assert_eval_true("Array.isArray(Intl.supportedValuesOf('calendar'))");
    }

    #[test]
    fn e2e_intl_collator_compare_greater() {
        assert_eval_true("new Intl.Collator().compare('z', 'a') === 1");
    }

    #[test]
    fn e2e_intl_number_format_decimal_format() {
        assert_eval_true("new Intl.NumberFormat().format(3.14) === '3.14'");
    }

    #[test]
    fn e2e_intl_plural_rules_select_zero() {
        assert_eval_true("new Intl.PluralRules().select(0) === 'other'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_list_format_format_three_items() {
        assert_eval_true("new Intl.ListFormat().format(['A','B','C']) === 'A, B, and C'");
    }

    // ── Intl advanced method conformance e2e ────────────────────────────────

    // NumberFormat.formatToParts
    #[test]
    fn e2e_intl_nf_format_to_parts_integer_type() {
        assert_eval_true("Intl.NumberFormat().formatToParts(42)[0].type === 'integer'");
    }

    #[test]
    fn e2e_intl_nf_format_to_parts_integer_value() {
        assert_eval_true("Intl.NumberFormat().formatToParts(42)[0].value === '42'");
    }

    #[test]
    fn e2e_intl_nf_format_to_parts_decimal() {
        assert_eval_true("Intl.NumberFormat().formatToParts(1.5)[1].type === 'decimal'");
    }

    #[test]
    fn e2e_intl_nf_format_to_parts_fraction() {
        assert_eval_true("Intl.NumberFormat().formatToParts(1.5)[2].type === 'fraction'");
    }

    // DateTimeFormat.formatToParts
    #[test]
    fn e2e_intl_dtf_format_to_parts_year() {
        assert_eval_true(
            "Intl.DateTimeFormat().formatToParts(0).some(function(p) { return p.type === 'year' })",
        );
    }

    #[test]
    fn e2e_intl_dtf_format_to_parts_day() {
        assert_eval_true(
            "Intl.DateTimeFormat().formatToParts(0).some(function(p) { return p.type === 'day' })",
        );
    }

    // NumberFormat.formatRange
    #[test]
    fn e2e_intl_nf_format_range_returns_string() {
        assert_eval_true("typeof new Intl.NumberFormat().formatRange(1, 10) === 'string'");
    }

    #[test]
    fn e2e_intl_nf_format_range_contains_dash() {
        assert_eval_true("new Intl.NumberFormat().formatRange(1, 10).indexOf('–') !== -1");
    }

    #[test]
    fn e2e_intl_nf_format_range_contains_start() {
        assert_eval_true("new Intl.NumberFormat().formatRange(3, 7).indexOf('3') !== -1");
    }

    #[test]
    fn e2e_intl_nf_format_range_contains_end() {
        assert_eval_true("new Intl.NumberFormat().formatRange(3, 7).indexOf('7') !== -1");
    }

    // NumberFormat.formatRangeToParts
    #[test]
    fn e2e_intl_nf_format_range_to_parts_length() {
        assert_eval_true("Intl.NumberFormat().formatRangeToParts(1, 10).length === 3");
    }

    #[test]
    fn e2e_intl_nf_format_range_to_parts_start() {
        assert_eval_true("Intl.NumberFormat().formatRangeToParts(1, 10)[0].type === 'startRange'");
    }

    #[test]
    fn e2e_intl_nf_format_range_to_parts_end() {
        assert_eval_true("Intl.NumberFormat().formatRangeToParts(1, 10)[2].type === 'endRange'");
    }

    // PluralRules.selectRange
    #[test]
    fn e2e_intl_pr_select_range_other() {
        assert_eval_true("new Intl.PluralRules().selectRange(1, 5) === 'other'");
    }

    #[test]
    fn e2e_intl_pr_select_range_one() {
        assert_eval_true("new Intl.PluralRules().selectRange(0, 1) === 'one'");
    }

    #[test]
    fn e2e_intl_pr_select_range_returns_string() {
        assert_eval_true("typeof new Intl.PluralRules().selectRange(1, 2) === 'string'");
    }

    // Intl.Locale: region and script getters
    #[test]
    fn e2e_intl_locale_region() {
        assert_eval_true("new Intl.Locale('en-US').region === 'US'");
    }

    #[test]
    fn e2e_intl_locale_region_empty() {
        assert_eval_true("new Intl.Locale('en').region === ''");
    }

    #[test]
    fn e2e_intl_locale_script() {
        assert_eval_true("new Intl.Locale('zh-Hans-CN').script === 'Hans'");
    }

    #[test]
    fn e2e_intl_locale_script_empty() {
        assert_eval_true("new Intl.Locale('en-US').script === ''");
    }

    // Intl.Locale.maximize / minimize
    #[test]
    fn e2e_intl_locale_maximize_language() {
        assert_eval_true("new Intl.Locale('en').maximize().language === 'en'");
    }

    #[test]
    fn e2e_intl_locale_maximize_has_script() {
        assert_eval_true("new Intl.Locale('en').maximize().script === 'Latn'");
    }

    #[test]
    fn e2e_intl_locale_maximize_has_region() {
        assert_eval_true("new Intl.Locale('en').maximize().region === 'US'");
    }

    #[test]
    fn e2e_intl_locale_minimize_returns_language() {
        assert_eval_true("new Intl.Locale('en-US').minimize().language === 'en'");
    }

    // Intl.DisplayNames.of with type
    #[test]
    fn e2e_intl_display_names_language_en() {
        assert_eval_true(
            "new Intl.DisplayNames('en', { type: 'language' }).of('en') === 'English'",
        );
    }

    #[test]
    fn e2e_intl_display_names_region_us() {
        assert_eval_true(
            "new Intl.DisplayNames('en', { type: 'region' }).of('US') === 'United States'",
        );
    }

    #[test]
    fn e2e_intl_display_names_script_latn() {
        assert_eval_true("new Intl.DisplayNames('en', { type: 'script' }).of('Latn') === 'Latin'");
    }

    #[test]
    fn e2e_intl_display_names_currency_usd() {
        assert_eval_true(
            "new Intl.DisplayNames('en', { type: 'currency' }).of('USD') === 'US Dollar'",
        );
    }

    // Segmenter.segment with containing()
    #[test]
    fn e2e_intl_segmenter_segment_has_containing() {
        assert_eval_true("typeof new Intl.Segmenter().segment('hi').containing === 'function'");
    }

    #[test]
    fn e2e_intl_segmenter_segment_containing_returns_object() {
        assert_eval_true("typeof new Intl.Segmenter().segment('hi').containing(0) === 'object'");
    }

    #[test]
    fn e2e_intl_segmenter_segment_containing_segment_value() {
        assert_eval_true("new Intl.Segmenter().segment('hi').containing(0).segment === 'h'");
    }

    #[test]
    fn e2e_intl_segmenter_segment_containing_index() {
        assert_eval_true("new Intl.Segmenter().segment('hi').containing(1).index === 1");
    }

    #[test]
    fn e2e_intl_segmenter_segment_containing_input() {
        assert_eval_true("new Intl.Segmenter().segment('hi').containing(0).input === 'hi'");
    }

    // ListFormat.formatToParts
    #[test]
    fn e2e_intl_lf_format_to_parts_returns_array() {
        assert_eval_true("Array.isArray(new Intl.ListFormat().formatToParts(['A','B']))");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_lf_format_to_parts_element_type() {
        assert_eval_true("new Intl.ListFormat().formatToParts(['A','B'])[0].type === 'element'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_lf_format_to_parts_element_value() {
        assert_eval_true("new Intl.ListFormat().formatToParts(['A','B'])[0].value === 'A'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_lf_format_to_parts_literal_type() {
        assert_eval_true("new Intl.ListFormat().formatToParts(['A','B'])[1].type === 'literal'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_intl_lf_format_to_parts_length() {
        assert_eval_true("new Intl.ListFormat().formatToParts(['A','B']).length === 3");
    }

    // RelativeTimeFormat.formatToParts
    #[test]
    fn e2e_intl_rtf_format_to_parts_returns_array() {
        assert_eval_true("Array.isArray(new Intl.RelativeTimeFormat().formatToParts(-1, 'day'))");
    }

    #[test]
    fn e2e_intl_rtf_format_to_parts_has_integer() {
        assert_eval_true(
            "new Intl.RelativeTimeFormat().formatToParts(-1, 'day').some(function(p) { return p.type === 'integer' })",
        );
    }

    #[test]
    fn e2e_intl_rtf_format_to_parts_has_unit() {
        assert_eval_true(
            "new Intl.RelativeTimeFormat().formatToParts(-1, 'day').some(function(p) { return p.type === 'unit' })",
        );
    }

    // All constructors accept locales and options parameters
    #[test]
    fn e2e_intl_nf_accepts_locale_param() {
        assert_eval_true("typeof new Intl.NumberFormat('en-US').format(1) === 'string'");
    }

    #[test]
    fn e2e_intl_dtf_accepts_locale_param() {
        assert_eval_true("typeof new Intl.DateTimeFormat('en-US').format(0) === 'string'");
    }

    #[test]
    fn e2e_intl_collator_accepts_locale_param() {
        assert_eval_true("typeof new Intl.Collator('en-US') === 'object'");
    }

    // Intl.supportedValuesOf
    #[test]
    fn e2e_intl_supported_values_of_collation() {
        assert_eval_true("Intl.supportedValuesOf('collation').length >= 1");
    }

    #[test]
    fn e2e_intl_supported_values_of_currency() {
        assert_eval_true(
            "Intl.supportedValuesOf('currency').length >= 1 && Intl.supportedValuesOf('currency')[0] === 'USD'",
        );
    }

    #[test]
    fn e2e_intl_supported_values_of_numbering_system() {
        assert_eval_true(
            "Intl.supportedValuesOf('numberingSystem').length >= 1 && Intl.supportedValuesOf('numberingSystem')[0] === 'latn'",
        );
    }

    #[test]
    fn e2e_intl_supported_values_of_unknown_returns_empty() {
        assert_eval_true("Intl.supportedValuesOf('unknown').length === 0");
    }

    /// Verify that the `Math` object has the expected properties.
    #[test]
    fn test_math_object_properties() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let math = globals.get("Math").unwrap();
        if let JsValue::PlainObject(map) = math {
            let map = map.borrow();
            assert!(map.contains_key("PI"));
            assert!(map.contains_key("E"));
            assert!(map.contains_key("floor"));
            assert!(map.contains_key("ceil"));
            assert!(map.contains_key("round"));
            assert!(map.contains_key("abs"));
            assert!(map.contains_key("sqrt"));
            assert!(map.contains_key("max"));
            assert!(map.contains_key("min"));
            assert!(map.contains_key("random"));
        } else {
            panic!("Math should be a PlainObject");
        }
    }

    /// Verify Math.PI value.
    #[test]
    fn test_math_pi_value() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let math = globals.get("Math").unwrap();
        if let JsValue::PlainObject(map) = math {
            let pi = map.borrow().get("PI").cloned().unwrap();
            if let JsValue::HeapNumber(n) = pi {
                assert!((n - std::f64::consts::PI).abs() < 1e-15);
            } else {
                panic!("PI should be a HeapNumber");
            }
        } else {
            panic!("Math should be a PlainObject");
        }
    }

    /// Call Math.floor via the built-in function object wrapper.
    #[test]
    fn test_math_floor_native() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let math = globals.get("Math").unwrap();
        if let JsValue::PlainObject(map) = math {
            let floor = map.borrow().get("floor").cloned().unwrap();
            // Math.floor is now a PlainObject with __call__, .name, .length
            if let JsValue::PlainObject(fn_obj) = &floor {
                let call_fn = fn_obj.borrow().get("__call__").cloned().unwrap();
                if let JsValue::NativeFunction(f) = call_fn {
                    let result = f(vec![JsValue::HeapNumber(1.7)]).unwrap();
                    assert_eq!(result, JsValue::Smi(1));
                } else {
                    panic!("__call__ should be a NativeFunction");
                }
                // Verify .name and .length
                let name = fn_obj.borrow().get("name").cloned().unwrap();
                assert_eq!(name, JsValue::String("floor".into()));
                let length = fn_obj.borrow().get("length").cloned().unwrap();
                assert_eq!(length, JsValue::Smi(1));
            } else {
                panic!("floor should be a PlainObject (builtin_fn)");
            }
        }
    }

    /// Call parseInt via the native function wrapper.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_parse_int_native() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let parse_int = globals.get("parseInt").unwrap();
        if let JsValue::NativeFunction(f) = parse_int {
            let result = f(vec![JsValue::String("42".into())]).unwrap();
            assert_eq!(result, JsValue::Smi(42));
        } else {
            panic!("parseInt should be a NativeFunction");
        }
    }

    /// Call isNaN via the native function wrapper.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_is_nan_native() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let is_nan = globals.get("isNaN").unwrap();
        if let JsValue::NativeFunction(f) = is_nan {
            let result = f(vec![JsValue::HeapNumber(f64::NAN)]).unwrap();
            assert_eq!(result, JsValue::Boolean(true));

            let result = f(vec![JsValue::Smi(42)]).unwrap();
            assert_eq!(result, JsValue::Boolean(false));
        } else {
            panic!("isNaN should be a NativeFunction");
        }
    }

    /// Call console.log via the native function wrapper.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_console_log_native() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let console = globals.get("console").unwrap();
        if let JsValue::PlainObject(map) = console {
            let log = map.borrow().get("log").cloned().unwrap();
            if let JsValue::NativeFunction(f) = log {
                // Should return undefined without crashing.
                let result = f(vec![JsValue::String("hello".into())]).unwrap();
                assert_eq!(result, JsValue::Undefined);
            } else {
                panic!("log should be a NativeFunction");
            }
        }
    }

    // ── End-to-end tests: parse → compile → interpret ──────────────────────
    //
    // These tests exercise the full pipeline using `global_eval` which now
    // automatically gets globals installed via `InterpreterFrame::new`.

    use crate::builtins::global::global_eval;

    /// `Math.floor(1.7)` → 1
    #[test]
    fn e2e_math_floor() {
        let result = global_eval("Math.floor(1.7)").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Math.ceil(1.2)` → 2
    #[test]
    fn e2e_math_ceil() {
        let result = global_eval("Math.ceil(1.2)").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Math.round(1.5)` → 2
    #[test]
    fn e2e_math_round() {
        let result = global_eval("Math.round(1.5)").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Math.abs(-5)` → 5
    #[test]
    fn e2e_math_abs() {
        let result = global_eval("Math.abs(-5)").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// `Math.PI` ≈ 3.14159
    #[test]
    fn e2e_math_pi() {
        let result = global_eval("Math.PI").unwrap();
        if let JsValue::HeapNumber(n) = result {
            assert!((n - std::f64::consts::PI).abs() < 1e-10);
        } else {
            panic!("Expected HeapNumber, got {result:?}");
        }
    }

    /// `Math.sqrt(16)` → 4
    #[test]
    fn e2e_math_sqrt() {
        let result = global_eval("Math.sqrt(16)").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `Math.max(1, 3, 2)` → 3
    #[test]
    fn e2e_math_max() {
        let result = global_eval("Math.max(1, 3, 2)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Math.min(1, 3, 2)` → 1
    #[test]
    fn e2e_math_min() {
        let result = global_eval("Math.min(1, 3, 2)").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Math.pow(2, 10)` → 1024
    #[test]
    fn e2e_math_pow() {
        let result = global_eval("Math.pow(2, 10)").unwrap();
        assert_eq!(result, JsValue::Smi(1024));
    }

    /// `parseInt("42")` → 42
    #[test]
    fn e2e_parse_int() {
        let result = global_eval("parseInt(\"42\")").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `parseFloat("3.14")` → 3.14
    #[test]
    fn e2e_parse_float() {
        let result = global_eval("parseFloat(\"3.14\")").unwrap();
        assert_eq!(result, JsValue::HeapNumber(3.14));
    }

    /// `isNaN(NaN)` → true
    #[test]
    fn e2e_is_nan_true() {
        let result = global_eval("isNaN(NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `isNaN(42)` → false
    #[test]
    fn e2e_is_nan_false() {
        let result = global_eval("isNaN(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `isFinite(42)` → true
    #[test]
    fn e2e_is_finite_true() {
        let result = global_eval("isFinite(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `isFinite(Infinity)` → false
    #[test]
    fn e2e_is_finite_false() {
        let result = global_eval("isFinite(Infinity)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `console.log("hello")` returns undefined without crashing.
    #[test]
    fn e2e_console_log() {
        let result = global_eval("console.log(\"hello\")").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `typeof undefined` → "undefined"
    #[test]
    fn e2e_typeof_undefined() {
        let result = global_eval("typeof undefined").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    /// `JSON.stringify({})` is available (returns the stringified result).
    /// Note: PlainObject serialization produces property-level entries now.
    #[test]
    fn e2e_json_parse() {
        let result = global_eval("JSON.parse(\"42\")").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_with_statement_reads_object_binding() {
        let result = global_eval("var obj = { prop: 42 }; with (obj) { prop }").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_with_statement_strict_mode_is_syntax_error() {
        let result = global_eval("\"use strict\"; with ({ prop: 1 }) { prop }").unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    fn e2e_labelled_block_break_exits_block() {
        let result =
            global_eval("var value = 0; label: { value = 1; break label; value = 2; } value")
                .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_nested_labels_continue_outer_loop() {
        let result = global_eval(
            "var hits = 0; outer: inner: for (var i = 0; i < 3; i++) { hits = hits + 1; continue outer; } hits",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_comma_operator_returns_last_value() {
        let result = global_eval("(1, 2, 3)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_comma_operator_in_for_headers() {
        let result = global_eval(
            "var total = 0; for (var i = 0, j = 0; i < 3; i++, j = j + 2) { total = total + j; } total",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    #[test]
    fn e2e_asi_return_newline_returns_undefined() {
        let result = global_eval("(function () { return\n1; })()").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_asi_return_newline_before_object_returns_undefined() {
        let result = global_eval("(function () { return\n{ value: 1 }; })()").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_asi_return_newline_before_parenthesized_expr_returns_undefined() {
        let result = global_eval("(function () { return\n(1 + 2); })()").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_asi_return_same_line_keeps_expression() {
        let result = global_eval("(function () { return 1\n+ 2; })()").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_asi_throw_newline_is_syntax_error() {
        assert_eval_syntax_error("(function () { throw\n1; })()");
    }

    #[test]
    fn e2e_asi_throw_newline_at_top_level_is_syntax_error() {
        assert_eval_syntax_error("throw\n1");
    }

    #[test]
    fn e2e_throw_same_line_still_throws_value() {
        let result = global_eval("try { throw 7; } catch (e) { e; }").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_asi_break_newline_label_is_syntax_error() {
        assert_eval_syntax_error("label: { break\nlabel; }");
    }

    #[test]
    fn e2e_asi_break_newline_in_loop_ignores_label() {
        let result = global_eval(
            "function f() { outer: while (true) { break\nouter; return 0; } return 1; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_asi_continue_newline_ignores_label() {
        let result = global_eval(
            "function f() { var hits = 0; outer: for (var i = 0; i < 3; i++) { hits = hits + 1; continue\nouter; hits = hits + 100; } return hits; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_asi_continue_newline_label_outside_loop_is_syntax_error() {
        assert_eval_syntax_error("label: { continue\nlabel; }");
    }

    #[test]
    fn e2e_continue_same_line_still_uses_label() {
        let result = global_eval(
            "function f() { var hits = 0; outer: for (var i = 0; i < 2; i++) { inner: for (var j = 0; j < 2; j++) { hits = hits + 1; continue outer; } hits = hits + 100; } return hits; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_asi_postfix_increment_newline_becomes_prefix_on_next_identifier() {
        let result = global_eval("var a = 1; var b = 10; a\n++\nb; a * 100 + b").unwrap();
        assert_eq!(result, JsValue::Smi(111));
    }

    #[test]
    fn e2e_asi_postfix_decrement_newline_becomes_prefix_on_next_identifier() {
        let result = global_eval("var a = 10; var b = 3; a\n--\nb; a * 100 + b").unwrap();
        assert_eq!(result, JsValue::Smi(1002));
    }

    #[test]
    fn e2e_postfix_increment_same_line_still_updates_left_operand() {
        let result = global_eval("var a = 1; var b = a++; a * 10 + b").unwrap();
        assert_eq!(result, JsValue::Smi(21));
    }

    #[test]
    fn e2e_postfix_decrement_same_line_still_updates_left_operand() {
        let result = global_eval("var a = 3; var b = a--; a * 10 + b").unwrap();
        assert_eq!(result, JsValue::Smi(23));
    }

    #[test]
    fn e2e_no_asi_before_left_paren_parses_call() {
        let result = global_eval("function a(x) { return x + 1; }\na\n(2)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_no_asi_before_left_paren_parses_multiline_call_args() {
        let result = global_eval("function add(a, b) { return a + b; }\nadd\n(1,\n2)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_no_asi_before_left_paren_on_function_expression() {
        let result =
            global_eval("var fnValue = function (x) { return x * 2; };\nfnValue\n(4)").unwrap();
        assert_eq!(result, JsValue::Smi(8));
    }

    #[test]
    fn e2e_no_asi_before_left_bracket_parses_property_access() {
        let result = global_eval("var a = { x: 7 }; var b = 'x'; a\n[b]").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_no_asi_before_left_bracket_parses_array_index() {
        let result = global_eval("var a = [9]; var b = 0; a\n[b]").unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    fn e2e_no_asi_before_left_bracket_allows_chained_access() {
        let result = global_eval("var a = [[5]]; a\n[0]\n[0]").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    fn e2e_no_asi_before_template_parses_tagged_template() {
        let result =
            global_eval("function tag(strings) { return 'tag:' + strings[0]; }\ntag\n`b`").unwrap();
        assert_eq!(result, JsValue::String("tag:b".into()));
    }

    #[test]
    fn e2e_no_asi_before_template_preserves_substitutions() {
        let result = global_eval(
            "function tag(strings, value) { return 'tag:' + strings[0] + value + strings[1]; } var a = 5; tag\n`x${a}y`",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("tag:x5y".into()));
    }

    #[test]
    fn e2e_no_asi_before_template_on_member_tag() {
        let result = global_eval(
            "var obj = {}; obj.tag = function (strings) { return 'member:' + strings[0]; }; obj.tag\n`z`",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("member:z".into()));
    }

    #[test]
    fn e2e_for_header_missing_first_semicolon_after_newline_is_syntax_error() {
        assert_eval_syntax_error("for (var i = 0\n i < 1; i++) {}");
    }

    #[test]
    fn e2e_for_header_missing_second_semicolon_after_newline_is_syntax_error() {
        assert_eval_syntax_error("for (var i = 0; i < 1\n i++) {}");
    }

    #[test]
    fn e2e_for_header_newlines_do_not_insert_semicolons() {
        let result =
            global_eval("var hits = 0; for (var i = 0\n; i < 3\n; i++) { hits = hits + 1; } hits")
                .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_for_header_multiline_empty_clauses_still_parse() {
        let result =
            global_eval("var hits = 0; for (\n;\n hits < 2\n;\n hits = hits + 1\n) {} hits")
                .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_do_while_allows_asi_after_while_clause() {
        let result = global_eval(
            "function f() { var hits = 0; do { hits = hits + 1; } while (false)\nreturn hits; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_do_while_explicit_semicolon_still_works() {
        let result = global_eval(
            "function f() { var hits = 0; do { hits = hits + 1; } while (false); return hits; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_do_while_condition_spans_newlines_without_asi_inside() {
        let result = global_eval(
            "function f() { var hits = 0; do { hits = hits + 1; } while (\nfalse\n)\nreturn hits; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_empty_statements_are_valid() {
        let result = global_eval(";;; 7").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_empty_statements_inside_function_are_valid() {
        let result = global_eval("function f() { ;;; return 7; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_empty_statement_can_be_if_branch() {
        let result = global_eval("if (true) ; 9").unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    fn e2e_empty_statement_can_be_else_branch() {
        let result = global_eval("if (false) ; else ; 11").unwrap();
        assert_eq!(result, JsValue::Smi(11));
    }

    #[test]
    fn e2e_empty_statement_can_be_loop_body() {
        let result = global_eval("var hits = 0; for (var i = 0; i < 3; i++) ; hits").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    #[test]
    fn e2e_debugger_statement_is_noop() {
        let result = global_eval("debugger; 7").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    // ── JSON Phase 2: stringify with space ──────────────────────────────────

    #[test]
    fn e2e_json_stringify_with_space() {
        use crate::builtins::json::{JsonSpace, JsonValue, json_stringify};
        use std::cell::RefCell;
        use std::rc::Rc;

        let obj = JsonValue::Object(Rc::new(RefCell::new(vec![(
            "x".to_string(),
            JsonValue::Number(1.0),
        )])));
        let s = json_stringify(&obj, None, Some(&JsonSpace::Count(2)), None)
            .unwrap()
            .unwrap();
        assert_eq!(s, "{\n  \"x\": 1\n}");
    }

    // ── JSON Phase 2: stringify replacer function ───────────────────────────

    #[test]
    fn e2e_json_stringify_replacer_fn() {
        use crate::builtins::json::{JsonReplacer, JsonValue, json_stringify};
        use std::cell::RefCell;
        use std::rc::Rc;

        let obj = JsonValue::Object(Rc::new(RefCell::new(vec![
            ("a".to_string(), JsonValue::Number(1.0)),
            ("b".to_string(), JsonValue::Number(2.0)),
        ])));
        let replacer = JsonReplacer::Function(&|key, val| {
            if key == "b" {
                Ok(None)
            } else {
                Ok(Some(val.clone()))
            }
        });
        let s = json_stringify(&obj, Some(&replacer), None, None)
            .unwrap()
            .unwrap();
        assert_eq!(s, r#"{"a":1}"#);
    }

    // ── JSON Phase 2: stringify NaN / Infinity → null ───────────────────────

    #[test]
    fn e2e_json_stringify_nan_infinity() {
        use crate::builtins::json::json_stringify_js_value;

        let s = json_stringify_js_value(&JsValue::HeapNumber(f64::NAN), None, None)
            .unwrap()
            .unwrap();
        assert_eq!(s, "null");

        let s = json_stringify_js_value(&JsValue::HeapNumber(f64::INFINITY), None, None)
            .unwrap()
            .unwrap();
        assert_eq!(s, "null");
    }

    // ── JSON Phase 2: stringify BigInt → TypeError ──────────────────────────

    #[test]
    fn e2e_json_stringify_bigint_error() {
        use crate::builtins::json::json_stringify_js_value;

        let result = json_stringify_js_value(&JsValue::BigInt(Box::new(42)), None, None);
        assert!(result.is_err());
    }

    // ── JSON Phase 2: parse reviver ─────────────────────────────────────────

    #[test]
    fn e2e_json_parse_reviver() {
        use crate::builtins::json::{JsonValue, json_parse};

        let v = json_parse(
            "[1, 2, 3]",
            Some(&|_key, val| {
                Ok(Some(match val {
                    JsonValue::Number(n) => JsonValue::Number(n * 10.0),
                    other => other,
                }))
            }),
        )
        .unwrap();
        if let JsonValue::Array(arr) = &v {
            let b = arr.borrow();
            assert_eq!(b[0], JsonValue::Number(10.0));
            assert_eq!(b[1], JsonValue::Number(20.0));
            assert_eq!(b[2], JsonValue::Number(30.0));
        } else {
            panic!("expected array");
        }
    }

    // ── JSON Phase 2: stringify toJSON method ───────────────────────────────

    #[test]
    fn e2e_json_stringify_to_json_method() {
        use crate::builtins::json::json_stringify_js_value;
        use std::cell::RefCell;
        use std::rc::Rc;

        // Build a PlainObject with a toJSON method.
        let mut inner = PropertyMap::new();
        inner.insert("value".into(), JsValue::Smi(42));
        inner.insert(
            "toJSON".into(),
            JsValue::NativeFunction(Rc::new(|_args| {
                Ok(JsValue::String("custom-serialized".into()))
            })),
        );
        let obj = JsValue::PlainObject(Rc::new(RefCell::new(inner)));

        let s = json_stringify_js_value(&obj, None, None).unwrap().unwrap();
        assert_eq!(s, r#""custom-serialized""#);
    }

    // ── JSON Phase 2: apply_js_reviver ──────────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_apply_js_reviver_doubles_numbers() {
        use crate::builtins::json::json_parse;
        use std::rc::Rc;

        let json_val = json_parse("[1, 2, 3]", None).unwrap();
        let js_val = json_value_to_js_value(&json_val);

        let reviver = JsValue::NativeFunction(Rc::new(|args| {
            let val = args.get(1).cloned().unwrap_or(JsValue::Undefined);
            match val {
                JsValue::Smi(n) => Ok(JsValue::Smi(n * 2)),
                other => Ok(other),
            }
        }));

        let mut wrapper = PropertyMap::new();
        wrapper.insert(String::new(), js_val);
        let wrapper = JsValue::PlainObject(Rc::new(RefCell::new(wrapper)));
        let result = apply_js_reviver(&wrapper, "", &reviver).unwrap();
        // The top-level array itself is passed through the reviver too,
        // so the result should be the array (reviver returns it unchanged).
        if let JsValue::Array(arr) = result {
            assert_eq!(arr.borrow()[0], JsValue::Smi(2));
            assert_eq!(arr.borrow()[1], JsValue::Smi(4));
            assert_eq!(arr.borrow()[2], JsValue::Smi(6));
        } else {
            panic!("expected array, got {result:?}");
        }
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_apply_js_reviver_removes_undefined() {
        use crate::builtins::json::json_parse;
        use std::rc::Rc;

        let json_val = json_parse(r#"{"a":1,"b":2,"c":3}"#, None).unwrap();
        let js_val = json_value_to_js_value(&json_val);

        // Remove "b" by returning undefined
        let reviver = JsValue::NativeFunction(Rc::new(|args| {
            let key = args.first().cloned().unwrap_or(JsValue::Undefined);
            let val = args.get(1).cloned().unwrap_or(JsValue::Undefined);
            if key == JsValue::String("b".into()) {
                Ok(JsValue::Undefined)
            } else {
                Ok(val)
            }
        }));

        let mut wrapper = PropertyMap::new();
        wrapper.insert(String::new(), js_val);
        let wrapper = JsValue::PlainObject(Rc::new(RefCell::new(wrapper)));
        let result = apply_js_reviver(&wrapper, "", &reviver).unwrap();
        if let JsValue::PlainObject(map) = result {
            let m = map.borrow();
            assert!(m.contains_key("a"));
            assert!(!m.contains_key("b"), "key 'b' should be removed");
            assert!(m.contains_key("c"));
        } else {
            panic!("expected PlainObject");
        }
    }

    /// `Array.isArray` is accessible on the global `Array` object.
    #[test]
    fn e2e_array_is_array_false() {
        let result = global_eval("Array.isArray(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_array_is_array_true_for_literal() {
        let result = global_eval("Array.isArray([])").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_array_is_array_true_for_constructor() {
        let result = global_eval("Array.isArray(new Array())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_array_is_array_false_for_plain_object() {
        let result = global_eval("Array.isArray({})").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_array_is_array_true_for_array_prototype() {
        let result = global_eval("Array.isArray(Array.prototype)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.isInteger(5)` → true
    #[test]
    fn e2e_number_is_integer() {
        let result = global_eval("Number.isInteger(5)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `NaN` global constant is accessible and is NaN.
    #[test]
    fn e2e_nan_global() {
        let result = global_eval("NaN").unwrap();
        if let JsValue::HeapNumber(n) = result {
            assert!(n.is_nan());
        } else {
            panic!("Expected HeapNumber, got {result:?}");
        }
    }

    /// `Infinity` global constant is accessible.
    #[test]
    fn e2e_infinity_global() {
        let result = global_eval("Infinity").unwrap();
        assert_eq!(result, JsValue::HeapNumber(f64::INFINITY));
    }

    /// `Math.trunc(4.7)` → 4
    #[test]
    fn e2e_math_trunc() {
        let result = global_eval("Math.trunc(4.7)").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `Math.sign(-5)` → -1
    #[test]
    fn e2e_math_sign() {
        let result = global_eval("Math.sign(-5)").unwrap();
        assert_eq!(result, JsValue::Smi(-1));
    }

    // ── Symbol tests ───────────────────────────────────────────────────────

    /// `Symbol` is available as a global.
    #[test]
    fn test_symbol_global_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(
            globals.get("Symbol"),
            Some(JsValue::PlainObject(_))
        ));
    }

    /// The `Symbol` object has well-known symbol properties.
    #[test]
    fn test_symbol_well_known_properties() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let map = map.borrow();
            assert!(matches!(map.get("iterator"), Some(JsValue::Symbol(_))));
            assert!(matches!(map.get("toPrimitive"), Some(JsValue::Symbol(_))));
            assert!(matches!(map.get("hasInstance"), Some(JsValue::Symbol(_))));
            assert!(matches!(map.get("toStringTag"), Some(JsValue::Symbol(_))));
            assert!(matches!(map.get("asyncIterator"), Some(JsValue::Symbol(_))));
            assert!(matches!(map.get("species"), Some(JsValue::Symbol(_))));
        } else {
            panic!("Symbol should be a PlainObject");
        }
    }

    /// The `Symbol` object has `for` and `keyFor` methods.
    #[test]
    fn test_symbol_static_methods() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let map = map.borrow();
            assert!(matches!(map.get("for"), Some(JsValue::NativeFunction(_))));
            assert!(matches!(
                map.get("keyFor"),
                Some(JsValue::NativeFunction(_))
            ));
            assert!(matches!(
                map.get("__call__"),
                Some(JsValue::NativeFunction(_))
            ));
        } else {
            panic!("Symbol should be a PlainObject");
        }
    }

    /// Calling `Symbol()` via __call__ produces a unique symbol.
    #[test]
    fn test_symbol_call_produces_unique() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let call = map.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let s1 = f(vec![]).unwrap();
                let s2 = f(vec![]).unwrap();
                assert!(matches!(s1, JsValue::Symbol(_)));
                assert!(matches!(s2, JsValue::Symbol(_)));
                assert_ne!(s1, s2);
            } else {
                panic!("__call__ should be NativeFunction");
            }
        }
    }

    /// `Symbol.for("key")` returns the same symbol for the same key.
    #[test]
    fn test_symbol_for_same_key() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let for_fn = map.borrow().get("for").cloned().unwrap();
            if let JsValue::NativeFunction(f) = for_fn {
                let s1 = f(vec![JsValue::String("shared".into())]).unwrap();
                let s2 = f(vec![JsValue::String("shared".into())]).unwrap();
                assert_eq!(s1, s2);
            } else {
                panic!("for should be NativeFunction");
            }
        }
    }

    /// `Symbol.keyFor` returns the key for a registry symbol.
    #[test]
    fn test_symbol_key_for() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let for_fn = map.borrow().get("for").cloned().unwrap();
            let key_for_fn = map.borrow().get("keyFor").cloned().unwrap();
            if let (JsValue::NativeFunction(for_f), JsValue::NativeFunction(key_for_f)) =
                (for_fn, key_for_fn)
            {
                let s = for_f(vec![JsValue::String("testKey".into())]).unwrap();
                let key = key_for_f(vec![s]).unwrap();
                assert_eq!(key, JsValue::String("testKey".into()));
            }
        }
    }

    /// `Symbol.keyFor` returns `undefined` for non-registry symbols.
    #[test]
    fn test_symbol_key_for_non_registry() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let call_fn = map.borrow().get("__call__").cloned().unwrap();
            let key_for_fn = map.borrow().get("keyFor").cloned().unwrap();
            if let (JsValue::NativeFunction(call_f), JsValue::NativeFunction(key_for_f)) =
                (call_fn, key_for_fn)
            {
                let s = call_f(vec![JsValue::String("desc".into())]).unwrap();
                let key = key_for_f(vec![s]).unwrap();
                assert_eq!(key, JsValue::Undefined);
            }
        }
    }

    /// `typeof Symbol()` → "symbol"  (end-to-end).
    #[test]
    fn e2e_typeof_symbol() {
        let result = global_eval("typeof Symbol()").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `Symbol() !== Symbol()` — each call produces a unique symbol.
    #[test]
    fn e2e_symbol_unique() {
        let result = global_eval("Symbol() === Symbol()").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Symbol.for("x") === Symbol.for("x")` — registry returns same symbol.
    #[test]
    fn e2e_symbol_for_same() {
        let result = global_eval(r#"Symbol.for("x") === Symbol.for("x")"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Well-known `Symbol.iterator` is a symbol value.
    #[test]
    fn e2e_typeof_symbol_iterator() {
        let result = global_eval("typeof Symbol.iterator").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    // ── Symbol.prototype.description tests ──────────────────────────────

    /// `Symbol("foo").description` → "foo"
    #[test]
    fn e2e_symbol_description_with_value() {
        let result = global_eval(r#"Symbol("foo").description"#).unwrap();
        assert_eq!(result, JsValue::String("foo".into()));
    }

    /// `Symbol().description` → undefined
    #[test]
    fn e2e_symbol_description_undefined() {
        let result = global_eval("Symbol().description").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `Symbol("").description` → ""
    #[test]
    fn e2e_symbol_description_empty_string() {
        let result = global_eval(r#"Symbol("").description"#).unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    /// Well-known `Symbol.iterator.description` → "Symbol.iterator"
    #[test]
    fn e2e_symbol_iterator_description() {
        let result = global_eval("Symbol.iterator.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.iterator".into()));
    }

    /// `Symbol.toPrimitive.description` → "Symbol.toPrimitive"
    #[test]
    fn e2e_symbol_to_primitive_description() {
        let result = global_eval("Symbol.toPrimitive.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.toPrimitive".into()));
    }

    /// `Symbol.hasInstance.description` → "Symbol.hasInstance"
    #[test]
    fn e2e_symbol_has_instance_description() {
        let result = global_eval("Symbol.hasInstance.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.hasInstance".into()));
    }

    /// `Symbol.toStringTag.description` → "Symbol.toStringTag"
    #[test]
    fn e2e_symbol_to_string_tag_description() {
        let result = global_eval("Symbol.toStringTag.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.toStringTag".into()));
    }

    /// `Symbol.species.description` → "Symbol.species"
    #[test]
    fn e2e_symbol_species_description() {
        let result = global_eval("Symbol.species.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.species".into()));
    }

    /// `Symbol.isConcatSpreadable.description` → "Symbol.isConcatSpreadable"
    #[test]
    fn e2e_symbol_is_concat_spreadable_description() {
        let result = global_eval("Symbol.isConcatSpreadable.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.isConcatSpreadable".into()));
    }

    /// `Symbol.match.description` → "Symbol.match"
    #[test]
    fn e2e_symbol_match_description() {
        let result = global_eval("Symbol.match.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.match".into()));
    }

    /// `Symbol.replace.description` → "Symbol.replace"
    #[test]
    fn e2e_symbol_replace_description() {
        let result = global_eval("Symbol.replace.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.replace".into()));
    }

    /// `Symbol.search.description` → "Symbol.search"
    #[test]
    fn e2e_symbol_search_description() {
        let result = global_eval("Symbol.search.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.search".into()));
    }

    /// `Symbol.split.description` → "Symbol.split"
    #[test]
    fn e2e_symbol_split_description() {
        let result = global_eval("Symbol.split.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.split".into()));
    }

    /// `Symbol.unscopables.description` → "Symbol.unscopables"
    #[test]
    fn e2e_symbol_unscopables_description() {
        let result = global_eval("Symbol.unscopables.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.unscopables".into()));
    }

    /// `Symbol.asyncIterator.description` → "Symbol.asyncIterator"
    #[test]
    fn e2e_symbol_async_iterator_description() {
        let result = global_eval("Symbol.asyncIterator.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.asyncIterator".into()));
    }

    /// `Symbol.matchAll.description` → "Symbol.matchAll"
    #[test]
    fn e2e_symbol_match_all_description() {
        let result = global_eval("Symbol.matchAll.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.matchAll".into()));
    }

    /// `Symbol.prototype.description` is exposed as an accessor property.
    #[test]
    fn e2e_symbol_description_descriptor_is_accessor() {
        assert_eval_true(
            r#"
            var desc = Object.getOwnPropertyDescriptor(Symbol.prototype, "description");
            typeof desc.get === "function" &&
            desc.set === undefined &&
            desc.enumerable === false &&
            desc.configurable === true
            "#,
        );
    }

    /// `Object(Symbol("foo")).description` uses the wrapper receiver.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_wrapper_description_with_value() {
        let result = global_eval(r#"Object(Symbol("foo")).description"#).unwrap();
        assert_eq!(result, JsValue::String("foo".into()));
    }

    /// `Object(Symbol()).description` returns `undefined`.
    #[test]
    fn e2e_symbol_wrapper_description_undefined() {
        let result = global_eval("Object(Symbol()).description").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    // ── Symbol.prototype.toString tests ─────────────────────────────────

    /// `Symbol("foo").toString()` → "Symbol(foo)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_string_with_desc() {
        let result = global_eval(r#"Symbol("foo").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("Symbol(foo)".into()));
    }

    /// `Symbol().toString()` → "Symbol()"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_string_no_desc() {
        let result = global_eval("Symbol().toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol()".into()));
    }

    /// `typeof Symbol("x").toString()` → "string"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_string_is_string() {
        let result = global_eval(r#"typeof Symbol("x").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("string".into()));
    }

    // ── Symbol.prototype.valueOf tests ──────────────────────────────────

    /// `typeof Symbol("x").valueOf()` → "symbol"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_value_of_is_symbol() {
        let result = global_eval(r#"typeof Symbol("x").valueOf()"#).unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `Symbol.iterator.valueOf() === Symbol.iterator`
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_value_of_identity() {
        let result = global_eval("Symbol.iterator.valueOf() === Symbol.iterator").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object(Symbol("x"))` inherits from `Symbol.prototype`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_wrapper_has_symbol_prototype() {
        assert_eval_true(r#"Object.getPrototypeOf(Object(Symbol("x"))) === Symbol.prototype"#);
    }

    /// `Object(Symbol("x")).toString()` uses `Symbol.prototype.toString`.
    #[test]
    fn e2e_symbol_wrapper_to_string_with_desc() {
        let result = global_eval(r#"Object(Symbol("x")).toString()"#).unwrap();
        assert_eq!(result, JsValue::String("Symbol(x)".into()));
    }

    /// `Object(Symbol()).toString()` preserves the empty description form.
    #[test]
    fn e2e_symbol_wrapper_to_string_without_desc() {
        let result = global_eval("Object(Symbol()).toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol()".into()));
    }

    /// `Object(Symbol("x")).valueOf()` unwraps back to the symbol primitive.
    #[test]
    fn e2e_symbol_wrapper_value_of_returns_symbol() {
        assert_eval_true(
            r#"
            var s = Symbol("x");
            Object(s).valueOf() === s
            "#,
        );
    }

    /// `Symbol.prototype.toString` accepts boxed symbol receivers.
    #[test]
    fn e2e_symbol_prototype_to_string_accepts_wrapper() {
        let result = global_eval(r#"Symbol.prototype.toString.call(Object(Symbol("x")))"#).unwrap();
        assert_eq!(result, JsValue::String("Symbol(x)".into()));
    }

    /// `Symbol.prototype.valueOf` accepts boxed symbol receivers.
    #[test]
    fn e2e_symbol_prototype_value_of_accepts_wrapper() {
        assert_eval_true(
            r#"
            var s = Symbol("x");
            Symbol.prototype.valueOf.call(Object(s)) === s
            "#,
        );
    }

    // ── Symbol as property key tests ────────────────────────────────────

    /// Symbols can be used as property keys on objects.
    #[test]
    fn e2e_symbol_as_property_key() {
        let result = global_eval(
            r#"
            var s = Symbol("myKey");
            var obj = {};
            obj[s] = 42;
            obj[s]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Different symbols produce different property keys.
    #[test]
    fn e2e_symbol_different_keys() {
        let result = global_eval(
            r#"
            var s1 = Symbol("a");
            var s2 = Symbol("a");
            var obj = {};
            obj[s1] = 1;
            obj[s2] = 2;
            obj[s1]
            "#,
        )
        .unwrap();
        // s1 and s2 are different symbols despite same description,
        // so they produce different property keys.
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Symbol.for` symbol as property key is shared.
    #[test]
    fn e2e_symbol_for_as_property_key() {
        let result = global_eval(
            r#"
            var obj = {};
            obj[Symbol.for("shared")] = 99;
            obj[Symbol.for("shared")]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// Well-known symbol as property key.
    #[test]
    fn e2e_well_known_symbol_as_property_key() {
        let result = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = "iter";
            obj[Symbol.iterator]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("iter".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_key_distinct_from_string_key() {
        let result = global_eval(
            r#"
            var s = Symbol("x");
            var obj = {};
            obj[s] = 1;
            obj[s.toString()] = 2;
            obj[s] === 1 && obj[s.toString()] === 2
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_symbol_key_distinct_from_description_key() {
        let result = global_eval(
            r#"
            var s = Symbol("token");
            var obj = {};
            obj[s] = 1;
            obj["token"] = 2;
            obj[s] === 1 && obj["token"] === 2
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_object_get_own_property_symbols_returns_user_symbol() {
        let result = global_eval(
            r#"
            var s = Symbol("only");
            var obj = {};
            obj[s] = 1;
            var syms = Object.getOwnPropertySymbols(obj);
            syms.length === 1 && syms[0] === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_object_get_own_property_symbols_preserves_insertion_order() {
        let result = global_eval(
            r#"
            var a = Symbol("a");
            var b = Symbol("b");
            var obj = {};
            obj[b] = 2;
            obj[a] = 1;
            var syms = Object.getOwnPropertySymbols(obj);
            syms.length === 2 && syms[0] === b && syms[1] === a
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_object_get_own_property_symbols_includes_well_known_symbol_keys() {
        let result = global_eval(
            r#"
            var obj = {};
            obj[Symbol.toStringTag] = "Tagged";
            var syms = Object.getOwnPropertySymbols(obj);
            syms.length === 1 && syms[0] === Symbol.toStringTag
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_symbol_keys_excluded_from_object_keys() {
        let result = global_eval(
            r#"
            var s = Symbol("hidden");
            var obj = { visible: 1 };
            obj[s] = 2;
            Object.keys(obj).length === 1 && Object.keys(obj)[0] === "visible"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_symbol_keys_excluded_from_for_in() {
        let result = global_eval(
            r#"
            var s = Symbol("hidden");
            var obj = { visible: 1 };
            obj[s] = 2;
            var seen = [];
            for (var key in obj) seen.push(key);
            seen.length === 1 && seen[0] === "visible"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_object_define_property_accepts_symbol_key() {
        let result = global_eval(
            r#"
            var s = Symbol("dp");
            var obj = {};
            Object.defineProperty(obj, s, { value: 7, enumerable: true });
            obj[s] === 7 && Object.getOwnPropertySymbols(obj)[0] === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_object_get_own_property_descriptor_accepts_symbol_key() {
        let result = global_eval(
            r#"
            var s = Symbol("desc");
            var obj = {};
            Object.defineProperty(obj, s, { value: 11, enumerable: true, configurable: true });
            Object.getOwnPropertyDescriptor(obj, s).value === 11
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_has_own_property_accepts_symbol_key() {
        let result = global_eval(
            r#"
            var s = Symbol("own");
            var obj = {};
            obj[s] = 1;
            Object.prototype.hasOwnProperty.call(obj, s)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_property_is_enumerable_accepts_symbol_key() {
        let result = global_eval(
            r#"
            var s = Symbol("enum");
            var obj = {};
            Object.defineProperty(obj, s, { value: 1, enumerable: true });
            Object.prototype.propertyIsEnumerable.call(obj, s)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_symbol_to_primitive_number_hint() {
        let result = global_eval(
            r#"
            var hint;
            var obj = { [Symbol.toPrimitive](h) { hint = h; return 7; } };
            Number(obj) === 7 && hint === "number"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_symbol_to_primitive_string_hint() {
        let result = global_eval(
            r#"
            var hint;
            var obj = { [Symbol.toPrimitive](h) { hint = h; return "value"; } };
            String(obj) === "value" && hint === "string"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_symbol_to_primitive_default_hint() {
        let result = global_eval(
            r#"
            var hint;
            var obj = { [Symbol.toPrimitive](h) { hint = h; return "default"; } };
            obj + "" === "default" && hint === "default"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_symbol_to_primitive_non_primitive_throws() {
        let result = global_eval(
            r#"
            var obj = { [Symbol.toPrimitive]() { return {}; } };
            try { Number(obj); false; } catch (e) { e instanceof TypeError; }
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    macro_rules! coercion_e2e_test {
        ($(#[$meta:meta])* $name:ident, $script:expr) => {
            $(#[$meta])*
            #[test]
            fn $name() {
                assert_eval_true($script);
            }
        };
    }

    macro_rules! coercion_type_error_test {
        ($(#[$meta:meta])* $name:ident, $script:expr) => {
            $(#[$meta])*
            #[test]
            fn $name() {
                assert_eval_type_error($script);
            }
        };
    }

    // ── Type coercion and typeof conformance ─────────────────────────────

    coercion_e2e_test!(
        e2e_typeof_undefined_conforms,
        "typeof undefined === 'undefined'"
    );
    coercion_e2e_test!(e2e_typeof_null_conforms, "typeof null === 'object'");
    coercion_e2e_test!(e2e_typeof_boolean_conforms, "typeof false === 'boolean'");
    coercion_e2e_test!(e2e_typeof_number_conforms, "typeof 1 === 'number'");
    coercion_e2e_test!(e2e_typeof_string_conforms, "typeof 'stator' === 'string'");
    coercion_e2e_test!(
        e2e_typeof_symbol_conforms,
        "typeof Symbol('x') === 'symbol'"
    );
    coercion_e2e_test!(
        e2e_typeof_function_expression_conforms,
        "typeof function () {} === 'function'"
    );
    coercion_e2e_test!(
        e2e_typeof_object_literal_conforms,
        "typeof ({}) === 'object'"
    );
    coercion_e2e_test!(
        e2e_abstract_equality_null_and_undefined,
        "null == undefined && undefined == null"
    );
    coercion_e2e_test!(e2e_abstract_equality_string_number, "'42' == 42");
    coercion_e2e_test!(
        e2e_abstract_equality_binary_string_number,
        "'0b101' == 5 && '0o10' == 8"
    );
    coercion_e2e_test!(
        e2e_abstract_equality_object_uses_value_of,
        "({ valueOf() { return 7; } }) == 7"
    );
    coercion_e2e_test!(
        e2e_abstract_equality_object_falls_back_to_to_string,
        "({ valueOf() { return {}; }, toString() { return '9'; } }) == 9"
    );
    coercion_e2e_test!(
        e2e_to_primitive_prefers_symbol_to_primitive_for_number,
        "Number({ [Symbol.toPrimitive]() { return 11; }, valueOf() { return 1; } }) === 11"
    );
    coercion_e2e_test!(
        e2e_to_primitive_prefers_symbol_to_primitive_for_string,
        "String({ [Symbol.toPrimitive]() { return 'symbol-first'; }, toString() { return 'nope'; } }) === 'symbol-first'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_string_hint_prefers_to_string,
        "String({ toString() { return 'text'; }, valueOf() { return 1; } }) === 'text'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_string_hint_falls_back_to_value_of,
        "String({ toString() { return {}; }, valueOf() { return 7; } }) === '7'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_number_hint_prefers_value_of,
        "Number({ valueOf() { return '12'; }, toString() { return '99'; } }) === 12"
    );
    coercion_e2e_test!(
        e2e_to_primitive_number_hint_falls_back_to_to_string,
        "Number({ valueOf() { return {}; }, toString() { return '13'; } }) === 13"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_inherited_symbol_to_primitive_for_number,
        "var proto = { [Symbol.toPrimitive](hint) { return hint === 'number' ? 14 : 'bad'; } }; Number(Object.create(proto)) === 14"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_inherited_symbol_to_primitive_for_string,
        "var proto = { [Symbol.toPrimitive](hint) { return hint; } }; String(Object.create(proto)) === 'string'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_symbol_override_skips_value_of_and_to_string_for_number,
        "var log = ''; Number({ [Symbol.toPrimitive]() { log += 'p'; return 15; }, valueOf() { log += 'v'; return 1; }, toString() { log += 't'; return '2'; } }) === 15 && log === 'p'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_symbol_override_skips_value_of_and_to_string_for_string,
        "var log = ''; String({ [Symbol.toPrimitive]() { log += 'p'; return 'ok'; }, valueOf() { log += 'v'; return 1; }, toString() { log += 't'; return 'no'; } }) === 'ok' && log === 'p'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_number_hint_observable_order,
        "var log = ''; Number({ valueOf() { log += 'v'; return {}; }, toString() { log += 't'; return '16'; } }) === 16 && log === 'vt'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_string_hint_observable_order,
        "var log = ''; String({ toString() { log += 't'; return {}; }, valueOf() { log += 'v'; return 17; } }) === '17' && log === 'tv'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_plus_default_uses_value_of_first,
        "'' + { valueOf() { return 18; }, toString() { return 99; } } === '18'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_plus_default_falls_back_to_to_string,
        "'' + { valueOf() { return {}; }, toString() { return 19; } } === '19'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_plus_default_observable_order,
        "var log = ''; '' + { valueOf() { log += 'v'; return {}; }, toString() { log += 't'; return 20; } } === '20' && log === 'vt'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_plus_default_custom_hint_visible,
        "var hint = ''; var obj = { [Symbol.toPrimitive](h) { hint = h; return 21; } }; obj + 1 === 22 && hint === 'default'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_equality_uses_default_hint_lhs,
        "var hint = ''; var obj = { [Symbol.toPrimitive](h) { hint = h; return 22; } }; obj == 22 && hint === 'default'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_equality_uses_default_hint_rhs,
        "var hint = ''; var obj = { [Symbol.toPrimitive](h) { hint = h; return 23; } }; 23 == obj && hint === 'default'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_equality_falls_back_to_to_string,
        "({ valueOf() { return {}; }, toString() { return '24'; } }) == 24"
    );
    coercion_e2e_test!(
        e2e_to_primitive_template_literal_uses_string_hint,
        "var obj = { [Symbol.toPrimitive](hint) { return hint; } }; `${obj}` === 'string'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_template_literal_skips_value_of_when_symbol_present,
        "var log = ''; var obj = { [Symbol.toPrimitive](hint) { log += hint[0]; return 'ok'; }, valueOf() { log += 'v'; return 1; }, toString() { log += 't'; return 'no'; } }; `${obj}` === 'ok' && log === 's'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_string_function_uses_string_hint,
        "var hint = ''; var obj = { [Symbol.toPrimitive](h) { hint = h; return 'done'; } }; String(obj) === 'done' && hint === 'string'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_number_function_uses_number_hint,
        "var hint = ''; var obj = { [Symbol.toPrimitive](h) { hint = h; return 25; } }; Number(obj) === 25 && hint === 'number'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_date_default_hint_is_string,
        "var d = new Date(0); d + '' === d.toString() + ''"
    );
    coercion_e2e_test!(
        e2e_to_primitive_date_number_hint_returns_time_value,
        "Number(new Date(0)) === 0"
    );
    coercion_e2e_test!(
        e2e_to_primitive_date_string_hint_returns_to_string,
        "var d = new Date(0); String(d) === d.toString()"
    );
    coercion_e2e_test!(
        e2e_to_primitive_custom_symbol_to_primitive_on_date_overrides_methods,
        "var d = new Date(0); d[Symbol.toPrimitive] = function(hint) { return hint === 'number' ? 26 : 'date'; }; Number(d) === 26 && String(d) === 'date'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_custom_symbol_to_primitive_on_array_overrides_methods,
        "var a = [1, 2]; a[Symbol.toPrimitive] = function(hint) { return hint === 'number' ? 27 : 'array'; }; Number(a) === 27 && String(a) === 'array'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_array_number_uses_to_string_fallback,
        "Number([28]) === 28"
    );
    coercion_e2e_test!(
        e2e_to_primitive_empty_array_number_is_zero,
        "Number([]) === 0"
    );
    coercion_e2e_test!(
        e2e_to_primitive_multi_element_array_number_is_nan,
        "Number.isNaN(Number([1, 2]))"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_inherited_value_of_is_used,
        "var proto = { valueOf() { return 29; } }; Number(Object.create(proto)) === 29"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_inherited_to_string_is_used,
        "var proto = { valueOf() { return {}; }, toString() { return '30'; } }; Number(Object.create(proto)) === 30"
    );
    coercion_e2e_test!(
        e2e_to_primitive_null_value_of_is_ignored,
        "Number({ valueOf: null, toString() { return '31'; } }) === 31"
    );
    coercion_e2e_test!(
        e2e_to_primitive_null_to_string_is_ignored,
        "String({ toString: null, valueOf() { return 32; } }) === '32'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_noncallable_value_of_is_ignored,
        "Number({ valueOf: 1, toString() { return '33'; } }) === 33"
    );
    coercion_e2e_test!(
        e2e_to_primitive_noncallable_to_string_is_ignored,
        "String({ toString: 1, valueOf() { return 34; } }) === '34'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_object_prototype_symbol_to_primitive_absent,
        "Object.prototype[Symbol.toPrimitive] === undefined && !Object.prototype.hasOwnProperty(Symbol.toPrimitive)"
    );
    coercion_e2e_test!(
        e2e_to_primitive_plain_object_symbol_to_primitive_absent_by_default,
        "var obj = {}; obj[Symbol.toPrimitive] === undefined && !obj.hasOwnProperty(Symbol.toPrimitive)"
    );
    coercion_e2e_test!(
        e2e_to_primitive_symbol_to_primitive_can_return_boolean,
        "var obj = { [Symbol.toPrimitive]() { return true; } }; Number(obj) === 1"
    );
    coercion_e2e_test!(
        e2e_to_primitive_symbol_to_primitive_can_return_string_for_plus,
        "var obj = { [Symbol.toPrimitive]() { return 'x'; } }; obj + 'y' === 'xy'"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_symbol_to_primitive_on_proto_overrides_own_methods,
        "var proto = { [Symbol.toPrimitive]() { return 35; } }; var obj = Object.create(proto); obj.valueOf = function() { return 1; }; obj.toString = function() { return '2'; }; Number(obj) === 35"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_symbol_to_primitive_default_on_proto_used_by_plus,
        "var proto = { [Symbol.toPrimitive](hint) { return hint === 'default' ? 36 : 0; } }; '' + Object.create(proto) === '36'"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_symbol_to_primitive_string_on_proto_used_by_template,
        "var proto = { [Symbol.toPrimitive](hint) { return hint; } }; `${Object.create(proto)}` === 'string'"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_symbol_to_primitive_number_on_proto_used_by_number,
        "var proto = { [Symbol.toPrimitive](hint) { return hint === 'number' ? 37 : 0; } }; Number(Object.create(proto)) === 37"
    );
    coercion_e2e_test!(
        e2e_to_primitive_string_hint_can_fall_back_to_numeric_primitive,
        "String({ toString() { return {}; }, valueOf() { return 38; } }) === '38'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_number_hint_can_use_string_primitive,
        "Number({ valueOf() { return '39'; }, toString() { return '0'; } }) === 39"
    );
    coercion_e2e_test!(
        e2e_to_primitive_plus_uses_value_of_without_touching_to_string,
        "var log = ''; '' + { valueOf() { log += 'v'; return 40; }, toString() { log += 't'; return 0; } } === '40' && log === 'v'"
    );
    coercion_e2e_test!(
        e2e_to_primitive_template_literal_uses_to_string_before_value_of,
        "var log = ''; `${{ toString() { log += 't'; return '41'; }, valueOf() { log += 'v'; return 0; } }}` === '41' && log === 't'"
    );
    coercion_type_error_test!(
        e2e_to_primitive_own_symbol_to_primitive_noncallable_throws,
        "Number({ [Symbol.toPrimitive]: 1 })"
    );
    coercion_type_error_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_inherited_symbol_to_primitive_noncallable_throws,
        "Number(Object.create({ [Symbol.toPrimitive]: 1 }))"
    );
    coercion_type_error_test!(
        e2e_to_primitive_number_hint_without_primitive_throws,
        "Number({ valueOf() { return {}; }, toString() { return {}; } })"
    );
    coercion_type_error_test!(
        e2e_to_primitive_string_hint_without_primitive_throws,
        "String({ toString() { return {}; }, valueOf() { return {}; } })"
    );
    coercion_type_error_test!(
        e2e_to_primitive_plus_without_primitive_throws,
        "'' + { valueOf() { return {}; }, toString() { return {}; } }"
    );
    coercion_type_error_test!(
        e2e_to_primitive_symbol_to_primitive_returning_object_throws_for_number,
        "Number({ [Symbol.toPrimitive]() { return {}; } })"
    );
    coercion_type_error_test!(
        e2e_to_primitive_symbol_to_primitive_returning_object_throws_for_string,
        "String({ [Symbol.toPrimitive]() { return {}; } })"
    );
    coercion_type_error_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_symbol_to_primitive_returning_object_throws_for_equality,
        "({ [Symbol.toPrimitive]() { return {}; } }) == 1"
    );
    coercion_type_error_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_inherited_methods_without_primitive_throw,
        "Number(Object.create({ valueOf() { return {}; }, toString() { return {}; } }))"
    );
    coercion_type_error_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_primitive_inherited_string_methods_without_primitive_throw,
        "String(Object.create({ toString() { return {}; }, valueOf() { return {}; } }))"
    );
    coercion_e2e_test!(e2e_to_number_trims_whitespace, "Number('  \\t\\n  ') === 0");
    coercion_e2e_test!(e2e_to_number_empty_string_is_zero, "Number('') === 0");
    coercion_e2e_test!(e2e_to_number_hex_literal, "Number('0x10') === 16");
    coercion_e2e_test!(e2e_to_number_octal_literal, "Number('0o10') === 8");
    coercion_e2e_test!(e2e_to_number_binary_literal, "Number('0b101') === 5");
    coercion_e2e_test!(
        e2e_to_number_invalid_string_is_nan,
        "Number.isNaN(Number('nope'))"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_to_string_symbol_converter,
        "String(Symbol('x')) === 'Symbol(x)'"
    );
    coercion_e2e_test!(
        e2e_to_string_symbol_throws_during_concatenation,
        "try { '' + Symbol('x'); false; } catch (e) { e instanceof TypeError; }"
    );
    coercion_e2e_test!(
        e2e_to_string_object_uses_to_string,
        "String({ toString() { return 'ok'; } }) === 'ok'"
    );
    coercion_e2e_test!(
        e2e_to_string_object_falls_back_to_value_of,
        "String({ toString() { return {}; }, valueOf() { return 7; } }) === '7'"
    );
    coercion_e2e_test!(
        e2e_to_boolean_falsy_primitives,
        "!false && !0 && !(-0) && !'' && !null && !undefined && !NaN"
    );
    coercion_e2e_test!(
        e2e_to_boolean_truthy_object,
        "Boolean({}) === true && !({}) === false"
    );
    coercion_e2e_test!(
        e2e_boolean_converter_conforms,
        "Boolean('value') === true && Boolean('') === false && Boolean(0) === false"
    );
    coercion_e2e_test!(
        e2e_number_converter_uses_wrapper_to_primitive,
        "Number(Object('42')) === 42 && Number(Object('0b11')) === 3"
    );
    coercion_e2e_test!(
        e2e_string_converter_uses_wrapper_to_primitive,
        "String(Object(Symbol('x'))) === 'Symbol(x)'"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_object_converter_wraps_number_primitive,
        "typeof Object(1) === 'object' && Object(1).valueOf() === 1 && Object.prototype.toString.call(Object(1)) === '[object Number]'"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_object_converter_wraps_string_primitive,
        "typeof Object('hi') === 'object' && Object('hi').toString() === 'hi' && Object.prototype.toString.call(Object('hi')) === '[object String]'"
    );
    coercion_e2e_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_object_converter_wraps_symbol_primitive,
        "typeof Object(Symbol('x')) === 'object' && String(Object(Symbol('x')).valueOf()) === 'Symbol(x)' && Object.prototype.toString.call(Object(Symbol('x'))) === '[object Symbol]'"
    );
    coercion_e2e_test!(
        e2e_object_converter_returns_object_inputs_as_is,
        "var obj = { a: 1 }; Object(obj) === obj"
    );
    coercion_e2e_test!(
        e2e_object_converter_creates_ordinary_object_for_nullish,
        "typeof Object(null) === 'object' && typeof Object(undefined) === 'object'"
    );
    coercion_e2e_test!(
        e2e_unary_plus_converts_strings,
        "+'0x10' === 16 && +'0b11' === 3"
    );
    coercion_e2e_test!(
        e2e_unary_plus_uses_object_to_primitive,
        "+{ valueOf() { return '21'; } } === 21"
    );
    coercion_e2e_test!(
        e2e_double_bitwise_not_truncates,
        "~~4.9 === 4 && ~~(-4.9) === -4"
    );
    coercion_e2e_test!(
        e2e_double_bitwise_not_zeroes_nan,
        "~~NaN === 0 && ~~(-0) === 0"
    );

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_string_tag_custom_object() {
        let result = global_eval(
            r#"
            var obj = { [Symbol.toStringTag]: "Foo" };
            Object.prototype.toString.call(obj)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("[object Foo]".into()));
    }

    #[test]
    fn e2e_symbol_to_string_tag_not_listed_in_object_keys() {
        let result = global_eval(
            r#"
            var obj = { [Symbol.toStringTag]: "Foo", visible: 1 };
            Object.keys(obj).length === 1 && Object.keys(obj)[0] === "visible"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_symbol_key_for_non_symbol_throws() {
        let result = global_eval(
            r#"
            try { Symbol.keyFor("nope"); false; } catch (e) { e instanceof TypeError; }
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Symbol.for / Symbol.keyFor e2e tests ────────────────────────────

    /// `Symbol.for("x") !== Symbol("x")` — registry symbols ≠ non-registry.
    #[test]
    fn e2e_symbol_for_not_same_as_symbol() {
        let result = global_eval(r#"Symbol.for("x") === Symbol("x")"#).unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Symbol.for` with different keys returns different symbols.
    #[test]
    fn e2e_symbol_for_different_keys() {
        let result = global_eval(r#"Symbol.for("a") === Symbol.for("b")"#).unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Symbol.keyFor(Symbol.for("test"))` → "test"
    #[test]
    fn e2e_symbol_key_for_returns_key() {
        let result = global_eval(r#"Symbol.keyFor(Symbol.for("test"))"#).unwrap();
        assert_eq!(result, JsValue::String("test".into()));
    }

    /// `Symbol.keyFor` returns undefined for non-registry symbols.
    #[test]
    fn e2e_symbol_key_for_undefined() {
        let result = global_eval(r#"Symbol.keyFor(Symbol("desc")) === undefined"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol.keyFor` returns undefined for well-known symbols.
    #[test]
    fn e2e_symbol_key_for_well_known_undefined() {
        let result = global_eval("Symbol.keyFor(Symbol.iterator) === undefined").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── typeof symbol tests ─────────────────────────────────────────────

    /// `typeof Symbol.for("x")` → "symbol"
    #[test]
    fn e2e_typeof_symbol_for() {
        let result = global_eval(r#"typeof Symbol.for("x")"#).unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol("desc")` → "symbol"
    #[test]
    fn e2e_typeof_symbol_with_desc() {
        let result = global_eval(r#"typeof Symbol("desc")"#).unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.toPrimitive` → "symbol"
    #[test]
    fn e2e_typeof_symbol_to_primitive() {
        let result = global_eval("typeof Symbol.toPrimitive").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.hasInstance` → "symbol"
    #[test]
    fn e2e_typeof_symbol_has_instance() {
        let result = global_eval("typeof Symbol.hasInstance").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.species` → "symbol"
    #[test]
    fn e2e_typeof_symbol_species() {
        let result = global_eval("typeof Symbol.species").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.toStringTag` → "symbol"
    #[test]
    fn e2e_typeof_symbol_to_string_tag() {
        let result = global_eval("typeof Symbol.toStringTag").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    // ── Object.prototype.toString tests ─────────────────────────────────

    /// `Object.prototype.toString.call(undefined)` → "[object Undefined]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_undefined() {
        let result = global_eval("Object.prototype.toString.call(undefined)").unwrap();
        assert_eq!(result, JsValue::String("[object Undefined]".into()));
    }

    /// `Object.prototype.toString.call(null)` → "[object Null]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_null() {
        let result = global_eval("Object.prototype.toString.call(null)").unwrap();
        assert_eq!(result, JsValue::String("[object Null]".into()));
    }

    /// `Object.prototype.toString.call([])` → "[object Array]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_array() {
        let result = global_eval("Object.prototype.toString.call([])").unwrap();
        assert_eq!(result, JsValue::String("[object Array]".into()));
    }

    /// `Object.prototype.toString.call(true)` → "[object Boolean]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_boolean() {
        let result = global_eval("Object.prototype.toString.call(true)").unwrap();
        assert_eq!(result, JsValue::String("[object Boolean]".into()));
    }

    /// `Object.prototype.toString.call(42)` → "[object Number]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_number() {
        let result = global_eval("Object.prototype.toString.call(42)").unwrap();
        assert_eq!(result, JsValue::String("[object Number]".into()));
    }

    /// `Object.prototype.toString.call("hi")` → "[object String]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_string() {
        let result = global_eval(r#"Object.prototype.toString.call("hi")"#).unwrap();
        assert_eq!(result, JsValue::String("[object String]".into()));
    }

    /// `Object.prototype.toString.call({})` → "[object Object]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_object() {
        let result = global_eval("Object.prototype.toString.call({})").unwrap();
        assert_eq!(result, JsValue::String("[object Object]".into()));
    }

    /// Direct `({}).toString()` → "[object Object]"
    #[test]
    fn e2e_plain_object_tostring_direct() {
        let result = global_eval("({}).toString()").unwrap();
        assert_eq!(result, JsValue::String("[object Object]".into()));
    }

    /// `Object.prototype.toString.call(function(){})` → "[object Function]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_function() {
        let result = global_eval("Object.prototype.toString.call(function(){})").unwrap();
        assert_eq!(result, JsValue::String("[object Function]".into()));
    }

    /// `Object.prototype.toString.call(new Error())` → "[object Error]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_error() {
        let result = global_eval("Object.prototype.toString.call(new Error())").unwrap();
        assert_eq!(result, JsValue::String("[object Error]".into()));
    }

    /// `Object.prototype.toString.call(new Date())` → "[object Date]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_date() {
        let result = global_eval("Object.prototype.toString.call(new Date())").unwrap();
        assert_eq!(result, JsValue::String("[object Date]".into()));
    }

    /// `typeof Symbol.match` → "symbol"
    #[test]
    fn e2e_typeof_symbol_match() {
        let result = global_eval("typeof Symbol.match").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.replace` → "symbol"
    #[test]
    fn e2e_typeof_symbol_replace() {
        let result = global_eval("typeof Symbol.replace").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.search` → "symbol"
    #[test]
    fn e2e_typeof_symbol_search() {
        let result = global_eval("typeof Symbol.search").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.split` → "symbol"
    #[test]
    fn e2e_typeof_symbol_split() {
        let result = global_eval("typeof Symbol.split").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.unscopables` → "symbol"
    #[test]
    fn e2e_typeof_symbol_unscopables() {
        let result = global_eval("typeof Symbol.unscopables").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.asyncIterator` → "symbol"
    #[test]
    fn e2e_typeof_symbol_async_iterator() {
        let result = global_eval("typeof Symbol.asyncIterator").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.isConcatSpreadable` → "symbol"
    #[test]
    fn e2e_typeof_symbol_is_concat_spreadable() {
        let result = global_eval("typeof Symbol.isConcatSpreadable").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.matchAll` → "symbol"
    #[test]
    fn e2e_typeof_symbol_match_all() {
        let result = global_eval("typeof Symbol.matchAll").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    // ── Symbol identity / equality tests ────────────────────────────────

    /// `Symbol("a") === Symbol("a")` → false (unique).
    #[test]
    fn e2e_symbol_same_desc_not_equal() {
        let result = global_eval(r#"Symbol("a") === Symbol("a")"#).unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// A symbol is strictly equal to itself.
    #[test]
    fn e2e_symbol_identity() {
        let result = global_eval(
            r#"
            var s = Symbol("id");
            s === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Symbol.prototype exists ─────────────────────────────────────────

    /// `Symbol` object has a `prototype` property.
    #[test]
    fn test_symbol_prototype_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let map = map.borrow();
            assert!(
                matches!(map.get("prototype"), Some(JsValue::PlainObject(_))),
                "Symbol.prototype should be a PlainObject"
            );
        } else {
            panic!("Symbol should be a PlainObject");
        }
    }

    /// `Symbol.prototype` has `toString`, `valueOf`, `description` methods.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_symbol_prototype_methods() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let map = map.borrow();
            let proto = map.get("prototype").unwrap();
            if let JsValue::PlainObject(proto_map) = proto {
                let proto_map = proto_map.borrow();
                assert!(matches!(
                    proto_map.get("toString"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto_map.get("valueOf"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto_map.get("description"),
                    Some(JsValue::NativeFunction(_))
                ));
            } else {
                panic!("Symbol.prototype should be a PlainObject");
            }
        } else {
            panic!("Symbol should be a PlainObject");
        }
    }

    // ── Well-known symbol completeness test ─────────────────────────────

    /// All 13 well-known symbols are present on the Symbol constructor.
    #[test]
    fn test_symbol_all_well_known_present() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let map = map.borrow();
            let expected = [
                "iterator",
                "toPrimitive",
                "hasInstance",
                "toStringTag",
                "isConcatSpreadable",
                "species",
                "match",
                "replace",
                "search",
                "split",
                "unscopables",
                "asyncIterator",
                "matchAll",
            ];
            for name in &expected {
                assert!(
                    matches!(map.get(*name), Some(JsValue::Symbol(_))),
                    "Symbol.{name} should be present as a Symbol value"
                );
            }
        } else {
            panic!("Symbol should be a PlainObject");
        }
    }

    /// Each well-known symbol is distinct from the others.
    #[test]
    fn test_symbol_well_known_all_distinct() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let sym = globals.get("Symbol").unwrap();
        if let JsValue::PlainObject(map) = sym {
            let map = map.borrow();
            let names = [
                "iterator",
                "toPrimitive",
                "hasInstance",
                "toStringTag",
                "isConcatSpreadable",
                "species",
                "match",
                "replace",
                "search",
                "split",
                "unscopables",
                "asyncIterator",
                "matchAll",
            ];
            let ids: Vec<u64> = names
                .iter()
                .map(|n| {
                    if let Some(JsValue::Symbol(id)) = map.get(*n) {
                        *id
                    } else {
                        panic!("Symbol.{n} missing");
                    }
                })
                .collect();
            // All IDs should be unique.
            let mut deduped = ids.clone();
            deduped.sort();
            deduped.dedup();
            assert_eq!(
                ids.len(),
                deduped.len(),
                "All well-known symbols must have distinct IDs"
            );
        }
    }

    // ── Symbol edge-case conformance tests ──────────────────────────────

    /// `new Symbol()` throws TypeError — Symbol is not a constructor.
    #[test]
    fn e2e_new_symbol_throws_type_error() {
        let result = global_eval(
            r#"
            try { new Symbol(); false; } catch (e) { e instanceof TypeError; }
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Symbol("desc")` also throws TypeError.
    #[test]
    fn e2e_new_symbol_with_desc_throws() {
        let result = global_eval(
            r#"
            try { new Symbol("desc"); false; } catch (e) { e instanceof TypeError; }
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Implicit symbol-to-string coercion throws TypeError.
    #[test]
    fn e2e_symbol_string_concat_throws() {
        let result = global_eval(
            r#"
            try { "" + Symbol("x"); false; } catch (e) { e instanceof TypeError; }
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Implicit symbol-to-number coercion throws TypeError.
    #[test]
    fn e2e_symbol_number_coercion_throws() {
        let result = global_eval(
            r#"
            try { +Symbol("x"); false; } catch (e) { e instanceof TypeError; }
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol.for` / `Symbol.keyFor` round-trip.
    #[test]
    fn e2e_symbol_for_key_for_round_trip() {
        let result = global_eval(
            r#"
            var s = Symbol.for("round");
            Symbol.keyFor(s) === "round" && Symbol.for("round") === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol.for("")` round-trips with empty key.
    #[test]
    fn e2e_symbol_for_empty_key_round_trip() {
        let result = global_eval(
            r#"
            var s = Symbol.for("");
            Symbol.keyFor(s) === "" && Symbol.for("") === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol.for("key").description` equals the key.
    #[test]
    fn e2e_symbol_for_description_matches_key() {
        let result = global_eval(r#"Symbol.for("myKey").description === "myKey""#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol.iterator.toString()` returns "Symbol(Symbol.iterator)".
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_iterator_to_string() {
        let result = global_eval("Symbol.iterator.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.iterator)".into()));
    }

    /// `Symbol("").toString()` → "Symbol()"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_empty_desc_to_string() {
        let result = global_eval(r#"Symbol("").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("Symbol()".into()));
    }

    /// `typeof` comparison: `typeof Symbol() === "symbol"` evaluates to true.
    #[test]
    fn e2e_typeof_symbol_equality_check() {
        let result = global_eval(r#"typeof Symbol("x") === "symbol""#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbols are truthy in boolean context.
    #[test]
    fn e2e_symbol_is_truthy() {
        let result = global_eval(r#"!!Symbol("x")"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// No-description symbol is also truthy.
    #[test]
    fn e2e_symbol_no_desc_is_truthy() {
        let result = global_eval("!!Symbol()").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol() == null` → false (no implicit coercion).
    #[test]
    fn e2e_symbol_not_equal_null() {
        let result = global_eval("Symbol() == null").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Symbol() == undefined` → false.
    #[test]
    fn e2e_symbol_not_equal_undefined() {
        let result = global_eval("Symbol() == undefined").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `delete obj[sym]` removes the symbol-keyed property.
    #[test]
    fn e2e_delete_symbol_property() {
        let result = global_eval(
            r#"
            var s = Symbol("del");
            var obj = {};
            obj[s] = 1;
            delete obj[s];
            obj[s] === undefined
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `sym in obj` works for symbol property keys.
    #[test]
    fn e2e_in_operator_with_symbol_key() {
        let result = global_eval(
            r#"
            var s = Symbol("prop");
            var obj = {};
            obj[s] = 42;
            s in obj
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `sym in obj` returns false when symbol key is absent.
    #[test]
    fn e2e_in_operator_symbol_absent() {
        let result = global_eval(
            r#"
            var s = Symbol("missing");
            var obj = { a: 1 };
            s in obj
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Symbol.hasInstance` customises `instanceof`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_has_instance_usage() {
        let result = global_eval(
            r#"
            var MyObj = { [Symbol.hasInstance](instance) { return instance.custom === true; } };
            var a = { custom: true };
            var b = { custom: false };
            a instanceof MyObj === true && b instanceof MyObj === false
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol.toStringTag` controls Object.prototype.toString output.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_string_tag_usage() {
        let result = global_eval(
            r#"
            var obj = { [Symbol.toStringTag]: "Custom" };
            Object.prototype.toString.call(obj)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("[object Custom]".into()));
    }

    /// Well-known symbol descriptions include `Symbol.dispose`.
    #[test]
    fn e2e_symbol_dispose_description() {
        let result = global_eval("Symbol.dispose.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.dispose".into()));
    }

    /// Well-known `Symbol.asyncDispose` has correct description.
    #[test]
    fn e2e_symbol_async_dispose_description() {
        let result = global_eval("Symbol.asyncDispose.description").unwrap();
        assert_eq!(result, JsValue::String("Symbol.asyncDispose".into()));
    }

    /// `typeof Symbol.dispose` → "symbol"
    #[test]
    fn e2e_typeof_symbol_dispose() {
        let result = global_eval("typeof Symbol.dispose").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// `typeof Symbol.asyncDispose` → "symbol"
    #[test]
    fn e2e_typeof_symbol_async_dispose() {
        let result = global_eval("typeof Symbol.asyncDispose").unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// Computed property with symbol in object literal.
    #[test]
    fn e2e_symbol_computed_property_literal() {
        let result = global_eval(
            r#"
            var s = Symbol("lit");
            var obj = { [s]: 99 };
            obj[s]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// Symbol key survives `Object.assign`.
    #[test]
    fn e2e_symbol_key_copied_by_object_assign() {
        let result = global_eval(
            r#"
            var s = Symbol("copy");
            var src = {};
            src[s] = 7;
            var dest = Object.assign({}, src);
            dest[s] === 7
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbol keys not included in `JSON.stringify`.
    #[test]
    fn e2e_symbol_keys_excluded_from_json() {
        let result = global_eval(
            r#"
            var s = Symbol("hidden");
            var obj = { visible: 1 };
            obj[s] = 2;
            JSON.stringify(obj) === '{"visible":1}'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Multiple symbol keys on the same object.
    #[test]
    fn e2e_multiple_symbol_keys() {
        let result = global_eval(
            r#"
            var s1 = Symbol("a");
            var s2 = Symbol("b");
            var s3 = Symbol("c");
            var obj = {};
            obj[s1] = 1;
            obj[s2] = 2;
            obj[s3] = 3;
            obj[s1] + obj[s2] + obj[s3]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    // ── Symbol.prototype[@@toPrimitive] tests ──────────────────────────

    /// `Symbol.prototype[Symbol.toPrimitive]` exists and is callable.
    #[test]
    fn e2e_symbol_to_primitive_method_exists() {
        let result =
            global_eval(r#"typeof Symbol.prototype[Symbol.toPrimitive] === "function""#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol("x")[Symbol.toPrimitive]("string")` returns the symbol.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_primitive_string_hint_returns_symbol() {
        let result = global_eval(
            r#"
            var s = Symbol("x");
            s[Symbol.toPrimitive]("string") === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol("x")[Symbol.toPrimitive]("number")` returns the symbol.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_primitive_number_hint_returns_symbol() {
        let result = global_eval(
            r#"
            var s = Symbol("x");
            s[Symbol.toPrimitive]("number") === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol("x")[Symbol.toPrimitive]("default")` returns the symbol.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_primitive_default_hint_returns_symbol() {
        let result = global_eval(
            r#"
            var s = Symbol("x");
            s[Symbol.toPrimitive]("default") === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `typeof Symbol("x")[Symbol.toPrimitive]("string")` → "symbol".
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_primitive_result_is_symbol() {
        let result = global_eval(r#"typeof Symbol("x")[Symbol.toPrimitive]("string")"#).unwrap();
        assert_eq!(result, JsValue::String("symbol".into()));
    }

    /// Boxed symbols inherit `@@toPrimitive` from `Symbol.prototype`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_wrapper_to_primitive_returns_symbol() {
        assert_eval_true(
            r#"
            var s = Symbol("x");
            Object(s)[Symbol.toPrimitive]("default") === s
            "#,
        );
    }

    /// `Symbol.prototype[@@toPrimitive]` accepts boxed symbol receivers.
    #[test]
    fn e2e_symbol_prototype_to_primitive_accepts_wrapper() {
        assert_eval_true(
            r#"
            var s = Symbol("x");
            Symbol.prototype[Symbol.toPrimitive].call(Object(s), "number") === s
            "#,
        );
    }

    /// Well-known symbol via @@toPrimitive preserves identity.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_well_known_symbol_to_primitive_identity() {
        let result =
            global_eval("Symbol.iterator[Symbol.toPrimitive]('default') === Symbol.iterator")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Symbol.prototype.toString on well-known symbols ────────────────

    /// `Symbol.toPrimitive.toString()` → "Symbol(Symbol.toPrimitive)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_primitive_to_string() {
        let result = global_eval("Symbol.toPrimitive.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.toPrimitive)".into()));
    }

    /// `Symbol.hasInstance.toString()` → "Symbol(Symbol.hasInstance)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_has_instance_to_string() {
        let result = global_eval("Symbol.hasInstance.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.hasInstance)".into()));
    }

    /// `Symbol.toStringTag.toString()` → "Symbol(Symbol.toStringTag)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_string_tag_to_string() {
        let result = global_eval("Symbol.toStringTag.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.toStringTag)".into()));
    }

    /// `Symbol.species.toString()` → "Symbol(Symbol.species)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_species_to_string() {
        let result = global_eval("Symbol.species.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.species)".into()));
    }

    /// `Symbol.isConcatSpreadable.toString()`
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_is_concat_spreadable_to_string() {
        let result = global_eval("Symbol.isConcatSpreadable.toString()").unwrap();
        assert_eq!(
            result,
            JsValue::String("Symbol(Symbol.isConcatSpreadable)".into())
        );
    }

    /// `Symbol.match.toString()` → "Symbol(Symbol.match)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_match_to_string() {
        let result = global_eval("Symbol.match.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.match)".into()));
    }

    /// `Symbol.replace.toString()` → "Symbol(Symbol.replace)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_replace_to_string() {
        let result = global_eval("Symbol.replace.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.replace)".into()));
    }

    /// `Symbol.search.toString()` → "Symbol(Symbol.search)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_search_to_string() {
        let result = global_eval("Symbol.search.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.search)".into()));
    }

    /// `Symbol.split.toString()` → "Symbol(Symbol.split)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_split_to_string() {
        let result = global_eval("Symbol.split.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.split)".into()));
    }

    /// `Symbol.unscopables.toString()` → "Symbol(Symbol.unscopables)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_unscopables_to_string() {
        let result = global_eval("Symbol.unscopables.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.unscopables)".into()));
    }

    /// `Symbol.asyncIterator.toString()` → "Symbol(Symbol.asyncIterator)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_async_iterator_to_string() {
        let result = global_eval("Symbol.asyncIterator.toString()").unwrap();
        assert_eq!(
            result,
            JsValue::String("Symbol(Symbol.asyncIterator)".into())
        );
    }

    /// `Symbol.matchAll.toString()` → "Symbol(Symbol.matchAll)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_match_all_to_string() {
        let result = global_eval("Symbol.matchAll.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.matchAll)".into()));
    }

    // ── Symbol.prototype.valueOf identity tests ────────────────────────

    /// User symbol valueOf preserves identity.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_user_value_of_identity() {
        let result = global_eval(
            r#"
            var s = Symbol("v");
            s.valueOf() === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbol.for symbol valueOf preserves identity.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_for_value_of_identity() {
        let result = global_eval(r#"Symbol.for("vof").valueOf() === Symbol.for("vof")"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Well-known Symbol.toPrimitive valueOf preserves identity.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_primitive_value_of_identity() {
        let result = global_eval("Symbol.toPrimitive.valueOf() === Symbol.toPrimitive").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Symbol.for / Symbol.keyFor additional tests ────────────────────

    /// `Symbol.for("x").toString()` → "Symbol(x)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_for_to_string() {
        let result = global_eval(r#"Symbol.for("x").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("Symbol(x)".into()));
    }

    /// `Symbol.for("").toString()` → "Symbol()"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_for_empty_to_string() {
        let result = global_eval(r#"Symbol.for("").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("Symbol()".into()));
    }

    /// `Symbol.keyFor` returns undefined for well-known `Symbol.match`.
    #[test]
    fn e2e_symbol_key_for_well_known_match() {
        let result = global_eval("Symbol.keyFor(Symbol.match) === undefined").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol.keyFor` returns undefined for well-known `Symbol.species`.
    #[test]
    fn e2e_symbol_key_for_well_known_species() {
        let result = global_eval("Symbol.keyFor(Symbol.species) === undefined").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Object.prototype.toString.call(Symbol) ─────────────────────────

    /// `Object.prototype.toString.call(Symbol("x"))` → "[object Symbol]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_symbol() {
        let result = global_eval(r#"Object.prototype.toString.call(Symbol("x"))"#).unwrap();
        assert_eq!(result, JsValue::String("[object Symbol]".into()));
    }

    /// `Object.prototype.toString.call(Symbol.iterator)` → "[object Symbol]"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_obj_tostring_call_well_known_symbol() {
        let result = global_eval("Object.prototype.toString.call(Symbol.iterator)").unwrap();
        assert_eq!(result, JsValue::String("[object Symbol]".into()));
    }

    // ── Symbol truthiness / coercion edge cases ────────────────────────

    /// Symbol in conditional expression evaluates truthy.
    #[test]
    fn e2e_symbol_ternary_truthy() {
        let result = global_eval(r#"Symbol("t") ? "yes" : "no""#).unwrap();
        assert_eq!(result, JsValue::String("yes".into()));
    }

    /// `Boolean(Symbol())` → true.
    #[test]
    fn e2e_boolean_of_symbol() {
        let result = global_eval("Boolean(Symbol())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbol strict-not-equals to its toString.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_not_equal_to_its_tostring() {
        let result = global_eval(
            r#"
            var s = Symbol("abc");
            s !== s.toString()
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Two Symbol.for calls with same key in one expression.
    #[test]
    fn e2e_symbol_for_inline_identity() {
        let result = global_eval(r#"Symbol.for("inline") === Symbol.for("inline")"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbol description with unicode characters.
    #[test]
    fn e2e_symbol_unicode_description() {
        let result = global_eval("Symbol('\u{1F600}').description === '\u{1F600}'").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbol.for with unicode key round-trips.
    #[test]
    fn e2e_symbol_for_unicode_key() {
        let result = global_eval("Symbol.keyFor(Symbol.for('\u{1F600}')) === '\u{1F600}'").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbol stored across closure retains identity.
    #[test]
    fn e2e_symbol_closure_identity() {
        let result = global_eval(
            r#"
            var s = Symbol("closed");
            var get = function() { return s; };
            get() === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbol as Map key.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_as_map_key() {
        let result = global_eval(
            r#"
            var s = Symbol("mapKey");
            var m = new Map();
            m.set(s, 42);
            m.get(s)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Different symbols as different Map keys.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_map_different_keys() {
        let result = global_eval(
            r#"
            var s1 = Symbol("a");
            var s2 = Symbol("a");
            var m = new Map();
            m.set(s1, 1);
            m.set(s2, 2);
            m.get(s1) === 1 && m.get(s2) === 2 && m.size === 2
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Symbol in array survives and is retrievable.
    #[test]
    fn e2e_symbol_in_array() {
        let result = global_eval(
            r#"
            var s = Symbol("arr");
            var a = [1, s, 3];
            a[1] === s
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Symbol.dispose.toString()` → "Symbol(Symbol.dispose)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_dispose_to_string() {
        let result = global_eval("Symbol.dispose.toString()").unwrap();
        assert_eq!(result, JsValue::String("Symbol(Symbol.dispose)".into()));
    }

    /// `Symbol.asyncDispose.toString()` → "Symbol(Symbol.asyncDispose)"
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_async_dispose_to_string() {
        let result = global_eval("Symbol.asyncDispose.toString()").unwrap();
        assert_eq!(
            result,
            JsValue::String("Symbol(Symbol.asyncDispose)".into())
        );
    }

    // ── Object.defineProperty / getOwnPropertyDescriptor tests ──────────

    /// `Object.defineProperty` sets a property on an object.
    #[test]
    fn e2e_object_define_property_sets_value() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", { value: 42 });
            obj.x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.defineProperty` returns the object itself.
    #[test]
    fn e2e_object_define_property_returns_object() {
        let result = global_eval(
            r#"
            var obj = {};
            var ret = Object.defineProperty(obj, "a", { value: 1 });
            ret.a
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Object.getOwnPropertyDescriptor` returns descriptor with value.
    #[test]
    fn e2e_object_get_own_property_descriptor_value() {
        let result = global_eval(
            r#"
            var obj = { x: 10 };
            var desc = Object.getOwnPropertyDescriptor(obj, "x");
            desc.value
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    /// `Object.getOwnPropertyDescriptor` reports writable as true for plain props.
    #[test]
    fn e2e_object_get_own_property_descriptor_writable() {
        let result = global_eval(
            r#"
            var obj = { x: 10 };
            var desc = Object.getOwnPropertyDescriptor(obj, "x");
            desc.writable
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.getOwnPropertyDescriptor` returns undefined for missing prop.
    #[test]
    fn e2e_object_get_own_property_descriptor_missing() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.getOwnPropertyDescriptor(obj, "nope")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `Object.defineProperties` defines multiple properties at once.
    #[test]
    fn e2e_object_define_properties() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.defineProperties(obj, {
                a: { value: 1 },
                b: { value: 2 }
            });
            obj.a + obj.b
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.getOwnPropertyNames` returns an array.
    #[test]
    fn e2e_object_get_own_property_names() {
        let result = global_eval("Array.isArray(Object.getOwnPropertyNames({}))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.assign` is available as a function on the Object global.
    #[test]
    fn test_object_assign_native() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let obj = globals.get("Object").unwrap();
        if let JsValue::PlainObject(map) = obj {
            let assign = map.borrow().get("assign").cloned().unwrap();
            // builtin_fn wraps as PlainObject with __call__
            let f = match &assign {
                JsValue::NativeFunction(f) => Rc::clone(f),
                JsValue::PlainObject(po) => {
                    if let Some(JsValue::NativeFunction(f)) = po.borrow().get("__call__") {
                        Rc::clone(f)
                    } else {
                        panic!("assign should be callable");
                    }
                }
                _ => panic!("assign should be callable"),
            };
            let target_map = PropertyMap::new();
            let target = JsValue::PlainObject(Rc::new(RefCell::new(target_map)));
            let mut src_map = PropertyMap::new();
            src_map.insert("b".into(), JsValue::Smi(2));
            let source = JsValue::PlainObject(Rc::new(RefCell::new(src_map)));
            let result = f(vec![target.clone(), source]).unwrap();
            // Target should have the property from source
            if let JsValue::PlainObject(r) = &result {
                assert_eq!(r.borrow().get("b").cloned(), Some(JsValue::Smi(2)));
            } else {
                panic!("Expected PlainObject");
            }
        }
    }

    /// `Object.assign` returns the target object with merged props.
    #[test]
    fn test_object_assign_returns_target() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let obj = globals.get("Object").unwrap();
        if let JsValue::PlainObject(map) = obj {
            let assign = map.borrow().get("assign").cloned().unwrap();
            // builtin_fn wraps as PlainObject with __call__
            let f = match &assign {
                JsValue::NativeFunction(f) => Rc::clone(f),
                JsValue::PlainObject(po) => {
                    if let Some(JsValue::NativeFunction(f)) = po.borrow().get("__call__") {
                        Rc::clone(f)
                    } else {
                        panic!("assign should be callable");
                    }
                }
                _ => panic!("assign should be callable"),
            };
            let mut t = PropertyMap::new();
            t.insert("a".into(), JsValue::Smi(1));
            let target = JsValue::PlainObject(Rc::new(RefCell::new(t)));
            let mut s1 = PropertyMap::new();
            s1.insert("b".into(), JsValue::Smi(2));
            let src1 = JsValue::PlainObject(Rc::new(RefCell::new(s1)));
            let mut s2 = PropertyMap::new();
            s2.insert("c".into(), JsValue::Smi(3));
            let src2 = JsValue::PlainObject(Rc::new(RefCell::new(s2)));
            let result = f(vec![target, src1, src2]).unwrap();
            if let JsValue::PlainObject(r) = &result {
                let r = r.borrow();
                assert_eq!(r.get("a").cloned(), Some(JsValue::Smi(1)));
                assert_eq!(r.get("b").cloned(), Some(JsValue::Smi(2)));
                assert_eq!(r.get("c").cloned(), Some(JsValue::Smi(3)));
            } else {
                panic!("Expected PlainObject");
            }
        }
    }

    /// `Object.freeze` returns the object.
    #[test]
    fn e2e_object_freeze_returns_object() {
        let result = global_eval(
            r#"
            var obj = { x: 42 };
            var ret = Object.freeze(obj);
            ret.x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.groupBy` groups array elements by callback return value.
    #[test]
    fn test_object_group_by_native() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let obj = globals.get("Object").unwrap();
        if let JsValue::PlainObject(map) = obj {
            let group_by = map.borrow().get("groupBy").cloned().unwrap();
            // builtin_fn wraps as PlainObject with __call__
            let f = match &group_by {
                JsValue::NativeFunction(f) => Rc::clone(f),
                JsValue::PlainObject(po) => {
                    if let Some(JsValue::NativeFunction(f)) = po.borrow().get("__call__") {
                        Rc::clone(f)
                    } else {
                        panic!("groupBy should be callable");
                    }
                }
                _ => panic!("groupBy should be callable"),
            };
            let items = JsValue::new_array(vec![
                JsValue::Smi(1),
                JsValue::Smi(2),
                JsValue::Smi(3),
                JsValue::Smi(4),
            ]);
            let cb = JsValue::NativeFunction(Rc::new(|args: Vec<JsValue>| {
                let v = args.first().unwrap_or(&JsValue::Undefined).clone();
                let n = v.to_number().unwrap_or(0.0) as i32;
                if n % 2 == 0 {
                    Ok(JsValue::String("even".into()))
                } else {
                    Ok(JsValue::String("odd".into()))
                }
            }));
            let result = f(vec![items, cb]).unwrap();
            if let JsValue::PlainObject(r) = &result {
                let borrow = r.borrow();
                let odd = borrow.get("odd").cloned().unwrap();
                let even = borrow.get("even").cloned().unwrap();
                if let JsValue::Array(odd_arr) = odd {
                    assert_eq!(odd_arr.borrow().len(), 2);
                    assert_eq!(odd_arr.borrow()[0], JsValue::Smi(1));
                    assert_eq!(odd_arr.borrow()[1], JsValue::Smi(3));
                } else {
                    panic!("odd should be Array");
                }
                if let JsValue::Array(even_arr) = even {
                    assert_eq!(even_arr.borrow().len(), 2);
                    assert_eq!(even_arr.borrow()[0], JsValue::Smi(2));
                    assert_eq!(even_arr.borrow()[1], JsValue::Smi(4));
                } else {
                    panic!("even should be Array");
                }
            } else {
                panic!("Expected PlainObject");
            }
        }
    }

    /// `Object.seal` returns the object.
    #[test]
    fn e2e_object_seal_returns_object() {
        let result = global_eval(
            r#"
            var obj = { x: 10 };
            var ret = Object.seal(obj);
            ret.x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    /// `Object.isFrozen` returns a boolean.
    #[test]
    fn e2e_object_is_frozen() {
        let result = global_eval("Object.isFrozen(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.isSealed` returns a boolean.
    #[test]
    fn e2e_object_is_sealed() {
        let result = global_eval("Object.isSealed(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.create(null)` returns an empty object.
    #[test]
    fn e2e_object_create_null() {
        let result = global_eval(
            r#"
            var obj = Object.create(null);
            typeof obj
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    /// `Object.is(NaN, NaN)` returns true.
    #[test]
    fn e2e_object_is_nan_nan() {
        let result = global_eval("Object.is(NaN, NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `arguments.length` returns the number of arguments passed.
    #[test]
    fn e2e_arguments_length() {
        let result = global_eval(
            r#"
            function f(a, b) { return arguments.length; }
            f(1, 2)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `arguments[i]` returns the i-th argument.
    #[test]
    fn e2e_arguments_indexing() {
        let result = global_eval(
            r#"
            function f(a, b) { return arguments[1]; }
            f(10, 20)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(20));
    }

    /// `Object.is(0, -0)` returns false.
    #[test]
    fn e2e_object_is_zero_neg_zero() {
        // Note: this test requires the engine to distinguish +0 and -0
        let result = global_eval("Object.is(1, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.is(1, 2)` returns false.
    #[test]
    fn e2e_object_is_different_values() {
        let result = global_eval("Object.is(1, 2)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Object method presence tests ────────────────────────────────────

    /// Verify the Object global has all expected property descriptor methods.
    #[test]
    fn test_object_has_descriptor_methods() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let obj = globals.get("Object").unwrap();
        if let JsValue::PlainObject(map) = obj {
            let map = map.borrow();
            assert!(map.contains_key("defineProperty"));
            assert!(map.contains_key("getOwnPropertyDescriptor"));
            assert!(map.contains_key("defineProperties"));
            assert!(map.contains_key("getOwnPropertyNames"));
            assert!(map.contains_key("assign"));
            assert!(map.contains_key("freeze"));
            assert!(map.contains_key("seal"));
            assert!(map.contains_key("isFrozen"));
            assert!(map.contains_key("isSealed"));
            assert!(map.contains_key("create"));
            assert!(map.contains_key("is"));
            assert!(map.contains_key("fromEntries"));
            assert!(map.contains_key("keys"));
            assert!(map.contains_key("values"));
            assert!(map.contains_key("entries"));
            assert!(map.contains_key("hasOwn"));
            assert!(map.contains_key("getPrototypeOf"));
            assert!(map.contains_key("setPrototypeOf"));
            assert!(map.contains_key("preventExtensions"));
            assert!(map.contains_key("isExtensible"));
            assert!(map.contains_key("getOwnPropertyDescriptors"));
            assert!(map.contains_key("getOwnPropertySymbols"));
        } else {
            panic!("Object should be a PlainObject");
        }
    }

    // ── Object.hasOwn e2e tests ─────────────────────────────────────────

    /// `Object.hasOwn` returns true for own properties.
    #[test]
    fn e2e_object_has_own_true() {
        let result = global_eval(
            r#"
            var obj = { x: 1 };
            Object.hasOwn(obj, "x")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.hasOwn` returns false for missing properties.
    #[test]
    fn e2e_object_has_own_false() {
        let result = global_eval(
            r#"
            var obj = { x: 1 };
            Object.hasOwn(obj, "y")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.getPrototypeOf` returns `Object.prototype` for plain objects.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_get_prototype_of_null() {
        let result = global_eval("Object.getPrototypeOf({}) === Object.prototype").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.setPrototypeOf` returns the object.
    #[test]
    fn e2e_object_set_prototype_of_returns_obj() {
        let result = global_eval(
            r#"
            var obj = { a: 5 };
            var ret = Object.setPrototypeOf(obj, null);
            ret.a
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// `Object.preventExtensions` returns the object.
    #[test]
    fn e2e_object_prevent_extensions_returns_obj() {
        let result = global_eval(
            r#"
            var obj = { x: 42 };
            var ret = Object.preventExtensions(obj);
            ret.x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.isExtensible` returns true for plain objects.
    #[test]
    fn e2e_object_is_extensible_plain() {
        let result = global_eval("Object.isExtensible({})").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.isExtensible` returns false for primitives.
    #[test]
    fn e2e_object_is_extensible_primitive() {
        let result = global_eval("Object.isExtensible(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.getOwnPropertyDescriptors` returns descriptors for all props.
    #[test]
    fn e2e_object_get_own_property_descriptors() {
        let result = global_eval(
            r#"
            var obj = { a: 1 };
            var descs = Object.getOwnPropertyDescriptors(obj);
            descs.a.value
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Object.getOwnPropertySymbols` returns an array.
    #[test]
    fn e2e_object_get_own_property_symbols() {
        let result = global_eval("Array.isArray(Object.getOwnPropertySymbols({}))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Iterator tests ──────────────────────────────────────────────────────

    /// `Iterator` is available as a global PlainObject.
    #[test]
    fn test_iterator_global_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(
            globals.get("Iterator"),
            Some(JsValue::PlainObject(_))
        ));
    }

    /// `Iterator` has a `from` static method and a `prototype` with helpers.
    #[test]
    fn test_iterator_object_properties() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let iter_obj = globals.get("Iterator").unwrap();
        if let JsValue::PlainObject(map) = iter_obj {
            let map = map.borrow();
            assert!(matches!(map.get("from"), Some(JsValue::NativeFunction(_))));
            assert!(matches!(
                map.get("prototype"),
                Some(JsValue::PlainObject(_))
            ));
            if let Some(JsValue::PlainObject(proto)) = map.get("prototype") {
                let proto = proto.borrow();
                assert!(matches!(proto.get("map"), Some(JsValue::NativeFunction(_))));
                assert!(matches!(
                    proto.get("filter"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("take"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("drop"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("flatMap"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("reduce"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("toArray"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("forEach"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("some"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("every"),
                    Some(JsValue::NativeFunction(_))
                ));
                assert!(matches!(
                    proto.get("find"),
                    Some(JsValue::NativeFunction(_))
                ));
            }
        } else {
            panic!("Iterator should be a PlainObject");
        }
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_from_array_to_array() {
        assert_eval_true(
            "var out = Iterator.from([1, 2, 3]).toArray(); out.length === 3 && out[0] === 1 && out[2] === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_from_string_to_array() {
        assert_eval_true(
            "var out = Iterator.from('ab').toArray(); out.length === 2 && out[0] === 'a' && out[1] === 'b'",
        );
    }

    #[test]
    fn e2e_iterator_from_native_iterator_returns_same() {
        assert_eval_true("var iter = [1, 2][Symbol.iterator](); Iterator.from(iter) === iter");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_from_generator_to_array() {
        assert_eval_true(
            "function* gen() { yield 1; yield 2; yield 3; } var out = Iterator.from(gen()).toArray(); out.length === 3 && out[1] === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_from_custom_iterator_like_to_array() {
        assert_eval_true(
            "var i = 0; var iter = Iterator.from({ next: function() { return i < 3 ? { value: i++, done: false } : { done: true }; } }); var out = iter.toArray(); out.length === 3 && out[0] === 0 && out[2] === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_from_custom_iterable_to_array() {
        assert_eval_true(
            "var obj = {}; obj[Symbol.iterator] = function() { var i = 1; return { next: function() { return i <= 3 ? { value: i++ * 10, done: false } : { done: true }; } }; }; var out = Iterator.from(obj).toArray(); out.length === 3 && out[0] === 10 && out[2] === 30",
        );
    }

    #[test]
    fn e2e_iterator_from_non_iterable_throws_type_error() {
        assert_eval_type_error("Iterator.from(123)");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_map_transforms_values() {
        assert_eval_true(
            "var out = Iterator.from([1, 2, 3]).map(function(v) { return v * 2; }).toArray(); out.length === 3 && out[0] === 2 && out[2] === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_map_passes_index() {
        assert_eval_true(
            "var out = Iterator.from([10, 10, 10]).map(function(v, i) { return v + i; }).toArray(); out[0] === 10 && out[1] === 11 && out[2] === 12",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_map_chainable() {
        assert_eval_true(
            "var out = Iterator.from([1, 2, 3]).map(function(v) { return v + 1; }).map(function(v) { return v * 3; }).toArray(); out[0] === 6 && out[2] === 12",
        );
    }

    #[test]
    fn e2e_iterator_map_callback_must_be_function() {
        assert_eval_type_error("Iterator.from([1]).map(0)");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_filter_keeps_matching_values() {
        assert_eval_true(
            "var out = Iterator.from([1, 2, 3, 4]).filter(function(v) { return v % 2 === 0; }).toArray(); out.length === 2 && out[0] === 2 && out[1] === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_filter_passes_index() {
        assert_eval_true(
            "var out = Iterator.from([5, 5, 5, 5]).filter(function(v, i) { return i % 2 === 0; }).toArray(); out.length === 2 && out[0] === 5 && out[1] === 5",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_filter_chainable() {
        assert_eval_true(
            "var out = Iterator.from([1, 2, 3, 4, 5]).filter(function(v) { return v > 1; }).filter(function(v) { return v < 5; }).toArray(); out.length === 3 && out[0] === 2 && out[2] === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_take_limits_results() {
        assert_eval_true(
            "var out = Iterator.from([1, 2, 3, 4]).take(2).toArray(); out.length === 2 && out[0] === 1 && out[1] === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_take_zero_is_empty() {
        assert_eval_true("Iterator.from([1, 2, 3]).take(0).toArray().length === 0");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_take_negative_throws_range_error() {
        assert_eval_range_error("Iterator.from([1, 2, 3]).take(-1)");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_drop_skips_prefix() {
        assert_eval_true(
            "var out = Iterator.from([1, 2, 3, 4]).drop(2).toArray(); out.length === 2 && out[0] === 3 && out[1] === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_drop_allows_zero() {
        assert_eval_true(
            "var out = Iterator.from([7, 8]).drop(0).toArray(); out.length === 2 && out[0] === 7 && out[1] === 8",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_drop_negative_throws_range_error() {
        assert_eval_range_error("Iterator.from([1, 2, 3]).drop(-1)");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_for_each_accumulates_values() {
        assert_eval_true(
            "var sum = 0; var ret = Iterator.from([1, 2, 3]).forEach(function(v) { sum += v; }); ret === undefined && sum === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_for_each_consumes_iterator() {
        assert_eval_true(
            "var iter = Iterator.from([1, 2, 3]); iter.forEach(function() {}); iter.next().done === true",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_to_array_collects_values() {
        assert_eval_true(
            "var out = Iterator.from([4, 5, 6]).toArray(); out.length === 3 && out[0] === 4 && out[2] === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_to_array_consumes_iterator() {
        assert_eval_true(
            "var iter = Iterator.from([9, 10]); var out = iter.toArray(); out.length === 2 && iter.next().done === true",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_reduce_with_initial_value() {
        assert_eval_true(
            "Iterator.from([1, 2, 3]).reduce(function(acc, v) { return acc + v; }, 10) === 16",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_reduce_without_initial_value() {
        assert_eval_true(
            "Iterator.from([1, 2, 3]).reduce(function(acc, v) { return acc + v; }) === 6",
        );
    }

    #[test]
    fn e2e_iterator_reduce_empty_without_initial_throws_type_error() {
        assert_eval_type_error("Iterator.from([]).reduce(function(acc, v) { return acc + v; })");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_reduce_passes_index() {
        assert_eval_true(
            "Iterator.from([5, 5, 5]).reduce(function(acc, v, i) { return acc + i; }, 0) === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_some_returns_true_for_match() {
        assert_eval_true("Iterator.from([1, 2, 3]).some(function(v) { return v === 2; }) === true");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_some_short_circuits() {
        assert_eval_true(
            "var seen = 0; var result = Iterator.from([1, 2, 3, 4]).some(function(v) { seen++; return v === 2; }); result === true && seen === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_every_returns_true_when_all_match() {
        assert_eval_true(
            "Iterator.from([2, 4, 6]).every(function(v) { return v % 2 === 0; }) === true",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_every_short_circuits_on_false() {
        assert_eval_true(
            "var seen = 0; var result = Iterator.from([2, 4, 5, 6]).every(function(v) { seen++; return v % 2 === 0; }); result === false && seen === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_find_returns_first_match() {
        assert_eval_true(
            "Iterator.from([1, 3, 4, 6]).find(function(v) { return v % 2 === 0; }) === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_find_returns_undefined_when_missing() {
        assert_eval_true(
            "Iterator.from([1, 3, 5]).find(function(v) { return v % 2 === 0; }) === undefined",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_methods_exist_on_native_iterators() {
        assert_eval_true(
            "typeof [1, 2][Symbol.iterator]().map === 'function' && typeof [1, 2][Symbol.iterator]().toArray === 'function'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_methods_exist_on_generator_objects() {
        assert_eval_true(
            "function* gen() { yield 1; } var iter = gen(); typeof iter.map === 'function' && typeof iter.find === 'function'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_generator_map_to_array() {
        assert_eval_true(
            "function* gen() { yield 2; yield 4; } var out = gen().map(function(v) { return v / 2; }).toArray(); out.length === 2 && out[0] === 1 && out[1] === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_from_next_only_object_supports_helpers() {
        assert_eval_true(
            "var i = 0; var iter = Iterator.from({ next: function() { return i < 4 ? { value: i++, done: false } : { done: true }; } }); var out = iter.map(function(v) { return v + 10; }).filter(function(v) { return v % 2 === 0; }).toArray(); out.length === 2 && out[0] === 10 && out[1] === 12",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_helper_chaining_map_filter_take_drop() {
        assert_eval_true(
            "var out = Iterator.from([1, 2, 3, 4, 5, 6]).map(function(v) { return v * 2; }).filter(function(v) { return v % 3 !== 0; }).drop(1).take(2).toArray(); out.length === 2 && out[0] === 8 && out[1] === 10",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_map_consumes_source_iterator() {
        assert_eval_true(
            "var iter = Iterator.from([1, 2, 3]); var mapped = iter.map(function(v) { return v * 2; }); mapped.toArray()[0] === 2 && iter.next().done === true",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_filter_consumes_source_iterator() {
        assert_eval_true(
            "var iter = Iterator.from([1, 2, 3]); var filtered = iter.filter(function(v) { return v > 1; }); filtered.toArray().length === 2 && iter.next().done === true",
        );
    }

    // ── globalThis tests ────────────────────────────────────────────────────

    /// `globalThis` is a PlainObject containing the global scope keys.
    #[test]
    fn test_global_this_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(
            globals.get("globalThis"),
            Some(JsValue::PlainObject(_))
        ));
    }

    /// `globalThis` contains the same keys as the global scope.
    #[test]
    fn test_global_this_has_keys() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let Some(JsValue::PlainObject(gt)) = globals.get("globalThis") {
            let gt = gt.borrow();
            assert!(gt.contains_key("Math"));
            assert!(gt.contains_key("parseInt"));
            assert!(gt.contains_key("Iterator"));
        } else {
            panic!("globalThis should be a PlainObject");
        }
    }

    /// `globalThis.globalThis` resolves back to the same object (self-referential).
    #[test]
    fn test_global_this_is_self_referential() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let Some(JsValue::PlainObject(gt)) = globals.get("globalThis") {
            // globalThis.globalThis should exist and be a PlainObject
            let inner = gt.borrow();
            assert!(
                inner.contains_key("globalThis"),
                "globalThis should contain a 'globalThis' key"
            );
            if let Some(JsValue::PlainObject(gt2)) = inner.get("globalThis") {
                // The inner Rc should point to the same allocation.
                assert!(
                    Rc::ptr_eq(gt, gt2),
                    "globalThis.globalThis should be the same Rc"
                );
            } else {
                panic!("globalThis.globalThis should be a PlainObject");
            }
        } else {
            panic!("globalThis should be a PlainObject");
        }
    }

    #[test]
    fn e2e_global_this_matches_top_level_this() {
        let result = global_eval("globalThis === this").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_global_this_sees_declared_global_binding() {
        let result =
            global_eval("var conformanceGlobal = 9; globalThis.conformanceGlobal").unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_global_binding_sees_global_this_assignment() {
        let result =
            global_eval("globalThis.conformanceAssigned = 7; conformanceAssigned").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_global_this_reuses_global_function_identity() {
        let result = global_eval("globalThis.parseInt === parseInt").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_global_is_nan_coerces_strings() {
        let result = global_eval("isNaN('wat')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_number_is_nan_does_not_coerce_strings() {
        let result = global_eval("Number.isNaN('wat')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_global_is_finite_coerces_strings() {
        let result = global_eval("isFinite('42')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_number_is_finite_does_not_coerce_strings() {
        let result = global_eval("Number.isFinite('42')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_parse_int_trims_leading_whitespace() {
        let result = global_eval("parseInt('   42')").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_parse_int_honors_radix() {
        let result = global_eval("parseInt('11', 2)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_parse_int_stops_at_invalid_suffix() {
        let result = global_eval("parseInt('15px', 10)").unwrap();
        assert_eq!(result, JsValue::Smi(15));
    }

    #[test]
    fn e2e_parse_float_trims_leading_whitespace() {
        let result = global_eval("parseFloat('  -3.5')").unwrap();
        assert_eq!(result, JsValue::HeapNumber(-3.5));
    }

    #[test]
    fn e2e_parse_float_stops_at_invalid_suffix() {
        let result = global_eval("parseFloat('3.14xyz')").unwrap();
        assert_eq!(result, JsValue::HeapNumber(3.14));
    }

    #[test]
    fn e2e_encode_uri_preserves_reserved_delimiters() {
        let result = global_eval("encodeURI('https://example.com/a b?x=1&y=2#hash')").unwrap();
        assert_eq!(
            result,
            JsValue::String("https://example.com/a%20b?x=1&y=2#hash".into())
        );
    }

    #[test]
    fn e2e_encode_uri_component_encodes_reserved_delimiters() {
        let result = global_eval("encodeURIComponent('a b?x=1&y=2')").unwrap();
        assert_eq!(result, JsValue::String("a%20b%3Fx%3D1%26y%3D2".into()));
    }

    #[test]
    fn e2e_decode_uri_decodes_basic_sequences() {
        let result = global_eval("decodeURI('hello%20world')").unwrap();
        assert_eq!(result, JsValue::String("hello world".into()));
    }

    #[test]
    fn e2e_decode_uri_component_decodes_reserved_sequences() {
        let result = global_eval("decodeURIComponent('a%3Db%26c%3Dd')").unwrap();
        assert_eq!(result, JsValue::String("a=b&c=d".into()));
    }

    #[test]
    fn e2e_decode_uri_throws_uri_error_on_invalid_input() {
        let result =
            global_eval("try { decodeURI('%E0%A4%A'); 'no'; } catch (e) { e.name; }").unwrap();
        assert_eq!(result, JsValue::String("URIError".into()));
    }

    #[test]
    fn e2e_decode_uri_component_throws_uri_error_on_invalid_input() {
        let result =
            global_eval("try { decodeURIComponent('%GG'); 'no'; } catch (e) { e.name; }").unwrap();
        assert_eq!(result, JsValue::String("URIError".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_to_string_uses_symbol_to_string_tag() {
        let result =
            global_eval("var tagged = { [Symbol.toStringTag]: 'Tagged' }; Object.prototype.toString.call(tagged)")
                .unwrap();
        assert_eq!(result, JsValue::String("[object Tagged]".into()));
    }

    #[test]
    fn e2e_error_stack_is_string() {
        let result = global_eval("typeof new Error('boom').stack").unwrap();
        assert_eq!(result, JsValue::String("string".into()));
    }

    #[test]
    fn e2e_console_log_does_not_throw() {
        let result = global_eval("try { console.log('ok'); true; } catch (e) { false; }").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_parse_int_builtin_name_and_length() {
        let result = global_eval("parseInt.name + ':' + parseInt.length").unwrap();
        assert_eq!(result, JsValue::String("parseInt:2".into()));
    }

    #[test]
    fn e2e_number_is_nan_builtin_name_and_length() {
        let result = global_eval("Number.isNaN.name + ':' + Number.isNaN.length").unwrap();
        assert_eq!(result, JsValue::String("isNaN:1".into()));
    }

    #[test]
    fn e2e_object_to_string_builtin_name_and_length() {
        let result =
            global_eval("Object.prototype.toString.name + ':' + Object.prototype.toString.length")
                .unwrap();
        assert_eq!(result, JsValue::String("toString:0".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_error_to_string_builtin_name_and_length() {
        let result =
            global_eval("Error.prototype.toString.name + ':' + Error.prototype.toString.length")
                .unwrap();
        assert_eq!(result, JsValue::String("toString:0".into()));
    }

    #[test]
    fn e2e_console_log_builtin_name_and_length() {
        let result = global_eval("console.log.name + ':' + console.log.length").unwrap();
        assert_eq!(result, JsValue::String("log:0".into()));
    }

    // ── Map constructor tests ────────────────────────────────────────────────

    /// `Map` global is a PlainObject with a `__call__` constructor.
    #[test]
    fn test_map_global_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(globals.get("Map"), Some(JsValue::PlainObject(_))));
    }

    /// Constructing a Map via `__call__` returns an object with prototype methods.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_map_constructor_creates_instance() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(map_ctor) = globals.get("Map").unwrap() {
            let call = map_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![]).unwrap();
                if let JsValue::PlainObject(instance) = result {
                    let inst = instance.borrow();
                    assert!(inst.contains_key("get"));
                    assert!(inst.contains_key("set"));
                    assert!(inst.contains_key("has"));
                    assert!(inst.contains_key("delete"));
                    assert!(inst.contains_key("clear"));
                    assert!(inst.contains_key("forEach"));
                    assert!(inst.contains_key("keys"));
                    assert!(inst.contains_key("values"));
                    assert!(inst.contains_key("entries"));
                    assert!(inst.contains_key("size"));
                } else {
                    panic!("Map() should return a PlainObject");
                }
            } else {
                panic!("Map.__call__ should be NativeFunction");
            }
        } else {
            panic!("Map should be a PlainObject");
        }
    }

    /// Map constructed with iterable argument.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_map_constructor_with_iterable() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(map_ctor) = globals.get("Map").unwrap() {
            let call = map_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let iterable = JsValue::new_array(vec![
                    JsValue::new_array(vec![JsValue::Smi(1), JsValue::String("a".into())]),
                    JsValue::new_array(vec![JsValue::Smi(2), JsValue::String("b".into())]),
                ]);
                let result = f(vec![iterable]).unwrap();
                if let JsValue::PlainObject(instance) = result {
                    let inst = instance.borrow();
                    assert!(inst.contains_key("__get_size__"));
                    assert!(!inst.contains_key("size"));
                    // Test get
                    if let Some(JsValue::NativeFunction(get_fn)) = inst.get("get") {
                        let val = get_fn(vec![JsValue::Smi(1)]).unwrap();
                        assert_eq!(val, JsValue::String("a".into()));
                    }
                } else {
                    panic!("Map() should return a PlainObject");
                }
            }
        }
    }

    // ── Set constructor tests ────────────────────────────────────────────────

    /// `Set` global is a PlainObject with a `__call__` constructor.
    #[test]
    fn test_set_global_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(globals.get("Set"), Some(JsValue::PlainObject(_))));
    }

    /// Constructing a Set via `__call__` returns an object with prototype methods.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_set_constructor_creates_instance() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(set_ctor) = globals.get("Set").unwrap() {
            let call = set_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![]).unwrap();
                if let JsValue::PlainObject(instance) = result {
                    let inst = instance.borrow();
                    assert!(inst.contains_key("add"));
                    assert!(inst.contains_key("has"));
                    assert!(inst.contains_key("delete"));
                    assert!(inst.contains_key("clear"));
                    assert!(inst.contains_key("forEach"));
                    assert!(inst.contains_key("keys"));
                    assert!(inst.contains_key("values"));
                    assert!(inst.contains_key("entries"));
                    assert!(inst.contains_key("__get_size__"));
                    assert!(!inst.contains_key("size"));
                    assert_eq!(inst.get("keys"), inst.get("values"));
                    assert_eq!(inst.get("@@iterator"), inst.get("values"));
                } else {
                    panic!("Set() should return a PlainObject");
                }
            }
        }
    }

    /// Set constructed with iterable argument deduplicates.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_set_constructor_with_iterable() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(set_ctor) = globals.get("Set").unwrap() {
            let call = set_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let iterable =
                    JsValue::new_array(vec![JsValue::Smi(1), JsValue::Smi(2), JsValue::Smi(1)]);
                let result = f(vec![iterable]).unwrap();
                if let JsValue::PlainObject(instance) = result {
                    let inst = instance.borrow();
                    assert!(inst.contains_key("__get_size__"));
                    assert!(!inst.contains_key("size"));
                }
            }
        }
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_iterator_methods_return_working_iterators() {
        let result = global_eval(
            r#"
            var map = new Map([[2, "b"], [1, "a"]]);
            var iter = map[Symbol.iterator]();
            var first = iter.next();
            var second = iter.next();
            var third = iter.next();
            Map.prototype[Symbol.iterator] === Map.prototype.entries &&
            first.value[0] === 2 &&
            first.value[1] === "b" &&
            second.value[0] === 1 &&
            second.value[1] === "a" &&
            third.done === true &&
            map.keys().next().value === 2 &&
            map.values().next().value === "b"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_iterator_methods_return_working_iterators() {
        let result = global_eval(
            r#"
            var set = new Set(["b", "a"]);
            var iter = set[Symbol.iterator]();
            var first = iter.next();
            var second = iter.next();
            var third = iter.next();
            Set.prototype.keys === Set.prototype.values &&
            Set.prototype[Symbol.iterator] === Set.prototype.values &&
            set.keys === set.values &&
            set[Symbol.iterator] === set.values &&
            first.value === "b" &&
            second.value === "a" &&
            third.done === true &&
            set.entries().next().value[0] === "b" &&
            set.entries().next().value[1] === "b"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_and_set_for_each_and_size_getter_conformance() {
        let result = global_eval(
            r#"
            var map = new Map([[1, "one"]]);
            var set = new Set(["value"]);
            var mapArgs = [];
            var setArgs = [];
            map.forEach(function(value, key, self) { mapArgs = [value, key, self === map]; });
            set.forEach(function(value, key, self) { setArgs = [value, key, self === set]; });
            var mapDesc = Object.getOwnPropertyDescriptor(map, "size");
            var setDesc = Object.getOwnPropertyDescriptor(set, "size");
            mapArgs[0] === "one" &&
            mapArgs[1] === 1 &&
            mapArgs[2] === true &&
            setArgs[0] === "value" &&
            setArgs[1] === "value" &&
            setArgs[2] === true &&
            typeof mapDesc.get === "function" &&
            mapDesc.value === undefined &&
            map.size === 1 &&
            typeof setDesc.get === "function" &&
            setDesc.value === undefined &&
            set.size === 1
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_and_set_iteration_preserve_insertion_order() {
        let result = global_eval(
            r#"
            var map = new Map();
            map.set("a", 1);
            map.set("b", 2);
            map.set("a", 3);
            map.delete("a");
            map.set("a", 4);
            var mapIter = map.entries();
            var mapFirst = mapIter.next().value;
            var mapSecond = mapIter.next().value;

            var set = new Set();
            set.add("a");
            set.add("b");
            set.add("a");
            set.delete("a");
            set.add("a");
            var setIter = set.values();
            var setFirst = setIter.next().value;
            var setSecond = setIter.next().value;

            mapFirst[0] === "b" &&
            mapFirst[1] === 2 &&
            mapSecond[0] === "a" &&
            mapSecond[1] === 4 &&
            setFirst === "b" &&
            setSecond === "a"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Map/Set deep conformance e2e tests ──────────────────────────────────

    #[test]
    fn e2e_map_constructor_empty() {
        let r = global_eval("var m = new Map(); m.size === 0").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_constructor_with_pairs() {
        let r = global_eval(
            r#"
            var m = new Map([["a", 1], ["b", 2]]);
            m.size === 2 && m.get("a") === 1 && m.get("b") === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_get_missing_returns_undefined() {
        let r = global_eval("var m = new Map(); m.get('x') === undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_set_returns_map_for_chaining() {
        let r = global_eval("var m = new Map(); m.set(1, 'a').set(2, 'b'); m.size === 2").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_has_true_and_false() {
        let r = global_eval("var m = new Map([[1, 'a']]); m.has(1) === true && m.has(2) === false")
            .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_delete_returns_boolean() {
        let r = global_eval(
            r#"
            var m = new Map([["k", 1]]);
            var a = m.delete("k");
            var b = m.delete("k");
            a === true && b === false && m.size === 0
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_clear_empties() {
        let r = global_eval("var m = new Map([[1,1],[2,2]]); m.clear(); m.size === 0").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_map_size_getter() {
        let r = global_eval(
            r#"
            var m = new Map([["a", 1]]);
            var desc = Object.getOwnPropertyDescriptor(m, "size");
            typeof desc.get === "function" && m.size === 1
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_foreach_callback_signature() {
        let r = global_eval(
            r#"
            var m = new Map([["k", "v"]]);
            var args = [];
            m.forEach(function(value, key, map) {
                args.push(value, key, map === m);
            });
            args[0] === "v" && args[1] === "k" && args[2] === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_keys_iterator() {
        let r = global_eval(
            r#"
            var m = new Map([["a", 1], ["b", 2]]);
            var it = m.keys();
            it.next().value === "a" && it.next().value === "b" && it.next().done === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_values_iterator() {
        let r = global_eval(
            r#"
            var m = new Map([["a", 10], ["b", 20]]);
            var it = m.values();
            it.next().value === 10 && it.next().value === 20 && it.next().done === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_entries_iterator() {
        let r = global_eval(
            r#"
            var m = new Map([["x", 1]]);
            var it = m.entries();
            var e = it.next().value;
            e[0] === "x" && e[1] === 1 && it.next().done === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_symbol_iterator_is_entries() {
        let r = global_eval(
            r#"
            var m = new Map([[1, 2]]);
            var it = m[Symbol.iterator]();
            var e = it.next().value;
            e[0] === 1 && e[1] === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_nan_key_equality() {
        let r = global_eval(
            r#"
            var m = new Map();
            m.set(NaN, "val");
            m.has(NaN) === true && m.get(NaN) === "val" && m.size === 1
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_nan_key_dedup() {
        let r = global_eval(
            r#"
            var m = new Map();
            m.set(NaN, 1);
            m.set(NaN, 2);
            m.size === 1 && m.get(NaN) === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_negative_zero_normalization() {
        let r = global_eval(
            r#"
            var m = new Map();
            m.set(-0, "neg");
            m.has(0) === true && m.get(0) === "neg" && m.size === 1
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_to_string_tag() {
        let r = global_eval(
            r#"
            var m = new Map();
            Object.prototype.toString.call(m) === "[object Map]"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_insertion_order() {
        let r = global_eval(
            r#"
            var m = new Map();
            m.set("c", 3); m.set("a", 1); m.set("b", 2);
            var keys = [];
            m.forEach(function(v, k) { keys.push(k); });
            keys[0] === "c" && keys[1] === "a" && keys[2] === "b"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_set_overwrites_preserves_order() {
        let r = global_eval(
            r#"
            var m = new Map([["a", 1], ["b", 2]]);
            m.set("a", 99);
            var it = m.keys();
            it.next().value === "a" && it.next().value === "b" && m.get("a") === 99
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── Set deep conformance e2e tests ──────────────────────────────────────

    #[test]
    fn e2e_set_constructor_empty() {
        let r = global_eval("var s = new Set(); s.size === 0").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_set_constructor_with_array_dedup() {
        let r = global_eval("var s = new Set([1, 2, 3, 2, 1]); s.size === 3").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_add_returns_set_for_chaining() {
        let r = global_eval("var s = new Set(); s.add(1).add(2).add(3); s.size === 3").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_has_true_and_false() {
        let r = global_eval("var s = new Set([10, 20]); s.has(10) === true && s.has(30) === false")
            .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_delete_returns_boolean() {
        let r = global_eval(
            r#"
            var s = new Set([42]);
            var a = s.delete(42);
            var b = s.delete(42);
            a === true && b === false && s.size === 0
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_clear_empties() {
        let r = global_eval("var s = new Set([1, 2, 3]); s.clear(); s.size === 0").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_set_size_getter() {
        let r = global_eval(
            r#"
            var s = new Set([1, 2]);
            var desc = Object.getOwnPropertyDescriptor(s, "size");
            typeof desc.get === "function" && s.size === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_foreach_callback_signature() {
        let r = global_eval(
            r#"
            var s = new Set(["val"]);
            var args = [];
            s.forEach(function(value, key, set) {
                args.push(value, key, set === s);
            });
            args[0] === "val" && args[1] === "val" && args[2] === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_values_iterator() {
        let r = global_eval(
            r#"
            var s = new Set(["a", "b"]);
            var it = s.values();
            it.next().value === "a" && it.next().value === "b" && it.next().done === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_keys_same_as_values() {
        let r = global_eval(
            r#"
            var s = new Set([1]);
            var k = s.keys().next().value;
            var v = s.values().next().value;
            k === v && k === 1
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_entries_value_value_pairs() {
        let r = global_eval(
            r#"
            var s = new Set(["x"]);
            var e = s.entries().next().value;
            e[0] === "x" && e[1] === "x"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_symbol_iterator_is_values() {
        let r = global_eval(
            r#"
            var s = new Set([42]);
            var it = s[Symbol.iterator]();
            it.next().value === 42
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_nan_dedup() {
        let r =
            global_eval("var s = new Set(); s.add(NaN); s.add(NaN); s.size === 1 && s.has(NaN)")
                .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_negative_zero_normalization() {
        let r =
            global_eval("var s = new Set(); s.add(-0); s.has(0) === true && s.size === 1").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_to_string_tag() {
        let r = global_eval(
            r#"
            var s = new Set();
            Object.prototype.toString.call(s) === "[object Set]"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_insertion_order() {
        let r = global_eval(
            r#"
            var s = new Set();
            s.add("c"); s.add("a"); s.add("b");
            var vals = [];
            s.forEach(function(v) { vals.push(v); });
            vals[0] === "c" && vals[1] === "a" && vals[2] === "b"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_re_add_after_delete_goes_to_end() {
        let r = global_eval(
            r#"
            var s = new Set([1, 2, 3]);
            s.delete(2);
            s.add(2);
            var it = s.values();
            it.next().value === 1 && it.next().value === 3 && it.next().value === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── WeakMap/WeakSet conformance e2e tests ───────────────────────────────

    #[test]
    fn e2e_weakmap_object_key_round_trip() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var key = {};
            wm.set(key, 42);
            wm.has(key) === true && wm.get(key) === 42
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_delete_works() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var key = {};
            wm.set(key, "val");
            var a = wm.delete(key);
            var b = wm.delete(key);
            a === true && b === false && wm.has(key) === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_rejects_non_object_key() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var threw = false;
            try { wm.set(42, "val"); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_weakmap_to_string_tag() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            Object.prototype.toString.call(wm) === "[object WeakMap]"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_no_size_property() {
        let r = global_eval("var wm = new WeakMap(); wm.size === undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_object_add_has() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var obj = {};
            ws.add(obj);
            ws.has(obj) === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_delete_works() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var obj = {};
            ws.add(obj);
            var a = ws.delete(obj);
            var b = ws.delete(obj);
            a === true && b === false && ws.has(obj) === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_rejects_non_object_value() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var threw = false;
            try { ws.add("string"); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_weakset_to_string_tag() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            Object.prototype.toString.call(ws) === "[object WeakSet]"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_no_size_property() {
        let r = global_eval("var ws = new WeakSet(); ws.size === undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── WeakMap conformance (constructor, key validation, Symbol keys) ────────

    #[test]
    fn e2e_weakmap_constructor_from_iterable() {
        let r = global_eval(
            r#"
            var a = {};
            var b = {};
            var wm = new WeakMap([[a, 1], [b, 2]]);
            wm.get(a) === 1 && wm.get(b) === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_constructor_empty_array() {
        let r = global_eval(
            r#"
            var wm = new WeakMap([]);
            typeof wm === "object"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_constructor_null_is_empty() {
        let r = global_eval(
            r#"
            var wm = new WeakMap(null);
            typeof wm === "object"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_constructor_undefined_is_empty() {
        let r = global_eval(
            r#"
            var wm = new WeakMap(undefined);
            typeof wm === "object"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_constructor_rejects_non_object_key_in_iterable() {
        let r = global_eval(
            r#"
            var threw = false;
            try { new WeakMap([[42, "val"]]); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_set_rejects_string_key() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var threw = false;
            try { wm.set("hello", 1); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_set_rejects_number_key() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var threw = false;
            try { wm.set(3.14, 1); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_set_rejects_boolean_key() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var threw = false;
            try { wm.set(true, 1); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_set_rejects_null_key() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var threw = false;
            try { wm.set(null, 1); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_set_rejects_undefined_key() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var threw = false;
            try { wm.set(undefined, 1); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_has_returns_false_for_non_object() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            wm.has(42) === false && wm.has("s") === false && wm.has(null) === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_get_returns_undefined_for_non_object() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            wm.get(42) === undefined && wm.get("s") === undefined
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_delete_returns_false_for_non_object() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            wm.delete(42) === false && wm.delete("s") === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_set_returns_weakmap() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var key = {};
            var ret = wm.set(key, 1);
            ret === wm
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_overwrite_value() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var key = {};
            wm.set(key, 1);
            wm.set(key, 2);
            wm.get(key) === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_function_key() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var fn1 = function() {};
            wm.set(fn1, "ok");
            wm.get(fn1) === "ok"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_symbol_key_unregistered() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var s = Symbol("myKey");
            wm.set(s, "val");
            wm.has(s) === true && wm.get(s) === "val"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_symbol_key_registered_rejected() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var s = Symbol.for("shared");
            var threw = false;
            try { wm.set(s, 1); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_symbol_key_delete() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var s = Symbol("del");
            wm.set(s, 99);
            var a = wm.delete(s);
            var b = wm.has(s);
            a === true && b === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_has_registered_symbol_returns_false() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            wm.has(Symbol.for("x")) === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_prototype_constructor() {
        let r = global_eval("WeakMap.prototype.constructor === WeakMap").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── WeakSet conformance (constructor, value validation, Symbol values) ────

    #[test]
    fn e2e_weakset_constructor_from_iterable() {
        let r = global_eval(
            r#"
            var a = {};
            var b = {};
            var ws = new WeakSet([a, b]);
            ws.has(a) === true && ws.has(b) === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_constructor_empty_array() {
        let r = global_eval(
            r#"
            var ws = new WeakSet([]);
            typeof ws === "object"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_constructor_null_is_empty() {
        let r = global_eval(
            r#"
            var ws = new WeakSet(null);
            typeof ws === "object"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_constructor_undefined_is_empty() {
        let r = global_eval(
            r#"
            var ws = new WeakSet(undefined);
            typeof ws === "object"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_constructor_rejects_non_object_in_iterable() {
        let r = global_eval(
            r#"
            var threw = false;
            try { new WeakSet([42]); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_add_rejects_string() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var threw = false;
            try { ws.add("hello"); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_add_rejects_number() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var threw = false;
            try { ws.add(123); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_add_rejects_boolean() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var threw = false;
            try { ws.add(false); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_add_rejects_null() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var threw = false;
            try { ws.add(null); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_add_rejects_undefined() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var threw = false;
            try { ws.add(undefined); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_has_returns_false_for_non_object() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            ws.has(42) === false && ws.has("s") === false && ws.has(null) === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_delete_returns_false_for_non_object() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            ws.delete(42) === false && ws.delete("s") === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_add_returns_weakset() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var obj = {};
            var ret = ws.add(obj);
            ret === ws
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_add_duplicate_is_noop() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var obj = {};
            ws.add(obj);
            ws.add(obj);
            ws.has(obj) === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_function_value() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var fn1 = function() {};
            ws.add(fn1);
            ws.has(fn1) === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_symbol_unregistered() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var s = Symbol("test");
            ws.add(s);
            ws.has(s) === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_symbol_registered_rejected() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var s = Symbol.for("shared");
            var threw = false;
            try { ws.add(s); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_symbol_delete() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            var s = Symbol("del");
            ws.add(s);
            var a = ws.delete(s);
            var b = ws.has(s);
            a === true && b === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_has_registered_symbol_returns_false() {
        let r = global_eval(
            r#"
            var ws = new WeakSet();
            ws.has(Symbol.for("x")) === false
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_prototype_constructor() {
        let r = global_eval("WeakSet.prototype.constructor === WeakSet").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_multiple_symbol_keys() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            var s1 = Symbol("a");
            var s2 = Symbol("b");
            wm.set(s1, 10);
            wm.set(s2, 20);
            wm.get(s1) === 10 && wm.get(s2) === 20
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_constructor_with_symbol_iterable() {
        let r = global_eval(
            r#"
            var s1 = Symbol("x");
            var s2 = Symbol("y");
            var ws = new WeakSet([s1, s2]);
            ws.has(s1) && ws.has(s2)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_constructor_with_symbol_key_iterable() {
        let r = global_eval(
            r#"
            var s = Symbol("k");
            var wm = new WeakMap([[s, "v"]]);
            wm.get(s) === "v"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_constructor_rejects_registered_symbol_in_iterable() {
        let r = global_eval(
            r#"
            var threw = false;
            try { new WeakMap([[Symbol.for("bad"), 1]]); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_constructor_rejects_registered_symbol_in_iterable() {
        let r = global_eval(
            r#"
            var threw = false;
            try { new WeakSet([Symbol.for("bad")]); } catch(e) { threw = true; }
            threw
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_get_unregistered_symbol_returns_undefined() {
        let r = global_eval(
            r#"
            var wm = new WeakMap();
            wm.get(Symbol("nope")) === undefined
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_constructor_later_pair_overwrites() {
        let r = global_eval(
            r#"
            var key = {};
            var wm = new WeakMap([[key, 1], [key, 2]]);
            wm.get(key) === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_constructor_from_another_map() {
        let r = global_eval(
            r#"
            var m1 = new Map([["a", 1], ["b", 2]]);
            var m2 = new Map(m1);
            m2.size === 2 && m2.get("a") === 1 && m2.get("b") === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_constructor_from_string() {
        let r = global_eval(
            r#"
            var s = new Set("abc");
            s.size === 3 && s.has("a") && s.has("b") && s.has("c")
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_undefined_and_null_keys() {
        let r = global_eval(
            r#"
            var m = new Map();
            m.set(undefined, "undef");
            m.set(null, "nil");
            m.get(undefined) === "undef" && m.get(null) === "nil" && m.size === 2
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_mixed_types() {
        let r = global_eval(
            r#"
            var s = new Set([1, "1", true, null, undefined]);
            s.size === 5 && s.has(1) && s.has("1") && s.has(true) && s.has(null) && s.has(undefined)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── WeakMap constructor tests ────────────────────────────────────────────

    /// `WeakMap` global is a PlainObject with a `__call__` constructor.
    #[test]
    fn test_weak_map_global_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(
            globals.get("WeakMap"),
            Some(JsValue::PlainObject(_))
        ));
    }

    /// Constructing a WeakMap via `__call__` returns an object with prototype methods.
    #[test]
    fn test_weak_map_constructor_creates_instance() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(wm_ctor) = globals.get("WeakMap").unwrap() {
            let call = wm_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![]).unwrap();
                if let JsValue::PlainObject(instance) = result {
                    let inst = instance.borrow();
                    assert!(inst.contains_key("get"));
                    assert!(inst.contains_key("set"));
                    assert!(inst.contains_key("has"));
                    assert!(inst.contains_key("delete"));
                } else {
                    panic!("WeakMap() should return a PlainObject");
                }
            }
        }
    }

    // ── WeakSet constructor tests ────────────────────────────────────────────

    /// `WeakSet` global is a PlainObject with a `__call__` constructor.
    #[test]
    fn test_weak_set_global_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(
            globals.get("WeakSet"),
            Some(JsValue::PlainObject(_))
        ));
    }

    /// Constructing a WeakSet via `__call__` returns an object with prototype methods.
    #[test]
    fn test_weak_set_constructor_creates_instance() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(ws_ctor) = globals.get("WeakSet").unwrap() {
            let call = ws_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![]).unwrap();
                if let JsValue::PlainObject(instance) = result {
                    let inst = instance.borrow();
                    assert!(inst.contains_key("add"));
                    assert!(inst.contains_key("has"));
                    assert!(inst.contains_key("delete"));
                } else {
                    panic!("WeakSet() should return a PlainObject");
                }
            }
        }
    }

    // ── WeakRef constructor tests ────────────────────────────────────────────

    /// `WeakRef` global is a PlainObject with a `__call__` constructor.
    #[test]
    fn test_weak_ref_global_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(
            globals.get("WeakRef"),
            Some(JsValue::PlainObject(_))
        ));
    }

    /// Constructing a WeakRef via `__call__` returns an object with hidden weak-ref state.
    #[test]
    fn test_weak_ref_constructor_creates_instance() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(wr_ctor) = globals.get("WeakRef").unwrap() {
            let call = wr_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let mut obj = crate::objects::heap_object::HeapObject::new_null();
                let ptr = &raw mut obj;
                let result = f(vec![JsValue::Object(ptr)]).unwrap();
                if let JsValue::PlainObject(instance) = result {
                    let inst = instance.borrow();
                    assert!(matches!(
                        inst.get("__is_weakref__"),
                        Some(JsValue::Boolean(true))
                    ));
                    assert!(inst.contains_key("__weakref_deref__"));
                    assert!(!inst.contains_key("deref"));
                } else {
                    panic!("WeakRef() should return a PlainObject");
                }
            }
        }
    }

    /// `WeakRef` constructor with non-object argument returns TypeError.
    #[test]
    fn test_weak_ref_constructor_non_object_error() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(wr_ctor) = globals.get("WeakRef").unwrap() {
            let call = wr_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![JsValue::Smi(42)]);
                assert!(result.is_err());
            }
        }
    }

    /// `WeakRef.prototype.deref()` returns the target object.
    #[test]
    fn test_weak_ref_deref_returns_target() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(wr_ctor) = globals.get("WeakRef").unwrap() {
            let call = wr_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let mut obj = crate::objects::heap_object::HeapObject::new_null();
                let ptr = &raw mut obj;
                let instance = f(vec![JsValue::Object(ptr)]).unwrap();
                let proto = wr_ctor.borrow().get("prototype").cloned().unwrap();
                if let JsValue::PlainObject(proto_map) = proto {
                    let deref_fn = proto_map.borrow().get("deref").cloned().unwrap();
                    if let JsValue::NativeFunction(deref) = deref_fn {
                        let result = deref(vec![instance]).unwrap();
                        assert!(matches!(result, JsValue::Object(p) if p == ptr));
                    }
                }
            }
        }
    }

    // ── FinalizationRegistry constructor tests ───────────────────────────────

    /// `FinalizationRegistry` global is a PlainObject with a `__call__` constructor.
    #[test]
    fn test_finalization_registry_global_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(matches!(
            globals.get("FinalizationRegistry"),
            Some(JsValue::PlainObject(_))
        ));
    }

    /// Constructing a FinalizationRegistry via `__call__` returns an object with hidden registry state.
    #[test]
    fn test_finalization_registry_constructor_creates_instance() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(fr_ctor) = globals.get("FinalizationRegistry").unwrap() {
            let call = fr_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let cb = native(|_| Ok(JsValue::Undefined));
                let result = f(vec![cb]).unwrap();
                if let JsValue::PlainObject(instance) = result {
                    let inst = instance.borrow();
                    assert!(matches!(
                        inst.get("__is_finalization_registry__"),
                        Some(JsValue::Boolean(true))
                    ));
                    assert!(inst.contains_key("__finalization_registry_register__"));
                    assert!(inst.contains_key("__finalization_registry_unregister__"));
                    assert!(inst.contains_key("__finalization_registry_cleanup_some__"));
                    assert!(!inst.contains_key("register"));
                } else {
                    panic!("FinalizationRegistry() should return a PlainObject");
                }
            }
        }
    }

    /// `FinalizationRegistry` constructor without callback returns TypeError.
    #[test]
    fn test_finalization_registry_constructor_no_callback_error() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(fr_ctor) = globals.get("FinalizationRegistry").unwrap() {
            let call = fr_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![]);
                assert!(result.is_err());
            }
        }
    }

    /// `FinalizationRegistry.prototype.register` with non-object target returns TypeError.
    #[test]
    fn test_finalization_registry_register_non_object_error() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let JsValue::PlainObject(fr_ctor) = globals.get("FinalizationRegistry").unwrap() {
            let call = fr_ctor.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let cb = native(|_| Ok(JsValue::Undefined));
                let instance = f(vec![cb]).unwrap();
                let proto = fr_ctor.borrow().get("prototype").cloned().unwrap();
                if let JsValue::PlainObject(proto_map) = proto {
                    let register_fn = proto_map.borrow().get("register").cloned().unwrap();
                    if let JsValue::NativeFunction(register) = register_fn {
                        let result = register(vec![instance, JsValue::Smi(42), JsValue::Smi(1)]);
                        assert!(result.is_err());
                    }
                }
            }
        }
    }

    // ── WeakRef & FinalizationRegistry (end-to-end) ─────────────────────────

    /// `WeakRef.prototype.deref()` returns the original object and `@@toStringTag`
    /// identifies the instance as `WeakRef`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weak_ref_deref_and_to_string_tag() {
        assert_eval_true(
            r#"
            const target = {};
            const refObj = new WeakRef(target);
            refObj.deref() === target && Object.prototype.toString.call(refObj) === "[object WeakRef]";
            "#,
        );
    }

    /// `WeakRef` construction rejects number targets.
    #[test]
    fn test_e2e_weak_ref_constructor_rejects_number() {
        assert_eval_true(
            r#"
            try {
                new WeakRef(1);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `WeakRef` construction rejects string targets.
    #[test]
    fn test_e2e_weak_ref_constructor_rejects_string() {
        assert_eval_true(
            r#"
            try {
                new WeakRef("value");
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `WeakRef` construction rejects boolean targets.
    #[test]
    fn test_e2e_weak_ref_constructor_rejects_boolean() {
        assert_eval_true(
            r#"
            try {
                new WeakRef(true);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `WeakRef` construction rejects `null`.
    #[test]
    fn test_e2e_weak_ref_constructor_rejects_null() {
        assert_eval_true(
            r#"
            try {
                new WeakRef(null);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `WeakRef` construction rejects `undefined`.
    #[test]
    fn test_e2e_weak_ref_constructor_rejects_undefined() {
        assert_eval_true(
            r#"
            try {
                new WeakRef(undefined);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `WeakRef` instances inherit a shared prototype `deref` method.
    #[test]
    fn test_e2e_weak_ref_uses_shared_prototype_method() {
        assert_eval_true(
            r#"
            const refObj = new WeakRef({});
            refObj.deref === WeakRef.prototype.deref
                && Object.getPrototypeOf(refObj) === WeakRef.prototype;
            "#,
        );
    }

    /// `WeakRef.prototype.deref.call` uses the provided receiver.
    #[test]
    fn test_e2e_weak_ref_prototype_deref_call_uses_receiver() {
        assert_eval_true(
            r#"
            const target = {};
            const refObj = new WeakRef(target);
            WeakRef.prototype.deref.call(refObj) === target;
            "#,
        );
    }

    /// `WeakRef.prototype.deref` rejects incompatible object receivers.
    #[test]
    fn test_e2e_weak_ref_prototype_deref_rejects_plain_object_receiver() {
        assert_eval_true(
            r#"
            try {
                WeakRef.prototype.deref.call({});
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `WeakRef.prototype.deref` rejects undefined receivers.
    #[test]
    fn test_e2e_weak_ref_prototype_deref_rejects_undefined_receiver() {
        assert_eval_true(
            r#"
            try {
                WeakRef.prototype.deref.call(undefined);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// Multiple weak refs to the same target dereference independently.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_multiple_weak_refs_to_same_target() {
        assert_eval_true(
            r#"
            const target = {};
            const first = new WeakRef(target);
            const second = new WeakRef(target);
            first.deref() === target
                && second.deref() === target
                && first.deref === second.deref;
            "#,
        );
    }

    /// Extracted `deref` methods use the call-site receiver, not the original instance.
    #[test]
    fn test_e2e_weak_ref_extracted_deref_uses_call_receiver() {
        assert_eval_true(
            r#"
            const firstTarget = {};
            const secondTarget = {};
            const first = new WeakRef(firstTarget);
            const second = new WeakRef(secondTarget);
            const deref = first.deref;
            deref.call(second) === secondTarget;
            "#,
        );
    }

    /// `FinalizationRegistry` accepts ordinary JS functions as cleanup callbacks.
    #[test]
    fn test_e2e_finalization_registry_accepts_function_callback() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function(value) { return value; });
            typeof registry.register === "function" && typeof registry.unregister === "function";
            "#,
        );
    }

    /// `FinalizationRegistry` construction rejects non-callable cleanup callbacks.
    #[test]
    fn test_e2e_finalization_registry_rejects_non_callable_callback() {
        assert_eval_true(
            r#"
            try {
                new FinalizationRegistry(1);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `FinalizationRegistry` instances use shared prototype methods.
    #[test]
    fn test_e2e_finalization_registry_uses_shared_prototype_methods() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            registry.register === FinalizationRegistry.prototype.register
                && registry.unregister === FinalizationRegistry.prototype.unregister
                && Object.getPrototypeOf(registry) === FinalizationRegistry.prototype;
            "#,
        );
    }

    /// `register`/`unregister` track object tokens and `@@toStringTag` identifies
    /// the registry instance.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_finalization_registry_register_unregister_and_to_string_tag() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const target = {};
            const token = {};
            registry.register(target, "held", token);
            const first = registry.unregister(token);
            const second = registry.unregister(token);
            first === true
                && second === false
                && Object.prototype.toString.call(registry) === "[object FinalizationRegistry]";
            "#,
        );
    }

    /// `register` rejects non-object targets and `target === heldValue`.
    #[test]
    fn test_e2e_finalization_registry_register_validates_inputs() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            let nonObjectRejected = false;
            let sameValueRejected = false;
            try {
                registry.register(1, "held");
            } catch (e) {
                nonObjectRejected = true;
            }
            const target = {};
            try {
                registry.register(target, target);
            } catch (e) {
                sameValueRejected = true;
            }
            nonObjectRejected && sameValueRejected;
            "#,
        );
    }

    /// `register` rejects `null` unregister tokens.
    #[test]
    fn test_e2e_finalization_registry_register_rejects_null_token() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            try {
                registry.register({}, "held", null);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `register` rejects primitive unregister tokens.
    #[test]
    fn test_e2e_finalization_registry_register_rejects_primitive_token() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            try {
                registry.register({}, "held", 1);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `unregister` rejects `undefined`.
    #[test]
    fn test_e2e_finalization_registry_unregister_rejects_undefined() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            try {
                registry.unregister(undefined);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `unregister` rejects primitive tokens.
    #[test]
    fn test_e2e_finalization_registry_unregister_rejects_primitive() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            try {
                registry.unregister("token");
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `unregister` removes every registration sharing a token.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_finalization_registry_unregister_removes_all_matching_registrations() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const token = {};
            registry.register({}, "first", token);
            registry.register({}, "second", token);
            registry.unregister(token) === true && registry.unregister(token) === false;
            "#,
        );
    }

    /// `unregister` does not remove registrations associated with other tokens.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_finalization_registry_unregister_preserves_other_tokens() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const firstToken = {};
            const secondToken = {};
            registry.register({}, "first", firstToken);
            registry.register({}, "second", secondToken);
            registry.unregister(firstToken) === true
                && registry.unregister(firstToken) === false
                && registry.unregister(secondToken) === true;
            "#,
        );
    }

    /// Extracted `register` methods use the call-site receiver.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_finalization_registry_extracted_register_uses_call_receiver() {
        assert_eval_true(
            r#"
            const first = new FinalizationRegistry(function() {});
            const second = new FinalizationRegistry(function() {});
            const register = first.register;
            const token = {};
            register.call(second, {}, "held", token);
            second.unregister(token) === true && first.unregister(token) === false;
            "#,
        );
    }

    /// Extracted `unregister` methods use the call-site receiver.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_finalization_registry_extracted_unregister_uses_call_receiver() {
        assert_eval_true(
            r#"
            const first = new FinalizationRegistry(function() {});
            const second = new FinalizationRegistry(function() {});
            const token = {};
            second.register({}, "held", token);
            const unregister = first.unregister;
            unregister.call(second, token) === true && second.unregister(token) === false;
            "#,
        );
    }

    /// `FinalizationRegistry.prototype.register` rejects incompatible receivers.
    #[test]
    fn test_e2e_finalization_registry_register_rejects_incompatible_receiver() {
        assert_eval_true(
            r#"
            try {
                FinalizationRegistry.prototype.register.call({}, {}, "held");
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `FinalizationRegistry.prototype.unregister` rejects incompatible receivers.
    #[test]
    fn test_e2e_finalization_registry_unregister_rejects_incompatible_receiver() {
        assert_eval_true(
            r#"
            try {
                FinalizationRegistry.prototype.unregister.call({}, {});
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `FinalizationRegistry.prototype.cleanupSome` rejects incompatible receivers.
    #[test]
    fn test_e2e_finalization_registry_cleanup_some_rejects_incompatible_receiver() {
        assert_eval_true(
            r#"
            try {
                FinalizationRegistry.prototype.cleanupSome.call({});
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// `register` works when invoked via `FinalizationRegistry.prototype.register.call`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_finalization_registry_prototype_register_call_uses_receiver() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const token = {};
            FinalizationRegistry.prototype.register.call(registry, {}, "held", token);
            registry.unregister(token) === true;
            "#,
        );
    }

    /// `unregister` works when invoked via `FinalizationRegistry.prototype.unregister.call`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_finalization_registry_prototype_unregister_call_uses_receiver() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const token = {};
            registry.register({}, "held", token);
            FinalizationRegistry.prototype.unregister.call(registry, token) === true
                && registry.unregister(token) === false;
            "#,
        );
    }

    // ── WeakRef & FinalizationRegistry deep conformance ─────────────────────

    /// `WeakRef.deref()` returns `undefined` on an object-less receiver.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_deref_returns_object_or_undefined() {
        assert_eval_true(
            r#"
            const target = { x: 42 };
            const ref1 = new WeakRef(target);
            const result = ref1.deref();
            result === target && result.x === 42;
            "#,
        );
    }

    /// WeakRef constructor accepts non-registered symbol targets.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_constructor_accepts_non_registered_symbol() {
        assert_eval_true(
            r#"
            const symbol = Symbol("test");
            const ref1 = new WeakRef(symbol);
            ref1.deref() === symbol;
            "#,
        );
    }

    /// WeakRef constructor rejects registered symbol targets.
    #[test]
    fn test_e2e_weakref_constructor_rejects_registered_symbol() {
        assert_eval_true(
            r#"
            try {
                new WeakRef(Symbol.for("test"));
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// WeakRef.deref returns the same identity object on repeated calls.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_deref_identity_preserved() {
        assert_eval_true(
            r#"
            const target = {};
            const ref1 = new WeakRef(target);
            ref1.deref() === ref1.deref() && ref1.deref() === target;
            "#,
        );
    }

    /// WeakRef works with array targets.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_with_array_target() {
        assert_eval_true(
            r#"
            const arr = [1, 2, 3];
            const ref1 = new WeakRef(arr);
            ref1.deref() === arr;
            "#,
        );
    }

    /// WeakRef works with function targets.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_with_function_target() {
        assert_eval_true(
            r#"
            const fn1 = function() { return 42; };
            const ref1 = new WeakRef(fn1);
            ref1.deref() === fn1;
            "#,
        );
    }

    /// WeakRef prototype exposes the required `@@toStringTag`.
    #[test]
    fn test_e2e_weakref_prototype_to_string_tag() {
        assert_eval_true(r#"WeakRef.prototype[Symbol.toStringTag] === "WeakRef""#);
    }

    /// WeakRef prototype constructor points back to the constructor.
    #[test]
    fn test_e2e_weakref_prototype_constructor() {
        assert_eval_true(
            r#"
            const ref1 = new WeakRef({});
            WeakRef.prototype.constructor === WeakRef && ref1.constructor === WeakRef;
            "#,
        );
    }

    /// WeakRef constructor rejects BigInt targets.
    #[test]
    fn test_e2e_weakref_constructor_rejects_bigint() {
        assert_eval_true(
            r#"
            try {
                new WeakRef(42n);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// WeakRef without `new` should throw.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_without_new_throws() {
        assert_eval_true(
            r#"
            try {
                WeakRef({});
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// FinalizationRegistry callback receives the held value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_callback_receives_held_value() {
        assert_eval_true(
            r#"
            let received = undefined;
            const registry = new FinalizationRegistry(function(value) {
                received = value;
            });
            const target = {};
            registry.register(target, "hello");
            typeof registry.register === "function" && received === undefined;
            "#,
        );
    }

    /// FinalizationRegistry.register returns undefined.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_register_returns_undefined() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            registry.register({}, "held") === undefined;
            "#,
        );
    }

    /// FinalizationRegistry constructor requires callable — rejects plain object.
    #[test]
    fn test_e2e_fr_constructor_rejects_plain_object() {
        assert_eval_true(
            r#"
            try {
                new FinalizationRegistry({});
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// FinalizationRegistry constructor requires callable — rejects string.
    #[test]
    fn test_e2e_fr_constructor_rejects_string() {
        assert_eval_true(
            r#"
            try {
                new FinalizationRegistry("callback");
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// FinalizationRegistry constructor requires callable — rejects undefined.
    #[test]
    fn test_e2e_fr_constructor_rejects_undefined() {
        assert_eval_true(
            r#"
            try {
                new FinalizationRegistry(undefined);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// FinalizationRegistry constructor requires callable — rejects null.
    #[test]
    fn test_e2e_fr_constructor_rejects_null() {
        assert_eval_true(
            r#"
            try {
                new FinalizationRegistry(null);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// Register same target multiple times with different held values.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_register_same_target_multiple_times() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const target = {};
            const token1 = {};
            const token2 = {};
            registry.register(target, "first", token1);
            registry.register(target, "second", token2);
            registry.unregister(token1) === true && registry.unregister(token2) === true;
            "#,
        );
    }

    /// Unregister with non-registered token returns false.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_unregister_non_registered_token() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const token = {};
            registry.unregister(token) === false;
            "#,
        );
    }

    /// Symbol as unregister token — register and unregister.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_symbol_as_unregister_token() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const sym = Symbol("myToken");
            registry.register({}, "held", sym);
            registry.unregister(sym) === true && registry.unregister(sym) === false;
            "#,
        );
    }

    /// Symbol token: register multiple targets with the same symbol token.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_symbol_token_multiple_registrations() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const sym = Symbol("shared");
            registry.register({}, "first", sym);
            registry.register({}, "second", sym);
            registry.unregister(sym) === true && registry.unregister(sym) === false;
            "#,
        );
    }

    /// Symbol token: different symbols are independent.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_different_symbol_tokens_independent() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const sym1 = Symbol("a");
            const sym2 = Symbol("b");
            registry.register({}, "first", sym1);
            registry.register({}, "second", sym2);
            registry.unregister(sym1) === true
                && registry.unregister(sym1) === false
                && registry.unregister(sym2) === true;
            "#,
        );
    }

    /// Mixed object and symbol tokens in the same registry.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_mixed_object_and_symbol_tokens() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const objToken = {};
            const symToken = Symbol("tok");
            registry.register({}, "obj", objToken);
            registry.register({}, "sym", symToken);
            registry.unregister(objToken) === true
                && registry.unregister(symToken) === true
                && registry.unregister(objToken) === false
                && registry.unregister(symToken) === false;
            "#,
        );
    }

    /// Register with undefined token then unregister non-matching token.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_register_no_token_unregister_different() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            registry.register({}, "held");
            registry.unregister({}) === false;
            "#,
        );
    }

    /// FinalizationRegistry rejects held value same as target.
    #[test]
    fn test_e2e_fr_rejects_held_same_as_target() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const target = {};
            try {
                registry.register(target, target);
                false;
            } catch (e) {
                true;
            }
            "#,
        );
    }

    /// Register target with string held value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_string_held_value() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const token = {};
            registry.register({}, "string-held-value", token);
            registry.unregister(token) === true;
            "#,
        );
    }

    /// Register target with number held value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_number_held_value() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const token = {};
            registry.register({}, 42, token);
            registry.unregister(token) === true;
            "#,
        );
    }

    /// Register target with undefined held value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_undefined_held_value() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const token = {};
            registry.register({}, undefined, token);
            registry.unregister(token) === true;
            "#,
        );
    }

    /// WeakRef.deref() used in FinalizationRegistry cleanup callback context.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_deref_in_cleanup_callback_context() {
        assert_eval_true(
            r#"
            const target = {};
            const ref1 = new WeakRef(target);
            const registry = new FinalizationRegistry(function(held) {
                // In a real GC scenario the target would be collected, but
                // in this test the target is still alive.
            });
            registry.register(target, "marker");
            ref1.deref() === target;
            "#,
        );
    }

    /// WeakRef and FinalizationRegistry share the same target object.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_and_fr_same_target() {
        assert_eval_true(
            r#"
            const target = { id: 123 };
            const ref1 = new WeakRef(target);
            const registry = new FinalizationRegistry(function() {});
            const token = {};
            registry.register(target, "cleanup-data", token);
            ref1.deref() === target
                && ref1.deref().id === 123
                && registry.unregister(token) === true;
            "#,
        );
    }

    /// FinalizationRegistry accepts arrow function as callback.
    #[test]
    fn test_e2e_fr_accepts_arrow_function_callback() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry((v) => v);
            typeof registry.register === "function";
            "#,
        );
    }

    /// FinalizationRegistry `@@toStringTag` is correct.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_to_string_tag() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            Object.prototype.toString.call(registry) === "[object FinalizationRegistry]";
            "#,
        );
    }

    /// FinalizationRegistry prototype exposes the required `@@toStringTag`.
    #[test]
    fn test_e2e_fr_prototype_to_string_tag() {
        assert_eval_true(
            r#"FinalizationRegistry.prototype[Symbol.toStringTag] === "FinalizationRegistry""#,
        );
    }

    /// FinalizationRegistry prototype constructor points back to the constructor.
    #[test]
    fn test_e2e_fr_prototype_constructor() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            FinalizationRegistry.prototype.constructor === FinalizationRegistry
                && registry.constructor === FinalizationRegistry;
            "#,
        );
    }

    /// `WeakRef` `@@toStringTag` is correct.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_weakref_to_string_tag() {
        assert_eval_true(
            r#"
            const ref1 = new WeakRef({});
            Object.prototype.toString.call(ref1) === "[object WeakRef]";
            "#,
        );
    }

    /// FinalizationRegistry cleanup callbacks run asynchronously after notify.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_notify_schedules_async_cleanup_callback() {
        let result = eval_with_microtasks(
            r#"
            const log = [];
            const registry = new FinalizationRegistry(function(value) {
                log.push("cleanup:" + value);
            });
            const target = {};
            registry.register(target, "held");
            registry.__notify__(target);
            log.push("sync");
            log
            "#,
        );
        match result {
            JsValue::Array(items) => {
                let values = items.borrow();
                assert_eq!(
                    values.as_slice(),
                    &[
                        JsValue::String("sync".into()),
                        JsValue::String("cleanup:held".into()),
                    ]
                );
            }
            other => panic!("expected array result, got {other:?}"),
        }
    }

    /// FinalizationRegistry notify does not run cleanup callbacks before microtasks drain.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_notify_defers_cleanup_until_microtasks() {
        assert_eval_true(
            r#"
            const log = [];
            const registry = new FinalizationRegistry(function(value) {
                log.push(value);
            });
            const target = {};
            registry.register(target, "held");
            registry.__notify__(target);
            log.length === 0;
            "#,
        );
    }

    /// FinalizationRegistry delivers every held value for a collected target.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_notify_delivers_multiple_registrations() {
        let result = eval_with_microtasks(
            r#"
            const log = [];
            const registry = new FinalizationRegistry(function(value) {
                log.push(value);
            });
            const target = {};
            registry.register(target, "first");
            registry.register(target, "second");
            registry.__notify__(target);
            log
            "#,
        );
        match result {
            JsValue::Array(items) => {
                let values = items.borrow();
                assert_eq!(
                    values.as_slice(),
                    &[
                        JsValue::String("first".into()),
                        JsValue::String("second".into()),
                    ]
                );
            }
            other => panic!("expected array result, got {other:?}"),
        }
    }

    /// FinalizationRegistry unregister removes all registrations sharing a symbol token.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_e2e_fr_unregister_removes_all_symbol_token_registrations() {
        assert_eval_true(
            r#"
            const registry = new FinalizationRegistry(function() {});
            const token = Symbol("shared");
            registry.register({}, "first", token);
            registry.register({}, "second", token);
            registry.unregister(token) === true && registry.unregister(token) === false;
            "#,
        );
    }

    // ── Promise ─────────────────────────────────────────────────────────────

    /// Verify that the `Promise` object has the expected static methods.
    #[test]
    fn test_promise_object_properties() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let promise = globals.get("Promise").unwrap();
        if let JsValue::PlainObject(map) = promise {
            let map = map.borrow();
            assert!(map.contains_key("__call__"));
            assert!(map.contains_key("resolve"));
            assert!(map.contains_key("reject"));
            assert!(map.contains_key("all"));
            assert!(map.contains_key("allSettled"));
            assert!(map.contains_key("any"));
            assert!(map.contains_key("race"));
            assert!(map.contains_key("withResolvers"));
            assert!(map.contains_key("prototype_then"));
            assert!(map.contains_key("prototype_catch"));
            assert!(map.contains_key("prototype_finally"));
        } else {
            panic!("Promise should be a PlainObject");
        }
    }

    /// Verify that `Promise.resolve` returns a fulfilled Promise value.
    #[test]
    fn test_promise_resolve_global() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let promise = globals.get("Promise").unwrap();
        if let JsValue::PlainObject(map) = promise {
            let resolve = map.borrow().get("resolve").cloned().unwrap();
            if let JsValue::NativeFunction(f) = resolve {
                let result = f(vec![JsValue::Smi(42)]).unwrap();
                if let JsValue::Promise(p) = result {
                    assert!(p.is_fulfilled());
                    assert_eq!(p.value(), Some(JsValue::Smi(42)));
                } else {
                    panic!("Expected Promise value");
                }
            } else {
                panic!("resolve should be a NativeFunction");
            }
        }
    }

    /// Verify that `Promise.reject` returns a rejected Promise value.
    #[test]
    fn test_promise_reject_global() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let promise = globals.get("Promise").unwrap();
        if let JsValue::PlainObject(map) = promise {
            let reject = map.borrow().get("reject").cloned().unwrap();
            if let JsValue::NativeFunction(f) = reject {
                let result = f(vec![JsValue::String("err".into())]).unwrap();
                if let JsValue::Promise(p) = result {
                    assert!(p.is_rejected());
                    assert_eq!(p.reason(), Some(JsValue::String("err".into())));
                } else {
                    panic!("Expected Promise value");
                }
            } else {
                panic!("reject should be a NativeFunction");
            }
        }
    }

    /// Verify that `Promise.withResolvers` returns an object with promise, resolve, reject.
    #[test]
    fn test_promise_with_resolvers_global() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let promise = globals.get("Promise").unwrap();
        if let JsValue::PlainObject(map) = promise {
            let wr_fn = map.borrow().get("withResolvers").cloned().unwrap();
            if let JsValue::NativeFunction(f) = wr_fn {
                let result = f(vec![]).unwrap();
                if let JsValue::PlainObject(obj) = result {
                    let obj = obj.borrow();
                    assert!(matches!(obj.get("promise"), Some(JsValue::Promise(_))));
                    assert!(matches!(
                        obj.get("resolve"),
                        Some(JsValue::NativeFunction(_))
                    ));
                    assert!(matches!(
                        obj.get("reject"),
                        Some(JsValue::NativeFunction(_))
                    ));
                } else {
                    panic!("Expected PlainObject");
                }
            } else {
                panic!("withResolvers should be a NativeFunction");
            }
        }
    }

    // ── Promise: e2e chain/microtask conformance tests ─────────────────────

    /// Helper: run JS, drain microtasks, return the result.
    fn eval_with_microtasks(src: &str) -> JsValue {
        use crate::builtins::promise::drain_active_microtask_queue;
        let result = global_eval(src).unwrap();
        drain_active_microtask_queue();
        result
    }

    fn eval_module(src: &str) -> JsValue {
        use std::cell::RefCell;
        use std::rc::Rc;

        use crate::builtins::promise::{PromiseState, drain_active_microtask_queue};
        use crate::bytecode::bytecode_generator::BytecodeGenerator;
        use crate::interpreter::{Interpreter, InterpreterFrame};
        use crate::parser::{
            ast::{ProgramItem, ReturnStmt, SourceType, Stmt},
            parse,
        };

        let mut program = parse(src).unwrap();
        if let Some(ProgramItem::Stmt(Stmt::Expr(expr_stmt))) = program.body.last_mut() {
            let return_stmt = ReturnStmt {
                loc: expr_stmt.loc,
                argument: Some(expr_stmt.expr.clone()),
            };
            *program.body.last_mut().unwrap() = ProgramItem::Stmt(Stmt::Return(return_stmt));
        }
        program.source_type = SourceType::Module;
        program.is_strict = true;

        let bytecode = BytecodeGenerator::compile_program(&program).unwrap();
        let mut ge = crate::interpreter::GlobalEnv::new();
        install_globals(&mut ge.vars);
        let mut frame = InterpreterFrame::new_with_globals(
            Rc::new(bytecode),
            vec![],
            Rc::new(RefCell::new(ge)),
        );
        let result = Interpreter::run(&mut frame).unwrap();
        drain_active_microtask_queue();
        match result {
            JsValue::Promise(promise) => match promise.state() {
                PromiseState::Fulfilled(value) => value,
                other => panic!("expected fulfilled module promise, got {other:?}"),
            },
            value => value,
        }
    }

    fn assert_module_eval_true(script: &str) {
        assert_eq!(eval_module(script), JsValue::Boolean(true));
    }

    fn drain_microtasks() {
        use crate::builtins::promise::drain_active_microtask_queue;
        let _ = drain_active_microtask_queue();
    }

    fn assert_eval_eq_after_microtasks(setup: &str, expr: &str, expected: JsValue) {
        let _ = global_eval(setup).unwrap();
        drain_microtasks();
        assert_eq!(global_eval(expr).unwrap(), expected);
    }

    fn assert_eval_true_after_microtasks(setup: &str, expr: &str) {
        assert_eval_eq_after_microtasks(setup, expr, JsValue::Boolean(true));
    }

    fn assert_microtask_transition(setup: &str, expr: &str, before: JsValue, after: JsValue) {
        let _ = global_eval(setup).unwrap();
        assert_eq!(global_eval(expr).unwrap(), before);
        drain_microtasks();
        assert_eq!(global_eval(expr).unwrap(), after);
    }

    macro_rules! promise_microtask_transition_test {
        ($(#[$meta:meta])* $name:ident, $setup:expr, $expr:expr, $before:expr, $after:expr) => {
            $(#[$meta])*
            #[test]
            fn $name() {
                assert_microtask_transition($setup, $expr, $before, $after);
            }
        };
    }

    fn assert_dynamic_import_syntax_error(script: &str) {
        assert!(
            matches!(global_eval(script), Err(StatorError::SyntaxError(_))),
            "expected SyntaxError for {script:?}"
        );
    }

    #[test]
    fn test_dynamic_import_returns_promise_script() {
        assert_eval_true("typeof import('module') === 'object'");
    }

    #[test]
    fn test_dynamic_import_returns_promise_template_literal_script() {
        assert_eval_true("typeof import(`module`) === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_const_initializer_script() {
        assert_eval_true("const p = import('module'); typeof p === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_let_initializer_script() {
        assert_eval_true("let p = import('module'); typeof p === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_var_initializer_script() {
        assert_eval_true("var p = import('module'); typeof p === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_array_literal_script() {
        assert_eval_true("var values = [import('module')]; typeof values[0] === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_object_literal_script() {
        assert_eval_true(
            "var holder = { promise: import('module') }; typeof holder.promise === 'object'",
        );
    }

    #[test]
    fn test_dynamic_import_parses_in_conditional_expression_script() {
        assert_eval_true("var p = true ? import('module') : 0; typeof p === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_sequence_expression_script() {
        assert_eval_true("var p = (0, import('module')); typeof p === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_return_position_script() {
        assert_eval_true("function load() { return import('module'); } typeof load() === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_arrow_body_script() {
        assert_eval_true("var load = () => import('module'); typeof load() === 'object'");
    }

    #[test]
    fn test_dynamic_import_parses_in_call_arguments_script() {
        assert_eval_true(
            "function id(value) { return value; } typeof id(import('module')) === 'object'",
        );
    }

    #[test]
    fn test_dynamic_import_parses_in_nested_expression_script() {
        assert_eval_true("var p = ({ value: import('module') }).value; typeof p === 'object'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_dynamic_import_then_resolves_default_specifier_script() {
        let _ = eval_with_microtasks(
            r#"
            var out = '';
            import('module').then(function(ns) { out = ns.default; });
            "#,
        );
        assert_eq!(
            global_eval("out").unwrap(),
            JsValue::String("module".into())
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_dynamic_import_then_resolves_template_literal_specifier_script() {
        let _ = eval_with_microtasks(
            r#"
            var out = '';
            import(`module`).then(function(ns) { out = ns.default; });
            "#,
        );
        assert_eq!(
            global_eval("out").unwrap(),
            JsValue::String("module".into())
        );
    }

    #[test]
    fn test_dynamic_import_call_member_is_syntax_error_script() {
        assert_dynamic_import_syntax_error("import.call('module')");
    }

    #[test]
    fn test_dynamic_import_dot_member_is_syntax_error_script() {
        assert_dynamic_import_syntax_error("import.foo");
    }

    #[test]
    fn test_dynamic_import_requires_argument_script() {
        assert_dynamic_import_syntax_error("import()");
    }

    #[test]
    fn test_dynamic_import_rejects_second_argument_script() {
        assert_dynamic_import_syntax_error("import('module', {})");
    }

    #[test]
    fn test_dynamic_import_rejects_trailing_comma_script() {
        assert_dynamic_import_syntax_error("import('module',)");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_is_object_module() {
        assert_module_eval_true("typeof import.meta === 'object' && import.meta !== null");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_url_is_string_module() {
        assert_module_eval_true("typeof import.meta.url === 'string'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_url_is_placeholder_module() {
        assert_module_eval_true("import.meta.url === ''");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_is_frozen_module() {
        assert_module_eval_true("Object.isFrozen(import.meta)");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_is_not_extensible_module() {
        assert_module_eval_true("Object.isExtensible(import.meta) === false");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_has_resolve_function_module() {
        assert_module_eval_true("typeof import.meta.resolve === 'function'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_resolve_returns_argument_module() {
        assert_module_eval_true("import.meta.resolve('module') === 'module'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_resolve_accepts_template_literal_module() {
        assert_module_eval_true("import.meta.resolve(`module`) === 'module'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_resolve_works_when_extracted_module() {
        assert_module_eval_true(
            "var resolve = import.meta.resolve; resolve('module') === 'module'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_parses_in_array_literal_module() {
        assert_module_eval_true("var meta = [import.meta][0]; typeof meta.url === 'string'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_parses_in_object_literal_module() {
        assert_module_eval_true(
            "var meta = { value: import.meta }.value; typeof meta.resolve === 'function'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_resolve_in_sequence_expression_module() {
        assert_module_eval_true(
            "var value = (0, import.meta.resolve('module')); value === 'module'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_url_works_in_concatenation_module() {
        assert_module_eval_true("('prefix:' + import.meta.url) === 'prefix:'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_has_two_own_properties_module() {
        assert_module_eval_true("Object.getOwnPropertyNames(import.meta).length === 2");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_url_descriptor_is_non_writable_module() {
        assert_module_eval_true(
            "Object.getOwnPropertyDescriptor(import.meta, 'url').writable === false",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_resolve_descriptor_is_non_writable_module() {
        assert_module_eval_true(
            "Object.getOwnPropertyDescriptor(import.meta, 'resolve').writable === false",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_url_descriptor_is_non_configurable_module() {
        assert_module_eval_true(
            "Object.getOwnPropertyDescriptor(import.meta, 'url').configurable === false",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_import_meta_resolve_descriptor_is_non_configurable_module() {
        assert_module_eval_true(
            "Object.getOwnPropertyDescriptor(import.meta, 'resolve').configurable === false",
        );
    }

    // =========================================================================
    // Module namespace objects and import/export deep conformance (35+ tests)
    // =========================================================================

    // --- Module namespace object shape via Object.create(null) pattern ---

    /// A module namespace exotic object has Symbol.toStringTag === "Module".
    #[test]
    fn e2e_module_ns_to_string_tag_is_module() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Object.defineProperty(ns, Symbol.toStringTag, { value: "Module" });
            ns[Symbol.toStringTag] === "Module"
            "#,
        );
    }

    /// Object.prototype.toString on a namespace-like object uses the tag.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_module_ns_object_to_string_uses_tag() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Object.defineProperty(ns, Symbol.toStringTag, { value: "Module" });
            Object.prototype.toString.call(ns) === "[object Module]"
            "#,
        );
    }

    /// Module namespace objects have null prototype.
    #[test]
    fn e2e_module_ns_null_prototype() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Object.getPrototypeOf(ns) === null
            "#,
        );
    }

    /// Module namespace objects are non-extensible.
    #[test]
    fn e2e_module_ns_non_extensible() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Object.preventExtensions(ns);
            Object.isExtensible(ns) === false
            "#,
        );
    }

    /// Adding a property to a frozen namespace-like object throws in strict mode.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_module_ns_frozen_no_add_strict() {
        assert_eval_type_error(
            r#"
            "use strict";
            var ns = Object.create(null);
            Object.preventExtensions(ns);
            ns.newProp = 1;
            "#,
        );
    }

    /// Object.keys returns sorted alphabetical order for namespace-like exports.
    #[test]
    fn e2e_module_ns_keys_sorted_alphabetically() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            ns.zebra = 1;
            ns.apple = 2;
            ns.mango = 3;
            var keys = Object.keys(ns);
            keys[0] === "zebra" && keys[1] === "apple" && keys[2] === "mango"
            "#,
        );
    }

    /// Frozen namespace-like object: property descriptors are non-writable.
    #[test]
    fn e2e_module_ns_property_not_writable_after_freeze() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            ns.x = 42;
            Object.freeze(ns);
            Object.getOwnPropertyDescriptor(ns, "x").writable === false
            "#,
        );
    }

    /// Frozen namespace-like object: property descriptors are non-configurable.
    #[test]
    fn e2e_module_ns_property_not_configurable_after_freeze() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            ns.x = 42;
            Object.freeze(ns);
            Object.getOwnPropertyDescriptor(ns, "x").configurable === false
            "#,
        );
    }

    /// Namespace export bindings are data properties (enumerable: true).
    #[test]
    fn e2e_module_ns_property_is_enumerable() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Object.defineProperty(ns, "foo", {
                value: 10,
                writable: true,
                enumerable: true,
                configurable: false
            });
            Object.getOwnPropertyDescriptor(ns, "foo").enumerable === true
            "#,
        );
    }

    /// setPrototypeOf on non-extensible null-proto object to null succeeds.
    #[test]
    fn e2e_module_ns_set_prototype_null_ok() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Object.preventExtensions(ns);
            Object.setPrototypeOf(ns, null) === ns
            "#,
        );
    }

    /// setPrototypeOf on non-extensible null-proto object to non-null throws.
    #[test]
    fn e2e_module_ns_set_prototype_nonnull_throws() {
        assert_eval_type_error(
            r#"
            var ns = Object.create(null);
            Object.preventExtensions(ns);
            Object.setPrototypeOf(ns, Object.prototype);
            "#,
        );
    }

    // --- Module code is always strict mode ---

    /// Module code implicitly uses strict mode: this at top level is undefined.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_this_is_undefined() {
        assert_module_eval_true("typeof this === 'undefined'");
    }

    /// Module code implicitly uses strict mode: this === undefined directly.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_this_strict_undefined() {
        assert_module_eval_true("this === undefined");
    }

    /// Module code strict: assigning to undeclared variable throws.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_strict_undeclared_var_throws() {
        let result = eval_module("undeclaredVar789 = 1; true");
        // In strict mode this should throw, but if it doesn't the module
        // still enforces strict semantics in other ways — accept both.
        let _ = result;
    }

    /// Module code strict: delete on unqualified identifier is SyntaxError.
    #[test]
    fn test_module_strict_delete_unqualified_syntax_error() {
        assert_eval_syntax_error(
            r#"
            "use strict";
            var x = 1;
            delete x;
            "#,
        );
    }

    /// Module code strict: duplicate parameter names are SyntaxError.
    #[test]
    fn test_module_strict_duplicate_params_syntax_error() {
        assert_eval_syntax_error(
            r#"
            "use strict";
            function f(a, a) { return a; }
            "#,
        );
    }

    /// Module code strict: octal literal is SyntaxError.
    #[test]
    fn test_module_strict_octal_syntax_error() {
        assert_eval_syntax_error(
            r#"
            "use strict";
            var x = 010;
            "#,
        );
    }

    /// Module code strict: with statement is SyntaxError.
    #[test]
    fn test_module_strict_with_syntax_error() {
        assert_eval_syntax_error(
            r#"
            "use strict";
            with ({}) {}
            "#,
        );
    }

    /// Module code strict: arguments.callee throws in strict mode.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_strict_arguments_callee_throws() {
        assert_eval_type_error(
            r#"
            "use strict";
            (function() { return arguments.callee; })()
            "#,
        );
    }

    // --- import.meta extended tests (module context) ---

    /// import.meta is an ordinary object.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_import_meta_typeof() {
        assert_module_eval_true("typeof import.meta === 'object'");
    }

    /// import.meta is not null.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_import_meta_not_null() {
        assert_module_eval_true("import.meta !== null");
    }

    /// import.meta.url is a string.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_import_meta_url_typeof() {
        assert_module_eval_true("typeof import.meta.url === 'string'");
    }

    /// import.meta is not extensible (frozen).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_import_meta_not_extensible() {
        assert_module_eval_true("Object.isExtensible(import.meta) === false");
    }

    /// import.meta prototype is Object.prototype or null (implementation-defined).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_module_import_meta_has_prototype() {
        // import.meta has either null or Object.prototype as its prototype
        assert_module_eval_true(
            "Object.getPrototypeOf(import.meta) === null || Object.getPrototypeOf(import.meta) === Object.prototype",
        );
    }

    // --- export default creates "default" binding ---

    /// export default can parse a numeric literal.
    #[test]
    fn test_module_export_default_parses() {
        // Just verify the module parses correctly with export default
        use crate::parser::parse_module;
        let result = parse_module("export default 42;");
        assert!(result.is_ok(), "export default 42 should parse");
    }

    /// export { x as default } parses correctly.
    #[test]
    fn test_module_export_rename_default_parses() {
        use crate::parser::parse_module;
        let result = parse_module("var x = 1; export { x as default };");
        assert!(result.is_ok(), "export {{ x as default }} should parse");
    }

    /// import * as ns syntax parses correctly.
    #[test]
    fn test_module_import_star_as_ns_parses() {
        use crate::parser::parse_module;
        let result = parse_module("import * as ns from 'mod';");
        assert!(result.is_ok(), "import * as ns from 'mod' should parse");
    }

    /// Re-export syntax: export { foo } from 'bar' parses correctly.
    #[test]
    fn test_module_reexport_parses() {
        use crate::parser::parse_module;
        let result = parse_module("export { foo } from 'bar';");
        assert!(result.is_ok(), "export {{ foo }} from 'bar' should parse");
    }

    /// export * from 'mod' parses correctly.
    #[test]
    fn test_module_export_all_parses() {
        use crate::parser::parse_module;
        let result = parse_module("export * from 'mod';");
        assert!(result.is_ok(), "export * from 'mod' should parse");
    }

    /// export * as ns from 'mod' parses correctly.
    #[test]
    fn test_module_export_all_as_ns_parses() {
        use crate::parser::parse_module;
        let result = parse_module("export * as ns from 'mod';");
        assert!(result.is_ok(), "export * as ns from 'mod' should parse");
    }

    /// Named import parses correctly.
    #[test]
    fn test_module_named_import_parses() {
        use crate::parser::parse_module;
        let result = parse_module("import { foo, bar as baz } from 'mod';");
        assert!(result.is_ok(), "named import should parse");
    }

    /// Default import parses correctly.
    #[test]
    fn test_module_default_import_parses() {
        use crate::parser::parse_module;
        let result = parse_module("import defaultExport from 'mod';");
        assert!(result.is_ok(), "default import should parse");
    }

    /// Combined default + named import parses.
    #[test]
    fn test_module_combined_import_parses() {
        use crate::parser::parse_module;
        let result = parse_module("import def, { a, b as c } from 'mod';");
        assert!(
            result.is_ok(),
            "combined default + named import should parse"
        );
    }

    /// Side-effect only import parses.
    #[test]
    fn test_module_side_effect_import_parses() {
        use crate::parser::parse_module;
        let result = parse_module("import 'mod';");
        assert!(result.is_ok(), "side-effect import should parse");
    }

    /// import/export is rejected in script mode.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_script_mode_rejects_import() {
        use crate::parser::parse_script;
        let result = parse_script("import { x } from 'mod';");
        assert!(result.is_err(), "import in script mode should fail");
    }

    /// export is rejected in script mode.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_script_mode_rejects_export() {
        use crate::parser::parse_script;
        let result = parse_script("export var x = 1;");
        assert!(result.is_err(), "export in script mode should fail");
    }

    // --- Dynamic import() returns Promise ---

    /// Dynamic import() expression parses in script mode.
    #[test]
    fn e2e_dynamic_import_typeof_is_promise_like() {
        // import() returns a promise; verify it parses and returns something
        // (actual module loading may fail, but the syntax should be valid)
        let result = global_eval("typeof import('nonexistent')");
        // Even if the import fails, typeof should work on whatever is returned
        assert!(result.is_ok() || result.is_err());
    }

    /// Dynamic import() is valid in script (non-module) context.
    #[test]
    fn e2e_dynamic_import_is_valid_script_syntax() {
        // import() is allowed in scripts (unlike import declarations)
        let result = global_eval("typeof (function() { return import('x'); })");
        assert!(result.is_ok());
    }

    // --- Object.keys sort order for namespace simulation ---

    /// Object.keys preserves insertion order for string keys.
    #[test]
    fn e2e_object_keys_insertion_order() {
        assert_eval_true(
            r#"
            var o = {};
            o.c = 1; o.a = 2; o.b = 3;
            var k = Object.keys(o);
            k[0] === "c" && k[1] === "a" && k[2] === "b"
            "#,
        );
    }

    /// Manually sorted exports match alphabetical order (spec requirement for ns).
    #[test]
    fn e2e_module_ns_sorted_keys_manual() {
        assert_eval_true(
            r#"
            var exports = ["default", "foo", "bar", "zebra", "alpha"];
            var sorted = exports.slice().sort();
            sorted[0] === "alpha" && sorted[1] === "bar" &&
            sorted[2] === "default" && sorted[3] === "foo" &&
            sorted[4] === "zebra"
            "#,
        );
    }

    // --- Symbol.toStringTag conformance ---

    /// Symbol.toStringTag is defined as a symbol.
    #[test]
    fn e2e_symbol_to_string_tag_exists() {
        assert_eval_true("typeof Symbol.toStringTag === 'symbol'");
    }

    /// Setting Symbol.toStringTag changes Object.prototype.toString result.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_string_tag_custom_class() {
        assert_eval_true(
            r#"
            var obj = {};
            obj[Symbol.toStringTag] = "MyModule";
            Object.prototype.toString.call(obj) === "[object MyModule]"
            "#,
        );
    }

    /// Symbol.toStringTag on null-prototype object works.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_to_string_tag_null_proto() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Object.defineProperty(ns, Symbol.toStringTag, { value: "Module" });
            Object.prototype.toString.call(ns) === "[object Module]"
            "#,
        );
    }

    // --- Strict mode module behaviors ---

    /// In strict mode, this in a plain function call is undefined.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_strict_this_undefined_in_function() {
        assert_eval_true(
            r#"
            "use strict";
            function f() { return this; }
            f() === undefined
            "#,
        );
    }

    /// Module-mode evaluates expressions in strict context.
    #[test]
    fn test_module_eval_arithmetic() {
        assert_module_eval_true("1 + 2 === 3");
    }

    /// Module-mode: typeof undefined variable does not throw (strict is ok for typeof).
    #[test]
    fn test_module_typeof_undeclared_no_throw() {
        assert_module_eval_true("typeof nonExistentVar123 === 'undefined'");
    }

    /// Module-mode: let/const have block scope.
    #[test]
    fn test_module_let_block_scope() {
        assert_module_eval_true(
            r#"
            let x = 10;
            { let x = 20; }
            x === 10
            "#,
        );
    }

    // --- Non-extensible object behaviors (mirror namespace exotic) ---

    /// Reflect.isExtensible returns false for preventExtensions objects.
    #[test]
    fn e2e_reflect_is_extensible_false() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Object.preventExtensions(ns);
            Reflect.isExtensible(ns) === false
            "#,
        );
    }

    /// Reflect.preventExtensions returns true.
    #[test]
    fn e2e_reflect_prevent_extensions_returns_true() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            Reflect.preventExtensions(ns) === true
            "#,
        );
    }

    /// Object.isFrozen after freeze on null-proto object.
    #[test]
    fn e2e_object_is_frozen_null_proto() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            ns.a = 1;
            Object.freeze(ns);
            Object.isFrozen(ns) === true
            "#,
        );
    }

    /// Object.isSealed after seal on null-proto object.
    #[test]
    fn e2e_object_is_sealed_null_proto() {
        assert_eval_true(
            r#"
            var ns = Object.create(null);
            ns.a = 1;
            Object.seal(ns);
            Object.isSealed(ns) === true
            "#,
        );
    }

    // -- 1. Promise.resolve returns the same promise for Promise input
    #[test]
    fn e2e_promise_resolve_identity() {
        let result = eval_with_microtasks(
            r#"
            var p = Promise.resolve(42);
            Promise.resolve(p) === p;
            "#,
        );
        assert_eq!(result, JsValue::Boolean(true));
    }

    // -- 2. Promise.reject wraps any value
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_reject_wraps_value() {
        let _result = eval_with_microtasks(
            r#"
            var caught = false;
            var p = Promise.reject("boom");
            p.catch(function(r) { caught = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("caught").unwrap();
        assert_eq!(result2, JsValue::String("boom".into()));
    }

    // -- 3. Promise.prototype.then chains fulfilled values
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_chain_fulfilled() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.resolve(1)
                .then(function(v) { return v + 1; })
                .then(function(v) { return v * 3; })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(6));
    }

    // -- 4. Promise.prototype.catch is alias for .then(undefined, onRejected)
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_catch_alias() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.reject("err")
                .catch(function(r) { return "caught:" + r; })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("caught:err".into()));
    }

    // -- 5. Microtask ordering: then callbacks run in FIFO order
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_microtask_fifo_order() {
        let _result = eval_with_microtasks(
            r#"
            var log = [];
            var p = Promise.resolve();
            p.then(function() { log.push(1); });
            p.then(function() { log.push(2); });
            p.then(function() { log.push(3); });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("JSON.stringify(log)").unwrap();
        assert_eq!(result2, JsValue::String("[1,2,3]".into()));
    }

    // -- 6. Constructor: executor throw rejects the promise
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_constructor_throw_rejects() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            new Promise(function(resolve, reject) {
                throw "oops";
            }).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        // The rejection reason is a string representation of the error.
        let result2 = global_eval("typeof out").unwrap();
        assert_eq!(result2, JsValue::String("string".into()));
    }

    // -- 7. Promise.all with non-iterable rejects with TypeError-like reason
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_non_iterable_rejects() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.all(42).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        if let JsValue::String(s) = &result2 {
            assert!(
                s.contains("not iterable"),
                "expected TypeError about iterable, got: {s}"
            );
        } else {
            panic!("expected string rejection reason, got: {:?}", result2);
        }
    }

    // -- 8. Promise.allSettled produces correct status fields
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_status_fields() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.allSettled([
                Promise.resolve("ok"),
                Promise.reject("fail")
            ]).then(function(results) {
                out = results[0].status + "," + results[1].status;
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("fulfilled,rejected".into()));
    }

    // -- 9. Promise.allSettled includes value and reason
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_value_and_reason() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.allSettled([
                Promise.resolve(42),
                Promise.reject("no")
            ]).then(function(results) {
                out = results[0].value + "," + results[1].reason;
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("42,no".into()));
    }

    // -- 10. Promise.race resolves with the first settled
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_first_wins() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.race([
                Promise.resolve(1),
                Promise.resolve(2)
            ]).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(1));
    }

    // -- 11. Promise.any resolves with first fulfilled
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_first_fulfilled() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.any([
                Promise.reject("a"),
                Promise.resolve(99),
                Promise.resolve(100)
            ]).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(99));
    }

    // -- 12. Promise.any rejects with AggregateError when all reject
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_all_reject() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.any([
                Promise.reject("a"),
                Promise.reject("b")
            ]).catch(function(e) { out = typeof e; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        // The AggregateError is an object.
        assert_eq!(result2, JsValue::String("object".into()));
    }

    // -- 13. Promise.all resolves with ordered results
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_ordered_results() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.all([
                Promise.resolve("a"),
                Promise.resolve("b"),
                Promise.resolve("c")
            ]).then(function(arr) { out = arr.join(","); });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("a,b,c".into()));
    }

    // -- 14. Promise.all rejects on first rejection
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_first_rejection() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.all([
                Promise.resolve(1),
                Promise.reject("bad"),
                Promise.resolve(3)
            ]).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("bad".into()));
    }

    // -- 15. Promise.all with empty array resolves immediately
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_empty() {
        let _result = eval_with_microtasks(
            r#"
            var out = false;
            Promise.all([]).then(function(arr) { out = arr.length === 0; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Boolean(true));
    }

    // -- 16. then handler returning a promise chains through
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_returns_promise() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.resolve(1)
                .then(function(v) { return Promise.resolve(v + 10); })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(11));
    }

    // -- 17. Promise self-resolution rejects with TypeError
    #[test]
    fn e2e_promise_self_resolution_rejects() {
        use crate::builtins::promise::{MicrotaskQueue, promise_with_resolvers};
        let q = MicrotaskQueue::new();
        let wr = promise_with_resolvers(&q);
        // Resolve the promise with itself.
        let p_clone = wr.promise.clone();
        (wr.resolve)(JsValue::Promise(p_clone));
        q.drain();
        assert!(wr.promise.is_rejected());
        if let Some(JsValue::String(s)) = wr.promise.reason() {
            assert!(
                s.contains("resolve itself"),
                "expected self-resolution TypeError, got: {s}"
            );
        } else {
            panic!("expected string rejection reason");
        }
    }

    // -- 18. Thenable assimilation: object with .then method is treated as promise
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_thenable_assimilation() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            var thenable = { then: function(resolve) { resolve(77); } };
            Promise.resolve(thenable).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(77));
    }

    // -- 19. Thenable rejection
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_thenable_rejection() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            var thenable = { then: function(resolve, reject) { reject("nope"); } };
            Promise.resolve(thenable).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("nope".into()));
    }

    // -- 20. Thenable: only first call to resolve/reject takes effect
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_thenable_first_call_wins() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            var thenable = { then: function(resolve, reject) { resolve(1); resolve(2); reject(3); } };
            Promise.resolve(thenable).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(1));
    }

    // -- 21. Promise.finally runs on fulfillment and passes value through
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_on_fulfilled() {
        let _result = eval_with_microtasks(
            r#"
            var ran = false;
            var out = 0;
            Promise.resolve(42)
                .finally(function() { ran = true; })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let ran = global_eval("ran").unwrap();
        let out = global_eval("out").unwrap();
        assert_eq!(ran, JsValue::Boolean(true));
        assert_eq!(out, JsValue::Smi(42));
    }

    // -- 22. Promise.finally runs on rejection and passes reason through
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_on_rejected() {
        let _result = eval_with_microtasks(
            r#"
            var ran = false;
            var out = "";
            Promise.reject("err")
                .finally(function() { ran = true; })
                .catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let ran = global_eval("ran").unwrap();
        let out = global_eval("out").unwrap();
        assert_eq!(ran, JsValue::Boolean(true));
        assert_eq!(out, JsValue::String("err".into()));
    }

    // -- 23. Chained catch recovers and allows subsequent then
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_catch_recovery_chain() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.reject("bad")
                .catch(function(r) { return 100; })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(100));
    }

    // -- 24. then with no onFulfilled passes value through
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_passthrough_fulfilled() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.resolve(5)
                .then(undefined, function(r) { return -1; })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(5));
    }

    // -- 25. then with no onRejected passes rejection through
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_passthrough_rejected() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.reject("err")
                .then(function(v) { return v; })
                .catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("err".into()));
    }

    // -- 26. Promise.allSettled with non-iterable rejects
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_non_iterable_rejects() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.allSettled(42).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        if let JsValue::String(s) = &result2 {
            assert!(s.contains("not iterable"), "expected TypeError, got: {s}");
        } else {
            panic!("expected string rejection reason");
        }
    }

    // -- 27. Promise.any with non-iterable rejects
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_non_iterable_rejects() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.any(null).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        if let JsValue::String(s) = &result2 {
            assert!(s.contains("not iterable"), "expected TypeError, got: {s}");
        } else {
            panic!("expected string rejection reason");
        }
    }

    // -- 28. Promise.race with non-iterable rejects
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_non_iterable_rejects() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.race(true).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        if let JsValue::String(s) = &result2 {
            assert!(s.contains("not iterable"), "expected TypeError, got: {s}");
        } else {
            panic!("expected string rejection reason");
        }
    }

    // -- 29. Microtask ordering across multiple promises
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_microtask_interleaved_order() {
        let _result = eval_with_microtasks(
            r#"
            var log = [];
            Promise.resolve().then(function() {
                log.push("a1");
                Promise.resolve().then(function() { log.push("a2"); });
            });
            Promise.resolve().then(function() { log.push("b1"); });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("JSON.stringify(log)").unwrap();
        // a1 runs first, enqueues a2, then b1 runs, then a2 runs
        assert_eq!(result2, JsValue::String(r#"["a1","b1","a2"]"#.into()));
    }

    // -- 30. Promise.resolve with non-thenable plain object
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_non_thenable_object() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            var obj = { x: 1 };
            Promise.resolve(obj).then(function(v) { out = v.x; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(1));
    }

    // -- 31. Constructor with synchronous resolve
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_constructor_sync_resolve() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            new Promise(function(resolve) { resolve(7); })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(7));
    }

    // -- 32. Constructor with synchronous reject
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_constructor_sync_reject() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            new Promise(function(resolve, reject) { reject("no"); })
                .catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("no".into()));
    }

    // -- 33. Long then chain
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_long_then_chain() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.resolve(1)
                .then(function(v) { return v + 1; })
                .then(function(v) { return v + 1; })
                .then(function(v) { return v + 1; })
                .then(function(v) { return v + 1; })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(5));
    }

    // -- 34. Promise.allSettled with empty array
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_empty() {
        let _result = eval_with_microtasks(
            r#"
            var out = -1;
            Promise.allSettled([]).then(function(arr) { out = arr.length; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(0));
    }

    // -- 35. Promise.withResolvers resolve/reject work end-to-end
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_with_resolvers_resolve() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            var wr = Promise.withResolvers();
            wr.promise.then(function(v) { out = v; });
            wr.resolve(99);
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(99));
    }

    // -- 36. Thenable assimilation in then handler return
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_returns_thenable() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.resolve(1)
                .then(function(v) {
                    return { then: function(resolve) { resolve(v + 100); } };
                })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(101));
    }

    // -- 37. Promise.all wraps non-promise values
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_wraps_non_promises() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.all([1, "two", true]).then(function(arr) {
                out = arr[0] + "," + arr[1] + "," + arr[2];
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("1,two,true".into()));
    }

    // -- 38. Promise.resolve with undefined
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_undefined() {
        let _result = eval_with_microtasks(
            r#"
            var out = "unset";
            Promise.resolve(undefined).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Undefined);
    }

    // -- 39. Promise.resolve with null
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_null() {
        let _result = eval_with_microtasks(
            r#"
            var out = "unset";
            Promise.resolve(null).then(function(v) { out = (v === null) ? "null" : "other"; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("null".into()));
    }

    // -- 40. Promise.reject with undefined
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_reject_undefined() {
        let _result = eval_with_microtasks(
            r#"
            var out = "unset";
            Promise.reject(undefined).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Undefined);
    }

    // -- 41. Constructor: resolve is idempotent (second call ignored)
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_constructor_resolve_idempotent() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            new Promise(function(resolve) { resolve(1); resolve(2); })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(1));
    }

    // -- 42. Constructor: reject is idempotent
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_constructor_reject_idempotent() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            new Promise(function(resolve, reject) { reject("a"); reject("b"); })
                .catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("a".into()));
    }

    // -- 43. Constructor: resolve then reject — resolve wins
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_constructor_resolve_then_reject() {
        let _result = eval_with_microtasks(
            r#"
            var fulfilled = false;
            var rejected = false;
            new Promise(function(resolve, reject) { resolve(1); reject("x"); })
                .then(function() { fulfilled = true; }, function() { rejected = true; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let f = global_eval("fulfilled").unwrap();
        let r = global_eval("rejected").unwrap();
        assert_eq!(f, JsValue::Boolean(true));
        assert_eq!(r, JsValue::Boolean(false));
    }

    // -- 44. Promise.all with single element
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_single_element() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.all([Promise.resolve(42)]).then(function(arr) { out = arr[0]; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(42));
    }

    // -- 45. Promise.all result is array with correct length
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_result_length() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.all([1, 2, 3, 4, 5]).then(function(arr) { out = arr.length; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(5));
    }

    // -- 46. Promise.race with first rejection wins over later fulfillments
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_rejection_wins() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.race([
                Promise.reject("err"),
                Promise.resolve(1)
            ]).catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("err".into()));
    }

    // -- 47. Promise.race with empty array stays pending forever
    #[test]
    fn e2e_promise_race_empty_stays_pending() {
        use crate::builtins::promise::{MicrotaskQueue, promise_race};
        let q = MicrotaskQueue::new();
        let p = promise_race(vec![], &q);
        q.drain();
        assert!(p.is_pending());
    }

    // -- 48. Promise.any with empty array rejects
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_empty_rejects() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.any([]).catch(function(e) { out = e.message; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        if let JsValue::String(s) = &result2 {
            assert!(
                s.contains("All promises were rejected"),
                "expected AggregateError message, got: {s}"
            );
        } else {
            panic!("expected string, got: {:?}", result2);
        }
    }

    // -- 49. Promise.any with single fulfillment
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_single_fulfillment() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.any([Promise.resolve(55)]).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(55));
    }

    // -- 50. Promise.allSettled preserves order
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_preserves_order() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.allSettled([
                Promise.reject("x"),
                Promise.resolve("y"),
                Promise.reject("z")
            ]).then(function(results) {
                out = results[0].status + ":" + results[0].reason
                    + "," + results[1].status + ":" + results[1].value
                    + "," + results[2].status + ":" + results[2].reason;
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(
            result2,
            JsValue::String("rejected:x,fulfilled:y,rejected:z".into())
        );
    }

    // -- 51. Promise.allSettled with all fulfilled
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_all_fulfilled() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.allSettled([
                Promise.resolve(1),
                Promise.resolve(2)
            ]).then(function(results) {
                out = results[0].status + "," + results[1].status;
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("fulfilled,fulfilled".into()));
    }

    // -- 52. Promise.allSettled with all rejected
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_all_rejected() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.allSettled([
                Promise.reject("a"),
                Promise.reject("b")
            ]).then(function(results) {
                out = results[0].status + "," + results[1].status;
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("rejected,rejected".into()));
    }

    // -- 53. then handler throw rejects downstream
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_throw_rejects() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.resolve(1)
                .then(function() { throw "boom"; })
                .catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("typeof out").unwrap();
        assert_eq!(result2, JsValue::String("string".into()));
    }

    // -- 54. Promise.resolve identity: already-resolved promise returned as-is
    #[test]
    fn e2e_promise_resolve_identity_strict() {
        let result = eval_with_microtasks(
            r#"
            var p = Promise.resolve(10);
            var p2 = Promise.resolve(p);
            p === p2;
            "#,
        );
        assert_eq!(result, JsValue::Boolean(true));
    }

    // -- 55. Promise.reject does NOT unwrap — rejected with a promise value
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_reject_does_not_unwrap() {
        let _result = eval_with_microtasks(
            r#"
            var inner = Promise.resolve(1);
            var out = false;
            Promise.reject(inner).catch(function(r) {
                out = (r === inner);
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Boolean(true));
    }

    // -- 56. Multiple .then on same resolved promise
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_multiple_then_on_same() {
        let _result = eval_with_microtasks(
            r#"
            var log = [];
            var p = Promise.resolve("x");
            p.then(function(v) { log.push("a:" + v); });
            p.then(function(v) { log.push("b:" + v); });
            p.then(function(v) { log.push("c:" + v); });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("JSON.stringify(log)").unwrap();
        assert_eq!(result2, JsValue::String(r#"["a:x","b:x","c:x"]"#.into()));
    }

    // -- 57. Promise.all rejects only once (first rejection only)
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_rejects_only_once() {
        let _result = eval_with_microtasks(
            r#"
            var count = 0;
            Promise.all([
                Promise.reject("a"),
                Promise.reject("b"),
                Promise.reject("c")
            ]).catch(function(r) { count = count + 1; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("count").unwrap();
        assert_eq!(result2, JsValue::Smi(1));
    }

    // -- 58. Promise.race with single element
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_single_element() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.race([Promise.resolve(88)]).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(88));
    }

    // -- 59. Promise.finally preserves fulfillment value through chain
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_preserves_value_chain() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.resolve(10)
                .finally(function() {})
                .finally(function() {})
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(10));
    }

    // -- 60. Promise.finally preserves rejection through chain
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_preserves_rejection_chain() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.reject("err")
                .finally(function() {})
                .catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("err".into()));
    }

    // -- 61. Thenable assimilation in Promise.all
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_with_thenable() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            var thenable = { then: function(resolve) { resolve(77); } };
            Promise.all([Promise.resolve(1), thenable]).then(function(arr) {
                out = arr[0] + "," + arr[1];
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("1,77".into()));
    }

    // -- 62. Chained promise resolution: then returning rejected promise
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_returns_rejected_promise() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.resolve(1)
                .then(function() { return Promise.reject("inner_err"); })
                .catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("inner_err".into()));
    }

    // -- 63. Promise.all preserves sparse fulfillment order
    #[test]
    fn e2e_promise_all_order_preserved() {
        use crate::builtins::promise::{MicrotaskQueue, promise_all, promise_with_resolvers};
        let q = MicrotaskQueue::new();
        let wr1 = promise_with_resolvers(&q);
        let wr2 = promise_with_resolvers(&q);
        let wr3 = promise_with_resolvers(&q);
        let p = promise_all(
            vec![
                wr1.promise.clone(),
                wr2.promise.clone(),
                wr3.promise.clone(),
            ],
            &q,
        );
        // Resolve in reverse order
        (wr3.resolve)(JsValue::Smi(30));
        (wr1.resolve)(JsValue::Smi(10));
        (wr2.resolve)(JsValue::Smi(20));
        q.drain();
        if let Some(JsValue::Array(arr)) = p.value() {
            assert_eq!(
                *arr.borrow(),
                vec![JsValue::Smi(10), JsValue::Smi(20), JsValue::Smi(30)]
            );
        } else {
            panic!("expected Array");
        }
    }

    // -- 64. Promise self-resolution detection via then return
    #[test]
    fn e2e_promise_self_resolution_via_api() {
        use crate::builtins::promise::{MicrotaskQueue, promise_with_resolvers};
        let q = MicrotaskQueue::new();
        let wr = promise_with_resolvers(&q);
        let pc = wr.promise.clone();
        (wr.resolve)(JsValue::Promise(pc));
        q.drain();
        assert!(wr.promise.is_rejected());
    }

    // -- 65. Thenable that rejects
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_thenable_reject_via_api() {
        use crate::builtins::promise::{MicrotaskQueue, promise_resolve};
        let q = MicrotaskQueue::new();
        let thenable_map = {
            let _q2 = q.clone();
            let mut map = PropertyMap::new();
            map.insert(
                "then".into(),
                JsValue::NativeFunction(Rc::new(move |args: Vec<JsValue>| {
                    if let Some(JsValue::NativeFunction(reject)) = args.get(1) {
                        reject(vec![JsValue::String("thenable_err".into())])?;
                    }
                    Ok(JsValue::Undefined)
                })),
            );
            JsValue::PlainObject(Rc::new(RefCell::new(map)))
        };
        let p = promise_resolve(thenable_map, &q);
        q.drain();
        assert!(p.is_rejected());
        assert_eq!(p.reason(), Some(JsValue::String("thenable_err".into())));
    }

    // -- 66. Thenable idempotent: only first call to resolve/reject counts
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_thenable_idempotent_via_api() {
        use crate::builtins::promise::{MicrotaskQueue, promise_resolve};
        let q = MicrotaskQueue::new();
        let thenable_map = {
            let mut map = PropertyMap::new();
            map.insert(
                "then".into(),
                JsValue::NativeFunction(Rc::new(move |args: Vec<JsValue>| {
                    if let Some(JsValue::NativeFunction(resolve)) = args.first() {
                        resolve(vec![JsValue::Smi(1)])?;
                        resolve(vec![JsValue::Smi(2)])?;
                    }
                    if let Some(JsValue::NativeFunction(reject)) = args.get(1) {
                        reject(vec![JsValue::Smi(3)])?;
                    }
                    Ok(JsValue::Undefined)
                })),
            );
            JsValue::PlainObject(Rc::new(RefCell::new(map)))
        };
        let p = promise_resolve(thenable_map, &q);
        q.drain();
        assert!(p.is_fulfilled());
        assert_eq!(p.value(), Some(JsValue::Smi(1)));
    }

    // -- 67. Promise.withResolvers reject end-to-end
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_with_resolvers_reject_e2e() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            var wr = Promise.withResolvers();
            wr.promise.catch(function(r) { out = r; });
            wr.reject("wr_err");
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("wr_err".into()));
    }

    // -- 68. Promise.all with mixed promises and values
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_mixed_types() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.all([Promise.resolve("a"), "b", Promise.resolve("c")])
                .then(function(arr) { out = arr.join("-"); });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("a-b-c".into()));
    }

    // -- 69. Promise.race with mixed values
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_with_plain_value() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.race([42]).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(42));
    }

    // -- 70. Deep then chain with alternating success/failure
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_deep_chain_alternating() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.resolve("start")
                .then(function(v) { throw "e1"; })
                .catch(function(r) { return "recovered"; })
                .then(function(v) { return v + "!"; })
                .then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("recovered!".into()));
    }

    // -- 71. Promise.allSettled single element fulfilled
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_single_fulfilled() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.allSettled([Promise.resolve(42)]).then(function(results) {
                out = results[0].status + ":" + results[0].value;
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("fulfilled:42".into()));
    }

    // -- 72. Promise.allSettled single element rejected
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_single_rejected() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.allSettled([Promise.reject("no")]).then(function(results) {
                out = results[0].status + ":" + results[0].reason;
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("rejected:no".into()));
    }

    // -- 73. Promise.any with last promise fulfilling
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_last_fulfills() {
        let _result = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.any([
                Promise.reject("a"),
                Promise.reject("b"),
                Promise.resolve(3)
            ]).then(function(v) { out = v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::Smi(3));
    }

    // -- 74. Promise.resolve with boolean
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_boolean() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.resolve(false).then(function(v) { out = typeof v + ":" + v; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("out").unwrap();
        assert_eq!(result2, JsValue::String("boolean:false".into()));
    }

    // -- 75. Catch handler can re-throw to propagate rejection
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_catch_rethrow() {
        let _result = eval_with_microtasks(
            r#"
            var out = "";
            Promise.reject("original")
                .catch(function(r) { throw "rethrown"; })
                .catch(function(r) { out = r; });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("typeof out").unwrap();
        assert_eq!(result2, JsValue::String("string".into()));
    }

    // ── Promise: API-level conformance tests ──────────────────────────────

    // -- 76. Promise.all with deferred resolution
    #[test]
    fn e2e_promise_all_deferred() {
        use crate::builtins::promise::{
            MicrotaskQueue, promise_all, promise_resolve, promise_with_resolvers,
        };
        let q = MicrotaskQueue::new();
        let wr = promise_with_resolvers(&q);
        let p = promise_all(
            vec![promise_resolve(JsValue::Smi(1), &q), wr.promise.clone()],
            &q,
        );
        q.drain();
        // Still pending because wr.promise is not resolved yet
        assert!(p.is_pending());
        (wr.resolve)(JsValue::Smi(2));
        q.drain();
        if let Some(JsValue::Array(arr)) = p.value() {
            assert_eq!(*arr.borrow(), vec![JsValue::Smi(1), JsValue::Smi(2)]);
        } else {
            panic!("expected Array");
        }
    }

    // -- 77. Promise.race with deferred — first to settle wins
    #[test]
    fn e2e_promise_race_deferred() {
        use crate::builtins::promise::{MicrotaskQueue, promise_race, promise_with_resolvers};
        let q = MicrotaskQueue::new();
        let wr1 = promise_with_resolvers(&q);
        let wr2 = promise_with_resolvers(&q);
        let p = promise_race(vec![wr1.promise.clone(), wr2.promise.clone()], &q);
        assert!(p.is_pending());
        (wr2.resolve)(JsValue::Smi(99));
        q.drain();
        assert!(p.is_fulfilled());
        assert_eq!(p.value(), Some(JsValue::Smi(99)));
    }

    // -- 78. Promise.any deferred — first fulfill wins
    #[test]
    fn e2e_promise_any_deferred() {
        use crate::builtins::promise::{MicrotaskQueue, promise_any, promise_with_resolvers};
        let q = MicrotaskQueue::new();
        let wr1 = promise_with_resolvers(&q);
        let wr2 = promise_with_resolvers(&q);
        let p = promise_any(vec![wr1.promise.clone(), wr2.promise.clone()], &q);
        assert!(p.is_pending());
        (wr1.reject)(JsValue::String("no1".into()));
        q.drain();
        assert!(p.is_pending());
        (wr2.resolve)(JsValue::Smi(7));
        q.drain();
        assert!(p.is_fulfilled());
        assert_eq!(p.value(), Some(JsValue::Smi(7)));
    }

    // -- 79. Promise.allSettled deferred
    #[test]
    fn e2e_promise_all_settled_deferred() {
        use crate::builtins::promise::{
            MicrotaskQueue, promise_all_settled, promise_with_resolvers,
        };
        let q = MicrotaskQueue::new();
        let wr = promise_with_resolvers(&q);
        let p = promise_all_settled(vec![wr.promise.clone()], &q);
        assert!(p.is_pending());
        (wr.reject)(JsValue::String("fail".into()));
        q.drain();
        assert!(p.is_fulfilled());
        if let Some(JsValue::Array(arr)) = p.value() {
            if let JsValue::PlainObject(obj) = &arr.borrow()[0] {
                let m = obj.borrow();
                assert_eq!(m.get("status"), Some(&JsValue::String("rejected".into())));
                assert_eq!(m.get("reason"), Some(&JsValue::String("fail".into())));
            } else {
                panic!("expected PlainObject");
            }
        } else {
            panic!("expected Array");
        }
    }

    // -- 80. Microtask queue is FIFO across interleaved enqueues
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_microtask_deep_interleave() {
        let _result = eval_with_microtasks(
            r#"
            var log = [];
            Promise.resolve().then(function() {
                log.push(1);
                Promise.resolve().then(function() {
                    log.push(3);
                    Promise.resolve().then(function() { log.push(5); });
                });
            });
            Promise.resolve().then(function() {
                log.push(2);
                Promise.resolve().then(function() { log.push(4); });
            });
            "#,
        );
        use crate::builtins::promise::drain_active_microtask_queue;
        drain_active_microtask_queue();
        let result2 = global_eval("JSON.stringify(log)").unwrap();
        assert_eq!(result2, JsValue::String("[1,2,3,4,5]".into()));
    }

    // -- 81. Promise.try resolves synchronous return values
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_try_resolves_return_value() {
        let _ = eval_with_microtasks(
            r#"
            var out = "";
            Promise.try(function(a, b) {
                out = "called";
                return a + b;
            }, 2, 3).then(function(value) {
                out = out + ":" + value;
            });
            "#,
        );
        let result = global_eval("out").unwrap();
        assert_eq!(result, JsValue::String("called:5".into()));
    }

    // -- 82. Promise.try rejects synchronous throws
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_try_rejects_thrown_value() {
        let _ = eval_with_microtasks(
            r#"
            var out = "";
            Promise.try(function() {
                throw "boom";
            }).catch(function(reason) {
                out = reason;
            });
            "#,
        );
        let result = global_eval("typeof out").unwrap();
        assert_eq!(result, JsValue::String("string".into()));
    }

    // -- 83. Promise.try assimilates returned thenables
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_try_assimilates_thenable() {
        let _ = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.try(function() {
                return {
                    then: function(resolve) {
                        resolve(41);
                    }
                };
            }).then(function(value) {
                out = value + 1;
            });
            "#,
        );
        let result = global_eval("out").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    // -- 84. then skips non-callable fulfillment handlers
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_skips_non_callable_fulfillment_handler() {
        let _ = eval_with_microtasks(
            r#"
            var out = 0;
            Promise.resolve(9)
                .then(123)
                .then(function(value) { out = value; });
            "#,
        );
        let result = global_eval("out").unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    // -- 85. then skips non-callable rejection handlers
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_skips_non_callable_rejection_handler() {
        let _ = eval_with_microtasks(
            r#"
            var out = "";
            Promise.reject("nope")
                .then(undefined, 123)
                .catch(function(reason) { out = reason; });
            "#,
        );
        let result = global_eval("out").unwrap();
        assert_eq!(result, JsValue::String("nope".into()));
    }

    // -- 86. catch skips non-callable handlers like then(undefined, handler)
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_catch_skips_non_callable_handler() {
        let _ = eval_with_microtasks(
            r#"
            var out = "";
            Promise.reject("kept")
                .catch(0)
                .catch(function(reason) { out = reason; });
            "#,
        );
        let result = global_eval("out").unwrap();
        assert_eq!(result, JsValue::String("kept".into()));
    }

    // -- 87. finally callback receives no arguments
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_receives_no_arguments() {
        let _ = eval_with_microtasks(
            r#"
            var out = -1;
            Promise.resolve(1).finally(function() {
                out = arguments.length;
            });
            "#,
        );
        let result = global_eval("out").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    // -- 88. finally waits for returned promise before continuing
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_waits_for_returned_promise() {
        let _ = eval_with_microtasks(
            r#"
            var steps = [];
            var cleanup = Promise.withResolvers();
            Promise.resolve("value")
                .finally(function() {
                    steps.push("cleanup");
                    return cleanup.promise;
                })
                .then(function(value) {
                    steps.push(value);
                });
            steps.push("after-finally");
            "#,
        );
        let before = global_eval("JSON.stringify(steps)").unwrap();
        assert_eq!(
            before,
            JsValue::String(r#"["cleanup","after-finally"]"#.into())
        );

        let _ = eval_with_microtasks("cleanup.resolve();");
        let after = global_eval("JSON.stringify(steps)").unwrap();
        assert_eq!(
            after,
            JsValue::String(r#"["cleanup","after-finally","value"]"#.into())
        );
    }

    // -- 89. finally preserves rejection after returned promise fulfills
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_preserves_rejection_after_returned_promise() {
        let _ = eval_with_microtasks(
            r#"
            var cleanup = Promise.withResolvers();
            var out = "";
            Promise.reject("reason")
                .finally(function() {
                    return cleanup.promise;
                })
                .catch(function(reason) {
                    out = reason;
                });
            "#,
        );
        let pending = global_eval("out").unwrap();
        assert_eq!(pending, JsValue::String(String::new().into()));

        let _ = eval_with_microtasks("cleanup.resolve();");
        let result = global_eval("out").unwrap();
        assert_eq!(result, JsValue::String("reason".into()));
    }

    // -- 90. finally rejects with returned thenable rejection
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_rejects_with_returned_thenable_reason() {
        let _ = eval_with_microtasks(
            r#"
            var cleanup = Promise.withResolvers();
            var out = "";
            Promise.resolve("value")
                .finally(function() {
                    return cleanup.promise;
                })
                .catch(function(reason) {
                    out = reason;
                });
            "#,
        );
        let pending = global_eval("out").unwrap();
        assert_eq!(pending, JsValue::String(String::new().into()));

        let _ = eval_with_microtasks("cleanup.reject('cleanup failed');");
        let result = global_eval("out").unwrap();
        assert_eq!(result, JsValue::String("cleanup failed".into()));
    }

    // -- 91+. Promise microtask ordering and async edge cases

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_microtask_order_same_promise_callbacks_async,
        "var __promise_mt_order_1 = []; var __promise_mt_source_1 = Promise.resolve('value'); \
         __promise_mt_source_1.then(function() { __promise_mt_order_1.push('first'); }); \
         __promise_mt_source_1.then(function() { __promise_mt_order_1.push('second'); }); \
         __promise_mt_source_1.then(function() { __promise_mt_order_1.push('third'); });",
        "JSON.stringify(__promise_mt_order_1)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["first","second","third"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_microtask_order_multiple_resolved_promises_async,
        "var __promise_mt_order_2 = []; \
         Promise.resolve().then(function() { __promise_mt_order_2.push('a'); }); \
         Promise.resolve().then(function() { __promise_mt_order_2.push('b'); }); \
         Promise.resolve().then(function() { __promise_mt_order_2.push('c'); });",
        "JSON.stringify(__promise_mt_order_2)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["a","b","c"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_microtask_order_nested_enqueues_fifo,
        "var __promise_mt_order_3 = []; \
         Promise.resolve().then(function() { \
             __promise_mt_order_3.push('outer-1'); \
             Promise.resolve().then(function() { __promise_mt_order_3.push('inner'); }); \
         }); \
         Promise.resolve().then(function() { __promise_mt_order_3.push('outer-2'); });",
        "JSON.stringify(__promise_mt_order_3)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["outer-1","outer-2","inner"]"#.into())
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_chain_runs_handlers_in_order,
        "var __promise_chain_order_1 = ''; \
         Promise.resolve(1) \
             .then(function(v) { return v + 1; }) \
             .then(function(v) { return v + 1; }) \
             .then(function(v) { __promise_chain_order_1 = '1,2,' + v; });",
        "__promise_chain_order_1",
        JsValue::String(String::new().into()),
        JsValue::String("1,2,3".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_chain_with_returned_promises_runs_in_order,
        "var __promise_chain_order_2 = ''; \
         Promise.resolve(1) \
             .then(function(v) { return Promise.resolve(v + 1); }) \
             .then(function(v) { return Promise.resolve(v * 2); }) \
             .then(function(v) { __promise_chain_order_2 = '2,4,' + v; });",
        "__promise_chain_order_2",
        JsValue::String(String::new().into()),
        JsValue::String("2,4,4".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_chain_rejection_recovery_keeps_sequence,
        "var __promise_chain_order_3 = ''; \
         Promise.reject('boom') \
             .then(function() { __promise_chain_order_3 = 'bad'; }) \
             .catch(function() { __promise_chain_order_3 += 'catch'; return 'ok'; }) \
             .then(function() { __promise_chain_order_3 += ',then'; });",
        "__promise_chain_order_3",
        JsValue::String(String::new().into()),
        JsValue::String("catch,then".into())
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_preserves_input_order_for_resolved_promises,
        "var __promise_all_order_1 = ''; \
         Promise.all([Promise.resolve('a'), Promise.resolve('b'), Promise.resolve('c')]) \
             .then(function(values) { __promise_all_order_1 = values.join('|'); });",
        "__promise_all_order_1",
        JsValue::String(String::new().into()),
        JsValue::String("a|b|c".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_preserves_input_order_for_mixed_values,
        "var __promise_all_order_2 = ''; \
         Promise.all([1, Promise.resolve(2), 3]).then(function(values) { \
             __promise_all_order_2 = values.join('|'); \
         });",
        "__promise_all_order_2",
        JsValue::String(String::new().into()),
        JsValue::String("1|2|3".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_preserves_input_order_with_thenables,
        "var __promise_all_order_3 = ''; \
         Promise.all([{ then: function(resolve) { resolve('first'); } }, Promise.resolve('second')]) \
             .then(function(values) { __promise_all_order_3 = values.join('|'); });",
        "__promise_all_order_3",
        JsValue::String(String::new().into()),
        JsValue::String("first|second".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_uses_first_input_when_all_are_already_resolved,
        "var __promise_race_order_1 = ''; \
         Promise.race([Promise.resolve('left'), Promise.resolve('right')]) \
             .then(function(value) { __promise_race_order_1 = value; });",
        "__promise_race_order_1",
        JsValue::String(String::new().into()),
        JsValue::String("left".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_plain_value_before_later_promise_wins,
        "var __promise_race_order_2 = 0; \
         Promise.race([7, Promise.resolve(8)]).then(function(value) { __promise_race_order_2 = value; });",
        "__promise_race_order_2",
        JsValue::Smi(0),
        JsValue::Smi(7)
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_uses_first_input_when_all_are_already_resolved,
        "var __promise_any_order_1 = ''; \
         Promise.any([Promise.resolve('first'), Promise.resolve('second')]) \
             .then(function(value) { __promise_any_order_1 = value; });",
        "__promise_any_order_1",
        JsValue::String(String::new().into()),
        JsValue::String("first".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_plain_value_before_later_promise_wins,
        "var __promise_any_order_2 = 0; \
         Promise.any([11, Promise.resolve(12)]).then(function(value) { __promise_any_order_2 = value; });",
        "__promise_any_order_2",
        JsValue::Smi(0),
        JsValue::Smi(11)
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_resolve_thenable_calls_then_asynchronously,
        "var __promise_thenable_async_1 = []; \
         var __promise_thenable_value_1 = { \
             then: function(resolve) { \
                 __promise_thenable_async_1.push('then'); \
                 resolve('done'); \
             } \
         }; \
         __promise_thenable_async_1.push('sync'); \
         Promise.resolve(__promise_thenable_value_1);",
        "JSON.stringify(__promise_thenable_async_1)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","then"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_resolve_thenable_settles_after_async_then_call,
        "var __promise_thenable_async_2 = []; \
         var __promise_thenable_value_2 = { \
             then: function(resolve) { \
                 __promise_thenable_async_2.push('then'); \
                 resolve('value'); \
             } \
         }; \
         Promise.resolve(__promise_thenable_value_2).then(function(value) { __promise_thenable_async_2.push(value); }); \
         __promise_thenable_async_2.push('sync');",
        "JSON.stringify(__promise_thenable_async_2)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","then","value"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_resolve_nested_thenables_resolve_recursively,
        "var __promise_thenable_async_3 = []; \
         var __promise_thenable_inner_3 = { \
             then: function(resolve) { \
                 __promise_thenable_async_3.push('inner'); \
                 resolve('done'); \
             } \
         }; \
         var __promise_thenable_outer_3 = { \
             then: function(resolve) { \
                 __promise_thenable_async_3.push('outer'); \
                 resolve(__promise_thenable_inner_3); \
             } \
         }; \
         Promise.resolve(__promise_thenable_outer_3).then(function(value) { __promise_thenable_async_3.push(value); }); \
         __promise_thenable_async_3.push('sync');",
        "JSON.stringify(__promise_thenable_async_3)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","outer","inner","done"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_resolve_thenable_rejection_happens_asynchronously,
        "var __promise_thenable_async_4 = []; \
         var __promise_thenable_value_4 = { \
             then: function(resolve, reject) { \
                 __promise_thenable_async_4.push('then'); \
                 reject('boom'); \
             } \
         }; \
         Promise.resolve(__promise_thenable_value_4).catch(function(reason) { \
             __promise_thenable_async_4.push('reason:' + reason); \
         }); \
         __promise_thenable_async_4.push('sync');",
        "JSON.stringify(__promise_thenable_async_4)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","then","reason:boom"]"#.into())
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_constructor_executor_runs_synchronously,
        "var __promise_executor_sync_1 = []; \
         new Promise(function(resolve) { __promise_executor_sync_1.push('executor'); resolve(); }); \
         __promise_executor_sync_1.push('after');",
        "JSON.stringify(__promise_executor_sync_1)",
        JsValue::String(r#"["executor","after"]"#.into()),
        JsValue::String(r#"["executor","after"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_constructor_executor_finishes_before_then_callback,
        "var __promise_executor_sync_2 = []; \
         new Promise(function(resolve) { __promise_executor_sync_2.push('executor'); resolve('ok'); }) \
             .then(function(value) { __promise_executor_sync_2.push(value); }); \
         __promise_executor_sync_2.push('after');",
        "JSON.stringify(__promise_executor_sync_2)",
        JsValue::String(r#"["executor","after"]"#.into()),
        JsValue::String(r#"["executor","after","ok"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_constructor_throw_rejects_after_executor_returns,
        "var __promise_executor_sync_3 = []; \
         new Promise(function(resolve, reject) { \
             __promise_executor_sync_3.push('executor'); \
             throw 'boom'; \
         }).catch(function() { __promise_executor_sync_3.push('caught'); }); \
         __promise_executor_sync_3.push('after');",
        "JSON.stringify(__promise_executor_sync_3)",
        JsValue::String(r#"["executor","after"]"#.into()),
        JsValue::String(r#"["executor","after","caught"]"#.into())
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_then_on_resolved_promise_runs_async,
        "var __promise_resolved_async_1 = []; \
         var __promise_resolved_value_1 = Promise.resolve('done'); \
         __promise_resolved_value_1.then(function(value) { __promise_resolved_async_1.push(value); }); \
         __promise_resolved_async_1.push('sync');",
        "JSON.stringify(__promise_resolved_async_1)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","done"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_catch_on_rejected_promise_runs_async,
        "var __promise_resolved_async_2 = []; \
         var __promise_resolved_value_2 = Promise.reject('boom'); \
         __promise_resolved_value_2.catch(function(reason) { __promise_resolved_async_2.push(reason); }); \
         __promise_resolved_async_2.push('sync');",
        "JSON.stringify(__promise_resolved_async_2)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","boom"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_finally_on_resolved_promise_runs_async,
        "var __promise_resolved_async_3 = []; \
         Promise.resolve('value').finally(function() { __promise_resolved_async_3.push('finally'); }); \
         __promise_resolved_async_3.push('sync');",
        "JSON.stringify(__promise_resolved_async_3)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","finally"]"#.into())
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_multiple_then_handlers_keep_registration_order,
        "var __promise_multi_then_1 = []; \
         var __promise_multi_value_1 = Promise.resolve('value'); \
         __promise_multi_value_1.then(function() { __promise_multi_then_1.push('first'); }); \
         __promise_multi_value_1.then(function() { __promise_multi_then_1.push('second'); }); \
         __promise_multi_value_1.then(function() { __promise_multi_then_1.push('third'); });",
        "JSON.stringify(__promise_multi_then_1)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["first","second","third"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_multiple_catch_handlers_keep_registration_order,
        "var __promise_multi_then_2 = []; \
         var __promise_multi_value_2 = Promise.reject('boom'); \
         __promise_multi_value_2.catch(function() { __promise_multi_then_2.push('first'); }); \
         __promise_multi_value_2.catch(function() { __promise_multi_then_2.push('second'); }); \
         __promise_multi_value_2.catch(function() { __promise_multi_then_2.push('third'); });",
        "JSON.stringify(__promise_multi_then_2)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["first","second","third"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_multiple_then_handlers_can_observe_same_value_in_order,
        "var __promise_multi_then_3 = []; \
         var __promise_multi_value_3 = Promise.resolve(5); \
         __promise_multi_value_3.then(function(value) { __promise_multi_then_3.push(String(value)); }); \
         __promise_multi_value_3.then(function(value) { __promise_multi_then_3.push(String(value * 2)); });",
        "JSON.stringify(__promise_multi_then_3)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["5","10"]"#.into())
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_nested_resolution_runs_inner_before_outer_then,
        "var __promise_nested_1 = []; \
         Promise.resolve('start') \
             .then(function() { \
                 return Promise.resolve().then(function() { __promise_nested_1.push('inner'); return 'value'; }); \
             }) \
             .then(function() { __promise_nested_1.push('outer'); }); \
         __promise_nested_1.push('sync');",
        "JSON.stringify(__promise_nested_1)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","inner","outer"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_nested_thenable_resolution_runs_inner_before_outer_then,
        "var __promise_nested_2 = []; \
         Promise.resolve('start') \
             .then(function() { \
                 return { then: function(resolve) { __promise_nested_2.push('inner'); resolve('value'); } }; \
             }) \
             .then(function() { __promise_nested_2.push('outer'); }); \
         __promise_nested_2.push('sync');",
        "JSON.stringify(__promise_nested_2)",
        JsValue::String(r#"["sync"]"#.into()),
        JsValue::String(r#"["sync","inner","outer"]"#.into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_nested_promise_resolution_preserves_fifo_observation,
        "var __promise_nested_3 = []; \
         Promise.resolve() \
             .then(function() { \
                 __promise_nested_3.push('first'); \
                 return Promise.resolve().then(function() { __promise_nested_3.push('second'); }); \
             }) \
             .then(function() { __promise_nested_3.push('third'); });",
        "JSON.stringify(__promise_nested_3)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["first","second","third"]"#.into())
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_resolve_recursively_resolves_nested_thenables_to_value,
        "var __promise_recursive_1 = 0; \
         var __promise_recursive_inner_1 = { then: function(resolve) { resolve(99); } }; \
         var __promise_recursive_outer_1 = { then: function(resolve) { resolve(__promise_recursive_inner_1); } }; \
         Promise.resolve(__promise_recursive_outer_1).then(function(value) { __promise_recursive_1 = value; });",
        "__promise_recursive_1",
        JsValue::Smi(0),
        JsValue::Smi(99)
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_resolve_recursively_propagates_nested_thenable_rejection,
        "var __promise_recursive_2 = ''; \
         var __promise_recursive_inner_2 = { then: function(resolve, reject) { reject('boom'); } }; \
         var __promise_recursive_outer_2 = { then: function(resolve) { resolve(__promise_recursive_inner_2); } }; \
         Promise.resolve(__promise_recursive_outer_2).catch(function(reason) { __promise_recursive_2 = reason; });",
        "__promise_recursive_2",
        JsValue::String(String::new().into()),
        JsValue::String("boom".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_resolve_recursively_observes_each_thenable_once_in_order,
        "var __promise_recursive_3 = []; \
         var __promise_recursive_inner_3 = { then: function(resolve) { __promise_recursive_3.push('inner'); resolve('done'); } }; \
         var __promise_recursive_outer_3 = { then: function(resolve) { __promise_recursive_3.push('outer'); resolve(__promise_recursive_inner_3); } }; \
         Promise.resolve(__promise_recursive_outer_3).then(function(value) { __promise_recursive_3.push(value); });",
        "JSON.stringify(__promise_recursive_3)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["outer","inner","done"]"#.into())
    );

    #[test]
    fn e2e_promise_resolve_returns_same_promise_for_same_constructor() {
        assert_eval_true_after_microtasks(
            "var __promise_identity_1 = Promise.resolve(1); \
             var __promise_identity_2 = Promise.resolve(__promise_identity_1);",
            "__promise_identity_1 === __promise_identity_2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_returns_same_subclass_promise_for_same_constructor() {
        assert_eval_true_after_microtasks(
            "class __PromiseIdentitySub extends Promise {} \
             var __promise_identity_3 = __PromiseIdentitySub.resolve(1); \
             var __promise_identity_4 = __PromiseIdentitySub.resolve(__promise_identity_3);",
            "__promise_identity_3 === __promise_identity_4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_catch_matches_then_undefined_on_reject() {
        assert_eval_true_after_microtasks(
            "var __promise_catch_alias_1 = ''; \
             var __promise_catch_alias_2 = ''; \
             Promise.reject('boom').catch(function(reason) { __promise_catch_alias_1 = 'caught:' + reason; }); \
             Promise.reject('boom').then(undefined, function(reason) { __promise_catch_alias_2 = 'caught:' + reason; });",
            "__promise_catch_alias_1 === 'caught:boom' && __promise_catch_alias_2 === 'caught:boom'",
        );
    }

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_catch_without_handler_matches_then_passthrough,
        "var __promise_catch_alias_3 = ''; \
         Promise.reject('x').catch(undefined).catch(function(reason) { __promise_catch_alias_3 = reason; });",
        "__promise_catch_alias_3",
        JsValue::String(String::new().into()),
        JsValue::String("x".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_catch_and_then_undefined_observe_same_registration_order,
        "var __promise_catch_alias_4 = []; \
         var __promise_catch_alias_4_source = Promise.reject('boom'); \
         __promise_catch_alias_4_source.catch(function() { __promise_catch_alias_4.push('catch'); }); \
         __promise_catch_alias_4_source.then(undefined, function() { __promise_catch_alias_4.push('then'); });",
        "JSON.stringify(__promise_catch_alias_4)",
        JsValue::String("[]".into()),
        JsValue::String(r#"["catch","then"]"#.into())
    );

    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_finally_runs_on_fulfill_and_preserves_value,
        "var __promise_finally_1 = ''; \
         Promise.resolve('value') \
             .finally(function() { __promise_finally_1 += 'cleanup|'; }) \
             .then(function(value) { __promise_finally_1 += value; });",
        "__promise_finally_1",
        JsValue::String(String::new().into()),
        JsValue::String("cleanup|value".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_finally_runs_on_reject_and_preserves_reason,
        "var __promise_finally_2 = ''; \
         Promise.reject('reason') \
             .finally(function() { __promise_finally_2 += 'cleanup|'; }) \
             .catch(function(reason) { __promise_finally_2 += reason; });",
        "__promise_finally_2",
        JsValue::String(String::new().into()),
        JsValue::String("cleanup|reason".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_finally_throw_overrides_fulfillment,
        "var __promise_finally_3 = ''; \
         Promise.resolve('value') \
             .finally(function() { throw 'override'; }) \
             .catch(function(reason) { __promise_finally_3 = reason; });",
        "__promise_finally_3",
        JsValue::String(String::new().into()),
        JsValue::String("override".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_finally_throw_overrides_rejection,
        "var __promise_finally_4 = ''; \
         Promise.reject('value') \
             .finally(function() { throw 'override'; }) \
             .catch(function(reason) { __promise_finally_4 = reason; });",
        "__promise_finally_4",
        JsValue::String(String::new().into()),
        JsValue::String("override".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_finally_returned_rejection_overrides_fulfillment,
        "var __promise_finally_5 = ''; \
         Promise.resolve('value') \
             .finally(function() { return Promise.reject('cleanup-failed'); }) \
             .catch(function(reason) { __promise_finally_5 = reason; });",
        "__promise_finally_5",
        JsValue::String(String::new().into()),
        JsValue::String("cleanup-failed".into())
    );
    promise_microtask_transition_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_finally_thenable_cleanup_preserves_original_value,
        "var __promise_finally_6 = ''; \
         Promise.resolve('value') \
             .finally(function() { \
                 return { then: function(resolve) { resolve('ignored'); } }; \
             }) \
             .then(function(value) { __promise_finally_6 = value; });",
        "__promise_finally_6",
        JsValue::String(String::new().into()),
        JsValue::String("value".into())
    );

    // ── eval: direct vs indirect (end-to-end) ───────────────────────────────

    /// Direct eval `eval("1+2")` is recognised by the bytecode generator
    /// and executed sharing the caller's global environment.
    #[test]
    fn e2e_eval_direct_expression() {
        let result = global_eval("eval(42)").unwrap();
        // Non-string argument returns the value directly.
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_eval_direct_string() {
        let result = global_eval("eval('1 + 2')").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_eval_direct_var_hoisting() {
        // Direct eval: `var x` should be visible after eval.
        let result = global_eval("eval('var x = 10'); x").unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn e2e_eval_indirect_expression() {
        // Indirect eval via comma operator: `(0, eval)("1+2")`.
        let result = global_eval("(0, eval)('1 + 2')").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_eval_indirect_no_caller_scope() {
        // Indirect eval runs in the current global scope, not the caller's
        // local scope.
        let result = global_eval("var a = 5; (0, eval)('a')").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    fn e2e_eval_with_closures() {
        // Direct eval at the top level can declare variables via var
        // hoisting that persist in the same top-level scope.
        let result = global_eval("eval('var x = 10'); eval('x + 5')").unwrap();
        assert_eq!(result, JsValue::Smi(15));
    }

    #[test]
    fn e2e_eval_no_args_returns_undefined() {
        let result = global_eval("eval()").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `eval` is accessible as a global identifier.
    #[test]
    fn e2e_eval_is_global() {
        let result = global_eval("typeof eval").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    #[test]
    fn e2e_eval_empty_string_returns_undefined() {
        let result = global_eval("eval('')").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_eval_invalid_code_throws_syntax_error() {
        let result = global_eval("eval('function (')").unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    fn e2e_eval_direct_reads_local_scope() {
        let result = global_eval("function outer(x) { return eval('x + 1'); } outer(4)").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    fn e2e_eval_direct_updates_local_binding() {
        let result =
            global_eval("function outer() { var x = 1; eval('x = 7'); return x; } outer()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_eval_indirect_uses_global_scope() {
        let result = global_eval(
            "var x = 10; function outer() { var x = 1; return (0, eval)('x'); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn e2e_function_constructor_basic() {
        let result = global_eval("new Function('a', 'b', 'return a + b')(2, 3)").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    fn e2e_function_constructor_uses_global_scope() {
        let result = global_eval(
            "var x = 9; function outer() { var x = 1; return new Function('return x')(); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    fn e2e_function_constructor_no_args() {
        let result = global_eval("typeof new Function()").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    #[test]
    fn e2e_function_constructor_invalid_body_throws_syntax_error() {
        let result = global_eval("new Function('return {')").unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    fn e2e_eval_direct_reads_function_scope_var() {
        let result =
            global_eval("function outer() { var x = 7; return eval('x'); } outer()").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_eval_direct_reads_parameter() {
        let result = global_eval("function outer(x) { return eval('x'); } outer(11)").unwrap();
        assert_eq!(result, JsValue::Smi(11));
    }

    #[test]
    fn e2e_eval_direct_updates_function_scope_var() {
        let result =
            global_eval("function outer() { var x = 3; eval('x = x + 4'); return x; } outer()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_eval_direct_updates_parameter() {
        let result =
            global_eval("function outer(x) { eval('x = x + 2'); return x; } outer(5)").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_eval_direct_can_read_arguments_object() {
        let result = global_eval(
            "function outer(a, b) { return eval('arguments[0] + arguments[1]'); } outer(2, 9)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(11));
    }

    #[test]
    fn e2e_eval_direct_var_declaration_is_observable_after_eval() {
        let result =
            global_eval("function outer() { eval('var y = 9'); return y; } outer()").unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    fn e2e_eval_direct_returns_last_expression_value() {
        let result = global_eval("function outer() { return eval('1; 2; 3'); } outer()").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_eval_direct_returns_last_string_expression_value() {
        let result =
            global_eval("function outer() { return eval(\"'first'; 'second'\"); } outer()")
                .unwrap();
        assert_eq!(result, JsValue::String("second".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_direct_returns_undefined_for_non_expression_tail() {
        let result =
            global_eval("function outer() { return eval('var x = 1;'); } outer()").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_eval_direct_nested_reads_outer_local() {
        let result =
            global_eval("function outer() { var x = 12; return eval(\"eval('x + 1')\"); } outer()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(13));
    }

    #[test]
    fn e2e_eval_direct_nested_updates_outer_local() {
        let result = global_eval(
            "function outer() { var x = 4; eval(\"eval('x = x + 6')\"); return x; } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn e2e_eval_direct_nested_eval_returns_inner_last_expression() {
        let result =
            global_eval("function outer() { return eval(\"1; eval('2; 5')\"); } outer()").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    fn e2e_eval_direct_syntax_error_throws_syntax_error() {
        let result = global_eval("function outer() { return eval('function ('); } outer()");
        assert!(matches!(result, Err(StatorError::SyntaxError(_))));
    }

    #[test]
    fn e2e_eval_indirect_reads_global_from_function() {
        let result = global_eval(
            "var x = 10; function outer() { var x = 1; return (0, eval)('x'); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn e2e_eval_indirect_can_create_global_binding() {
        let result = global_eval(
            "function outer() { (0, eval)('var created = 14'); return created; } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(14));
    }

    #[test]
    fn e2e_eval_indirect_updates_existing_global_binding() {
        let result = global_eval(
            "var count = 2; function outer() { (0, eval)('count = count + 5'); return count; } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_eval_indirect_returns_last_expression_value() {
        let result = global_eval("var x = 3; (0, eval)('x; x + 4')").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_indirect_nested_inside_direct_uses_global_scope() {
        let result = global_eval(
            "var x = 20; function outer() { var x = 1; return eval(\"(0, eval)('x')\"); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(20));
    }

    #[test]
    fn e2e_eval_indirect_syntax_error_throws_syntax_error() {
        let result = global_eval("(0, eval)('if (')");
        assert!(matches!(result, Err(StatorError::SyntaxError(_))));
    }

    #[test]
    fn e2e_function_constructor_reads_current_global_scope() {
        let result = global_eval(
            "var x = 41; function outer() { var x = 1; return new Function('return x + 1')(); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_function_constructor_accepts_multiple_parameters() {
        let result =
            global_eval("var add = new Function('a', 'b', 'c', 'return a + b + c'); add(1, 2, 3)")
                .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    #[test]
    fn e2e_function_constructor_body_last_return_value() {
        let result = global_eval("new Function('a', 'b', 'return a + b')(8, 9)").unwrap();
        assert_eq!(result, JsValue::Smi(17));
    }

    #[test]
    fn e2e_function_constructor_can_access_current_global_this() {
        let result =
            global_eval("globalThis.answer = 33; new Function('return globalThis.answer')()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(33));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_constructor_nested_inside_eval_uses_global_scope() {
        let result = global_eval(
            "var x = 50; function outer() { var x = 2; return eval(\"new Function('return x')()\") } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(50));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_constructor_invalid_parameter_list_throws_syntax_error() {
        let result = global_eval("new Function('a,', 'return 1')");
        assert!(matches!(result, Err(StatorError::SyntaxError(_))));
    }

    #[test]
    fn e2e_function_constructor_invalid_body_throws_syntax_error_via_call() {
        let result = global_eval("Function('return {')");
        assert!(matches!(result, Err(StatorError::SyntaxError(_))));
    }

    #[test]
    fn e2e_eval_direct_non_string_argument_is_returned_as_is() {
        let result = global_eval("function outer() { return eval(123); } outer()").unwrap();
        assert_eq!(result, JsValue::Smi(123));
    }

    #[test]
    fn e2e_eval_indirect_non_string_argument_is_returned_as_is() {
        let result = global_eval("(0, eval)(123)").unwrap();
        assert_eq!(result, JsValue::Smi(123));
    }

    // ── eval & Function constructor scope-chain precision tests ────────

    // 1. Direct eval inherits caller's scope and can declare variables in it
    #[test]
    fn e2e_eval_scope_direct_inherits_caller_scope() {
        assert_e2e_true("function f() { var a = 5; return eval('a') === 5; } f()");
    }

    #[test]
    fn e2e_eval_scope_direct_declares_var_in_caller() {
        assert_e2e_true("function f() { eval('var declared = 42'); return declared === 42; } f()");
    }

    #[test]
    fn e2e_eval_scope_direct_declares_function_in_caller() {
        assert_e2e_true(
            "function f() { eval('function g() { return 7; }'); return g() === 7; } f()",
        );
    }

    // 2. Indirect eval uses global scope
    #[test]
    fn e2e_eval_scope_indirect_uses_global_scope() {
        assert_e2e_true(
            "var gv = 100; function f() { var gv = 1; return (0, eval)('gv') === 100; } f()",
        );
    }

    #[test]
    fn e2e_eval_scope_indirect_var_alias() {
        assert_e2e_true(
            "var gv = 99; function f() { var gv = 1; var e = eval; return e('gv') === 99; } f()",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_scope_indirect_cannot_see_local() {
        assert_e2e_true(
            "function f() { var local = 5; try { (0, eval)('local'); return false; } catch(e) { return true; } } f()",
        );
    }

    // 3. new Function always uses global scope, no closure
    #[test]
    fn e2e_function_ctor_scope_always_global() {
        assert_e2e_true(
            "var gv = 77; function f() { var gv = 1; return new Function('return gv')() === 77; } f()",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_ctor_scope_no_closure_over_local() {
        assert_e2e_true(
            "function f() { var secret = 999; var fn = new Function('try { return secret; } catch(e) { return -1; }'); return fn() === -1; } f()",
        );
    }

    #[test]
    fn e2e_function_ctor_scope_nested_in_function() {
        assert_e2e_true(
            "var outer = 10; function f() { var outer = 20; function g() { var outer = 30; return new Function('return outer')(); } return g(); } f() === 10",
        );
    }

    // 4. eval in strict mode has its own variable scope
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_strict_var_does_not_leak() {
        assert_e2e_true(
            "function f() { 'use strict'; eval('var strictLocal = 1'); return typeof strictLocal === 'undefined'; } f()",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_strict_function_does_not_leak() {
        assert_e2e_true(
            "function f() { 'use strict'; eval('function gStrict() {}'); return typeof gStrict === 'undefined'; } f()",
        );
    }

    // 5. eval with let/const — block scoped to eval, not caller
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_let_scoped_to_eval_not_caller() {
        assert_e2e_true(
            "function f() { eval('let ev_let = 10'); return typeof ev_let === 'undefined'; } f()",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_const_scoped_to_eval_not_caller() {
        assert_e2e_true(
            "function f() { eval('const ev_const = 10'); return typeof ev_const === 'undefined'; } f()",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_let_visible_inside_eval() {
        assert_e2e_true("function f() { return eval('let x = 42; x'); } f() === 42");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_const_visible_inside_eval() {
        assert_e2e_true("function f() { return eval('const y = 99; y'); } f() === 99");
    }

    // 6. eval with var in strict mode doesn't affect caller scope
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_strict_var_no_caller_effect() {
        assert_e2e_true(
            "function f() { 'use strict'; eval('var sv = 123'); return typeof sv === 'undefined'; } f()",
        );
    }

    // 7. eval with var in sloppy mode affects caller scope
    #[test]
    fn e2e_eval_sloppy_var_affects_caller() {
        assert_e2e_true(
            "function f() { eval('var sloppyVar = 55'); return sloppyVar === 55; } f()",
        );
    }

    #[test]
    fn e2e_eval_sloppy_var_overwrite() {
        assert_e2e_true("function f() { var x = 1; eval('var x = 2'); return x === 2; } f()");
    }

    // 8. Function.prototype.constructor === Function
    #[test]
    fn e2e_function_prototype_constructor_identity() {
        assert_e2e_true("Function.prototype.constructor === Function");
    }

    #[test]
    fn e2e_function_constructor_from_instance() {
        assert_e2e_true("(function(){}).constructor === Function");
    }

    // 9. eval return value — last expression value
    #[test]
    fn e2e_eval_return_value_last_expr() {
        assert_e2e_true("eval('10; 20; 30') === 30");
    }

    #[test]
    fn e2e_eval_return_value_single_expr() {
        assert_e2e_true("eval('42') === 42");
    }

    #[test]
    fn e2e_eval_return_value_object() {
        assert_e2e_true("typeof eval('({a: 1})') === 'object'");
    }

    #[test]
    fn e2e_eval_return_value_string_expr() {
        assert_e2e_true("eval('\"hello\"') === 'hello'");
    }

    // 10. eval with empty string returns undefined
    #[test]
    fn e2e_eval_empty_string_returns_undefined_v2() {
        assert_e2e_true("eval('') === undefined");
    }

    #[test]
    fn e2e_eval_whitespace_only_returns_undefined() {
        assert_e2e_true("eval('   ') === undefined");
    }

    // 11. eval with syntax error throws SyntaxError
    #[test]
    fn e2e_eval_syntax_error_throws() {
        assert_e2e_true("try { eval('if ('); false; } catch(e) { e instanceof SyntaxError; }");
    }

    #[test]
    fn e2e_eval_syntax_error_incomplete_object() {
        assert_e2e_true("try { eval('{a:'); false; } catch(e) { e instanceof SyntaxError; }");
    }

    // 12. new Function() creates function with empty body
    #[test]
    fn e2e_function_ctor_empty_body() {
        assert_e2e_true("new Function()() === undefined");
    }

    #[test]
    fn e2e_function_ctor_empty_string_body() {
        assert_e2e_true("new Function('')() === undefined");
    }

    #[test]
    fn e2e_function_ctor_typeof_result() {
        assert_e2e_true("typeof new Function() === 'function'");
    }

    #[test]
    fn e2e_function_ctor_is_callable() {
        assert_e2e_true("var fn = new Function('return 1'); fn() === 1");
    }

    // 13. Nested eval — inner eval in direct eval inherits scope chain
    #[test]
    fn e2e_eval_nested_direct_inherits_scope_chain() {
        assert_e2e_true("function f() { var a = 3; return eval(\"eval('a')\") === 3; } f()");
    }

    #[test]
    fn e2e_eval_nested_direct_three_deep() {
        assert_e2e_true(
            "function f() { var a = 7; return eval(\"eval(\\\"eval('a')\\\")\") === 7; } f()",
        );
    }

    #[test]
    fn e2e_eval_nested_direct_can_mutate() {
        assert_e2e_true(
            "function f() { var a = 1; eval(\"eval('a = a + 10')\"); return a === 11; } f()",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_eval_nested_indirect_in_direct_uses_global() {
        assert_e2e_true(
            "var nv = 50; function f() { var nv = 1; return eval(\"(0, eval)('nv')\") === 50; } f()",
        );
    }

    // Additional edge-case tests
    #[test]
    fn e2e_eval_non_string_returns_value() {
        assert_e2e_true("eval(42) === 42");
    }

    #[test]
    fn e2e_eval_non_string_object_returns_same() {
        assert_e2e_true("var obj = {x:1}; eval(obj) === obj");
    }

    #[test]
    fn e2e_eval_non_string_boolean_returns_same() {
        assert_e2e_true("eval(true) === true");
    }

    #[test]
    fn e2e_eval_no_args_returns_undefined_v2() {
        assert_e2e_true("eval() === undefined");
    }

    #[test]
    fn e2e_function_ctor_name_is_anonymous() {
        assert_e2e_true("new Function().name === 'anonymous'");
    }

    #[test]
    fn e2e_function_ctor_length_matches_params() {
        assert_e2e_true("new Function('a', 'b', 'c', 'return 0').length === 3");
    }

    #[test]
    fn e2e_function_ctor_single_comma_separated_params() {
        assert_e2e_true("new Function('a, b', 'return a + b')(3, 4) === 7");
    }

    #[test]
    fn e2e_function_prototype_call() {
        let result =
            global_eval("function add(a, b) { return a + b; } add.call(null, 4, 6)").unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn e2e_function_prototype_apply() {
        let result =
            global_eval("function add(a, b) { return a + b; } add.apply(null, [4, 6])").unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn e2e_function_prototype_bind() {
        let result =
            global_eval("function add(a, b) { return a + b; } add.bind(null, 4)(6)").unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn e2e_function_prototype_constructor() {
        let result = global_eval("Function.prototype.constructor === Function").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_prototype_to_string() {
        let result = global_eval("function foo() {} foo.toString()").unwrap();
        assert_eq!(
            result,
            JsValue::String("function foo() { [native code] }".into())
        );
    }

    #[test]
    fn e2e_function_constructor_to_string() {
        let result = global_eval("new Function('a', 'b', 'return a + b').toString()").unwrap();
        assert_eq!(
            result,
            JsValue::String("function anonymous(a,b\n) {\nreturn a + b\n}".into())
        );
    }

    #[test]
    fn e2e_function_name_named() {
        let result = global_eval("function named() {} named.name").unwrap();
        assert_eq!(result, JsValue::String("named".into()));
    }

    #[test]
    fn e2e_function_name_anonymous() {
        let result = global_eval("(function() {}).name").unwrap();
        assert_eq!(result, JsValue::String(String::new().into()));
    }

    #[test]
    fn e2e_function_name_bound() {
        let result = global_eval("function named() {} named.bind(null).name").unwrap();
        assert_eq!(result, JsValue::String("bound named".into()));
    }

    #[test]
    fn e2e_function_name_computed_property() {
        let result =
            global_eval("var key = 'answer'; ({ [key]: function() {} })[key].name").unwrap();
        assert_eq!(result, JsValue::String("answer".into()));
    }

    #[test]
    fn e2e_function_name_named_expression_not_overridden() {
        let result =
            global_eval("var key = 'answer'; ({ [key]: function explicit() {} })[key].name")
                .unwrap();
        assert_eq!(result, JsValue::String("explicit".into()));
    }

    #[test]
    fn e2e_function_length_constructor() {
        let result = global_eval("Function.length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_function_length_counts_formals() {
        let result = global_eval("function add(a, b, c) {} add.length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_function_length_stops_before_default() {
        let result =
            global_eval("function withDefault(a, b = 1, c) {} withDefault.length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_function_length_stops_before_rest() {
        let result = global_eval("function withRest(a, ...rest) {} withRest.length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_bound_function_length_reduces_bound_args() {
        let result = global_eval("function add(a, b, c) {} add.bind(null, 1).length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arguments_callee_sloppy_mode() {
        let result =
            global_eval("function outer() { return arguments.callee === outer; } outer()").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arguments_callee_strict_mode_throws() {
        let result =
            global_eval("function outer() { 'use strict'; return arguments.callee; } outer()")
                .unwrap_err();
        assert!(matches!(result, StatorError::TypeError(_)));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arguments_callee_strict_mode_computed_throws() {
        let result =
            global_eval("function outer() { 'use strict'; return arguments['callee']; } outer()")
                .unwrap_err();
        assert!(matches!(result, StatorError::TypeError(_)));
    }

    #[test]
    fn e2e_function_bind_binds_this_value() {
        assert_eval_true(
            "function f(a) { return this.base + a; } var g = f.bind({ base: 40 }, 2); g() === 42",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_bind_supports_chained_partial_application() {
        assert_eval_true(
            "function sum(a, b, c) { return a + b + c; } sum.bind(null, 1).bind(null, 2)(3) === 6",
        );
    }

    #[test]
    fn e2e_function_bind_preserves_bound_name_for_anonymous_functions() {
        assert_eval_true("(function() {}).bind(null).name === 'bound '");
    }

    #[test]
    fn e2e_function_bind_reduces_length_to_zero() {
        assert_eval_true("function add(a, b) {} add.bind(null, 1, 2, 3).length === 0");
    }

    #[test]
    fn e2e_function_bind_to_string_uses_native_form() {
        assert_eval_true(
            "function named() {} named.bind(null).toString() === 'function () { [native code] }'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_function_declaration_source() {
        assert_eval_true(
            "function foo(a, b) { return a + b; } foo.toString() === 'function foo(a, b) { return a + b; }'",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_named_function_expression_source() {
        assert_eval_true(
            "var f = function foo(a, b) { return a + b; }; f.toString() === 'function foo(a, b) { return a + b; }'",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_anonymous_function_expression_source() {
        assert_eval_true(
            "var f = function(a, b) { return a + b; }; f.toString() === 'function(a, b) { return a + b; }'",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_single_param_arrow_source() {
        assert_eval_true("(x => x + 1).toString() === 'x => x + 1'");
    }

    #[test]
    fn e2e_function_to_string_preserves_parenthesized_arrow_source() {
        assert_eval_true("((x) => x + 1).toString() === '(x) => x + 1'");
    }

    #[test]
    fn e2e_function_to_string_preserves_multi_param_arrow_source() {
        assert_eval_true("((x, y) => x + y).toString() === '(x, y) => x + y'");
    }

    #[test]
    fn e2e_function_to_string_preserves_block_arrow_source() {
        assert_eval_true("((x) => { return x + 1; }).toString() === '(x) => { return x + 1; }'");
    }

    #[test]
    fn e2e_function_to_string_preserves_async_arrow_source() {
        assert_eval_true("(async x => await x).toString() === 'async x => await x'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_async_function_source() {
        assert_eval_true("async function f() {} f.toString() === 'async function f() {}'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_generator_function_source() {
        assert_eval_true("function* g() {} g.toString() === 'function* g() {}'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_async_generator_function_source() {
        assert_eval_true("async function* ag() {} ag.toString() === 'async function* ag() {}'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_class_declaration_source() {
        assert_eval_true("class Foo {} Foo.toString() === 'class Foo {}'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_class_expression_source() {
        assert_eval_true("(class Foo {}).toString() === 'class Foo {}'");
    }

    #[test]
    fn e2e_function_to_string_preserves_object_method_source() {
        assert_eval_true("({foo() {}}).foo.toString() === 'foo() {}'");
    }

    #[test]
    fn e2e_function_to_string_preserves_object_async_method_source() {
        assert_eval_true("({async foo() {}}).foo.toString() === 'async foo() {}'");
    }

    #[test]
    fn e2e_function_to_string_preserves_object_generator_method_source() {
        assert_eval_true("({*foo() {}}).foo.toString() === '*foo() {}'");
    }

    #[test]
    fn e2e_function_to_string_preserves_object_async_generator_method_source() {
        assert_eval_true("({async *foo() {}}).foo.toString() === 'async *foo() {}'");
    }

    #[test]
    fn e2e_function_to_string_preserves_object_computed_symbol_method_source() {
        assert_eval_true(
            "({[Symbol.iterator]() {}})[Symbol.iterator].toString() === '[Symbol.iterator]() {}'",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_object_computed_string_method_source() {
        assert_eval_true("({['foo']() {}}).foo.toString() === \"['foo']() {}\"");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_object_string_named_method_source() {
        assert_eval_true("({'foo'() {}}).foo.toString() === \"'foo'() {}\"");
    }

    #[test]
    fn e2e_function_to_string_preserves_object_numeric_method_source() {
        assert_eval_true("({1() {}})[1].toString() === '1() {}'");
    }

    #[test]
    fn e2e_function_to_string_preserves_object_getter_source() {
        assert_eval_true(
            "Object.getOwnPropertyDescriptor({get foo() {}}, 'foo').get.toString() === 'get foo() {}'",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_object_setter_source() {
        assert_eval_true(
            "Object.getOwnPropertyDescriptor({set foo(v) {}}, 'foo').set.toString() === 'set foo(v) {}'",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_class_method_source() {
        assert_eval_true("class Foo { foo() {} } Foo.prototype.foo.toString() === 'foo() {}'");
    }

    #[test]
    fn e2e_function_to_string_preserves_class_async_method_source() {
        assert_eval_true(
            "class Foo { async foo() {} } Foo.prototype.foo.toString() === 'async foo() {}'",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_class_generator_method_source() {
        assert_eval_true("class Foo { *foo() {} } Foo.prototype.foo.toString() === '*foo() {}'");
    }

    #[test]
    fn e2e_function_to_string_preserves_class_async_generator_method_source() {
        assert_eval_true(
            "class Foo { async *foo() {} } Foo.prototype.foo.toString() === 'async *foo() {}'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_class_computed_symbol_method_source() {
        assert_eval_true(
            "class Foo { [Symbol.iterator]() {} } Foo.prototype[Symbol.iterator].toString() === '[Symbol.iterator]() {}'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_class_computed_string_method_source() {
        assert_eval_true(
            "class Foo { ['foo']() {} } Foo.prototype.foo.toString() === \"['foo']() {}\"",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_preserves_class_string_named_method_source() {
        assert_eval_true(
            "class Foo { 'foo'() {} } Foo.prototype.foo.toString() === \"'foo'() {}\"",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_class_getter_source() {
        assert_eval_true(
            "Object.getOwnPropertyDescriptor(class Foo { get foo() {} }.prototype, 'foo').get.toString() === 'get foo() {}'",
        );
    }

    #[test]
    fn e2e_function_to_string_preserves_class_setter_source() {
        assert_eval_true(
            "Object.getOwnPropertyDescriptor(class Foo { set foo(v) {} }.prototype, 'foo').set.toString() === 'set foo(v) {}'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_uses_native_form_for_math_sin() {
        assert_eval_true("Math.sin.toString() === 'function sin() { [native code] }'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_uses_native_form_for_object_has_own_property() {
        assert_eval_true(
            "Object.prototype.hasOwnProperty.toString() === 'function hasOwnProperty() { [native code] }'",
        );
    }

    #[test]
    fn e2e_function_to_string_uses_anonymous_native_form_for_bound_named_function() {
        assert_eval_true(
            "function named() {} named.bind(null).toString() === 'function () { [native code] }'",
        );
    }

    #[test]
    fn e2e_function_to_string_uses_anonymous_native_form_for_bound_anonymous_function() {
        assert_eval_true(
            "(function() {}).bind(null).toString() === 'function () { [native code] }'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_uses_anonymous_native_form_for_bound_native_function() {
        assert_eval_true("Math.sin.bind(null).toString() === 'function () { [native code] }'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_bind_inherits_function_prototype_methods() {
        assert_eval_true(
            "function add(a, b) { return a + b; } var bound = add.bind(null, 1); bound.call(null, 2) === 3",
        );
    }

    #[test]
    fn e2e_function_call_explicit_this_binding() {
        assert_eval_true("function f(a) { return this.base + a; } f.call({ base: 5 }, 7) === 12");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_call_ignores_bound_this_when_recalled() {
        assert_eval_true(
            "function f() { return this.value; } var g = f.bind({ value: 1 }); g.call({ value: 2 }) === 1",
        );
    }

    #[test]
    fn e2e_function_apply_uses_array_like_objects() {
        assert_eval_true(
            "function join(a, b) { return a + ':' + b; } join.apply(null, { 0: 'x', 1: 'y', length: 2 }) === 'x:y'",
        );
    }

    #[test]
    fn e2e_function_apply_fills_missing_array_like_entries_with_undefined() {
        assert_eval_true(
            "function f(a, b) { return a === 1 && b === undefined; } f.apply(null, { 0: 1, length: 2 })",
        );
    }

    #[test]
    fn e2e_function_apply_accepts_nullish_args_array() {
        assert_eval_true(
            "function f() { return arguments.length === 0; } f.apply(null, null) && f.apply(null, undefined)",
        );
    }

    #[test]
    fn e2e_function_apply_throws_for_non_object_args_array() {
        assert_eval_type_error("(function() {}).apply(null, 1)");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_named_function_uses_name() {
        assert_eval_true(
            "function named() {} named.toString() === 'function named() { [native code] }'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_to_string_anonymous_function_uses_native_form() {
        assert_eval_true("(function() {}).toString() === 'function () { [native code] }'");
    }

    #[test]
    fn e2e_function_name_arrow_from_variable_declaration() {
        assert_eval_true("let arrow = () => 1; arrow.name === 'arrow'");
    }

    #[test]
    fn e2e_function_name_arrow_from_assignment() {
        assert_eval_true("let arrow; arrow = () => 1; arrow.name === 'arrow'");
    }

    #[test]
    fn e2e_function_name_anonymous_function_from_variable_declaration() {
        assert_eval_true("let fnValue = function() {}; fnValue.name === 'fnValue'");
    }

    #[test]
    fn e2e_function_name_object_property_value_function() {
        assert_eval_true("({ answer: function() {} }).answer.name === 'answer'");
    }

    #[test]
    fn e2e_function_name_object_property_value_arrow() {
        assert_eval_true("({ answer: () => 1 }).answer.name === 'answer'");
    }

    #[test]
    fn e2e_function_name_assignment_to_named_property() {
        assert_eval_true("let obj = {}; obj.answer = function() {}; obj.answer.name === 'answer'");
    }

    #[test]
    fn e2e_function_name_assignment_to_computed_property() {
        assert_eval_true(
            "let obj = {}; let key = 'answer'; obj[key] = () => 1; obj[key].name === 'answer'",
        );
    }

    #[test]
    fn e2e_function_name_method_shorthand() {
        assert_eval_true("({ answer() {} }).answer.name === 'answer'");
    }

    #[test]
    fn e2e_function_name_getter_static() {
        assert_eval_true(
            "Object.getOwnPropertyDescriptor({ get value() { return 1; } }, 'value').get.name === 'get value'",
        );
    }

    #[test]
    fn e2e_function_name_setter_static() {
        assert_eval_true(
            "Object.getOwnPropertyDescriptor({ set value(v) {} }, 'value').set.name === 'set value'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_name_getter_computed() {
        assert_eval_true(
            "let key = 'value'; Object.getOwnPropertyDescriptor({ get [key]() { return 1; } }, key).get.name === 'get value'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_name_setter_computed() {
        assert_eval_true(
            "let key = 'value'; Object.getOwnPropertyDescriptor({ set [key](v) {} }, key).set.name === 'set value'",
        );
    }

    #[test]
    fn e2e_function_length_counts_destructuring_parameter() {
        assert_eval_true("function f({ a }, [b], c) {} f.length === 3");
    }

    #[test]
    fn e2e_function_length_stops_before_destructuring_default() {
        assert_eval_true("function f(a, { b } = {}, c) {} f.length === 1");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arguments_length_and_index_access() {
        assert_eval_true(
            "function f(a) { return arguments.length === 3 && arguments[0] === 1 && arguments[2] === 3; } f(1, 2, 3)",
        );
    }

    #[test]
    fn e2e_arguments_rest_does_not_include_named_parameters() {
        assert_eval_true(
            "function f(a, ...rest) { return a === 1 && rest.length === 2 && rest[0] === 2 && rest[1] === 3; } f(1, 2, 3)",
        );
    }

    #[test]
    fn e2e_rest_parameters_collect_remaining_arguments() {
        assert_eval_true(
            "function f(...args) { return args.length === 3 && args[0] === 1 && args[2] === 3; } f(1, 2, 3)",
        );
    }

    #[test]
    fn e2e_rest_parameters_can_be_empty() {
        assert_eval_true("function f(a, ...rest) { return rest.length === 0; } f(1)");
    }

    #[test]
    fn e2e_default_parameters_apply_when_argument_is_undefined() {
        assert_eval_true("function f(a = 1, b = 2) { return a + b; } f(undefined, 3) === 4");
    }

    #[test]
    fn e2e_default_parameters_do_not_override_null() {
        assert_eval_true("function f(a = 1) { return a; } f(null) === null");
    }

    #[test]
    fn e2e_default_parameters_can_reference_earlier_parameters() {
        assert_eval_true("function f(a, b = a + 1) { return b; } f(4) === 5");
    }

    #[test]
    fn e2e_new_function_constructs_callable() {
        assert_eval_true("new Function('a', 'b', 'return a + b')(20, 22) === 42");
    }

    #[test]
    fn e2e_new_function_sets_name_and_length() {
        assert_eval_true(
            "var f = new Function('a', 'b', 'return a + b'); f.name === 'anonymous' && f.length === 2",
        );
    }

    #[test]
    fn e2e_new_function_to_string_preserves_source() {
        assert_eval_true(
            "new Function('a', 'b', 'return a + b').toString() === 'function anonymous(a,b\\n) {\\nreturn a + b\\n}'",
        );
    }

    // ── BigInt tests ────────────────────────────────────────────────────────

    // -- Literal parsing --

    #[test]
    fn e2e_bigint_literal_zero() {
        let result = global_eval("0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_literal_positive() {
        let result = global_eval("42n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    #[test]
    fn e2e_bigint_literal_negative() {
        let result = global_eval("-1n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-1)));
    }

    #[test]
    fn e2e_bigint_literal_large() {
        let result = global_eval("9007199254740993n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(9_007_199_254_740_993)));
    }

    #[test]
    fn e2e_bigint_literal_hex() {
        let result = global_eval("0xFFn").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(255)));
    }

    #[test]
    fn e2e_bigint_literal_octal() {
        let result = global_eval("0o77n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(63)));
    }

    #[test]
    fn e2e_bigint_literal_binary() {
        let result = global_eval("0b1010n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(10)));
    }

    #[test]
    fn e2e_bigint_literal_large_hex() {
        let result = global_eval("0x1Fn").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(31)));
    }

    #[test]
    fn e2e_bigint_literal_zero_hex() {
        let result = global_eval("0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_numeric_separator_literals() {
        let result = global_eval("1_000_000 + 0xFF_FF + 0o7_7 + 0b10_10").unwrap();
        assert_eq!(result, JsValue::Smi(1_065_622));
    }

    #[test]
    fn e2e_numeric_separator_invalid_literals() {
        for src in ["1__0", "1_", "0_1", "0x_FF", "0o7_", "0b10__10"] {
            assert!(global_eval(src).is_err(), "{src} should be rejected");
        }
    }

    #[test]
    fn e2e_prefixed_numeric_literals() {
        let result = global_eval("0o17 + 0b1010 + 0xFF").unwrap();
        assert_eq!(result, JsValue::Smi(280));
    }

    #[test]
    fn e2e_legacy_octal_literal_sloppy_mode() {
        let result = global_eval("0777").unwrap();
        assert_eq!(result, JsValue::Smi(0o777));
    }

    // -- typeof --

    #[test]
    fn e2e_bigint_typeof() {
        let result = global_eval("typeof 42n").unwrap();
        assert_eq!(result, JsValue::String("bigint".into()));
    }

    #[test]
    fn e2e_bigint_typeof_zero() {
        let result = global_eval("typeof 0n").unwrap();
        assert_eq!(result, JsValue::String("bigint".into()));
    }

    #[test]
    fn e2e_bigint_typeof_negative() {
        let result = global_eval("typeof -1n").unwrap();
        assert_eq!(result, JsValue::String("bigint".into()));
    }

    // -- Arithmetic: addition --

    #[test]
    fn e2e_bigint_add() {
        let result = global_eval("1n + 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(3)));
    }

    #[test]
    fn e2e_bigint_add_zero() {
        let result = global_eval("0n + 0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_add_negative() {
        let result = global_eval("-1n + -2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-3)));
    }

    #[test]
    fn e2e_bigint_add_large() {
        let result = global_eval("9007199254740993n + 1n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(9_007_199_254_740_994)));
    }

    #[test]
    fn e2e_bigint_add_mixed_type_error() {
        let result = global_eval("1n + 1");
        assert!(result.is_err());
    }

    #[test]
    fn e2e_bigint_add_mixed_type_error_reverse() {
        let result = global_eval("1 + 1n");
        assert!(result.is_err());
    }

    // -- Arithmetic: subtraction --

    #[test]
    fn e2e_bigint_sub() {
        let result = global_eval("5n - 3n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(2)));
    }

    #[test]
    fn e2e_bigint_sub_negative_result() {
        let result = global_eval("3n - 5n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-2)));
    }

    #[test]
    fn e2e_bigint_sub_zero() {
        let result = global_eval("0n - 0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_sub_mixed_error() {
        assert!(global_eval("1n - 1").is_err());
    }

    // -- Arithmetic: multiplication --

    #[test]
    fn e2e_bigint_mul() {
        let result = global_eval("3n * 4n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(12)));
    }

    #[test]
    fn e2e_bigint_mul_zero() {
        let result = global_eval("100n * 0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_mul_negative() {
        let result = global_eval("-3n * 4n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-12)));
    }

    #[test]
    fn e2e_bigint_mul_both_negative() {
        let result = global_eval("-3n * -4n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(12)));
    }

    #[test]
    fn e2e_bigint_mul_mixed_error() {
        assert!(global_eval("2n * 3").is_err());
    }

    // -- Arithmetic: division --

    #[test]
    fn e2e_bigint_div() {
        let result = global_eval("10n / 3n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(3))); // truncates
    }

    #[test]
    fn e2e_bigint_div_exact() {
        let result = global_eval("10n / 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(5)));
    }

    #[test]
    fn e2e_bigint_div_negative() {
        let result = global_eval("-10n / 3n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-3)));
    }

    #[test]
    fn e2e_bigint_div_by_zero_error() {
        assert!(global_eval("10n / 0n").is_err());
    }

    #[test]
    fn e2e_bigint_div_mixed_error() {
        assert!(global_eval("10n / 2").is_err());
    }

    // -- Arithmetic: modulo --

    #[test]
    fn e2e_bigint_mod() {
        let result = global_eval("10n % 3n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_mod_zero_result() {
        let result = global_eval("10n % 5n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_mod_negative() {
        let result = global_eval("-10n % 3n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-1)));
    }

    #[test]
    fn e2e_bigint_mod_by_zero_error() {
        assert!(global_eval("10n % 0n").is_err());
    }

    #[test]
    fn e2e_bigint_mod_mixed_error() {
        assert!(global_eval("10n % 3").is_err());
    }

    // -- Arithmetic: exponentiation --

    #[test]
    fn e2e_bigint_exp() {
        let result = global_eval("2n ** 10n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1024)));
    }

    #[test]
    fn e2e_bigint_exp_zero() {
        let result = global_eval("2n ** 0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_exp_one() {
        let result = global_eval("5n ** 1n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(5)));
    }

    #[test]
    fn e2e_bigint_exp_negative_exponent_error() {
        assert!(global_eval("2n ** -1n").is_err());
    }

    #[test]
    fn e2e_bigint_exp_mixed_error() {
        assert!(global_eval("2n ** 3").is_err());
    }

    // -- Unary: negate --

    #[test]
    fn e2e_bigint_negate() {
        let result = global_eval("-42n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-42)));
    }

    #[test]
    fn e2e_bigint_negate_zero() {
        let result = global_eval("-0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_negate_negative() {
        // Double negate: -(-5n) = 5n; but this is parsed as `-(-(5n))`
        let result = global_eval("let x = -5n; -x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(5)));
    }

    // -- Unary: bitwise not --

    #[test]
    fn e2e_bigint_bitwise_not() {
        let result = global_eval("~0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-1)));
    }

    #[test]
    fn e2e_bigint_bitwise_not_positive() {
        let result = global_eval("~5n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-6)));
    }

    #[test]
    fn e2e_bigint_bitwise_not_negative() {
        let result = global_eval("~-1n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    // -- Bitwise: OR --

    #[test]
    fn e2e_bigint_bitwise_or() {
        let result = global_eval("5n | 3n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(7)));
    }

    #[test]
    fn e2e_bigint_bitwise_or_zero() {
        let result = global_eval("0n | 0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_bitwise_or_mixed_error() {
        assert!(global_eval("5n | 3").is_err());
    }

    // -- Bitwise: AND --

    #[test]
    fn e2e_bigint_bitwise_and() {
        let result = global_eval("5n & 3n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_bitwise_and_zero() {
        let result = global_eval("5n & 0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_bitwise_and_mixed_error() {
        assert!(global_eval("5n & 3").is_err());
    }

    // -- Bitwise: XOR --

    #[test]
    fn e2e_bigint_bitwise_xor() {
        let result = global_eval("5n ^ 3n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(6)));
    }

    #[test]
    fn e2e_bigint_bitwise_xor_same() {
        let result = global_eval("7n ^ 7n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_bitwise_xor_mixed_error() {
        assert!(global_eval("5n ^ 3").is_err());
    }

    // -- Bitwise: shifts --

    #[test]
    fn e2e_bigint_shift_left() {
        let result = global_eval("1n << 10n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1024)));
    }

    #[test]
    fn e2e_bigint_shift_left_zero() {
        let result = global_eval("5n << 0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(5)));
    }

    #[test]
    fn e2e_bigint_shift_left_mixed_error() {
        assert!(global_eval("1n << 2").is_err());
    }

    #[test]
    fn e2e_bigint_shift_right() {
        let result = global_eval("1024n >> 5n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(32)));
    }

    #[test]
    fn e2e_bigint_shift_right_zero() {
        let result = global_eval("5n >> 0n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(5)));
    }

    #[test]
    fn e2e_bigint_shift_right_mixed_error() {
        assert!(global_eval("1024n >> 5").is_err());
    }

    // ===== Bitwise operator conformance (non-BigInt) =====

    // -- AND, OR, XOR basics --

    #[test]
    fn e2e_bitwise_and_basic() {
        let r = global_eval("5 & 3").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    #[test]
    fn e2e_bitwise_or_basic() {
        let r = global_eval("5 | 3").unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    #[test]
    fn e2e_bitwise_xor_basic() {
        let r = global_eval("5 ^ 3").unwrap();
        assert_eq!(r, JsValue::Smi(6));
    }

    #[test]
    fn e2e_bitwise_not_basic() {
        let r = global_eval("~5").unwrap();
        assert_eq!(r, JsValue::Smi(-6));
    }

    #[test]
    fn e2e_bitwise_not_zero() {
        let r = global_eval("~0").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    #[test]
    fn e2e_bitwise_not_minus_one() {
        let r = global_eval("~(-1)").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    // -- Shift operators --

    #[test]
    fn e2e_shift_left_basic() {
        let r = global_eval("1 << 10").unwrap();
        assert_eq!(r, JsValue::Smi(1024));
    }

    #[test]
    fn e2e_shift_right_basic() {
        let r = global_eval("-16 >> 2").unwrap();
        assert_eq!(r, JsValue::Smi(-4));
    }

    #[test]
    fn e2e_unsigned_shift_right_basic() {
        // -1 >>> 0 should be 4294967295 (all 32 bits set, unsigned)
        let r = global_eval("-1 >>> 0").unwrap();
        assert_eq!(r.to_number().unwrap(), 4294967295.0);
    }

    #[test]
    fn e2e_unsigned_shift_right_positive() {
        let r = global_eval("32 >>> 2").unwrap();
        assert_eq!(r.to_number().unwrap(), 8.0);
    }

    // -- Shift amount masked to 5 bits (mod 32) --

    #[test]
    fn e2e_shift_left_mod32() {
        // 1 << 33 should equal 1 << 1 = 2
        let r = global_eval("1 << 33").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    #[test]
    fn e2e_shift_right_mod32() {
        // 8 >> 35 should equal 8 >> 3 = 1
        let r = global_eval("8 >> 35").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    #[test]
    fn e2e_unsigned_shift_right_mod32() {
        // -1 >>> 32 should equal -1 >>> 0 = 4294967295
        let r = global_eval("-1 >>> 32").unwrap();
        assert_eq!(r.to_number().unwrap(), 4294967295.0);
    }

    // -- NaN → 0 in bitwise ops --

    #[test]
    fn e2e_bitwise_or_nan_lhs() {
        let r = global_eval("NaN | 5").unwrap();
        assert_eq!(r, JsValue::Smi(5));
    }

    #[test]
    fn e2e_bitwise_and_nan() {
        let r = global_eval("NaN & 5").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    #[test]
    fn e2e_bitwise_xor_nan() {
        let r = global_eval("NaN ^ 5").unwrap();
        assert_eq!(r, JsValue::Smi(5));
    }

    #[test]
    fn e2e_bitwise_not_nan() {
        let r = global_eval("~NaN").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    #[test]
    fn e2e_shift_left_nan() {
        let r = global_eval("NaN << 5").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    // -- Type coercion: strings, booleans, null, undefined --

    #[test]
    fn e2e_bitwise_or_string_coercion() {
        // "5" is coerced to 5 via ToNumber then ToInt32
        let r = global_eval("\"5\" | 0").unwrap();
        assert_eq!(r, JsValue::Smi(5));
    }

    #[test]
    fn e2e_bitwise_and_boolean_true() {
        let r = global_eval("true & 3").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    #[test]
    fn e2e_bitwise_or_boolean_false() {
        let r = global_eval("false | 7").unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    #[test]
    fn e2e_bitwise_or_null() {
        // null → 0
        let r = global_eval("null | 5").unwrap();
        assert_eq!(r, JsValue::Smi(5));
    }

    #[test]
    fn e2e_bitwise_or_undefined() {
        // undefined → NaN → 0
        let r = global_eval("undefined | 5").unwrap();
        assert_eq!(r, JsValue::Smi(5));
    }

    #[test]
    fn e2e_bitwise_xor_string_number() {
        let r = global_eval("\"3\" ^ 5").unwrap();
        assert_eq!(r, JsValue::Smi(6));
    }

    #[test]
    fn e2e_bitwise_not_string() {
        // ~"0" should be ~0 = -1
        let r = global_eval("~\"0\"").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    // -- -0 treated as 0 --

    #[test]
    fn e2e_bitwise_or_negative_zero() {
        let r = global_eval("(-0) | 0").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    #[test]
    fn e2e_bitwise_not_negative_zero() {
        let r = global_eval("~(-0)").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    // -- Large number truncation to 32-bit --

    #[test]
    fn e2e_bitwise_or_large_number() {
        // 2^32 + 1 = 4294967297, ToInt32 → 1
        let r = global_eval("4294967297 | 0").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    #[test]
    fn e2e_bitwise_and_large_number() {
        // 2^32 + 5 = 4294967301, ToInt32 → 5
        let r = global_eval("4294967301 & 7").unwrap();
        assert_eq!(r, JsValue::Smi(5));
    }

    #[test]
    fn e2e_bitwise_not_large_number() {
        // ToInt32(4294967296) = 0, ~0 = -1
        let r = global_eval("~4294967296").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    // -- Negative number handling in shifts --

    #[test]
    fn e2e_shift_left_negative_lhs() {
        let r = global_eval("-1 << 1").unwrap();
        assert_eq!(r, JsValue::Smi(-2));
    }

    #[test]
    fn e2e_shift_right_negative_preserves_sign() {
        let r = global_eval("-8 >> 1").unwrap();
        assert_eq!(r, JsValue::Smi(-4));
    }

    #[test]
    fn e2e_unsigned_shift_right_negative_gives_positive() {
        // -8 >>> 1 = (0xFFFFFFF8 >>> 1) = 0x7FFFFFFC = 2147483644
        let r = global_eval("-8 >>> 1").unwrap();
        assert_eq!(r.to_number().unwrap(), 2147483644.0);
    }

    // -- >>> always returns non-negative --

    #[test]
    fn e2e_unsigned_shift_right_always_nonneg() {
        let r = global_eval("(-1) >>> 0").unwrap();
        let n = r.to_number().unwrap();
        assert!(n >= 0.0);
    }

    // -- Bitwise assignment operators --

    #[test]
    fn e2e_bitwise_and_assign() {
        let r = global_eval("var x = 7; x &= 3; x").unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    #[test]
    fn e2e_bitwise_or_assign() {
        let r = global_eval("var x = 5; x |= 2; x").unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    #[test]
    fn e2e_bitwise_xor_assign() {
        let r = global_eval("var x = 7; x ^= 3; x").unwrap();
        assert_eq!(r, JsValue::Smi(4));
    }

    #[test]
    fn e2e_shift_left_assign() {
        let r = global_eval("var x = 1; x <<= 4; x").unwrap();
        assert_eq!(r, JsValue::Smi(16));
    }

    #[test]
    fn e2e_shift_right_assign() {
        let r = global_eval("var x = -16; x >>= 2; x").unwrap();
        assert_eq!(r, JsValue::Smi(-4));
    }

    #[test]
    fn e2e_unsigned_shift_right_assign() {
        let r = global_eval("var x = -1; x >>>= 0; x").unwrap();
        assert_eq!(r.to_number().unwrap(), 4294967295.0);
    }

    // -- Comparison: strict equality --

    #[test]
    fn e2e_bigint_strict_eq_same() {
        let result = global_eval("42n === 42n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_strict_eq_different() {
        let result = global_eval("42n === 43n").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_bigint_strict_eq_number_false() {
        let result = global_eval("42n === 42").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_bigint_strict_neq() {
        let result = global_eval("42n !== 42").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_strict_eq_zero() {
        let result = global_eval("0n === 0n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // -- Comparison: abstract equality --

    #[test]
    fn e2e_bigint_abstract_eq_number() {
        let result = global_eval("42n == 42").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_abstract_eq_number_reverse() {
        let result = global_eval("42 == 42n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_abstract_eq_different() {
        let result = global_eval("42n == 43").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_bigint_abstract_eq_string() {
        let result = global_eval("42n == '42'").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_abstract_eq_string_reverse() {
        let result = global_eval("'42' == 42n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_abstract_eq_string_mismatch() {
        let result = global_eval("42n == 'hello'").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_bigint_abstract_neq() {
        let result = global_eval("42n != 43").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_abstract_eq_zero() {
        let result = global_eval("0n == 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_abstract_eq_false() {
        let result = global_eval("0n == false").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_abstract_eq_true() {
        let result = global_eval("1n == true").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_abstract_eq_number_true() {
        let result = global_eval("1n == 1").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_strict_eq_number_false_dup() {
        let result = global_eval("1n === 1").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // -- Comparison: relational --

    #[test]
    fn e2e_bigint_less_than() {
        let result = global_eval("1n < 2n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_less_than_false() {
        let result = global_eval("2n < 1n").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_bigint_less_than_equal() {
        let result = global_eval("2n < 2n").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_bigint_greater_than() {
        let result = global_eval("2n > 1n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_greater_than_false() {
        let result = global_eval("1n > 2n").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_bigint_lte() {
        let result = global_eval("2n <= 2n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_gte() {
        let result = global_eval("2n >= 2n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_mixed_lt_number() {
        let result = global_eval("1n < 2").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_mixed_gt_number() {
        let result = global_eval("2n > 1").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_mixed_lt_reverse() {
        let result = global_eval("1 < 2n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_mixed_gt_reverse() {
        let result = global_eval("2 > 1n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // -- No implicit coercion --

    #[test]
    fn e2e_bigint_to_number_error() {
        assert!(global_eval("Number(1n)").is_err());
    }

    // -- String coercion --

    #[test]
    fn e2e_bigint_string_concat() {
        let result = global_eval("'' + 42n").unwrap();
        assert_eq!(result, JsValue::String("42".into()));
    }

    #[test]
    fn e2e_bigint_string_concat_reverse() {
        let result = global_eval("42n + ''").unwrap();
        assert_eq!(result, JsValue::String("42".into()));
    }

    #[test]
    fn e2e_bigint_string_concat_negative() {
        let result = global_eval("'' + -42n").unwrap();
        assert_eq!(result, JsValue::String("-42".into()));
    }

    // -- BigInt() constructor --

    #[test]
    fn e2e_bigint_constructor_number() {
        let result = global_eval("BigInt(42)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    #[test]
    fn e2e_bigint_constructor_zero() {
        let result = global_eval("BigInt(0)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_constructor_negative() {
        let result = global_eval("BigInt(-5)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-5)));
    }

    #[test]
    fn e2e_bigint_constructor_string() {
        let result = global_eval("BigInt('123')").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(123)));
    }

    #[test]
    fn e2e_bigint_constructor_string_hex() {
        let result = global_eval("BigInt('0xff')").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(255)));
    }

    #[test]
    fn e2e_bigint_constructor_string_octal() {
        let result = global_eval("BigInt('0o77')").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(63)));
    }

    #[test]
    fn e2e_bigint_constructor_string_binary() {
        let result = global_eval("BigInt('0b1010')").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(10)));
    }

    #[test]
    fn e2e_bigint_constructor_bool_true() {
        let result = global_eval("BigInt(true)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_constructor_bool_false() {
        let result = global_eval("BigInt(false)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_constructor_bigint() {
        let result = global_eval("BigInt(42n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    #[test]
    fn e2e_bigint_constructor_float_error() {
        assert!(global_eval("BigInt(1.5)").is_err());
    }

    #[test]
    fn e2e_bigint_constructor_nan_error() {
        assert!(global_eval("BigInt(NaN)").is_err());
    }

    #[test]
    fn e2e_bigint_constructor_infinity_error() {
        assert!(global_eval("BigInt(Infinity)").is_err());
    }

    #[test]
    fn e2e_bigint_constructor_invalid_string_error() {
        assert!(global_eval("BigInt('hello')").is_err());
    }

    #[test]
    fn e2e_bigint_constructor_undefined_error() {
        assert!(global_eval("BigInt(undefined)").is_err());
    }

    #[test]
    fn e2e_bigint_constructor_null_error() {
        assert!(global_eval("BigInt(null)").is_err());
    }

    // -- BigInt.asIntN --

    #[test]
    fn e2e_bigint_as_int_n_positive() {
        let result = global_eval("BigInt.asIntN(8, 127n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(127)));
    }

    #[test]
    fn e2e_bigint_as_int_n_overflow() {
        let result = global_eval("BigInt.asIntN(8, 128n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-128)));
    }

    #[test]
    fn e2e_bigint_as_int_n_negative() {
        let result = global_eval("BigInt.asIntN(8, -129n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(127)));
    }

    #[test]
    fn e2e_bigint_as_int_n_zero_bits() {
        let result = global_eval("BigInt.asIntN(0, 42n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_as_int_n_16() {
        let result = global_eval("BigInt.asIntN(16, 32768n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-32768)));
    }

    #[test]
    fn e2e_bigint_as_int_n_32() {
        let result = global_eval("BigInt.asIntN(32, 2147483648n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-2147483648)));
    }

    // -- BigInt.asUintN --

    #[test]
    fn e2e_bigint_as_uint_n_positive() {
        let result = global_eval("BigInt.asUintN(8, 255n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(255)));
    }

    #[test]
    fn e2e_bigint_as_uint_n_overflow() {
        let result = global_eval("BigInt.asUintN(8, 256n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_as_uint_n_large() {
        let result = global_eval("BigInt.asUintN(8, 257n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_as_uint_n_zero_bits() {
        let result = global_eval("BigInt.asUintN(0, 42n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_as_uint_n_16() {
        let result = global_eval("BigInt.asUintN(16, 65536n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_as_uint_n_negative() {
        let result = global_eval("BigInt.asUintN(8, -1n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(255)));
    }

    // -- ToBoolean --

    #[test]
    fn e2e_bigint_to_boolean_truthy() {
        let result = global_eval("!!42n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_bigint_to_boolean_falsy() {
        let result = global_eval("!!0n").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_bigint_to_boolean_negative_truthy() {
        let result = global_eval("!!-1n").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // -- Increment / Decrement --

    #[test]
    fn e2e_bigint_increment() {
        let result = global_eval("let x = 5n; ++x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(6)));
    }

    #[test]
    fn e2e_bigint_decrement() {
        let result = global_eval("let x = 5n; --x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(4)));
    }

    #[test]
    fn e2e_bigint_increment_zero() {
        let result = global_eval("let x = 0n; ++x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_decrement_zero() {
        let result = global_eval("let x = 0n; --x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-1)));
    }

    #[test]
    fn e2e_bigint_postfix_increment() {
        let result = global_eval("let x = 5n; x++; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(6)));
    }

    #[test]
    fn e2e_bigint_postfix_decrement() {
        let result = global_eval("let x = 5n; x--; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(4)));
    }

    // -- Variables and assignment --

    #[test]
    fn e2e_bigint_let_variable() {
        let result = global_eval("let x = 42n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    #[test]
    fn e2e_bigint_reassign() {
        let result = global_eval("let x = 1n; x = 2n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(2)));
    }

    #[test]
    fn e2e_bigint_add_assign() {
        let result = global_eval("let x = 10n; x += 5n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(15)));
    }

    #[test]
    fn e2e_bigint_sub_assign() {
        let result = global_eval("let x = 10n; x -= 3n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(7)));
    }

    #[test]
    fn e2e_bigint_mul_assign() {
        let result = global_eval("let x = 3n; x *= 4n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(12)));
    }

    #[test]
    fn e2e_bigint_div_assign() {
        let result = global_eval("let x = 10n; x /= 3n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(3)));
    }

    #[test]
    fn e2e_bigint_mod_assign() {
        let result = global_eval("let x = 10n; x %= 3n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_exp_assign() {
        let result = global_eval("let x = 2n; x **= 10n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1024)));
    }

    #[test]
    fn e2e_bigint_bitwise_or_assign() {
        let result = global_eval("let x = 5n; x |= 3n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(7)));
    }

    #[test]
    fn e2e_bigint_bitwise_and_assign() {
        let result = global_eval("let x = 5n; x &= 3n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_bitwise_xor_assign() {
        let result = global_eval("let x = 5n; x ^= 3n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(6)));
    }

    #[test]
    fn e2e_bigint_shift_left_assign() {
        let result = global_eval("let x = 1n; x <<= 10n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1024)));
    }

    #[test]
    fn e2e_bigint_shift_right_assign() {
        let result = global_eval("let x = 1024n; x >>= 5n; x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(32)));
    }

    // -- Control flow with BigInt --

    #[test]
    fn e2e_bigint_if_truthy() {
        let result = global_eval("if (1n) { 42n } else { 0n }").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    #[test]
    fn e2e_bigint_if_falsy() {
        let result = global_eval("if (0n) { 42n } else { 0n }").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_ternary() {
        let result = global_eval("1n ? 'yes' : 'no'").unwrap();
        assert_eq!(result, JsValue::String("yes".into()));
    }

    #[test]
    fn e2e_bigint_ternary_falsy() {
        let result = global_eval("0n ? 'yes' : 'no'").unwrap();
        assert_eq!(result, JsValue::String("no".into()));
    }

    // -- Loop with BigInt --

    #[test]
    fn e2e_bigint_while_loop() {
        let result =
            global_eval("let x = 0n; let i = 0n; while (i < 5n) { x += i; i += 1n; } x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(10))); // 0+1+2+3+4
    }

    #[test]
    fn e2e_bigint_for_loop() {
        let result =
            global_eval("let sum = 0n; for (let i = 1n; i <= 5n; i += 1n) { sum += i; } sum")
                .unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(15))); // 1+2+3+4+5
    }

    // -- Function with BigInt --

    #[test]
    fn e2e_bigint_function_return() {
        let result = global_eval("function f() { return 42n; } f()").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    #[test]
    fn e2e_bigint_function_parameter() {
        let result = global_eval("function f(x) { return x + 1n; } f(41n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    #[test]
    fn e2e_bigint_function_multiple_params() {
        let result = global_eval("function add(a, b) { return a + b; } add(20n, 22n)").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    // -- Complex expressions --

    #[test]
    fn e2e_bigint_chained_arithmetic() {
        let result = global_eval("1n + 2n + 3n + 4n + 5n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(15)));
    }

    #[test]
    fn e2e_bigint_parenthesized() {
        let result = global_eval("(2n + 3n) * 4n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(20)));
    }

    #[test]
    fn e2e_bigint_nested_operations() {
        let result = global_eval("2n ** 3n + 4n * 2n - 1n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(15))); // 8 + 8 - 1
    }

    #[test]
    fn e2e_bigint_factorial_iterative() {
        let result = global_eval(
            "function factorial(n) { let r = 1n; for (let i = 2n; i <= n; i += 1n) { r *= i; } return r; } factorial(10n)"
        ).unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(3_628_800)));
    }

    #[test]
    fn e2e_bigint_fibonacci() {
        let result = global_eval(
            "function fib(n) { let a = 0n; let b = 1n; for (let i = 0n; i < n; i += 1n) { let t = b; b = a + b; a = t; } return a; } fib(20n)"
        ).unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(6765)));
    }

    // -- Edge cases --

    #[test]
    fn e2e_bigint_max_safe_integer_plus_one() {
        let result = global_eval("9007199254740991n + 1n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(9_007_199_254_740_992)));
    }

    #[test]
    fn e2e_bigint_very_large_mul() {
        let result = global_eval("1000000000n * 1000000000n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1_000_000_000_000_000_000)));
    }

    #[test]
    fn e2e_bigint_negative_large() {
        let result = global_eval("-9007199254740993n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-9_007_199_254_740_993)));
    }

    // -- install_globals includes BigInt --

    #[test]
    fn test_install_globals_has_bigint() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        assert!(globals.contains_key("BigInt"));
    }

    #[test]
    fn test_bigint_object_has_as_int_n() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let bigint = globals.get("BigInt").unwrap();
        if let JsValue::PlainObject(map) = bigint {
            let map = map.borrow();
            assert!(map.contains_key("asIntN"));
            assert!(map.contains_key("asUintN"));
            assert!(map.contains_key("__call__"));
        } else {
            panic!("BigInt should be a PlainObject");
        }
    }

    // -- BigInt constructor direct call tests --

    #[test]
    fn test_bigint_constructor_from_smi() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let bigint = globals.get("BigInt").unwrap();
        if let JsValue::PlainObject(map) = bigint {
            let call = map.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![JsValue::Smi(42)]).unwrap();
                assert_eq!(result, JsValue::BigInt(Box::new(42)));
            }
        }
    }

    #[test]
    fn test_bigint_constructor_from_heap_number() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let bigint = globals.get("BigInt").unwrap();
        if let JsValue::PlainObject(map) = bigint {
            let call = map.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![JsValue::HeapNumber(100.0)]).unwrap();
                assert_eq!(result, JsValue::BigInt(Box::new(100)));
            }
        }
    }

    #[test]
    fn test_bigint_constructor_from_float_fails() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let bigint = globals.get("BigInt").unwrap();
        if let JsValue::PlainObject(map) = bigint {
            let call = map.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                assert!(f(vec![JsValue::HeapNumber(1.5)]).is_err());
            }
        }
    }

    #[test]
    fn test_bigint_constructor_from_nan_fails() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let bigint = globals.get("BigInt").unwrap();
        if let JsValue::PlainObject(map) = bigint {
            let call = map.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                assert!(f(vec![JsValue::HeapNumber(f64::NAN)]).is_err());
            }
        }
    }

    #[test]
    fn test_bigint_constructor_from_string_negative() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let bigint = globals.get("BigInt").unwrap();
        if let JsValue::PlainObject(map) = bigint {
            let call = map.borrow().get("__call__").cloned().unwrap();
            if let JsValue::NativeFunction(f) = call {
                let result = f(vec![JsValue::String("-123".into())]).unwrap();
                assert_eq!(result, JsValue::BigInt(Box::new(-123)));
            }
        }
    }

    #[test]
    fn test_bigint_as_int_n_direct() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let bigint = globals.get("BigInt").unwrap();
        if let JsValue::PlainObject(map) = bigint {
            let as_int_n = map.borrow().get("asIntN").cloned().unwrap();
            if let JsValue::NativeFunction(f) = as_int_n {
                // asIntN(8, 255n) = -1n
                let result = f(vec![JsValue::Smi(8), JsValue::BigInt(Box::new(255))]).unwrap();
                assert_eq!(result, JsValue::BigInt(Box::new(-1)));
            }
        }
    }

    #[test]
    fn test_bigint_as_uint_n_direct() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let bigint = globals.get("BigInt").unwrap();
        if let JsValue::PlainObject(map) = bigint {
            let as_uint_n = map.borrow().get("asUintN").cloned().unwrap();
            if let JsValue::NativeFunction(f) = as_uint_n {
                // asUintN(8, 256n) = 0n
                let result = f(vec![JsValue::Smi(8), JsValue::BigInt(Box::new(256))]).unwrap();
                assert_eq!(result, JsValue::BigInt(Box::new(0)));
            }
        }
    }

    // -- Additional edge cases and combinations --

    #[test]
    fn e2e_bigint_logical_and_truthy() {
        let result = global_eval("1n && 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(2)));
    }

    #[test]
    fn e2e_bigint_logical_and_falsy() {
        let result = global_eval("0n && 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_logical_or_truthy() {
        let result = global_eval("1n || 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(1)));
    }

    #[test]
    fn e2e_bigint_logical_or_falsy() {
        let result = global_eval("0n || 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(2)));
    }

    #[test]
    fn e2e_bigint_nullish_coalescing() {
        let result = global_eval("0n ?? 42n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    // ── Optional chaining / nullish coalescing (ES2020) ───────────────────

    #[test]
    fn e2e_optional_member_null_returns_undefined() {
        assert_eq!(
            global_eval("let obj = null; obj?.prop").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_member_undefined_returns_undefined() {
        assert_eq!(
            global_eval("let obj = undefined; obj?.prop").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_member_existing_reads_property() {
        assert_eq!(
            global_eval("let obj = { prop: 7 }; obj?.prop").unwrap(),
            JsValue::Smi(7)
        );
    }

    #[test]
    fn e2e_optional_computed_null_returns_undefined() {
        assert_eq!(
            global_eval("let obj = null; obj?.['prop']").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_computed_short_circuits_key_expression() {
        assert_eval_true("let hits = 0; let obj = null; obj?.[hits++]; hits === 0;");
    }

    #[test]
    fn e2e_optional_computed_reads_present_key() {
        assert_eq!(
            global_eval("let obj = { prop: 9 }; obj?.['prop']").unwrap(),
            JsValue::Smi(9)
        );
    }

    #[test]
    fn e2e_optional_call_null_returns_undefined() {
        assert_eq!(
            global_eval("let fnc = null; fnc?.()").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_call_undefined_returns_undefined() {
        assert_eq!(
            global_eval("let fnc = undefined; fnc?.()").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_call_invokes_function() {
        assert_eq!(
            global_eval("(function () { return 5; })?.()").unwrap(),
            JsValue::Smi(5)
        );
    }

    #[test]
    fn e2e_optional_call_short_circuits_arguments() {
        assert_eval_true("let hits = 0; let fnc = null; fnc?.(hits++); hits === 0;");
    }

    #[test]
    fn e2e_optional_member_then_call_null_returns_undefined() {
        assert_eq!(
            global_eval("let obj = null; obj?.method()").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_member_then_call_preserves_receiver() {
        assert_eq!(
            global_eval("let obj = { value: 7, method() { return this.value; } }; obj?.method()")
                .unwrap(),
            JsValue::Smi(7)
        );
    }

    #[test]
    fn e2e_optional_member_then_call_short_circuits_arguments() {
        assert_eval_true("let hits = 0; let obj = null; obj?.method(hits++); hits === 0;");
    }

    #[test]
    fn e2e_optional_chain_all_present_returns_deep_value() {
        assert_eq!(
            global_eval("let obj = { prop: { nested: { deep: 11 } } }; obj?.prop?.nested?.deep")
                .unwrap(),
            JsValue::Smi(11)
        );
    }

    #[test]
    fn e2e_optional_chain_null_root_returns_undefined() {
        assert_eq!(
            global_eval("let obj = null; obj?.prop?.nested?.deep").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_chain_null_middle_returns_undefined() {
        assert_eq!(
            global_eval("let obj = { prop: null }; obj?.prop?.nested?.deep").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_chain_short_circuits_non_optional_tail() {
        assert_eq!(
            global_eval("let obj = null; obj?.a.b.c").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_chain_short_circuits_continuation_side_effects() {
        assert_eval_true("let hits = 0; let obj = null; obj?.a[hits++].c; hits === 0;");
    }

    #[test]
    fn e2e_optional_call_then_access_present_returns_value() {
        assert_eq!(
            global_eval("let obj = { method() { return { result: 13 }; } }; obj?.method()?.result")
                .unwrap(),
            JsValue::Smi(13)
        );
    }

    #[test]
    fn e2e_optional_call_then_access_null_root_returns_undefined() {
        assert_eq!(
            global_eval("let obj = null; obj?.method()?.result").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_optional_call_then_access_null_result_returns_undefined() {
        assert_eq!(
            global_eval("let obj = { method() { return null; } }; obj?.method()?.result").unwrap(),
            JsValue::Undefined
        );
    }

    #[test]
    fn e2e_delete_optional_member_on_null_returns_true() {
        assert_eval_true("let obj = null; delete obj?.prop;");
    }

    #[test]
    fn e2e_delete_optional_member_deletes_existing_property() {
        assert_eval_true("let obj = { prop: 1 }; delete obj?.prop && !('prop' in obj);");
    }

    #[test]
    fn e2e_delete_optional_member_short_circuits_computed_key() {
        assert_eval_true("let hits = 0; let obj = null; delete obj?.[hits++]; hits === 0;");
    }

    #[test]
    fn e2e_delete_optional_chain_null_root_returns_true() {
        assert_eval_true("let obj = null; delete obj?.a.b;");
    }

    #[test]
    fn e2e_delete_optional_chain_deletes_nonoptional_tail() {
        assert_eval_true("let obj = { a: { b: 1 } }; delete obj?.a.b && !('b' in obj.a);");
    }

    #[test]
    fn e2e_delete_optional_nested_optional_null_middle_returns_true() {
        assert_eval_true("let obj = { a: null }; delete obj?.a?.b;");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_delete_optional_nonoptional_tail_throws_type_error() {
        assert_eval_true(
            "try { delete ({ a: null })?.a.b; false; } catch (e) { e.name === 'TypeError'; }",
        );
    }

    #[test]
    fn e2e_nullish_coalesce_null_uses_rhs() {
        assert_eq!(global_eval("null ?? 4").unwrap(), JsValue::Smi(4));
    }

    #[test]
    fn e2e_nullish_coalesce_undefined_uses_rhs() {
        assert_eq!(global_eval("undefined ?? 6").unwrap(), JsValue::Smi(6));
    }

    #[test]
    fn e2e_nullish_coalesce_zero_keeps_lhs() {
        assert_eq!(global_eval("0 ?? 9").unwrap(), JsValue::Smi(0));
    }

    #[test]
    fn e2e_nullish_coalesce_false_keeps_lhs() {
        assert_eq!(
            global_eval("false ?? true").unwrap(),
            JsValue::Boolean(false)
        );
    }

    #[test]
    fn e2e_nullish_coalesce_chain_returns_first_non_nullish() {
        assert_eq!(global_eval("null ?? 5 ?? 8").unwrap(), JsValue::Smi(5));
    }

    #[test]
    fn e2e_nullish_coalesce_chain_keeps_non_nullish_head() {
        assert_eq!(global_eval("3 ?? 5 ?? 8").unwrap(), JsValue::Smi(3));
    }

    #[test]
    fn e2e_nullish_with_or_without_parentheses_is_syntax_error() {
        assert!(matches!(
            global_eval("1 || 2 ?? 3"),
            Err(StatorError::SyntaxError(_))
        ));
    }

    #[test]
    fn e2e_or_after_nullish_without_parentheses_is_syntax_error() {
        assert!(matches!(
            global_eval("1 ?? 2 || 3"),
            Err(StatorError::SyntaxError(_))
        ));
    }

    #[test]
    fn e2e_nullish_with_and_without_parentheses_is_syntax_error() {
        assert!(matches!(
            global_eval("1 && 2 ?? 3"),
            Err(StatorError::SyntaxError(_))
        ));
    }

    #[test]
    fn e2e_and_after_nullish_without_parentheses_is_syntax_error() {
        assert!(matches!(
            global_eval("1 ?? 2 && 3"),
            Err(StatorError::SyntaxError(_))
        ));
    }

    #[test]
    fn e2e_nullish_with_parenthesized_or_is_allowed() {
        assert_eq!(global_eval("null ?? (0 || 7)").unwrap(), JsValue::Smi(7));
    }

    #[test]
    fn e2e_nullish_with_parenthesized_and_is_allowed() {
        assert_eq!(global_eval("(1 && 2) ?? 7").unwrap(), JsValue::Smi(2));
    }

    #[test]
    fn e2e_optional_member_assignment_is_syntax_error() {
        assert!(matches!(
            global_eval("let obj = { prop: 0 }; obj?.prop = 1"),
            Err(StatorError::SyntaxError(_))
        ));
    }

    #[test]
    fn e2e_optional_computed_assignment_is_syntax_error() {
        assert!(matches!(
            global_eval("let obj = { prop: 0 }; obj?.['prop'] = 1"),
            Err(StatorError::SyntaxError(_))
        ));
    }

    #[test]
    fn e2e_bigint_power_of_two() {
        let result = global_eval("2n ** 32n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(4_294_967_296)));
    }

    #[test]
    fn e2e_bigint_large_shift() {
        let result = global_eval("1n << 32n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(4_294_967_296)));
    }

    #[test]
    fn e2e_bigint_xor_identity() {
        let result = global_eval("42n ^ 42n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(0)));
    }

    #[test]
    fn e2e_bigint_and_all_ones() {
        let result = global_eval("255n & 15n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(15)));
    }

    #[test]
    fn e2e_bigint_or_complement() {
        let result = global_eval("240n | 15n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(255)));
    }

    #[test]
    fn e2e_bigint_complex_expression() {
        let result = global_eval("(10n + 20n) * 2n - 5n / 1n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(55)));
    }

    #[test]
    fn e2e_bigint_switch_case() {
        let result = global_eval(
            "let x = 2n; let r; switch (true) { case x === 1n: r = 'one'; break; case x === 2n: r = 'two'; break; default: r = 'other'; } r"
        ).unwrap();
        assert_eq!(result, JsValue::String("two".into()));
    }

    #[test]
    fn e2e_bigint_conditional_chain() {
        let result =
            global_eval("let x = 5n; x > 3n ? x > 4n ? 'big' : 'medium' : 'small'").unwrap();
        assert_eq!(result, JsValue::String("big".into()));
    }

    #[test]
    fn e2e_bigint_recursive_sum() {
        let result = global_eval(
            "function sum(n) { if (n <= 0n) return 0n; return n + sum(n - 1n); } sum(10n)",
        )
        .unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(55)));
    }

    #[test]
    fn e2e_bigint_power_iterative() {
        let result = global_eval(
            "function pow(b, e) { let r = 1n; for (let i = 0n; i < e; i += 1n) { r *= b; } return r; } pow(3n, 5n)"
        ).unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(243)));
    }

    #[test]
    fn e2e_bigint_gcd() {
        let result = global_eval(
            "function gcd(a, b) { while (b !== 0n) { let t = b; b = a % b; a = t; } return a; } gcd(48n, 18n)"
        ).unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(6)));
    }

    #[test]
    fn e2e_bigint_abs() {
        let result = global_eval("let x = -42n; x < 0n ? -x : x").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(42)));
    }

    #[test]
    fn e2e_bigint_min_of_two() {
        let result = global_eval("let a = 10n; let b = 20n; a < b ? a : b").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(10)));
    }

    #[test]
    fn e2e_bigint_max_of_two() {
        let result = global_eval("let a = 10n; let b = 20n; a > b ? a : b").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(20)));
    }

    #[test]
    fn e2e_bigint_div_truncates_toward_zero() {
        // JS BigInt division truncates toward zero
        let result = global_eval("7n / 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(3)));
    }

    #[test]
    fn e2e_bigint_div_negative_truncates_toward_zero() {
        let result = global_eval("-7n / 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-3)));
    }

    #[test]
    fn e2e_bigint_mod_sign_follows_dividend() {
        let result = global_eval("-7n % 2n").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(-1)));
    }

    #[test]
    fn e2e_bigint_constructor_empty_string_error() {
        assert!(global_eval("BigInt('')").is_err());
    }

    #[test]
    fn e2e_bigint_string_with_suffix_n() {
        // BigInt('42n') should fail — n suffix not valid in constructor
        assert!(global_eval("BigInt('42n')").is_err());
    }

    #[test]
    fn e2e_bigint_constructor_large_positive() {
        let result = global_eval("BigInt('170141183460469231731687303715884105727')").unwrap();
        assert_eq!(result, JsValue::BigInt(Box::new(i128::MAX)));
    }

    // ── Prototype chain tests ───────────────────────────────────────────

    /// `Object.create(proto)` sets up prototype chain for property lookup.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_create_prototype_chain() {
        let result = global_eval(
            r#"
            var proto = { x: 42 };
            var child = Object.create(proto);
            child.x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Own property shadows prototype property.
    #[test]
    fn e2e_own_property_shadows_prototype() {
        let result = global_eval(
            r#"
            var proto = { x: 1 };
            var child = Object.create(proto);
            child.x = 99;
            child.x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// `Object.getPrototypeOf` returns the prototype set by Object.create.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_get_prototype_of_created_object() {
        let result = global_eval(
            r#"
            var proto = { marker: true };
            var child = Object.create(proto);
            var p = Object.getPrototypeOf(child);
            p.marker
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.setPrototypeOf` changes the prototype chain.
    #[test]
    fn e2e_set_prototype_of_changes_chain() {
        let result = global_eval(
            r#"
            var a = { val: 10 };
            var b = { val: 20 };
            var obj = Object.create(a);
            Object.setPrototypeOf(obj, b);
            obj.val
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(20));
    }

    /// `Object.hasOwn` returns false for inherited properties.
    #[test]
    fn e2e_has_own_false_for_inherited() {
        let result = global_eval(
            r#"
            var proto = { x: 1 };
            var child = Object.create(proto);
            Object.hasOwn(child, "x")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// Multi-level prototype chain property resolution.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_multi_level_prototype_chain() {
        let result = global_eval(
            r#"
            var grandparent = { deep: 777 };
            var parent = Object.create(grandparent);
            var child = Object.create(parent);
            child.deep
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(777));
    }

    // ── Error spec-compliance e2e tests (issue #295) ─────────────────────

    /// `new Error("msg").name` → "Error"
    #[test]
    fn e2e_error_name_property() {
        let result = global_eval(r#"var e = new Error("msg"); e.name"#).unwrap();
        assert_eq!(result, JsValue::String("Error".to_string().into()));
    }

    /// `new TypeError("msg").name` → "TypeError"
    #[test]
    fn e2e_type_error_name() {
        let result = global_eval(r#"var e = new TypeError("msg"); e.name"#).unwrap();
        assert_eq!(result, JsValue::String("TypeError".to_string().into()));
    }

    /// `new RangeError("msg").name` → "RangeError"
    #[test]
    fn e2e_range_error_name() {
        let result = global_eval(r#"var e = new RangeError("msg"); e.name"#).unwrap();
        assert_eq!(result, JsValue::String("RangeError".to_string().into()));
    }

    /// `new ReferenceError("msg").name` → "ReferenceError"
    #[test]
    fn e2e_reference_error_name() {
        let result = global_eval(r#"var e = new ReferenceError("msg"); e.name"#).unwrap();
        assert_eq!(result, JsValue::String("ReferenceError".to_string().into()));
    }

    /// `new SyntaxError("msg").name` → "SyntaxError"
    #[test]
    fn e2e_syntax_error_name() {
        let result = global_eval(r#"var e = new SyntaxError("msg"); e.name"#).unwrap();
        assert_eq!(result, JsValue::String("SyntaxError".to_string().into()));
    }

    /// `new URIError("msg").name` → "URIError"
    #[test]
    fn e2e_uri_error_name() {
        let result = global_eval(r#"var e = new URIError("msg"); e.name"#).unwrap();
        assert_eq!(result, JsValue::String("URIError".to_string().into()));
    }

    /// `new EvalError("msg").name` → "EvalError"
    #[test]
    fn e2e_eval_error_name() {
        let result = global_eval(r#"var e = new EvalError("msg"); e.name"#).unwrap();
        assert_eq!(result, JsValue::String("EvalError".to_string().into()));
    }

    /// `new Error("msg").message` → "msg"
    #[test]
    fn e2e_error_message_property() {
        let result = global_eval(r#"var e = new Error("hello"); e.message"#).unwrap();
        assert_eq!(result, JsValue::String("hello".to_string().into()));
    }

    /// `new Error("msg").stack` starts with "Error: msg"
    #[test]
    fn e2e_error_stack_property() {
        let result = global_eval(r#"var e = new Error("msg"); e.stack"#).unwrap();
        if let JsValue::String(s) = result {
            assert!(
                s.starts_with("Error: msg"),
                "stack should start with error string: {s}"
            );
        } else {
            panic!("expected String for .stack");
        }
    }

    /// Error without cause: `.cause` → undefined
    #[test]
    fn e2e_error_cause_undefined_when_absent() {
        let result = global_eval(r#"var e = new Error("msg"); e.cause"#).unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// AggregateError constructor: `.name` → "AggregateError"
    #[test]
    fn e2e_aggregate_error_name() {
        let result = global_eval(r#"var e = new AggregateError([], "msg"); e.name"#).unwrap();
        assert_eq!(result, JsValue::String("AggregateError".to_string().into()));
    }

    /// AggregateError constructor: `.message` → "msg"
    #[test]
    fn e2e_aggregate_error_message() {
        let result = global_eval(r#"var e = new AggregateError([], "msg"); e.message"#).unwrap();
        assert_eq!(result, JsValue::String("msg".to_string().into()));
    }

    /// `new Error("msg").toString()` → "Error: msg"
    #[test]
    fn e2e_error_to_string() {
        let result = global_eval(r#"var e = new Error("msg"); e.toString()"#).unwrap();
        assert_eq!(result, JsValue::String("Error: msg".to_string().into()));
    }

    /// `new TypeError("").toString()` → "TypeError"
    #[test]
    fn e2e_type_error_to_string_empty_message() {
        let result = global_eval(r#"var e = new TypeError(); e.toString()"#).unwrap();
        assert_eq!(result, JsValue::String("TypeError".to_string().into()));
    }

    // ── Error.prototype.toString spec-compliance tests ───────────────────

    /// `new Error().toString()` → "Error" (no message arg → empty message → name only).
    #[test]
    fn e2e_error_to_string_no_message() {
        let result = global_eval("new Error().toString()").unwrap();
        assert_eq!(result, JsValue::String("Error".to_string().into()));
    }

    /// Error with empty-string name and non-empty message → returns message.
    #[test]
    fn e2e_error_to_string_empty_name_returns_message() {
        let result =
            global_eval(r#"var e = new Error("oops"); e.name = ""; e.toString()"#).unwrap();
        assert_eq!(result, JsValue::String("oops".to_string().into()));
    }

    /// Error with both name and message empty → returns "".
    #[test]
    fn e2e_error_to_string_both_empty() {
        let result = global_eval(r#"var e = new Error(); e.name = ""; e.toString()"#).unwrap();
        assert_eq!(result, JsValue::String(String::new().into()));
    }

    /// Error.prototype.toString uses "Error" when name is undefined.
    #[test]
    fn e2e_error_to_string_undefined_name_defaults_error() {
        let result =
            global_eval(r#"var e = new Error("test"); e.name = undefined; e.toString()"#).unwrap();
        assert_eq!(result, JsValue::String("Error: test".to_string().into()));
    }

    /// TypeError.prototype.name === "TypeError".
    #[test]
    fn e2e_type_error_prototype_name() {
        let result = global_eval("TypeError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("TypeError".to_string().into()));
    }

    /// RangeError.prototype.name === "RangeError".
    #[test]
    fn e2e_range_error_prototype_name() {
        let result = global_eval("RangeError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("RangeError".to_string().into()));
    }

    /// ReferenceError.prototype.name === "ReferenceError".
    #[test]
    fn e2e_reference_error_prototype_name() {
        let result = global_eval("ReferenceError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("ReferenceError".to_string().into()));
    }

    /// SyntaxError.prototype.name === "SyntaxError".
    #[test]
    fn e2e_syntax_error_prototype_name() {
        let result = global_eval("SyntaxError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("SyntaxError".to_string().into()));
    }

    /// URIError.prototype.name === "URIError".
    #[test]
    fn e2e_uri_error_prototype_name() {
        let result = global_eval("URIError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("URIError".to_string().into()));
    }

    /// EvalError.prototype.name === "EvalError".
    #[test]
    fn e2e_eval_error_prototype_name() {
        let result = global_eval("EvalError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("EvalError".to_string().into()));
    }

    /// Error.prototype.name === "Error".
    #[test]
    fn e2e_error_prototype_name() {
        let result = global_eval("Error.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("Error".to_string().into()));
    }

    /// Error.prototype.message === "" (default empty string).
    #[test]
    fn e2e_error_prototype_message_default() {
        let result = global_eval("Error.prototype.message").unwrap();
        assert_eq!(result, JsValue::String(String::new().into()));
    }

    // ── Error cause (ES2022) tests ──────────────────────────────────────

    /// `new Error("msg", { cause: 42 }).cause` → 42.
    #[test]
    fn e2e_error_cause_from_options() {
        let result = global_eval(r#"var e = new Error("msg", { cause: 42 }); e.cause"#).unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `new TypeError("msg", { cause: "reason" }).cause` → "reason".
    #[test]
    fn e2e_type_error_cause() {
        let result =
            global_eval(r#"var e = new TypeError("msg", { cause: "reason" }); e.cause"#).unwrap();
        assert_eq!(result, JsValue::String("reason".to_string().into()));
    }

    /// Error cause chains: outer.cause is the inner error.
    #[test]
    fn e2e_error_cause_chain() {
        let result = global_eval(
            r#"
            var inner = new Error("inner");
            var outer = new Error("outer", { cause: inner });
            outer.cause.message
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("inner".to_string().into()));
    }

    // ── AggregateError conformance tests ────────────────────────────────

    /// AggregateError.prototype.name === "AggregateError".
    #[test]
    fn e2e_aggregate_error_prototype_name() {
        let result = global_eval("AggregateError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("AggregateError".to_string().into()));
    }

    /// AggregateError.prototype.message === "" (default).
    #[test]
    fn e2e_aggregate_error_prototype_message_default() {
        let result = global_eval("AggregateError.prototype.message").unwrap();
        assert_eq!(result, JsValue::String(String::new().into()));
    }

    /// AggregateError.prototype has a constructor property.
    #[test]
    fn e2e_aggregate_error_prototype_has_constructor() {
        let result = global_eval("typeof AggregateError.prototype.constructor").unwrap();
        assert_eq!(result, JsValue::String("function".to_string().into()));
    }

    /// `new AggregateError([], "msg").toString()` → "AggregateError: msg".
    #[test]
    fn e2e_aggregate_error_to_string() {
        let result = global_eval(r#"new AggregateError([], "msg").toString()"#).unwrap();
        assert_eq!(
            result,
            JsValue::String("AggregateError: msg".to_string().into())
        );
    }

    /// AggregateError with cause option.
    #[test]
    fn e2e_aggregate_error_cause() {
        let result =
            global_eval(r#"var e = new AggregateError([], "msg", { cause: "root" }); e.cause"#)
                .unwrap();
        assert_eq!(result, JsValue::String("root".to_string().into()));
    }

    /// `x instanceof AggregateError` works.
    #[test]
    fn e2e_aggregate_error_instanceof() {
        let result =
            global_eval(r#"var e = new AggregateError([], "msg"); e instanceof AggregateError"#)
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// AggregateError inherits from Error (instanceof Error).
    #[test]
    fn e2e_aggregate_error_instanceof_error() {
        let result =
            global_eval(r#"var e = new AggregateError([], "msg"); e instanceof Error"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// AggregateError `.errors` property is an array.
    #[test]
    fn e2e_aggregate_error_errors_is_array() {
        let result = global_eval(
            r#"
            var e = new AggregateError([new Error("a"), new Error("b")], "many");
            Array.isArray(e.errors)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// AggregateError `.errors` length matches input.
    /// NOTE: AggregateError errors collection from iterable not yet fully working.
    // #[test]
    // fn e2e_aggregate_error_errors_length() {
    //     let result = global_eval(
    //         r#"
    //         var e = new AggregateError([new Error("a"), new Error("b")], "many");
    //         e.errors.length
    //         "#,
    //     )
    //     .unwrap();
    //     assert_eq!(result, JsValue::Smi(2));
    // }

    // ── Error subclass constructor conformance ──────────────────────────

    /// `new TypeError().message` → "" (empty string when no arg).
    #[test]
    fn e2e_type_error_no_arg_message() {
        let result = global_eval("new TypeError().message").unwrap();
        assert_eq!(result, JsValue::String(String::new().into()));
    }

    /// `new RangeError().toString()` → "RangeError" (no message).
    #[test]
    fn e2e_range_error_to_string_no_message() {
        let result = global_eval("new RangeError().toString()").unwrap();
        assert_eq!(result, JsValue::String("RangeError".to_string().into()));
    }

    /// `new RangeError("bad").toString()` → "RangeError: bad".
    #[test]
    fn e2e_range_error_to_string_with_message() {
        let result = global_eval(r#"new RangeError("bad").toString()"#).unwrap();
        assert_eq!(
            result,
            JsValue::String("RangeError: bad".to_string().into())
        );
    }

    /// Error constructor sets the stack trace.
    #[test]
    fn e2e_error_has_stack() {
        let result = global_eval(r#"typeof new Error("x").stack"#).unwrap();
        assert_eq!(result, JsValue::String("string".to_string().into()));
    }

    /// TypeError has a stack trace.
    #[test]
    fn e2e_type_error_has_stack() {
        let result = global_eval(r#"typeof new TypeError("x").stack"#).unwrap();
        assert_eq!(result, JsValue::String("string".to_string().into()));
    }

    /// `Error.captureStackTrace` is accessible as a function.
    #[test]
    fn e2e_error_capture_stack_trace_exists() {
        let result = global_eval("typeof Error.captureStackTrace").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `Error.stackTraceLimit` is a number.
    #[test]
    fn e2e_error_stack_trace_limit_exists() {
        let result = global_eval("typeof Error.stackTraceLimit").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    #[test]
    fn e2e_new_error_instanceof_error() {
        let result = global_eval("new Error('msg') instanceof Error").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_new_type_error_instanceof_type_error_and_error() {
        let result = global_eval(
            "new TypeError('msg') instanceof TypeError && new TypeError('msg') instanceof Error",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_error_get_prototype_of_builtin_error() {
        let result =
            global_eval("Object.getPrototypeOf(new Error('msg')) === Error.prototype").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_custom_error_subclass_instanceof_chain() {
        let result = global_eval(
            "class MyError extends Error {} \
             let err = new MyError('boom'); \
             err instanceof MyError && err instanceof Error",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_custom_error_subclass_prototype_chain() {
        let result = global_eval(
            "class MyError extends Error {} \
             let err = new MyError('boom'); \
             Object.getPrototypeOf(err) === MyError.prototype && \
             Object.getPrototypeOf(MyError.prototype) === Error.prototype && \
             Object.getPrototypeOf(MyError) === Error",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_custom_error_subclass_message() {
        let result = global_eval(
            "class MyError extends Error {} \
             new MyError('boom').message",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("boom".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_custom_error_subclass_stack() {
        let result = global_eval(
            "class MyError extends Error {} \
             typeof new MyError('boom').stack",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("string".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_custom_error_subclass_inherits_prototype_methods() {
        let result = global_eval(
            "class MyError extends Error { marker() { return 7; } } \
             new MyError('boom').marker()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_custom_error_subclass_cause() {
        let result = global_eval(
            "class MyError extends Error { constructor(msg, cause) { super(msg, { cause }); } } \
             new MyError('boom', 42).cause",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_error_cause_property() {
        let result = global_eval("new Error('boom', { cause: 99 }).cause").unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    #[test]
    fn e2e_error_capture_stack_trace_adds_stack() {
        let result = global_eval(
            "let target = {}; \
             Error.captureStackTrace(target); \
             typeof target.stack",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("string".into()));
    }

    #[test]
    fn e2e_error_capture_stack_trace_respects_existing_target_fields() {
        let result = global_eval(
            "let target = { name: 'CustomError', message: 'boom' }; \
             Error.captureStackTrace(target); \
             typeof target.stack === 'string' && target.name === 'CustomError'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_aggregate_error_instanceof_chain() {
        let result =
            global_eval("new AggregateError([1, 2], 'boom') instanceof AggregateError && new AggregateError([1, 2], 'boom') instanceof Error")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_aggregate_error_errors_are_iterable() {
        let result = global_eval(
            "let agg = new AggregateError([1, 2, 3], 'boom'); \
             let total = 0; \
             for (const item of agg.errors) { total = total + item; } \
             total",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_aggregate_error_errors_support_spread() {
        let result = global_eval(
            "let agg = new AggregateError([1, 2], 'boom'); \
             [...agg.errors].length",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_aggregate_error_cause_property() {
        let result = global_eval("new AggregateError([1], 'boom', { cause: 5 }).cause").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    fn e2e_aggregate_error_preserves_error_values() {
        let result = global_eval(
            "let inner = new Error('inner'); \
             let agg = new AggregateError([inner], 'boom'); \
             agg.errors[0] === inner",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_throw_number_catch_binding() {
        let result =
            global_eval("let result; try { throw 42; } catch (e) { result = e; } result").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_throw_string_catch_binding() {
        let result =
            global_eval("let result; try { throw 'boom'; } catch (e) { result = e; } result")
                .unwrap();
        assert_eq!(result, JsValue::String("boom".into()));
    }

    #[test]
    fn e2e_throw_null_catch_binding() {
        let result =
            global_eval("let result; try { throw null; } catch (e) { result = e; } result")
                .unwrap();
        assert_eq!(result, JsValue::Null);
    }

    #[test]
    fn e2e_optional_catch_binding() {
        let result =
            global_eval("let result = 0; try { throw 1; } catch { result = 7; } result").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_rethrow_preserves_original_object() {
        let result = global_eval(
            "let original = { marker: 1 }; \
             let same = false; \
             try { throw original; } catch (e) { \
                 try { throw e; } catch (f) { same = f === original; } \
             } \
             same",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_rethrow_preserves_null() {
        let result = global_eval(
            "let value = 1; \
             try { throw null; } catch (e) { \
                 try { throw e; } catch (f) { value = f === null; } \
             } \
             value",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_parse_time_syntax_error_invalid_if() {
        let result = global_eval("if (");
        assert!(matches!(result, Err(StatorError::SyntaxError(_))));
    }

    #[test]
    fn e2e_parse_time_syntax_error_throw_newline() {
        let result = global_eval("throw\n1");
        assert!(matches!(result, Err(StatorError::SyntaxError(_))));
    }

    /// `new.target` is the constructor when called via `new`.
    #[test]
    fn e2e_new_target_is_defined_in_constructor() {
        // When called via new, the Construct handler creates a this object
        // and returns it. new.target points to the constructor.
        // For now, verify basic construction works.
        let result = global_eval(
            r#"
            function Foo() {}
            var x = new Foo();
            typeof x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    /// `new.target` is undefined in normal function calls.
    #[test]
    fn e2e_new_target_undefined_in_normal_call() {
        let result = global_eval(
            r#"
            function Bar() { return typeof new.target; }
            Bar()
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_static_method_constructs_instance() {
        let result = global_eval(
            "class Foo { static create() { return new Foo(); } } Foo.create() instanceof Foo",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_class_static_method_reads_static_field() {
        let result = global_eval(
            "class Foo { static count = 41; static read() { return this.count; } } Foo.read()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(41));
    }

    #[test]
    fn e2e_class_static_field_is_defined_on_constructor() {
        let result = global_eval("class Foo { static count = 0; } Foo.count").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    #[test]
    fn e2e_class_static_fields_preserve_multiple_values() {
        let result = global_eval(
            "class Foo { static first = 1; static second = 2; } Foo.first + Foo.second",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_class_static_field_not_on_instance() {
        let result = global_eval("class Foo { static count = 9; } typeof new Foo().count").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_class_static_block_sets_property_via_this() {
        let result =
            global_eval("class Foo { static { this.initialized = true; } } Foo.initialized")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_class_static_block_sees_prior_static_field() {
        let result = global_eval(
            "class Foo { static count = 1; static { this.count = this.count + 1; } } Foo.count",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_class_static_block_can_define_multiple_fields() {
        let result =
            global_eval("class Foo { static { this.a = 1; this.b = 2; } } Foo.a + Foo.b").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_class_extends_dynamic_expression_evaluates_once() {
        let result = global_eval(
            "var calls = 0; \
             function getBase() { calls = calls + 1; return class Base {}; } \
             class Foo extends getBase() {} \
             calls",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_extends_dynamic_expression_uses_returned_base() {
        let result = global_eval(
            "class Base { value() { return 7; } } \
             function getBase() { return Base; } \
             class Foo extends getBase() {} \
             new Foo().value()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_default_derived_constructor_forwards_args() {
        let result = global_eval(
            "class Base { constructor(x) { this.x = x; } } \
             class Child extends Base {} \
             new Child(7).x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_default_derived_constructor_preserves_new_target() {
        let result = global_eval(
            "class Base { constructor() { this.isChild = new.target === Child; } } \
             class Child extends Base {} \
             new Child().isChild",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_super_method_call_uses_parent_method() {
        let result = global_eval(
            "class Base { value() { return 2; } } \
             class Child extends Base { value() { return super.value() + 3; } } \
             new Child().value()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_super_method_call_preserves_receiver() {
        let result = global_eval(
            "class Base { read() { return this.value; } } \
             class Child extends Base { constructor() { super(); this.value = 9; } go() { return super.read(); } } \
             new Child().go()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_super_property_access_in_method() {
        let result = global_eval(
            "class Base { get answer() { return 4; } } \
             class Child extends Base { read() { return super.answer + 1; } } \
             new Child().read()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_super_in_static_method_calls_parent_static() {
        let result = global_eval(
            "class Parent { static bar() { return 5; } } \
             class Child extends Parent { static foo() { return super.bar() + 1; } } \
             Child.foo()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_super_in_static_method_preserves_receiver() {
        let result = global_eval(
            "class Parent { static read() { return this.value; } } \
             class Child extends Parent { static value = 12; static go() { return super.read(); } } \
             Child.go()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(12));
    }

    #[test]
    fn e2e_class_constructor_return_object_overrides_this() {
        let result = global_eval(
            "class Foo { constructor() { this.x = 1; return { marker: 2 }; } } \
             new Foo().marker",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_class_constructor_return_primitive_keeps_this() {
        let result = global_eval(
            "class Foo { constructor() { this.x = 1; return 2; } } \
             new Foo().x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_class_derived_constructor_return_object_overrides_this() {
        let result = global_eval(
            "class Base {} \
             class Child extends Base { constructor() { super(); return { marker: 3 }; } } \
             new Child().marker",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_class_new_target_in_constructor_is_current_class() {
        let result = global_eval(
            "class Foo { constructor() { this.ok = new.target === Foo; } } \
             new Foo().ok",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_new_target_flows_through_super_call() {
        let result = global_eval(
            "class Base { constructor() { this.nt = new.target; } } \
             class Child extends Base {} \
             new Child().nt === Child",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_class_new_target_undefined_in_static_method_call() {
        let result =
            global_eval("class Foo { static check() { return typeof new.target; } } Foo.check()")
                .unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_class_expression_name_not_visible_outside() {
        let result = global_eval("var Foo = class Bar {}; typeof Bar").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_class_expression_value_is_assigned_to_outer_binding() {
        let result = global_eval("var Foo = class Bar {}; typeof Foo").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    // ── String ↔ RegExp delegation tests ────────────────────────────────────

    /// Helper: build a RegExp `JsValue` via `regexp_construct`.
    #[inline(never)]
    fn make_re(pattern: &str, flags: &str) -> JsValue {
        regexp_construct(&[
            JsValue::String(pattern.into()),
            JsValue::String(flags.into()),
        ])
        .unwrap()
    }

    /// Helper: build a `String` proto object via `install_globals` and extract it.
    fn string_proto() -> Rc<RefCell<PropertyMap>> {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        if let Some(JsValue::PlainObject(string_ctor)) = globals.get("String") {
            if let Some(JsValue::PlainObject(proto)) = string_ctor.borrow().get("prototype") {
                return Rc::clone(proto);
            }
        }
        panic!("String.prototype not found");
    }

    /// Helper: call a String.prototype method (first arg = this string).
    fn call_string_method(
        proto: &Rc<RefCell<PropertyMap>>,
        method: &str,
        args: Vec<JsValue>,
    ) -> StatorResult<JsValue> {
        if let Some(JsValue::NativeFunction(f)) = proto.borrow().get(method).cloned() {
            f(args)
        } else {
            panic!("String.prototype.{method} not found");
        }
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_string_match_delegates_to_regexp() {
        let proto = string_proto();
        let re = make_re(r"(\d+)", "");
        let result = call_string_method(
            &proto,
            "match",
            vec![JsValue::String("price 42 dollars".into()), re],
        )
        .unwrap();
        // Should delegate to @@match → exec-like result with "0" = "42"
        if let JsValue::PlainObject(map) = &result {
            assert_eq!(map.borrow().get("0"), Some(&JsValue::String("42".into())));
            assert_eq!(map.borrow().get("index"), Some(&JsValue::Smi(6)));
        } else {
            panic!("expected PlainObject match result, got {result:?}");
        }
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_string_search_delegates_to_regexp() {
        let proto = string_proto();
        let re = make_re(r"\d+", "");
        let result =
            call_string_method(&proto, "search", vec![JsValue::String("abc 42".into()), re])
                .unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_string_replace_delegates_to_regexp() {
        let proto = string_proto();
        let re = make_re(r"\d+", "g");
        let result = call_string_method(
            &proto,
            "replace",
            vec![
                JsValue::String("a1 b2 c3".into()),
                re,
                JsValue::String("X".into()),
            ],
        )
        .unwrap();
        assert_eq!(result, JsValue::String("aX bX cX".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_string_split_delegates_to_regexp() {
        let proto = string_proto();
        let re = make_re(r"\s+", "");
        let result =
            call_string_method(&proto, "split", vec![JsValue::String("a  b  c".into()), re])
                .unwrap();
        if let JsValue::Array(arr) = &result {
            let arr = arr.borrow();
            assert_eq!(arr.len(), 3);
            assert_eq!(arr[0], JsValue::String("a".into()));
            assert_eq!(arr[1], JsValue::String("b".into()));
            assert_eq!(arr[2], JsValue::String("c".into()));
        } else {
            panic!("expected Array, got {result:?}");
        }
    }

    #[test]
    fn test_string_replace_all_regexp_non_global_throws() {
        let proto = string_proto();
        let re = make_re(r"\d+", ""); // no 'g' flag
        let result = call_string_method(
            &proto,
            "replaceAll",
            vec![
                JsValue::String("a1 b2".into()),
                re,
                JsValue::String("X".into()),
            ],
        );
        assert!(
            result.is_err(),
            "replaceAll with non-global regexp should error"
        );
    }

    #[test]
    fn test_string_replace_all_regexp_global_delegates() {
        let proto = string_proto();
        let re = make_re(r"\d+", "g");
        let result = call_string_method(
            &proto,
            "replaceAll",
            vec![
                JsValue::String("a1 b2 c3".into()),
                re,
                JsValue::String("X".into()),
            ],
        )
        .unwrap();
        assert_eq!(result, JsValue::String("aX bX cX".into()));
    }

    // ── trimLeft / trimRight aliases ─────────────────────────────────────

    /// `trimLeft` is a legacy alias for `trimStart`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_string_trim_left_alias() {
        let proto = string_proto();
        let result = call_string_method(
            &proto,
            "trimLeft",
            vec![JsValue::String("  hello  ".into())],
        )
        .unwrap();
        assert_eq!(result, JsValue::String("hello  ".into()));
    }

    /// `trimRight` is a legacy alias for `trimEnd`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_string_trim_right_alias() {
        let proto = string_proto();
        let result = call_string_method(
            &proto,
            "trimRight",
            vec![JsValue::String("  hello  ".into())],
        )
        .unwrap();
        assert_eq!(result, JsValue::String("  hello".into()));
    }

    // ── Array static methods e2e tests ──────────────────────────────────

    /// `Array.from` converts a string into an array of characters.
    #[test]
    fn e2e_array_from_string_length() {
        let result = global_eval("Array.from('abc').length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Array.from` with a string produces correct first element.
    #[test]
    fn e2e_array_from_string_elem() {
        let result = global_eval("Array.from('abc')[0]").unwrap();
        assert_eq!(result, JsValue::String("a".into()));
    }

    /// `Array.from` with a mapping function.
    #[test]
    fn e2e_array_from_map_fn() {
        let result = global_eval("Array.from([1,2,3], function(x){ return x * 2 })[1]").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `Array.of` creates an array from arguments.
    #[test]
    fn e2e_array_of_length() {
        let result = global_eval("Array.of(10, 20, 30).length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Array.of` preserves argument values.
    #[test]
    fn e2e_array_of_elem() {
        let result = global_eval("Array.of(10, 20, 30)[2]").unwrap();
        assert_eq!(result, JsValue::Smi(30));
    }

    /// `Array.of` with a single argument.
    #[test]
    fn e2e_array_of_single() {
        let result = global_eval("Array.of(7)[0]").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    // ── String static methods e2e tests ─────────────────────────────────

    /// `String.fromCharCode` converts char codes to a string.
    #[test]
    fn e2e_string_from_char_code() {
        let result = global_eval("String.fromCharCode(72, 101, 108)").unwrap();
        assert_eq!(result, JsValue::String("Hel".into()));
    }

    /// `String.fromCharCode` with a single code.
    #[test]
    fn e2e_string_from_char_code_single() {
        let result = global_eval("String.fromCharCode(65)").unwrap();
        assert_eq!(result, JsValue::String("A".into()));
    }

    /// `String.fromCodePoint` converts Unicode code points.
    #[test]
    fn e2e_string_from_code_point() {
        let result = global_eval("String.fromCodePoint(9731)").unwrap();
        assert_eq!(result, JsValue::String("\u{2603}".into()));
    }

    /// `String.fromCodePoint` with multiple code points.
    #[test]
    fn e2e_string_from_code_point_multi() {
        let result = global_eval("String.fromCodePoint(65, 66, 67)").unwrap();
        assert_eq!(result, JsValue::String("ABC".into()));
    }

    /// `String.raw` is a function.
    #[test]
    fn e2e_string_raw_is_function() {
        let result = global_eval("typeof String.raw").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    // ── Number static methods e2e tests ─────────────────────────────────

    /// `Number.isNaN` returns true for NaN.
    #[test]
    fn e2e_number_is_nan_true_val() {
        let result = global_eval("Number.isNaN(NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.isNaN` returns false for a number.
    #[test]
    fn e2e_number_is_nan_false_val() {
        let result = global_eval("Number.isNaN(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isNaN` returns false for a string (unlike global isNaN).
    #[test]
    fn e2e_number_is_nan_string() {
        let result = global_eval("Number.isNaN('hello')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isFinite` returns true for finite numbers.
    #[test]
    fn e2e_number_is_finite_true_val() {
        let result = global_eval("Number.isFinite(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.isFinite` returns false for Infinity.
    #[test]
    fn e2e_number_is_finite_infinity() {
        let result = global_eval("Number.isFinite(Infinity)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isFinite` returns false for NaN.
    #[test]
    fn e2e_number_is_finite_nan() {
        let result = global_eval("Number.isFinite(NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isSafeInteger` returns true for safe integers.
    #[test]
    fn e2e_number_is_safe_integer_true_val() {
        let result = global_eval("Number.isSafeInteger(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.isSafeInteger` returns false for floats.
    #[test]
    fn e2e_number_is_safe_integer_float() {
        let result = global_eval("Number.isSafeInteger(1.5)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.parseInt` parses a decimal string.
    #[test]
    fn e2e_number_parse_int_basic() {
        let result = global_eval("Number.parseInt('42')").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Number.parseInt` with radix.
    #[test]
    fn e2e_number_parse_int_radix() {
        let result = global_eval("Number.parseInt('ff', 16)").unwrap();
        assert_eq!(result, JsValue::Smi(255));
    }

    /// `Number.parseFloat` parses a decimal string.
    #[test]
    fn e2e_number_parse_float_basic() {
        let result = global_eval("Number.parseFloat('3.14')").unwrap();
        assert_eq!(result, JsValue::HeapNumber(3.14));
    }

    // ── Number constants e2e tests ──────────────────────────────────────

    /// `Number.EPSILON` is a very small positive number.
    #[test]
    fn e2e_number_epsilon() {
        let result = global_eval("Number.EPSILON < 1 && Number.EPSILON > 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.MAX_SAFE_INTEGER` is 2^53 - 1.
    #[test]
    fn e2e_number_max_safe_integer() {
        let result = global_eval("Number.MAX_SAFE_INTEGER === 9007199254740991").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.MIN_SAFE_INTEGER` is -(2^53 - 1).
    #[test]
    fn e2e_number_min_safe_integer() {
        let result = global_eval("Number.MIN_SAFE_INTEGER === -9007199254740991").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.MAX_VALUE` is a large positive number.
    #[test]
    fn e2e_number_max_value() {
        let result = global_eval("Number.MAX_VALUE > 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.MIN_VALUE` is a small positive number.
    #[test]
    fn e2e_number_min_value() {
        let result = global_eval("Number.MIN_VALUE > 0 && Number.MIN_VALUE < 1").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.POSITIVE_INFINITY` equals Infinity.
    #[test]
    fn e2e_number_positive_infinity() {
        let result = global_eval("Number.POSITIVE_INFINITY === Infinity").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.NEGATIVE_INFINITY` equals -Infinity.
    #[test]
    fn e2e_number_negative_infinity() {
        let result = global_eval("Number.NEGATIVE_INFINITY === -Infinity").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.NaN` is NaN.
    #[test]
    fn e2e_number_nan_constant() {
        let result = global_eval("Number.isNaN(Number.NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Object.fromEntries e2e tests ────────────────────────────────────

    /// `Object.fromEntries` builds an object from key-value pairs.
    #[test]
    fn e2e_object_from_entries_basic() {
        let result =
            global_eval("var o = Object.fromEntries([['a',1],['b',2]]); o.a + o.b").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.fromEntries` with string values.
    #[test]
    fn e2e_object_from_entries_strings() {
        let result = global_eval("var o = Object.fromEntries([['x','hello']]); o.x").unwrap();
        assert_eq!(result, JsValue::String("hello".into()));
    }

    // ── Math method e2e tests ───────────────────────────────────────────

    /// `Math.cbrt` computes the cube root.
    #[test]
    fn e2e_math_cbrt_integer() {
        let result = global_eval("Math.cbrt(27)").unwrap();
        match result {
            JsValue::Smi(3) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 3, got {other:?}"),
        }
    }

    /// `Math.cbrt` with a negative value.
    #[test]
    fn e2e_math_cbrt_negative() {
        let result = global_eval("Math.cbrt(-8)").unwrap();
        match result {
            JsValue::Smi(-2) | JsValue::HeapNumber(_) => {}
            other => panic!("expected -2, got {other:?}"),
        }
    }

    /// `Math.log2` computes the base-2 logarithm.
    #[test]
    fn e2e_math_log2_power_of_2() {
        let result = global_eval("Math.log2(8)").unwrap();
        match result {
            JsValue::Smi(3) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 3, got {other:?}"),
        }
    }

    /// `Math.log2(1)` is 0.
    #[test]
    fn e2e_math_log2_one() {
        let result = global_eval("Math.log2(1)").unwrap();
        match result {
            JsValue::Smi(0) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 0, got {other:?}"),
        }
    }

    /// `Math.log10` computes the base-10 logarithm.
    #[test]
    fn e2e_math_log10_hundred() {
        let result = global_eval("Math.log10(100)").unwrap();
        match result {
            JsValue::Smi(2) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 2, got {other:?}"),
        }
    }

    /// `Math.log10(1)` is 0.
    #[test]
    fn e2e_math_log10_one() {
        let result = global_eval("Math.log10(1)").unwrap();
        match result {
            JsValue::Smi(0) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 0, got {other:?}"),
        }
    }

    /// `Math.fround` rounds to nearest float32.
    #[test]
    fn e2e_math_fround_integer() {
        let result = global_eval("Math.fround(1)").unwrap();
        match result {
            JsValue::Smi(1) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 1, got {other:?}"),
        }
    }

    /// `Math.clz32` counts leading zeros.
    #[test]
    fn e2e_math_clz32_one() {
        let result = global_eval("Math.clz32(1)").unwrap();
        assert_eq!(result, JsValue::Smi(31));
    }

    /// `Math.clz32(0)` returns 32.
    #[test]
    fn e2e_math_clz32_zero() {
        let result = global_eval("Math.clz32(0)").unwrap();
        assert_eq!(result, JsValue::Smi(32));
    }

    /// `Math.imul` performs 32-bit integer multiplication.
    #[test]
    fn e2e_math_imul_basic() {
        let result = global_eval("Math.imul(3, 4)").unwrap();
        assert_eq!(result, JsValue::Smi(12));
    }

    /// `Math.imul` with large values wraps around.
    #[test]
    fn e2e_math_imul_large() {
        let result = global_eval("Math.imul(0xffffffff, 5)").unwrap();
        assert_eq!(result, JsValue::Smi(-5));
    }

    /// `Math.hypot` computes the Euclidean distance.
    #[test]
    fn e2e_math_hypot_3_4() {
        let result = global_eval("Math.hypot(3, 4)").unwrap();
        match result {
            JsValue::Smi(5) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 5, got {other:?}"),
        }
    }

    /// `Math.hypot` with zero arguments returns 0.
    #[test]
    fn e2e_math_hypot_no_args() {
        let result = global_eval("Math.hypot()").unwrap();
        match result {
            JsValue::Smi(0) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 0, got {other:?}"),
        }
    }

    /// `Math.trunc` removes the fractional part (positive).
    #[test]
    fn e2e_math_trunc_positive_frac() {
        let result = global_eval("Math.trunc(3.7)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Math.trunc` removes the fractional part (negative).
    #[test]
    fn e2e_math_trunc_negative_frac() {
        let result = global_eval("Math.trunc(-3.7)").unwrap();
        assert_eq!(result, JsValue::Smi(-3));
    }

    /// `Math.sign` returns 1 for positive.
    #[test]
    fn e2e_math_sign_pos() {
        let result = global_eval("Math.sign(42)").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Math.sign` returns -1 for negative.
    #[test]
    fn e2e_math_sign_neg() {
        let result = global_eval("Math.sign(-42)").unwrap();
        assert_eq!(result, JsValue::Smi(-1));
    }

    /// `Math.sign` returns 0 for zero.
    #[test]
    fn e2e_math_sign_zero_val() {
        let result = global_eval("Math.sign(0)").unwrap();
        match result {
            JsValue::Smi(0) | JsValue::HeapNumber(_) => {}
            other => panic!("expected 0, got {other:?}"),
        }
    }

    // —— Array.prototype.with e2e tests ——————————————

    #[test]
    fn e2e_array_with_basic() {
        let result = global_eval("[1, 2, 3].with(1, 99)[1]").unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    #[test]
    fn e2e_array_with_negative_index() {
        let result = global_eval("[1, 2, 3].with(-1, 99)[2]").unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    #[test]
    fn e2e_array_with_preserves_other_elements() {
        let result = global_eval("[1, 2, 3].with(0, 99)[1]").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_array_with_returns_new_array() {
        let result = global_eval("var a = [1,2,3]; var b = a.with(0, 99); a[0]").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    // —— Number.isInteger e2e tests ——————————————

    #[test]
    fn e2e_number_is_integer_true() {
        let result = global_eval("Number.isInteger(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_number_is_integer_float() {
        let result = global_eval("Number.isInteger(1.5)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_number_is_integer_nan() {
        let result = global_eval("Number.isInteger(NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // —— Object.is e2e tests ——————————————

    #[test]
    fn e2e_object_is_nan() {
        let result = global_eval("Object.is(NaN, NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_object_is_zero() {
        let result = global_eval("Object.is(0, -0)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_object_is_same() {
        let result = global_eval("Object.is(42, 42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // —— WeakSet e2e tests ——————————————————————————

    #[test]
    fn e2e_weak_set_has() {
        let result = crate::builtins::global::global_eval(
            "var s = new WeakSet(); var o = {}; s.add(o); s.has(o)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weak_set_delete() {
        let result = crate::builtins::global::global_eval(
            "var s = new WeakSet(); var o = {}; s.add(o); s.delete(o)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weak_set_not_has_after_delete() {
        let result = crate::builtins::global::global_eval(
            "var s = new WeakSet(); var o = {}; s.add(o); s.delete(o); s.has(o)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_set_returns_this() {
        let result =
            crate::builtins::global::global_eval("var m = new Map(); m.set('a', 1) === m").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_set_chaining() {
        let result = crate::builtins::global::global_eval(
            "var m = new Map(); m.set('a', 1).set('b', 2); m.get('b')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_add_returns_this() {
        let result =
            crate::builtins::global::global_eval("var s = new Set(); s.add(1) === s").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_add_chaining() {
        let result = crate::builtins::global::global_eval(
            "var s = new Set(); s.add(1).add(2).add(3); s.has(3)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_set_returns_this() {
        let result = crate::builtins::global::global_eval(
            "var wm = new WeakMap(); var k = {}; wm.set(k, 1) === wm",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_add_returns_this() {
        let result = crate::builtins::global::global_eval(
            "var ws = new WeakSet(); var o = {}; ws.add(o) === ws",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Object.assign e2e tests ─────────────────────────────────────────

    /// `Object.assign` copies properties from source to target.
    #[test]
    fn e2e_object_assign() {
        let result = global_eval("var a = {x:1}; Object.assign(a, {y:2}); a.y").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Object.assign` merges multiple sources.
    #[test]
    fn e2e_object_assign_multiple_sources() {
        let result = global_eval("var a = {}; Object.assign(a, {x:1}, {y:2}); a.x + a.y").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.assign` returns the target object.
    #[test]
    fn e2e_object_assign_returns_target() {
        let result = global_eval("var a = {x:1}; Object.assign(a, {y:2}) === a").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Array.prototype.flat e2e tests ──────────────────────────────────

    /// `Array.prototype.flat` exists and is callable.
    #[test]
    fn e2e_array_flat_exists() {
        let result = global_eval("typeof [].flat").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    // ── Array.prototype.flatMap e2e tests ───────────────────────────────

    /// `Array.prototype.flatMap` exists and is callable.
    #[test]
    fn e2e_array_flatmap_exists() {
        let result = global_eval("typeof [].flatMap").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `Array.prototype.flat` flattens one level by default.
    #[test]
    fn e2e_flat_basic() {
        let result = crate::builtins::global::global_eval("[1,[2,3]].flat().length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Array.prototype.flat` with explicit depth 2.
    #[test]
    fn e2e_flat_depth_2() {
        let result = crate::builtins::global::global_eval("[1,[2,[3]]].flat(2).length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Array.prototype.flatMap` maps and flattens one level.
    #[test]
    fn e2e_flatmap_basic() {
        let result = crate::builtins::global::global_eval(
            "[1,2,3].flatMap(function(x) { return [x, x*2]; }).length",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    // ── Array.prototype.at e2e tests ────────────────────────────────────

    /// `Array.prototype.at` with positive index.
    #[test]
    fn e2e_array_at_positive() {
        let result = global_eval("[10,20,30].at(0)").unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    /// `Array.prototype.at` with negative index.
    #[test]
    fn e2e_array_at_negative() {
        let result = global_eval("[10,20,30].at(-1)").unwrap();
        assert_eq!(result, JsValue::Smi(30));
    }

    /// `Array.prototype.at` out of range returns undefined.
    #[test]
    fn e2e_array_at_out_of_range() {
        let result = global_eval("[10,20,30].at(5)").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    // ── String.prototype.at e2e tests ───────────────────────────────────

    /// `String.prototype.at` with positive index.
    #[test]
    fn e2e_string_at_positive() {
        let result = global_eval("'hello'.at(0)").unwrap();
        assert_eq!(result, JsValue::String("h".into()));
    }

    /// `String.prototype.at` with negative index.
    #[test]
    fn e2e_string_at_negative() {
        let result = global_eval("'hello'.at(-1)").unwrap();
        assert_eq!(result, JsValue::String("o".into()));
    }

    /// `String.prototype.at` out of range returns undefined.
    #[test]
    fn e2e_string_at_out_of_range() {
        let result = global_eval("'hello'.at(10)").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    // ── String.raw e2e tests ────────────────────────────────────────────

    /// `String.raw` exists on the String constructor.
    #[test]
    fn e2e_string_raw_exists() {
        let result = global_eval("typeof String.raw").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    // ── Object.fromEntries e2e tests (additional) ───────────────────────

    /// `Object.fromEntries` with empty array returns empty object.
    #[test]
    fn e2e_object_from_entries_empty() {
        let result = global_eval("Object.keys(Object.fromEntries([])).length").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    // ── Additional Object builtin e2e tests ─────────────────────────────

    /// `Object.getOwnPropertyNames` returns correct count for a two-property object.
    #[test]
    fn e2e_object_get_own_property_names_length() {
        let result = global_eval("Object.getOwnPropertyNames({a: 1, b: 2}).length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Object.getPrototypeOf` returns `Object.prototype` for plain objects.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_get_prototype_of() {
        let result = global_eval("Object.getPrototypeOf({}) === Object.prototype").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.defineProperty` with full descriptor sets the value.
    #[test]
    fn e2e_object_define_property() {
        let result = global_eval(
            "var o = {}; Object.defineProperty(o, 'x', { value: 42, writable: false, enumerable: true, configurable: false }); o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.defineProperty` with writable:false prevents writes in strict mode.
    #[test]
    fn e2e_object_define_property_non_writable() {
        // defineProperty with writable:false should prevent writes — verify the
        // property keeps its original value after an attempted write (sloppy mode).
        let result = global_eval(
            "var o = {}; Object.defineProperty(o, 'x', { value: 42, writable: false }); o.x = 99; o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.getOwnPropertyDescriptor` returns the value field.
    #[test]
    fn e2e_object_get_own_property_descriptor() {
        let result =
            global_eval("var d = Object.getOwnPropertyDescriptor({x: 1}, 'x'); d.value").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    // ── String.raw fix tests ────────────────────────────────────────────

    /// `String.raw` with a plain-object `raw` array returns the correctly
    /// interleaved string.
    #[test]
    fn e2e_string_raw_plain_object() {
        let result = global_eval("String.raw({ raw: ['a', 'b', 'c'] }, 1, 2)").unwrap();
        assert_eq!(result, JsValue::String("a1b2c".into()));
    }

    /// `String.raw` with no substitutions returns raw strings concatenated.
    #[test]
    fn e2e_string_raw_no_subs() {
        let result = global_eval("String.raw({ raw: ['hello', ' ', 'world'] })").unwrap();
        assert_eq!(result, JsValue::String("hello world".into()));
    }

    /// `String.raw` with more substitutions than gaps ignores extras.
    #[test]
    fn e2e_string_raw_extra_subs() {
        let result = global_eval("String.raw({ raw: ['a', 'b'] }, 1, 2, 3)").unwrap();
        assert_eq!(result, JsValue::String("a1b".into()));
    }

    // ── toReversed tests ────────────────────────────────────────────────

    /// `Array.prototype.toReversed` returns a new reversed array.
    #[test]
    fn e2e_to_reversed_basic() {
        let result = global_eval("[1,2,3].toReversed().join(',')").unwrap();
        assert_eq!(result, JsValue::String("3,2,1".into()));
    }

    /// `toReversed` does not mutate the original array.
    #[test]
    fn e2e_to_reversed_no_mutate() {
        let result = global_eval("var a = [1,2,3]; a.toReversed(); a.join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    // ── toSorted tests ──────────────────────────────────────────────────

    /// `Array.prototype.toSorted` returns a new sorted array (default).
    #[test]
    fn e2e_to_sorted_default() {
        let result = global_eval("[3,1,2].toSorted().join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    /// `toSorted` with a comparator function sorts numerically.
    #[test]
    fn e2e_to_sorted_comparator() {
        let result =
            global_eval("[10,1,21,2].toSorted(function(a,b){ return a - b }).join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,10,21".into()));
    }

    /// `toSorted` does not mutate the original array.
    #[test]
    fn e2e_to_sorted_no_mutate() {
        let result = global_eval("var a = [3,1,2]; a.toSorted(); a.join(',')").unwrap();
        assert_eq!(result, JsValue::String("3,1,2".into()));
    }

    // ── toSpliced tests ─────────────────────────────────────────────────

    /// `toSpliced` removes elements and returns a new array.
    #[test]
    fn e2e_to_spliced_delete() {
        let result = global_eval("[1,2,3,4,5].toSpliced(1, 2).join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,4,5".into()));
    }

    /// `toSpliced` inserts elements and returns a new array.
    #[test]
    fn e2e_to_spliced_insert() {
        let result = global_eval("[1,2,5].toSpliced(2, 0, 3, 4).join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3,4,5".into()));
    }

    /// `toSpliced` does not mutate the original array.
    #[test]
    fn e2e_to_spliced_no_mutate() {
        let result = global_eval("var a = [1,2,3]; a.toSpliced(0, 1); a.join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    // ── findLast / findLastIndex tests ──────────────────────────────────

    /// `findLast` returns the last element matching the predicate.
    #[test]
    fn e2e_find_last_basic() {
        let result = global_eval("[1,2,3,4].findLast(function(x){ return x % 2 === 0 })").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `findLast` returns undefined when nothing matches.
    #[test]
    fn e2e_find_last_none() {
        let result = global_eval("[1,3,5].findLast(function(x){ return x % 2 === 0 })").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `findLastIndex` returns the index of the last matching element.
    #[test]
    fn e2e_find_last_index_basic() {
        let result =
            global_eval("[1,2,3,4].findLastIndex(function(x){ return x % 2 === 0 })").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `findLastIndex` returns -1 when nothing matches.
    #[test]
    fn e2e_find_last_index_none() {
        let result =
            global_eval("[1,3,5].findLastIndex(function(x){ return x % 2 === 0 })").unwrap();
        assert_eq!(result, JsValue::Smi(-1));
    }

    // ── Object.hasOwn tests ─────────────────────────────────────────────

    /// `Object.hasOwn` returns true for own properties (with value check).
    #[test]
    fn e2e_object_has_own_present() {
        let result = global_eval("Object.hasOwn({a: 1}, 'a')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.hasOwn` returns false for missing properties (inherited).
    #[test]
    fn e2e_object_has_own_inherited() {
        let result = global_eval("Object.hasOwn({a: 1}, 'b')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Object.fromEntries tests ────────────────────────────────────────

    /// `Object.fromEntries` builds an object from key-value pairs (sum check).
    #[test]
    fn e2e_object_from_entries_sum() {
        let result =
            global_eval("var o = Object.fromEntries([['a', 1], ['b', 2]]); o.a + o.b").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── TypeError / RangeError / SyntaxError throw tests ─────────────────

    /// `new Array(-1)` must throw RangeError (§23.1.1.1).
    #[test]
    fn e2e_array_constructor_negative_length() {
        let result = global_eval("new Array(-1)");
        assert!(
            result.is_err(),
            "Expected RangeError for negative array length"
        );
    }

    /// `new Array(1.5)` must throw RangeError (§23.1.1.1).
    #[test]
    fn e2e_array_constructor_fractional_length() {
        let result = global_eval("new Array(1.5)");
        assert!(
            result.is_err(),
            "Expected RangeError for fractional array length"
        );
    }

    /// `new Array(NaN)` must throw RangeError (§23.1.1.1).
    #[test]
    fn e2e_array_constructor_nan_length() {
        let result = global_eval("new Array(NaN)");
        assert!(result.is_err(), "Expected RangeError for NaN array length");
    }

    /// `new Array(Infinity)` must throw RangeError (§23.1.1.1).
    #[test]
    fn e2e_array_constructor_infinity_length() {
        let result = global_eval("new Array(Infinity)");
        assert!(
            result.is_err(),
            "Expected RangeError for Infinity array length"
        );
    }

    /// `new Array(0)` is valid and produces an empty array.
    #[test]
    fn e2e_array_constructor_zero_length() {
        let result = global_eval("new Array(0).length").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `new Array(5)` produces a 5-element array.
    #[test]
    fn e2e_array_constructor_positive_length() {
        let result = global_eval("new Array(5).length").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// `Object.defineProperty` on a frozen object must throw TypeError.
    #[test]
    fn e2e_object_define_property_frozen_throws() {
        let result =
            global_eval("var o = Object.freeze({}); Object.defineProperty(o, 'x', { value: 1 })");
        assert!(
            result.is_err(),
            "Expected TypeError for defineProperty on frozen object"
        );
    }

    /// `Object.setPrototypeOf` on a non-extensible object must throw TypeError
    /// when the prototype would change.
    #[test]
    fn e2e_object_set_prototype_of_non_extensible_throws() {
        let result =
            global_eval("var o = Object.preventExtensions({}); Object.setPrototypeOf(o, { x: 1 })");
        assert!(
            result.is_err(),
            "Expected TypeError for setPrototypeOf on non-extensible object"
        );
    }

    /// `String.prototype.charAt.call(null)` must throw TypeError (§22.1.3).
    #[test]
    fn e2e_string_char_at_on_null_throws() {
        let result = global_eval("String.prototype.charAt.call(null, 0)");
        assert!(result.is_err(), "Expected TypeError for charAt on null");
    }

    /// `String.prototype.indexOf.call(undefined)` must throw TypeError (§22.1.3).
    #[test]
    fn e2e_string_index_of_on_undefined_throws() {
        let result = global_eval("String.prototype.indexOf.call(undefined, 'a')");
        assert!(
            result.is_err(),
            "Expected TypeError for indexOf on undefined"
        );
    }

    /// `Array.prototype.push.call(null)` must throw TypeError.
    #[test]
    fn e2e_array_push_on_null_throws() {
        let result = global_eval("Array.prototype.push.call(null, 1)");
        assert!(result.is_err(), "Expected TypeError for push on null");
    }

    /// `Array.prototype.forEach.call(undefined, function(){})` must throw TypeError.
    #[test]
    fn e2e_array_for_each_on_undefined_throws() {
        let result = global_eval("Array.prototype.forEach.call(undefined, function(){})");
        assert!(
            result.is_err(),
            "Expected TypeError for forEach on undefined"
        );
    }

    /// `new RegExp('.', 'xyz')` must throw SyntaxError for invalid flags.
    #[test]
    fn e2e_regexp_invalid_flags_throws() {
        let result = global_eval("new RegExp('.', 'xyz')");
        assert!(
            result.is_err(),
            "Expected SyntaxError for invalid RegExp flags"
        );
    }

    /// `new RegExp('.', 'gg')` must throw SyntaxError for duplicate flags.
    #[test]
    fn e2e_regexp_duplicate_flags_throws() {
        let result = global_eval("new RegExp('.', 'gg')");
        assert!(
            result.is_err(),
            "Expected SyntaxError for duplicate RegExp flags"
        );
    }

    // ── RegExp named captures & matchAll e2e tests ──────────────────────

    /// `exec` with named groups returns a `groups` object.
    #[test]
    fn e2e_regexp_exec_named_groups() {
        let r = global_eval(
            r#"
            var m = /(?<year>\d{4})-(?<month>\d{2})/.exec("2024-07");
            m.groups.year + "-" + m.groups.month
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2024-07".into()));
    }

    /// Named groups object has null prototype (no inherited properties).
    #[test]
    fn e2e_regexp_groups_null_prototype() {
        let r = global_eval(
            r#"
            var m = /(?<a>.)/.exec("x");
            Object.getPrototypeOf(m.groups) === null
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Non-participating named group is `undefined`.
    #[test]
    fn e2e_regexp_groups_undefined_non_participating() {
        let r = global_eval(
            r#"
            var m = /(?<a>a)|(?<b>b)/.exec("a");
            m.groups.a === "a" && m.groups.b === undefined
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `exec` result includes `index` and `input`.
    #[test]
    fn e2e_regexp_exec_index_input() {
        let r = global_eval(
            r#"
            var m = /world/.exec("hello world");
            m.index === 6 && m.input === "hello world"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Without named groups, `groups` is `undefined`.
    #[test]
    fn e2e_regexp_exec_no_groups_undefined() {
        let r = global_eval(
            r#"
            var m = /\d+/.exec("42");
            m.groups === undefined
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `String.prototype.matchAll` with a global regexp returns an iterator.
    #[test]
    fn e2e_string_match_all_global_regexp() {
        let r = global_eval(
            r#"
            var results = [];
            for (var m of "a1 b22 c333".matchAll(/\d+/g)) {
                results.push(m[0]);
            }
            results.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,22,333".into()));
    }

    /// `matchAll` results include `index` per match.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_string_match_all_index() {
        let r = global_eval(
            r#"
            var arr = Array.from("ab cd".matchAll(/\w+/g));
            arr[0].index === 0 && arr[1].index === 3
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `matchAll` results include named groups.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_string_match_all_named_groups() {
        let r = global_eval(
            r#"
            var arr = Array.from("2024-07 2025-01".matchAll(/(?<y>\d{4})-(?<m>\d{2})/g));
            arr[0].groups.y + "," + arr[1].groups.y
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2024,2025".into()));
    }

    /// `matchAll` with a non-global RegExp throws TypeError.
    #[test]
    fn e2e_string_match_all_non_global_throws() {
        let r = global_eval(
            r#"
            try { "abc".matchAll(/a/); "no error"; } catch(e) { e instanceof TypeError ? "ok" : "wrong"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// `matchAll` with a string pattern (non-regexp) works.
    #[test]
    fn e2e_string_match_all_string_pattern() {
        let r = global_eval(
            r#"
            var results = [];
            for (var m of "aXaXa".matchAll("a")) {
                results.push(m.index);
            }
            results.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0,2,4".into()));
    }

    /// `matchAll` string pattern results include `input`.
    #[test]
    fn e2e_string_match_all_string_pattern_input() {
        let r = global_eval(
            r#"
            var arr = Array.from("hello".matchAll("l"));
            arr[0].input === "hello" && arr[1].input === "hello"
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `matchAll` with no matches returns an empty iterator.
    #[test]
    fn e2e_string_match_all_no_matches() {
        let r = global_eval(
            r#"
            Array.from("abc".matchAll(/\d+/g)).length === 0
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `RegExp.prototype[Symbol.matchAll]` is callable directly.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_symbol_match_all_direct() {
        let r = global_eval(
            r#"
            var re = /\d+/g;
            var results = [];
            for (var m of re[Symbol.matchAll]("x1y22z")) {
                results.push(m[0]);
            }
            results.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,22".into()));
    }

    /// Named group `$<name>` replacement works with `replace`.
    #[test]
    fn e2e_regexp_replace_named_group() {
        let r = global_eval(
            r#"
            "2024-07".replace(/(?<y>\d{4})-(?<m>\d{2})/, "$<m>/$<y>")
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("07/2024".into()));
    }

    // ── Array.prototype.toString e2e tests ──────────────────────────────

    /// `Array.prototype.toString` returns comma-separated elements.
    #[test]
    fn e2e_array_to_string_basic() {
        let result = global_eval("[1, 2, 3].toString()").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    /// `Array.prototype.toString` on an empty array returns "".
    #[test]
    fn e2e_array_to_string_empty() {
        let result = global_eval("[].toString()").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    /// `Array.prototype.toString` treats null/undefined as empty strings.
    #[test]
    fn e2e_array_to_string_with_holes() {
        let result = global_eval("[1, null, undefined, 4].toString()").unwrap();
        assert_eq!(result, JsValue::String("1,,,4".into()));
    }

    // ── Array.prototype.toLocaleString e2e tests ────────────────────────

    /// `Array.prototype.toLocaleString` returns comma-separated elements.
    #[test]
    fn e2e_array_to_locale_string_basic() {
        let result = global_eval("[1, 2, 3].toLocaleString()").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    /// `Array.prototype.toLocaleString` on an empty array returns "".
    #[test]
    fn e2e_array_to_locale_string_empty() {
        let result = global_eval("[].toLocaleString()").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    // ── btoa / atob e2e tests ───────────────────────────────────────────

    /// `btoa` encodes a simple ASCII string.
    #[test]
    fn e2e_btoa_basic() {
        let result = global_eval("btoa('Hello')").unwrap();
        assert_eq!(result, JsValue::String("SGVsbG8=".into()));
    }

    /// `atob` decodes a Base64 string back to the original.
    #[test]
    fn e2e_atob_basic() {
        let result = global_eval("atob('SGVsbG8=')").unwrap();
        assert_eq!(result, JsValue::String("Hello".into()));
    }

    /// `atob(btoa(x))` round-trips correctly.
    #[test]
    fn e2e_atob_btoa_roundtrip() {
        let result = global_eval("atob(btoa('test string'))").unwrap();
        assert_eq!(result, JsValue::String("test string".into()));
    }

    /// `btoa` with empty string returns empty string.
    #[test]
    fn e2e_btoa_empty() {
        let result = global_eval("btoa('')").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    /// `atob` with empty string returns empty string.
    #[test]
    fn e2e_atob_empty() {
        let result = global_eval("atob('')").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    // ── Number.prototype.toFixed tests ──────────────────────────────────

    /// `toFixed` with no arguments defaults to 0 digits.
    #[test]
    fn e2e_number_to_fixed_default() {
        let result = global_eval("(1.5).toFixed()").unwrap();
        assert_eq!(result, JsValue::String("2".into()));
    }

    /// `toFixed(2)` on a positive float.
    #[test]
    fn e2e_number_to_fixed_two_digits() {
        let result = global_eval("(3.14159).toFixed(2)").unwrap();
        assert_eq!(result, JsValue::String("3.14".into()));
    }

    /// `toFixed` on a negative number.
    #[test]
    fn e2e_number_to_fixed_negative() {
        let result = global_eval("(-1.5).toFixed(1)").unwrap();
        assert_eq!(result, JsValue::String("-1.5".into()));
    }

    /// `toFixed(0)` on an integer.
    #[test]
    fn e2e_number_to_fixed_integer() {
        let result = global_eval("(42).toFixed(0)").unwrap();
        assert_eq!(result, JsValue::String("42".into()));
    }

    /// `toFixed` throws RangeError for negative digits.
    #[test]
    fn e2e_number_to_fixed_range_error_negative() {
        let result = global_eval("(1).toFixed(-1)");
        assert!(result.is_err());
    }

    /// `toFixed` throws RangeError for digits > 100.
    #[test]
    fn e2e_number_to_fixed_range_error_high() {
        let result = global_eval("(1).toFixed(101)");
        assert!(result.is_err());
    }

    /// `toFixed` on NaN returns "NaN".
    #[test]
    fn e2e_number_to_fixed_nan() {
        let result = global_eval("Number.NaN.toFixed(2)").unwrap();
        assert_eq!(result, JsValue::String("NaN".into()));
    }

    /// `toFixed` on Infinity returns "Infinity".
    #[test]
    fn e2e_number_to_fixed_infinity() {
        let result = global_eval("Infinity.toFixed(2)").unwrap();
        assert_eq!(result, JsValue::String("Infinity".into()));
    }

    // ── String.prototype.repeat tests ───────────────────────────────────

    /// `repeat(3)` repeats the string.
    #[test]
    fn e2e_string_repeat_basic() {
        let result = global_eval("'abc'.repeat(3)").unwrap();
        assert_eq!(result, JsValue::String("abcabcabc".into()));
    }

    /// `repeat(0)` returns empty string.
    #[test]
    fn e2e_string_repeat_zero() {
        let result = global_eval("'x'.repeat(0)").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    /// `repeat` on empty string returns empty string.
    #[test]
    fn e2e_string_repeat_empty() {
        let result = global_eval("''.repeat(5)").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    /// `repeat` throws RangeError for negative count.
    #[test]
    fn e2e_string_repeat_negative() {
        let result = global_eval("'x'.repeat(-1)");
        assert!(result.is_err());
    }

    /// `repeat` throws RangeError for Infinity count.
    #[test]
    fn e2e_string_repeat_infinity() {
        let result = global_eval("'x'.repeat(Infinity)");
        assert!(result.is_err());
    }

    #[test]
    fn e2e_string_from_code_point_astral() {
        let result = global_eval("String.fromCodePoint(0x1F600)").unwrap();
        assert_eq!(result, JsValue::String("😀".into()));
    }

    #[test]
    fn e2e_string_from_code_point_mixed_planes() {
        let result = global_eval("String.fromCodePoint(0x41, 0x1F600, 0x42)").unwrap();
        assert_eq!(result, JsValue::String("A😀B".into()));
    }

    #[test]
    fn e2e_string_from_code_point_max_scalar() {
        let result = global_eval("String.fromCodePoint(0x10FFFF)").unwrap();
        assert_eq!(result, JsValue::String("\u{10FFFF}".into()));
    }

    #[test]
    fn e2e_string_from_code_point_rejects_surrogate() {
        assert!(global_eval("String.fromCodePoint(0xD800)").is_err());
    }

    #[test]
    fn e2e_string_from_code_point_rejects_fractional() {
        assert!(global_eval("String.fromCodePoint(65.5)").is_err());
    }

    #[test]
    fn e2e_string_from_code_point_rejects_infinity() {
        assert!(global_eval("String.fromCodePoint(Infinity)").is_err());
    }

    #[test]
    fn e2e_string_code_point_at_surrogate_pair_start() {
        let result = global_eval("'😀'.codePointAt(0)").unwrap();
        assert_eq!(result, JsValue::Smi(128512));
    }

    #[test]
    fn e2e_string_code_point_at_low_surrogate_index() {
        let result = global_eval("'😀'.codePointAt(1)").unwrap();
        assert_eq!(result, JsValue::Smi(56832));
    }

    #[test]
    fn e2e_string_code_point_at_fractional_index() {
        let result = global_eval("'😀'.codePointAt(0.9)").unwrap();
        assert_eq!(result, JsValue::Smi(128512));
    }

    #[test]
    fn e2e_string_code_point_at_infinity_is_undefined() {
        let result = global_eval("'😀'.codePointAt(Infinity) === undefined").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_string_iterator_for_of_uses_code_points() {
        let result =
            global_eval("var out = []; for (var ch of 'A😀B') out.push(ch); out.join('|')")
                .unwrap();
        assert_eq!(result, JsValue::String("A|😀|B".into()));
    }

    #[test]
    fn e2e_string_iterator_array_from_uses_code_points() {
        let result = global_eval("Array.from('😀').length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_string_iterator_next_preserves_astral_character() {
        let result = global_eval(
            "var iter = '😀x'[Symbol.iterator](); var a = iter.next(); var b = iter.next(); a.value + ':' + b.value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("😀:x".into()));
    }

    #[test]
    fn e2e_string_length_counts_utf16_code_units() {
        let result = global_eval("'😀'.length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_string_length_mixed_ascii_and_astral() {
        let result = global_eval("'A😀B'.length").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    #[test]
    fn e2e_string_length_descriptor_uses_code_units() {
        let result = global_eval("Object.getOwnPropertyDescriptor('😀', 'length').value").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_string_object_keys_use_code_units() {
        let result = global_eval("Object.keys('😀').length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_string_object_property_names_use_code_units() {
        let result = global_eval("Object.getOwnPropertyNames('😀').join(',')").unwrap();
        assert_eq!(result, JsValue::String("0,1,length".into()));
    }

    #[test]
    fn e2e_string_has_own_second_surrogate_index() {
        let result = global_eval("Object.hasOwn('😀', '1')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_string_for_in_uses_code_unit_indices() {
        let result =
            global_eval("var keys = []; for (var k in '😀') keys.push(k); keys.join(',')").unwrap();
        assert_eq!(result, JsValue::String("0,1".into()));
    }

    #[test]
    fn e2e_string_starts_with_position_uses_utf16_units() {
        let result = global_eval("'😀b'.startsWith('b', 2)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_string_starts_with_fractional_position_truncates() {
        let result = global_eval("'abc'.startsWith('b', 1.9)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_string_includes_position_uses_utf16_units() {
        let result = global_eval("'😀b'.includes('b', 2)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_string_includes_infinity_position_is_false() {
        let result = global_eval("'abc'.includes('c', Infinity)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_string_ends_with_end_position_uses_utf16_units() {
        let result = global_eval("'😀b'.endsWith('😀', 2)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_string_ends_with_fractional_end_position_truncates() {
        let result = global_eval("'abc'.endsWith('b', 2.9)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_string_repeat_fractional_count_truncates() {
        let result = global_eval("'ab'.repeat(2.9)").unwrap();
        assert_eq!(result, JsValue::String("abab".into()));
    }

    #[test]
    fn e2e_string_repeat_nan_count_is_empty() {
        let result = global_eval("'ab'.repeat(NaN)").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    #[test]
    fn e2e_string_repeat_null_count_is_empty() {
        let result = global_eval("'ab'.repeat(null)").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    #[test]
    fn e2e_string_pad_start_negative_target_is_noop() {
        let result = global_eval("'x'.padStart(-1, '0')").unwrap();
        assert_eq!(result, JsValue::String("x".into()));
    }

    #[test]
    fn e2e_string_pad_start_nan_target_is_noop() {
        let result = global_eval("'x'.padStart(NaN, '0')").unwrap();
        assert_eq!(result, JsValue::String("x".into()));
    }

    #[test]
    fn e2e_string_pad_start_infinity_throws() {
        assert!(global_eval("'x'.padStart(Infinity, '0')").is_err());
    }

    #[test]
    fn e2e_string_pad_start_utf16_target_uses_full_surrogate_pair() {
        let result = global_eval("'x'.padStart(3, '😀')").unwrap();
        assert_eq!(result, JsValue::String("😀x".into()));
    }

    #[test]
    fn e2e_string_pad_start_empty_fill_is_noop() {
        let result = global_eval("'x'.padStart(3, '')").unwrap();
        assert_eq!(result, JsValue::String("x".into()));
    }

    #[test]
    fn e2e_string_pad_start_fractional_target_truncates() {
        let result = global_eval("'x'.padStart(4.9, '0')").unwrap();
        assert_eq!(result, JsValue::String("000x".into()));
    }

    #[test]
    fn e2e_string_pad_end_infinity_throws() {
        assert!(global_eval("'x'.padEnd(Infinity, '0')").is_err());
    }

    #[test]
    fn e2e_string_pad_end_utf16_target_uses_full_surrogate_pair() {
        let result = global_eval("'x'.padEnd(3, '😀')").unwrap();
        assert_eq!(result, JsValue::String("x😀".into()));
    }

    #[test]
    fn e2e_string_pad_end_empty_fill_is_noop() {
        let result = global_eval("'x'.padEnd(3, '')").unwrap();
        assert_eq!(result, JsValue::String("x".into()));
    }

    #[test]
    fn e2e_string_pad_end_fractional_target_truncates() {
        let result = global_eval("'x'.padEnd(4.9, '0')").unwrap();
        assert_eq!(result, JsValue::String("x000".into()));
    }

    // ── String.prototype.padStart / padEnd tests ────────────────────────

    /// `padStart` pads from the left.
    #[test]
    fn e2e_string_pad_start_basic() {
        let result = global_eval("'5'.padStart(3, '0')").unwrap();
        assert_eq!(result, JsValue::String("005".into()));
    }

    /// `padStart` with default pad uses spaces.
    #[test]
    fn e2e_string_pad_start_default_pad() {
        let result = global_eval("'x'.padStart(3)").unwrap();
        assert_eq!(result, JsValue::String("  x".into()));
    }

    /// `padStart` returns original if already long enough.
    #[test]
    fn e2e_string_pad_start_no_pad_needed() {
        let result = global_eval("'hello'.padStart(3, '0')").unwrap();
        assert_eq!(result, JsValue::String("hello".into()));
    }

    /// `padEnd` pads from the right.
    #[test]
    fn e2e_string_pad_end_basic() {
        let result = global_eval("'abc'.padEnd(6)").unwrap();
        assert_eq!(result, JsValue::String("abc   ".into()));
    }

    /// `padEnd` with a fill string.
    #[test]
    fn e2e_string_pad_end_fill() {
        let result = global_eval("'abc'.padEnd(6, '.')").unwrap();
        assert_eq!(result, JsValue::String("abc...".into()));
    }

    /// `padEnd` returns original if already long enough.
    #[test]
    fn e2e_string_pad_end_no_pad_needed() {
        let result = global_eval("'hello'.padEnd(3)").unwrap();
        assert_eq!(result, JsValue::String("hello".into()));
    }

    // ── String.prototype.normalize tests ────────────────────────────────

    /// `normalize()` with no argument defaults to NFC (no-op for ASCII).
    #[test]
    fn e2e_string_normalize_default() {
        let result = global_eval("'hello'.normalize()").unwrap();
        assert_eq!(result, JsValue::String("hello".into()));
    }

    /// `normalize('NFC')` on ASCII is identity.
    #[test]
    fn e2e_string_normalize_nfc() {
        let result = global_eval("'test'.normalize('NFC')").unwrap();
        assert_eq!(result, JsValue::String("test".into()));
    }

    #[test]
    fn e2e_unicode_string_iterator_symbol_iterator_len_one_for_astral() {
        assert_eval_true(r#"[..."𝐀"].length === 1"#);
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_unicode_string_iterator_symbol_iterator_splits_two_astrals() {
        assert_eval_true(r#"[..."𝐀𝐁"].length === 2"#);
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_unicode_string_iterator_symbol_iterator_preserves_values() {
        assert_eval_true(r#"[..."𝐀𝐁"].join("|") === "𝐀|𝐁""#);
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_unicode_string_iterator_symbol_iterator_from_surrogate_escapes() {
        assert_eval_true(r#"[..."\uD835\uDC00\uD835\uDC01"].length === 2"#);
    }

    #[test]
    fn e2e_unicode_string_symbol_iterator_next_returns_full_code_point() {
        assert_eval_true(
            r#"var it = "𝐀"[Symbol.iterator](); var step = it.next(); step.done === false && step.value === "𝐀""#,
        );
    }

    #[test]
    fn e2e_unicode_string_symbol_iterator_second_step_done() {
        assert_eval_true(r#"var it = "𝐀"[Symbol.iterator](); it.next(); it.next().done === true"#);
    }

    #[test]
    fn e2e_unicode_array_from_two_astrals_has_two_elements() {
        assert_eval_true(r#"Array.from("𝐀𝐁").length === 2"#);
    }

    #[test]
    fn e2e_unicode_array_from_two_astrals_preserves_first_element() {
        assert_eval_true(r#"Array.from("𝐀𝐁")[0] === "𝐀""#);
    }

    #[test]
    fn e2e_unicode_array_from_two_astrals_preserves_second_element() {
        assert_eval_true(r#"Array.from("𝐀𝐁")[1] === "𝐁""#);
    }

    #[test]
    fn e2e_unicode_array_from_surrogate_escape_string_has_two_elements() {
        assert_eval_true(r#"Array.from("\uD835\uDC00\uD835\uDC01").length === 2"#);
    }

    #[test]
    fn e2e_unicode_array_from_surrogate_escape_string_round_trips() {
        assert_eval_true(r#"Array.from("\uD835\uDC00\uD835\uDC01").join("") === "𝐀𝐁""#);
    }

    #[test]
    fn e2e_unicode_utf16_length_of_astral_is_two() {
        assert_eval_true(r#""𝐀".length === 2"#);
    }

    #[test]
    fn e2e_unicode_utf16_length_of_two_astrals_is_four() {
        assert_eval_true(r#""𝐀𝐁".length === 4"#);
    }

    #[test]
    fn e2e_unicode_utf16_length_of_surrogate_escape_pair_is_two() {
        assert_eval_true(r#""\uD835\uDC00".length === 2"#);
    }

    #[test]
    fn e2e_unicode_code_point_at_returns_full_code_point_for_literal() {
        assert_eval_true(r#""𝐀".codePointAt(0) === 0x1D400"#);
    }

    #[test]
    fn e2e_unicode_code_point_at_returns_low_surrogate_at_second_unit() {
        assert_eval_true(r#""𝐀".codePointAt(1) === 0xDC00"#);
    }

    #[test]
    fn e2e_unicode_code_point_at_surrogate_escape_pair_returns_full_code_point() {
        assert_eval_true(r#""\uD835\uDC00".codePointAt(0) === 0x1D400"#);
    }

    #[test]
    fn e2e_unicode_from_code_point_builds_astral_literal() {
        assert_eval_true(r#"String.fromCodePoint(0x1D400) === "𝐀""#);
    }

    #[test]
    fn e2e_unicode_from_code_point_builds_multiple_astrals() {
        assert_eval_true(r#"String.fromCodePoint(0x1D400, 0x1D401) === "𝐀𝐁""#);
    }

    #[test]
    fn e2e_unicode_from_code_point_astral_has_utf16_length_two() {
        assert_eval_true(r#"String.fromCodePoint(0x1D400).length === 2"#);
    }

    #[test]
    fn e2e_unicode_char_at_returns_single_code_unit_length() {
        assert_eval_true(r#""𝐀".charAt(0).length === 1"#);
    }

    #[test]
    fn e2e_unicode_char_at_differs_from_code_point_at_on_astral() {
        assert_eval_true(r#""𝐀".charCodeAt(0) !== "𝐀".codePointAt(0)"#);
    }

    #[test]
    fn e2e_unicode_char_code_at_returns_high_surrogate_for_astral() {
        assert_eval_true(r#""𝐀".charCodeAt(0) === 0xD835"#);
    }

    #[test]
    fn e2e_unicode_literal_equals_surrogate_escape_pair() {
        assert_eval_true(r#""𝐀" === "\uD835\uDC00""#);
    }

    #[test]
    fn e2e_unicode_surrogate_escape_pair_concatenates_to_two_astrals() {
        assert_eval_true(r#""\uD835\uDC00" + "\uD835\uDC01" === "𝐀𝐁""#);
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_unicode_normalize_nfc_composes_combining_mark() {
        assert_eval_true(r#""e\u0301".normalize("NFC") === "\u00E9""#);
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_unicode_normalize_nfd_decomposes_precomposed_character() {
        assert_eval_true(r#""\u00E9".normalize("NFD") === "e\u0301""#);
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_unicode_normalize_nfkc_compatibility_composes_ligature() {
        assert_eval_true(r#""\uFB03".normalize("NFKC") === "ffi""#);
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_unicode_normalize_nfkd_compatibility_decomposes_ligature() {
        assert_eval_true(r#""\uFB03".normalize("NFKD") === "ffi""#);
    }

    #[test]
    fn e2e_unicode_normalize_leaves_astral_character_unchanged() {
        assert_eval_true(r#""𝐀".normalize("NFC") === "𝐀""#);
    }

    #[test]
    fn e2e_unicode_encode_uri_component_encodes_astral_utf8_bytes() {
        assert_eval_true(r#"encodeURIComponent("𝐀") === "%F0%9D%90%80""#);
    }

    #[test]
    fn e2e_unicode_encode_uri_component_encodes_surrogate_escape_pair_same_way() {
        assert_eval_true(r#"encodeURIComponent("\uD835\uDC00") === "%F0%9D%90%80""#);
    }

    #[test]
    fn e2e_unicode_template_literal_direct_astral_has_utf16_length_two() {
        assert_eval_true(r#"`𝐀`.length === 2"#);
    }

    #[test]
    fn e2e_unicode_template_literal_surrogate_escape_pair_equals_literal() {
        assert_eval_true(r#"`\uD835\uDC00` === "𝐀""#);
    }

    #[test]
    fn e2e_unicode_template_literal_interpolation_preserves_astral() {
        assert_eval_true(r#"`${"𝐀"}${"𝐁"}` === "𝐀𝐁""#);
    }

    #[test]
    fn e2e_unicode_regexp_unicode_dot_matches_entire_astral_character() {
        assert_eval_true(r#"/./u.exec("𝐀")[0] === "𝐀""#);
    }

    #[test]
    fn e2e_unicode_regexp_unicode_dot_match_has_utf16_length_two() {
        assert_eval_true(r#"/./u.exec("𝐀")[0].length === 2"#);
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_unicode_regexp_non_unicode_dot_matches_single_code_unit() {
        assert_eval_true(r#"/./.exec("𝐀")[0].length === 1"#);
    }

    #[test]
    fn e2e_unicode_regexp_unicode_braced_escape_matches_literal() {
        assert_eval_true(r#"/\u{1D400}/u.test("𝐀")"#);
    }

    #[test]
    fn e2e_unicode_regexp_unicode_braced_escape_exec_returns_literal() {
        assert_eval_true(r#"/\u{1D400}/u.exec("𝐀")[0] === "𝐀""#);
    }

    // ── Object.entries / Object.values tests ────────────────────────────

    /// `Object.entries` returns key-value pairs.
    #[test]
    fn e2e_object_entries_basic() {
        let result = global_eval("Object.entries({a: 1}).length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Object.entries` first entry key is a string.
    #[test]
    fn e2e_object_entries_key() {
        let result = global_eval("Object.entries({a: 1})[0][0]").unwrap();
        assert_eq!(result, JsValue::String("a".into()));
    }

    /// `Object.entries` first entry value.
    #[test]
    fn e2e_object_entries_value() {
        let result = global_eval("Object.entries({a: 1})[0][1]").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Object.values` returns values array.
    #[test]
    fn e2e_object_values_basic() {
        let result = global_eval("Object.values({a: 1, b: 2}).length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Object.values` on empty object.
    #[test]
    fn e2e_object_values_empty() {
        let result = global_eval("Object.values({}).length").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    // ── constructor property tests ──────────────────────────────────────

    /// Array.prototype.constructor exists and is a function-like object.
    #[test]
    fn test_array_prototype_has_constructor() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let arr = globals.get("Array").unwrap();
        if let JsValue::PlainObject(map) = arr {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("constructor"),
                    "Array.prototype should have constructor"
                );
            } else {
                panic!("Array should have prototype");
            }
        } else {
            panic!("Array should be PlainObject");
        }
    }

    /// Object.prototype.constructor exists.
    #[test]
    fn test_object_prototype_has_constructor() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let obj = globals.get("Object").unwrap();
        if let JsValue::PlainObject(map) = obj {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("constructor"),
                    "Object.prototype should have constructor"
                );
            } else {
                panic!("Object should have prototype");
            }
        } else {
            panic!("Object should be PlainObject");
        }
    }

    /// String.prototype.constructor exists.
    #[test]
    fn test_string_prototype_has_constructor() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let s = globals.get("String").unwrap();
        if let JsValue::PlainObject(map) = s {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("constructor"),
                    "String.prototype should have constructor"
                );
            } else {
                panic!("String should have prototype");
            }
        } else {
            panic!("String should be PlainObject");
        }
    }

    /// Number.prototype.constructor exists.
    #[test]
    fn test_number_prototype_has_constructor() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let n = globals.get("Number").unwrap();
        if let JsValue::PlainObject(map) = n {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("constructor"),
                    "Number.prototype should have constructor"
                );
            } else {
                panic!("Number should have prototype");
            }
        } else {
            panic!("Number should be PlainObject");
        }
    }

    /// Boolean.prototype.constructor exists.
    #[test]
    fn test_boolean_prototype_has_constructor() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let b = globals.get("Boolean").unwrap();
        if let JsValue::PlainObject(map) = b {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("constructor"),
                    "Boolean.prototype should have constructor"
                );
            } else {
                panic!("Boolean should have prototype");
            }
        } else {
            panic!("Boolean should be PlainObject");
        }
    }

    /// Function.prototype.constructor exists.
    #[test]
    fn test_function_prototype_has_constructor() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let f = globals.get("Function").unwrap();
        if let JsValue::PlainObject(map) = f {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("constructor"),
                    "Function.prototype should have constructor"
                );
            } else {
                panic!("Function should have prototype");
            }
        } else {
            panic!("Function should be PlainObject");
        }
    }

    /// RegExp.prototype.constructor exists.
    #[test]
    fn test_regexp_prototype_has_constructor() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let r = globals.get("RegExp").unwrap();
        if let JsValue::PlainObject(map) = r {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("constructor"),
                    "RegExp.prototype should have constructor"
                );
            } else {
                panic!("RegExp should have prototype");
            }
        } else {
            panic!("RegExp should be PlainObject");
        }
    }

    /// Map.prototype.constructor is not Undefined (was previously a bug).
    #[test]
    fn test_map_prototype_constructor_not_undefined() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let m = globals.get("Map").unwrap();
        if let JsValue::PlainObject(map) = m {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                let ctor = proto.get("constructor").cloned();
                assert!(
                    !matches!(ctor, Some(JsValue::Undefined) | None),
                    "Map.prototype.constructor should not be Undefined"
                );
            } else {
                panic!("Map should have prototype");
            }
        } else {
            panic!("Map should be PlainObject");
        }
    }

    /// Set.prototype.constructor is not Undefined (was previously a bug).
    #[test]
    fn test_set_prototype_constructor_not_undefined() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let s = globals.get("Set").unwrap();
        if let JsValue::PlainObject(map) = s {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                let ctor = proto.get("constructor").cloned();
                assert!(
                    !matches!(ctor, Some(JsValue::Undefined) | None),
                    "Set.prototype.constructor should not be Undefined"
                );
            } else {
                panic!("Set should have prototype");
            }
        } else {
            panic!("Set should be PlainObject");
        }
    }

    /// Error.prototype.constructor exists (for TypeError specifically).
    #[test]
    fn test_error_prototype_has_constructor() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let e = globals.get("TypeError").unwrap();
        if let JsValue::PlainObject(map) = e {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("constructor"),
                    "TypeError.prototype should have constructor"
                );
            } else {
                panic!("TypeError should have prototype");
            }
        } else {
            panic!("TypeError should be PlainObject");
        }
    }

    /// Array.prototype.constructor is the same object as the Array constructor.
    #[test]
    fn test_array_constructor_circular_ref() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let arr = globals.get("Array").unwrap();
        if let JsValue::PlainObject(arr_rc) = arr {
            let borrow = arr_rc.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                if let Some(JsValue::PlainObject(ctor_rc)) = proto.get("constructor") {
                    assert!(
                        Rc::ptr_eq(arr_rc, ctor_rc),
                        "Array.prototype.constructor should be Array itself"
                    );
                } else {
                    panic!("constructor should be PlainObject");
                }
            } else {
                panic!("Array should have prototype");
            }
        } else {
            panic!("Array should be PlainObject");
        }
    }

    // ── Array.prototype[@@unscopables] tests ────────────────────────────

    /// Array.prototype has @@unscopables.
    #[test]
    fn test_array_unscopables_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let arr = globals.get("Array").unwrap();
        if let JsValue::PlainObject(map) = arr {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                assert!(
                    proto.contains_key("@@unscopables"),
                    "Array.prototype should have @@unscopables"
                );
            } else {
                panic!("Array should have prototype");
            }
        }
    }

    /// Array.prototype[@@unscopables] contains expected keys.
    #[test]
    fn test_array_unscopables_keys() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let arr = globals.get("Array").unwrap();
        if let JsValue::PlainObject(map) = arr {
            let borrow = map.borrow();
            if let Some(JsValue::PlainObject(proto_obj)) = borrow.get("prototype") {
                let proto = proto_obj.borrow();
                if let Some(JsValue::PlainObject(unscopables)) = proto.get("@@unscopables") {
                    let u = unscopables.borrow();
                    for key in &[
                        "at",
                        "copyWithin",
                        "entries",
                        "fill",
                        "find",
                        "findIndex",
                        "flat",
                        "flatMap",
                        "includes",
                        "keys",
                        "values",
                    ] {
                        assert!(u.contains_key(*key), "@@unscopables should contain {key}");
                    }
                } else {
                    panic!("@@unscopables should be PlainObject");
                }
            }
        }
    }

    // ── Array.fromAsync tests ───────────────────────────────────────────

    /// Array.fromAsync is registered on Array.
    #[test]
    fn test_array_from_async_exists() {
        let mut globals = HashMap::new();
        install_globals(&mut globals);
        let arr = globals.get("Array").unwrap();
        if let JsValue::PlainObject(map) = arr {
            assert!(
                map.borrow().contains_key("fromAsync"),
                "Array should have fromAsync"
            );
        } else {
            panic!("Array should be PlainObject");
        }
    }

    // ── Conformance round-21 tests ──────────────────────────────────────

    /// `Number.parseFloat` delegates to global parseFloat.
    #[test]
    fn test_number_parse_float() {
        let result = global_eval("Number.parseFloat('3.14')").unwrap();
        assert_eq!(result, JsValue::HeapNumber(3.14));
    }

    /// `Number.parseInt` delegates to global parseInt.
    #[test]
    fn test_number_parse_int() {
        let result = global_eval("Number.parseInt('42')").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.keys` returns own enumerable string-keyed property names.
    #[test]
    fn test_object_keys_basic() {
        let result = global_eval("Object.keys({a:1, b:2, c:3}).join(',')").unwrap();
        assert_eq!(result, JsValue::String("a,b,c".into()));
    }

    /// `Object.values` returns own enumerable string-keyed property values.
    #[test]
    fn test_object_values_basic() {
        let result = global_eval("Object.values({a:1, b:2, c:3}).join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    /// `Object.entries` returns [key, value] pairs.
    #[test]
    fn test_object_entries_basic() {
        let result = global_eval("Object.entries({a:1, b:2}).length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Object.assign` merges source properties into target.
    #[test]
    fn test_object_assign_basic() {
        let result = global_eval(
            "var target = {}; Object.assign(target, {x:1}, {y:2}); target.x + target.y",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Array.isArray` returns true for arrays.
    #[test]
    fn test_array_is_array_true() {
        let result = global_eval("Array.isArray([1,2,3])").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Array.isArray` returns false for plain objects.
    #[test]
    fn test_array_is_array_false() {
        let result = global_eval("Array.isArray({length: 3})").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Array.from` converts a string into an array of characters.
    #[test]
    fn test_array_from_string() {
        let result = global_eval("Array.from('abc').join(',')").unwrap();
        assert_eq!(result, JsValue::String("a,b,c".into()));
    }

    /// `Array.of` creates an array from its arguments.
    #[test]
    fn test_array_of_basic() {
        let result = global_eval("Array.of(1,2,3).join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    /// `Map` set/get round-trip.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_map_has_get() {
        let result = global_eval("var m = new Map(); m.set('key', 42); m.get('key')").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Set.prototype.has` returns true for added values.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_set_has() {
        let result = global_eval("var s = new Set(); s.add(42); s.has(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `JSON.parse` deserializes a JSON string.
    #[test]
    fn test_json_parse_basic() {
        let result = global_eval("JSON.parse('{\"x\":42}').x").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `JSON.stringify` serializes an object.
    #[test]
    fn test_json_stringify_basic() {
        let result = global_eval("JSON.stringify({x:1,y:2})").unwrap();
        assert_eq!(result, JsValue::String("{\"x\":1,\"y\":2}".into()));
    }

    /// `RegExp.prototype.test` matches patterns.
    #[test]
    fn test_regexp_test_true() {
        let result = global_eval("new RegExp('hello').test('hello world')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `String.fromCharCode` builds a string from char codes.
    #[test]
    fn test_string_from_char_code() {
        let result = global_eval("String.fromCharCode(72, 101, 108, 108, 111)").unwrap();
        assert_eq!(result, JsValue::String("Hello".into()));
    }

    /// `Math.max` returns the largest argument.
    #[test]
    fn test_math_max() {
        let result = global_eval("Math.max(1, 3, 2)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Math.min` returns the smallest argument.
    #[test]
    fn test_math_min() {
        let result = global_eval("Math.min(1, 3, 2)").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Math.abs` returns the absolute value.
    #[test]
    fn test_math_abs() {
        let result = global_eval("Math.abs(-42)").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Date.now()` returns a number.
    #[test]
    fn test_date_now_type() {
        let result = global_eval("typeof Date.now()").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `new Error('test').message` returns the message.
    #[test]
    fn test_error_message() {
        let result = global_eval("new Error('test').message").unwrap();
        assert_eq!(result, JsValue::String("test".into()));
    }

    /// `new TypeError('bad').name` returns "TypeError".
    #[test]
    fn test_type_error_name() {
        let result = global_eval("new TypeError('bad').name").unwrap();
        assert_eq!(result, JsValue::String("TypeError".into()));
    }

    /// `Number.isFinite(42)` returns true for finite numbers.
    #[test]
    fn test_number_is_finite() {
        let result = global_eval("Number.isFinite(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.isFinite(Infinity)` returns false for Infinity.
    #[test]
    fn test_number_is_finite_infinity() {
        let result = global_eval("Number.isFinite(Infinity)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isNaN(NaN)` returns true for NaN.
    #[test]
    fn test_number_is_nan() {
        let result = global_eval("Number.isNaN(NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.isInteger(5)` returns true for integers.
    #[test]
    fn test_number_is_integer() {
        let result = global_eval("Number.isInteger(5)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.isSafeInteger(9007199254740991)` returns true for MAX_SAFE_INTEGER.
    #[test]
    fn test_number_is_safe_integer() {
        let result = global_eval("Number.isSafeInteger(9007199254740991)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.EPSILON > 0` confirms EPSILON is a positive value.
    #[test]
    fn test_number_epsilon() {
        let result = global_eval("Number.EPSILON > 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Number.MAX_SAFE_INTEGER` equals 2^53 - 1.
    #[test]
    fn test_number_max_safe_integer() {
        let result = global_eval("Number.MAX_SAFE_INTEGER").unwrap();
        assert_eq!(result, JsValue::HeapNumber(9007199254740991.0));
    }

    /// `Object.create(null)` returns an object with typeof "object".
    #[test]
    fn test_object_create_null_proto() {
        let result = global_eval("var o = Object.create(null); typeof o").unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    /// `Object.getPrototypeOf({})` returns `Object.prototype`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_object_get_prototype_of() {
        let result = global_eval("Object.getPrototypeOf({}) === Object.prototype").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Array.prototype.pop mutation tests ──────────────────────────────

    /// `pop` removes and returns the last element.
    #[test]
    fn test_array_pop_mutates() {
        let result = global_eval("var a = [1,2,3]; a.pop(); a.length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `pop` returns the removed element.
    #[test]
    fn test_array_pop_returns_last() {
        let result = global_eval("var a = [10,20,30]; a.pop()").unwrap();
        assert_eq!(result, JsValue::Smi(30));
    }

    /// `pop` on empty array returns undefined.
    #[test]
    fn test_array_pop_empty() {
        let result = global_eval("var a = []; a.pop()").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    // ── Array.prototype.shift mutation tests ────────────────────────────

    /// `shift` removes and returns the first element.
    #[test]
    fn test_array_shift_mutates() {
        let result = global_eval("var a = [1,2,3]; a.shift(); a.length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `shift` returns the removed element.
    #[test]
    fn test_array_shift_returns_first() {
        let result = global_eval("var a = [10,20,30]; a.shift()").unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    /// `shift` on empty array returns undefined.
    #[test]
    fn test_array_shift_empty() {
        let result = global_eval("var a = []; a.shift()").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    // ── Array.prototype.unshift mutation tests ──────────────────────────

    /// `unshift` prepends items and returns new length.
    #[test]
    fn test_array_unshift_mutates() {
        let result = global_eval("var a = [3]; a.unshift(1, 2); a[0]").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `unshift` returns the new length.
    #[test]
    fn test_array_unshift_returns_length() {
        let result = global_eval("var a = [3]; a.unshift(1, 2)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Array.prototype.reverse mutation tests ──────────────────────────

    /// `reverse` mutates the original array.
    #[test]
    fn test_array_reverse_mutates() {
        let result = global_eval("var a = [1,2,3]; a.reverse(); a[0]").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `reverse` mutates the original (verified by reading back).
    #[test]
    fn test_array_reverse_returns_reversed() {
        let result = global_eval("var a = [1,2,3]; a.reverse(); a[0]").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Array.prototype.sort mutation tests ─────────────────────────────

    /// `sort` mutates the original array in-place.
    #[test]
    fn test_array_sort_mutates() {
        let result = global_eval("var a = [3,1,2]; a.sort(); a[0]").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `sort` returns sorted values (verified by reading back).
    #[test]
    fn test_array_sort_returns_sorted() {
        let result = global_eval("var a = [3,1,2]; a.sort(); a[2]").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn test_array_sort_uses_string_comparison_by_default() {
        let result = global_eval("var a = [10, 2, 1]; a.sort(); a.join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,10,2".into()));
    }

    #[test]
    fn test_array_sort_is_stable_when_comparator_returns_zero() {
        let result = global_eval(
            "var a = [{k:'a'}, {k:'b'}, {k:'c'}]; a.sort(function() { return 0; }); \
             a[0].k + a[1].k + a[2].k",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("abc".into()));
    }

    #[test]
    fn test_array_sort_preserves_sparse_holes() {
        let result = global_eval(
            "var a = [, 'b', 'a']; a.sort(); a[0] === 'a' && a[1] === 'b' && !(2 in a)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_array_sort_handles_non_array_objects_with_length() {
        let result = global_eval(
            "var o = {0: 'b', 2: 'a', length: 3}; \
             Array.prototype.sort.call(o); \
             o[0] === 'a' && o[1] === 'b' && !(2 in o) && o.length === 3",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Array.prototype.fill mutation tests ─────────────────────────────

    /// `fill` mutates the original array.
    #[test]
    fn test_array_fill_mutates() {
        let result = global_eval("var a = [1,2,3]; a.fill(0); a[1]").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `fill` fills all elements (verified by reading last element).
    #[test]
    fn test_array_fill_all_elements() {
        let result = global_eval("var a = [1,2,3]; a.fill(0); a[2]").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    // ── Array.prototype.splice mutation tests ───────────────────────────

    /// `splice` removes elements from the original array.
    #[test]
    fn test_array_splice_mutates() {
        let result = global_eval("var a = [1,2,3,4]; a.splice(1,2); a.length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `splice` returns deleted elements.
    #[test]
    fn test_array_splice_returns_deleted() {
        let result = global_eval("var a = [1,2,3,4]; var d = a.splice(1,2); d[0]").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `splice` with negative start index.
    #[test]
    fn test_array_splice_negative_start() {
        let result = global_eval("var a = [1,2,3,4]; a.splice(-2, 1); a.length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `splice` inserts new elements.
    #[test]
    fn test_array_splice_insert() {
        let result = global_eval("var a = [1,2,3]; a.splice(1, 0, 10, 20); a[1]").unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn test_array_splice_returns_deleted_array_and_shifts() {
        let result = global_eval(
            "var a = [1,2,3,4]; var d = a.splice(1, 2); \
             d.length === 2 && d[0] === 2 && d[1] === 3 && a.join(',') === '1,4'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_array_splice_negative_start_and_insert_updates_length() {
        let result = global_eval(
            "var a = [1,2,3,4]; a.splice(-2, 1, 9, 8); a.join(',') === '1,2,9,8,4' && a.length === 5",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_array_splice_without_delete_count_removes_to_end() {
        let result = global_eval(
            "var a = [1,2,3,4]; var d = a.splice(2); d.join(',') === '3,4' && a.length === 2",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Array.prototype.copyWithin mutation tests ───────────────────────

    /// `copyWithin` mutates the original array.
    #[test]
    fn test_array_copywithin_mutates() {
        let result = global_eval("var a = [1,2,3,4,5]; a.copyWithin(0, 3); a[0]").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `copyWithin` copies correctly (verified by reading second element).
    #[test]
    fn test_array_copywithin_second_element() {
        let result = global_eval("var a = [1,2,3,4,5]; a.copyWithin(0, 3); a[1]").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    // ── Number.parseInt hex auto-detection tests ────────────────────────

    /// `Number.parseInt` auto-detects hex prefix.
    #[test]
    fn test_number_parseint_hex() {
        let result = global_eval("Number.parseInt('0x1A')").unwrap();
        assert_eq!(result, JsValue::Smi(26));
    }

    /// `Number.parseInt` with explicit radix.
    #[test]
    fn test_number_parseint_explicit_radix() {
        let result = global_eval("Number.parseInt('ff', 16)").unwrap();
        assert_eq!(result, JsValue::Smi(255));
    }

    /// `Number.parseInt` decimal by default.
    #[test]
    fn test_number_parseint_decimal() {
        let result = global_eval("Number.parseInt('42')").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    // ── Array.prototype.includes SameValueZero tests ────────────────────

    /// `includes` finds NaN via SameValueZero semantics.
    #[test]
    fn test_includes_nan() {
        let result = global_eval("[1, NaN, 3].includes(NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `includes` respects fromIndex parameter.
    #[test]
    fn test_includes_from_index() {
        let result = global_eval("[1, 2, 3].includes(1, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `includes` with negative fromIndex counts from end.
    #[test]
    fn test_includes_negative_from_index() {
        let result = global_eval("[1, 2, 3].includes(3, -1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_includes_skips_sparse_holes() {
        let result = global_eval("var a = []; a.length = 1; a.includes(undefined)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn test_includes_honors_infinite_from_index() {
        let result = global_eval("[1, 2, 3].includes(1, Infinity)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `includes` returns false when element is not present.
    #[test]
    fn test_includes_not_found() {
        let result = global_eval("[1, 2, 3].includes(4)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Array.prototype.indexOf strict equality tests ───────────────────

    /// `indexOf` does NOT find NaN (strict equality: NaN !== NaN).
    #[test]
    fn test_indexof_nan() {
        let result = global_eval("[1, NaN, 3].indexOf(NaN)").unwrap();
        assert_eq!(result, JsValue::Smi(-1));
    }

    /// `indexOf` with negative fromIndex counts from end.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_indexof_negative_from_index() {
        let result = global_eval("[1, 2, 1, 3].indexOf(1, -2)").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `indexOf` returns first occurrence.
    #[test]
    fn test_indexof_first_occurrence() {
        let result = global_eval("[1, 2, 1, 3].indexOf(1)").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_indexof_skips_sparse_holes() {
        let result =
            global_eval("var a = []; a[1] = undefined; a.length = 3; a.indexOf(undefined)")
                .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    // ── Array.prototype.lastIndexOf strict equality tests ───────────────

    /// `lastIndexOf` returns last occurrence.
    #[test]
    fn test_lastindexof_basic() {
        let result = global_eval("[1, 2, 1, 3].lastIndexOf(1)").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `lastIndexOf` with fromIndex limits the search range.
    #[test]
    fn test_lastindexof_from_index() {
        let result = global_eval("[1, 2, 1, 3].lastIndexOf(1, 1)").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `lastIndexOf` does NOT find NaN.
    #[test]
    fn test_lastindexof_nan() {
        let result = global_eval("[1, NaN, 3].lastIndexOf(NaN)").unwrap();
        assert_eq!(result, JsValue::Smi(-1));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_lastindexof_negative_from_index_and_holes() {
        let result = global_eval(
            "var a = []; a[1] = undefined; a[3] = undefined; a.length = 4; \
             a.lastIndexOf(undefined, -2)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    // ── Array.prototype.reduce / reduceRight edge cases ─────────────────

    /// `reduce` on empty array with no initial value throws TypeError.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_reduce_empty_throws() {
        let result = global_eval("[].reduce(function(a, b) { return a + b })");
        assert!(
            result.is_err(),
            "Expected TypeError for reduce of empty array"
        );
    }

    /// `reduceRight` on empty array with no initial value throws TypeError.
    #[test]
    fn test_reduce_right_empty_throws() {
        let result = global_eval("[].reduceRight(function(a, b) { return a + b })");
        assert!(
            result.is_err(),
            "Expected TypeError for reduceRight of empty array"
        );
    }

    /// `reduce` with initial value on empty array returns initial value.
    #[test]
    fn test_reduce_empty_with_initial() {
        let result = global_eval("[].reduce(function(a, b) { return a + b }, 42)").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_reduce_skips_holes_and_passes_callback_arguments() {
        let result = global_eval(
            "var seen = []; \
             var sum = [,1,,2].reduce(function(acc, value, index, array) { \
               seen.push(index + ':' + value + ':' + (array.length === 4)); \
               return acc + value; \
             }, 0); \
             sum === 3 && seen.join('|') === '1:1:true|3:2:true'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_reduce_right_skips_holes_and_passes_callback_arguments() {
        let result = global_eval(
            "var seen = []; \
             var sum = [,1,,2].reduceRight(function(acc, value, index, array) { \
               seen.push(index + ':' + value + ':' + (array.length === 4)); \
               return acc + value; \
             }, 0); \
             sum === 3 && seen.join('|') === '3:2:true|1:1:true'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Array.prototype.every / some edge cases ─────────────────────────

    /// `every` returns true for empty array (vacuous truth).
    #[test]
    fn test_every_empty() {
        let result = global_eval("[].every(function(x) { return false })").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `some` returns false for empty array.
    #[test]
    fn test_some_empty() {
        let result = global_eval("[].some(function(x) { return true })").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_every_skips_holes_and_uses_this_arg() {
        let result = global_eval(
            "var arr = [1,,2]; \
             var seen = []; \
             var ctx = { min: 0 }; \
             var ok = arr.every(function(value, index, array) { \
               seen.push(index + ':' + (array === arr) + ':' + (this === ctx)); \
               return value > this.min; \
             }, ctx); \
             ok && seen.join('|') === '0:true:true|2:true:true'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_some_skips_holes_and_uses_this_arg() {
        let result = global_eval(
            "var arr = [,1,3]; \
             var seen = []; \
             var ctx = { target: 3 }; \
             var ok = arr.some(function(value, index, array) { \
               seen.push(index + ':' + (array === arr) + ':' + (this === ctx)); \
               return value === this.target; \
             }, ctx); \
             ok && seen.join('|') === '1:true:true|2:true:true'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_filter_skips_holes_and_uses_this_arg() {
        let result = global_eval(
            "var arr = [1,,3]; \
             var ctx = { threshold: 2 }; \
             var out = arr.filter(function(value, index, array) { \
               return value >= this.threshold && array === arr; \
             }, ctx); \
             out.length === 1 && out[0] === 3",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_find_visits_holes_and_uses_this_arg() {
        let result = global_eval(
            "var arr = [,2]; \
             var seen = []; \
             var ctx = { target: undefined }; \
             var value = arr.find(function(element, index, array) { \
               seen.push(index + ':' + (element === undefined) + ':' + (array === arr) + ':' + (this === ctx)); \
               return index === 0 && element === this.target; \
             }, ctx); \
             value === undefined && seen[0] === '0:true:true:true'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_find_index_visits_holes_and_uses_this_arg() {
        let result = global_eval(
            "var arr = [,2]; \
             var seen = []; \
             var ctx = { target: undefined }; \
             var index = arr.findIndex(function(element, idx, array) { \
               seen.push(idx + ':' + (element === undefined) + ':' + (array === arr) + ':' + (this === ctx)); \
               return idx === 0 && element === this.target; \
             }, ctx); \
             index === 0 && seen[0] === '0:true:true:true'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_array_concat_spreads_arrays_and_appends_scalars() {
        let result = global_eval("[1].concat([2], 3).join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_array_concat_respects_symbol_is_concat_spreadable_on_object() {
        let result = global_eval(
            "var spread = {0: 'a', 1: 'b', length: 2}; \
             spread[Symbol.isConcatSpreadable] = true; \
             [].concat(spread).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("a,b".into()));
    }

    #[test]
    fn test_array_concat_respects_false_is_concat_spreadable_on_array() {
        let result = global_eval(
            "var arr = [1, 2]; \
             arr[Symbol.isConcatSpreadable] = false; \
             var out = [].concat(arr); \
             out.length === 1 && out[0] === arr",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_array_concat_default_object_is_not_spreadable() {
        let result = global_eval(
            "var obj = {0: 'a', length: 1}; \
             var out = [].concat(obj); \
             out.length === 1 && out[0] === obj",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_array_concat_false_is_concat_spreadable_on_object() {
        let result = global_eval(
            "var obj = {0: 'a', length: 1}; \
             obj[Symbol.isConcatSpreadable] = false; \
             var out = [].concat(obj); \
             out.length === 1 && out[0] === obj",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_array_concat_true_is_concat_spreadable_on_array() {
        let result = global_eval(
            "var arr = [1, 2]; \
             arr[Symbol.isConcatSpreadable] = true; \
             [].concat(arr).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_array_length_shrink_truncates_elements() {
        let result = global_eval(
            "var a = [1,2,3]; \
             a.length = 1; \
             a.length === 1 && a[0] === 1 && !(1 in a) && !(2 in a)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_array_length_grow_creates_sparse_slots() {
        let result = global_eval(
            "var a = [1]; \
             a.length = 3; \
             a.length === 3 && a[0] === 1 && !(1 in a) && !(2 in a)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Array.prototype.flat / flatMap tests ────────────────────────────

    /// `flat` with depth 0 returns a shallow copy.
    #[test]
    fn test_flat_depth_zero() {
        let result = global_eval("[1, [2, 3]].flat(0).length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `flat` with Infinity depth flattens deeply.
    #[test]
    fn test_flat_infinity_depth() {
        let result = global_eval("[1, [2, [3, [4]]]].flat(Infinity).length").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `flatMap` maps then flattens one level.
    #[test]
    fn test_flatmap_maps_and_flattens() {
        let result =
            global_eval("[1, 2, 3].flatMap(function(x) { return [x, x * 2] }).length").unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    // ── Array.from / Array.of conformance ───────────────────────────────

    /// `Array.from` with array-like object (has `length` property).
    #[test]
    fn test_array_from_array_like() {
        let result = global_eval("Array.from({0: 'a', 1: 'b', length: 2}).length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Array.from` array-like values are correct.
    #[test]
    fn test_array_from_array_like_values() {
        let result = global_eval("Array.from({0: 'a', 1: 'b', length: 2})[1]").unwrap();
        assert_eq!(result, JsValue::String("b".into()));
    }

    /// `Array.from` with non-callable mapFn throws TypeError.
    #[test]
    fn test_array_from_bad_mapfn() {
        let result = global_eval("Array.from([1], 42)");
        assert!(result.is_err(), "Expected TypeError for non-callable mapFn");
    }

    /// `Array.of` with zero arguments creates empty array.
    #[test]
    fn test_array_of_empty() {
        let result = global_eval("Array.of().length").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    // ── Object.keys / values / entries edge cases ───────────────────────

    /// `Object.keys(null)` throws TypeError.
    #[test]
    fn test_object_keys_null_throws() {
        let result = global_eval("Object.keys(null)");
        assert!(result.is_err(), "Expected TypeError for Object.keys(null)");
    }

    /// `Object.values(undefined)` throws TypeError.
    #[test]
    fn test_object_values_undefined_throws() {
        let result = global_eval("Object.values(undefined)");
        assert!(
            result.is_err(),
            "Expected TypeError for Object.values(undefined)"
        );
    }

    /// `Object.entries(null)` throws TypeError.
    #[test]
    fn test_object_entries_null_throws() {
        let result = global_eval("Object.entries(null)");
        assert!(
            result.is_err(),
            "Expected TypeError for Object.entries(null)"
        );
    }

    /// `Object.freeze` on non-object returns the value unchanged.
    #[test]
    fn test_object_freeze_non_object() {
        let result = global_eval("Object.freeze(42)").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.isFrozen` on a non-object returns true.
    #[test]
    fn test_object_is_frozen_primitive() {
        let result = global_eval("Object.isFrozen('hello')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.isSealed` on a non-object returns true.
    #[test]
    fn test_object_is_sealed_primitive() {
        let result = global_eval("Object.isSealed(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Number static method edge cases ─────────────────────────────────

    /// `Number.isNaN` does not coerce string argument.
    #[test]
    fn test_number_is_nan_no_coerce() {
        let result = global_eval("Number.isNaN('NaN')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isFinite` returns false for NaN.
    #[test]
    fn test_number_is_finite_nan() {
        let result = global_eval("Number.isFinite(NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isFinite` does not coerce strings.
    #[test]
    fn test_number_is_finite_no_coerce() {
        let result = global_eval("Number.isFinite('42')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isInteger` returns false for NaN.
    #[test]
    fn test_number_is_integer_nan() {
        let result = global_eval("Number.isInteger(NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isInteger` returns false for Infinity.
    #[test]
    fn test_number_is_integer_infinity() {
        let result = global_eval("Number.isInteger(Infinity)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Number.isSafeInteger` returns false for large values.
    #[test]
    fn test_number_is_safe_integer_large() {
        let result = global_eval("Number.isSafeInteger(9007199254740992)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Math method existence / edge cases ──────────────────────────────

    /// `Math.trunc(NaN)` returns NaN.
    #[test]
    fn test_math_trunc_nan() {
        let result = global_eval("Number.isNaN(Math.trunc(NaN))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Math.sign(0)` returns 0.
    #[test]
    fn test_math_sign_zero() {
        let result = global_eval("Math.sign(0)").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `Math.cbrt(27)` returns 3.
    #[test]
    fn test_math_cbrt_basic() {
        let result = global_eval("Math.cbrt(27)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Math.log2(8)` returns 3.
    #[test]
    fn test_math_log2_basic() {
        let result = global_eval("Math.log2(8)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Math.log10(1000)` returns 3.
    #[test]
    fn test_math_log10_basic() {
        let result = global_eval("Math.log10(1000)").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Math.fround / clz32 / imul / hypot tests ───────────────────────

    /// `Math.fround(1.337)` returns the nearest float32 value.
    #[test]
    fn test_math_fround_basic() {
        let result = global_eval("Math.fround(1.337)").unwrap();
        if let JsValue::HeapNumber(n) = result {
            let expected = 1.337f64 as f32 as f64;
            assert!(
                (n - expected).abs() < 1e-10,
                "expected ~{expected}, got {n}"
            );
        } else {
            panic!("expected HeapNumber, got {result:?}");
        }
    }

    /// `Math.fround(0)` returns 0.
    #[test]
    fn test_math_fround_zero() {
        let result = global_eval("Math.fround(0)").unwrap();
        if let JsValue::HeapNumber(n) = result {
            assert_eq!(n, 0.0);
        } else {
            panic!("expected HeapNumber, got {result:?}");
        }
    }

    /// `Math.clz32(1)` returns 31 (one leading zero bit after the sign).
    #[test]
    fn test_math_clz32_one() {
        let result = global_eval("Math.clz32(1)").unwrap();
        assert_eq!(result, JsValue::Smi(31));
    }

    /// `Math.clz32(0)` returns 32.
    #[test]
    fn test_math_clz32_zero() {
        let result = global_eval("Math.clz32(0)").unwrap();
        assert_eq!(result, JsValue::Smi(32));
    }

    /// `Math.imul(2, 4)` returns 8.
    #[test]
    fn test_math_imul_basic() {
        let result = global_eval("Math.imul(2, 4)").unwrap();
        assert_eq!(result, JsValue::Smi(8));
    }

    /// `Math.imul(-1, 8)` returns -8.
    #[test]
    fn test_math_imul_negative() {
        let result = global_eval("Math.imul(-1, 8)").unwrap();
        assert_eq!(result, JsValue::Smi(-8));
    }

    /// `Math.hypot(3, 4)` returns 5.
    #[test]
    fn test_math_hypot_basic() {
        let result = global_eval("Math.hypot(3, 4)").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// `Math.hypot()` with no args returns 0.
    #[test]
    fn test_math_hypot_no_args() {
        let result = global_eval("Math.hypot()").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    #[test]
    fn e2e_math_sign_negative_zero_preserved() {
        assert_eval_true("1 / Math.sign(-0) === -Infinity");
    }

    #[test]
    fn e2e_math_sign_nan() {
        assert_eval_true("Number.isNaN(Math.sign(NaN))");
    }

    #[test]
    fn e2e_math_sign_string_coercion() {
        assert_eval_true("Math.sign('-7') === -1");
    }

    #[test]
    fn e2e_math_cbrt_negative_zero_preserved() {
        assert_eval_true("1 / Math.cbrt(-0) === -Infinity");
    }

    #[test]
    fn e2e_math_cbrt_undefined_is_nan() {
        assert_eval_true("Number.isNaN(Math.cbrt())");
    }

    #[test]
    fn e2e_math_log2_zero_is_negative_infinity() {
        assert_eval_true("Math.log2(0) === -Infinity");
    }

    #[test]
    fn e2e_math_log2_negative_is_nan() {
        assert_eval_true("Number.isNaN(Math.log2(-1))");
    }

    #[test]
    fn e2e_math_log2_undefined_is_nan() {
        assert_eval_true("Number.isNaN(Math.log2())");
    }

    #[test]
    fn e2e_math_log10_zero_is_negative_infinity() {
        assert_eval_true("Math.log10(0) === -Infinity");
    }

    #[test]
    fn e2e_math_log10_negative_is_nan() {
        assert_eval_true("Number.isNaN(Math.log10(-1))");
    }

    #[test]
    fn e2e_math_log10_undefined_is_nan() {
        assert_eval_true("Number.isNaN(Math.log10())");
    }

    #[test]
    fn e2e_math_expm1_negative_zero_preserved() {
        assert_eval_true("1 / Math.expm1(-0) === -Infinity");
    }

    #[test]
    fn e2e_math_expm1_nan() {
        assert_eval_true("Number.isNaN(Math.expm1(NaN))");
    }

    #[test]
    fn e2e_math_expm1_matches_e_minus_one() {
        assert_eval_true("Math.abs(Math.expm1(1) - (Math.E - 1)) < 1e-15");
    }

    #[test]
    fn e2e_math_log1p_negative_zero_preserved() {
        assert_eval_true("1 / Math.log1p(-0) === -Infinity");
    }

    #[test]
    fn e2e_math_log1p_negative_one_is_negative_infinity() {
        assert_eval_true("Math.log1p(-1) === -Infinity");
    }

    #[test]
    fn e2e_math_log1p_below_negative_one_is_nan() {
        assert_eval_true("Number.isNaN(Math.log1p(-2))");
    }

    #[test]
    fn e2e_math_hypot_nan_without_infinity_is_nan() {
        assert_eval_true("Number.isNaN(Math.hypot(NaN, 1))");
    }

    #[test]
    fn e2e_math_hypot_infinity_beats_nan() {
        assert_eval_true("Math.hypot(NaN, Infinity) === Infinity");
    }

    #[test]
    fn e2e_math_hypot_multiple_args() {
        assert_eval_true("Math.hypot(2, 3, 6) === 7");
    }

    #[test]
    fn e2e_math_hypot_large_finite_values() {
        assert_eval_true(
            "var r = Math.hypot(1e308, 1e308); r !== Infinity && r > 1.4e308 && r < 1.5e308",
        );
    }

    #[test]
    fn e2e_math_clz32_negative_one() {
        assert_eval_true("Math.clz32(-1) === 0");
    }

    #[test]
    fn e2e_math_clz32_nan_is_32() {
        assert_eval_true("Math.clz32(NaN) === 32");
    }

    #[test]
    fn e2e_math_clz32_fractional_operand() {
        assert_eval_true("Math.clz32(3.5) === 30");
    }

    #[test]
    fn e2e_math_fround_negative_zero_preserved() {
        assert_eval_true("1 / Math.fround(-0) === -Infinity");
    }

    #[test]
    fn e2e_math_fround_nan() {
        assert_eval_true("Number.isNaN(Math.fround(NaN))");
    }

    #[test]
    fn e2e_math_fround_infinity() {
        assert_eval_true("Math.fround(Infinity) === Infinity");
    }

    #[test]
    fn e2e_math_trunc_negative_zero_preserved() {
        assert_eval_true("1 / Math.trunc(-0.9) === -Infinity");
    }

    #[test]
    fn e2e_math_trunc_negative_infinity() {
        assert_eval_true("Math.trunc(-Infinity) === -Infinity");
    }

    #[test]
    fn e2e_math_imul_fractional_operands() {
        assert_eval_true("Math.imul(3.9, 2.1) === 6");
    }

    #[test]
    fn e2e_math_imul_large_wrap() {
        assert_eval_true("Math.imul(0xffffffff, 5) === -5");
    }

    #[test]
    fn e2e_math_imul_undefined_is_zero() {
        assert_eval_true("Math.imul(undefined, 7) === 0");
    }

    #[test]
    fn e2e_math_max_no_args_is_negative_infinity() {
        assert_eval_true("Math.max() === -Infinity");
    }

    #[test]
    fn e2e_math_max_nan_propagates() {
        assert_eval_true("Number.isNaN(Math.max(1, NaN, 3))");
    }

    #[test]
    fn e2e_math_max_prefers_positive_zero() {
        assert_eval_true("1 / Math.max(-0, 0) === Infinity");
    }

    #[test]
    fn e2e_math_min_no_args_is_infinity() {
        assert_eval_true("Math.min() === Infinity");
    }

    #[test]
    fn e2e_math_min_nan_propagates() {
        assert_eval_true("Number.isNaN(Math.min(1, NaN, 3))");
    }

    #[test]
    fn e2e_math_min_preserves_negative_zero() {
        assert_eval_true("1 / Math.min(-0, 0) === -Infinity");
    }

    #[test]
    fn e2e_math_symbol_to_string_tag() {
        assert_eval_true("Math[Symbol.toStringTag] === 'Math'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_math_object_to_string_uses_math_tag() {
        let result = global_eval("Object.prototype.toString.call(Math)").unwrap();
        assert_eq!(result, JsValue::String("[object Math]".into()));
    }

    #[test]
    fn e2e_math_to_string_tag_descriptor() {
        assert_eval_true(
            "var d = Object.getOwnPropertyDescriptor(Math, Symbol.toStringTag); \
             d.value === 'Math' && d.writable === false && d.enumerable === false && d.configurable === true",
        );
    }

    // ── Number.prototype.valueOf / toPrecision / toExponential tests ────

    /// `(42).valueOf()` returns 42.
    #[test]
    fn e2e_number_value_of() {
        let result = global_eval("(42).valueOf()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `(3.14).valueOf()` returns 3.14.
    #[test]
    fn e2e_number_value_of_float() {
        let result = global_eval("(3.14).valueOf()").unwrap();
        assert_eq!(result, JsValue::HeapNumber(3.14));
    }

    /// `(123.456).toPrecision(5)` returns a string representation.
    #[test]
    fn e2e_number_to_precision_basic() {
        let result = global_eval("(123.456).toPrecision(5)").unwrap();
        // Engine returns a string (exact format depends on implementation)
        assert!(matches!(result, JsValue::String(_)));
    }

    /// `(0.00123).toPrecision(2)` returns a string representation.
    #[test]
    fn e2e_number_to_precision_small() {
        let result = global_eval("(0.00123).toPrecision(2)").unwrap();
        assert!(matches!(result, JsValue::String(_)));
    }

    /// `toPrecision()` with no argument returns toString.
    #[test]
    fn e2e_number_to_precision_no_arg() {
        let result = global_eval("(3.14).toPrecision()").unwrap();
        assert_eq!(result, JsValue::String("3.14".into()));
    }

    /// `toPrecision(0)` throws RangeError.
    #[test]
    fn e2e_number_to_precision_range_error() {
        let result = global_eval("(1).toPrecision(0)");
        assert!(result.is_err());
    }

    /// `(12345).toExponential(2)` returns exponential notation.
    #[test]
    fn e2e_number_to_exponential_basic() {
        let result = global_eval("(12345).toExponential(2)").unwrap();
        if let JsValue::String(s) = &result {
            assert!(
                s.contains('e') || s.contains('E'),
                "expected exponential notation, got {s}"
            );
        } else {
            panic!("expected String, got {result:?}");
        }
    }

    /// `(0).toExponential()` returns exponential notation for zero.
    #[test]
    fn e2e_number_to_exponential_zero() {
        let result = global_eval("(0).toExponential()").unwrap();
        if let JsValue::String(s) = &result {
            assert!(
                s.contains('e') || s.contains('E'),
                "expected exponential notation, got {s}"
            );
        } else {
            panic!("expected String, got {result:?}");
        }
    }

    // ── Primitive auto-boxing and wrapper object tests ───────────────────

    #[test]
    fn e2e_string_primitive_to_upper_case_autoboxes() {
        assert_eval_true("'hello'.toUpperCase() === 'HELLO'");
    }

    #[test]
    fn e2e_string_primitive_to_lower_case_autoboxes() {
        assert_eval_true("'HELLO'.toLowerCase() === 'hello'");
    }

    #[test]
    fn e2e_string_primitive_char_at_autoboxes() {
        assert_eval_true("'hello'.charAt(1) === 'e'");
    }

    #[test]
    fn e2e_string_prototype_call_on_primitive() {
        assert_eval_true("String.prototype.toUpperCase.call('boxed') === 'BOXED'");
    }

    #[test]
    fn e2e_string_value_of_call_on_primitive() {
        assert_eval_true("String.prototype.valueOf.call('abc') === 'abc'");
    }

    #[test]
    fn e2e_string_wrapper_typeof_is_object() {
        assert_eval_true("typeof new String('abc') === 'object'");
    }

    #[test]
    fn e2e_string_primitive_typeof_is_string() {
        assert_eval_true("typeof 'abc' === 'string'");
    }

    #[test]
    fn e2e_string_wrapper_value_of_returns_primitive() {
        assert_eval_true("new String('abc').valueOf() === 'abc'");
    }

    #[test]
    fn e2e_string_wrapper_to_string_returns_primitive_text() {
        assert_eval_true("new String('abc').toString() === 'abc'");
    }

    #[test]
    fn e2e_string_wrapper_is_instance_of_string() {
        assert_eval_true("new String('abc') instanceof String");
    }

    #[test]
    fn e2e_object_string_wrapper_typeof_is_object() {
        assert_eval_true("typeof Object('hello') === 'object'");
    }

    #[test]
    fn e2e_object_string_wrapper_value_of_returns_primitive() {
        assert_eval_true("Object('hello').valueOf() === 'hello'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_string_wrapper_is_instance_of_string() {
        assert_eval_true("Object('hello') instanceof String");
    }

    #[test]
    fn e2e_number_primitive_to_string_hex_autoboxes() {
        assert_eval_true("(42).toString(16) === '2a'");
    }

    #[test]
    fn e2e_number_primitive_to_string_default_autoboxes() {
        assert_eval_true("(42).toString() === '42'");
    }

    #[test]
    fn e2e_number_prototype_to_string_call_on_primitive() {
        assert_eval_true("Number.prototype.toString.call(255, 16) === 'ff'");
    }

    #[test]
    fn e2e_number_prototype_to_string_call_on_wrapper() {
        assert_eval_true("Number.prototype.toString.call(new Number(255), 16) === 'ff'");
    }

    #[test]
    fn e2e_number_wrapper_typeof_is_object() {
        assert_eval_true("typeof new Number(42) === 'object'");
    }

    #[test]
    fn e2e_number_wrapper_value_of_returns_primitive() {
        assert_eval_true("new Number(42).valueOf() === 42");
    }

    #[test]
    fn e2e_number_wrapper_is_instance_of_number() {
        assert_eval_true("new Number(42) instanceof Number");
    }

    #[test]
    fn e2e_object_number_wrapper_typeof_is_object() {
        assert_eval_true("typeof Object(42) === 'object'");
    }

    #[test]
    fn e2e_object_number_wrapper_value_of_returns_primitive() {
        assert_eval_true("Object(42).valueOf() === 42");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_number_wrapper_is_instance_of_number() {
        assert_eval_true("Object(42) instanceof Number");
    }

    #[test]
    fn e2e_boolean_primitive_to_string_true_autoboxes() {
        assert_eval_true("true.toString() === 'true'");
    }

    #[test]
    fn e2e_boolean_primitive_to_string_false_autoboxes() {
        assert_eval_true("false.toString() === 'false'");
    }

    #[test]
    fn e2e_boolean_prototype_to_string_call_on_primitive() {
        assert_eval_true("Boolean.prototype.toString.call(true) === 'true'");
    }

    #[test]
    fn e2e_boolean_prototype_to_string_call_on_wrapper() {
        assert_eval_true("Boolean.prototype.toString.call(new Boolean(true)) === 'true'");
    }

    #[test]
    fn e2e_boolean_wrapper_typeof_is_object() {
        assert_eval_true("typeof new Boolean(false) === 'object'");
    }

    #[test]
    fn e2e_boolean_wrapper_value_of_returns_primitive() {
        assert_eval_true("new Boolean(false).valueOf() === false");
    }

    #[test]
    fn e2e_boolean_wrapper_is_truthy() {
        assert_eval_true("var hit = false; if (new Boolean(false)) { hit = true; } hit");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_boolean_wrapper_is_instance_of_boolean() {
        assert_eval_true("Object(true) instanceof Boolean");
    }

    #[test]
    fn e2e_object_boolean_wrapper_value_of_returns_primitive() {
        assert_eval_true("Object(false).valueOf() === false");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_symbol_primitive_to_string_autoboxes() {
        assert_eval_true("Symbol('s').toString() === 'Symbol(s)'");
    }

    #[test]
    fn e2e_symbol_prototype_to_string_call_on_primitive() {
        assert_eval_true("Symbol.prototype.toString.call(Symbol('s')) === 'Symbol(s)'");
    }

    #[test]
    fn e2e_object_symbol_wrapper_value_of_returns_same_symbol() {
        assert_eval_true("var s = Symbol('s'); Object(s).valueOf() === s");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_symbol_wrapper_is_instance_of_symbol() {
        assert_eval_true("var s = Symbol('s'); Object(s) instanceof Symbol");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_prototype_to_string_tags_string_primitive() {
        assert_eval_true("Object.prototype.toString.call('x') === '[object String]'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_prototype_to_string_tags_number_primitive() {
        assert_eval_true("Object.prototype.toString.call(42) === '[object Number]'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_prototype_to_string_tags_boolean_primitive() {
        assert_eval_true("Object.prototype.toString.call(true) === '[object Boolean]'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_prototype_to_string_tags_string_wrapper() {
        assert_eval_true("Object.prototype.toString.call(new String('x')) === '[object String]'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_prototype_to_string_tags_number_wrapper() {
        assert_eval_true("Object.prototype.toString.call(new Number(42)) === '[object Number]'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_prototype_to_string_tags_boolean_wrapper() {
        assert_eval_true(
            "Object.prototype.toString.call(new Boolean(false)) === '[object Boolean]'",
        );
    }

    #[test]
    fn e2e_string_wrapper_exposes_length() {
        assert_eval_true("new String('hello').length === 5");
    }

    #[test]
    fn e2e_string_wrapper_exposes_indexed_chars() {
        assert_eval_true("new String('hello')[1] === 'e'");
    }

    #[test]
    fn e2e_null_to_string_throws_type_error() {
        assert_eval_type_error("null.toString()");
    }

    #[test]
    fn e2e_undefined_to_string_throws_type_error() {
        assert_eval_type_error("undefined.toString()");
    }

    // ── String.prototype.replaceAll edge cases ──────────────────────────

    /// `replaceAll` replaces all occurrences of a plain string.
    #[test]
    fn test_string_replace_all_basic() {
        let result = global_eval("'aabbcc'.replaceAll('b', 'x')").unwrap();
        assert_eq!(result, JsValue::String("aaxxcc".into()));
    }

    /// `replaceAll` with empty search string inserts between every char.
    #[test]
    fn test_string_replace_all_empty_search() {
        let result = global_eval("'ab'.replaceAll('', '-').length").unwrap();
        // 'ab'.replaceAll('', '-') → '-a-b-' (length 5)
        assert_eq!(result, JsValue::Smi(5));
    }

    // ── String.prototype.at edge cases ──────────────────────────────────

    /// `String.prototype.at` with negative index wraps from end.
    #[test]
    fn test_string_at_negative() {
        let result = global_eval("'abcde'.at(-2)").unwrap();
        assert_eq!(result, JsValue::String("d".into()));
    }

    /// `String.prototype.at` with 0 returns first char.
    #[test]
    fn test_string_at_zero() {
        let result = global_eval("'hello'.at(0)").unwrap();
        assert_eq!(result, JsValue::String("h".into()));
    }

    // ── Conformance: startsWith/endsWith reject RegExp ──────────────────

    /// `String.prototype.startsWith` must throw TypeError when given a RegExp.
    #[test]
    fn e2e_starts_with_rejects_regexp() {
        let result = global_eval("'foobar'.startsWith(/foo/)");
        assert!(result.is_err(), "Expected TypeError for RegExp argument");
    }

    /// `String.prototype.endsWith` must throw TypeError when given a RegExp.
    #[test]
    fn e2e_ends_with_rejects_regexp() {
        let result = global_eval("'foobar'.endsWith(/bar/)");
        assert!(result.is_err(), "Expected TypeError for RegExp argument");
    }

    /// `String.prototype.startsWith` still works with plain strings.
    #[test]
    fn e2e_starts_with_plain_string() {
        let result = global_eval("'hello world'.startsWith('hello')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `String.prototype.endsWith` still works with plain strings.
    #[test]
    fn e2e_ends_with_plain_string() {
        let result = global_eval("'hello world'.endsWith('world')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Conformance: trim* whitespace handling ──────────────────────────

    /// `String.prototype.trim` strips tabs and newlines.
    #[test]
    fn e2e_trim_whitespace_chars() {
        let result = global_eval(r#"'\t\n\r hello \t\n\r '.trim()"#).unwrap();
        assert_eq!(result, JsValue::String("hello".into()));
    }

    /// `String.prototype.trimStart` strips leading whitespace only.
    #[test]
    fn e2e_trim_start_basic() {
        let result = global_eval("'  hello  '.trimStart()").unwrap();
        assert_eq!(result, JsValue::String("hello  ".into()));
    }

    /// `String.prototype.trimEnd` strips trailing whitespace only.
    #[test]
    fn e2e_trim_end_basic() {
        let result = global_eval("'  hello  '.trimEnd()").unwrap();
        assert_eq!(result, JsValue::String("  hello".into()));
    }

    // ── Conformance: Array.prototype.toReversed ─────────────────────────

    /// `toReversed` returns a new reversed array without mutating original.
    #[test]
    fn e2e_array_to_reversed() {
        let result =
            global_eval("var a = [1,2,3]; var b = a.toReversed(); a[0] * 10 + b[0]").unwrap();
        // a[0] is still 1, b[0] is 3 → 1*10+3 = 13
        assert_eq!(result, JsValue::Smi(13));
    }

    // ── Conformance: Array.prototype.toSorted ───────────────────────────

    /// `toSorted` returns a new sorted array without mutating original.
    #[test]
    fn e2e_array_to_sorted() {
        let result =
            global_eval("var a = [3,1,2]; var b = a.toSorted(); a[0] * 10 + b[0]").unwrap();
        // a[0] is still 3, b[0] is 1 → 3*10+1 = 31
        assert_eq!(result, JsValue::Smi(31));
    }

    // ── Conformance: Array.prototype.toSpliced ──────────────────────────

    /// `toSpliced` returns a new array with splice applied.
    #[test]
    fn e2e_array_to_spliced() {
        let result = global_eval("[1,2,3,4].toSpliced(1, 2, 99).length").unwrap();
        // [1, 99, 4] → length 3
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `toSpliced` does not mutate the original array.
    #[test]
    fn e2e_array_to_spliced_no_mutation() {
        let result = global_eval("var a = [1,2,3]; a.toSpliced(0, 1); a.length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Conformance: Array.prototype.with ────────────────────────────────

    /// `with` throws RangeError for out-of-range index.
    #[test]
    fn e2e_array_with_out_of_range() {
        let result = global_eval("[1,2,3].with(5, 99)");
        assert!(
            result.is_err(),
            "Expected RangeError for out-of-range index"
        );
    }

    // ── Conformance: Array.prototype.findLast / findLastIndex ───────────

    /// `findLast` returns the last matching element.
    #[test]
    fn e2e_array_find_last() {
        let result =
            global_eval("[1,2,3,4].findLast(function(x) { return x % 2 === 0; })").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `findLastIndex` returns the index of the last match.
    #[test]
    fn e2e_array_find_last_index() {
        let result =
            global_eval("[1,2,3,4].findLastIndex(function(x) { return x % 2 === 0; })").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `findLast` returns undefined when no match.
    #[test]
    fn e2e_array_find_last_no_match() {
        let result = global_eval("[1,2,3].findLast(function(x) { return x > 10; })").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `findLastIndex` returns -1 when no match.
    #[test]
    fn e2e_array_find_last_index_no_match() {
        let result = global_eval("[1,2,3].findLastIndex(function(x) { return x > 10; })").unwrap();
        assert_eq!(result, JsValue::Smi(-1));
    }

    // ── Conformance: Array.prototype.flat depth / Infinity ──────────────

    /// `flat(Infinity)` fully flattens nested arrays.
    #[test]
    fn e2e_array_flat_infinity() {
        let result = global_eval("[1,[2,[3,[4]]]].flat(Infinity).length").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `flat()` with no args uses depth 1.
    #[test]
    fn e2e_array_flat_default_depth() {
        let result = global_eval("[1,[2,[3]]].flat().length").unwrap();
        // depth 1: [1, 2, [3]] → length 3
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Conformance: Array.prototype.flatMap ────────────────────────────

    /// `flatMap` maps and flattens exactly one level.
    #[test]
    fn e2e_array_flatmap_one_level() {
        let result =
            global_eval("[1,2].flatMap(function(x) { return [[x, x*2]]; }).length").unwrap();
        // [[1,2],[2,4]] after flatMap → [1,2], [2,4] are kept as arrays → length 2
        assert_eq!(result, JsValue::Smi(2));
    }

    // ── Conformance: Map.prototype.forEach args ─────────────────────────

    /// `Map.prototype.forEach` callback receives `(value, key, map)`.
    /// We verify the third argument is the map by checking it has a `get`
    /// method (i.e., it is the Map instance).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_foreach_three_args() {
        // The callback checks that three arguments are received.
        let result = global_eval(
            "var count = 0; var m = new Map([['a', 1]]); \
             m.forEach(function(v, k, map) { if (typeof map.get === 'function') count = 3; }); count",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Map.prototype.forEach` calls with correct (value, key) order.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_foreach_value_key_order() {
        let result = global_eval(
            "var out = ''; var m = new Map([['x', 42]]); \
             m.forEach(function(v, k) { out = k + ':' + v; }); out",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("x:42".into()));
    }

    // ── Conformance: Set.prototype.forEach args ─────────────────────────

    /// `Set.prototype.forEach` callback receives `(value, value, set)`.
    /// We verify the third argument is the set by checking it has an `add`
    /// method.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_foreach_three_args() {
        let result = global_eval(
            "var count = 0; var s = new Set([10]); \
             s.forEach(function(v1, v2, set) { if (typeof set.add === 'function') count = 3; }); count",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Set.prototype.forEach` passes (value, value) as first two args.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_foreach_value_value() {
        let result = global_eval(
            "var ok = true; var s = new Set([5]); \
             s.forEach(function(v1, v2) { if (v1 !== v2) ok = false; }); ok",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Conformance: String.raw ─────────────────────────────────────────

    /// `String.raw` with template-like object works correctly.
    #[test]
    fn e2e_string_raw_interleaves() {
        let result = global_eval("String.raw({ raw: ['a', 'b', 'c'] }, 1, 2)").unwrap();
        assert_eq!(result, JsValue::String("a1b2c".into()));
    }

    // ── Conformance: Promise.race / allSettled / any exist ───────────────

    /// `Promise.race` is a function.
    #[test]
    fn e2e_promise_race_exists() {
        let result = global_eval("typeof Promise.race").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `Promise.allSettled` is a function.
    #[test]
    fn e2e_promise_all_settled_exists() {
        let result = global_eval("typeof Promise.allSettled").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `Promise.any` is a function.
    #[test]
    fn e2e_promise_any_exists() {
        let result = global_eval("typeof Promise.any").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    // ── Promise.any conformance ─────────────────────────────────────────

    /// `Promise.any` resolves with the first fulfilled value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_first_fulfilled_v2() {
        let result = global_eval(
            r#"
            var result;
            Promise.any([
                Promise.reject(0),
                Promise.resolve(42),
                Promise.resolve(99)
            ]).then(function(v) { result = v; });
            result
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Promise.any` rejects with AggregateError when all reject.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_all_reject_v2() {
        let result = global_eval(
            r#"
            var name;
            Promise.any([
                Promise.reject(1),
                Promise.reject(2)
            ]).catch(function(e) { name = e.name; });
            name
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("AggregateError".into()));
    }

    /// `Promise.any` with empty array rejects with AggregateError.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_empty_rejects_v2() {
        let result = global_eval(
            r#"
            var name;
            Promise.any([]).catch(function(e) { name = e.name; });
            name
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("AggregateError".into()));
    }

    /// `Promise.any` AggregateError has correct message.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_aggregate_error_message() {
        let result = global_eval(
            r#"
            var msg;
            Promise.any([Promise.reject(1)]).catch(function(e) { msg = e.message; });
            msg
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("All promises were rejected".into()));
    }

    // ── Promise.race conformance ────────────────────────────────────────

    /// `Promise.race` resolves with the first settled (fulfilled).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_first_fulfilled() {
        let result = global_eval(
            r#"
            var result;
            Promise.race([
                Promise.resolve(10),
                Promise.resolve(20)
            ]).then(function(v) { result = v; });
            result
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    /// `Promise.race` rejects with first rejection when it settles first.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_first_rejected() {
        let result = global_eval(
            r#"
            var reason;
            Promise.race([
                Promise.reject("err"),
                Promise.resolve(1)
            ]).catch(function(r) { reason = r; });
            reason
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("err".into()));
    }

    // ── Promise.all edge cases ──────────────────────────────────────────

    /// `Promise.all` with non-promise values treats them as resolved.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_non_promise_values() {
        let result = global_eval(
            r#"
            var result;
            Promise.all([1, 2, 3]).then(function(arr) { result = arr.length; });
            result
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Promise.all` with empty array resolves with empty array.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_empty_resolves() {
        let result = global_eval(
            r#"
            var result;
            Promise.all([]).then(function(arr) { result = arr.length; });
            result
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    // ── Promise.prototype.finally conformance ───────────────────────────

    /// `Promise.prototype.finally` runs on resolve and passes through value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_resolve_passthrough() {
        let result = global_eval(
            r#"
            var finallyRan = false;
            var result;
            Promise.resolve(42).finally(function() { finallyRan = true; }).then(function(v) { result = v; });
            finallyRan && result === 42
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Promise.prototype.finally` runs on reject and passes through reason.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_reject_passthrough() {
        let result = global_eval(
            r#"
            var finallyRan = false;
            var reason;
            Promise.reject("err").finally(function() { finallyRan = true; }).catch(function(r) { reason = r; });
            finallyRan && reason === "err"
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Promise constructor edge cases ──────────────────────────────────

    /// Calling resolve multiple times: only first counts.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_constructor_resolve_once() {
        let result = global_eval(
            r#"
            var result;
            new Promise(function(resolve, reject) {
                resolve(1);
                resolve(2);
            }).then(function(v) { result = v; });
            result
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// Calling resolve then reject: only first (resolve) counts.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_constructor_resolve_then_reject_v2() {
        let result = global_eval(
            r#"
            var result;
            var caught = false;
            new Promise(function(resolve, reject) {
                resolve(1);
                reject("err");
            }).then(function(v) { result = v; }).catch(function() { caught = true; });
            result === 1 && !caught
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Promise edge-case regression tests ───────────────────────────────

    #[test]
    fn e2e_promise_with_resolvers_exists() {
        assert_eval_true("typeof Promise.withResolvers === 'function'");
    }

    #[test]
    fn e2e_promise_prototype_exists() {
        assert_eval_true("typeof Promise.prototype.then === 'function'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolved_prototype_is_promise_prototype() {
        assert_eval_true("Object.getPrototypeOf(Promise.resolve(1)) === Promise.prototype");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_with_resolvers_promise_has_default_prototype() {
        assert_eval_true(
            "Object.getPrototypeOf(Promise.withResolvers().promise) === Promise.prototype",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_with_resolvers_resolve_fulfills_chain() {
        assert_eval_true(
            "var out = 0; var wr = Promise.withResolvers(); \
             wr.promise.then(function(v) { out = v; }); \
             wr.resolve(7); \
             out === 7",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_with_resolvers_reject_rejects_chain() {
        assert_eval_true(
            "var out = ''; var wr = Promise.withResolvers(); \
             wr.promise.catch(function(r) { out = r; }); \
             wr.reject('boom'); \
             out === 'boom'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_with_resolvers_first_call_wins() {
        assert_eval_true(
            "var out = ''; var wr = Promise.withResolvers(); \
             wr.promise.then(function(v) { out = 'ok:' + v; }, function(r) { out = 'err:' + r; }); \
             wr.resolve(1); \
             wr.reject('late'); \
             wr.resolve(2); \
             out === 'ok:1'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_with_resolvers_resolve_assimilates_thenable() {
        assert_eval_true(
            "var out = 0; var wr = Promise.withResolvers(); \
             wr.promise.then(function(v) { out = v; }); \
             wr.resolve({ then: function(resolve) { resolve(11); } }); \
             out === 11",
        );
    }

    #[test]
    fn e2e_promise_with_resolvers_functions_are_distinct() {
        assert_eval_true(
            "var wr = Promise.withResolvers(); \
             typeof wr.resolve === 'function' && typeof wr.reject === 'function' && wr.resolve !== wr.reject",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_empty_errors_array() {
        assert_eval_true(
            "var len = -1; Promise.any([]).catch(function(e) { len = e.errors.length; }); len === 0",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_all_rejected_errors_order() {
        assert_eval_true(
            "var out = ''; \
             Promise.any([Promise.reject('a'), Promise.reject('b'), Promise.reject('c')])\
               .catch(function(e) { out = e.errors.join(','); }); \
             out === 'a,b,c'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_all_rejected_retains_values() {
        assert_eval_true(
            "var out = ''; \
             Promise.any([Promise.reject(1), Promise.reject(false), Promise.reject('x')])\
               .catch(function(e) { out = String(e.errors[0]) + '|' + String(e.errors[1]) + '|' + e.errors[2]; }); \
             out === '1|false|x'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_non_promise_value_fulfills() {
        assert_eval_true(
            "var out = 0; Promise.any([Promise.reject('no'), 9]).then(function(v) { out = v; }); out === 9",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_any_first_fulfillment_wins_over_later_rejections() {
        assert_eval_true(
            "var out = ''; \
             Promise.any([Promise.reject('a'), Promise.resolve('win'), Promise.reject('b')])\
               .then(function(v) { out = v; }, function() { out = 'lose'; }); \
             out === 'win'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_mixed_result_shape() {
        assert_eval_true(
            "var ok = false; \
             Promise.allSettled([Promise.resolve(1), Promise.reject('x')]).then(function(results) { \
               ok = results[0].status === 'fulfilled' && results[0].value === 1 && !('reason' in results[0]) && \
                    results[1].status === 'rejected' && results[1].reason === 'x' && !('value' in results[1]); \
             }); \
             ok",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_fulfilled_result_has_no_reason() {
        assert_eval_true(
            "var ok = false; \
             Promise.allSettled([Promise.resolve(2)]).then(function(results) { ok = !('reason' in results[0]); }); \
             ok",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_rejected_result_has_no_value() {
        assert_eval_true(
            "var ok = false; \
             Promise.allSettled([Promise.reject('no')]).then(function(results) { ok = !('value' in results[0]); }); \
             ok",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_wraps_non_promises() {
        assert_eval_true(
            "var ok = false; \
             Promise.allSettled([1, Promise.reject('x'), true]).then(function(results) { \
               ok = results[0].value === 1 && results[1].reason === 'x' && results[2].value === true; \
             }); \
             ok",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_settled_empty_resolves_array() {
        assert_eval_true(
            "var len = -1; Promise.allSettled([]).then(function(results) { len = results.length; }); len === 0",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_empty_remains_pending() {
        assert_eval_true(
            "var settled = false; \
             Promise.race([]).then(function() { settled = true; }, function() { settled = true; }); \
             settled === false",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_first_rejection_wins() {
        assert_eval_true(
            "var out = ''; \
             Promise.race([Promise.reject('boom'), Promise.resolve(1)]).catch(function(r) { out = r; }); \
             out === 'boom'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_plain_value_wins() {
        assert_eval_true(
            "var out = 0; Promise.race([5, Promise.resolve(9)]).then(function(v) { out = v; }); out === 5",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_race_deferred_first_settlement_wins() {
        assert_eval_true(
            "var out = ''; \
             var a = Promise.withResolvers(); \
             var b = Promise.withResolvers(); \
             Promise.race([a.promise, b.promise]).then(function(v) { out = v; }, function(r) { out = r; }); \
             b.resolve('second'); \
             a.resolve('first'); \
             out === 'second'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_empty_resolves_array_value() {
        assert_eval_true(
            "var ok = false; Promise.all([]).then(function(results) { ok = Array.isArray(results) && results.length === 0; }); ok",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_wraps_non_promises_exact_values() {
        assert_eval_true(
            "var out = ''; \
             Promise.all([1, 'two', false]).then(function(results) { out = results.join('|'); }); \
             out === '1|two|false'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_assimilates_thenable_values() {
        assert_eval_true(
            "var out = 0; \
             Promise.all([{ then: function(resolve) { resolve(4); } }, Promise.resolve(5)])\
               .then(function(results) { out = results[0] + results[1]; }); \
             out === 9",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_all_rejects_on_first_rejection_even_with_plain_values() {
        assert_eval_true(
            "var out = ''; \
             Promise.all([1, Promise.reject('bad'), 3]).catch(function(reason) { out = reason; }); \
             out === 'bad'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_thenable_fulfills_value() {
        assert_eval_true(
            "var out = 0; Promise.resolve({ then: function(resolve) { resolve(12); } }).then(function(v) { out = v; }); out === 12",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_thenable_rejects_reason() {
        assert_eval_true(
            "var out = ''; Promise.resolve({ then: function(resolve, reject) { reject('no'); } }).catch(function(r) { out = r; }); out === 'no'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_thenable_getter_throw_rejects() {
        assert_eval_true(
            "var out = ''; \
             var obj = {}; \
             Object.defineProperty(obj, 'then', { get: function() { throw 'getter'; } }); \
             Promise.resolve(obj).catch(function(r) { out = r; }); \
             out === 'getter'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_resolve_plain_object_passthrough() {
        assert_eval_true(
            "var obj = { x: 3 }; var out = 0; Promise.resolve(obj).then(function(v) { out = v.x; }); out === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_reject_keeps_promise_reason() {
        assert_eval_true(
            "var inner = Promise.resolve(1); var same = false; \
             Promise.reject(inner).catch(function(reason) { same = reason === inner; }); \
             same",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_subclass_instance_uses_subclass_prototype() {
        assert_eval_true(
            "class SubPromise extends Promise {} \
             var p = new SubPromise(function(resolve) { resolve(1); }); \
             p instanceof SubPromise && Object.getPrototypeOf(p) === SubPromise.prototype",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_respects_default_species_subclass() {
        assert_eval_true(
            "class SubPromise extends Promise {} \
             var p = new SubPromise(function(resolve) { resolve(1); }); \
             var chained = p.then(function(v) { return v + 1; }); \
             chained instanceof SubPromise && Object.getPrototypeOf(chained) === SubPromise.prototype",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_catch_respects_default_species_subclass() {
        assert_eval_true(
            "class SubPromise extends Promise {} \
             var p = new SubPromise(function(resolve, reject) { reject('x'); }); \
             var chained = p.catch(function(reason) { return reason; }); \
             chained instanceof SubPromise && Object.getPrototypeOf(chained) === SubPromise.prototype",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_respects_default_species_subclass() {
        assert_eval_true(
            "class SubPromise extends Promise {} \
             var p = new SubPromise(function(resolve) { resolve(1); }); \
             var chained = p.finally(function() {}); \
             chained instanceof SubPromise && Object.getPrototypeOf(chained) === SubPromise.prototype",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_then_respects_species_override_to_promise() {
        assert_eval_true(
            "class SubPromise extends Promise { static get [Symbol.species]() { return Promise; } } \
             var p = new SubPromise(function(resolve) { resolve(1); }); \
             var chained = p.then(function(v) { return v; }); \
             Object.getPrototypeOf(chained) === Promise.prototype && Object.getPrototypeOf(chained) !== SubPromise.prototype",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_catch_respects_species_override_to_other_subclass() {
        assert_eval_true(
            "class OtherPromise extends Promise {} \
             class SubPromise extends Promise { static get [Symbol.species]() { return OtherPromise; } } \
             var p = new SubPromise(function(resolve, reject) { reject('x'); }); \
             var chained = p.catch(function(reason) { return reason; }); \
             chained instanceof OtherPromise && Object.getPrototypeOf(chained) === OtherPromise.prototype",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_finally_respects_null_species_fallback() {
        assert_eval_true(
            "class SubPromise extends Promise { static get [Symbol.species]() { return null; } } \
             var p = new SubPromise(function(resolve) { resolve(1); }); \
             var chained = p.finally(function() {}); \
             Object.getPrototypeOf(chained) === Promise.prototype",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_promise_subclass_chain_result_still_settles() {
        assert_eval_true(
            "class SubPromise extends Promise {} \
              var out = 0; \
              new SubPromise(function(resolve) { resolve(2); })\
                .then(function(v) { return v * 5; })\
                .then(function(v) { out = v; }); \
              out === 10",
        );
    }

    macro_rules! promise_iterable_edge_test {
        ($(#[$meta:meta])* $name:ident, $script:expr) => {
            $(#[$meta])*
            #[test]
            fn $name() {
                assert_eval_true($script);
            }
        };
    }

    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_set_iterable_mixed,
        "var ok = false; Promise.allSettled(new Set([Promise.resolve(1), Promise.reject('x')]))\
         .then(function(results) { ok = results.length === 2 && results[0].value === 1 && results[1].reason === 'x'; }); ok"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_generator_iterable,
        "function* values() { yield Promise.resolve('a'); yield Promise.reject('b'); } \
         var out = ''; Promise.allSettled(values()).then(function(results) { out = results[0].status + '|' + results[1].reason; }); out === 'fulfilled|b'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_string_iterable,
        "var out = ''; Promise.allSettled('ok').then(function(results) { out = results[0].value + results[1].value; }); out === 'ok'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_custom_iterator_iterable,
        "var iterable = { [Symbol.iterator]: function() { var i = 0; return { next: function() { \
             i += 1; if (i === 1) return { value: Promise.resolve('x'), done: false }; \
             if (i === 2) return { value: Promise.reject('y'), done: false }; \
             return { done: true }; } }; } }; \
         var out = ''; Promise.allSettled(iterable).then(function(results) { out = results[0].value + '|' + results[1].reason; }); out === 'x|y'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_empty_custom_iterable,
        "var iterable = { [Symbol.iterator]: function() { return { next: function() { return { done: true }; } }; } }; \
         var len = -1; Promise.allSettled(iterable).then(function(results) { len = results.length; }); len === 0"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_preserves_iterator_order,
        "function* values() { yield Promise.reject('first'); yield Promise.resolve('second'); yield 3; } \
         var out = ''; Promise.allSettled(values()).then(function(results) { out = results[0].reason + ',' + results[1].value + ',' + results[2].value; }); out === 'first,second,3'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_wraps_set_values,
        "var out = ''; Promise.allSettled(new Set([1, true, 'z'])).then(function(results) { out = results[0].value + '|' + results[1].value + '|' + results[2].value; }); out === '1|true|z'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_non_callable_resolve_rejects,
        "class BadPromise extends Promise {} BadPromise.resolve = 1; \
         var out = false; BadPromise.allSettled([1]).catch(function(e) { out = String(e).indexOf('callable') !== -1; }); out"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_default_subclass_result,
        "class SubPromise extends Promise {} var p = SubPromise.allSettled([1]); \
         p instanceof SubPromise && Object.getPrototypeOf(p) === SubPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_species_override_to_promise,
        "class SubPromise extends Promise { static get [Symbol.species]() { return Promise; } } \
         var p = SubPromise.allSettled([1]); Object.getPrototypeOf(p) === Promise.prototype && Object.getPrototypeOf(p) !== SubPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_species_override_to_other_subclass,
        "class OtherPromise extends Promise {} \
         class SubPromise extends Promise { static get [Symbol.species]() { return OtherPromise; } } \
         var p = SubPromise.allSettled([1]); p instanceof OtherPromise && Object.getPrototypeOf(p) === OtherPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_uses_symbol_iterator_once,
        "var hits = 0; var iterable = {}; iterable[Symbol.iterator] = function() { hits += 1; return [1][Symbol.iterator](); }; \
         var out = false; Promise.allSettled(iterable).then(function(results) { out = hits === 1 && results[0].value === 1; }); out"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_non_iterable_number_rejects,
        "var ok = false; Promise.allSettled(7).catch(function(e) { ok = String(e).indexOf('not iterable') !== -1; }); ok"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_all_settled_never_rejects_mixed_iterable,
        "var ok = false; Promise.allSettled(new Set([Promise.reject('a'), Promise.resolve('b')]))\
         .then(function(results) { ok = results[0].status === 'rejected' && results[1].status === 'fulfilled'; }, function() { ok = false; }); ok"
    );

    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_set_iterable_first_fulfilled,
        "var out = ''; Promise.any(new Set([Promise.reject('x'), Promise.resolve('y')])).then(function(value) { out = value; }); out === 'y'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_generator_iterable,
        "function* values() { yield Promise.reject('a'); yield Promise.resolve('win'); } \
         var out = ''; Promise.any(values()).then(function(value) { out = value; }); out === 'win'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_string_iterable,
        "var out = ''; Promise.any('go').then(function(value) { out = value; }); out === 'g'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_custom_iterator_iterable,
        "var iterable = { [Symbol.iterator]: function() { var i = 0; return { next: function() { \
             i += 1; if (i === 1) return { value: Promise.reject('no'), done: false }; \
             if (i === 2) return { value: Promise.resolve('yes'), done: false }; \
             return { done: true }; } }; } }; \
         var out = ''; Promise.any(iterable).then(function(value) { out = value; }); out === 'yes'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_empty_custom_iterable_rejects_aggregate,
        "var iterable = { [Symbol.iterator]: function() { return { next: function() { return { done: true }; } }; } }; \
         var ok = false; Promise.any(iterable).catch(function(e) { ok = e.name === 'AggregateError' && e.errors.length === 0; }); ok"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_errors_preserve_set_order,
        "var out = ''; Promise.any(new Set([Promise.reject('a'), Promise.reject('b'), Promise.reject('c')]))\
         .catch(function(e) { out = e.errors.join(','); }); out === 'a,b,c'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_wraps_set_values,
        "var out = ''; Promise.any(new Set([Promise.reject('x'), 5])).then(function(value) { out = String(value); }); out === '5'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_non_callable_resolve_rejects,
        "class BadPromise extends Promise {} BadPromise.resolve = 0; \
         var out = false; BadPromise.any([1]).catch(function(e) { out = String(e).indexOf('callable') !== -1; }); out"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_default_subclass_result,
        "class SubPromise extends Promise {} var p = SubPromise.any([1]); \
         p instanceof SubPromise && Object.getPrototypeOf(p) === SubPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_species_override_to_promise,
        "class SubPromise extends Promise { static get [Symbol.species]() { return Promise; } } \
         var p = SubPromise.any([1]); Object.getPrototypeOf(p) === Promise.prototype && Object.getPrototypeOf(p) !== SubPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_species_override_to_other_subclass,
        "class OtherPromise extends Promise {} \
         class SubPromise extends Promise { static get [Symbol.species]() { return OtherPromise; } } \
         var p = SubPromise.any([1]); p instanceof OtherPromise && Object.getPrototypeOf(p) === OtherPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_uses_symbol_iterator_once,
        "var hits = 0; var iterable = {}; iterable[Symbol.iterator] = function() { hits += 1; return [Promise.resolve(2)][Symbol.iterator](); }; \
         var out = 0; Promise.any(iterable).then(function(value) { out = value; }); hits === 1 && out === 2"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_all_rejections_from_generator_in_errors,
        "function* values() { yield Promise.reject('left'); yield Promise.reject('right'); } \
         var out = ''; Promise.any(values()).catch(function(e) { out = e.errors[0] + '|' + e.errors[1]; }); out === 'left|right'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_non_iterable_number_rejects,
        "var ok = false; Promise.any(9).catch(function(e) { ok = String(e).indexOf('not iterable') !== -1; }); ok"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_any_first_fulfillment_wins_in_custom_iterable,
        "var iterable = { [Symbol.iterator]: function() { var i = 0; return { next: function() { \
             i += 1; if (i === 1) return { value: Promise.reject('a'), done: false }; \
             if (i === 2) return { value: 11, done: false }; \
             if (i === 3) return { value: Promise.reject('b'), done: false }; \
             return { done: true }; } }; } }; \
         var out = 0; Promise.any(iterable).then(function(value) { out = value; }); out === 11"
    );

    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_set_iterable_first_resolved,
        "var out = ''; Promise.race(new Set([Promise.resolve('a'), Promise.resolve('b')])).then(function(value) { out = value; }); out === 'a'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_generator_iterable,
        "function* values() { yield Promise.resolve('first'); yield Promise.resolve('second'); } \
         var out = ''; Promise.race(values()).then(function(value) { out = value; }); out === 'first'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_string_iterable,
        "var out = ''; Promise.race('xy').then(function(value) { out = value; }); out === 'x'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_custom_iterator_iterable,
        "var iterable = { [Symbol.iterator]: function() { var i = 0; return { next: function() { \
             i += 1; if (i === 1) return { value: Promise.resolve('one'), done: false }; \
             if (i === 2) return { value: Promise.resolve('two'), done: false }; \
             return { done: true }; } }; } }; \
         var out = ''; Promise.race(iterable).then(function(value) { out = value; }); out === 'one'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_empty_custom_iterable_pending,
        "var iterable = { [Symbol.iterator]: function() { return { next: function() { return { done: true }; } }; } }; \
         var settled = false; Promise.race(iterable).then(function() { settled = true; }, function() { settled = true; }); settled === false"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_wraps_set_values,
        "var out = 0; Promise.race(new Set([3, Promise.resolve(4)])).then(function(value) { out = value; }); out === 3"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_non_callable_resolve_rejects,
        "class BadPromise extends Promise {} BadPromise.resolve = null; \
         var out = false; BadPromise.race([1]).catch(function(e) { out = String(e).indexOf('callable') !== -1; }); out"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_default_subclass_result,
        "class SubPromise extends Promise {} var p = SubPromise.race([1]); \
         p instanceof SubPromise && Object.getPrototypeOf(p) === SubPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_species_override_to_promise,
        "class SubPromise extends Promise { static get [Symbol.species]() { return Promise; } } \
         var p = SubPromise.race([1]); Object.getPrototypeOf(p) === Promise.prototype && Object.getPrototypeOf(p) !== SubPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_species_override_to_other_subclass,
        "class OtherPromise extends Promise {} \
         class SubPromise extends Promise { static get [Symbol.species]() { return OtherPromise; } } \
         var p = SubPromise.race([1]); p instanceof OtherPromise && Object.getPrototypeOf(p) === OtherPromise.prototype"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_uses_symbol_iterator_once,
        "var hits = 0; var iterable = {}; iterable[Symbol.iterator] = function() { hits += 1; return [7][Symbol.iterator](); }; \
         var out = 0; Promise.race(iterable).then(function(value) { out = value; }); hits === 1 && out === 7"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_first_rejection_from_custom_iterable,
        "var iterable = { [Symbol.iterator]: function() { var i = 0; return { next: function() { \
             i += 1; if (i === 1) return { value: Promise.reject('boom'), done: false }; \
             if (i === 2) return { value: Promise.resolve('later'), done: false }; \
             return { done: true }; } }; } }; \
         var out = ''; Promise.race(iterable).catch(function(reason) { out = reason; }); out === 'boom'"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_plain_first_value_from_generator,
        "function* values() { yield 12; yield Promise.resolve(99); } \
         var out = 0; Promise.race(values()).then(function(value) { out = value; }); out === 12"
    );
    promise_iterable_edge_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_promise_race_non_iterable_number_rejects,
        "var ok = false; Promise.race(5).catch(function(e) { ok = String(e).indexOf('not iterable') !== -1; }); ok"
    );

    // ── Missing builtins: Object.getOwnPropertyDescriptor extended ──────

    /// `Object.getOwnPropertyDescriptor` returns all four data descriptor fields.
    #[test]
    fn test_gopd_all_data_fields() {
        let result = global_eval(
            r#"
            var obj = { x: 42 };
            var d = Object.getOwnPropertyDescriptor(obj, "x");
            String(d.value) + "," + String(d.writable) + "," +
            String(d.enumerable) + "," + String(d.configurable)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("42,true,true,true".into()));
    }

    /// `Object.getOwnPropertyDescriptor` reflects defineProperty attributes.
    #[test]
    fn test_gopd_non_writable() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", { value: 1, writable: false, enumerable: false, configurable: true });
            var d = Object.getOwnPropertyDescriptor(obj, "x");
            String(d.writable) + "," + String(d.enumerable) + "," + String(d.configurable)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("false,false,true".into()));
    }

    /// `Object.getOwnPropertyDescriptor` returns accessor descriptor for get/set.
    #[test]
    fn test_gopd_accessor() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", { get: function() { return 1; }, enumerable: true, configurable: true });
            var d = Object.getOwnPropertyDescriptor(obj, "x");
            typeof d.get === "function" && d.value === undefined && d.enumerable === true
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.getOwnPropertyDescriptor` on array index.
    #[test]
    fn test_gopd_array_index() {
        let result = global_eval(
            r#"
            var d = Object.getOwnPropertyDescriptor([10, 20], "1");
            d.value
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(20));
    }

    /// `Object.getOwnPropertyDescriptor` on array length.
    #[test]
    fn test_gopd_array_length() {
        let result = global_eval(
            r#"
            var d = Object.getOwnPropertyDescriptor([1, 2, 3], "length");
            d.value
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.getOwnPropertyDescriptor` on string index.
    #[test]
    fn test_gopd_string_index() {
        let result = global_eval(
            r#"
            var d = Object.getOwnPropertyDescriptor("abc", "1");
            d.value
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("b".into()));
    }

    /// `Object.getOwnPropertyDescriptor` throws for null.
    #[test]
    fn test_gopd_null_throws() {
        let result = global_eval("Object.getOwnPropertyDescriptor(null, 'x')");
        assert!(result.is_err());
    }

    /// `Object.defineProperties` returns the target object.
    #[test]
    fn test_define_properties_returns_target() {
        let result = global_eval(
            r#"
            var obj = {};
            var ret = Object.defineProperties(obj, { a: { value: 10 } });
            ret.a
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    /// `Object.defineProperties` throws for non-object target.
    #[test]
    fn test_define_properties_non_object_throws() {
        let result = global_eval("Object.defineProperties(42, {})");
        assert!(result.is_err());
    }

    /// `Object.defineProperties` sets attribute flags correctly.
    #[test]
    fn test_define_properties_attributes() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.defineProperties(obj, {
                x: { value: 1, writable: false, enumerable: true, configurable: false }
            });
            var d = Object.getOwnPropertyDescriptor(obj, "x");
            String(d.writable) + "," + String(d.enumerable) + "," + String(d.configurable)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("false,true,false".into()));
    }

    /// `Object.getOwnPropertyNames` includes non-enumerable properties.
    #[test]
    fn test_gopn_includes_non_enumerable() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "hidden", { value: 1, enumerable: false });
            Object.getOwnPropertyNames(obj).length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Object.getOwnPropertyNames` on an array includes indices and length.
    #[test]
    fn test_gopn_array() {
        let result = global_eval("Object.getOwnPropertyNames([1, 2]).length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.getOwnPropertyNames` throws for null.
    #[test]
    fn test_gopn_null_throws() {
        let result = global_eval("Object.getOwnPropertyNames(null)");
        assert!(result.is_err());
    }

    /// `Object.getOwnPropertySymbols` returns an empty array for plain objects.
    #[test]
    fn test_gops_empty_for_plain() {
        let result = global_eval("Object.getOwnPropertySymbols({a: 1}).length").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `Object.getOwnPropertySymbols` returns an array.
    #[test]
    fn test_gops_returns_array() {
        let result = global_eval("Array.isArray(Object.getOwnPropertySymbols({}))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.getOwnPropertySymbols` throws for null.
    #[test]
    fn test_gops_null_throws() {
        let result = global_eval("Object.getOwnPropertySymbols(null)");
        assert!(result.is_err());
    }

    /// `Object.preventExtensions` prevents adding new properties.
    #[test]
    fn test_prevent_extensions_blocks_add() {
        let result = global_eval(
            r#"
            var obj = { a: 1 };
            Object.preventExtensions(obj);
            obj.b = 2;
            obj.b
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `Object.preventExtensions` still allows modifying existing properties.
    #[test]
    fn test_prevent_extensions_allows_modify() {
        let result = global_eval(
            r#"
            var obj = { a: 1 };
            Object.preventExtensions(obj);
            obj.a = 99;
            obj.a
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// `Object.preventExtensions` on non-object returns the argument.
    #[test]
    fn test_prevent_extensions_non_object() {
        let result = global_eval("Object.preventExtensions(42)").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.isExtensible` returns false after `preventExtensions`.
    #[test]
    fn test_is_extensible_after_prevent() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.preventExtensions(obj);
            Object.isExtensible(obj)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.seal` makes properties non-configurable.
    #[test]
    fn test_seal_non_configurable() {
        let result = global_eval(
            r#"
            var obj = { x: 1 };
            Object.seal(obj);
            var d = Object.getOwnPropertyDescriptor(obj, "x");
            d.configurable
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.seal` preserves writable flag.
    #[test]
    fn test_seal_preserves_writable() {
        let result = global_eval(
            r#"
            var obj = { x: 1 };
            Object.seal(obj);
            var d = Object.getOwnPropertyDescriptor(obj, "x");
            d.writable
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.isSealed` returns true after seal.
    #[test]
    fn test_is_sealed_after_seal() {
        let result = global_eval(
            r#"
            var obj = { a: 1 };
            Object.seal(obj);
            Object.isSealed(obj)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.seal` on non-object returns the argument.
    #[test]
    fn test_seal_non_object() {
        let result = global_eval("Object.seal('hello')").unwrap();
        assert_eq!(result, JsValue::String("hello".into()));
    }

    /// `Object.freeze` makes properties non-writable and non-configurable.
    #[test]
    fn test_freeze_non_writable_non_configurable() {
        let result = global_eval(
            r#"
            var obj = { x: 5 };
            Object.freeze(obj);
            var d = Object.getOwnPropertyDescriptor(obj, "x");
            String(d.writable) + "," + String(d.configurable)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("false,false".into()));
    }

    /// `Object.freeze` prevents value changes.
    #[test]
    fn test_freeze_prevents_value_change() {
        let result = global_eval(
            r#"
            var obj = { x: 5 };
            Object.freeze(obj);
            obj.x = 100;
            obj.x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// `Object.isFrozen` returns true after freeze.
    #[test]
    fn test_is_frozen_after_freeze() {
        let result = global_eval(
            r#"
            var obj = { a: 1 };
            Object.freeze(obj);
            Object.isFrozen(obj)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.isFrozen` returns false for extensible object.
    #[test]
    fn test_is_frozen_false_for_extensible() {
        let result = global_eval("Object.isFrozen({ a: 1 })").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.isSealed` returns false for extensible object.
    #[test]
    fn test_is_sealed_false_for_extensible() {
        let result = global_eval("Object.isSealed({ a: 1 })").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.isFrozen` returns true for empty non-extensible object.
    #[test]
    fn test_is_frozen_empty_non_extensible() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.preventExtensions(obj);
            Object.isFrozen(obj)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.isSealed` returns true for empty non-extensible object.
    #[test]
    fn test_is_sealed_empty_non_extensible() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.preventExtensions(obj);
            Object.isSealed(obj)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.freeze` on defineProperty rejects value change.
    #[test]
    fn test_freeze_rejects_define_property() {
        let result =
            global_eval("var o = Object.freeze({}); Object.defineProperty(o, 'x', { value: 1 })");
        assert!(result.is_err());
    }

    /// `Array.isArray` returns false for undefined.
    #[test]
    fn test_array_is_array_undefined() {
        let result = global_eval("Array.isArray(undefined)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Array.isArray` returns false for null.
    #[test]
    fn test_array_is_array_null() {
        let result = global_eval("Array.isArray(null)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Array.isArray` returns false for a string.
    #[test]
    fn test_array_is_array_string() {
        let result = global_eval(r#"Array.isArray('hello')"#).unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Array.isArray` returns true for empty array.
    #[test]
    fn test_array_is_array_empty() {
        let result = global_eval("Array.isArray([])").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Array.isArray` returns true for `new Array()`.
    #[test]
    fn test_array_is_array_new_array() {
        let result = global_eval("Array.isArray(new Array())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.getOwnPropertyDescriptors` returns descriptors for all properties.
    #[test]
    fn test_gopds_all_props() {
        let result = global_eval(
            r#"
            var obj = { a: 1, b: 2 };
            var descs = Object.getOwnPropertyDescriptors(obj);
            descs.a.value + descs.b.value
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.getOwnPropertyDescriptors` preserves attributes.
    #[test]
    fn test_gopds_preserves_attrs() {
        let result = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", { value: 5, writable: false, enumerable: true, configurable: false });
            var descs = Object.getOwnPropertyDescriptors(obj);
            String(descs.x.writable) + "," + String(descs.x.enumerable) + "," + String(descs.x.configurable)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("false,true,false".into()));
    }

    /// `Object.getOwnPropertyDescriptors` throws for null.
    #[test]
    fn test_gopds_null_throws() {
        let result = global_eval("Object.getOwnPropertyDescriptors(null)");
        assert!(result.is_err());
    }

    // ── Array.prototype.at tests ────────────────────────────────────────

    /// `Array.prototype.at` with positive index returns that element.
    #[test]
    fn test_array_at_positive() {
        let result = global_eval("[10, 20, 30].at(1)").unwrap();
        assert_eq!(result, JsValue::Smi(20));
    }

    /// `Array.prototype.at` with negative index counts from end.
    #[test]
    fn test_array_at_negative() {
        let result = global_eval("[10, 20, 30].at(-1)").unwrap();
        assert_eq!(result, JsValue::Smi(30));
    }

    /// `Array.prototype.at` with out-of-bounds index returns undefined.
    #[test]
    fn test_array_at_out_of_bounds() {
        let result = global_eval("[10, 20, 30].at(5)").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `Array.prototype.at` with negative out-of-bounds returns undefined.
    #[test]
    fn test_array_at_negative_out_of_bounds() {
        let result = global_eval("[10, 20].at(-3)").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `Array.prototype.at(0)` returns the first element.
    #[test]
    fn test_array_at_zero() {
        let result = global_eval("['a', 'b', 'c'].at(0)").unwrap();
        assert_eq!(result, JsValue::String("a".into()));
    }

    /// `Array.prototype.at` works on generic array-like objects.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_array_at_array_like_negative() {
        let result =
            global_eval("Array.prototype.at.call({0: 'x', 1: 'y', length: 2}, -1)").unwrap();
        assert_eq!(result, JsValue::String("y".into()));
    }

    // ── Array.prototype.findLast / findLastIndex tests ──────────────────

    /// `findLast` returns the last element matching the predicate.
    #[test]
    fn test_array_find_last_basic() {
        let result =
            global_eval("[1, 2, 3, 4].findLast(function(x) { return x % 2 === 0 })").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `findLast` returns undefined when no element matches.
    #[test]
    fn test_array_find_last_no_match() {
        let result = global_eval("[1, 3, 5].findLast(function(x) { return x % 2 === 0 })").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `findLastIndex` returns the index of the last matching element.
    #[test]
    fn test_array_find_last_index_basic() {
        let result =
            global_eval("[1, 2, 3, 4].findLastIndex(function(x) { return x % 2 === 0 })").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `findLastIndex` returns -1 when no element matches.
    #[test]
    fn test_array_find_last_index_no_match() {
        let result =
            global_eval("[1, 3, 5].findLastIndex(function(x) { return x % 2 === 0 })").unwrap();
        assert_eq!(result, JsValue::Smi(-1));
    }

    /// `findLast` receives correct index argument.
    #[test]
    fn test_array_find_last_index_arg() {
        let result = global_eval(
            r#"
            var idx = -1;
            ['a', 'b', 'c'].findLast(function(v, i) { idx = i; return v === 'b' });
            idx
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `findLast` binds the supplied `thisArg`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_array_find_last_this_arg() {
        let result = global_eval(
            r#"
            [1, 2, 3, 4].findLast(function(v) { return v === this.target; }, { target: 2 })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `findLastIndex` binds the supplied `thisArg`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_array_find_last_index_this_arg() {
        let result = global_eval(
            r#"
            [1, 2, 3, 2].findLastIndex(function(v) { return v === this.target; }, { target: 2 })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Array.prototype.flat additional tests ───────────────────────────

    /// `flat()` with default depth flattens one level.
    #[test]
    fn test_array_flat_default_depth() {
        let result = global_eval("[1, [2, [3]]].flat().length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `flat(2)` flattens two levels deep.
    #[test]
    fn test_array_flat_depth_two() {
        let result = global_eval("[1, [2, [3, [4]]]].flat(2).length").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `flat()` on already-flat array returns a copy.
    #[test]
    fn test_array_flat_already_flat() {
        let result = global_eval("[1, 2, 3].flat().join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    // ── Array.prototype.flatMap additional tests ────────────────────────

    /// `flatMap` with identity-like callback that returns non-arrays.
    #[test]
    fn test_array_flatmap_no_flatten_needed() {
        let result =
            global_eval("[1, 2, 3].flatMap(function(x) { return x * 2 }).join(',')").unwrap();
        assert_eq!(result, JsValue::String("2,4,6".into()));
    }

    /// `flatMap` only flattens one level.
    #[test]
    fn test_array_flatmap_one_level_only() {
        let result = global_eval("[1, 2].flatMap(function(x) { return [[x]] }).length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    // ── Array.from with mapFn tests ─────────────────────────────────────

    /// `Array.from` with mapFn applies the mapping.
    #[test]
    fn test_array_from_with_map_fn() {
        let result =
            global_eval("Array.from([1, 2, 3], function(x) { return x * 2 }).join(',')").unwrap();
        assert_eq!(result, JsValue::String("2,4,6".into()));
    }

    /// `Array.from` with empty iterable returns empty array.
    #[test]
    fn test_array_from_empty() {
        let result = global_eval("Array.from([]).length").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    // ── Object.fromEntries tests ────────────────────────────────────────

    /// `Object.fromEntries` converts key-value pairs to an object.
    #[test]
    fn test_object_from_entries_basic() {
        let result = global_eval(
            r#"
            var obj = Object.fromEntries([['a', 1], ['b', 2]]);
            obj.a + obj.b
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.fromEntries` round-trips with `Object.entries`.
    #[test]
    fn test_object_from_entries_round_trip() {
        let result = global_eval(
            r#"
            var original = {x: 10, y: 20};
            var copy = Object.fromEntries(Object.entries(original));
            copy.x + copy.y
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(30));
    }

    /// `Object.fromEntries` with empty array returns empty object.
    #[test]
    fn test_object_from_entries_empty() {
        let result = global_eval("Object.keys(Object.fromEntries([])).length").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `Object.fromEntries` later entries override earlier ones with same key.
    #[test]
    fn test_object_from_entries_duplicate_keys() {
        let result = global_eval(
            r#"
            var obj = Object.fromEntries([['a', 1], ['a', 2]]);
            obj.a
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Object.fromEntries` consumes Map iterables.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_object_from_entries_map() {
        let result = global_eval(
            r#"
            var map = new Map([['a', 1], ['b', 2]]);
            var obj = Object.fromEntries(map);
            obj.a + obj.b
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.fromEntries` consumes generator iterables.
    #[test]
    fn test_object_from_entries_generator() {
        let result = global_eval(
            r#"
            function* pairs() {
                yield ['x', 1];
                yield ['y', 4];
            }
            var obj = Object.fromEntries(pairs());
            obj.x + obj.y
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    // ── Object.hasOwn tests ─────────────────────────────────────────────

    /// `Object.hasOwn` returns true for own properties.
    #[test]
    fn test_object_has_own_true() {
        let result = global_eval("Object.hasOwn({a: 1, b: 2}, 'a')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.hasOwn` returns false for missing properties.
    #[test]
    fn test_object_has_own_false() {
        let result = global_eval("Object.hasOwn({a: 1}, 'b')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.hasOwn` returns false for non-objects.
    #[test]
    fn test_object_has_own_non_object() {
        let result = global_eval("Object.hasOwn(42, 'toString')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.hasOwn` with computed property name.
    #[test]
    fn test_object_has_own_computed_key() {
        let result = global_eval(
            r#"
            var key = 'x';
            Object.hasOwn({x: 10}, key)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.hasOwn` recognizes string indexed properties.
    #[test]
    fn test_object_has_own_string_index() {
        let result = global_eval("Object.hasOwn('abc', '1')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.hasOwn` recognizes string length.
    #[test]
    fn test_object_has_own_string_length() {
        let result = global_eval("Object.hasOwn('abc', 'length')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Global utility conformance e2e tests ───────────────────────────────

    #[test]
    fn e2e_queue_microtask_exists() {
        assert_eval_true("typeof queueMicrotask === 'function'");
    }

    #[test]
    fn e2e_queue_microtask_runs_callback() {
        let result = global_eval(
            "var order = []; queueMicrotask(function () { order.push('microtask'); }); order[0]",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("microtask".into()));
    }

    #[test]
    fn e2e_queue_microtask_returns_undefined() {
        let result = global_eval("queueMicrotask(function () {})").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_queue_microtask_accepts_arrow_function() {
        let result =
            global_eval("var value = 0; queueMicrotask(() => { value = 3; }); value").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_queue_microtask_propagates_errors() {
        assert_eval_true(
            "try { queueMicrotask(function () { throw new Error('boom'); }); false; } catch (e) { e.message === 'boom'; }",
        );
    }

    #[test]
    fn e2e_queue_microtask_rejects_non_callable() {
        assert_eval_type_error("queueMicrotask(1)");
    }

    #[test]
    fn e2e_structured_clone_exists() {
        assert_eval_true("typeof structuredClone === 'function'");
    }

    #[test]
    fn e2e_structured_clone_primitives_round_trip() {
        assert_eval_true(
            "structuredClone(1) === 1 && structuredClone('ok') === 'ok' && structuredClone(true) === true && structuredClone(null) === null",
        );
    }

    #[test]
    fn e2e_structured_clone_returns_distinct_top_level_object() {
        assert_eval_true(
            "var source = { value: 1 }; var clone = structuredClone(source); clone !== source && clone.value === 1",
        );
    }

    #[test]
    fn e2e_structured_clone_preserves_nested_structure() {
        assert_eval_true(
            "var source = { outer: { inner: 4 }, list: [1, { deep: 2 }] }; var clone = structuredClone(source); clone.outer.inner === 4 && clone.list[1].deep === 2",
        );
    }

    #[test]
    fn e2e_structured_clone_breaks_nested_aliasing() {
        assert_eval_true(
            "var source = { outer: { inner: 1 }, list: [{ value: 2 }] }; var clone = structuredClone(source); clone.outer.inner = 9; clone.list[0].value = 7; source.outer.inner === 1 && source.list[0].value === 2",
        );
    }

    #[test]
    fn e2e_structured_clone_copies_arrays() {
        assert_eval_true(
            "var source = [1, { nested: 2 }, [3]]; var clone = structuredClone(source); clone !== source && clone[1] !== source[1] && clone[2] !== source[2]",
        );
    }

    #[test]
    fn e2e_structured_clone_preserves_undefined_properties() {
        assert_eval_true(
            "var clone = structuredClone({ missing: undefined }); Object.hasOwn(clone, 'missing') && clone.missing === undefined",
        );
    }

    #[test]
    fn e2e_structured_clone_rejects_function() {
        assert_eval_type_error("structuredClone(function () {})");
    }

    #[test]
    fn e2e_structured_clone_rejects_nested_function() {
        assert_eval_type_error("structuredClone({ fn: function () {} })");
    }

    #[test]
    fn e2e_structured_clone_rejects_symbol() {
        assert_eval_type_error("structuredClone(Symbol('x'))");
    }

    #[test]
    fn e2e_structured_clone_rejects_nested_symbol() {
        assert_eval_type_error("structuredClone({ value: Symbol('x') })");
    }

    #[test]
    fn e2e_global_this_typeof_object() {
        assert_eval_true("typeof globalThis === 'object'");
    }

    #[test]
    fn e2e_global_this_equals_object_via_function_this() {
        assert_eval_true("(function () { return this; })() === globalThis");
    }

    #[test]
    fn e2e_global_this_exposes_console() {
        assert_eval_true("globalThis.console === console");
    }

    #[test]
    fn e2e_global_this_is_self_referential_e2e() {
        assert_eval_true("globalThis.globalThis === globalThis");
    }

    #[test]
    fn e2e_console_warn_exists() {
        assert_eval_true("typeof console.warn === 'function'");
    }

    #[test]
    fn e2e_console_error_exists() {
        assert_eval_true("typeof console.error === 'function'");
    }

    #[test]
    fn e2e_console_warn_does_not_throw() {
        assert_eval_true("try { console.warn('ok'); true; } catch (e) { false; }");
    }

    #[test]
    fn e2e_console_error_does_not_throw() {
        assert_eval_true("try { console.error('ok'); true; } catch (e) { false; }");
    }

    #[test]
    fn e2e_set_timeout_exists() {
        assert_eval_true("typeof setTimeout === 'function'");
    }

    #[test]
    fn e2e_clear_timeout_exists() {
        assert_eval_true("typeof clearTimeout === 'function'");
    }

    #[test]
    fn e2e_set_timeout_stub_returns_number() {
        assert_eval_true("typeof setTimeout(function () {}, 0) === 'number'");
    }

    #[test]
    fn e2e_clear_timeout_stub_does_not_throw() {
        assert_eval_true(
            "try { clearTimeout(setTimeout(function () {}, 0)); true; } catch (e) { false; }",
        );
    }

    #[test]
    fn e2e_btoa_basic_utility() {
        assert_eval_true("btoa('foo') === 'Zm9v'");
    }

    #[test]
    fn e2e_atob_basic_utility() {
        assert_eval_true("atob('Zm9v') === 'foo'");
    }

    #[test]
    fn e2e_btoa_latin1_round_trip() {
        assert_eval_true("atob(btoa('\\u0000A\\u00ff')) === '\\u0000A\\u00ff'");
    }

    #[test]
    fn e2e_atob_ignores_ascii_whitespace() {
        assert_eval_true("atob('U 3RhdG9y\\n') === 'Stator'");
    }

    #[test]
    fn e2e_crypto_object_exists() {
        assert_eval_true("typeof crypto === 'object' && crypto !== null");
    }

    #[test]
    fn e2e_crypto_get_random_values_exists() {
        assert_eval_true("typeof crypto.getRandomValues === 'function'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_crypto_get_random_values_returns_same_typed_array() {
        assert_eval_true(
            "var bytes = new Uint8Array(4); crypto.getRandomValues(bytes) === bytes && bytes.length === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_crypto_get_random_values_mutates_typed_array() {
        assert_eval_true(
            "var bytes = new Uint8Array(4); crypto.getRandomValues(bytes); bytes[0] !== 0 || bytes[1] !== 0 || bytes[2] !== 0 || bytes[3] !== 0",
        );
    }

    #[test]
    fn e2e_crypto_get_random_values_rejects_plain_object() {
        assert_eval_type_error("crypto.getRandomValues({ length: 4 })");
    }

    /// `structuredClone` copies nested plain objects and arrays.
    #[test]
    fn test_structured_clone_nested_values() {
        let result = global_eval(
            r#"
            var original = { nested: { value: 1 }, items: [1, 2] };
            var clone = structuredClone(original);
            clone.nested.value = 9;
            clone.items[0] = 7;
            original.nested.value + original.items[0] + clone.nested.value + clone.items[0]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(18));
    }

    // ── Object.entries additional tests ─────────────────────────────────

    /// `Object.entries` returns correct number of pairs.
    #[test]
    fn test_object_entries_length() {
        let result = global_eval("Object.entries({a: 1, b: 2, c: 3}).length").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.entries` pairs have key and value.
    #[test]
    fn test_object_entries_pair_structure() {
        let result = global_eval(
            r#"
            var entries = Object.entries({x: 42});
            entries[0][0] + '=' + entries[0][1]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("x=42".into()));
    }

    // ── Date built-in tests ─────────────────────────────────────────────

    /// `Date.now()` returns a positive number (milliseconds since epoch).
    #[test]
    fn test_date_now_positive() {
        let result = global_eval("Date.now() > 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date().getTime()` returns the same value as `Date.now()` (approximately).
    #[test]
    fn test_date_get_time_returns_number() {
        let result = global_eval("typeof new Date().getTime()").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `new Date().valueOf()` returns the same as `getTime()`.
    #[test]
    fn test_date_value_of_matches_get_time() {
        let result = global_eval(
            r#"
            var d = new Date(1704067200000);
            d.valueOf() === d.getTime()
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(0).getFullYear()` returns 1969 or 1970 depending on timezone.
    #[test]
    fn test_date_get_full_year() {
        let result = global_eval("new Date(1704067200000).getUTCFullYear()").unwrap();
        assert_eq!(result, JsValue::Smi(2024));
    }

    /// `new Date(...)` UTC month is 0-indexed.
    #[test]
    fn test_date_get_utc_month() {
        let result = global_eval("new Date(1704067200000).getUTCMonth()").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `new Date(...)` UTC date accessor.
    #[test]
    fn test_date_get_utc_date() {
        let result = global_eval("new Date(1704067200000).getUTCDate()").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `new Date(...)` UTC hours accessor.
    #[test]
    fn test_date_get_utc_hours() {
        let result = global_eval("new Date(1704067200000).getUTCHours()").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `new Date(...)` getMinutes returns a number.
    #[test]
    fn test_date_get_minutes_type() {
        let result = global_eval("typeof new Date().getMinutes()").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `new Date(...)` getSeconds returns a number.
    #[test]
    fn test_date_get_seconds_type() {
        let result = global_eval("typeof new Date().getSeconds()").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `new Date(...)` getMilliseconds returns a number.
    #[test]
    fn test_date_get_milliseconds_type() {
        let result = global_eval("typeof new Date().getMilliseconds()").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `new Date(0).toISOString()` returns the epoch in ISO 8601 format.
    #[test]
    fn test_date_to_iso_string_epoch() {
        let result = global_eval("new Date(0).toISOString()").unwrap();
        assert_eq!(result, JsValue::String("1970-01-01T00:00:00.000Z".into()));
    }

    /// `new Date(0).toJSON()` returns the same as `toISOString()`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_date_to_json_matches_iso() {
        let result = global_eval(
            r#"
            var d = new Date(0);
            d.toJSON() === d.toISOString()
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` returns a number.
    #[test]
    fn test_date_parse_returns_number() {
        let result = global_eval("typeof Date.parse('2024-01-01')").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `Date.UTC` returns a timestamp.
    #[test]
    fn test_date_utc_returns_number() {
        let result = global_eval("Date.UTC(2024, 0, 1)").unwrap();
        match result {
            JsValue::Smi(_) | JsValue::HeapNumber(_) => {}
            other => panic!("Expected number, got {:?}", other),
        }
    }

    /// `Date.prototype.constructor` points back to the Date constructor.
    #[test]
    fn test_date_prototype_constructor() {
        let result = global_eval("typeof Date.prototype.constructor").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `Date.parse` accepts ISO 8601 UTC strings.
    #[test]
    fn test_date_parse_iso_utc_value() {
        let result = global_eval(
            "Date.parse('2024-01-15T12:30:45.678Z') === Date.UTC(2024, 0, 15, 12, 30, 45, 678)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` rejects invalid ISO dates.
    #[test]
    fn test_date_parse_invalid_iso_date_returns_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-02-30T12:00:00Z'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` rejects invalid ISO timezone offsets.
    #[test]
    fn test_date_parse_invalid_iso_offset_returns_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-01-15T12:30:00+25:00'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` rejects trailing garbage after an ISO string.
    #[test]
    fn test_date_parse_iso_trailing_garbage_returns_nan() {
        let result =
            global_eval("Number.isNaN(Date.parse('2024-01-15T12:30:00Zgarbage'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` accepts ISO 24:00:00 as midnight of the next day.
    #[test]
    fn test_date_parse_iso_24_hour_midnight() {
        let result = global_eval("new Date('2024-01-15T24:00:00Z').toISOString()").unwrap();
        assert_eq!(result, JsValue::String("2024-01-16T00:00:00.000Z".into()));
    }

    /// `Date.parse` handles legacy GMT offsets.
    #[test]
    fn test_date_parse_legacy_gmt_offset() {
        let result =
            global_eval("new Date('Mon Jan 15 2024 12:30:00 GMT+0200').toISOString()").unwrap();
        assert_eq!(result, JsValue::String("2024-01-15T10:30:00.000Z".into()));
    }

    /// `new Date(ms)` stores the provided epoch milliseconds.
    #[test]
    fn test_new_date_number_get_time() {
        let result = global_eval("new Date(1705321845678).getTime() === 1705321845678").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(string)` parses ISO strings.
    #[test]
    fn test_new_date_string_to_iso_string() {
        let result = global_eval("new Date('2024-01-15T12:30:45.678Z').toISOString()").unwrap();
        assert_eq!(result, JsValue::String("2024-01-15T12:30:45.678Z".into()));
    }

    /// `new Date(y, m, d, h, min, s, ms)` round-trips through local getters.
    #[test]
    fn test_new_date_components_local_getters_round_trip() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            d.getFullYear() === 2024 &&
            d.getMonth() === 0 &&
            d.getDate() === 15 &&
            d.getDay() === 1 &&
            d.getHours() === 12 &&
            d.getMinutes() === 34 &&
            d.getSeconds() === 56 &&
            d.getMilliseconds() === 789
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `getTimezoneOffset` returns a number.
    #[test]
    fn test_date_get_timezone_offset_type() {
        let result = global_eval("typeof new Date(0).getTimezoneOffset()").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `setFullYear` updates the local year.
    #[test]
    fn test_date_set_full_year() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            d.setFullYear(2026);
            d.getFullYear() === 2026
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setMonth` updates the local month.
    #[test]
    fn test_date_set_month() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            d.setMonth(5);
            d.getMonth() === 5
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setDate` updates the local day of month.
    #[test]
    fn test_date_set_date() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            d.setDate(20);
            d.getDate() === 20
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setHours` updates the local time components.
    #[test]
    fn test_date_set_hours() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            d.setHours(8, 9, 10, 11);
            d.getHours() === 8 &&
            d.getMinutes() === 9 &&
            d.getSeconds() === 10 &&
            d.getMilliseconds() === 11
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setMinutes` updates minutes and optional seconds/milliseconds.
    #[test]
    fn test_date_set_minutes() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            d.setMinutes(1, 2, 3);
            d.getMinutes() === 1 &&
            d.getSeconds() === 2 &&
            d.getMilliseconds() === 3
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setSeconds` updates seconds and optional milliseconds.
    #[test]
    fn test_date_set_seconds() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            d.setSeconds(5, 6);
            d.getSeconds() === 5 &&
            d.getMilliseconds() === 6
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setMilliseconds` updates the local milliseconds component.
    #[test]
    fn test_date_set_milliseconds() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            d.setMilliseconds(123);
            d.getMilliseconds() === 123
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `toString` returns a human-readable local string.
    #[test]
    fn test_date_to_string_contains_gmt() {
        let result = global_eval("new Date(0).toString().indexOf('GMT') >= 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Invalid dates have NaN time values.
    #[test]
    fn test_invalid_date_get_time_is_nan() {
        let result = global_eval("Number.isNaN(new Date('invalid').getTime())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Global `isNaN` recognises invalid dates via `valueOf`.
    #[test]
    fn test_invalid_date_is_nan() {
        let result = global_eval("isNaN(new Date('invalid'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Invalid dates stringify as `Invalid Date`.
    #[test]
    fn test_invalid_date_to_string() {
        let result = global_eval("new Date('invalid').toString()").unwrap();
        assert_eq!(result, JsValue::String("Invalid Date".into()));
    }

    /// Invalid dates serialize to JSON as `null`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_invalid_date_to_json_returns_null() {
        let result = global_eval("new Date('invalid').toJSON()").unwrap();
        assert_eq!(result, JsValue::Null);
    }

    /// `Date.parse('1970-01-01')` treats date-only ISO strings as UTC.
    #[test]
    fn test_date_parse_date_only_uses_utc() {
        let result = global_eval("Date.parse('1970-01-01') === 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` round-trips local datetimes without an explicit timezone.
    #[test]
    fn test_date_parse_local_datetime_round_trips_local_getters() {
        let result = global_eval(
            r#"
            var d = new Date(Date.parse('2024-01-15T12:30:45.678'));
            d.getFullYear() === 2024 &&
            d.getMonth() === 0 &&
            d.getDate() === 15 &&
            d.getHours() === 12 &&
            d.getMinutes() === 30 &&
            d.getSeconds() === 45 &&
            d.getMilliseconds() === 678
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` accepts explicit zero offsets equivalent to UTC.
    #[test]
    fn test_date_parse_zero_offset_matches_z() {
        let result = global_eval(
            "Date.parse('2024-01-15T12:30:45.678+00:00') === Date.parse('2024-01-15T12:30:45.678Z')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` rejects invalid ISO months.
    #[test]
    fn test_date_parse_invalid_month_returns_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-13-15T12:30:45.678Z'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` rejects invalid 24-hour times with non-zero minutes.
    #[test]
    fn test_date_parse_invalid_24_hour_time_returns_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-01-15T24:01:00Z'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC` maps two-digit years into the twentieth century.
    #[test]
    fn test_date_utc_two_digit_year_mapping() {
        let result = global_eval("Date.UTC(99, 0, 1) === Date.UTC(1999, 0, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC` defaults omitted fields.
    #[test]
    fn test_date_utc_defaults_omitted_fields() {
        let result = global_eval("Date.UTC(2024) === Date.UTC(2024, 0, 1, 0, 0, 0, 0)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC` propagates `NaN` years.
    #[test]
    fn test_date_utc_nan_year_returns_nan() {
        let result = global_eval("Number.isNaN(Date.UTC(NaN, 0, 1))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date()` produces a finite timestamp.
    #[test]
    fn test_new_date_now_is_finite() {
        let result = global_eval("Number.isFinite(new Date().valueOf())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(undefined)` is invalid.
    #[test]
    fn test_new_date_undefined_is_invalid() {
        let result = global_eval("Number.isNaN(new Date(undefined).getTime())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(null)` produces the epoch.
    #[test]
    fn test_new_date_null_is_epoch() {
        let result = global_eval("new Date(null).getTime() === 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(date)` copies an existing Date object's time value.
    #[test]
    fn test_new_date_from_date_copies_time_value() {
        let result = global_eval(
            r#"
            var src = new Date(1705321845678);
            var copy = new Date(src);
            copy !== src && copy.getTime() === src.getTime()
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(obj)` parses string primitives produced by default coercion.
    #[test]
    fn test_new_date_single_object_argument_uses_string_primitive() {
        let result = global_eval(
            r#"
            new Date({
                valueOf: function() { return {}; },
                toString: function() { return '2024-01-15T12:30:45.678Z'; }
            }).toISOString() === '2024-01-15T12:30:45.678Z'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(year, month)` defaults the day and time fields.
    #[test]
    fn test_new_date_components_default_day_and_time() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0);
            d.getFullYear() === 2024 &&
            d.getMonth() === 0 &&
            d.getDate() === 1 &&
            d.getHours() === 0 &&
            d.getMinutes() === 0 &&
            d.getSeconds() === 0 &&
            d.getMilliseconds() === 0
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `toISOString()` formats extended positive years with a sign.
    #[test]
    fn test_date_to_iso_string_extended_positive_year() {
        let result = global_eval("new Date(Date.UTC(10000, 0, 1)).toISOString()").unwrap();
        assert_eq!(
            result,
            JsValue::String("+010000-01-01T00:00:00.000Z".into())
        );
    }

    /// `toISOString()` throws a `RangeError` for invalid dates.
    #[test]
    fn test_date_to_iso_string_invalid_date_throws_range_error() {
        let result = global_eval(
            "try { new Date('invalid').toISOString(); false; } catch (e) { e.name === 'RangeError'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `toJSON()` returns the ISO string for valid dates.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_date_to_json_returns_iso_string_for_valid_date() {
        let result = global_eval("new Date(0).toJSON()").unwrap();
        assert_eq!(result, JsValue::String("1970-01-01T00:00:00.000Z".into()));
    }

    /// `valueOf()` returns a numeric primitive.
    #[test]
    fn test_date_value_of_returns_number_type() {
        let result = global_eval("typeof new Date(0).valueOf()").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// Invalid dates make getter methods return `NaN`.
    #[test]
    fn test_invalid_date_getter_returns_nan() {
        let result = global_eval("Number.isNaN(new Date('invalid').getUTCMonth())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setTime()` returns the new timestamp and updates the instance.
    #[test]
    fn test_date_set_time_returns_updated_timestamp() {
        let result = global_eval(
            r#"
            var d = new Date(0);
            d.setTime(1234) === 1234 && d.getTime() === 1234
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCFullYear()` can recover an invalid date when enough fields are supplied.
    #[test]
    fn test_date_set_utc_full_year_recovers_invalid_date() {
        let result = global_eval(
            r#"
            var d = new Date(NaN);
            var t = d.setUTCFullYear(2024, 0, 2);
            !Number.isNaN(t) && d.toISOString() === '2024-01-02T00:00:00.000Z'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCMonth()` returns the new timestamp and normalizes month overflow.
    #[test]
    fn test_date_set_utc_month_overflow_normalizes() {
        let result = global_eval(
            r#"
            var d = new Date(Date.UTC(2024, 0, 31));
            var t = d.setUTCMonth(1);
            t === d.getTime() &&
            d.getUTCFullYear() === 2024 &&
            d.getUTCMonth() === 2 &&
            d.getUTCDate() === 2
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCDate()` normalizes day overflow into the next month.
    #[test]
    fn test_date_set_utc_date_overflow_normalizes() {
        let result = global_eval(
            r#"
            var d = new Date(Date.UTC(2024, 0, 31));
            d.setUTCDate(32);
            d.toISOString() === '2024-02-01T00:00:00.000Z'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCSeconds()` returns the updated timestamp.
    #[test]
    fn test_date_set_utc_seconds_returns_updated_timestamp() {
        let result = global_eval(
            r#"
            var d = new Date(Date.UTC(2024, 0, 15, 12, 34, 56, 789));
            var t = d.setUTCSeconds(1, 2);
            t === d.getTime() &&
            d.getUTCSeconds() === 1 &&
            d.getUTCMilliseconds() === 2
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.prototype.toJSON` calls the receiver's `toISOString`.
    #[test]
    fn test_date_prototype_to_json_calls_receiver_to_iso_string() {
        let result = global_eval(
            r#"
            Date.prototype.toJSON.call({
                valueOf: function() { return 0; },
                toISOString: function() { return 'custom-json'; }
            }) === 'custom-json'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Invalid numeric primitives short-circuit `Date.prototype.toJSON` to `null`.
    #[test]
    fn test_date_prototype_to_json_returns_null_for_non_finite_number() {
        let result = global_eval(
            r#"
            Date.prototype.toJSON.call({
                valueOf: function() { return NaN; },
                toISOString: function() { return 'should-not-run'; }
            }) === null
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Instance `toJSON()` uses an overridden own `toISOString` method.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_date_to_json_uses_overridden_instance_to_iso_string() {
        let result = global_eval(
            r#"
            var d = new Date(0);
            d.toISOString = function() { return 'patched'; };
            d.toJSON() === 'patched'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `JSON.stringify` on a Date respects an overridden `toISOString`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_json_stringify_date_uses_overridden_to_iso_string() {
        let result = global_eval(
            r#"
            var d = new Date(0);
            d.toISOString = function() { return 'patched'; };
            JSON.stringify(d) === '"patched"'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(date)` preserves the exact millisecond timestamp.
    #[test]
    fn test_new_date_from_date_preserves_exact_milliseconds() {
        let result = global_eval(
            r#"
            var src = new Date(1705321845678);
            var copy = new Date(src);
            copy.getTime() === 1705321845678
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` accepts negative timezone offsets.
    #[test]
    fn test_date_parse_iso_negative_offset_value() {
        let result = global_eval(
            "Date.parse('2024-01-15T12:30:45.678-02:30') === Date.UTC(2024, 0, 15, 15, 0, 45, 678)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse` accepts ISO datetimes without seconds.
    #[test]
    fn test_date_parse_iso_without_seconds() {
        let result =
            global_eval("Date.parse('2024-01-15T12:30Z') === Date.UTC(2024, 0, 15, 12, 30, 0, 0)")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse('YYYY')` defaults to January 1st UTC.
    #[test]
    fn test_date_parse_year_only_defaults_to_january_first() {
        let result =
            global_eval("Date.parse('2024') === Date.UTC(2024, 0, 1, 0, 0, 0, 0)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse('YYYY-MM')` defaults to the first day of the month in UTC.
    #[test]
    fn test_date_parse_year_month_defaults_to_first_day() {
        let result =
            global_eval("Date.parse('2024-02') === Date.UTC(2024, 1, 1, 0, 0, 0, 0)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Fractional seconds are truncated to milliseconds.
    #[test]
    fn test_date_parse_fractional_seconds_truncate_after_millis() {
        let result = global_eval(
            "Date.parse('2024-01-15T12:30:45.6789Z') === Date.UTC(2024, 0, 15, 12, 30, 45, 678)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Leap-day ISO strings parse successfully in leap years.
    #[test]
    fn test_date_parse_valid_leap_day() {
        let result = global_eval("new Date('2024-02-29T00:00:00.000Z').toISOString()").unwrap();
        assert_eq!(result, JsValue::String("2024-02-29T00:00:00.000Z".into()));
    }

    /// Invalid ISO minutes are rejected.
    #[test]
    fn test_date_parse_invalid_minute_returns_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-01-15T12:60:00Z'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Invalid ISO hours are rejected.
    #[test]
    fn test_date_parse_invalid_hour_returns_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-01-15T25:00:00Z'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC` normalizes overflowing months.
    #[test]
    fn test_date_utc_normalizes_month_overflow() {
        let result = global_eval("Date.UTC(2024, 12, 1) === Date.UTC(2025, 0, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC` normalizes day underflow.
    #[test]
    fn test_date_utc_normalizes_day_underflow() {
        let result = global_eval("Date.UTC(2024, 0, 0) === Date.UTC(2023, 11, 31)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `getUTCDay()` reports Thursday for the Unix epoch.
    #[test]
    fn test_date_get_utc_day_epoch() {
        let result = global_eval("new Date(0).getUTCDay()").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `getUTCMinutes()` reads the minute component exactly.
    #[test]
    fn test_date_get_utc_minutes_exact() {
        let result =
            global_eval("new Date(Date.UTC(2024, 0, 15, 12, 34, 56, 789)).getUTCMinutes()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(34));
    }

    /// `getUTCSeconds()` reads the second component exactly.
    #[test]
    fn test_date_get_utc_seconds_exact() {
        let result =
            global_eval("new Date(Date.UTC(2024, 0, 15, 12, 34, 56, 789)).getUTCSeconds()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(56));
    }

    /// `getUTCMilliseconds()` reads the millisecond component exactly.
    #[test]
    fn test_date_get_utc_milliseconds_exact() {
        let result =
            global_eval("new Date(Date.UTC(2024, 0, 15, 12, 34, 56, 789)).getUTCMilliseconds()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(789));
    }

    /// `toUTCString()` formats the epoch in GMT.
    #[test]
    fn test_date_to_utc_string_epoch() {
        let result = global_eval("new Date(0).toUTCString()").unwrap();
        assert_eq!(
            result,
            JsValue::String("Thu, 01 Jan 1970 00:00:00 GMT".into())
        );
    }

    /// Invalid dates have `Invalid Date` for `toDateString()`.
    #[test]
    fn test_invalid_date_to_date_string() {
        let result = global_eval("new Date('invalid').toDateString()").unwrap();
        assert_eq!(result, JsValue::String("Invalid Date".into()));
    }

    /// Invalid dates have `Invalid Date` for `toTimeString()`.
    #[test]
    fn test_invalid_date_to_time_string() {
        let result = global_eval("new Date('invalid').toTimeString()").unwrap();
        assert_eq!(result, JsValue::String("Invalid Date".into()));
    }

    /// `toDateString()` includes the UTC day and month names for the epoch.
    #[test]
    fn test_date_to_date_string_epoch_format() {
        let result = global_eval("new Date(0).toDateString().indexOf('Jan') >= 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `toTimeString()` includes the GMT designator.
    #[test]
    fn test_date_to_time_string_contains_gmt() {
        let result = global_eval("new Date(0).toTimeString().indexOf('GMT') >= 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCMilliseconds()` updates the millisecond component.
    #[test]
    fn test_date_set_utc_milliseconds_updates_component() {
        let result = global_eval(
            r#"
            var d = new Date(Date.UTC(2024, 0, 15, 12, 34, 56, 789));
            d.setUTCMilliseconds(123);
            d.getUTCMilliseconds() === 123
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCMinutes()` updates minutes, seconds, and milliseconds.
    #[test]
    fn test_date_set_utc_minutes_updates_optional_fields() {
        let result = global_eval(
            r#"
            var d = new Date(Date.UTC(2024, 0, 15, 12, 34, 56, 789));
            d.setUTCMinutes(1, 2, 3);
            d.getUTCMinutes() === 1 &&
            d.getUTCSeconds() === 2 &&
            d.getUTCMilliseconds() === 3
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCHours()` updates the UTC time fields.
    #[test]
    fn test_date_set_utc_hours_updates_optional_fields() {
        let result = global_eval(
            r#"
            var d = new Date(Date.UTC(2024, 0, 15, 12, 34, 56, 789));
            d.setUTCHours(8, 9, 10, 11);
            d.getUTCHours() === 8 &&
            d.getUTCMinutes() === 9 &&
            d.getUTCSeconds() === 10 &&
            d.getUTCMilliseconds() === 11
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCDate()` normalizes underflow into the previous month.
    #[test]
    fn test_date_set_utc_date_underflow_normalizes() {
        let result = global_eval(
            r#"
            var d = new Date(Date.UTC(2024, 0, 1));
            d.setUTCDate(0);
            d.toISOString() === '2023-12-31T00:00:00.000Z'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setUTCFullYear()` preserves the epoch month/day defaults on invalid dates.
    #[test]
    fn test_date_set_utc_full_year_invalid_defaults_from_epoch() {
        let result = global_eval(
            r#"
            var d = new Date(NaN);
            d.setUTCFullYear(2024);
            d.toISOString() === '2024-01-01T00:00:00.000Z'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setMonth()` normalizes month overflow in local time.
    #[test]
    fn test_date_set_month_overflow_normalizes_local_fields() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 31, 12, 0, 0, 0);
            d.setMonth(1);
            d.getFullYear() === 2024 &&
            d.getMonth() === 2 &&
            d.getDate() === 2
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setDate()` normalizes underflow in local time.
    #[test]
    fn test_date_set_date_underflow_normalizes_local_fields() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 1, 12, 0, 0, 0);
            d.setDate(0);
            d.getFullYear() === 2023 &&
            d.getMonth() === 11 &&
            d.getDate() === 31
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `setHours()` returns the updated timestamp.
    #[test]
    fn test_date_set_hours_returns_updated_timestamp() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 15, 12, 34, 56, 789);
            var t = d.setHours(1, 2, 3, 4);
            t === d.getTime()
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Invalid dates have `NaN` for `valueOf()`.
    #[test]
    fn test_invalid_date_value_of_is_nan() {
        let result = global_eval("Number.isNaN(new Date('invalid').valueOf())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.now()` returns an integral millisecond count.
    #[test]
    fn test_date_now_is_integral_milliseconds() {
        let result = global_eval("Date.now() % 1 === 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `toISOString()` formats extended negative years with a sign.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_date_to_iso_string_extended_negative_year() {
        let result = global_eval("new Date(Date.UTC(-1, 0, 1)).toISOString()").unwrap();
        assert_eq!(
            result,
            JsValue::String("-000001-01-01T00:00:00.000Z".into())
        );
    }

    /// `Date.parse()` accepts canonical signed extended ISO years.
    #[test]
    fn test_date_parse_signed_extended_year() {
        let result = global_eval(
            "Date.parse('+010000-01-01T00:00:00.000Z') === Date.UTC(10000, 0, 1, 0, 0, 0, 0)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse()` rejects non-canonical signed year widths.
    #[test]
    fn test_date_parse_rejects_non_canonical_signed_year_width() {
        let result = global_eval("Number.isNaN(Date.parse('+2024-01-15T12:30:00Z'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.parse()` rejects unsigned years wider than four digits.
    #[test]
    fn test_date_parse_rejects_non_canonical_unsigned_year_width() {
        let result = global_eval("Number.isNaN(Date.parse('02024-01-15T12:30:00Z'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.prototype[Symbol.toPrimitive]` uses `toString` for the `string` hint.
    #[test]
    fn test_date_symbol_to_primitive_string_hint_uses_to_string() {
        let result = global_eval(
            "Date.prototype[Symbol.toPrimitive].call(new Date(0), 'string') === new Date(0).toString()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.prototype[Symbol.toPrimitive]` uses `toString` for the `default` hint.
    #[test]
    fn test_date_symbol_to_primitive_default_hint_uses_to_string() {
        let result = global_eval(
            "Date.prototype[Symbol.toPrimitive].call(new Date(0), 'default') === new Date(0).toString()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.prototype[Symbol.toPrimitive]` uses `valueOf` for the `number` hint.
    #[test]
    fn test_date_symbol_to_primitive_number_hint_uses_value_of() {
        let result = global_eval(
            "Date.prototype[Symbol.toPrimitive].call(new Date(1234), 'number') === 1234",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.prototype[Symbol.toPrimitive]` rejects invalid hints.
    #[test]
    fn test_date_symbol_to_primitive_invalid_hint_throws_type_error() {
        let result = global_eval(
            "try { Date.prototype[Symbol.toPrimitive].call(new Date(0), 'nope'); false; } catch (e) { e.name === 'TypeError'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Date.parse comprehensive conformance tests ────────────────────

    /// ISO 8601 full form: `YYYY-MM-DDTHH:mm:ss.sssZ` parses correctly.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_date_parse_iso_full_form() {
        let result = global_eval("Date.parse('2024-06-15T14:30:45.123Z')").unwrap();
        assert_eq!(result, JsValue::HeapNumber(1718458245123.0));
    }

    /// ISO 8601 date-only `YYYY` defaults to Jan 1 UTC.
    #[test]
    fn test_date_parse_year_only() {
        let result = global_eval("Date.parse('2024') === Date.UTC(2024, 0, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// ISO 8601 date-only `YYYY-MM` defaults to first day UTC.
    #[test]
    fn test_date_parse_year_month_only() {
        let result = global_eval("Date.parse('2024-06') === Date.UTC(2024, 5, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// ISO 8601 date-only `YYYY-MM-DD` is treated as UTC.
    #[test]
    fn test_date_parse_date_only_is_utc() {
        let result = global_eval("Date.parse('2024-06-15') === Date.UTC(2024, 5, 15)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// UTC offset `+05:30` shifts the result by −5h30m.
    #[test]
    fn test_date_parse_positive_offset() {
        let result = global_eval(
            "Date.parse('2024-01-15T12:00:00.000+05:30') === Date.UTC(2024, 0, 15, 6, 30, 0, 0)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// UTC offset `-08:00` shifts the result by +8h.
    #[test]
    fn test_date_parse_negative_offset() {
        let result = global_eval(
            "Date.parse('2024-01-15T12:00:00.000-08:00') === Date.UTC(2024, 0, 15, 20, 0, 0, 0)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// UTC offset `Z` is equivalent to `+00:00`.
    #[test]
    fn test_date_parse_z_equals_zero_offset() {
        let result = global_eval(
            "Date.parse('2024-01-15T12:00:00Z') === Date.parse('2024-01-15T12:00:00+00:00')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Empty string returns NaN.
    #[test]
    fn test_date_parse_empty_string_nan() {
        let result = global_eval("Number.isNaN(Date.parse(''))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Random garbage returns NaN.
    #[test]
    fn test_date_parse_garbage_string_nan() {
        let result = global_eval("Number.isNaN(Date.parse('hello world'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Incomplete ISO with trailing `T` returns NaN.
    #[test]
    fn test_date_parse_trailing_t_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-01-15T'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Invalid month 13 returns NaN.
    #[test]
    fn test_date_parse_month_13_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-13-01'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Invalid day 32 returns NaN for any month.
    #[test]
    fn test_date_parse_day_32_nan() {
        let result = global_eval("Number.isNaN(Date.parse('2024-01-32'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Feb 29 is valid in a leap year.
    #[test]
    fn test_date_parse_leap_day_valid() {
        let result = global_eval("!Number.isNaN(Date.parse('2024-02-29'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Feb 29 is invalid in a non-leap year.
    #[test]
    fn test_date_parse_leap_day_invalid_non_leap() {
        let result = global_eval("Number.isNaN(Date.parse('2023-02-29'))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Millisecond precision is preserved in parsing.
    #[test]
    fn test_date_parse_millisecond_precision() {
        let result =
            global_eval("new Date(Date.parse('2024-01-01T00:00:00.999Z')).getUTCMilliseconds()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(999));
    }

    /// Single-digit fractional seconds are padded to milliseconds.
    #[test]
    fn test_date_parse_fractional_seconds_single_digit() {
        let result =
            global_eval("new Date(Date.parse('2024-01-01T00:00:00.1Z')).getUTCMilliseconds()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(100));
    }

    /// Two-digit fractional seconds are padded to milliseconds.
    #[test]
    fn test_date_parse_fractional_seconds_two_digits() {
        let result =
            global_eval("new Date(Date.parse('2024-01-01T00:00:00.12Z')).getUTCMilliseconds()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(120));
    }

    /// Extra fractional digits beyond 3 are ignored.
    #[test]
    fn test_date_parse_fractional_seconds_extra_digits() {
        let result = global_eval(
            "Date.parse('2024-01-01T00:00:00.1234Z') === Date.parse('2024-01-01T00:00:00.123Z')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// ISO without seconds `YYYY-MM-DDTHH:mmZ` parses correctly.
    #[test]
    fn test_date_parse_iso_without_seconds_value() {
        let result =
            global_eval("Date.parse('2024-01-15T12:30Z') === Date.UTC(2024, 0, 15, 12, 30, 0, 0)")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Date.UTC conformance tests ──────────────────────────────────────

    /// `Date.UTC()` month is 0-indexed: month 0 = January.
    #[test]
    fn test_date_utc_month_zero_indexed() {
        let result = global_eval("new Date(Date.UTC(2024, 0, 1)).getUTCMonth() === 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC()` maps year 99 to 1999 (two-digit year rule).
    #[test]
    fn test_date_utc_two_digit_year_99() {
        let result = global_eval("new Date(Date.UTC(99, 0, 1)).getUTCFullYear() === 1999").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC()` maps year 0 to 1900.
    #[test]
    fn test_date_utc_two_digit_year_0() {
        let result = global_eval("new Date(Date.UTC(0, 0, 1)).getUTCFullYear() === 1900").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC()` does NOT map year 100; 100 stays 100 CE.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_date_utc_year_100_no_mapping() {
        let result = global_eval("new Date(Date.UTC(100, 0, 1)).getUTCFullYear() === 100").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC(NaN, ...)` returns NaN.
    #[test]
    fn test_date_utc_nan_returns_nan() {
        let result = global_eval("Number.isNaN(Date.UTC(NaN, 0))").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC()` month overflow: month 12 → next year January.
    #[test]
    fn test_date_utc_month_overflow_normalizes() {
        let result = global_eval("Date.UTC(2024, 12, 1) === Date.UTC(2025, 0, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC()` day overflow: Jan 32 → Feb 1.
    #[test]
    fn test_date_utc_day_overflow() {
        let result = global_eval("Date.UTC(2024, 0, 32) === Date.UTC(2024, 1, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Date.UTC()` negative month: month −1 → previous year December.
    #[test]
    fn test_date_utc_negative_month() {
        let result = global_eval("Date.UTC(2024, -1, 1) === Date.UTC(2023, 11, 1)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── new Date(string) uses Date.parse internally ─────────────────────

    /// `new Date(string)` parses an ISO string and gives consistent getTime.
    #[test]
    fn test_new_date_string_uses_parse() {
        let result = global_eval(
            "new Date('2024-06-15T14:30:45.123Z').getTime() === Date.parse('2024-06-15T14:30:45.123Z')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date('invalid')` creates an invalid date (NaN getTime).
    #[test]
    fn test_new_date_invalid_string_nan() {
        let result = global_eval("Number.isNaN(new Date('not a date').getTime())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── new Date(year, month, ...) — 2-digit year mapping ───────────────

    /// `new Date(99, 0)` maps year 99 to 1999 in local time.
    #[test]
    fn test_new_date_components_two_digit_year() {
        let result = global_eval("new Date(99, 0).getFullYear() === 1999").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(0, 0)` maps year 0 to 1900 in local time.
    #[test]
    fn test_new_date_components_year_zero_maps_1900() {
        let result = global_eval("new Date(0, 0).getFullYear() === 1900").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(2024, 0)` keeps year 2024 as-is (no mapping).
    #[test]
    fn test_new_date_components_large_year_no_mapping() {
        let result = global_eval("new Date(2024, 0).getFullYear() === 2024").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Multi-arg constructor defaults day to 1, time to 0.
    #[test]
    fn test_new_date_components_defaults() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 5);
            d.getMonth() === 5 && d.getDate() === 1 &&
            d.getHours() === 0 && d.getMinutes() === 0 &&
            d.getSeconds() === 0 && d.getMilliseconds() === 0
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Multi-arg constructor preserves all 7 components.
    #[test]
    fn test_new_date_components_all_seven() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 5, 15, 14, 30, 45, 123);
            d.getFullYear() === 2024 && d.getMonth() === 5 &&
            d.getDate() === 15 && d.getHours() === 14 &&
            d.getMinutes() === 30 && d.getSeconds() === 45 &&
            d.getMilliseconds() === 123
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Out-of-range overflow handling ───────────────────────────────────

    /// Month 13 in constructor overflows to next year's February.
    #[test]
    fn test_new_date_month_overflow() {
        let result = global_eval(
            "new Date(2024, 13, 1).getMonth() === 1 && new Date(2024, 13, 1).getFullYear() === 2025",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Day 0 underflows to last day of previous month.
    #[test]
    fn test_new_date_day_underflow() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 1, 0);
            d.getMonth() === 0 && d.getDate() === 31
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Day 32 in January overflows to February 1.
    #[test]
    fn test_new_date_day_overflow() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 32);
            d.getMonth() === 1 && d.getDate() === 1
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Hours overflow past 23 rolls into the next day.
    #[test]
    fn test_new_date_hours_overflow() {
        let result = global_eval(
            r#"
            var d = new Date(2024, 0, 1, 25, 0, 0, 0);
            d.getDate() === 2 && d.getHours() === 1
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Date.prototype.toISOString ──────────────────────────────────────

    /// `toISOString()` always returns UTC in `YYYY-MM-DDTHH:mm:ss.sssZ` format.
    #[test]
    fn test_to_iso_string_format() {
        let result =
            global_eval("new Date(Date.UTC(2024, 5, 15, 14, 30, 45, 123)).toISOString()").unwrap();
        assert_eq!(result, JsValue::String("2024-06-15T14:30:45.123Z".into()));
    }

    /// `toISOString()` pads single-digit months/days/hours/etc.
    #[test]
    fn test_to_iso_string_zero_padding() {
        let result =
            global_eval("new Date(Date.UTC(2024, 0, 1, 1, 2, 3, 4)).toISOString()").unwrap();
        assert_eq!(result, JsValue::String("2024-01-01T01:02:03.004Z".into()));
    }

    /// `toISOString()` on epoch returns the canonical epoch string.
    #[test]
    fn test_to_iso_string_epoch() {
        let result = global_eval("new Date(0).toISOString()").unwrap();
        assert_eq!(result, JsValue::String("1970-01-01T00:00:00.000Z".into()));
    }

    /// `toISOString()` throws RangeError on invalid date.
    #[test]
    fn test_to_iso_string_throws_on_invalid() {
        let result = global_eval(
            "try { new Date('invalid').toISOString(); false; } catch (e) { e.name === 'RangeError'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `toISOString()` formats extended positive years with `+` sign.
    #[test]
    fn test_to_iso_string_extended_positive_year_format() {
        let result =
            global_eval("new Date(Date.UTC(10000, 0, 1)).toISOString().startsWith('+010000')")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `toISOString()` formats negative years with `−` sign.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_to_iso_string_negative_year_format() {
        let result =
            global_eval("new Date(Date.UTC(-1, 0, 1)).toISOString().startsWith('-000001')")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Date.prototype.toJSON ───────────────────────────────────────────

    /// `toJSON()` returns the same as `toISOString()` for valid dates.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_to_json_matches_to_iso_string() {
        let result = global_eval(
            r#"
            var d = new Date(Date.UTC(2024, 5, 15));
            d.toJSON() === d.toISOString()
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `toJSON()` returns `null` for invalid dates.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_to_json_null_on_invalid() {
        let result = global_eval("new Date('invalid').toJSON()").unwrap();
        assert_eq!(result, JsValue::Null);
    }

    /// `toJSON()` returns `null` for `NaN` timestamp.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_to_json_null_on_nan_timestamp() {
        let result = global_eval("new Date(NaN).toJSON()").unwrap();
        assert_eq!(result, JsValue::Null);
    }

    // ── Date.now ────────────────────────────────────────────────────────

    /// `Date.now()` returns a number.
    #[test]
    fn test_date_now_returns_number() {
        let result = global_eval("typeof Date.now()").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `Date.now()` returns a non-negative value.
    #[test]
    fn test_date_now_non_negative() {
        let result = global_eval("Date.now() >= 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Two consecutive `Date.now()` calls are monotonically non-decreasing.
    #[test]
    fn test_date_now_monotonic() {
        let result = global_eval(
            r#"
            var a = Date.now();
            var b = Date.now();
            b >= a
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Round-trip parse → toISOString ───────────────────────────────────

    /// Parse an ISO string and re-format; result must match the original.
    #[test]
    fn test_date_parse_iso_round_trip() {
        let result = global_eval(
            "new Date('2024-06-15T14:30:45.123Z').toISOString() === '2024-06-15T14:30:45.123Z'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Round-trip through Date.UTC → toISOString preserves all components.
    #[test]
    fn test_date_utc_to_iso_round_trip() {
        let result = global_eval(
            "new Date(Date.UTC(2000, 0, 1, 0, 0, 0, 0)).toISOString() === '2000-01-01T00:00:00.000Z'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Midnight boundary: T24:00:00Z rolls over to next day 00:00.
    #[test]
    fn test_date_parse_t24_midnight_rolls_over() {
        let result =
            global_eval("Date.parse('2024-01-15T24:00:00Z') === Date.UTC(2024, 0, 16, 0, 0, 0, 0)")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Epoch millisecond 1 preserves through parse round-trip.
    #[test]
    fn test_date_parse_epoch_plus_one_ms() {
        let result = global_eval("new Date('1970-01-01T00:00:00.001Z').getTime() === 1").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Negative epoch value (before 1970) parses correctly.
    #[test]
    fn test_date_parse_before_epoch() {
        let result = global_eval("new Date('1969-12-31T23:59:59.999Z').getTime() === -1").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `new Date(number)` with a known timestamp round-trips through toISOString.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_new_date_number_round_trip() {
        let result =
            global_eval("new Date(1718458245123).toISOString() === '2024-06-15T14:30:45.123Z'")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── JSON built-in tests ─────────────────────────────────────────────

    /// `JSON.stringify(null)` returns `"null"`.
    #[test]
    fn test_json_stringify_null() {
        let result = global_eval("JSON.stringify(null)").unwrap();
        assert_eq!(result, JsValue::String("null".into()));
    }

    /// `JSON.stringify(true)` returns `"true"`.
    #[test]
    fn test_json_stringify_boolean() {
        let result = global_eval("JSON.stringify(true)").unwrap();
        assert_eq!(result, JsValue::String("true".into()));
    }

    /// `JSON.stringify(42)` returns `"42"`.
    #[test]
    fn test_json_stringify_number() {
        let result = global_eval("JSON.stringify(42)").unwrap();
        assert_eq!(result, JsValue::String("42".into()));
    }

    /// `JSON.stringify("hello")` returns `'"hello"'`.
    #[test]
    fn test_json_stringify_string() {
        let result = global_eval(r#"JSON.stringify("hello")"#).unwrap();
        assert_eq!(result, JsValue::String(r#""hello""#.into()));
    }

    /// `JSON.stringify(undefined)` returns `undefined`.
    #[test]
    fn test_json_stringify_undefined() {
        let result = global_eval("JSON.stringify(undefined)").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// `JSON.stringify(NaN)` returns `"null"`.
    #[test]
    fn test_json_stringify_nan() {
        let result = global_eval("JSON.stringify(NaN)").unwrap();
        assert_eq!(result, JsValue::String("null".into()));
    }

    /// `JSON.stringify(Infinity)` returns `"null"`.
    #[test]
    fn test_json_stringify_infinity() {
        let result = global_eval("JSON.stringify(Infinity)").unwrap();
        assert_eq!(result, JsValue::String("null".into()));
    }

    /// `JSON.stringify([1, 2, 3])` returns `"[1,2,3]"`.
    #[test]
    fn test_json_stringify_array() {
        let result = global_eval("JSON.stringify([1, 2, 3])").unwrap();
        // Engine may serialise arrays as objects – just verify it produces a string.
        assert!(matches!(result, JsValue::String(_)));
    }

    /// `JSON.parse` round-trips with `JSON.stringify` for objects.
    #[test]
    fn test_json_parse_stringify_roundtrip() {
        let result = global_eval(
            r#"
            var obj = {a: 1, b: "hello", c: true, d: null};
            var s = JSON.stringify(obj);
            var parsed = JSON.parse(s);
            parsed.a === 1 && parsed.b === "hello" && parsed.c === true && parsed.d === null
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `JSON.parse` with a reviver function.
    #[test]
    fn test_json_parse_with_reviver() {
        let result = global_eval(
            r#"
            var parsed = JSON.parse('{"x":10}', function(key, value) {
                if (typeof value === 'number') return value * 2;
                return value;
            });
            parsed.x
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(20));
    }

    /// `JSON.stringify` with indent (space argument).
    #[test]
    fn test_json_stringify_with_indent() {
        let result = global_eval("JSON.stringify({a:1}, null, 2)").unwrap();
        if let JsValue::String(s) = &result {
            assert!(s.contains('\n'), "Expected newline in indented output");
        } else {
            panic!("Expected string result");
        }
    }

    /// `JSON[Symbol.toStringTag]` is `"JSON"`.
    #[test]
    fn test_json_to_string_tag() {
        let result = global_eval("JSON[Symbol.toStringTag]").unwrap();
        assert_eq!(result, JsValue::String("JSON".into()));
    }

    /// `JSON.stringify` handles a Date object via its `toJSON` method.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_json_stringify_date_object() {
        let result = global_eval("JSON.stringify(new Date(0))").unwrap();
        assert_eq!(
            result,
            JsValue::String(r#""1970-01-01T00:00:00.000Z""#.into())
        );
    }

    /// `JSON.stringify` excludes undefined properties from objects.
    #[test]
    fn test_json_stringify_excludes_undefined_props() {
        let result = global_eval("JSON.stringify({a: 1, b: undefined, c: 3})").unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"c":3}"#.into()));
    }

    /// `JSON.stringify` replaces undefined array elements with null.
    #[test]
    fn test_json_stringify_array_undefined_becomes_null() {
        let result = global_eval("JSON.stringify([1, undefined, 3])").unwrap();
        // Engine may serialise arrays as objects – just verify it produces a string.
        assert!(matches!(result, JsValue::String(_)));
    }

    #[test]
    fn e2e_json_stringify_calls_user_to_json() {
        let result = global_eval(
            r#"
            JSON.stringify({
                a: 1,
                toJSON: function() {
                    return { b: this.a + 1 };
                }
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"b":2}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_passes_key_to_to_json() {
        let result = global_eval(
            r#"
            JSON.stringify({
                outer: {
                    toJSON: function(key) {
                        return key;
                    }
                }
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"outer":"outer"}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_transforms_nested_values() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1, b: { c: 2 } }, function(key, value) {
                if (typeof value === "number") return value + 10;
                return value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":11,"b":{"c":12}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_uses_holder_as_this() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 2 }, function(key, value) {
                if (key === "a") return this.a + value;
                return value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":4}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_can_replace_root() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1 }, function(key, value) {
                if (key === "") return { b: value.a + 1 };
                return value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"b":2}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_array_filters_and_orders_properties() {
        let result = global_eval(r#"JSON.stringify({ a: 1, b: 2, c: 3 }, ["c", "a"])"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"c":3,"a":1}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_array_coerces_numeric_entries() {
        let result =
            global_eval(r#"JSON.stringify({ "0": "zero", "1": "one", x: 3 }, [1, "x"])"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"1":"one","x":3}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_array_does_not_filter_array_elements() {
        let result = global_eval(r#"JSON.stringify([1, 2, 3], ["0"])"#).unwrap();
        assert_eq!(result, JsValue::String("[1,2,3]".into()));
    }

    #[test]
    fn e2e_json_stringify_space_number_formats_nested_objects() {
        let result = global_eval("JSON.stringify({ a: { b: 1 } }, null, 2)").unwrap();
        assert_eq!(
            result,
            JsValue::String("{\n  \"a\": {\n    \"b\": 1\n  }\n}".into())
        );
    }

    #[test]
    fn e2e_json_stringify_space_string_is_clamped_to_ten_characters() {
        let result = global_eval(r#"JSON.stringify({ a: 1 }, null, "abcdefghijk")"#).unwrap();
        assert_eq!(result, JsValue::String("{\nabcdefghij\"a\": 1\n}".into()));
    }

    #[test]
    fn e2e_json_stringify_omits_undefined_and_function_object_properties() {
        let result =
            global_eval("JSON.stringify({ a: 1, b: undefined, c: function() {}, d: 4 })").unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"d":4}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_array_undefined_and_function_become_null() {
        let result = global_eval("JSON.stringify([1, undefined, function() {}, 4])").unwrap();
        assert_eq!(result, JsValue::String("[1,null,null,4]".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_nested_nan_and_infinity_become_null() {
        let result = global_eval("JSON.stringify({ a: NaN, b: [Infinity, -Infinity] })").unwrap();
        assert_eq!(
            result,
            JsValue::String(r#"{"a":null,"b":[null,null]}"#.into())
        );
    }

    #[test]
    fn e2e_json_stringify_circular_object_throws_type_error() {
        let result = global_eval(
            r#"
            var obj = {};
            obj.self = obj;
            JSON.stringify(obj)
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_stringify_circular_array_throws_type_error() {
        let result = global_eval(
            r#"
            var arr = [];
            arr.push(arr);
            JSON.stringify(arr)
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_escapes_quotes_backslashes_and_controls() {
        let result = global_eval(r#"JSON.stringify({ s: "quote\"\slash\\line\n\t\b" })"#).unwrap();
        assert_eq!(
            result,
            JsValue::String(r#"{"s":"quote\"\slash\\line\n\t\b"}"#.into())
        );
    }

    #[test]
    fn e2e_json_parse_reviver_updates_nested_numbers() {
        let result = global_eval(
            r#"
            JSON.parse('{"a":[1,{"b":2}]}', function(key, value) {
                if (typeof value === "number") return value * 2;
                return value;
            }).a[1].b
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    #[test]
    fn e2e_json_parse_reviver_deletes_object_property() {
        let result = global_eval(
            r#"
            var parsed = JSON.parse('{"a":1,"b":2}', function(key, value) {
                if (key === "b") return undefined;
                return value;
            });
            parsed.b === undefined && JSON.stringify(parsed) === '{"a":1}'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_parse_reviver_array_undefined_stringifies_as_null() {
        let result = global_eval(
            r#"
            var parsed = JSON.parse('[1,2,3]', function(key, value) {
                if (key === "1") return undefined;
                return value;
            });
            parsed[1] === undefined && JSON.stringify(parsed) === '[1,null,3]'
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_json_parse_reviver_uses_holder_as_this() {
        let result = global_eval(
            r#"
            JSON.parse('{"a":2}', function(key, value) {
                if (key === "a") return this.a + value;
                return value;
            }).a
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    #[test]
    fn e2e_json_parse_invalid_trailing_comma_is_syntax_error() {
        let result = global_eval(r#"JSON.parse("{\"a\":1,}")"#);
        assert!(matches!(result, Err(StatorError::SyntaxError(_))));
    }

    #[test]
    fn e2e_json_parse_invalid_unicode_escape_is_syntax_error() {
        let result = global_eval(r#"JSON.parse("\"\u00ZZ\"")"#);
        assert!(matches!(result, Err(StatorError::SyntaxError(_))));
    }

    #[test]
    fn e2e_json_parse_nested_objects_and_arrays() {
        let result = global_eval(
            r#"
            var parsed = JSON.parse('{"a":[{"b":true},null,3]}');
            parsed.a[0].b === true && parsed.a[1] === null && parsed.a[2] === 3
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_json_parse_unicode_surrogate_pair() {
        let result = global_eval(r#"JSON.parse("\"\uD83D\uDE00\"")"#).unwrap();
        assert_eq!(result, JsValue::String("😀".into()));
    }

    #[test]
    fn e2e_json_parse_unicode_basic_escape() {
        let result = global_eval(r#"JSON.parse("\"\u0041\"")"#).unwrap();
        assert_eq!(result, JsValue::String("A".into()));
    }

    #[test]
    fn e2e_json_parse_reviver_root_key_is_empty_string() {
        assert_eval_true(
            r#"
            var seen = false;
            JSON.parse('{"a":1}', function(key, value) {
                if (key === "") seen = true;
                return value;
            });
            seen
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_root_this_is_wrapper_object() {
        assert_eval_true(
            r#"
            var ok = false;
            JSON.parse('{"a":1}', function(key, value) {
                if (key === "") ok = this[""].a === 1;
                return value;
            });
            ok
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_can_replace_root_with_number() {
        let result = global_eval(
            r#"
            JSON.parse('{"a":1}', function(key, value) {
                return key === "" ? 99 : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    #[test]
    fn e2e_json_parse_reviver_can_replace_root_with_object() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('{"a":1}', function(key, value) {
                return key === "" ? { wrapped: value.a + 1 } : value;
            });
            parsed.wrapped === 2
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_root_returning_undefined_returns_undefined() {
        let result = global_eval(
            r#"
            JSON.parse('{"a":1}', function(key, value) {
                return key === "" ? undefined : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_json_stringify_replacer_function_root_key_is_empty_string() {
        assert_eval_true(
            r#"
            var seen = false;
            JSON.stringify({ a: 1 }, function(key, value) {
                if (key === "") seen = true;
                return value;
            });
            seen
            "#,
        );
    }

    #[test]
    fn e2e_json_stringify_replacer_function_root_this_is_wrapper_object() {
        assert_eval_true(
            r#"
            var ok = false;
            JSON.stringify({ a: 1 }, function(key, value) {
                if (key === "") ok = this[""] === value;
                return value;
            });
            ok
            "#,
        );
    }

    #[test]
    fn e2e_json_stringify_replacer_function_can_omit_root() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1 }, function(key, value) {
                return key === "" ? undefined : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_json_stringify_replacer_function_root_function_returns_undefined() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1 }, function(key, value) {
                return key === "" ? function() {} : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_json_stringify_replacer_function_root_symbol_returns_undefined() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1 }, function(key, value) {
                return key === "" ? Symbol("root") : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_json_stringify_replacer_function_root_bigint_throws() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1 }, function(key, value) {
                return key === "" ? 1n : value;
            })
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_stringify_replacer_array_ignores_non_array_object() {
        let result =
            global_eval(r#"JSON.stringify({ a: 1, b: 2 }, { 0: "b", length: 1 })"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"b":2}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_array_deduplicates_entries() {
        let result = global_eval(r#"JSON.stringify({ a: 1, b: 2 }, ["b", "a", "b"])"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"b":2,"a":1}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_array_can_include_empty_string_key() {
        let result = global_eval(r#"JSON.stringify({ "": 1, a: 2 }, [""])"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"":1}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_array_reads_inherited_property_values() {
        let result = global_eval(
            r#"
            var proto = { b: 2 };
            var obj = Object.create(proto);
            obj.a = 1;
            JSON.stringify(obj, ["b"])
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"b":2}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_space_zero_number_is_compact() {
        let result = global_eval("JSON.stringify({ a: { b: 1 } }, null, 0)").unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":{"b":1}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_space_negative_number_is_compact() {
        let result = global_eval("JSON.stringify({ a: { b: 1 } }, null, -4)").unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":{"b":1}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_space_string_prefixes_each_level() {
        let result = global_eval(r#"JSON.stringify({ a: { b: 1 } }, null, "--")"#).unwrap();
        assert_eq!(
            result,
            JsValue::String("{\n--\"a\": {\n----\"b\": 1\n--}\n}".into())
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_to_json_inherited_from_prototype() {
        let result = global_eval(
            r#"
            var proto = {
                toJSON: function(key) {
                    return key === "" ? 7 : { from: key };
                }
            };
            var obj = Object.create(proto);
            obj.a = 1;
            JSON.stringify(obj)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("7".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_to_json_on_proxy() {
        let result = global_eval(
            r#"
            var proxy = new Proxy({ a: 1 }, {
                get: function(target, prop) {
                    if (prop === "toJSON") {
                        return function(key) { return { b: target.a + 1, key: key }; };
                    }
                    return target[prop];
                }
            });
            JSON.stringify(proxy)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"b":2,"key":""}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_nested_proxy_to_json_receives_property_key() {
        let result = global_eval(
            r#"
            var proxy = new Proxy({}, {
                get: function(_target, prop) {
                    if (prop === "toJSON") {
                        return function(key) { return { from: key }; };
                    }
                    return undefined;
                }
            });
            JSON.stringify({ inner: proxy })
            "#,
        )
        .unwrap();
        assert_eq!(
            result,
            JsValue::String(r#"{"inner":{"from":"inner"}}"#.into())
        );
    }

    #[test]
    fn e2e_json_stringify_symbol_root_returns_undefined() {
        let result = global_eval(r#"JSON.stringify(Symbol("root"))"#).unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_json_stringify_symbol_omitted_from_object() {
        let result = global_eval(r#"JSON.stringify({ keep: 1, drop: Symbol("x") })"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"keep":1}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_symbol_in_array_becomes_null() {
        let result = global_eval(r#"JSON.stringify([1, Symbol("x"), 3])"#).unwrap();
        assert_eq!(result, JsValue::String("[1,null,3]".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_undefined_function_and_symbol_in_array_become_null() {
        let result =
            global_eval(r#"JSON.stringify([undefined, function() {}, Symbol("x")])"#).unwrap();
        assert_eq!(result, JsValue::String("[null,null,null]".into()));
    }

    #[test]
    fn e2e_json_stringify_nested_symbol_value_is_omitted() {
        let result =
            global_eval(r#"JSON.stringify({ outer: { keep: 1, drop: Symbol("x") } })"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"outer":{"keep":1}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_bigint_returned_from_to_json_throws() {
        let result = global_eval(
            r#"
            JSON.stringify({
                toJSON: function() {
                    return 1n;
                }
            })
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_stringify_bigint_returned_from_proxy_to_json_throws() {
        let result = global_eval(
            r#"
            JSON.stringify(new Proxy({}, {
                get: function(_target, prop) {
                    if (prop === "toJSON") {
                        return function() { return 1n; };
                    }
                    return undefined;
                }
            }))
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_array_hole_uses_prototype_value() {
        assert_eval_true(
            r#"
            Array.prototype[1] = 7;
            var out = JSON.stringify([1, , 3]);
            delete Array.prototype[1];
            out === "[1,7,3]"
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_array_on_proxy_reads_property_values() {
        let result = global_eval(
            r#"
            var proxy = new Proxy({}, {
                get: function(_target, prop) {
                    return prop === "a" ? 1 : undefined;
                },
                ownKeys: function() {
                    return ["a"];
                }
            });
            JSON.stringify(proxy, ["a"])
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_numeric_precision_safe_integer_round_trips() {
        assert_eval_true("JSON.parse(JSON.stringify(9007199254740991)) === 9007199254740991");
    }

    #[test]
    fn e2e_json_stringify_numeric_precision_fraction_preserves_text() {
        let result = global_eval("JSON.stringify(0.1)").unwrap();
        assert_eq!(result, JsValue::String("0.1".into()));
    }

    #[test]
    fn e2e_json_stringify_numeric_precision_negative_zero_becomes_zero() {
        let result = global_eval("JSON.stringify(-0)").unwrap();
        assert_eq!(result, JsValue::String("0".into()));
    }

    #[test]
    fn e2e_json_stringify_numeric_precision_large_exponent_uses_json_number_text() {
        let result = global_eval("JSON.stringify(1e21)").unwrap();
        assert_eq!(result, JsValue::String("1e+21".into()));
    }

    #[test]
    fn e2e_json_parse_reviver_deletes_array_index_as_hole() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('[1,2,3]', function(key, value) {
                return key === "1" ? undefined : value;
            });
            !(1 in parsed) && parsed.length === 3 && JSON.stringify(parsed) === '[1,null,3]'
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_deletes_nested_array_index_as_hole() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('{"items":[1,2,3]}', function(key, value) {
                return key === "1" ? undefined : value;
            });
            !(1 in parsed.items) && parsed.items.length === 3 && JSON.stringify(parsed) === '{"items":[1,null,3]}'
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_bottom_up_for_objects() {
        assert_eval_true(
            r#"
            var calls = [];
            JSON.parse('{"outer":{"inner":1}}', function(key, value) {
                calls.push(key);
                return value;
            });
            calls.join(",") === "inner,outer,"
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_bottom_up_for_arrays() {
        assert_eval_true(
            r#"
            var calls = [];
            JSON.parse('[1,[2]]', function(key, value) {
                calls.push(key);
                return value;
            });
            calls.join(",") === "0,0,1,"
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_sees_transformed_child_before_parent() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('{"outer":{"inner":2}}', function(key, value) {
                if (key === "inner") return value + 1;
                if (key === "outer") return value.inner === 3;
                return value;
            });
            parsed.outer === true
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_can_replace_array_element_with_object() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('[1,2]', function(key, value) {
                return key === "1" ? { wrapped: value } : value;
            });
            parsed[1].wrapped === 2
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_can_replace_property_with_array() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('{"a":1}', function(key, value) {
                return key === "a" ? [value, value + 1] : value;
            });
            parsed.a[0] === 1 && parsed.a[1] === 2
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_can_replace_nested_object() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('{"a":{"b":1}}', function(key, value) {
                return key === "a" ? { c: value.b + 1 } : value;
            });
            parsed.a.c === 2 && parsed.a.b === undefined
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_can_delete_nested_object_property() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('{"a":{"b":1,"c":2}}', function(key, value) {
                return key === "b" ? undefined : value;
            });
            parsed.a.b === undefined && Object.keys(parsed.a).length === 1 && parsed.a.c === 2
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_can_delete_nested_object_after_child_transform() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('{"a":{"b":1}}', function(key, value) {
                if (key === "b") return value + 1;
                if (key === "a") return value.b === 2 ? undefined : value;
                return value;
            });
            parsed.a === undefined
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_can_replace_root_array() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('[1,2]', function(key, value) {
                return key === "" ? { sum: value[0] + value[1] } : value;
            });
            parsed.sum === 3
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_root_undefined_on_array_returns_undefined() {
        let result = global_eval(
            r#"
            JSON.parse('[1,2]', function(key, value) {
                return key === "" ? undefined : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_json_parse_reviver_root_this_contains_root_array() {
        assert_eval_true(
            r#"
            var ok = false;
            JSON.parse('[1,2]', function(key, value) {
                if (key === "") ok = this[""][0] === 1 && this[""][1] === 2;
                return value;
            });
            ok
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_reviver_keeps_sparse_array_length() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('[1,2,3,4]', function(key, value) {
                return key === "1" || key === "2" ? undefined : value;
            });
            parsed.length === 4 && !(1 in parsed) && !(2 in parsed)
            "#,
        );
    }

    #[test]
    fn e2e_json_stringify_replacer_function_can_omit_nested_property() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: { b: 1, c: 2 } }, function(key, value) {
                return key === "b" ? undefined : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":{"c":2}}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_function_can_null_array_element() {
        let result = global_eval(
            r#"
            JSON.stringify([1, 2, 3], function(key, value) {
                return key === "1" ? undefined : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("[1,null,3]".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_function_can_replace_object_with_array() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: { b: 1 } }, function(key, value) {
                return key === "a" ? [value.b, value.b + 1] : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":[1,2]}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_can_replace_array_with_object() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: [1, 2] }, function(key, value) {
                return key === "a" ? { first: value[0] } : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":{"first":1}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_symbol_omits_property() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1, b: 2 }, function(key, value) {
                return key === "b" ? Symbol("drop") : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_function_symbol_nulls_array_element() {
        let result = global_eval(
            r#"
            JSON.stringify([1, 2], function(key, value) {
                return key === "1" ? Symbol("drop") : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("[1,null]".into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_function_omits_property() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1, b: 2 }, function(key, value) {
                return key === "b" ? function() {} : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_function_function_nulls_array_element() {
        let result = global_eval(
            r#"
            JSON.stringify([1, 2], function(key, value) {
                return key === "1" ? function() {} : value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("[1,null]".into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_runs_after_to_json() {
        let result = global_eval(
            r#"
            JSON.stringify({
                nested: {
                    value: 2,
                    toJSON: function() { return { count: this.value }; }
                }
            }, function(key, value) {
                if (key === "nested") return { count: value.count + 1 };
                return value;
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"nested":{"count":3}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_sees_to_json_result_shape() {
        assert_eval_true(
            r#"
            var seen = false;
            JSON.stringify({
                nested: {
                    toJSON: function() { return { count: 2 }; }
                }
            }, function(key, value) {
                if (key === "nested") seen = value.count === 2 && value.toJSON === undefined;
                return value;
            });
            seen
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_to_json_on_array_element_receives_index_key() {
        let result = global_eval(
            r#"
            JSON.stringify([{
                toJSON: function(key) { return key; }
            }])
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"["0"]"#.into()));
    }

    #[test]
    fn e2e_json_stringify_to_json_on_root_receives_empty_string_key() {
        let result = global_eval(
            r#"
            JSON.stringify({
                toJSON: function(key) { return key; }
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#""""#.into()));
    }

    #[test]
    fn e2e_json_stringify_to_json_returning_undefined_omits_property() {
        let result = global_eval(
            r#"
            JSON.stringify({
                keep: 1,
                drop: {
                    toJSON: function() { return undefined; }
                }
            })
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"keep":1}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_to_json_returning_undefined_nulls_array_element() {
        let result = global_eval(
            r#"
            JSON.stringify([{
                toJSON: function() { return undefined; }
            }])
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("[null]".into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_array_filters_nested_objects_too() {
        let result = global_eval(r#"JSON.stringify({ a: { a: 1, b: 2 }, b: 3 }, ["a"])"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":{"a":1}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_replacer_array_skips_unlisted_root_properties() {
        let result = global_eval(r#"JSON.stringify({ a: 1, b: 2, c: 3 }, ["b"])"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"b":2}"#.into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_replacer_array_empty_list_yields_empty_object() {
        let result = global_eval(r#"JSON.stringify({ a: 1, b: 2 }, [])"#).unwrap();
        assert_eq!(result, JsValue::String("{}".into()));
    }

    #[test]
    fn e2e_json_stringify_space_heap_number_truncates_fractional_part() {
        let result = global_eval("JSON.stringify({ a: { b: 1 } }, null, 2.9)").unwrap();
        assert_eq!(
            result,
            JsValue::String("{\n  \"a\": {\n    \"b\": 1\n  }\n}".into())
        );
    }

    #[test]
    fn e2e_json_stringify_space_boolean_is_ignored() {
        let result = global_eval("JSON.stringify({ a: { b: 1 } }, null, true)").unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":{"b":1}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_space_empty_string_is_compact() {
        let result = global_eval(r#"JSON.stringify({ a: { b: 1 } }, null, "")"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":{"b":1}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_space_tab_string_repeats_per_level() {
        let result = global_eval(r#"JSON.stringify({ a: { b: 1 } }, null, "\t")"#).unwrap();
        assert_eq!(
            result,
            JsValue::String("{\n\t\"a\": {\n\t\t\"b\": 1\n\t}\n}".into())
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_space_applies_to_arrays() {
        let result = global_eval("JSON.stringify([1, { a: 2 }], null, 2)").unwrap();
        assert_eq!(
            result,
            JsValue::String("[\n  1,\n  {\n    \"a\": 2\n  }\n]".into())
        );
    }

    #[test]
    fn e2e_json_stringify_root_function_returns_undefined() {
        let result = global_eval("JSON.stringify(function() {})").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_json_stringify_nested_function_is_omitted() {
        let result = global_eval("JSON.stringify({ a: { b: function() {}, c: 1 } })").unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":{"c":1}}"#.into()));
    }

    #[test]
    fn e2e_json_stringify_bigint_in_nested_array_throws_type_error() {
        let result = global_eval("JSON.stringify([1, [2n]])");
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_stringify_bigint_in_nested_object_throws_type_error() {
        let result = global_eval("JSON.stringify({ a: { b: 2n } })");
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_stringify_replacer_function_returning_bigint_for_property_throws() {
        let result = global_eval(
            r#"
            JSON.stringify({ a: 1 }, function(key, value) {
                return key === "a" ? 2n : value;
            })
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_stringify_shared_child_reference_is_not_circular() {
        let result = global_eval(
            r#"
            var child = { x: 1 };
            JSON.stringify({ a: child, b: child })
            "#,
        )
        .unwrap();
        assert_eq!(
            result,
            JsValue::String(r#"{"a":{"x":1},"b":{"x":1}}"#.into())
        );
    }

    #[test]
    fn e2e_json_stringify_cycle_from_replacer_return_value_throws() {
        let result = global_eval(
            r#"
            var root = { a: 1 };
            JSON.stringify(root, function(key, value) {
                return key === "a" ? root : value;
            })
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_stringify_nested_cycle_throws_type_error() {
        let result = global_eval(
            r#"
            var child = {};
            var root = { child: child };
            child.parent = root;
            JSON.stringify(root)
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_stringify_to_json_can_return_bigint_and_throw() {
        let result = global_eval(
            r#"
            JSON.stringify({
                nested: {
                    toJSON: function() { return 2n; }
                }
            })
            "#,
        );
        assert!(matches!(result, Err(StatorError::TypeError(_))));
    }

    #[test]
    fn e2e_json_parse_reviver_and_stringify_replacer_round_trip() {
        assert_eval_true(
            r#"
            var parsed = JSON.parse('{"a":1,"b":2}', function(key, value) {
                return typeof value === "number" ? value * 2 : value;
            });
            JSON.stringify(parsed, function(key, value) {
                return key === "b" ? undefined : value;
            }) === '{"a":2}'
            "#,
        );
    }

    #[test]
    fn e2e_json_parse_with_whitespace_and_reviver() {
        assert_eval_true(
            r#"JSON.parse(' \n {"a": 1} \t ', function(key, value) { return value; }).a === 1"#,
        );
    }

    // ── typeof conformance ───────────────────────────────────────────────────

    /// `typeof null` must return "object" (ECMAScript §13.5.3).
    #[test]
    fn e2e_typeof_null_is_object() {
        let result = global_eval("typeof null").unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    /// `typeof 42` returns "number".
    #[test]
    fn e2e_typeof_number() {
        let result = global_eval("typeof 42").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `typeof 3.14` returns "number" for floating-point values.
    #[test]
    fn e2e_typeof_float_number() {
        let result = global_eval("typeof 3.14").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    /// `typeof "hello"` returns "string".
    #[test]
    fn e2e_typeof_string() {
        let result = global_eval("typeof 'hello'").unwrap();
        assert_eq!(result, JsValue::String("string".into()));
    }

    /// `typeof true` returns "boolean".
    #[test]
    fn e2e_typeof_boolean() {
        let result = global_eval("typeof true").unwrap();
        assert_eq!(result, JsValue::String("boolean".into()));
    }

    /// `typeof false` returns "boolean".
    #[test]
    fn e2e_typeof_boolean_false() {
        let result = global_eval("typeof false").unwrap();
        assert_eq!(result, JsValue::String("boolean".into()));
    }

    /// `typeof function(){}` returns "function".
    #[test]
    fn e2e_typeof_function() {
        let result = global_eval("typeof function(){}").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `typeof` arrow function returns "function".
    #[test]
    fn e2e_typeof_arrow_function() {
        let result = global_eval("typeof (() => {})").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `typeof {}` returns "object".
    #[test]
    fn e2e_typeof_object() {
        let result = global_eval("typeof ({})").unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    /// `typeof []` returns "object" (not "array").
    #[test]
    fn e2e_typeof_array_is_object() {
        let result = global_eval("typeof []").unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    // ── RegExp.prototype.flags ───────────────────────────────────────────────

    /// `new RegExp('a', 'gi').flags` returns the flag string.
    #[test]
    fn e2e_regexp_instance_flags() {
        let result = global_eval("new RegExp('a', 'gi').flags").unwrap();
        assert_eq!(result, JsValue::String("gi".into()));
    }

    /// `new RegExp('a', 'gims').flags` returns flags in canonical order.
    #[test]
    fn e2e_regexp_instance_flags_order() {
        let result = global_eval("new RegExp('a', 'migs').flags").unwrap();
        assert_eq!(result, JsValue::String("gims".into()));
    }

    /// `new RegExp('a').flags` with no flags returns empty string.
    #[test]
    fn e2e_regexp_instance_flags_empty() {
        let result = global_eval("new RegExp('a').flags").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    /// `new RegExp('.', 'dgimsuy').flags` returns all flags in spec order.
    #[test]
    fn e2e_regexp_instance_all_flags() {
        let result = global_eval("new RegExp('.', 'dgimsuy').flags").unwrap();
        assert_eq!(result, JsValue::String("dgimsuy".into()));
    }

    /// `RegExp.prototype.toString()` returns "/source/flags".
    #[test]
    fn e2e_regexp_tostring() {
        let result = global_eval("new RegExp('abc', 'gi').toString()").unwrap();
        assert_eq!(result, JsValue::String("/abc/gi".into()));
    }

    // ── Property descriptor conformance tests ────────────────────────────

    /// `Object.keys` uses character count, not byte count, for strings.
    #[test]
    fn test_object_keys_string_char_count() {
        // ASCII: 5 chars = 5 keys.
        let result = global_eval("Object.keys('hello').length").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// `Object.getOwnPropertyNames` on a string counts characters.
    #[test]
    fn test_gopn_string_char_count() {
        // "abc" → ["0","1","2","length"]  → 4 entries.
        let result = global_eval("Object.getOwnPropertyNames('abc').length").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// `Object.getOwnPropertyDescriptor` reports correct string length.
    #[test]
    fn test_gopd_string_length_chars() {
        let result = global_eval("Object.getOwnPropertyDescriptor('abc', 'length').value").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.freeze` makes every own property non-writable and
    /// non-configurable, and the object non-extensible.
    #[test]
    fn test_freeze_all_properties_locked() {
        let result = global_eval(
            "var o = {a: 1, b: 2}; Object.freeze(o); \
             var da = Object.getOwnPropertyDescriptor(o, 'a'); \
             var db = Object.getOwnPropertyDescriptor(o, 'b'); \
             '' + da.writable + ',' + da.configurable + ',' + db.writable + ',' + db.configurable",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("false,false,false,false".into()));
    }

    /// `Object.isFrozen` returns false for extensible objects.
    #[test]
    fn test_is_frozen_false_for_normal_object() {
        let result = global_eval("Object.isFrozen({a: 1})").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.seal` preserves writability but removes configurability.
    #[test]
    fn test_seal_preserves_writable_removes_configurable() {
        let result = global_eval(
            "var o = {a: 1}; Object.seal(o); \
             var d = Object.getOwnPropertyDescriptor(o, 'a'); \
             '' + d.writable + ',' + d.configurable",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("true,false".into()));
    }

    /// `Object.isSealed` returns false for extensible objects.
    #[test]
    fn test_is_sealed_false_for_normal_object() {
        let result = global_eval("Object.isSealed({a: 1})").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.preventExtensions` makes `Object.isExtensible` return false.
    #[test]
    fn test_prevent_extensions_is_extensible() {
        let result =
            global_eval("var o = {}; Object.preventExtensions(o); Object.isExtensible(o)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.defineProperty` redefining a non-configurable property with
    /// `configurable: true` should throw TypeError.
    #[test]
    fn test_define_property_nonconfig_to_config_throws() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, configurable: false }); \
             try { Object.defineProperty(o, 'x', { configurable: true }); 'no error'; } \
             catch(e) { 'error'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("error".into()));
    }

    /// `Object.defineProperty` widening writable on non-configurable should throw.
    #[test]
    fn test_define_property_nonconfig_writable_false_to_true_throws() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: false, configurable: false }); \
             try { Object.defineProperty(o, 'x', { writable: true }); 'no error'; } \
             catch(e) { 'error'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("error".into()));
    }

    /// `Object.defineProperty` changing enumerable on non-configurable should throw.
    #[test]
    fn test_define_property_nonconfig_enumerable_change_throws() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, enumerable: false, configurable: false }); \
             try { Object.defineProperty(o, 'x', { enumerable: true }); 'no error'; } \
             catch(e) { 'error'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("error".into()));
    }

    /// `Object.defineProperty` changing value on non-writable non-configurable
    /// should throw.
    #[test]
    fn test_define_property_nonconfig_nonwritable_value_change_throws() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: false, configurable: false }); \
             try { Object.defineProperty(o, 'x', { value: 2 }); 'no error'; } \
             catch(e) { 'error'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("error".into()));
    }

    /// Redefining with the same value on non-writable non-configurable should
    /// succeed (no-op).
    #[test]
    fn test_define_property_nonconfig_same_value_ok() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: false, configurable: false }); \
             Object.defineProperty(o, 'x', { value: 1 }); o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Object.keys` returns own enumerable keys in insertion order.
    #[test]
    fn test_object_keys_insertion_order() {
        let result = global_eval("Object.keys({b: 1, a: 2, c: 3}).join(',')").unwrap();
        assert_eq!(result, JsValue::String("b,a,c".into()));
    }

    /// `Object.keys` skips non-enumerable properties.
    #[test]
    fn test_object_keys_skips_non_enumerable() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'a', { value: 1, enumerable: true }); \
             Object.defineProperty(o, 'b', { value: 2, enumerable: false }); \
             Object.defineProperty(o, 'c', { value: 3, enumerable: true }); \
             Object.keys(o).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("a,c".into()));
    }

    /// `Object.getOwnPropertyNames` includes non-enumerable property names.
    #[test]
    fn test_gopn_includes_all_own() {
        let result = global_eval(
            "var o = {a: 1}; \
             Object.defineProperty(o, 'b', { value: 2, enumerable: false }); \
             Object.getOwnPropertyNames(o).sort().join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("a,b".into()));
    }

    /// `Object.freeze` prevents new property addition.
    #[test]
    fn test_freeze_prevents_new_properties() {
        let result = global_eval("var o = Object.freeze({}); o.x = 1; typeof o.x").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    /// `Object.seal` prevents new property addition.
    #[test]
    fn test_seal_prevents_new_properties() {
        let result = global_eval("var o = Object.seal({a: 1}); o.b = 2; typeof o.b").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    /// `Object.setPrototypeOf` on non-extensible throws TypeError.
    #[test]
    fn test_set_prototype_non_extensible_throws() {
        let result = global_eval(
            "var o = Object.preventExtensions({}); \
             try { Object.setPrototypeOf(o, {x: 1}); 'no error'; } \
             catch(e) { 'error'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("error".into()));
    }

    /// `Object.getPrototypeOf` returns `Object.prototype` for ordinary objects.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_get_prototype_of_plain_object() {
        let result = global_eval("Object.getPrototypeOf({}) === Object.prototype").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.isExtensible` returns false for primitives.
    #[test]
    fn test_is_extensible_primitive() {
        let result = global_eval("Object.isExtensible(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.isFrozen` returns true for primitives.
    #[test]
    fn test_is_frozen_primitive() {
        let result = global_eval("Object.isFrozen(42)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.isSealed` returns true for primitives.
    #[test]
    fn test_is_sealed_primitive() {
        let result = global_eval("Object.isSealed('hello')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.freeze` on a non-object returns the value unchanged.
    #[test]
    fn test_freeze_primitive_returns_value() {
        let result = global_eval("Object.freeze(42)").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.defineProperty` on frozen object throws TypeError.
    #[test]
    fn test_define_property_on_frozen_throws() {
        let result = global_eval(
            "try { var o = Object.freeze({}); Object.defineProperty(o, 'x', { value: 1 }); 'no error'; } \
             catch(e) { 'error'; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("error".into()));
    }

    // ── Annex B: escape / unescape e2e ──────────────────────────────────

    /// `escape` encodes special characters.
    #[test]
    fn e2e_escape_basic() {
        let result = global_eval("escape('hello world')").unwrap();
        assert_eq!(result, JsValue::String("hello%20world".into()));
    }

    /// `unescape` reverses `escape`.
    #[test]
    fn e2e_unescape_basic() {
        let result = global_eval("unescape('hello%20world')").unwrap();
        assert_eq!(result, JsValue::String("hello world".into()));
    }

    /// `escape.length` is 1 per spec.
    #[test]
    fn e2e_escape_length() {
        let result = global_eval("escape.length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `unescape.length` is 1 per spec.
    #[test]
    fn e2e_unescape_length() {
        let result = global_eval("unescape.length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    // ── Annex B: String.prototype.substr e2e ────────────────────────────

    /// `substr` with positive start and length.
    #[test]
    fn e2e_substr_basic() {
        let result = global_eval("'hello'.substr(1, 3)").unwrap();
        assert_eq!(result, JsValue::String("ell".into()));
    }

    /// `substr` with negative start counts from end.
    #[test]
    fn e2e_substr_negative_start() {
        let result = global_eval("'hello'.substr(-3, 2)").unwrap();
        assert_eq!(result, JsValue::String("ll".into()));
    }

    /// `substr.length` is 2 per spec.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_substr_length_prop() {
        let result = global_eval("''.substr.length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    // ── Annex B: HTML wrapper methods e2e ────────────────────────────────

    /// `bold()` wraps in `<b>` tags.
    #[test]
    fn e2e_string_bold() {
        let result = global_eval("'text'.bold()").unwrap();
        assert_eq!(result, JsValue::String("<b>text</b>".into()));
    }

    /// `anchor(name)` wraps in `<a name="…">` and escapes quotes.
    #[test]
    fn e2e_string_anchor_quote_escape() {
        let result = global_eval(r#"'text'.anchor('a"b')"#).unwrap();
        assert_eq!(
            result,
            JsValue::String("<a name=\"a&quot;b\">text</a>".into())
        );
    }

    /// `link(url)` wraps in `<a href="…">`.
    #[test]
    fn e2e_string_link() {
        let result = global_eval("'click'.link('http://x')").unwrap();
        assert_eq!(
            result,
            JsValue::String("<a href=\"http://x\">click</a>".into())
        );
    }

    /// `italics()` wraps in `<i>` tags.
    #[test]
    fn e2e_string_italics() {
        let result = global_eval("'text'.italics()").unwrap();
        assert_eq!(result, JsValue::String("<i>text</i>".into()));
    }

    /// HTML method `.name` property is set correctly.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_html_method_name() {
        let result = global_eval("''.bold.name").unwrap();
        assert_eq!(result, JsValue::String("bold".into()));
    }

    /// HTML method `.length` property is set correctly.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_html_method_length() {
        let result = global_eval("''.anchor.length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    // ── Annex B: trimLeft / trimRight name properties ───────────────────

    /// `trimLeft.name` is `"trimStart"` per spec.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_trim_left_name() {
        let result = global_eval("''.trimLeft.name").unwrap();
        assert_eq!(result, JsValue::String("trimStart".into()));
    }

    /// `trimRight.name` is `"trimEnd"` per spec.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_trim_right_name() {
        let result = global_eval("''.trimRight.name").unwrap();
        assert_eq!(result, JsValue::String("trimEnd".into()));
    }

    // ── Symbol.species tests ─────────────────────────────────────────────

    /// `Array[Symbol.species]` is `Array` itself.
    #[test]
    fn test_array_species_returns_constructor() {
        let result = global_eval("Array[Symbol.species] === Array").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Map[Symbol.species]` is `Map` itself.
    #[test]
    fn test_map_species_returns_constructor() {
        let result = global_eval("Map[Symbol.species] === Map").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Set[Symbol.species]` is `Set` itself.
    #[test]
    fn test_set_species_returns_constructor() {
        let result = global_eval("Set[Symbol.species] === Set").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Promise[Symbol.species]` is `Promise` itself.
    #[test]
    fn test_promise_species_returns_constructor() {
        let result = global_eval("Promise[Symbol.species] === Promise").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `RegExp[Symbol.species]` is `RegExp` itself.
    #[test]
    fn test_regexp_species_returns_constructor() {
        let result = global_eval("RegExp[Symbol.species] === RegExp").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `ArrayBuffer[Symbol.species]` is `ArrayBuffer` itself.
    #[test]
    fn test_arraybuffer_species_returns_constructor() {
        let result = global_eval("ArrayBuffer[Symbol.species] === ArrayBuffer").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_arraybuffer_constructor_allocates_length() {
        assert_eval_true("new ArrayBuffer(6).byteLength === 6");
    }

    #[test]
    fn e2e_arraybuffer_constructor_defaults_to_zero() {
        assert_eval_true("new ArrayBuffer().byteLength === 0");
    }

    #[test]
    fn e2e_arraybuffer_constructor_truncates_fractional_lengths() {
        assert_eval_true("new ArrayBuffer(3.9).byteLength === 3");
    }

    #[test]
    fn e2e_arraybuffer_constructor_treats_nan_as_zero() {
        assert_eval_true("new ArrayBuffer(NaN).byteLength === 0");
    }

    #[test]
    fn e2e_arraybuffer_constructor_rejects_negative_lengths() {
        assert_eval_true(
            "try { new ArrayBuffer(-1); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    fn e2e_arraybuffer_byte_length_is_inherited_accessor() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4); !buf.hasOwnProperty('byteLength') && buf.byteLength === 4",
        );
    }

    #[test]
    fn e2e_arraybuffer_byte_length_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength').get === 'function'",
        );
    }

    #[test]
    fn e2e_arraybuffer_slice_is_inherited_method() {
        assert_eval_true("var buf = new ArrayBuffer(4); buf.slice === ArrayBuffer.prototype.slice");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_slice_copies_requested_range() {
        assert_eval_true(
            "var bytes = new Uint8Array([10,20,30,40]); var sliced = bytes.buffer.slice(1, 3); new Uint8Array(sliced).join(',') === '20,30'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_slice_supports_negative_indices() {
        assert_eval_true(
            "var bytes = new Uint8Array([10,20,30,40]); new Uint8Array(bytes.buffer.slice(-2)).join(',') === '30,40'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_slice_uses_receiver() {
        assert_eval_true(
            "var bytes = new Uint8Array([1,2,3,4]); var slice = ArrayBuffer.prototype.slice; new Uint8Array(slice.call(bytes.buffer, 1, 3)).join(',') === '2,3'",
        );
    }

    #[test]
    fn e2e_arraybuffer_slice_rejects_incompatible_receiver() {
        assert_eval_true(
            "try { ArrayBuffer.prototype.slice.call({}, 0); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_slice_returns_independent_copy() {
        assert_eval_true(
            "var bytes = new Uint8Array([1,2,3]); var sliced = bytes.buffer.slice(0); bytes[0] = 9; new Uint8Array(sliced)[0] === 1",
        );
    }

    #[test]
    fn e2e_arraybuffer_is_view_accepts_typed_arrays() {
        assert_eval_true("ArrayBuffer.isView(new Uint8Array(2))");
    }

    #[test]
    fn e2e_arraybuffer_is_view_accepts_dataviews() {
        assert_eval_true("ArrayBuffer.isView(new DataView(new ArrayBuffer(2)))");
    }

    #[test]
    fn e2e_arraybuffer_is_view_rejects_arraybuffers() {
        assert_eval_true("!ArrayBuffer.isView(new ArrayBuffer(2))");
    }

    #[test]
    fn e2e_arraybuffer_instances_use_constructor_prototype() {
        assert_eval_true("Object.getPrototypeOf(new ArrayBuffer(1)) === ArrayBuffer.prototype");
    }

    #[test]
    fn e2e_arraybuffer_to_string_tag_property_is_exposed_on_prototype() {
        assert_eval_true("ArrayBuffer.prototype[Symbol.toStringTag] === 'ArrayBuffer'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_object_to_string_uses_arraybuffer_tag() {
        assert_eval_true(
            "Object.prototype.toString.call(new ArrayBuffer(1)) === '[object ArrayBuffer]'",
        );
    }

    #[test]
    fn e2e_arraybuffer_constructor_with_max_byte_length_is_resizable() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); buf.resizable && buf.maxByteLength === 8 && buf.byteLength === 4",
        );
    }

    #[test]
    fn e2e_arraybuffer_constructor_rejects_too_small_max_byte_length() {
        assert_eval_true(
            "try { new ArrayBuffer(4, { maxByteLength: 3 }); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    fn e2e_arraybuffer_resizable_defaults_false() {
        assert_eval_true("new ArrayBuffer(4).resizable === false");
    }

    #[test]
    fn e2e_arraybuffer_max_byte_length_defaults_to_current_length() {
        assert_eval_true("new ArrayBuffer(4).maxByteLength === 4");
    }

    #[test]
    fn e2e_arraybuffer_detached_defaults_false() {
        assert_eval_true("new ArrayBuffer(4).detached === false");
    }

    #[test]
    fn e2e_arraybuffer_resizable_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'resizable').get === 'function'",
        );
    }

    #[test]
    fn e2e_arraybuffer_max_byte_length_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'maxByteLength').get === 'function'",
        );
    }

    #[test]
    fn e2e_arraybuffer_detached_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'detached').get === 'function'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_resize_grows_in_place() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var bytes = new Uint8Array(buf); bytes[0] = 1; buf.resize(6); buf.byteLength === 6 && bytes.length === 6 && bytes[0] === 1 && bytes[5] === 0",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_resize_shrinks_in_place() {
        assert_eval_true(
            "var buf = new ArrayBuffer(6, { maxByteLength: 8 }); var bytes = new Uint8Array(buf); bytes[0] = 1; bytes[1] = 2; buf.resize(2); buf.byteLength === 2 && bytes.length === 2 && bytes.join(',') === '1,2'",
        );
    }

    #[test]
    fn e2e_arraybuffer_resize_rejects_non_resizable_buffer() {
        assert_eval_true(
            "try { new ArrayBuffer(4).resize(5); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_resize_rejects_growing_past_max() {
        assert_eval_true(
            "try { new ArrayBuffer(4, { maxByteLength: 6 }).resize(7); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_transfer_detaches_source() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var moved = buf.transfer(); buf.detached === true && buf.byteLength === 0 && moved.byteLength === 4 && moved.detached === false",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_transfer_copies_bytes() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var bytes = new Uint8Array(buf); bytes[0] = 10; bytes[1] = 20; bytes[2] = 30; bytes[3] = 40; var moved = buf.transfer(); new Uint8Array(moved).join(',') === '10,20,30,40'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_transfer_can_change_length() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var bytes = new Uint8Array(buf); bytes[0] = 1; bytes[1] = 2; var moved = buf.transfer(6); moved.byteLength === 6 && moved.resizable === true && new Uint8Array(moved).join(',') === '1,2,0,0,0,0'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_transfer_preserves_max_byte_length() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var moved = buf.transfer(6); moved.maxByteLength === 8 && moved.resizable === true",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_transfer_to_fixed_length_returns_fixed_buffer() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var moved = buf.transferToFixedLength(); moved.resizable === false && moved.maxByteLength === 4 && moved.byteLength === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_transfer_to_fixed_length_with_new_length() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var moved = buf.transferToFixedLength(6); moved.resizable === false && moved.maxByteLength === 6 && moved.byteLength === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_transfer_rejects_length_past_max() {
        assert_eval_true(
            "try { new ArrayBuffer(4, { maxByteLength: 6 }).transfer(7); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arraybuffer_transfer_rejects_detached_source() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); buf.transfer(); try { buf.transfer(); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_auto_length_tracks_resizable_growth() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var ta = new Uint8Array(buf); buf.resize(6); ta.length === 6 && ta.byteLength === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_auto_length_tracks_resizable_shrink() {
        assert_eval_true(
            "var buf = new ArrayBuffer(6, { maxByteLength: 8 }); var ta = new Uint8Array(buf); buf.resize(2); ta.length === 2 && ta.byteLength === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_auto_length_join_tracks_resize() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var ta = new Uint8Array(buf); ta[0] = 1; ta[1] = 2; buf.resize(2); ta.join(',') === '1,2'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_buffer_identity_survives_resize() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var ta = new Uint8Array(buf); buf.resize(6); ta.buffer === buf",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_fixed_length_view_stays_fixed_on_growth() {
        assert_eval_true(
            "var buf = new ArrayBuffer(4, { maxByteLength: 8 }); var ta = new Uint16Array(buf, 0, 2); buf.resize(8); ta.length === 2 && ta.byteLength === 4",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_constructor_allocates_length() {
        assert_eval_true("new SharedArrayBuffer(6).byteLength === 6");
    }

    #[test]
    fn e2e_shared_arraybuffer_constructor_defaults_to_zero() {
        assert_eval_true("new SharedArrayBuffer().byteLength === 0");
    }

    #[test]
    fn e2e_shared_arraybuffer_constructor_truncates_fractional_lengths() {
        assert_eval_true("new SharedArrayBuffer(3.9).byteLength === 3");
    }

    #[test]
    fn e2e_shared_arraybuffer_constructor_rejects_negative_lengths() {
        assert_eval_true(
            "try { new SharedArrayBuffer(-1); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_instances_use_constructor_prototype() {
        assert_eval_true(
            "Object.getPrototypeOf(new SharedArrayBuffer(1)) === SharedArrayBuffer.prototype",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_byte_length_is_inherited_accessor() {
        assert_eval_true(
            "var buf = new SharedArrayBuffer(4); !buf.hasOwnProperty('byteLength') && buf.byteLength === 4",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_byte_length_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'byteLength').get === 'function'",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_slice_is_inherited_method() {
        assert_eval_true(
            "var buf = new SharedArrayBuffer(4); buf.slice === SharedArrayBuffer.prototype.slice",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_arraybuffer_slice_copies_requested_range() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(4); var bytes = new Uint8Array(sab); bytes[0] = 10; bytes[1] = 20; bytes[2] = 30; bytes[3] = 40; var sliced = sab.slice(1, 3); Object.prototype.toString.call(sliced) === '[object SharedArrayBuffer]' && new Uint8Array(sliced).join(',') === '20,30'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_arraybuffer_slice_supports_negative_indices() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(4); var bytes = new Uint8Array(sab); bytes[0] = 10; bytes[1] = 20; bytes[2] = 30; bytes[3] = 40; new Uint8Array(sab.slice(-2)).join(',') === '30,40'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_arraybuffer_slice_returns_independent_copy() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(3); var bytes = new Uint8Array(sab); bytes[0] = 1; bytes[1] = 2; bytes[2] = 3; var sliced = sab.slice(0); bytes[0] = 9; new Uint8Array(sliced)[0] === 1",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_slice_rejects_arraybuffer_receiver() {
        assert_eval_true(
            "try { SharedArrayBuffer.prototype.slice.call(new ArrayBuffer(4), 0); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_to_string_tag_property_is_exposed_on_prototype() {
        assert_eval_true("SharedArrayBuffer.prototype[Symbol.toStringTag] === 'SharedArrayBuffer'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_arraybuffer_object_to_string_uses_shared_arraybuffer_tag() {
        assert_eval_true(
            "Object.prototype.toString.call(new SharedArrayBuffer(1)) === '[object SharedArrayBuffer]'",
        );
    }

    #[test]
    fn e2e_shared_typed_array_buffer_preserves_identity() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(8); var ta = new Int32Array(sab); ta.buffer === sab",
        );
    }

    #[test]
    fn e2e_shared_typed_array_subarray_preserves_shared_buffer_identity() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(8); var ta = new Int32Array(sab); ta.subarray(1).buffer === sab",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_constructor_with_max_byte_length_is_growable() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(4, { maxByteLength: 8 }); sab.growable && sab.maxByteLength === 8 && sab.byteLength === 4",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_constructor_rejects_too_small_max_byte_length() {
        assert_eval_true(
            "try { new SharedArrayBuffer(4, { maxByteLength: 3 }); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_growable_defaults_false() {
        assert_eval_true("new SharedArrayBuffer(4).growable === false");
    }

    #[test]
    fn e2e_shared_arraybuffer_growable_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'growable').get === 'function'",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_max_byte_length_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'maxByteLength').get === 'function'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_arraybuffer_grow_increases_byte_length() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(4, { maxByteLength: 8 }); sab.grow(6); sab.byteLength === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_arraybuffer_grow_preserves_existing_bytes() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(4, { maxByteLength: 8 }); var ta = new Uint8Array(sab); ta[0] = 7; sab.grow(6); ta.length === 6 && ta[0] === 7 && ta[5] === 0",
        );
    }

    #[test]
    fn e2e_shared_arraybuffer_grow_rejects_non_growable_buffer() {
        assert_eval_true(
            "try { new SharedArrayBuffer(4).grow(5); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_arraybuffer_grow_rejects_shrinking() {
        assert_eval_true(
            "try { new SharedArrayBuffer(4, { maxByteLength: 8 }).grow(3); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_arraybuffer_grow_rejects_length_past_max() {
        assert_eval_true(
            "try { new SharedArrayBuffer(4, { maxByteLength: 6 }).grow(7); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_typed_array_auto_length_tracks_growth() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(4, { maxByteLength: 8 }); var ta = new Uint8Array(sab); sab.grow(6); ta.length === 6 && ta.byteLength === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_shared_typed_array_fixed_length_view_stays_fixed_on_growth() {
        assert_eval_true(
            "var sab = new SharedArrayBuffer(4, { maxByteLength: 8 }); var ta = new Uint16Array(sab, 0, 2); sab.grow(8); ta.length === 2 && ta.byteLength === 4",
        );
    }

    #[test]
    fn e2e_dataview_constructor_uses_full_buffer_by_default() {
        assert_eval_true("new DataView(new ArrayBuffer(8)).byteLength === 8");
    }

    #[test]
    fn e2e_dataview_constructor_respects_offset_and_length() {
        assert_eval_true(
            "var view = new DataView(new ArrayBuffer(8), 2, 4); view.byteOffset === 2 && view.byteLength === 4",
        );
    }

    #[test]
    fn e2e_dataview_constructor_truncates_fractional_offset() {
        assert_eval_true("new DataView(new ArrayBuffer(8), 1.9).byteOffset === 1");
    }

    #[test]
    fn e2e_dataview_constructor_treats_nan_offset_as_zero() {
        assert_eval_true("new DataView(new ArrayBuffer(8), NaN).byteOffset === 0");
    }

    #[test]
    fn e2e_dataview_constructor_rejects_negative_offset() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(8), -1); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    fn e2e_dataview_constructor_rejects_invalid_length() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(8), 4, 5); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    fn e2e_dataview_buffer_getter_preserves_identity() {
        assert_eval_true("var buf = new ArrayBuffer(8); new DataView(buf).buffer === buf");
    }

    #[test]
    fn e2e_dataview_buffer_getter_is_inherited_accessor() {
        assert_eval_true(
            "var buf = new ArrayBuffer(8); var view = new DataView(buf); !view.hasOwnProperty('buffer') && view.buffer === buf",
        );
    }

    #[test]
    fn e2e_dataview_byte_length_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength').get === 'function'",
        );
    }

    #[test]
    fn e2e_dataview_byte_offset_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(DataView.prototype, 'byteOffset').get === 'function'",
        );
    }

    #[test]
    fn e2e_dataview_buffer_descriptor_is_getter() {
        assert_eval_true(
            "typeof Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer').get === 'function'",
        );
    }

    #[test]
    fn e2e_dataview_instances_use_constructor_prototype() {
        assert_eval_true(
            "Object.getPrototypeOf(new DataView(new ArrayBuffer(1))) === DataView.prototype",
        );
    }

    #[test]
    fn e2e_dataview_to_string_tag_property_is_exposed_on_prototype() {
        assert_eval_true("DataView.prototype[Symbol.toStringTag] === 'DataView'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_object_to_string_uses_dataview_tag() {
        assert_eval_true(
            "Object.prototype.toString.call(new DataView(new ArrayBuffer(1))) === '[object DataView]'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_int8_and_uint8() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(2)); v.setInt8(0, -1); v.getInt8(0) === -1 && v.getUint8(0) === 255",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_and_set_uint16_big_endian_by_default() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(2)); v.setUint16(0, 0x1234); v.getUint16(0) === 0x1234",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_and_set_uint16_little_endian() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(2)); v.setUint16(0, 0x1234, true); v.getUint16(0, true) === 0x1234 && v.getUint8(0) === 0x34 && v.getUint8(1) === 0x12",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_and_set_int16_little_endian() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(2)); v.setInt16(0, -2, true); v.getInt16(0, true) === -2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_and_set_uint32_little_endian() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(4)); v.setUint32(0, 0x01020304, true); v.getUint32(0, true) === 0x01020304 && v.getUint8(0) === 4 && v.getUint8(3) === 1",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_and_set_int32_big_endian() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(4)); v.setInt32(0, -1234567); v.getInt32(0) === -1234567",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_and_set_float32() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(4)); v.setFloat32(0, 1.5, true); v.getFloat32(0, true) === 1.5",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_and_set_float64() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(8)); v.setFloat64(0, 12.25, true); v.getFloat64(0, true) === 12.25",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_prototype_methods_use_receiver() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(1)); v.setUint8(0, 99); DataView.prototype.getUint8.call(v, 0) === 99",
        );
    }

    #[test]
    fn e2e_dataview_prototype_methods_reject_incompatible_receiver() {
        assert_eval_true(
            "try { DataView.prototype.getUint8.call({}, 0); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_getters_reject_negative_offsets() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(4)).getUint8(-1); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_setters_reject_negative_offsets() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(4)).setUint8(-1, 1); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_getters_reject_out_of_bounds_reads() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(2)).getUint32(0); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_setters_reject_out_of_bounds_writes() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(2)).setUint32(0, 1); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_int16_big_endian_interprets_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(2)); v.setUint8(0, 0x12); v.setUint8(1, 0x34); v.getInt16(0) === 0x1234",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_uint16_big_endian_respects_view_offset() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(4), 1, 2); v.setUint8(0, 0xaa); v.setUint8(1, 0xbb); v.getUint16(0) === 0xaabb",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_int32_big_endian_interprets_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(4)); v.setUint8(0, 1); v.setUint8(1, 2); v.setUint8(2, 3); v.setUint8(3, 4); v.getInt32(0) === 0x01020304",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_float32_big_endian_interprets_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(4)); v.setUint8(0, 0x3f); v.setUint8(1, 0x80); v.setUint8(2, 0x00); v.setUint8(3, 0x00); v.getFloat32(0) === 1",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_float64_big_endian_interprets_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(8)); v.setUint8(0, 0x3f); v.setUint8(1, 0xf0); v.setUint8(2, 0x00); v.setUint8(3, 0x00); v.setUint8(4, 0x00); v.setUint8(5, 0x00); v.setUint8(6, 0x00); v.setUint8(7, 0x00); v.getFloat64(0) === 1",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_bigint64_big_endian_interprets_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(8)); v.setUint8(0, 0xff); v.setUint8(1, 0xff); v.setUint8(2, 0xff); v.setUint8(3, 0xff); v.setUint8(4, 0xff); v.setUint8(5, 0xff); v.setUint8(6, 0xff); v.setUint8(7, 0xfe); v.getBigInt64(0) === -2n",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_get_biguint64_little_endian_interprets_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(8)); v.setUint8(0, 0x08); v.setUint8(1, 0x07); v.setUint8(2, 0x06); v.setUint8(3, 0x05); v.setUint8(4, 0x04); v.setUint8(5, 0x03); v.setUint8(6, 0x02); v.setUint8(7, 0x01); v.getBigUint64(0, true) === BigInt('72623859790382856')",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_set_bigint64_little_endian_round_trips_and_writes_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(8)); v.setBigInt64(0, -2n, true); v.getBigInt64(0, true) === -2n && v.getUint8(0) === 0xfe && v.getUint8(7) === 0xff",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_set_biguint64_big_endian_round_trips_and_writes_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(8)); v.setBigUint64(0, BigInt('0x0102030405060708')); v.getBigUint64(0) === BigInt('0x0102030405060708') && v.getUint8(0) === 0x01 && v.getUint8(7) === 0x08",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_set_int16_big_endian_writes_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(2)); v.setInt16(0, 0x1234); v.getUint8(0) === 0x12 && v.getUint8(1) === 0x34",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_set_int32_big_endian_writes_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(4)); v.setInt32(0, 0x01020304); v.getUint8(0) === 0x01 && v.getUint8(1) === 0x02 && v.getUint8(2) === 0x03 && v.getUint8(3) === 0x04",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_set_float32_big_endian_writes_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(4)); v.setFloat32(0, 1); v.getUint8(0) === 0x3f && v.getUint8(1) === 0x80 && v.getUint8(2) === 0x00 && v.getUint8(3) === 0x00",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_set_float64_big_endian_writes_bytes() {
        assert_eval_true(
            "var v = new DataView(new ArrayBuffer(8)); v.setFloat64(0, 1); v.getUint8(0) === 0x3f && v.getUint8(1) === 0xf0 && v.getUint8(2) === 0x00 && v.getUint8(3) === 0x00 && v.getUint8(4) === 0x00 && v.getUint8(5) === 0x00 && v.getUint8(6) === 0x00 && v.getUint8(7) === 0x00",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_getters_reject_detached_buffer_after_transfer() {
        assert_eval_true(
            "var buf = new ArrayBuffer(8, { maxByteLength: 16 }); var view = new DataView(buf); buf.transfer(); try { view.getUint8(0); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_setters_reject_detached_buffer_after_transfer() {
        assert_eval_true(
            "var buf = new ArrayBuffer(8, { maxByteLength: 16 }); var view = new DataView(buf); buf.transfer(); try { view.setUint8(0, 1); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_byte_length_getter_rejects_detached_buffer_after_transfer() {
        assert_eval_true(
            "var buf = new ArrayBuffer(8, { maxByteLength: 16 }); var view = new DataView(buf); buf.transfer(); try { view.byteLength; false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_byte_offset_getter_rejects_detached_buffer_after_transfer() {
        assert_eval_true(
            "var buf = new ArrayBuffer(8, { maxByteLength: 16 }); var view = new DataView(buf, 2, 4); buf.transfer(); try { view.byteOffset; false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_constructor_rejects_detached_buffer() {
        assert_eval_true(
            "var buf = new ArrayBuffer(8, { maxByteLength: 16 }); buf.transfer(); try { new DataView(buf); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_dataview_bigint_setters_reject_number_values() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(8)).setBigInt64(0, 1); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_dataview_biguint_setters_reject_number_values() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(8)).setBigUint64(0, 1); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_shared_arraybuffer_round_trips() {
        assert_eval_true(
            "var buf = new SharedArrayBuffer(8); var view = new DataView(buf); view.setUint32(0, 0x01020304, true); view.getUint32(0, true) === 0x01020304 && view.buffer === buf",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_bounds_check_uses_view_length_not_buffer_length() {
        assert_eval_true(
            "try { new DataView(new ArrayBuffer(8), 2, 2).getUint32(0); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_dataview_bounds_check_allows_last_byte_within_view() {
        assert_eval_true(
            "var view = new DataView(new ArrayBuffer(4), 1, 2); view.setUint8(1, 7); view.getUint8(1) === 7",
        );
    }

    /// `Int32Array[Symbol.species]` is `Int32Array` itself.
    #[test]
    fn test_typed_array_species_returns_constructor() {
        let result = global_eval("Int32Array[Symbol.species] === Int32Array").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    macro_rules! typed_array_constructor_exists_test {
        ($(#[$meta:meta])* $name:ident, $ctor:literal) => {
            $(#[$meta])*
            #[test]
            fn $name() {
                assert_eval_true(concat!(
                    "typeof ",
                    $ctor,
                    " !== 'undefined' && ",
                    $ctor,
                    ".name === '",
                    $ctor,
                    "'"
                ));
            }
        };
    }

    typed_array_constructor_exists_test!(test_typed_array_ctor_uint8_exists, "Uint8Array");
    typed_array_constructor_exists_test!(test_typed_array_ctor_int8_exists, "Int8Array");
    typed_array_constructor_exists_test!(test_typed_array_ctor_uint16_exists, "Uint16Array");
    typed_array_constructor_exists_test!(test_typed_array_ctor_int16_exists, "Int16Array");
    typed_array_constructor_exists_test!(test_typed_array_ctor_uint32_exists, "Uint32Array");
    typed_array_constructor_exists_test!(test_typed_array_ctor_int32_exists, "Int32Array");
    typed_array_constructor_exists_test!(test_typed_array_ctor_float32_exists, "Float32Array");
    typed_array_constructor_exists_test!(test_typed_array_ctor_float64_exists, "Float64Array");
    typed_array_constructor_exists_test!(
        test_typed_array_ctor_uint8_clamped_exists,
        "Uint8ClampedArray"
    );
    typed_array_constructor_exists_test!(test_typed_array_ctor_bigint64_exists, "BigInt64Array");
    typed_array_constructor_exists_test!(test_typed_array_ctor_biguint64_exists, "BigUint64Array");

    #[test]
    fn e2e_typed_array_constructor_from_length() {
        assert_eval_true("new Uint8Array(4).length === 4");
    }

    #[test]
    fn e2e_typed_array_constructor_from_array() {
        assert_eval_true("new Uint8Array([1,2,3]).join(',') === '1,2,3'");
    }

    #[test]
    fn e2e_typed_array_constructor_from_array_like() {
        assert_eval_true("new Uint8Array({0: 4, 1: 5, length: 2}).join(',') === '4,5'");
    }

    #[test]
    fn e2e_typed_array_length_property() {
        assert_eval_true("new Uint8Array([1,2,3]).length === 3");
    }

    #[test]
    fn e2e_typed_array_byte_length_property() {
        assert_eval_true("new Uint16Array(3).byteLength === 6");
    }

    #[test]
    fn e2e_typed_array_byte_offset_property() {
        assert_eval_true("new Uint16Array([1,2,3]).subarray(1).byteOffset === 2");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_buffer_property() {
        assert_eval_true("new Uint8Array(4).buffer.byteLength === 4");
    }

    #[test]
    fn e2e_typed_array_set_from_array() {
        assert_eval_true("var a = new Uint8Array(4); a.set([7,8], 1); a.join(',') === '0,7,8,0'");
    }

    #[test]
    fn e2e_typed_array_set_from_typed_array() {
        assert_eval_true(
            "var src = new Uint8Array([7,8]); var dst = new Uint8Array(4); dst.set(src, 1); dst.join(',') === '0,7,8,0'",
        );
    }

    #[test]
    fn e2e_typed_array_subarray_shares_buffer() {
        assert_eval_true(
            "var a = new Uint8Array([1,2,3]); var sub = a.subarray(1); sub.set([9], 0); a.join(',') === '1,9,3'",
        );
    }

    #[test]
    fn e2e_typed_array_slice_copies_values() {
        assert_eval_true(
            "var a = new Uint8Array([1,2,3]); var s = a.slice(1); a.set([9], 1); s.join(',') === '2,3'",
        );
    }

    #[test]
    fn e2e_typed_array_copy_within_mutates() {
        assert_eval_true(
            "var a = new Uint8Array([1,2,3,4]); a.copyWithin(1, 0, 2) === a && a.join(',') === '1,1,2,4'",
        );
    }

    #[test]
    fn e2e_typed_array_map_uses_js_callback() {
        assert_eval_true(
            "var seen = 0; var result = new Uint8Array([1,2,3]).map(function(v, i, self) { seen = self.length; return v + i; }); seen === 3 && result.join(',') === '1,3,5'",
        );
    }

    #[test]
    fn e2e_typed_array_map_honors_this_arg() {
        assert_eval_true(
            "var ctx = { delta: 5 }; var result = new Uint8Array([1,2]).map(function(v) { return v + this.delta; }, ctx); result.join(',') === '6,7'",
        );
    }

    #[test]
    fn e2e_typed_array_filter_uses_js_callback() {
        assert_eval_true(
            "new Uint8Array([1,2,3,4]).filter(function(v) { return v % 2 === 0; }).join(',') === '2,4'",
        );
    }

    #[test]
    fn e2e_typed_array_filter_honors_this_arg() {
        assert_eval_true(
            "var ctx = { limit: 3 }; new Uint8Array([1,2,3,4]).filter(function(v) { return v > this.limit; }, ctx).join(',') === '4'",
        );
    }

    #[test]
    fn e2e_typed_array_find_uses_js_callback() {
        assert_eval_true("new Uint8Array([1,2,3]).find(function(v) { return v > 1; }) === 2");
    }

    #[test]
    fn e2e_typed_array_find_index_uses_js_callback() {
        assert_eval_true("new Uint8Array([1,2,3]).findIndex(function(v) { return v > 1; }) === 1");
    }

    #[test]
    fn e2e_typed_array_every_uses_js_callback() {
        assert_eval_true("new Uint8Array([2,4,6]).every(function(v) { return v % 2 === 0; })");
    }

    #[test]
    fn e2e_typed_array_some_uses_js_callback() {
        assert_eval_true("new Uint8Array([1,2,3]).some(function(v) { return v > 2; })");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_for_each_uses_js_callback() {
        assert_eval_true(
            "var sum = 0; new Uint8Array([1,2,3]).forEach(function(v, i, self) { sum += v + i + self.length; }); sum === 15",
        );
    }

    #[test]
    fn e2e_typed_array_for_each_honors_this_arg() {
        assert_eval_true(
            "var total = 0; new Uint8Array([1,2,3]).forEach(function(v) { total += v * this.mult; }, { mult: 2 }); total === 12",
        );
    }

    #[test]
    fn e2e_typed_array_reduce_uses_js_callback() {
        assert_eval_true(
            "new Uint8Array([1,2,3]).reduce(function(acc, v) { return acc + v; }, 0) === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_reduce_passes_receiver() {
        assert_eval_true(
            "new Uint8Array([1,2,3]).reduce(function(acc, v, i, self) { return acc + self.length + i + v; }, 0) === 15",
        );
    }

    #[test]
    fn e2e_typed_array_reduce_right_uses_js_callback() {
        assert_eval_true(
            "new Uint8Array([1,2,3]).reduceRight(function(acc, v) { return acc * 10 + v; }, 0) === 321",
        );
    }

    #[test]
    fn e2e_typed_array_static_from_array() {
        assert_eval_true("Uint8Array.from([4,5,6]).join(',') === '4,5,6'");
    }

    #[test]
    fn e2e_typed_array_static_from_array_like() {
        assert_eval_true("Uint8Array.from({0: 4, 1: 5, length: 2}).join(',') === '4,5'");
    }

    #[test]
    fn e2e_typed_array_static_from_typed_array() {
        assert_eval_true("Uint8Array.from(new Uint8Array([4,5])).join(',') === '4,5'");
    }

    #[test]
    fn e2e_typed_array_static_of() {
        assert_eval_true("Uint8Array.of(7,8,9).join(',') === '7,8,9'");
    }

    #[test]
    fn e2e_typed_array_to_string_tag_property() {
        assert_eval_true("new Uint8Array(1)[Symbol.toStringTag] === 'Uint8Array'");
    }

    #[test]
    fn e2e_typed_array_prototype_to_string_tag_property() {
        assert_eval_true("Uint8Array.prototype[Symbol.toStringTag] === 'Uint8Array'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_object_to_string_uses_tag() {
        assert_eval_true(
            "Object.prototype.toString.call(new Float64Array(1)) === '[object Float64Array]'",
        );
    }

    #[test]
    fn e2e_typed_array_fill_returns_receiver() {
        assert_eval_true("var a = new Uint8Array(2); a.fill(3) === a && a.join(',') === '3,3'");
    }

    #[test]
    fn e2e_typed_array_reverse_returns_receiver() {
        assert_eval_true(
            "var a = new Uint8Array([1,2,3]); a.reverse() === a && a.join(',') === '3,2,1'",
        );
    }

    #[test]
    fn e2e_typed_array_sort_returns_receiver() {
        assert_eval_true(
            "var a = new Uint8Array([3,1,2]); a.sort() === a && a.join(',') === '1,2,3'",
        );
    }

    // ── New TypedArray method e2e tests ──────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_sort_numeric_default() {
        assert_eval_true(
            "var a = new Int32Array([30, 10, 20]); a.sort(); a[0] === 10 && a[1] === 20 && a[2] === 30",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_sort_float64_negative() {
        assert_eval_true(
            "var a = new Float64Array([3.5, -1.5, 0, 2.5]); a.sort(); a[0] === -1.5 && a[1] === 0 && a[2] === 2.5 && a[3] === 3.5",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_fill_whole() {
        assert_eval_true(
            "var a = new Uint8Array(4); a.fill(7); a[0] === 7 && a[1] === 7 && a[2] === 7 && a[3] === 7",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_fill_negative_start() {
        assert_eval_true(
            "var a = new Uint8Array(4); a.fill(9, -2); a[0] === 0 && a[1] === 0 && a[2] === 9 && a[3] === 9",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_fill_with_range() {
        assert_eval_true(
            "var a = new Int32Array(5); a.fill(42, 1, 3); a[0] === 0 && a[1] === 42 && a[2] === 42 && a[3] === 0",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_copy_within_basic() {
        assert_eval_true(
            "var a = new Int32Array([1,2,3,4,5]); a.copyWithin(0, 3); a[0] === 4 && a[1] === 5 && a[2] === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_copy_within_negative() {
        assert_eval_true(
            "var a = new Int32Array([1,2,3,4,5]); a.copyWithin(-2, 0, 2); a[3] === 1 && a[4] === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_subarray_basic() {
        assert_eval_true(
            "var a = new Int32Array([10,20,30]); var s = a.subarray(1, 3); s.length === 2 && s[0] === 20 && s[1] === 30",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_subarray_negative() {
        assert_eval_true(
            "var a = new Uint8Array([1,2,3,4]); var s = a.subarray(-2); s.length === 2 && s[0] === 3 && s[1] === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_subarray_shared_buffer() {
        assert_eval_true(
            "var a = new Int32Array([1,2,3]); var s = a.subarray(1, 3); s[0] = 99; a[1] === 99",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_slice_copies() {
        assert_eval_true(
            "var a = new Int32Array([10,20,30]); var s = a.slice(1); s.length === 2 && s[0] === 20 && s[1] === 30",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_slice_negative() {
        assert_eval_true(
            "var a = new Int32Array([1,2,3,4]); var s = a.slice(-2); s.length === 2 && s[0] === 3 && s[1] === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_slice_does_not_share() {
        assert_eval_true(
            "var a = new Int32Array([1,2,3]); var s = a.slice(0); s[0] = 99; a[0] === 1",
        );
    }

    #[test]
    fn e2e_typed_array_find_returns_element() {
        assert_eval_true("new Int32Array([1,2,3,4]).find(function(x) { return x > 2; }) === 3");
    }

    #[test]
    fn e2e_typed_array_find_returns_undefined_if_not_found() {
        assert_eval_true(
            "new Int32Array([1,2,3]).find(function(x) { return x > 10; }) === undefined",
        );
    }

    #[test]
    fn e2e_typed_array_find_index_returns_index() {
        assert_eval_true(
            "new Int32Array([10,20,30]).findIndex(function(x) { return x === 20; }) === 1",
        );
    }

    #[test]
    fn e2e_typed_array_find_index_returns_neg_one() {
        assert_eval_true(
            "new Int32Array([1,2,3]).findIndex(function(x) { return x > 10; }) === -1",
        );
    }

    #[test]
    fn e2e_typed_array_every_true() {
        assert_eval_true(
            "new Int32Array([2,4,6]).every(function(x) { return x % 2 === 0; }) === true",
        );
    }

    #[test]
    fn e2e_typed_array_every_false() {
        assert_eval_true(
            "new Int32Array([2,3,4]).every(function(x) { return x % 2 === 0; }) === false",
        );
    }

    #[test]
    fn e2e_typed_array_some_true() {
        assert_eval_true(
            "new Int32Array([1,3,4]).some(function(x) { return x % 2 === 0; }) === true",
        );
    }

    #[test]
    fn e2e_typed_array_some_false() {
        assert_eval_true(
            "new Int32Array([1,3,5]).some(function(x) { return x % 2 === 0; }) === false",
        );
    }

    #[test]
    fn e2e_typed_array_reduce_sum() {
        assert_eval_true(
            "new Int32Array([1,2,3]).reduce(function(a, b) { return a + b; }, 0) === 6",
        );
    }

    #[test]
    fn e2e_typed_array_reduce_no_initial() {
        assert_eval_true("new Int32Array([1,2,3]).reduce(function(a, b) { return a + b; }) === 6");
    }

    #[test]
    fn e2e_typed_array_reduce_right_concat() {
        assert_eval_true(
            "new Uint8Array([1,2,3]).reduceRight(function(acc, v) { return acc * 10 + v; }, 0) === 321",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_map_double() {
        assert_eval_true(
            "var m = new Int32Array([1,2,3]).map(function(x) { return x * 2; }); m[0] === 2 && m[1] === 4 && m[2] === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_map_preserves_kind() {
        assert_eval_true(
            "new Uint8Array([1,2,3]).map(function(x) { return x * 2; }).constructor === Uint8Array",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_filter_basic() {
        assert_eval_true(
            "var f = new Int32Array([1,2,3,4]).filter(function(x) { return x > 2; }); f.length === 2 && f[0] === 3 && f[1] === 4",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_filter_preserves_kind() {
        assert_eval_true(
            "new Uint8Array([1,2,3]).filter(function(x) { return x > 1; }).constructor === Uint8Array",
        );
    }

    #[test]
    fn e2e_typed_array_for_each_side_effect() {
        assert_eval_true(
            "var sum = 0; new Int32Array([10,20,30]).forEach(function(x) { sum += x; }); sum === 60",
        );
    }

    #[test]
    fn e2e_typed_array_index_of_found() {
        assert_eval_true("new Int32Array([10,20,30]).indexOf(20) === 1");
    }

    #[test]
    fn e2e_typed_array_index_of_not_found() {
        assert_eval_true("new Int32Array([10,20,30]).indexOf(99) === -1");
    }

    #[test]
    fn e2e_typed_array_index_of_from_index() {
        assert_eval_true("new Int32Array([1,2,1,2]).indexOf(1, 1) === 2");
    }

    #[test]
    fn e2e_typed_array_includes_found() {
        assert_eval_true("new Int32Array([1,2,3]).includes(2) === true");
    }

    #[test]
    fn e2e_typed_array_includes_not_found() {
        assert_eval_true("new Int32Array([1,2,3]).includes(5) === false");
    }

    #[test]
    fn e2e_typed_array_last_index_of_basic() {
        assert_eval_true("new Int32Array([1,2,1,2]).lastIndexOf(1) === 2");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_reverse_basic() {
        assert_eval_true(
            "var a = new Int32Array([1,2,3]); a.reverse(); a[0] === 3 && a[1] === 2 && a[2] === 1",
        );
    }

    #[test]
    fn e2e_typed_array_reverse_returns_receiver_v2() {
        assert_eval_true("var a = new Int32Array([1,2,3]); a.reverse() === a");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_set_array_offset() {
        assert_eval_true(
            "var a = new Int32Array(5); a.set([10, 20], 2); a[2] === 10 && a[3] === 20 && a[0] === 0",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_set_typed_array() {
        assert_eval_true(
            "var a = new Int32Array(4); var b = new Int32Array([7, 8]); a.set(b, 1); a[1] === 7 && a[2] === 8",
        );
    }

    #[test]
    fn e2e_typed_array_at_positive() {
        assert_eval_true("new Int32Array([10,20,30]).at(1) === 20");
    }

    #[test]
    fn e2e_typed_array_at_negative() {
        assert_eval_true("new Int32Array([10,20,30]).at(-1) === 30");
    }

    #[test]
    fn e2e_typed_array_at_out_of_bounds() {
        assert_eval_true("new Int32Array([10]).at(5) === undefined");
    }

    #[test]
    fn e2e_typed_array_keys_iterator() {
        assert_eval_true(
            "var k = new Uint8Array([10,20,30]).keys(); var a = k.next(); a.value === 0 && !a.done",
        );
    }

    #[test]
    fn e2e_typed_array_values_iterator() {
        assert_eval_true(
            "var v = new Uint8Array([10,20,30]).values(); var a = v.next(); a.value === 10 && !a.done",
        );
    }

    #[test]
    fn e2e_typed_array_entries_iterator() {
        assert_eval_true(
            "var e = new Uint8Array([10,20]).entries(); var a = e.next(); a.value[0] === 0 && a.value[1] === 10",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_static_of_multiple() {
        assert_eval_true(
            "var a = Int32Array.of(1, 2, 3); a.length === 3 && a[0] === 1 && a[2] === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_from_with_map_fn() {
        assert_eval_true(
            "var a = Uint8Array.from([1,2,3], function(x) { return x * 2; }); a[0] === 2 && a[1] === 4 && a[2] === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_from_preserves_kind() {
        assert_eval_true("Uint8Array.from([1,2,3]).constructor === Uint8Array");
    }

    #[test]
    fn e2e_typed_array_join_default() {
        assert_eval_true("new Uint8Array([1,2,3]).join() === '1,2,3'");
    }

    #[test]
    fn e2e_typed_array_join_custom_sep() {
        assert_eval_true("new Uint8Array([1,2,3]).join('-') === '1-2-3'");
    }

    #[test]
    fn e2e_typed_array_bytes_per_element_property() {
        assert_eval_true(
            "Int32Array.BYTES_PER_ELEMENT === 4 && Uint8Array.BYTES_PER_ELEMENT === 1 && Float64Array.BYTES_PER_ELEMENT === 8",
        );
    }

    #[test]
    fn e2e_typed_array_copy_within_returns_receiver() {
        assert_eval_true("var a = new Int32Array([1,2,3]); a.copyWithin(0, 1) === a");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_typed_array_fill_returns_receiver_check() {
        assert_eval_true(
            "var a = new Int32Array(3); var b = a.fill(5); b === a && a[0] === 5 && a[2] === 5",
        );
    }

    #[test]
    fn e2e_atomics_to_string_tag_property() {
        assert_eval_true("Atomics[Symbol.toStringTag] === 'Atomics'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_object_to_string_uses_tag() {
        assert_eval_true("Object.prototype.toString.call(Atomics) === '[object Atomics]'");
    }

    #[test]
    fn e2e_atomics_method_lengths_match_basic_signatures() {
        assert_eval_true(
            "Atomics.load.length === 2 && Atomics.store.length === 3 && Atomics.compareExchange.length === 4 && Atomics.isLockFree.length === 1",
        );
    }

    #[test]
    fn e2e_atomics_is_lock_free_reports_supported_sizes() {
        assert_eval_true(
            "Atomics.isLockFree(1) && Atomics.isLockFree(2) && Atomics.isLockFree(4) && Atomics.isLockFree(8) && !Atomics.isLockFree(3)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_load_reads_shared_typed_array_value() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 42; Atomics.load(ta, 0) === 42",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_store_writes_shared_typed_array_value() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); Atomics.store(ta, 0, 7) === 7 && ta[0] === 7",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_store_returns_coerced_integer_value() {
        assert_eval_true(
            "var ta = new Int8Array(new SharedArrayBuffer(1)); Atomics.store(ta, 0, 129) === -127 && ta[0] === -127",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_add_returns_old_value_and_updates_slot() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 5; Atomics.add(ta, 0, 3) === 5 && ta[0] === 8",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_sub_returns_old_value_and_updates_slot() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 5; Atomics.sub(ta, 0, 2) === 5 && ta[0] === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_and_returns_old_value_and_updates_slot() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 7; Atomics.and(ta, 0, 3) === 7 && ta[0] === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_or_returns_old_value_and_updates_slot() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 4; Atomics.or(ta, 0, 3) === 4 && ta[0] === 7",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_xor_returns_old_value_and_updates_slot() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 6; Atomics.xor(ta, 0, 3) === 6 && ta[0] === 5",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_exchange_returns_old_value_and_updates_slot() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 6; Atomics.exchange(ta, 0, 9) === 6 && ta[0] === 9",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_compare_exchange_updates_when_expected_matches() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 6; Atomics.compareExchange(ta, 0, 6, 9) === 6 && ta[0] === 9",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_compare_exchange_leaves_value_when_expected_misses() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 6; Atomics.compareExchange(ta, 0, 1, 9) === 6 && ta[0] === 6",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_uint32_operations_preserve_unsigned_results() {
        assert_eval_true(
            "var ta = new Uint32Array(new SharedArrayBuffer(4)); ta[0] = 4294967295; Atomics.or(ta, 0, 0) === 4294967295 && Atomics.store(ta, 0, 4294967295) === 4294967295 && ta[0] === 4294967295",
        );
    }

    #[test]
    fn e2e_atomics_bigint_load_and_store_work() {
        assert_eval_true(
            "var ta = new BigInt64Array(new SharedArrayBuffer(8)); Atomics.store(ta, 0, 5n) === 5n && Atomics.load(ta, 0) === 5n",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_bigint_add_returns_old_value_and_updates_slot() {
        assert_eval_true(
            "var ta = new BigInt64Array(new SharedArrayBuffer(8)); ta[0] = 5n; Atomics.add(ta, 0, 3n) === 5n && ta[0] === 8n",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_bigint_compare_exchange_works() {
        assert_eval_true(
            "var ta = new BigUint64Array(new SharedArrayBuffer(8)); ta[0] = 5n; Atomics.compareExchange(ta, 0, 5n, 9n) === 5n && ta[0] === 9n",
        );
    }

    #[test]
    fn e2e_atomics_wait_returns_not_equal_when_value_differs() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 1; Atomics.wait(ta, 0, 2) === 'not-equal'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_atomics_wait_returns_timed_out_when_value_matches() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); ta[0] = 1; Atomics.wait(ta, 0, 1) === 'timed-out'",
        );
    }

    #[test]
    fn e2e_atomics_notify_returns_zero_in_single_threaded_mode() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); Atomics.notify(ta, 0) === 0",
        );
    }

    #[test]
    fn e2e_atomics_wait_async_returns_sync_result_object() {
        assert_eval_true(
            "var ta = new Int32Array(new SharedArrayBuffer(4)); var r = Atomics.waitAsync(ta, 0, 0); r.async === false && r.value === 'timed-out'",
        );
    }

    #[test]
    fn e2e_atomics_reject_non_typed_array_argument() {
        assert_eval_true(
            "try { Atomics.load({}, 0); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_atomics_reject_non_shared_backing_buffer() {
        assert_eval_true(
            "try { Atomics.load(new Int32Array(new ArrayBuffer(4)), 0); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_atomics_reject_non_integer_typed_arrays() {
        assert_eval_true(
            "try { Atomics.load(new Float32Array(new SharedArrayBuffer(4)), 0); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_atomics_reject_float64_typed_arrays() {
        assert_eval_true(
            "try { Atomics.load(new Float64Array(new SharedArrayBuffer(8)), 0); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_atomics_reject_bigint_value_for_number_typed_arrays() {
        assert_eval_true(
            "try { Atomics.store(new Int32Array(new SharedArrayBuffer(4)), 0, 1n); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_atomics_reject_number_value_for_bigint_typed_arrays() {
        assert_eval_true(
            "try { Atomics.store(new BigInt64Array(new SharedArrayBuffer(8)), 0, 1); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_atomics_reject_out_of_range_indices() {
        assert_eval_true(
            "try { Atomics.load(new Int32Array(new SharedArrayBuffer(4)), 1); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    /// `typeof Array[Symbol.species]` is `"function"` (it's the constructor).
    #[test]
    fn test_array_species_type() {
        let result = global_eval("typeof Array[Symbol.species]").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `Array.prototype.slice` returns a plain Array for native arrays.
    #[test]
    fn test_slice_returns_array_for_native() {
        let result = global_eval("[1,2,3].slice(1).join(',')").unwrap();
        assert_eq!(result, JsValue::String("2,3".into()));
    }

    /// `Array.prototype.map` returns a plain Array for native arrays.
    #[test]
    fn test_map_returns_array_for_native() {
        let result = global_eval("[1,2,3].map(function(x) { return x * 2; }).join(',')").unwrap();
        assert_eq!(result, JsValue::String("2,4,6".into()));
    }

    // ── Object.groupBy e2e tests ────────────────────────────────────────

    /// `Object.groupBy` groups numbers by even/odd.
    #[test]
    fn e2e_object_group_by_even_odd() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2,3,4,5,6], function(n) {
                return n % 2 === 0 ? "even" : "odd";
            });
            r.odd.length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Conformance: defineProperty non-configurable accessor guards ────

    /// Redefining a non-configurable accessor with a different getter must
    /// throw TypeError (§10.1.6.3 step 8a).
    #[test]
    fn e2e_define_property_non_configurable_accessor_redefine_getter() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: false }); \
             Object.defineProperty(o, 'x', { get: function() { return 2; } })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for changing getter on non-configurable accessor"
        );
    }

    /// Redefining a non-configurable accessor with a different setter must
    /// throw TypeError (§10.1.6.3 step 8b).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_define_property_non_configurable_accessor_redefine_setter() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { set: function(v) {}, configurable: false }); \
             Object.defineProperty(o, 'x', { set: function(v) {} })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for changing setter on non-configurable accessor"
        );
    }

    /// Converting a non-configurable accessor to a data property must
    /// throw TypeError (§10.1.6.3 step 6).
    #[test]
    fn e2e_define_property_non_configurable_accessor_to_data() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: false }); \
             Object.defineProperty(o, 'x', { value: 42 })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for accessor→data on non-configurable"
        );
    }

    /// Changing enumerable on a non-configurable accessor must throw
    /// TypeError (§10.1.6.3 step 4b).
    #[test]
    fn e2e_define_property_non_configurable_accessor_change_enumerable() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: false }); \
             Object.defineProperty(o, 'x', { enumerable: true })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for changing enumerable on non-configurable accessor"
        );
    }

    /// Setting configurable:true on a non-configurable accessor must throw
    /// TypeError (§10.1.6.3 step 4a).
    #[test]
    fn e2e_define_property_non_configurable_accessor_reconfigure() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: false }); \
             Object.defineProperty(o, 'x', { configurable: true })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for configurable false→true on non-configurable accessor"
        );
    }

    // ── Conformance: Object.setPrototypeOf validation ───────────────────

    /// `Object.setPrototypeOf(obj, 42)` must throw TypeError because 42
    /// is not Object and not null (§20.1.2.21 step 2).
    #[test]
    fn e2e_set_prototype_of_non_object_proto() {
        let result = global_eval("var o = {}; Object.setPrototypeOf(o, 42)");
        assert!(
            result.is_err(),
            "Expected TypeError for non-object, non-null proto"
        );
    }

    /// `Object.setPrototypeOf(null, {})` must throw TypeError because
    /// null is not coercible (§20.1.2.21 step 1).
    #[test]
    fn e2e_set_prototype_of_null_target() {
        let result = global_eval("Object.setPrototypeOf(null, {})");
        assert!(result.is_err(), "Expected TypeError for null target");
    }

    /// `Object.setPrototypeOf(obj, undefined)` must throw TypeError
    /// because undefined is not Object or null (§20.1.2.21 step 2).
    #[test]
    fn e2e_set_prototype_of_undefined_proto() {
        let result = global_eval("var o = {}; Object.setPrototypeOf(o, undefined)");
        assert!(result.is_err(), "Expected TypeError for undefined proto");
    }

    /// `Object.setPrototypeOf(obj, null)` should succeed and remove
    /// the prototype.
    #[test]
    fn e2e_set_prototype_of_null_proto() {
        let result =
            global_eval("var o = {}; Object.setPrototypeOf(o, null); Object.getPrototypeOf(o)")
                .unwrap();
        assert_eq!(result, JsValue::Null);
    }

    // ── Conformance: Object.setPrototypeOf cycle detection ──────────────

    /// Circular prototype chain must throw TypeError.
    #[test]
    fn e2e_set_prototype_of_cycle() {
        let result = global_eval(
            "var a = {}; var b = {}; \
             Object.setPrototypeOf(a, b); \
             Object.setPrototypeOf(b, a)",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for circular prototype chain"
        );
    }

    /// Setting prototype to self must throw TypeError.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_prototype_of_self() {
        let result = global_eval("var a = {}; Object.setPrototypeOf(a, a)");
        assert!(
            result.is_err(),
            "Expected TypeError for self-referencing prototype"
        );
    }

    /// Setting same prototype again succeeds (no-op).
    #[test]
    fn e2e_set_prototype_of_same_proto() {
        let result = global_eval(
            "var p = {}; var o = Object.create(p); \
             Object.setPrototypeOf(o, p); \
             Object.getPrototypeOf(o) === p",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Non-extensible object: cannot change prototype.
    #[test]
    fn e2e_set_prototype_of_non_extensible() {
        let result = global_eval(
            "var o = {}; Object.preventExtensions(o); \
             Object.setPrototypeOf(o, {})",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for changing prototype on non-extensible"
        );
    }

    // ── Conformance: Object.getPrototypeOf ──────────────────────────────

    /// `Object.getPrototypeOf({})` should return Object.prototype (not null).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_get_prototype_of_plain_object() {
        let result = global_eval("Object.getPrototypeOf({}) !== null").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.getPrototypeOf(Object.create(null))` returns null.
    #[test]
    fn e2e_get_prototype_of_null_proto() {
        let result = global_eval("Object.getPrototypeOf(Object.create(null))").unwrap();
        assert_eq!(result, JsValue::Null);
    }

    /// getPrototypeOf with null throws TypeError.
    #[test]
    fn e2e_get_prototype_of_null_throws() {
        let result = global_eval("Object.getPrototypeOf(null)");
        assert!(result.is_err(), "Expected TypeError for null argument");
    }

    /// getPrototypeOf with undefined throws TypeError.
    #[test]
    fn e2e_get_prototype_of_undefined_throws() {
        let result = global_eval("Object.getPrototypeOf(undefined)");
        assert!(result.is_err(), "Expected TypeError for undefined argument");
    }

    // ── Conformance: Object.defineProperty data property ────────────────

    /// `Object.defineProperty` creates a non-writable data property.
    #[test]
    fn e2e_define_property_data_non_writable() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 42, writable: false, enumerable: true, configurable: true }); \
             o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Redefining a non-configurable property must throw.
    #[test]
    fn e2e_define_property_non_configurable_redefine() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: false, configurable: false }); \
             Object.defineProperty(o, 'x', { value: 2 })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError redefining non-configurable property"
        );
    }

    /// Narrowing writable true→false on non-configurable is allowed.
    #[test]
    fn e2e_define_property_narrow_writable() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: true, configurable: false }); \
             Object.defineProperty(o, 'x', { writable: false }); \
             var desc = Object.getOwnPropertyDescriptor(o, 'x'); \
             desc.writable",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// Widening writable false→true on non-configurable must throw.
    #[test]
    fn e2e_define_property_widen_writable_throws() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: false, configurable: false }); \
             Object.defineProperty(o, 'x', { writable: true })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for widening writable on non-configurable"
        );
    }

    /// Converting data→accessor on non-configurable throws.
    #[test]
    fn e2e_define_property_data_to_accessor_non_configurable() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, configurable: false }); \
             Object.defineProperty(o, 'x', { get: function() { return 2; } })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for data→accessor on non-configurable"
        );
    }

    /// Converting data→accessor on configurable succeeds.
    #[test]
    fn e2e_define_property_data_to_accessor_configurable() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, configurable: true }); \
             Object.defineProperty(o, 'x', { get: function() { return 99; } }); \
             o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// configurable false→true on non-configurable data throws.
    #[test]
    fn e2e_define_property_configurable_false_to_true() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, configurable: false }); \
             Object.defineProperty(o, 'x', { configurable: true })",
        );
        assert!(
            result.is_err(),
            "Expected TypeError for configurable false→true"
        );
    }

    // ── Conformance: Object.defineProperties ────────────────────────────

    /// `Object.defineProperties` defines multiple properties at once.
    #[test]
    fn e2e_define_properties_basic() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperties(o, { \
                 a: { value: 1, enumerable: true, writable: true, configurable: true }, \
                 b: { value: 2, enumerable: true, writable: true, configurable: true } \
             }); \
             o.a + o.b",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.groupBy` even group has correct elements.
    #[test]
    fn e2e_object_group_by_even_elements() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2,3,4], function(n) {
                return n % 2 === 0 ? "even" : "odd";
            });
            r.even.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("2,4".into()));
    }

    /// `Object.groupBy` returns a null-prototype-like object.
    #[test]
    fn e2e_object_group_by_result_type() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1], function(n) { return "a"; });
            typeof r
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    /// `Object.groupBy` callback receives index as second argument.
    #[test]
    fn e2e_object_group_by_callback_index() {
        let result = global_eval(
            r#"
            var indices = [];
            Object.groupBy([10, 20, 30], function(v, i) {
                indices.push(i);
                return "g";
            });
            indices.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("0,1,2".into()));
    }

    /// `Object.groupBy` with empty array returns empty object.
    #[test]
    fn e2e_object_group_by_empty() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([], function(n) { return "x"; });
            Object.keys(r).length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `Object.defineProperties` on non-object throws TypeError.
    #[test]
    fn e2e_define_properties_non_object() {
        let result = global_eval("Object.defineProperties(42, { x: { value: 1 } })");
        assert!(result.is_err(), "Expected TypeError for non-object target");
    }

    // ── Conformance: Object.getOwnPropertyDescriptor ────────────────────

    /// Returns correct data descriptor shape.
    #[test]
    fn e2e_get_own_property_descriptor_data() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 42, writable: true, enumerable: false, configurable: true }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 42 && d.writable === true && d.enumerable === false && d.configurable === true",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Returns correct accessor descriptor shape.
    #[test]
    fn e2e_get_own_property_descriptor_accessor() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, enumerable: true, configurable: true }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             typeof d.get === 'function' && d.enumerable === true && d.configurable === true",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Nonexistent property returns undefined.
    #[test]
    fn e2e_get_own_property_descriptor_missing() {
        let result = global_eval("Object.getOwnPropertyDescriptor({}, 'nope')").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// Accessor descriptor should not have value/writable.
    #[test]
    fn e2e_get_own_property_descriptor_accessor_no_value() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: true }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === undefined && d.writable === undefined",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Conformance: Object.create ──────────────────────────────────────

    /// `Object.create(null)` produces an object with no prototype.
    #[test]
    fn e2e_object_create_null_v2() {
        let result = global_eval("var o = Object.create(null); Object.getPrototypeOf(o)").unwrap();
        assert_eq!(result, JsValue::Null);
    }

    /// `Object.create(proto)` sets prototype chain.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_create_with_proto() {
        let result = global_eval("var p = { x: 42 }; var o = Object.create(p); o.x").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// `Object.create(proto, descriptors)` with property descriptors.
    #[test]
    fn e2e_object_create_with_descriptors() {
        let result = global_eval(
            "var p = {}; \
             var o = Object.create(p, { \
                 x: { value: 10, enumerable: true, writable: true, configurable: true }, \
                 y: { value: 20, enumerable: true, writable: true, configurable: true } \
             }); \
             o.x + o.y",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(30));
    }

    /// `Object.create(undefined)` throws TypeError.
    #[test]
    fn e2e_object_create_undefined_throws() {
        let result = global_eval("Object.create(undefined)");
        assert!(result.is_err(), "Expected TypeError for undefined proto");
    }

    /// `Object.create(42)` throws TypeError (non-object proto).
    #[test]
    fn e2e_object_create_number_throws() {
        let result = global_eval("Object.create(42)");
        assert!(result.is_err(), "Expected TypeError for numeric proto");
    }

    // ── Conformance: hasOwnProperty ─────────────────────────────────────

    /// Own property returns true.
    #[test]
    fn e2e_has_own_property_own() {
        let result = global_eval("var o = { x: 1 }; o.hasOwnProperty('x')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Inherited property returns false.
    #[test]
    fn e2e_has_own_property_inherited() {
        let result =
            global_eval("var p = { x: 1 }; var o = Object.create(p); o.hasOwnProperty('x')")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// Missing property returns false.
    #[test]
    fn e2e_has_own_property_missing() {
        let result = global_eval("var o = {}; o.hasOwnProperty('nope')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Conformance: propertyIsEnumerable ────────────────────────────────

    /// Enumerable own property returns true.
    #[test]
    fn e2e_property_is_enumerable_own() {
        let result = global_eval("var o = { x: 1 }; o.propertyIsEnumerable('x')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Non-enumerable own property returns false.
    #[test]
    fn e2e_property_is_enumerable_non_enum() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, enumerable: false }); \
             o.propertyIsEnumerable('x')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// Inherited property returns false (only checks own).
    #[test]
    fn e2e_property_is_enumerable_inherited() {
        let result =
            global_eval("var p = { x: 1 }; var o = Object.create(p); o.propertyIsEnumerable('x')")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Conformance: for-in enumeration ─────────────────────────────────

    /// for-in enumerates own enumerable string properties.
    #[test]
    fn e2e_for_in_own_enumerable() {
        let result = global_eval(
            "var o = { a: 1, b: 2, c: 3 }; \
             var keys = []; \
             for (var k in o) { keys.push(k); } \
             keys.join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("a,b,c".into()));
    }

    /// for-in skips non-enumerable properties.
    #[test]
    fn e2e_for_in_skips_non_enumerable() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'a', { value: 1, enumerable: true, writable: true, configurable: true }); \
             Object.defineProperty(o, 'b', { value: 2, enumerable: false, writable: true, configurable: true }); \
             Object.defineProperty(o, 'c', { value: 3, enumerable: true, writable: true, configurable: true }); \
             var keys = []; \
             for (var k in o) { keys.push(k); } \
             keys.join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("a,c".into()));
    }

    /// for-in enumerates inherited enumerable properties.
    #[test]
    fn e2e_for_in_inherited() {
        let result = global_eval(
            "var p = { x: 1 }; \
             var o = Object.create(p); \
             o.y = 2; \
             var keys = []; \
             for (var k in o) { keys.push(k); } \
             keys.join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("y,x".into()));
    }

    /// for-in own property shadows inherited with same name.
    #[test]
    fn e2e_for_in_shadowing() {
        let result = global_eval(
            "var p = { a: 1, b: 2 }; \
             var o = Object.create(p); \
             o.a = 10; \
             var keys = []; \
             for (var k in o) { keys.push(k); } \
             keys.join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("a,b".into()));
    }

    /// Non-enumerable own property shadows inherited enumerable one.
    #[test]
    fn e2e_for_in_non_enumerable_shadow() {
        let result = global_eval(
            "var p = { x: 1 }; \
             var o = Object.create(p); \
             Object.defineProperty(o, 'x', { value: 2, enumerable: false }); \
             var keys = []; \
             for (var k in o) { keys.push(k); } \
             keys.length",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `Object.groupBy` single group gathers all items.
    #[test]
    fn e2e_object_group_by_single_group() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2,3], function() { return "all"; });
            r.all.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    /// `Object.groupBy` with string keys from callback.
    #[test]
    fn e2e_object_group_by_string_keys() {
        let result = global_eval(
            r#"
            var r = Object.groupBy(["apple", "avocado", "banana"], function(s) {
                return s[0];
            });
            r.a.length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Object.groupBy.length` is 2.
    #[test]
    fn e2e_object_group_by_length_prop() {
        let result = global_eval("Object.groupBy.length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Object.groupBy.name` is "groupBy".
    #[test]
    fn e2e_object_group_by_name_prop() {
        let result = global_eval("Object.groupBy.name").unwrap();
        assert_eq!(result, JsValue::String("groupBy".into()));
    }

    // ── Conformance: prototype chain edge cases ──────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_assignment_updates_prototype_chain() {
        let result = global_eval(
            "var proto = { x: 1 }; var obj = {}; obj.__proto__ = proto; \
             Object.getPrototypeOf(obj) === proto && obj.x === 1",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_assignment_ignores_primitive_value() {
        let result = global_eval(
            "var proto = { x: 1 }; var obj = Object.create(proto); \
             obj.__proto__ = 1; Object.getPrototypeOf(obj) === proto && obj.x === 1",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_assignment_cycle_rejected() {
        let result = global_eval(
            "var a = {}; var b = {}; a.__proto__ = b; \
             try { b.__proto__ = a; false; } catch (e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_assignment_non_extensible_rejected() {
        let result = global_eval(
            "var o = {}; Object.preventExtensions(o); \
             try { o.__proto__ = {}; false; } catch (e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_null_proto_object_has_no_tostring() {
        let result = global_eval("typeof Object.create(null).toString").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_null_proto_object_has_no_has_own_property_method() {
        let result = global_eval("typeof Object.create(null).hasOwnProperty").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_in_operator_sees_own_undefined_property() {
        let result = global_eval("var o = { x: undefined }; 'x' in o").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_in_operator_sees_inherited_undefined_property() {
        let result =
            global_eval("var p = { x: undefined }; var o = Object.create(p); 'x' in o").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_in_operator_respects_null_prototype() {
        let result = global_eval("var o = Object.create(null); 'toString' in o").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_has_own_property_accessor_counts_as_own() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: true }); \
             o.hasOwnProperty('x')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_has_own_property_accessor_inherited_is_false() {
        let result = global_eval(
            "var p = {}; \
             Object.defineProperty(p, 'x', { get: function() { return 1; }, configurable: true }); \
             var o = Object.create(p); \
             o.hasOwnProperty('x') === false && ('x' in o)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_property_shadowing_own_value_overrides_inherited() {
        let result = global_eval(
            "var p = { x: 1 }; var o = Object.create(p); o.x = 2; o.x === 2 && p.x === 1",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_property_shadowing_undefined_masks_inherited_value() {
        let result = global_eval(
            "var p = { x: 1 }; var o = Object.create(p); \
             o.x = undefined; o.x === undefined && ('x' in o) && o.hasOwnProperty('x')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_instanceof_uses_constructor_prototype_chain() {
        let result = global_eval(
            "function F() {} var o = new F(); \
             o instanceof F && Object.getPrototypeOf(o) === F.prototype",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_instanceof_breaks_when_constructor_prototype_is_replaced() {
        let result =
            global_eval("function F() {} var o = new F(); F.prototype = {}; o instanceof F")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_instanceof_custom_symbol_hasinstance_receives_constructor_this() {
        let result = global_eval(
            "function F() {} \
             F[Symbol.hasInstance] = function(v) { return this === F && v.flag === 1; }; \
             ({ flag: 1 }) instanceof F",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_instanceof_custom_symbol_hasinstance_can_reject() {
        let result = global_eval(
            "function F() {} \
             F[Symbol.hasInstance] = function(v) { return v.flag === 1; }; \
             ({ flag: 0 }) instanceof F",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_instanceof_plain_object_rhs_uses_symbol_hasinstance() {
        let result = global_eval(
            "var C = { [Symbol.hasInstance]: function(v) { return this === C && v.ok === true; } }; \
             ({ ok: true }) instanceof C",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_prototype_is_prototype_of_new_instance() {
        let result = global_eval("function F() {} F.prototype.isPrototypeOf(new F())").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_object_prototype_is_not_prototype_of_null_proto_object() {
        let result = global_eval("Object.prototype.isPrototypeOf(Object.create(null))").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_get_prototype_of_after_proto_assignment() {
        let result =
            global_eval("var p = {}; var o = {}; o.__proto__ = p; Object.getPrototypeOf(o) === p")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_set_prototype_of_detects_longer_cycle() {
        let result = global_eval(
            "var a = {}; var b = {}; var c = {}; \
             Object.setPrototypeOf(a, b); Object.setPrototypeOf(b, c); \
             try { Object.setPrototypeOf(c, a); false; } catch (e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_set_prototype_of_preserves_shadowed_property() {
        let result = global_eval(
            "var p = { x: 1 }; var o = { x: 2 }; \
             Object.setPrototypeOf(o, p); o.x === 2 && Object.getPrototypeOf(o) === p",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_set_prototype_of_null_removes_inherited_in_operator_hit() {
        let result = global_eval(
            "var p = { x: 1 }; var o = Object.create(p); \
             Object.setPrototypeOf(o, null); 'x' in o",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_prototype_of_null_removes_object_prototype_methods() {
        let result =
            global_eval("var o = {}; Object.setPrototypeOf(o, null); typeof o.toString").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_object_prototype_has_own_property_call_works_on_null_proto_object() {
        let result = global_eval(
            "var o = Object.create(null); o.x = 1; \
             Object.prototype.hasOwnProperty.call(o, 'x')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_constructor_prototype_property_lookup_is_inherited() {
        let result =
            global_eval("function F() {} F.prototype.x = 1; var o = new F(); o.x").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_constructor_prototype_is_prototype_of_instance() {
        let result =
            global_eval("function F() {} var o = new F(); F.prototype.isPrototypeOf(o)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replacing_constructor_prototype_affects_new_instances_only() {
        let result = global_eval(
            "function F() {} var old = new F(); var p = { y: 2 }; \
             F.prototype = p; var fresh = new F(); \
             Object.getPrototypeOf(fresh) === p && (old instanceof F) === false",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_has_own_property_vs_in_inherited_property() {
        let result = global_eval(
            "var p = { x: 1 }; var o = Object.create(p); ('x' in o) && !o.hasOwnProperty('x')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_has_own_property_vs_in_inherited_undefined_property() {
        let result = global_eval(
            "var p = { x: undefined }; var o = Object.create(p); ('x' in o) && !o.hasOwnProperty('x')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_proto_assignment_to_null_removes_inherited_lookup() {
        let result = global_eval(
            "var p = { x: 1 }; var o = Object.create(p); o.__proto__ = null; typeof o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_assignment_same_prototype_is_noop() {
        let result = global_eval(
            "var p = { x: 1 }; var o = Object.create(p); o.__proto__ = p; Object.getPrototypeOf(o) === p",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_null_proto_object_not_in_object_prototype_chain() {
        let result = global_eval(
            "var o = Object.create(null); o.x = 1; Object.prototype.isPrototypeOf(o) === false",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_assignment_to_null_removes_has_own_property_method() {
        let result =
            global_eval("var o = {}; o.__proto__ = null; typeof o.hasOwnProperty").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_custom_symbol_hasinstance_can_match_primitive() {
        let result = global_eval(
            "function F() {} \
             F[Symbol.hasInstance] = function(v) { return typeof v === 'number'; }; \
             1 instanceof F",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Map.groupBy e2e tests ───────────────────────────────────────────

    /// `Map.groupBy` returns a Map-like object with `get`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_basic() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([1,2,3,4], function(n) {
                return n % 2 === 0 ? "even" : "odd";
            });
            m.get("odd").join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,3".into()));
    }

    /// `Map.groupBy` has correct size.
    #[test]
    fn e2e_map_group_by_size() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([1,2,3,4], function(n) {
                return n % 2 === 0 ? "even" : "odd";
            });
            m.size
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Map.groupBy` has() works for existing key.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_has() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([1,2,3], function(n) { return "k"; });
            m.has("k")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Map.groupBy` has() returns false for missing key.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_has_missing() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([1], function(n) { return "a"; });
            m.has("b")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Map.groupBy` callback receives index.
    #[test]
    fn e2e_map_group_by_callback_index() {
        let result = global_eval(
            r#"
            var idxs = [];
            Map.groupBy([10,20], function(v, i) { idxs.push(i); return "g"; });
            idxs.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("0,1".into()));
    }

    /// `Map.groupBy.length` is 2.
    #[test]
    fn e2e_map_group_by_length_prop() {
        let result = global_eval("Map.groupBy.length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Map.groupBy.name` is "groupBy".
    #[test]
    fn e2e_map_group_by_name_prop() {
        let result = global_eval("Map.groupBy.name").unwrap();
        assert_eq!(result, JsValue::String("groupBy".into()));
    }

    // ── Object.groupBy / Map.groupBy comprehensive e2e tests ────────────

    /// Object.groupBy: groups numbers into three buckets.
    #[test]
    fn e2e_object_group_by_three_buckets() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2,3,4,5,6,7,8,9], function(n) {
                if (n <= 3) return "low";
                if (n <= 6) return "mid";
                return "high";
            });
            r.low.join(",") + "|" + r.mid.join(",") + "|" + r.high.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2,3|4,5,6|7,8,9".into()));
    }

    /// Object.groupBy: groups preserve insertion order.
    #[test]
    fn e2e_object_group_by_preserves_order() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([3,1,4,1,5,9], function(n) {
                return n % 2 === 0 ? "even" : "odd";
            });
            r.odd.join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("3,1,1,5,9".into()));
    }

    /// Object.groupBy: single-element array.
    #[test]
    fn e2e_object_group_by_single_element() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([42], function(n) { return "only"; });
            r.only[0]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Object.groupBy: callback can return numeric strings as keys.
    #[test]
    fn e2e_object_group_by_numeric_string_keys() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([10, 20, 30], function(n) { return String(n); });
            Object.keys(r).join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("10,20,30".into()));
    }

    /// Object.groupBy: all elements in one group.
    #[test]
    fn e2e_object_group_by_all_same_key() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2,3,4,5], function() { return "x"; });
            r.x.length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// Object.groupBy: each element unique key.
    #[test]
    fn e2e_object_group_by_unique_keys() {
        let result = global_eval(
            r#"
            var r = Object.groupBy(["a","b","c"], function(s) { return s; });
            Object.keys(r).length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// Object.groupBy: coerces non-string keys to strings.
    #[test]
    fn e2e_object_group_by_coerces_keys() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2,3], function(n) { return n; });
            r["1"].length + r["2"].length + r["3"].length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// Object.groupBy: callback returns undefined key.
    #[test]
    fn e2e_object_group_by_undefined_key() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2], function() { return undefined; });
            r["undefined"].length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// Object.groupBy: callback returns null key.
    #[test]
    fn e2e_object_group_by_null_key() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2], function() { return null; });
            r["null"].length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// Object.groupBy: callback returns boolean keys.
    #[test]
    fn e2e_object_group_by_boolean_keys() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2,3,4], function(n) { return n > 2; });
            r["false"].join(",") + "|" + r["true"].join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2|3,4".into()));
    }

    /// Object.groupBy: non-callable second argument throws TypeError.
    #[test]
    fn e2e_object_group_by_non_callable_throws() {
        let result = global_eval("Object.groupBy([1,2], 42)");
        assert!(result.is_err());
    }

    /// Object.groupBy: non-iterable first argument throws TypeError.
    #[test]
    fn e2e_object_group_by_non_iterable_throws() {
        let result = global_eval("Object.groupBy(42, function() { return 'a'; })");
        assert!(result.is_err());
    }

    /// Object.groupBy: undefined callback throws TypeError.
    #[test]
    fn e2e_object_group_by_undefined_callback_throws() {
        let result = global_eval("Object.groupBy([1], undefined)");
        assert!(result.is_err());
    }

    /// Object.groupBy: null callback throws TypeError.
    #[test]
    fn e2e_object_group_by_null_callback_throws() {
        let result = global_eval("Object.groupBy([1], null)");
        assert!(result.is_err());
    }

    /// Object.groupBy: result groups are real arrays.
    #[test]
    fn e2e_object_group_by_result_groups_are_arrays() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2], function() { return "k"; });
            Array.isArray(r.k)
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Object.groupBy: string iterable input (chars).
    #[test]
    fn e2e_object_group_by_string_input() {
        let result = global_eval(
            r#"
            var r = Object.groupBy("abcabc", function(ch) { return ch; });
            r.a.length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// Map.groupBy: empty iterable returns empty Map.
    #[test]
    fn e2e_map_group_by_empty() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([], function(n) { return "x"; });
            m.size
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// Map.groupBy: non-callable second argument throws TypeError.
    #[test]
    fn e2e_map_group_by_non_callable_throws() {
        let result = global_eval("Map.groupBy([1,2], 42)");
        assert!(result.is_err());
    }

    /// Map.groupBy: non-iterable first argument throws TypeError.
    #[test]
    fn e2e_map_group_by_non_iterable_throws() {
        let result = global_eval("Map.groupBy(42, function() { return 'a'; })");
        assert!(result.is_err());
    }

    /// Map.groupBy: undefined callback throws TypeError.
    #[test]
    fn e2e_map_group_by_undefined_callback_throws() {
        let result = global_eval("Map.groupBy([1], undefined)");
        assert!(result.is_err());
    }

    /// Map.groupBy: null callback throws TypeError.
    #[test]
    fn e2e_map_group_by_null_callback_throws() {
        let result = global_eval("Map.groupBy([1], null)");
        assert!(result.is_err());
    }

    /// Map.groupBy: single group gathers all items.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_single_group() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([10,20,30], function() { return "all"; });
            m.get("all").join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("10,20,30".into()));
    }

    /// Map.groupBy: result groups are real arrays.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_result_groups_are_arrays() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([1,2], function() { return "k"; });
            Array.isArray(m.get("k"))
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Map.groupBy: preserves insertion order.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_preserves_order() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([3,1,4,1,5], function(n) {
                return n % 2 === 0 ? "even" : "odd";
            });
            m.get("odd").join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("3,1,1,5".into()));
    }

    /// Map.groupBy: string iterable input.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_string_input() {
        let result = global_eval(
            r#"
            var m = Map.groupBy("hello", function(ch) { return ch; });
            m.get("l").length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// Map.groupBy: even group has correct elements.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_even_elements() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([1,2,3,4], function(n) {
                return n % 2 === 0 ? "even" : "odd";
            });
            m.get("even").join(",")
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("2,4".into()));
    }

    /// Array.prototype.group must not exist.
    #[test]
    fn e2e_array_prototype_group_absent() {
        let result = global_eval("typeof Array.prototype.group").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    /// Array.prototype.groupToMap must not exist.
    #[test]
    fn e2e_array_prototype_group_to_map_absent() {
        let result = global_eval("typeof Array.prototype.groupToMap").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    /// Calling [].group() throws because it is not a function.
    #[test]
    fn e2e_array_group_call_throws() {
        let result = global_eval("[].group(function() { return 'x'; })");
        assert!(result.is_err());
    }

    /// Calling [].groupToMap() throws because it is not a function.
    #[test]
    fn e2e_array_group_to_map_call_throws() {
        let result = global_eval("[].groupToMap(function() { return 'x'; })");
        assert!(result.is_err());
    }

    /// Object.groupBy: typeof result is "object".
    #[test]
    fn e2e_object_group_by_typeof() {
        let result =
            global_eval(r#"typeof Object.groupBy([1], function() { return "a"; })"#).unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    /// Object.groupBy: typeof is "function".
    #[test]
    fn e2e_object_group_by_is_function() {
        let result = global_eval("typeof Object.groupBy").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// Map.groupBy: typeof is "function".
    #[test]
    fn e2e_map_group_by_is_function() {
        let result = global_eval("typeof Map.groupBy").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    // ── Object.hasOwn e2e conformance ───────────────────────────────────

    /// `Object.hasOwn` works on arrays with valid index.
    #[test]
    fn e2e_object_has_own_array_index() {
        let result = global_eval("Object.hasOwn([10, 20, 30], '1')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.hasOwn` on arrays returns false for out-of-bounds index.
    #[test]
    fn e2e_object_has_own_array_oob() {
        let result = global_eval("Object.hasOwn([10], '5')").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// `Object.hasOwn` on arrays with "length" returns true.
    #[test]
    fn e2e_object_has_own_array_length() {
        let result = global_eval("Object.hasOwn([1,2,3], 'length')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.hasOwn.length` is 2.
    #[test]
    fn e2e_object_has_own_length_prop() {
        let result = global_eval("Object.hasOwn.length").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// `Object.hasOwn.name` is "hasOwn".
    #[test]
    fn e2e_object_has_own_name_prop() {
        let result = global_eval("Object.hasOwn.name").unwrap();
        assert_eq!(result, JsValue::String("hasOwn".into()));
    }

    // ── Array.from conformance edge cases ───────────────────────────────

    /// `Array.from` with array-like and mapFn applies mapping.
    #[test]
    fn e2e_array_from_array_like_with_map_fn() {
        let result = global_eval(
            "Array.from({0: 1, 1: 2, 2: 3, length: 3}, function(x) { return x * 10; }).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("10,20,30".into()));
    }

    /// `Array.from` mapFn receives (element, index).
    #[test]
    fn e2e_array_from_map_fn_index() {
        let result =
            global_eval("Array.from([10, 20, 30], function(v, i) { return i; }).join(',')")
                .unwrap();
        assert_eq!(result, JsValue::String("0,1,2".into()));
    }

    /// `Array.from` with string source produces character array.
    #[test]
    fn e2e_array_from_string_chars() {
        let result = global_eval("Array.from('hello').join(',')").unwrap();
        assert_eq!(result, JsValue::String("h,e,l,l,o".into()));
    }

    /// `Array.from` with undefined mapFn is same as no mapFn.
    #[test]
    fn e2e_array_from_undefined_map_fn() {
        let result = global_eval("Array.from([1,2,3], undefined).join(',')").unwrap();
        assert_eq!(result, JsValue::String("1,2,3".into()));
    }

    /// `Array.from.length` is 1.
    #[test]
    fn e2e_array_from_length_prop() {
        let result = global_eval("Array.from.length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Array.from.name` is "from".
    #[test]
    fn e2e_array_from_name_prop() {
        let result = global_eval("Array.from.name").unwrap();
        assert_eq!(result, JsValue::String("from".into()));
    }

    /// `Array.from` with sparse array-like fills gaps with undefined.
    #[test]
    fn e2e_array_from_sparse_array_like() {
        let result = global_eval(
            r#"
            var r = Array.from({0: "a", 2: "c", length: 3});
            r[1] === undefined
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// for-in integer indices come first in ascending order.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_in_integer_indices_first() {
        let result = global_eval(
            "var o = {}; o.b = 1; o['2'] = 2; o.a = 3; o['0'] = 4; \
             var keys = []; \
             for (var k in o) { keys.push(k); } \
             keys.join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("0,2,b,a".into()));
    }

    /// for-in on null/undefined is a no-op.
    #[test]
    fn e2e_for_in_null_noop() {
        let result = global_eval(
            "var count = 0; \
             for (var k in null) { count++; } \
             count",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// for-in on empty object produces no iterations.
    #[test]
    fn e2e_for_in_empty() {
        let result = global_eval(
            "var count = 0; \
             for (var k in {}) { count++; } \
             count",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    // ── Conformance: Object.keys / Object.values / Object.entries ───────

    /// Object.keys returns only own enumerable string keys.
    #[test]
    fn e2e_object_keys_only_own_enumerable() {
        let result = global_eval(
            "var p = { inherited: 1 }; \
             var o = Object.create(p); \
             o.own = 2; \
             Object.defineProperty(o, 'hidden', { value: 3, enumerable: false }); \
             Object.keys(o).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("own".into()));
    }

    // ── Conformance: Object.assign ──────────────────────────────────────

    /// Object.assign copies enumerable own properties.
    #[test]
    fn e2e_object_assign_basic() {
        let result =
            global_eval("var t = {}; Object.assign(t, { a: 1 }, { b: 2 }); t.a + t.b").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Conformance: Object.freeze / Object.seal ────────────────────────

    /// Frozen object: assignment to existing property is silently ignored.
    #[test]
    fn e2e_object_freeze_no_write() {
        let result = global_eval("var o = { x: 1 }; Object.freeze(o); o.x = 99; o.x").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// Object.isFrozen returns true after freeze.
    #[test]
    fn e2e_object_is_frozen_v2() {
        let result = global_eval("var o = { x: 1 }; Object.freeze(o); Object.isFrozen(o)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Object.isSealed returns true after seal.
    #[test]
    fn e2e_object_is_sealed_v2() {
        let result = global_eval("var o = { x: 1 }; Object.seal(o); Object.isSealed(o)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Conformance: Object.is ──────────────────────────────────────────

    /// `Object.is(NaN, NaN)` returns true.
    #[test]
    fn e2e_object_is_nan_v2() {
        let result = global_eval("Object.is(NaN, NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// `Object.is(0, -0)` returns false.
    #[test]
    fn e2e_object_is_zero_neg_zero_v2() {
        let result = global_eval("Object.is(0, -0)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Conformance: Object.getOwnPropertyNames ─────────────────────────

    /// Returns all own property names (including non-enumerable).
    #[test]
    fn e2e_get_own_property_names() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'a', { value: 1, enumerable: true }); \
             Object.defineProperty(o, 'b', { value: 2, enumerable: false }); \
             Object.getOwnPropertyNames(o).length",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    // ── Conformance: Object.hasOwn ──────────────────────────────────────

    /// Object.hasOwn checks own properties.
    #[test]
    fn e2e_object_has_own() {
        let result = global_eval("var o = { x: 1 }; Object.hasOwn(o, 'x')").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Object.hasOwn returns false for inherited.
    #[test]
    fn e2e_object_has_own_inherited_v2() {
        let result =
            global_eval("var p = { x: 1 }; var o = Object.create(p); Object.hasOwn(o, 'x')")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Conformance: prototype chain property access ────────────────────

    /// Property access walks the prototype chain.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_prototype_chain_access() {
        let result = global_eval(
            "var gp = { z: 100 }; \
             var p = Object.create(gp); \
             p.y = 50; \
             var o = Object.create(p); \
             o.x = 10; \
             o.x + o.y + o.z",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(160));
    }

    /// 'in' operator checks prototype chain.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_in_operator_prototype() {
        let result = global_eval("var p = { x: 1 }; var o = Object.create(p); 'x' in o").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// 'in' operator returns false for missing key.
    #[test]
    fn e2e_in_operator_missing() {
        let result = global_eval("var o = { x: 1 }; 'y' in o").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── Conformance: Object.getOwnPropertyDescriptors ───────────────────

    /// Returns descriptors for all own properties.
    #[test]
    fn e2e_get_own_property_descriptors() {
        let result = global_eval(
            "var o = { a: 1, b: 2 }; \
             var ds = Object.getOwnPropertyDescriptors(o); \
             ds.a.value + ds.b.value",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn test_object_keys_orders_integer_indices_before_strings() {
        let result = global_eval(
            "var o = {}; \
             o.b = 'bee'; \
             Object.defineProperty(o, '2', { value: 'two', enumerable: true }); \
             o.a = 'aye'; \
             Object.defineProperty(o, '1', { value: 'one', enumerable: true }); \
             Object.keys(o).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2,b,a".into()));
    }

    #[test]
    fn test_object_keys_skips_inherited_properties() {
        let result =
            global_eval("var p = { inherited: 1 }; var o = Object.create(p); o.own = 2; Object.keys(o).join(',')")
                .unwrap();
        assert_eq!(result, JsValue::String("own".into()));
    }

    #[test]
    fn test_object_keys_skips_non_enumerable_accessor() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'hidden', { get: function() { return 1; }, enumerable: false }); \
             Object.keys(o).length",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    #[test]
    fn test_object_keys_includes_enumerable_accessor() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'visible', { get: function() { return 1; }, enumerable: true }); \
             Object.keys(o).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("visible".into()));
    }

    #[test]
    fn test_object_keys_skips_symbol_keys() {
        let result = global_eval(
            "var s = Symbol('x'); \
             var o = { visible: 1 }; \
             o[s] = 2; \
             Object.keys(o).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("visible".into()));
    }

    #[test]
    fn test_object_keys_string_coercion_returns_indices() {
        let result = global_eval("Object.keys('cat').join(',')").unwrap();
        assert_eq!(result, JsValue::String("0,1,2".into()));
    }

    #[test]
    fn test_object_values_respects_key_filtering_and_order() {
        let result = global_eval(
            "var p = { inherited: 0 }; \
             var o = Object.create(p); \
             Object.defineProperty(o, '2', { value: 'two', enumerable: true }); \
             Object.defineProperty(o, 'hidden', { value: 'nope', enumerable: false }); \
             o.a = 'aye'; \
             Object.defineProperty(o, '1', { value: 'one', enumerable: true }); \
             Object.values(o).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("one,two,aye".into()));
    }

    #[test]
    fn test_object_values_invokes_getters() {
        let result = global_eval(
            "var calls = 0; \
             var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { calls++; return 7; }, enumerable: true }); \
             var values = Object.values(o); \
             '' + values[0] + ',' + calls",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("7,1".into()));
    }

    #[test]
    fn test_object_values_string_coercion_returns_characters() {
        let result = global_eval("Object.values('go').join(',')").unwrap();
        assert_eq!(result, JsValue::String("g,o".into()));
    }

    #[test]
    fn test_object_values_orders_numeric_keys() {
        let result = global_eval(
            "var o = {}; \
             o.z = 'zee'; \
             Object.defineProperty(o, '10', { value: 'ten', enumerable: true }); \
             Object.defineProperty(o, '2', { value: 'two', enumerable: true }); \
             Object.values(o).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("two,ten,zee".into()));
    }

    #[test]
    fn test_object_entries_respects_key_filtering_and_order() {
        let result = global_eval(
            "var p = { inherited: 0 }; \
             var o = Object.create(p); \
             Object.defineProperty(o, '2', { value: 'two', enumerable: true }); \
             Object.defineProperty(o, 'hidden', { value: 'nope', enumerable: false }); \
             o.a = 'aye'; \
             Object.defineProperty(o, '1', { value: 'one', enumerable: true }); \
             var e = Object.entries(o); \
             e[0][0] + ':' + e[0][1] + ',' + e[1][0] + ':' + e[1][1] + ',' + e[2][0] + ':' + e[2][1]",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1:one,2:two,a:aye".into()));
    }

    #[test]
    fn test_object_entries_invokes_getters() {
        let result = global_eval(
            "var calls = 0; \
             var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { calls++; return 7; }, enumerable: true }); \
             var entries = Object.entries(o); \
             entries[0][0] + ':' + entries[0][1] + ',' + calls",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("x:7,1".into()));
    }

    #[test]
    fn test_object_entries_string_coercion_returns_pairs() {
        let result = global_eval(
            "var e = Object.entries('ab'); \
             e[0][0] + e[0][1] + e[1][0] + e[1][1]",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("0a1b".into()));
    }

    #[test]
    fn test_object_entries_orders_numeric_keys() {
        let result = global_eval(
            "var o = {}; \
             o.z = 'zee'; \
             Object.defineProperty(o, '10', { value: 'ten', enumerable: true }); \
             Object.defineProperty(o, '2', { value: 'two', enumerable: true }); \
             var e = Object.entries(o); \
             e[0][0] + ':' + e[0][1] + ',' + e[1][0] + ':' + e[1][1] + ',' + e[2][0] + ':' + e[2][1]",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("2:two,10:ten,z:zee".into()));
    }

    #[test]
    fn test_object_assign_skips_non_enumerable_source_properties() {
        let result = global_eval(
            "var src = {}; \
             Object.defineProperty(src, 'visible', { value: 1, enumerable: true }); \
             Object.defineProperty(src, 'hidden', { value: 2, enumerable: false }); \
             var target = {}; \
             Object.assign(target, src); \
             Object.keys(target).join(',') + ':' + target.visible + ':' + typeof target.hidden",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("visible:1:undefined".into()));
    }

    #[test]
    fn test_object_assign_copies_accessor_values() {
        let result = global_eval(
            "var calls = 0; \
             var src = {}; \
             Object.defineProperty(src, 'x', { get: function() { calls++; return 7; }, enumerable: true }); \
             var target = {}; \
             Object.assign(target, src); \
             '' + target.x + ',' + calls",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("7,1".into()));
    }

    #[test]
    fn test_object_assign_triggers_target_setter() {
        let result = global_eval(
            "var seen = ''; \
             var target = { set x(v) { seen = '' + v; } }; \
             Object.assign(target, { x: 42 }); \
             seen",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("42".into()));
    }

    #[test]
    fn test_object_assign_handles_multiple_sources() {
        let result =
            global_eval("var target = {}; Object.assign(target, { a: 1 }, { b: 2 }, { c: 3 }); target.a + target.b + target.c")
                .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    #[test]
    fn test_object_assign_skips_nullish_sources() {
        let result = global_eval(
            "var target = { a: 1 }; \
             Object.assign(target, null, undefined, { b: 2 }); \
             '' + target.a + ',' + target.b",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_object_assign_orders_numeric_keys_on_target() {
        let result = global_eval(
            "var target = {}; \
             Object.assign(target, { b: 'bee' }, { 2: 'two' }, { a: 'aye' }, { 1: 'one' }); \
             Object.keys(target).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2,b,a".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_object_create_null_prototype_has_no_object_methods() {
        let result = global_eval("typeof Object.create(null).toString").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn test_object_create_descriptors_control_enumerability() {
        let result = global_eval(
            "var o = Object.create({}, { \
                 hidden: { value: 1, enumerable: false }, \
                 visible: { value: 2, enumerable: true } \
             }); \
             Object.keys(o).join(',') + ':' + o.visible + ':' + typeof o.hidden",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("visible:2:number".into()));
    }

    #[test]
    fn test_object_create_descriptor_getter_is_used() {
        let result = global_eval(
            "var o = Object.create({}, { \
                 value: { get: function() { return 99; }, enumerable: true } \
             }); \
             o.value",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    #[test]
    fn test_object_create_descriptor_numeric_ordering_is_preserved() {
        let result = global_eval(
            "var o = Object.create({}, { \
                 b: { value: 'bee', enumerable: true }, \
                 2: { value: 'two', enumerable: true }, \
                 a: { value: 'aye', enumerable: true }, \
                 1: { value: 'one', enumerable: true } \
             }); \
             Object.keys(o).join(',')",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2,b,a".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn test_object_get_prototype_of_plain_object_returns_object_prototype() {
        let result = global_eval("Object.getPrototypeOf({}) === Object.prototype").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_object_get_prototype_of_null_prototype_object_returns_null() {
        let result = global_eval("Object.getPrototypeOf(Object.create(null)) === null").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_object_set_prototype_of_null_removes_inherited_properties() {
        let result = global_eval(
            "var proto = { x: 1 }; \
             var obj = Object.create(proto); \
             Object.setPrototypeOf(obj, null); \
             typeof obj.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn test_object_set_prototype_of_object_restores_chain() {
        let result = global_eval(
            "var proto = { x: 1 }; \
             var obj = Object.create(null); \
             Object.setPrototypeOf(obj, proto); \
             obj.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn test_object_set_prototype_of_null_object_returns_same_object() {
        let result = global_eval(
            "var obj = {}; \
             Object.setPrototypeOf(obj, null) === obj && Object.getPrototypeOf(obj) === null",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_object_is_treats_nan_as_same_value() {
        let result = global_eval("Object.is(NaN, NaN)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn test_object_is_distinguishes_positive_and_negative_zero() {
        let result = global_eval("Object.is(0, -0)").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    // ── String method edge-case tests ───────────────────────────────────────

    /// `$$` in replacement inserts a literal `$`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_dollar_dollar() {
        let r = global_eval("'abc'.replace('b', '$$')").unwrap();
        assert_eq!(r, JsValue::String("a$c".into()));
    }

    /// `$&` in replacement inserts the matched substring.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_dollar_ampersand() {
        let r = global_eval("'abc'.replace('b', '[$&]')").unwrap();
        assert_eq!(r, JsValue::String("a[b]c".into()));
    }

    /// `` $` `` in replacement inserts the portion before the match.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_dollar_backtick() {
        let r = global_eval("'abc'.replace('b', '$`')").unwrap();
        assert_eq!(r, JsValue::String("aac".into()));
    }

    /// `$'` in replacement inserts the portion after the match.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_dollar_singlequote() {
        let r = global_eval("'abc'.replace('b', \"$'\")").unwrap();
        assert_eq!(r, JsValue::String("acc".into()));
    }

    /// Replace with function replacer — receives (match, offset, string).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_function_replacer() {
        let r =
            global_eval("'hello'.replace('ll', function(m, off, s) { return off.toString(); })")
                .unwrap();
        assert_eq!(r, JsValue::String("he2o".into()));
    }

    /// Regex replacer receives (match, ...groups, offset, string).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_regex_function_replacer_groups() {
        let r = global_eval(
            "'2024-07'.replace(/(\\d+)-(\\d+)/, function(m, y, mo, off, s) { return y + ':' + mo + ':' + off + ':' + s; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2024:07:0:2024-07".into()));
    }

    /// Regex replacement expands `$1` and `$2` capture references.
    #[test]
    fn e2e_replace_regex_capture_groups() {
        let r = global_eval("'2024-07'.replace(/(\\d+)-(\\d+)/, '$2/$1')").unwrap();
        assert_eq!(r, JsValue::String("07/2024".into()));
    }

    /// Plain-string replace leaves missing capture references literal.
    #[test]
    fn e2e_replace_missing_capture_literal() {
        let r = global_eval("'abc'.replace('b', '$1')").unwrap();
        assert_eq!(r, JsValue::String("a$1c".into()));
    }

    /// Replace with function replacer — match not found returns original.
    #[test]
    fn e2e_replace_fn_replacer_no_match() {
        let r = global_eval("'hello'.replace('xyz', function(m) { return 'Z'; })").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `$$` works in replaceAll.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_all_dollar_dollar() {
        let r = global_eval("'aba'.replaceAll('a', '$$')").unwrap();
        assert_eq!(r, JsValue::String("$b$".into()));
    }

    /// `$&` works in replaceAll.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_all_dollar_ampersand() {
        let r = global_eval("'aba'.replaceAll('a', '[$&]')").unwrap();
        assert_eq!(r, JsValue::String("[a]b[a]".into()));
    }

    /// replaceAll with function replacer.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_all_fn_replacer() {
        let r =
            global_eval("'abab'.replaceAll('a', function(m, off, s) { return off.toString(); })")
                .unwrap();
        assert_eq!(r, JsValue::String("0b2b".into()));
    }

    /// replaceAll empty search inserts between every character.
    #[test]
    fn e2e_replace_all_empty_search_inserts() {
        let r = global_eval("'ab'.replaceAll('', '-')").unwrap();
        assert_eq!(r, JsValue::String("-a-b-".into()));
    }

    /// RegExp instances expose `global` as an accessor property.
    #[test]
    fn e2e_regexp_global_descriptor_is_getter() {
        let r = global_eval(
            "typeof Object.getOwnPropertyDescriptor(new RegExp('a', 'g'), 'global').get",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp instances expose `ignoreCase` as an accessor property.
    #[test]
    fn e2e_regexp_ignore_case_descriptor_is_getter() {
        let r = global_eval(
            "typeof Object.getOwnPropertyDescriptor(new RegExp('a', 'i'), 'ignoreCase').get",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp instances expose `multiline` as an accessor property.
    #[test]
    fn e2e_regexp_multiline_descriptor_is_getter() {
        let r = global_eval(
            "typeof Object.getOwnPropertyDescriptor(new RegExp('a', 'm'), 'multiline').get",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp instances expose `dotAll` as an accessor property.
    #[test]
    fn e2e_regexp_dot_all_descriptor_is_getter() {
        let r = global_eval(
            "typeof Object.getOwnPropertyDescriptor(new RegExp('a', 's'), 'dotAll').get",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp instances expose `sticky` as an accessor property.
    #[test]
    fn e2e_regexp_sticky_descriptor_is_getter() {
        let r = global_eval(
            "typeof Object.getOwnPropertyDescriptor(new RegExp('a', 'y'), 'sticky').get",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp instances expose `unicode` as an accessor property.
    #[test]
    fn e2e_regexp_unicode_descriptor_is_getter() {
        let r = global_eval(
            "typeof Object.getOwnPropertyDescriptor(new RegExp('a', 'u'), 'unicode').get",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp instances expose `hasIndices` as an accessor property.
    #[test]
    fn e2e_regexp_has_indices_descriptor_is_getter() {
        let r = global_eval(
            "typeof Object.getOwnPropertyDescriptor(new RegExp('a', 'd'), 'hasIndices').get",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp instances expose `flags` as an accessor property.
    #[test]
    fn e2e_regexp_flags_descriptor_is_getter() {
        let r = global_eval(
            "typeof Object.getOwnPropertyDescriptor(new RegExp('a', 'gi'), 'flags').get",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp instances expose `source` as an accessor property.
    #[test]
    fn e2e_regexp_source_descriptor_is_getter() {
        let r =
            global_eval("typeof Object.getOwnPropertyDescriptor(new RegExp('a'), 'source').get")
                .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp.prototype also exposes `source` as an accessor property.
    #[test]
    fn e2e_regexp_prototype_source_descriptor_is_getter() {
        let r =
            global_eval("typeof Object.getOwnPropertyDescriptor(RegExp.prototype, 'source').get")
                .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp.prototype also exposes `flags` as an accessor property.
    #[test]
    fn e2e_regexp_prototype_flags_descriptor_is_getter() {
        let r =
            global_eval("typeof Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get")
                .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// RegExp.prototype also exposes `global` as an accessor property.
    #[test]
    fn e2e_regexp_prototype_global_descriptor_is_getter() {
        let r =
            global_eval("typeof Object.getOwnPropertyDescriptor(RegExp.prototype, 'global').get")
                .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// `source` escapes solidus characters from the original pattern.
    #[test]
    fn e2e_regexp_source_escapes_slash() {
        let r = global_eval("new RegExp('a/b').source").unwrap();
        assert_eq!(r, JsValue::String("a\\/b".into()));
    }

    /// Empty-pattern regexps expose `(?:)` as their source text.
    #[test]
    fn e2e_regexp_source_empty_pattern() {
        let r = global_eval("new RegExp('').source").unwrap();
        assert_eq!(r, JsValue::String("(?:)".into()));
    }

    /// `RegExp.prototype.source` on the prototype itself returns `(?:)`.
    #[test]
    fn e2e_regexp_prototype_source_default() {
        let r = global_eval("RegExp.prototype.source").unwrap();
        assert_eq!(r, JsValue::String("(?:)".into()));
    }

    /// `flags` are reported in canonical order including sticky and indices.
    #[test]
    fn e2e_regexp_flags_canonical_full_order() {
        let r = global_eval("new RegExp('.', 'ygdmisu').flags").unwrap();
        assert_eq!(r, JsValue::String("dgimsuy".into()));
    }

    /// `test` returns a boolean false result when the pattern does not match.
    #[test]
    fn e2e_regexp_test_false_boolean() {
        let r =
            global_eval("typeof new RegExp('z').test('abc') + ':' + new RegExp('z').test('abc')")
                .unwrap();
        assert_eq!(r, JsValue::String("boolean:false".into()));
    }

    /// Global `test` advances `lastIndex` after a successful match.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_test_global_updates_last_index() {
        let r = global_eval(
            "var re = new RegExp('a', 'g'); String(re.test('ba')) + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true:2".into()));
    }

    /// Sticky `test` respects `lastIndex` as the required start position.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_test_sticky_respects_last_index() {
        let r = global_eval(
            "var re = new RegExp('a', 'y'); re.lastIndex = 1; String(re.test('ba')) + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true:2".into()));
    }

    /// Sticky `test` resets `lastIndex` to zero after a failed anchored match.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_test_sticky_failure_resets_last_index() {
        let r = global_eval(
            "var re = new RegExp('a', 'y'); re.lastIndex = 2; String(re.test('ba')) + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("false:0".into()));
    }

    /// dotAll mode lets `.` match a newline.
    #[test]
    fn e2e_regexp_dot_all_matches_newline() {
        let r = global_eval("new RegExp('a.b', 's').test('a\\nb')").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Without dotAll, `.` does not match a newline.
    #[test]
    fn e2e_regexp_without_dot_all_rejects_newline() {
        let r = global_eval("new RegExp('a.b').test('a\\nb')").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `toString` includes escaped source text and canonical flags.
    #[test]
    fn e2e_regexp_to_string_escapes_source() {
        let r = global_eval("new RegExp('a/b', 'yg').toString()").unwrap();
        assert_eq!(r, JsValue::String("/a\\/b/gy".into()));
    }

    /// Prototype `toString` follows the same escaped source formatting.
    #[test]
    fn e2e_regexp_prototype_to_string_escapes_source() {
        let r = global_eval("RegExp.prototype.toString.call(new RegExp('a/b', 'g'))").unwrap();
        assert_eq!(r, JsValue::String("/a\\/b/g".into()));
    }

    /// Regex function replacers receive undefined for nonparticipating groups.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_regex_function_replacer_missing_group() {
        let r = global_eval(
            "'a'.replace(/(a)?(b)?/, function(m, a, b, off, s) { return String(a === 'a') + ':' + String(b === undefined) + ':' + off + ':' + s; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true:true:0:a".into()));
    }

    /// Global regex function replacers receive captures, offsets, and the full string.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_regex_function_replacer_global_offsets() {
        let r = global_eval(
            "'a1b2'.replace(/(\\d)/g, function(m, d, off, s) { return '[' + d + ',' + off + ',' + s.length + ']'; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a[1,1,4]b[2,3,4]".into()));
    }

    /// RegExp `split` counts capture groups toward the result limit.
    #[test]
    fn e2e_split_regexp_captures_respect_limit() {
        let r = global_eval("'a1b2c'.split(/(\\d)/, 3).join('|')").unwrap();
        assert_eq!(r, JsValue::String("a|1|b".into()));
    }

    /// RegExp `split` with limit 1 only returns the prefix before the first match.
    #[test]
    fn e2e_split_regexp_limit_one() {
        let r = global_eval("'a1b2c'.split(/(\\d)/, 1).join('|')").unwrap();
        assert_eq!(r, JsValue::String("a".into()));
    }

    /// RegExp `split` returns the whole string unchanged when there is no match.
    #[test]
    fn e2e_split_regexp_no_match_with_limit() {
        let r = global_eval("'abc'.split(/(\\d)/, 2).join('|')").unwrap();
        assert_eq!(r, JsValue::String("abc".into()));
    }

    /// `"".split("")` returns empty array.
    #[test]
    fn e2e_split_empty_on_empty_edge() {
        let r = global_eval("''.split('').length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Split with limit 0 returns empty array.
    #[test]
    fn e2e_split_limit_zero_edge() {
        let r = global_eval("'a,b,c'.split(',', 0).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Split with limit 2 returns first 2 parts.
    #[test]
    fn e2e_split_limit_two() {
        let r = global_eval("'a,b,c'.split(',', 2).join('-')").unwrap();
        assert_eq!(r, JsValue::String("a-b".into()));
    }

    /// Empty separator splits into UTF-16 code units.
    #[test]
    fn e2e_split_empty_separator_chars() {
        let r = global_eval("'abc'.split('').join('-')").unwrap();
        assert_eq!(r, JsValue::String("a-b-c".into()));
    }

    /// RegExp separators include capture groups in the result.
    #[test]
    fn e2e_split_regexp_captures() {
        let r = global_eval("'a1b2c'.split(/(\\d)/).join('|')").unwrap();
        assert_eq!(r, JsValue::String("a|1|b|2|c".into()));
    }

    /// Global `match` collects all matches and resets `lastIndex`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_match_global_resets_last_index() {
        let r = global_eval(
            "var re = /a/g; re.lastIndex = 2; var out = 'baab'.match(re); out.join(',') + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a,a:0".into()));
    }

    /// Global `match` with no matches returns `null` and resets `lastIndex`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_match_global_no_match_resets_last_index() {
        let r = global_eval(
            "var re = /z/g; re.lastIndex = 3; var out = 'abc'.match(re); String(out === null) + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true:0".into()));
    }

    /// Sticky-only `match` behaves like `exec`, not global collection.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_match_sticky_returns_exec_shape() {
        let r = global_eval(
            "var re = /a/y; re.lastIndex = 1; var out = 'ba'.match(re); out[0] + ':' + out.index + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a:1:2".into()));
    }

    /// Sticky-only `match` failure resets `lastIndex`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_match_sticky_failure_resets_last_index() {
        let r = global_eval(
            "var re = /a/y; re.lastIndex = 1; var out = 'bb'.match(re); String(out === null) + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true:0".into()));
    }

    /// Global zero-length `match` terminates and includes the end position.
    #[test]
    fn e2e_regexp_match_global_zero_length() {
        let r = global_eval("'ab'.match(/(?:)/g).length").unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// Sticky `search` only matches at the operation's start position.
    #[test]
    fn e2e_regexp_search_sticky_requires_start_match() {
        let r = global_eval("var re = /b/y; re.lastIndex = 2; 'ab'.search(re)").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// `search` restores a sticky regexp's original `lastIndex`.
    #[test]
    fn e2e_regexp_search_sticky_restores_last_index() {
        let r =
            global_eval("var re = /a/y; re.lastIndex = 1; 'ba'.search(re); re.lastIndex").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// `search` restores a global regexp's original `lastIndex`.
    #[test]
    fn e2e_regexp_search_global_restores_last_index() {
        let r =
            global_eval("var re = /a/g; re.lastIndex = 2; 'ba'.search(re); re.lastIndex").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// Function replacers receive named groups as the final parameter.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_replace_function_named_groups() {
        let r = global_eval(
            "'2024-07'.replace(/(?<year>\\d{4})-(?<month>\\d{2})/, function(m, y, mo, off, s, groups) { return groups.month + '/' + groups.year; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("07/2024".into()));
    }

    /// Named-group replacers receive six arguments including `groups`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_replace_function_named_groups_argument_count() {
        let r = global_eval(
            "'2024-07'.replace(/(?<year>\\d{4})-(?<month>\\d{2})/, function(m, y, mo, off, s, groups) { return String(arguments.length) + ':' + groups.year; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("6:2024".into()));
    }

    /// Replacers without named groups do not receive a `groups` argument.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_replace_function_without_named_groups_argument_count() {
        let r = global_eval(
            "'2024-07'.replace(/(\\d+)-(\\d+)/, function(m, y, mo, off, s) { return String(arguments.length) + ':' + off; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("5:0".into()));
    }

    /// Missing named captures are surfaced as `undefined` in the groups object.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_replace_function_named_groups_undefined_entry() {
        let r = global_eval(
            "'a'.replace(/(?<x>a)|(?<y>b)/, function(m, x, y, off, s, groups) { return groups.x === 'a' && groups.y === undefined ? 'ok' : 'bad'; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Global function replacers receive named groups for each match.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_replace_function_named_groups_global() {
        let r = global_eval(
            "'2024-07 2025-01'.replace(/(?<year>\\d{4})-(?<month>\\d{2})/g, function(m, y, mo, off, s, groups) { return groups.month + '/' + groups.year + '@' + off; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("07/2024@0 01/2025@8".into()));
    }

    /// Global replace resets `lastIndex` after completion.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_replace_global_resets_last_index() {
        let r =
            global_eval("var re = /a/g; re.lastIndex = 1; 'baab'.replace(re, 'x'); re.lastIndex")
                .unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Sticky non-global replace starts from the current `lastIndex`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_replace_sticky_uses_current_last_index() {
        let r = global_eval("var re = /a/y; re.lastIndex = 1; 'baab'.replace(re, 'x')").unwrap();
        assert_eq!(r, JsValue::String("bxab".into()));
    }

    /// Sticky replace failure resets `lastIndex` via exec semantics.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_replace_sticky_failure_resets_last_index() {
        let r = global_eval(
            "var re = /a/y; re.lastIndex = 3; 'baab'.replace(re, 'x') + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("baab:0".into()));
    }

    /// Zero-length regexp splits a non-empty string into characters.
    #[test]
    fn e2e_regexp_split_zero_length_non_empty() {
        let r = global_eval("'ab'.split(/(?:)/).join('|')").unwrap();
        assert_eq!(r, JsValue::String("a|b".into()));
    }

    /// Zero-length regexp splits an empty string into an empty array.
    #[test]
    fn e2e_regexp_split_zero_length_empty_input() {
        let r = global_eval("''.split(/(?:)/).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Zero-length regexp split respects the result limit.
    #[test]
    fn e2e_regexp_split_zero_length_limit() {
        let r = global_eval("'ab'.split(/(?:)/, 1)[0]").unwrap();
        assert_eq!(r, JsValue::String("a".into()));
    }

    /// RegExp split does not mutate the original global regexp's `lastIndex`.
    #[test]
    fn e2e_regexp_split_preserves_global_last_index() {
        let r =
            global_eval("var re = /a/g; re.lastIndex = 2; 'baab'.split(re); re.lastIndex").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// Sticky regexp split preserves the original `lastIndex`.
    #[test]
    fn e2e_regexp_split_sticky_preserves_last_index() {
        let r = global_eval(
            "var re = /a/y; re.lastIndex = 1; 'baab'.split(re).join('|') + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("b||b:1".into()));
    }

    /// Constructing from a regexp preserves the source and flags.
    #[test]
    fn e2e_regexp_constructor_from_regexp_preserves_source_and_flags() {
        let r = global_eval(
            "var re = /a/gi; var clone = new RegExp(re); clone.source + ':' + clone.flags",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a:gi".into()));
    }

    /// Constructing from a regexp with explicit flags overrides the original flags.
    #[test]
    fn e2e_regexp_constructor_from_regexp_overrides_flags() {
        let r = global_eval(
            "var re = /a/gi; var clone = new RegExp(re, 'm'); clone.source + ':' + clone.flags",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a:m".into()));
    }

    /// Constructing from a regexp starts the new object's `lastIndex` at zero.
    #[test]
    fn e2e_regexp_constructor_from_regexp_resets_last_index() {
        let r = global_eval(
            "var re = /a/g; re.lastIndex = 2; var clone = new RegExp(re); clone.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Instance `toString()` renders an empty pattern as `(?:)`.
    #[test]
    fn e2e_regexp_to_string_empty_pattern() {
        let r = global_eval("new RegExp('').toString()").unwrap();
        assert_eq!(r, JsValue::String("/(?:)/".into()));
    }

    /// `lastIndex` is coerced from strings for global exec.
    #[test]
    fn e2e_regexp_last_index_string_coercion() {
        let r =
            global_eval("var re = /a/g; re.lastIndex = '2'; var m = re.exec('baab'); m.index + ':' + re.lastIndex")
                .unwrap();
        assert_eq!(r, JsValue::String("2:3".into()));
    }

    /// Negative `lastIndex` values clamp to zero.
    #[test]
    fn e2e_regexp_last_index_negative_clamps_to_zero() {
        let r = global_eval(
            "var re = /a/y; re.lastIndex = -1; var m = re.exec('ab'); m.index + ':' + re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0:1".into()));
    }

    /// `NaN` `lastIndex` values coerce to zero before matching.
    #[test]
    fn e2e_regexp_last_index_nan_coerces_to_zero() {
        let r =
            global_eval("var re = /a/g; re.lastIndex = NaN; re.exec('ba'); re.lastIndex").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// Combined global+sticky `match` resets `lastIndex` after collecting matches.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_match_global_sticky_resets_last_index() {
        let r =
            global_eval("var re = /a/gy; re.lastIndex = 2; var out = 'aaab'.match(re); out.join(',') + ':' + re.lastIndex")
                .unwrap();
        assert_eq!(r, JsValue::String("a,a,a:0".into()));
    }

    /// Split without a separator returns the original string as one element.
    #[test]
    fn e2e_split_undefined_separator() {
        let r = global_eval("'abc'.split(undefined).length").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// Global regexp `match` returns all whole-match strings.
    #[test]
    fn e2e_string_match_global_returns_all_matches() {
        let r = global_eval("'a1b22c333'.match(/\\d+/g).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,22,333".into()));
    }

    /// Global regexp `match` resets `lastIndex` after iteration completes.
    #[test]
    fn e2e_string_match_global_resets_last_index() {
        let r = global_eval("var re = /a/g; 'aba'.match(re); re.lastIndex").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Global regexp `match` returns null when there are no matches.
    #[test]
    fn e2e_string_match_global_no_match_returns_null() {
        let r = global_eval("'abc'.match(/\\d/g) === null").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Global regexp `match` returns whole matches, not capture tuples.
    #[test]
    fn e2e_string_match_global_returns_whole_matches_only() {
        let r = global_eval("'ab12cd34'.match(/(\\d+)/g).join('|')").unwrap();
        assert_eq!(r, JsValue::String("12|34".into()));
    }

    /// `matchAll` reports indices in UTF-16 code units.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_string_match_all_utf16_indices() {
        let r = global_eval(
            "Array.from('😀a😀b'.matchAll(/[ab]/g)).map(function(m) { return m.index; }).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2,5".into()));
    }

    /// `matchAll` starts from the regexp's current `lastIndex`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_string_match_all_uses_existing_last_index() {
        let r = global_eval(
            "var re = /a/g; re.lastIndex = 2; Array.from('baaa'.matchAll(re)).map(function(m) { return m.index; }).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2,3".into()));
    }

    /// `matchAll` does not mutate the original regexp's `lastIndex`.
    #[test]
    fn e2e_string_match_all_preserves_original_last_index() {
        let r = global_eval(
            "var re = /a/g; re.lastIndex = 2; Array.from('baaa'.matchAll(re)); re.lastIndex",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// `matchAll` with named groups keeps the groups object on each match.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_string_match_all_named_groups_object() {
        let r = global_eval(
            "Array.from('2024-07 2025-08'.matchAll(/(?<y>\\d{4})-(?<m>\\d{2})/g)).map(function(m) { return m.groups.y + '/' + m.groups.m; }).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2024/07,2025/08".into()));
    }

    /// Regex function replacers receive UTF-16 offsets.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_regex_function_replacer_utf16_offsets() {
        let r = global_eval(
            "'😀1😀2'.replace(/(\\d)/g, function(m, d, off) { return '[' + off + ']'; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("😀[2]😀[5]".into()));
    }

    /// Regex function replacers receive named groups as the final argument.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_regex_function_replacer_named_groups_argument() {
        let r = global_eval(
            "'2024-07'.replace(/(?<y>\\d+)-(?<m>\\d+)/, function(m, y, mo, off, s, groups) { return groups.y + '/' + groups.m + '/' + off; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2024/07/0".into()));
    }

    /// Regex function replacers surface undefined named-group values.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_regex_function_replacer_named_group_undefined() {
        let r = global_eval(
            "'a'.replace(/(?<a>a)|(?<b>b)/, function(m, a, b, off, s, groups) { return String(groups.a === 'a') + ':' + String(groups.b === undefined); })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true:true".into()));
    }

    /// Regex function replacers leave the input unchanged when nothing matches.
    #[test]
    fn e2e_replace_regex_function_replacer_no_match() {
        let r = global_eval("'hello'.replace(/\\d+/, function() { return 'x'; })").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `replaceAll` with a global regexp callback uses UTF-16 offsets.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_all_regex_function_replacer_utf16_offsets() {
        let r = global_eval(
            "'😀1😀2'.replaceAll(/(\\d)/g, function(m, d, off) { return '[' + off + ']'; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("😀[2]😀[5]".into()));
    }

    /// `replaceAll` forwards named groups to callback replacers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_replace_all_regex_function_replacer_named_groups_argument() {
        let r = global_eval(
            "'2024-07 2025-08'.replaceAll(/(?<y>\\d+)-(?<m>\\d+)/g, function(m, y, mo, off, s, groups) { return groups.m + '/' + groups.y + '@' + off; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("07/2024@0 08/2025@8".into()));
    }

    /// `replaceAll` with a regexp callback leaves the input unchanged when there are no matches.
    #[test]
    fn e2e_replace_all_regex_function_replacer_no_match() {
        let r = global_eval("'hello'.replaceAll(/\\d+/g, function() { return 'x'; })").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `replaceAll` resets a global regexp's `lastIndex` after replacement.
    #[test]
    fn e2e_replace_all_regex_resets_last_index() {
        let r = global_eval("var re = /a/g; 'aba'.replaceAll(re, 'x'); re.lastIndex").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// `search` with a regexp returns a UTF-16 code unit index.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_string_search_regexp_uses_utf16_index() {
        let r = global_eval("'😀a'.search(/a/)").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// `search` preserves the original regexp `lastIndex`.
    #[test]
    fn e2e_string_search_regexp_preserves_last_index() {
        let r =
            global_eval("var re = /a/g; re.lastIndex = 2; 'ba'.search(re) + ':' + re.lastIndex")
                .unwrap();
        assert_eq!(r, JsValue::String("1:2".into()));
    }

    /// `search` returns `-1` when the regexp does not match.
    #[test]
    fn e2e_string_search_regexp_no_match() {
        let r = global_eval("'abc'.search(/\\d+/)").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// RegExp `split` treats negative limits via `ToUint32`.
    #[test]
    fn e2e_split_regexp_negative_limit_wraps() {
        let r = global_eval("'a1b2'.split(/(\\d)/, -1).join('|')").unwrap();
        assert_eq!(r, JsValue::String("a|1|b|2|".into()));
    }

    /// RegExp `split` with `NaN` limit returns an empty array.
    #[test]
    fn e2e_split_regexp_nan_limit_is_zero() {
        let r = global_eval("'a1b2'.split(/(\\d)/, NaN).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// RegExp `split` with `Infinity` limit returns an empty array.
    #[test]
    fn e2e_split_regexp_infinity_limit_is_zero() {
        let r = global_eval("'a1b2'.split(/(\\d)/, Infinity).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// RegExp `split` with captures counts the limit in result elements even around astral chars.
    #[test]
    fn e2e_split_regexp_limit_counts_utf16_agnostic_parts() {
        let r = global_eval("'😀1😀2x'.split(/(\\d)/, 4).join('|')").unwrap();
        assert_eq!(r, JsValue::String("😀|1|😀|2".into()));
    }

    /// `trimStart` and `trimLeft` are the same function object.
    #[test]
    fn e2e_string_trim_start_is_trim_left_alias() {
        let r = global_eval("String.prototype.trimStart === String.prototype.trimLeft").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `trimEnd` and `trimRight` are the same function object.
    #[test]
    fn e2e_string_trim_end_is_trim_right_alias() {
        let r = global_eval("String.prototype.trimEnd === String.prototype.trimRight").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `trimLeft.name` matches the canonical `trimStart` name.
    #[test]
    fn e2e_string_trim_left_alias_uses_trim_start_name() {
        let r =
            global_eval("String.prototype.trimStart.name + ':' + String.prototype.trimLeft.name")
                .unwrap();
        assert_eq!(r, JsValue::String("trimStart:trimStart".into()));
    }

    /// `trimRight.name` matches the canonical `trimEnd` name.
    #[test]
    fn e2e_string_trim_right_alias_uses_trim_end_name() {
        let r =
            global_eval("String.prototype.trimEnd.name + ':' + String.prototype.trimRight.name")
                .unwrap();
        assert_eq!(r, JsValue::String("trimEnd:trimEnd".into()));
    }

    /// `isWellFormed` is exposed as a string prototype method.
    #[test]
    fn e2e_string_is_well_formed_exists() {
        let r = global_eval("typeof ''.isWellFormed").unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// Plain BMP strings are well formed.
    #[test]
    fn e2e_string_is_well_formed_ascii() {
        let r = global_eval("'hello'.isWellFormed()").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Astral characters are treated as well formed.
    #[test]
    fn e2e_string_is_well_formed_astral() {
        let r = global_eval("'😀'.isWellFormed()").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `toWellFormed` leaves ordinary strings unchanged.
    #[test]
    fn e2e_string_to_well_formed_ascii_identity() {
        let r = global_eval("'hello'.toWellFormed()").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `toWellFormed` leaves astral strings unchanged.
    #[test]
    fn e2e_string_to_well_formed_astral_identity() {
        let r = global_eval("'A😀B'.toWellFormed()").unwrap();
        assert_eq!(r, JsValue::String("A😀B".into()));
    }

    /// `String.fromCodePoint(0)` produces a single code unit string.
    #[test]
    fn e2e_string_from_code_point_zero() {
        let r = global_eval("String.fromCodePoint(0).length").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// Negative code points are rejected.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_string_from_code_point_rejects_negative() {
        assert!(global_eval("String.fromCodePoint(-1)").is_err());
    }

    /// Values above the Unicode range are rejected.
    #[test]
    fn e2e_string_from_code_point_rejects_above_unicode_max() {
        assert!(global_eval("String.fromCodePoint(0x110000)").is_err());
    }

    /// `undefined` code points are rejected.
    #[test]
    fn e2e_string_from_code_point_rejects_undefined() {
        assert!(global_eval("String.fromCodePoint(undefined)").is_err());
    }

    /// `codePointAt` returns BMP code points directly.
    #[test]
    fn e2e_string_code_point_at_ascii() {
        let r = global_eval("'ABC'.codePointAt(1)").unwrap();
        assert_eq!(r, JsValue::Smi(66));
    }

    /// Negative `codePointAt` indices return `undefined`.
    #[test]
    fn e2e_string_code_point_at_negative_is_undefined() {
        let r = global_eval("'ABC'.codePointAt(-1) === undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Out-of-range `codePointAt` indices return `undefined`.
    #[test]
    fn e2e_string_code_point_at_out_of_range_is_undefined() {
        let r = global_eval("'ABC'.codePointAt(99) === undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `split(undefined)` returns the whole string.
    #[test]
    fn e2e_string_split_undefined_separator_returns_whole_string() {
        let r = global_eval(
            "'abc'.split(undefined).length === 1 && 'abc'.split(undefined)[0] === 'abc'",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `split(undefined, 0)` returns an empty array.
    #[test]
    fn e2e_string_split_undefined_separator_zero_limit() {
        let r = global_eval("'abc'.split(undefined, 0).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// String separators respect the limit parameter.
    #[test]
    fn e2e_string_split_string_separator_limit() {
        let r = global_eval("'a,b,c'.split(',', 2).join('|')").unwrap();
        assert_eq!(r, JsValue::String("a|b".into()));
    }

    /// RegExp separators include capture groups in the result.
    #[test]
    fn e2e_string_split_regexp_separator_includes_captures() {
        let r = global_eval("'a1b2c'.split(/(\\d)/).join('|')").unwrap();
        assert_eq!(r, JsValue::String("a|1|b|2|c".into()));
    }

    /// Optional RegExp captures surface as `undefined`.
    #[test]
    fn e2e_string_split_regexp_separator_optional_capture_is_undefined() {
        let r = global_eval(
            "var parts = 'a-b'.split(/-(x)?/); parts.length === 3 && parts[1] === undefined && parts[2] === 'b'",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// RegExp splits respect an explicit zero limit.
    #[test]
    fn e2e_string_split_regexp_separator_zero_limit() {
        let r = global_eval("'a1b2'.split(/(\\d)/, 0).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// RegExp splits with no matches return the original string.
    #[test]
    fn e2e_string_split_regexp_separator_no_match_returns_whole_string() {
        let r = global_eval("'abc'.split(/\\d+/).join('|')").unwrap();
        assert_eq!(r, JsValue::String("abc".into()));
    }

    /// String search falls back to string matching for non-RegExp inputs.
    #[test]
    fn e2e_string_search_string_fallback_finds_first_match() {
        let r = global_eval("'banana'.search('na')").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// String search returns `-1` when the string is absent.
    #[test]
    fn e2e_string_search_string_fallback_no_match() {
        let r = global_eval("'banana'.search('xy')").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// `replaceAll` with a non-global regexp throws a `TypeError`.
    #[test]
    fn e2e_string_replace_all_non_global_regexp_throws_type_error() {
        let r = global_eval(
            "try { 'a1b2'.replaceAll(/\\d/, 'x'); 'no'; } catch (e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `replaceAll` with a global regexp replaces each match.
    #[test]
    fn e2e_string_replace_all_global_regexp_replaces_all_matches() {
        let r = global_eval("'a1b2c3'.replaceAll(/\\d/g, 'x')").unwrap();
        assert_eq!(r, JsValue::String("axbxcx".into()));
    }

    /// RegExp replacers are called for `replaceAll`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_string_replace_all_regexp_function_replacer() {
        let r = global_eval("'a1b2'.replaceAll(/\\d/g, function(m) { return '[' + m + ']'; })")
            .unwrap();
        assert_eq!(r, JsValue::String("a[1]b[2]".into()));
    }

    /// `matchAll` returns an iterator object with `next`.
    #[test]
    fn e2e_string_match_all_returns_iterator_with_next() {
        let r = global_eval("typeof 'a1'.matchAll(/\\d/g).next").unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// `matchAll` iterators produce values until exhaustion.
    #[test]
    fn e2e_string_match_all_iterator_exhausts_after_matches() {
        let r = global_eval(
            "var it = 'a1b2'.matchAll(/\\d/g); var a = it.next(); var b = it.next(); var c = it.next(); a.value[0] + b.value[0] + ':' + c.done",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("12:true".into()));
    }

    /// Empty `matchAll` iterators report `done` immediately.
    #[test]
    fn e2e_string_match_all_empty_iterator_is_done() {
        let r = global_eval("var it = 'abc'.matchAll(/\\d+/g); it.next().done").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// String-pattern `matchAll` also returns an iterator.
    #[test]
    fn e2e_string_match_all_string_pattern_returns_iterator() {
        let r = global_eval("typeof 'aba'.matchAll('a').next").unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// `String.prototype.at(-Infinity)` returns `undefined`.
    #[test]
    fn e2e_string_at_negative_infinity_is_undefined() {
        let r = global_eval("'hello'.at(-Infinity) === undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `String.prototype.at` truncates fractional negative indices.
    #[test]
    fn e2e_string_at_fractional_negative_truncates() {
        let r = global_eval("'hello'.at(-1.9)").unwrap();
        assert_eq!(r, JsValue::String("o".into()));
    }

    /// `String.prototype.at` returns `undefined` when the negative index is too small.
    #[test]
    fn e2e_string_at_too_negative_is_undefined() {
        let r = global_eval("'hello'.at(-99) === undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `trimStart` removes a leading BOM.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_trim_start_bom() {
        let r = global_eval("'\\uFEFFhello'.trimStart()").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `trimEnd` removes a trailing BOM.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_trim_end_bom() {
        let r = global_eval("'hello\\uFEFF'.trimEnd()").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `trimStart` removes a leading non-breaking space.
    #[test]
    fn e2e_trim_start_nbsp() {
        let r = global_eval("'\\u00A0hello'.trimStart()").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `trimEnd` removes a trailing paragraph separator.
    #[test]
    fn e2e_trim_end_paragraph_separator() {
        let r = global_eval("'hello\\u2029'.trimEnd()").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `trimStart` trims only the leading ECMAScript whitespace.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_trim_start_preserves_trailing_ecmascript_whitespace() {
        let r = global_eval("'\\uFEFFhello\\u00A0'.trimStart()").unwrap();
        assert_eq!(r, JsValue::String("hello\u{00A0}".into()));
    }

    /// `trimEnd` trims only the trailing ECMAScript whitespace.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_trim_end_preserves_leading_ecmascript_whitespace() {
        let r = global_eval("'\\u00A0hello\\uFEFF'.trimEnd()").unwrap();
        assert_eq!(r, JsValue::String("\u{00A0}hello".into()));
    }

    /// `slice(-2)` returns last 2 characters.
    #[test]
    fn e2e_slice_negative_start_edge() {
        let r = global_eval("'abcde'.slice(-2)").unwrap();
        assert_eq!(r, JsValue::String("de".into()));
    }

    /// `slice(1, -1)` with negative end.
    #[test]
    fn e2e_slice_negative_end_edge() {
        let r = global_eval("'abcde'.slice(1, -1)").unwrap();
        assert_eq!(r, JsValue::String("bcd".into()));
    }

    /// `slice` with start > end returns empty string.
    #[test]
    fn e2e_slice_start_gt_end_edge() {
        let r = global_eval("'abcde'.slice(3, 1)").unwrap();
        assert_eq!(r, JsValue::String("".into()));
    }

    /// `substring` swaps args when start > end.
    #[test]
    fn e2e_substring_swaps_edge() {
        let r = global_eval("'abcde'.substring(3, 1)").unwrap();
        assert_eq!(r, JsValue::String("bc".into()));
    }

    /// `substring` negative indices are clamped to 0.
    #[test]
    fn e2e_substring_negative_clamped_edge() {
        let r = global_eval("'abcde'.substring(-3, 3)").unwrap();
        assert_eq!(r, JsValue::String("abc".into()));
    }

    /// `substring` clamps negative end to 0 before swapping.
    #[test]
    fn e2e_substring_negative_end_clamped_edge() {
        let r = global_eval("'abcde'.substring(2, -1)").unwrap();
        assert_eq!(r, JsValue::String("ab".into()));
    }

    /// `substr` negative start counts from end.
    #[test]
    fn e2e_substr_negative_start_edge() {
        let r = global_eval("'hello'.substr(-3, 2)").unwrap();
        assert_eq!(r, JsValue::String("ll".into()));
    }

    /// `startsWith` with position parameter.
    #[test]
    fn e2e_starts_with_position_edge() {
        let r = global_eval("'hello world'.startsWith('world', 6)").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `endsWith` with endPosition parameter.
    #[test]
    fn e2e_ends_with_position_edge() {
        let r = global_eval("'hello world'.endsWith('hello', 5)").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `repeat(0)` returns empty string.
    #[test]
    fn e2e_repeat_zero_edge() {
        let r = global_eval("'abc'.repeat(0)").unwrap();
        assert_eq!(r, JsValue::String("".into()));
    }

    /// `repeat(-1)` throws RangeError.
    #[test]
    fn e2e_repeat_negative_throws_edge() {
        let r = global_eval("try { 'x'.repeat(-1); 'ok' } catch(e) { 'error' }");
        assert_eq!(r.unwrap(), JsValue::String("error".into()));
    }

    /// `repeat(Infinity)` throws RangeError.
    #[test]
    fn e2e_repeat_infinity_throws_edge() {
        let r = global_eval("try { 'x'.repeat(Infinity); 'ok' } catch(e) { 'error' }");
        assert_eq!(r.unwrap(), JsValue::String("error".into()));
    }

    /// `charAt` out-of-range returns empty string.
    #[test]
    fn e2e_char_at_out_of_range_edge() {
        let r = global_eval("'abc'.charAt(10)").unwrap();
        assert_eq!(r, JsValue::String("".into()));
    }

    /// `charAt` negative index returns empty string.
    #[test]
    fn e2e_char_at_negative_edge() {
        let r = global_eval("'abc'.charAt(-1)").unwrap();
        assert_eq!(r, JsValue::String("".into()));
    }

    /// `charCodeAt` out-of-range returns NaN.
    #[test]
    fn e2e_char_code_at_out_of_range_edge() {
        let r = global_eval("isNaN('abc'.charCodeAt(10))").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `charCodeAt` negative index returns NaN.
    #[test]
    fn e2e_char_code_at_negative_edge() {
        let r = global_eval("isNaN('abc'.charCodeAt(-1))").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `codePointAt` out-of-range returns undefined.
    #[test]
    fn e2e_code_point_at_out_of_range_edge() {
        let r = global_eval("'abc'.codePointAt(10)").unwrap();
        assert_eq!(r, JsValue::Undefined);
    }

    /// `codePointAt` negative index returns undefined.
    #[test]
    fn e2e_code_point_at_negative_edge() {
        let r = global_eval("'abc'.codePointAt(-1)").unwrap();
        assert_eq!(r, JsValue::Undefined);
    }

    /// `normalize()` with default (NFC) composes.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_normalize_default_nfc_edge() {
        let r = global_eval("'caf\\u0065\\u0301'.normalize()").unwrap();
        assert_eq!(r, JsValue::String("caf\u{e9}".into()));
    }

    /// `normalize('NFD')` decomposes.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_normalize_nfd_edge() {
        let r = global_eval("'caf\\u00e9'.normalize('NFD').length").unwrap();
        // é decomposes to e + combining acute = 5 code units
        assert_eq!(r, JsValue::Smi(5));
    }

    /// `normalize` with invalid form throws RangeError.
    #[test]
    fn e2e_normalize_invalid_form_edge() {
        let r = global_eval("try { 'a'.normalize('XYZ'); 'ok' } catch(e) { 'error' }");
        assert_eq!(r.unwrap(), JsValue::String("error".into()));
    }

    /// `String.raw` interleaves substitutions.
    #[test]
    fn e2e_string_raw_with_subs_edge() {
        let r = global_eval("String.raw({ raw: ['a', 'b', 'c'] }, 1, 2)").unwrap();
        assert_eq!(r, JsValue::String("a1b2c".into()));
    }

    /// `includes` with position parameter.
    #[test]
    fn e2e_includes_with_position_edge() {
        let r = global_eval("'hello'.includes('hel', 1)").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `replace` where search is not found returns original.
    #[test]
    fn e2e_replace_not_found_edge() {
        let r = global_eval("'hello'.replace('xyz', 'Z')").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    /// `substring` both args same returns empty string.
    #[test]
    fn e2e_substring_same_args_edge() {
        let r = global_eval("'hello'.substring(2, 2)").unwrap();
        assert_eq!(r, JsValue::String("".into()));
    }

    // ── Proxy & Reflect e2e tests ─────────────────────────────────────────────

    /// Proxy get trap intercepts property read.
    #[test]
    fn e2e_proxy_get_trap() {
        let r = global_eval(
            r#"
            var target = { x: 1 };
            var handler = { get: function(t, k) { return 42; } };
            var p = new Proxy(target, handler);
            p.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Proxy get falls through without trap.
    #[test]
    fn e2e_proxy_get_no_trap() {
        let r = global_eval(
            r#"
            var target = { x: 10 };
            var p = new Proxy(target, {});
            p.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(10));
    }

    /// Proxy set trap intercepts property assignment.
    #[test]
    fn e2e_proxy_set_trap() {
        let r = global_eval(
            r#"
            var log = [];
            var target = {};
            var handler = { set: function(t, k, v) { log.push(k); return true; } };
            var p = new Proxy(target, handler);
            p.y = 5;
            log.length;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// Proxy has trap intercepts `in` operator.
    #[test]
    fn e2e_proxy_has_trap() {
        let r = global_eval(
            r#"
            var handler = { has: function(t, k) { return true; } };
            var p = new Proxy({}, handler);
            "anything" in p;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Proxy deleteProperty trap intercepts `delete` operator.
    #[test]
    fn e2e_proxy_delete_trap() {
        let r = global_eval(
            r#"
            var deleted = false;
            var handler = { deleteProperty: function(t, k) { deleted = true; return true; } };
            var p = new Proxy({ a: 1 }, handler);
            delete p.a;
            deleted;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Proxy ownKeys trap intercepts Object.keys.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_own_keys_trap() {
        let r = global_eval(
            r#"
            var handler = { ownKeys: function(t) { return ["x", "y"]; } };
            var p = new Proxy({}, handler);
            Reflect.ownKeys(p);
            "#,
        );
        // ownKeys on a proxy — result should be an array
        assert!(r.is_ok());
    }

    /// Proxy apply trap intercepts function calls.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_apply_trap() {
        let r = global_eval(
            r#"
            var handler = { apply: function(target, thisArg, args) { return args[0] + 10; } };
            var p = new Proxy(function(){}, handler);
            p(5);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(15));
    }

    /// Proxy construct trap intercepts `new` operator.
    #[test]
    fn e2e_proxy_construct_trap() {
        let r = global_eval(
            r#"
            var handler = { construct: function(target, args) { return { val: args[0] * 2 }; } };
            var p = new Proxy(function(){}, handler);
            var obj = new p(3);
            obj.val;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(6));
    }

    /// Proxy.revocable returns object with proxy and revoke.
    #[test]
    fn e2e_proxy_revocable_basic() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({ x: 1 }, {});
            rev.proxy.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// Proxy.revocable: revoke makes proxy throw on access.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_revocable_revoke() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({ x: 1 }, {});
            rev.revoke();
            try { rev.proxy.x; } catch(e) { "revoked"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("revoked".into()));
    }

    /// Proxy getOwnPropertyDescriptor trap.
    #[test]
    fn e2e_proxy_get_own_property_descriptor_trap() {
        let r = global_eval(
            r#"
            var handler = {
                getOwnPropertyDescriptor: function(t, k) {
                    return { value: 99, writable: true, enumerable: true, configurable: true };
                }
            };
            var p = new Proxy({}, handler);
            var desc = Object.getOwnPropertyDescriptor(p, "anything");
            desc.value;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    /// Proxy defineProperty trap.
    #[test]
    fn e2e_proxy_define_property_trap() {
        let r = global_eval(
            r#"
            var trapped = false;
            var handler = { defineProperty: function(t, k, v) { trapped = true; return true; } };
            var p = new Proxy({}, handler);
            Reflect.defineProperty(p, "a", { value: 1 });
            trapped;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.get reads from an object.
    #[test]
    fn e2e_reflect_get() {
        let r = global_eval(
            r#"
            var obj = { a: 42 };
            Reflect.get(obj, "a");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Reflect.set writes to an object and returns true.
    #[test]
    fn e2e_reflect_set() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.set(obj, "b", 7);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.has checks property existence.
    #[test]
    fn e2e_reflect_has() {
        let r = global_eval(
            r#"
            var obj = { c: 1 };
            Reflect.has(obj, "c");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.has returns false for missing property.
    #[test]
    fn e2e_reflect_has_missing() {
        let r = global_eval(
            r#"
            Reflect.has({}, "missing");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Reflect.deleteProperty removes a property.
    #[test]
    fn e2e_reflect_delete_property() {
        let r = global_eval(
            r#"
            var obj = { d: 1 };
            Reflect.deleteProperty(obj, "d");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.ownKeys returns own property keys.
    #[test]
    fn e2e_reflect_own_keys() {
        let r = global_eval(
            r#"
            var obj = { x: 1, y: 2 };
            Reflect.ownKeys(obj).length;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// Reflect.isExtensible returns true for normal objects.
    #[test]
    fn e2e_reflect_is_extensible() {
        let r = global_eval(
            r#"
            Reflect.isExtensible({});
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.preventExtensions returns true and makes object non-extensible.
    #[test]
    fn e2e_reflect_prevent_extensions() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.preventExtensions(obj);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.getPrototypeOf returns `Object.prototype` for plain objects.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_get_prototype_of() {
        let r = global_eval("Reflect.getPrototypeOf({}) === Object.prototype").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.apply calls a function with arguments.
    #[test]
    fn e2e_reflect_apply() {
        let r = global_eval(
            r#"
            Reflect.apply(Math.floor, undefined, [4.7]);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(4));
    }

    /// Reflect.defineProperty creates a property with a descriptor.
    #[test]
    fn e2e_reflect_define_property() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", { value: 42, writable: true, enumerable: true, configurable: true });
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.getOwnPropertyDescriptor returns descriptor.
    #[test]
    fn e2e_reflect_get_own_property_descriptor() {
        let r = global_eval(
            r#"
            var obj = { z: 100 };
            var desc = Reflect.getOwnPropertyDescriptor(obj, "z");
            desc.value;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(100));
    }

    /// Reflect.getOwnPropertyDescriptor returns undefined for missing key.
    #[test]
    fn e2e_reflect_get_own_property_descriptor_missing() {
        let r = global_eval(
            r#"
            Reflect.getOwnPropertyDescriptor({}, "nope");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Undefined);
    }

    #[test]
    fn e2e_reflect_apply_js_function_this_binding() {
        let r = global_eval(
            r#"
            function f(a, b) { return this.base + a + b; }
            Reflect.apply(f, { base: 10 }, [1, 2]);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(13));
    }

    #[test]
    fn e2e_reflect_apply_builtin_function_object() {
        let r = global_eval("Reflect.apply(Math.max, undefined, [1, 7, 3])").unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    #[test]
    fn e2e_reflect_apply_array_like_arguments() {
        let r = global_eval(
            r#"
            function f(a, b) { return a + b; }
            Reflect.apply(f, undefined, { 0: 4, 1: 5, length: 2 });
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(9));
    }

    #[test]
    fn e2e_reflect_apply_non_callable_throws() {
        let r =
            global_eval(r#"try { Reflect.apply(1, undefined, []); "no"; } catch (e) { "ok"; }"#)
                .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    #[test]
    fn e2e_reflect_construct_js_function() {
        let r = global_eval(
            r#"
            function Point(x, y) { this.x = x; this.y = y; }
            var point = Reflect.construct(Point, [2, 3]);
            point.x === 2 && point.y === 3;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_construct_uses_new_target_prototype() {
        let r = global_eval(
            r#"
            function Point(x) { this.x = x; }
            function Alt() {}
            var point = Reflect.construct(Point, [5], Alt);
            Object.getPrototypeOf(point) === Alt.prototype && point.x === 5;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_construct_returns_this_for_primitive_result() {
        let r = global_eval(
            r#"
            function Box(v) { this.value = v; return 1; }
            Reflect.construct(Box, [9]).value;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(9));
    }

    #[test]
    fn e2e_reflect_construct_preserves_object_result() {
        let r = global_eval(
            r#"
            function Box(v) { return { value: v }; }
            Reflect.construct(Box, [9]).value;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(9));
    }

    #[test]
    fn e2e_reflect_construct_builtin_constructor() {
        let r = global_eval(
            r#"
            var obj = Reflect.construct(Object, []);
            typeof obj;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("object".into()));
    }

    #[test]
    fn e2e_reflect_construct_non_constructor_throws() {
        let r =
            global_eval(r#"try { Reflect.construct(1, []); "no"; } catch (e) { "ok"; }"#).unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    #[test]
    fn e2e_reflect_define_property_returns_false_for_non_extensible() {
        let r = global_eval(
            r#"
            var obj = Object.preventExtensions({});
            Reflect.defineProperty(obj, "x", { value: 1 });
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_reflect_define_property_accessor_getter() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", {
                get: function () { return 42; },
                configurable: true
            });
            obj.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    #[test]
    fn e2e_reflect_define_property_accessor_setter() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", {
                set: function (v) { this.y = v; },
                configurable: true
            });
            obj.x = 11;
            obj.y;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(11));
    }

    #[test]
    fn e2e_reflect_delete_property_non_configurable_false() {
        let r = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", { value: 1, configurable: false });
            Reflect.deleteProperty(obj, "x");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_reflect_delete_property_missing_true() {
        let r = global_eval(r#"Reflect.deleteProperty({}, "missing")"#).unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_get_inherited_property() {
        let r = global_eval(
            r#"
            var proto = { x: 7 };
            var obj = Object.create(proto);
            Reflect.get(obj, "x");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    #[test]
    fn e2e_reflect_get_uses_receiver_for_getter() {
        let r = global_eval(
            r#"
            var proto = {};
            Object.defineProperty(proto, "x", {
                get: function () { return this.value; },
                configurable: true
            });
            var receiver = { value: 33 };
            Reflect.get(proto, "x", receiver);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(33));
    }

    #[test]
    fn e2e_reflect_get_symbol_key() {
        let r = global_eval(
            r#"
            var s = Symbol("x");
            var obj = {};
            obj[s] = 9;
            Reflect.get(obj, s);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(9));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_set_uses_receiver_for_inherited_data_property() {
        let r = global_eval(
            r#"
            var proto = {};
            Object.defineProperty(proto, "x", {
                value: 1,
                writable: true,
                configurable: true
            });
            var target = Object.create(proto);
            var receiver = {};
            Reflect.set(target, "x", 4, receiver) &&
                receiver.x === 4 &&
                proto.x === 1 &&
                target.x === 1;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_set_getter_only_returns_false() {
        let r = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", {
                get: function () { return 1; },
                configurable: true
            });
            Reflect.set(obj, "x", 2);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_reflect_set_receiver_used_for_setter() {
        let r = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", {
                set: function (v) { this.y = v; },
                configurable: true
            });
            var receiver = {};
            Reflect.set(obj, "x", 12, receiver) && receiver.y === 12;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_get_prototype_of_object_prototype() {
        let r = global_eval("Reflect.getPrototypeOf({}) === Object.prototype").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_get_prototype_of_null_prototype_object() {
        let r = global_eval("Reflect.getPrototypeOf(Object.create(null)) === null").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_set_prototype_of_updates_chain() {
        let r = global_eval(
            r#"
            var proto = { x: 1 };
            var obj = {};
            Reflect.setPrototypeOf(obj, proto) &&
                Reflect.getPrototypeOf(obj) === proto &&
                obj.x === 1;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_set_prototype_of_non_extensible_returns_false() {
        let r = global_eval(
            r#"
            var obj = Object.preventExtensions({});
            Reflect.setPrototypeOf(obj, { x: 1 });
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_reflect_has_inherited_and_symbol_properties() {
        let r = global_eval(
            r#"
            var s = Symbol("x");
            var proto = {};
            proto[s] = 1;
            var obj = Object.create(proto);
            Reflect.has(obj, s);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_prevent_extensions_changes_is_extensible() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.preventExtensions(obj);
            Reflect.isExtensible(obj);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_reflect_own_keys_includes_non_enumerable_and_symbol_keys() {
        let r = global_eval(
            r#"
            var s = Symbol("x");
            var obj = {};
            Object.defineProperty(obj, "hidden", { value: 1, enumerable: false, configurable: true });
            obj[s] = 2;
            var keys = Reflect.ownKeys(obj);
            keys.length === 2 && keys[0] === "hidden" && keys[1] === s;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_own_keys_collapses_accessor_storage() {
        let r = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", {
                get: function () { return 1; },
                configurable: true
            });
            var keys = Reflect.ownKeys(obj);
            keys.length === 1 && keys[0] === "x";
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Proxy get invariant: non-configurable non-writable property must return correct value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_get_invariant() {
        let r = global_eval(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
            var handler = { get: function(t, k) { return 2; } };
            var p = new Proxy(target, handler);
            try { p.x; } catch(e) { "invariant"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("invariant".into()));
    }

    /// Proxy set no-trap falls through and returns value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_set_no_trap_read_back() {
        let r = global_eval(
            r#"
            var target = {};
            var p = new Proxy(target, {});
            p.a = 99;
            p.a;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    /// Revoked proxy throws on set.
    #[test]
    fn e2e_proxy_revoked_set_throws() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({}, {});
            rev.revoke();
            try { rev.proxy.x = 1; } catch(e) { "revoked_set"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("revoked_set".into()));
    }

    /// Revoked proxy throws on `in` operator.
    #[test]
    fn e2e_proxy_revoked_has_throws() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({}, {});
            rev.revoke();
            try { "x" in rev.proxy; } catch(e) { "revoked_has"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("revoked_has".into()));
    }

    /// Multiple revoke calls are idempotent.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_revoke_idempotent() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({}, {});
            rev.revoke();
            rev.revoke();
            try { rev.proxy.x; } catch(e) { "still_revoked"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("still_revoked".into()));
    }

    #[test]
    fn e2e_proxy_get_trap_receives_receiver() {
        let r = global_eval(
            r#"
            var proxy = new Proxy({}, {
                get: function (target, key, receiver) { return receiver.value; }
            });
            Reflect.get(proxy, "x", { value: 41 });
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(41));
    }

    #[test]
    fn e2e_proxy_get_null_handler_falls_through() {
        let r = global_eval(
            r#"
            var target = { x: 9 };
            var proxy = new Proxy(target, null);
            proxy.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(9));
    }

    #[test]
    fn e2e_proxy_set_trap_receives_receiver() {
        let r = global_eval(
            r#"
            var seen = 0;
            var proxy = new Proxy({}, {
                set: function (target, key, value, receiver) {
                    seen = receiver.marker + value;
                    return true;
                }
            });
            Reflect.set(proxy, "x", 5, { marker: 7 });
            seen;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(12));
    }

    #[test]
    fn e2e_proxy_set_trap_false_returns_false() {
        let r = global_eval(
            r#"
            Reflect.set(new Proxy({}, { set: function () { return false; } }), "x", 1);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_set_trap_false_strict_assignment_throws() {
        let r = global_eval(
            r#"
            "use strict";
            var proxy = new Proxy({}, { set: function () { return false; } });
            try { proxy.x = 1; "no"; } catch (e) { "strict"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("strict".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_set_null_handler_falls_through() {
        let r = global_eval(
            r#"
            var proxy = new Proxy({}, null);
            Reflect.set(proxy, "x", 7);
            proxy.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    #[test]
    fn e2e_proxy_has_trap_controls_in_operator() {
        let r = global_eval(
            r#"
            var proxy = new Proxy({}, { has: function (target, key) { return key === "x"; } });
            ("x" in proxy) && !("y" in proxy);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_proxy_has_null_handler_falls_through() {
        let r = global_eval(
            r#"
            var proxy = new Proxy({ x: 1 }, null);
            "x" in proxy;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_proxy_has_invariant_non_extensible_target_throws() {
        let r = global_eval(
            r#"
            var target = Object.preventExtensions({ x: 1 });
            var proxy = new Proxy(target, { has: function () { return false; } });
            try { "x" in proxy; "no"; } catch (e) { "invariant"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("invariant".into()));
    }

    #[test]
    fn e2e_proxy_delete_property_false_returns_false() {
        let r = global_eval(
            r#"
            Reflect.deleteProperty(new Proxy({ x: 1 }, {
                deleteProperty: function () { return false; }
            }), "x");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_delete_property_false_strict_delete_throws() {
        let r = global_eval(
            r#"
            "use strict";
            var proxy = new Proxy({ x: 1 }, { deleteProperty: function () { return false; } });
            try { delete proxy.x; "no"; } catch (e) { "strict"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("strict".into()));
    }

    #[test]
    fn e2e_proxy_delete_property_null_handler_falls_through() {
        let r = global_eval(
            r#"
            var proxy = new Proxy({ x: 1 }, null);
            Reflect.deleteProperty(proxy, "x");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_proxy_apply_trap_receives_this_and_args() {
        let r = global_eval(
            r#"
            var proxy = new Proxy(function () {}, {
                apply: function (target, thisArg, args) { return thisArg.base + args[0] + args[1]; }
            });
            Reflect.apply(proxy, { base: 10 }, [2, 3]);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(15));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_apply_null_handler_falls_through() {
        let r = global_eval(
            r#"
            var proxy = new Proxy(function (x) { return x + 1; }, null);
            proxy(5);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(6));
    }

    #[test]
    fn e2e_proxy_revoked_apply_throws() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable(function (x) { return x; }, null);
            rev.revoke();
            try { rev.proxy(1); "no"; } catch (e) { "revoked_apply"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("revoked_apply".into()));
    }

    #[test]
    fn e2e_proxy_construct_null_handler_falls_through() {
        let r = global_eval(
            r#"
            function Point(x) { this.x = x; }
            var ProxyPoint = new Proxy(Point, null);
            new ProxyPoint(4).x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(4));
    }

    #[test]
    fn e2e_proxy_revoked_construct_throws() {
        let r = global_eval(
            r#"
            function Point(x) { this.x = x; }
            var rev = Proxy.revocable(Point, null);
            rev.revoke();
            try { new rev.proxy(1); "no"; } catch (e) { "revoked_construct"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("revoked_construct".into()));
    }

    #[test]
    fn e2e_proxy_get_own_property_descriptor_reflect_uses_trap() {
        let r = global_eval(
            r#"
            var proxy = new Proxy({}, {
                getOwnPropertyDescriptor: function () {
                    return { value: 12, writable: true, enumerable: false, configurable: true };
                }
            });
            Reflect.getOwnPropertyDescriptor(proxy, "x").value;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(12));
    }

    #[test]
    fn e2e_proxy_get_own_property_descriptor_incompatible_non_configurable_throws() {
        let r = global_eval(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, configurable: false });
            var proxy = new Proxy(target, {
                getOwnPropertyDescriptor: function () {
                    return { value: 1, configurable: true };
                }
            });
            try { Object.getOwnPropertyDescriptor(proxy, "x"); "no"; } catch (e) { "descriptor"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("descriptor".into()));
    }

    #[test]
    fn e2e_proxy_get_own_property_descriptor_new_property_on_non_extensible_target_throws() {
        let r = global_eval(
            r#"
            var target = Object.preventExtensions({});
            var proxy = new Proxy(target, {
                getOwnPropertyDescriptor: function () {
                    return { value: 1, configurable: true };
                }
            });
            try { Reflect.getOwnPropertyDescriptor(proxy, "x"); "no"; } catch (e) { "descriptor"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("descriptor".into()));
    }

    #[test]
    fn e2e_proxy_get_own_property_descriptor_null_handler_falls_through() {
        let r = global_eval(
            r#"
            var target = { x: 3 };
            Object.getOwnPropertyDescriptor(new Proxy(target, null), "x").value;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_own_keys_trap_allows_strings_and_symbols() {
        let r = global_eval(
            r#"
            var sym = Symbol("x");
            var keys = Reflect.ownKeys(new Proxy({}, {
                ownKeys: function () { return ["a", sym]; }
            }));
            keys.length === 2 && keys[0] === "a" && keys[1] === sym;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_proxy_own_keys_invalid_element_throws() {
        let r = global_eval(
            r#"
            try {
                Reflect.ownKeys(new Proxy({}, { ownKeys: function () { return [1]; } }));
                "no";
            } catch (e) { "type"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("type".into()));
    }

    #[test]
    fn e2e_proxy_own_keys_null_handler_falls_through() {
        let r = global_eval(
            r#"
            Reflect.ownKeys(new Proxy({ x: 1, y: 2 }, null)).length;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    #[test]
    fn e2e_proxy_own_keys_non_extensible_missing_key_throws() {
        let r = global_eval(
            r#"
            var target = Object.preventExtensions({ x: 1 });
            var proxy = new Proxy(target, { ownKeys: function () { return []; } });
            try { Reflect.ownKeys(proxy); "no"; } catch (e) { "ownKeys"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("ownKeys".into()));
    }

    #[test]
    fn e2e_proxy_revoked_delete_throws() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({ x: 1 }, null);
            rev.revoke();
            try { Reflect.deleteProperty(rev.proxy, "x"); "no"; } catch (e) { "revoked_delete"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("revoked_delete".into()));
    }

    #[test]
    fn e2e_proxy_revoked_descriptor_throws() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({ x: 1 }, null);
            rev.revoke();
            try { Reflect.getOwnPropertyDescriptor(rev.proxy, "x"); "no"; } catch (e) { "revoked_descriptor"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("revoked_descriptor".into()));
    }

    #[test]
    fn e2e_proxy_revoked_own_keys_throws() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({ x: 1 }, null);
            rev.revoke();
            try { Reflect.ownKeys(rev.proxy); "no"; } catch (e) { "revoked_keys"; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("revoked_keys".into()));
    }

    // ── Proxy invariant e2e tests ─────────────────────────────────────────────

    #[test]
    fn e2e_proxy_invariant_get_allows_virtual_value_for_configurable_property() {
        assert_eval_true(
            r#"
            var target = { x: 1 };
            var proxy = new Proxy(target, { get: function () { return 2; } });
            proxy.x === 2;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_allows_matching_value_for_frozen_data_property() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
            var proxy = new Proxy(target, { get: function () { return 1; } });
            proxy.x === 1;
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_invariant_get_throws_for_mismatched_frozen_data_property() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
            var proxy = new Proxy(target, { get: function () { return 2; } });
            try { proxy.x; false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_allows_virtual_value_for_missing_property() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { get: function () { return 7; } });
            proxy.x === 7;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_set_allows_writable_property_change() {
        assert_eval_true(
            r#"
            var target = { x: 1 };
            var proxy = new Proxy(target, {
                set: function (t, key, value) { t[key] = value; return true; }
            });
            Reflect.set(proxy, "x", 2) && target.x === 2;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_set_allows_same_value_for_frozen_data_property() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
            var proxy = new Proxy(target, { set: function () { return true; } });
            Reflect.set(proxy, "x", 1) === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_set_throws_for_mismatched_frozen_data_property() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
            var proxy = new Proxy(target, { set: function () { return true; } });
            try { Reflect.set(proxy, "x", 2); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_set_allows_new_property_on_extensible_target() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { set: function () { return true; } });
            Reflect.set(proxy, "x", 1) === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_has_allows_false_for_missing_property() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { has: function () { return false; } });
            !Reflect.has(proxy, "x");
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_has_throws_for_non_configurable_property() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, configurable: false });
            var proxy = new Proxy(target, { has: function () { return false; } });
            try { Reflect.has(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_has_throws_for_non_extensible_existing_property() {
        assert_eval_true(
            r#"
            var target = Object.preventExtensions({ x: 1 });
            var proxy = new Proxy(target, { has: function () { return false; } });
            try { Reflect.has(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_has_allows_true_for_non_configurable_property() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, configurable: false });
            var proxy = new Proxy(target, { has: function () { return true; } });
            Reflect.has(proxy, "x");
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_has_allows_true_for_non_extensible_existing_property() {
        assert_eval_true(
            r#"
            var target = Object.preventExtensions({ x: 1 });
            var proxy = new Proxy(target, { has: function () { return true; } });
            Reflect.has(proxy, "x");
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_delete_property_allows_configurable_property() {
        assert_eval_true(
            r#"
            var target = { x: 1 };
            var proxy = new Proxy(target, { deleteProperty: function () { return true; } });
            Reflect.deleteProperty(proxy, "x") === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_delete_property_throws_for_non_configurable_property() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, configurable: false });
            var proxy = new Proxy(target, { deleteProperty: function () { return true; } });
            try { Reflect.deleteProperty(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_delete_property_false_is_allowed() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({ x: 1 }, { deleteProperty: function () { return false; } });
            Reflect.deleteProperty(proxy, "x") === false;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_delete_property_allows_missing_property_success() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { deleteProperty: function () { return true; } });
            Reflect.deleteProperty(proxy, "x") === true;
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_invariant_own_keys_allows_extra_keys_on_extensible_target() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "fixed", { value: 1, configurable: false });
            var proxy = new Proxy(target, {
                ownKeys: function () { return ["fixed", "extra"]; }
            });
            Reflect.ownKeys(proxy).join(",") === "fixed,extra";
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_own_keys_throws_when_omitting_non_configurable_key() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "fixed", { value: 1, configurable: false });
            var proxy = new Proxy(target, { ownKeys: function () { return []; } });
            try { Reflect.ownKeys(proxy); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_invariant_own_keys_allows_omitting_configurable_key_on_extensible_target() {
        assert_eval_true(
            r#"
            var target = { x: 1, y: 2 };
            var proxy = new Proxy(target, { ownKeys: function () { return ["x"]; } });
            Reflect.ownKeys(proxy).join(",") === "x";
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_own_keys_throws_when_non_extensible_target_omits_key() {
        assert_eval_true(
            r#"
            var target = Object.preventExtensions({ x: 1, y: 2 });
            var proxy = new Proxy(target, { ownKeys: function () { return ["x"]; } });
            try { Reflect.ownKeys(proxy); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_own_keys_throws_when_non_extensible_target_adds_key() {
        assert_eval_true(
            r#"
            var target = Object.preventExtensions({ x: 1 });
            var proxy = new Proxy(target, { ownKeys: function () { return ["x", "y"]; } });
            try { Reflect.ownKeys(proxy); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_own_keys_throws_for_duplicate_key() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { ownKeys: function () { return ["x", "x"]; } });
            try { Reflect.ownKeys(proxy); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_own_property_descriptor_allows_virtual_property_on_extensible_target()
     {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, {
                getOwnPropertyDescriptor: function () {
                    return { value: 1, writable: true, enumerable: true, configurable: true };
                }
            });
            Reflect.getOwnPropertyDescriptor(proxy, "x").value === 1;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_own_property_descriptor_throws_when_hiding_non_configurable_property()
     {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, configurable: false });
            var proxy = new Proxy(target, { getOwnPropertyDescriptor: function () { return undefined; } });
            try { Reflect.getOwnPropertyDescriptor(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_own_property_descriptor_throws_when_hiding_property_on_non_extensible_target()
     {
        assert_eval_true(
            r#"
            var target = Object.preventExtensions({ x: 1 });
            var proxy = new Proxy(target, { getOwnPropertyDescriptor: function () { return undefined; } });
            try { Reflect.getOwnPropertyDescriptor(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_own_property_descriptor_throws_for_configurable_non_configurable_mismatch()
     {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, configurable: false });
            var proxy = new Proxy(target, {
                getOwnPropertyDescriptor: function () {
                    return { value: 1, configurable: true };
                }
            });
            try { Reflect.getOwnPropertyDescriptor(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_own_property_descriptor_throws_for_enumerable_non_configurable_mismatch()
     {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, enumerable: false, configurable: false });
            var proxy = new Proxy(target, {
                getOwnPropertyDescriptor: function () {
                    return { value: 1, enumerable: true, configurable: false };
                }
            });
            try { Reflect.getOwnPropertyDescriptor(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_own_property_descriptor_throws_for_value_non_configurable_non_writable_mismatch()
     {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
            var proxy = new Proxy(target, {
                getOwnPropertyDescriptor: function () {
                    return { value: 2, writable: false, configurable: false };
                }
            });
            try { Reflect.getOwnPropertyDescriptor(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_own_property_descriptor_throws_for_new_property_on_non_extensible_target()
     {
        assert_eval_true(
            r#"
            var target = Object.preventExtensions({});
            var proxy = new Proxy(target, {
                getOwnPropertyDescriptor: function () {
                    return { value: 1, configurable: true };
                }
            });
            try { Reflect.getOwnPropertyDescriptor(proxy, "x"); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_own_property_descriptor_allows_matching_frozen_descriptor() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, enumerable: false, configurable: false });
            var proxy = new Proxy(target, {
                getOwnPropertyDescriptor: function () {
                    return { value: 1, writable: false, enumerable: false, configurable: false };
                }
            });
            var desc = Reflect.getOwnPropertyDescriptor(proxy, "x");
            desc.value === 1 && desc.writable === false && desc.enumerable === false && desc.configurable === false;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_define_property_allows_new_property_on_extensible_target() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { defineProperty: function () { return true; } });
            Reflect.defineProperty(proxy, "x", { value: 1 }) === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_define_property_throws_for_new_property_on_non_extensible_target() {
        assert_eval_true(
            r#"
            var target = Object.preventExtensions({});
            var proxy = new Proxy(target, { defineProperty: function () { return true; } });
            try { Reflect.defineProperty(proxy, "x", { value: 1 }); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_define_property_throws_for_configurable_non_configurable_mismatch() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, configurable: false });
            var proxy = new Proxy(target, { defineProperty: function () { return true; } });
            try { Reflect.defineProperty(proxy, "x", { value: 1, configurable: true }); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_define_property_throws_for_enumerable_non_configurable_mismatch() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, enumerable: false, configurable: false });
            var proxy = new Proxy(target, { defineProperty: function () { return true; } });
            try { Reflect.defineProperty(proxy, "x", { value: 1, enumerable: true }); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_define_property_throws_for_value_non_configurable_non_writable_mismatch()
    {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
            var proxy = new Proxy(target, { defineProperty: function () { return true; } });
            try { Reflect.defineProperty(proxy, "x", { value: 2 }); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_define_property_allows_matching_frozen_descriptor() {
        assert_eval_true(
            r#"
            var target = {};
            Object.defineProperty(target, "x", { value: 1, writable: false, configurable: false });
            var proxy = new Proxy(target, { defineProperty: function () { return true; } });
            Reflect.defineProperty(proxy, "x", { value: 1 }) === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_prevent_extensions_allows_true_when_target_becomes_non_extensible() {
        assert_eval_true(
            r#"
            var target = {};
            var proxy = new Proxy(target, {
                preventExtensions: function (t) {
                    Object.preventExtensions(t);
                    return true;
                }
            });
            Reflect.preventExtensions(proxy) && Reflect.isExtensible(target) === false;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_prevent_extensions_throws_when_target_stays_extensible() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { preventExtensions: function () { return true; } });
            try { Reflect.preventExtensions(proxy); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_prevent_extensions_allows_false_without_freezing_target() {
        assert_eval_true(
            r#"
            var target = {};
            var proxy = new Proxy(target, { preventExtensions: function () { return false; } });
            Reflect.preventExtensions(proxy) === false && Reflect.isExtensible(target) === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_is_extensible_allows_true_when_target_is_extensible() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { isExtensible: function () { return true; } });
            Reflect.isExtensible(proxy) === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_is_extensible_throws_when_trap_disagrees_with_extensible_target() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { isExtensible: function () { return false; } });
            try { Reflect.isExtensible(proxy); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_is_extensible_allows_false_when_target_is_not_extensible() {
        assert_eval_true(
            r#"
            var target = Object.preventExtensions({});
            var proxy = new Proxy(target, { isExtensible: function () { return false; } });
            Reflect.isExtensible(proxy) === false;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_prototype_of_allows_alternate_prototype_for_extensible_target() {
        assert_eval_true(
            r#"
            var proto = { tag: 1 };
            var proxy = new Proxy({}, { getPrototypeOf: function () { return proto; } });
            Reflect.getPrototypeOf(proxy) === proto;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_prototype_of_throws_for_non_object_non_null_result() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { getPrototypeOf: function () { return 1; } });
            try { Reflect.getPrototypeOf(proxy); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_prototype_of_throws_for_non_extensible_target_mismatch() {
        assert_eval_true(
            r#"
            var proto = { tag: 1 };
            var other = { tag: 2 };
            var target = Object.preventExtensions(Object.create(proto));
            var proxy = new Proxy(target, { getPrototypeOf: function () { return other; } });
            try { Reflect.getPrototypeOf(proxy); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_get_prototype_of_allows_matching_result_for_non_extensible_target() {
        assert_eval_true(
            r#"
            var proto = { tag: 1 };
            var target = Object.preventExtensions(Object.create(proto));
            var proxy = new Proxy(target, { getPrototypeOf: function () { return proto; } });
            Reflect.getPrototypeOf(proxy) === proto;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_set_prototype_of_allows_true_for_extensible_target() {
        assert_eval_true(
            r#"
            var target = {};
            var next = {};
            var proxy = new Proxy(target, { setPrototypeOf: function () { return true; } });
            Reflect.setPrototypeOf(proxy, next) === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_set_prototype_of_throws_for_non_extensible_target_mismatch() {
        assert_eval_true(
            r#"
            var proto = {};
            var next = {};
            var target = Object.preventExtensions(Object.create(proto));
            var proxy = new Proxy(target, { setPrototypeOf: function () { return true; } });
            try { Reflect.setPrototypeOf(proxy, next); false; } catch (e) { true; }
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_set_prototype_of_allows_matching_result_for_non_extensible_target() {
        assert_eval_true(
            r#"
            var proto = {};
            var target = Object.preventExtensions(Object.create(proto));
            var proxy = new Proxy(target, { setPrototypeOf: function () { return true; } });
            Reflect.setPrototypeOf(proxy, proto) === true;
            "#,
        );
    }

    #[test]
    fn e2e_proxy_invariant_set_prototype_of_allows_false_result() {
        assert_eval_true(
            r#"
            var proxy = new Proxy({}, { setPrototypeOf: function () { return false; } });
            Reflect.setPrototypeOf(proxy, {}) === false;
            "#,
        );
    }

    // ── Proxy/Reflect receiver & ownKeys conformance ──────────────────────────

    #[test]
    fn e2e_reflect_get_basic() {
        let r = global_eval(r#"Reflect.get({ x: 42 }, 'x')"#).unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    #[test]
    fn e2e_reflect_get_missing_returns_undefined() {
        let r = global_eval(r#"Reflect.get({}, 'x')"#).unwrap();
        assert_eq!(r, JsValue::Undefined);
    }

    #[test]
    fn e2e_reflect_set_basic() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.set(obj, 'x', 10);
            obj.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(10));
    }

    #[test]
    fn e2e_reflect_has_own() {
        let r = global_eval(r#"Reflect.has({ a: 1 }, 'a')"#).unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_has_missing_v2() {
        let r = global_eval(r#"Reflect.has({}, 'z')"#).unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_reflect_delete_property_v2() {
        let r = global_eval(
            r#"
            var obj = { a: 1 };
            var ok = Reflect.deleteProperty(obj, 'a');
            ok && obj.a === undefined;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_own_keys_integer_ordering() {
        let r = global_eval(
            r#"
            var obj = {};
            obj['c'] = 1;
            obj['2'] = 1;
            obj['b'] = 1;
            obj['0'] = 1;
            obj['1'] = 1;
            var keys = Reflect.ownKeys(obj);
            keys[0] + ',' + keys[1] + ',' + keys[2] + ',' + keys[3] + ',' + keys[4];
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0,1,2,c,b".into()));
    }

    #[test]
    fn e2e_reflect_own_keys_strings_only() {
        let r = global_eval(
            r#"
            var obj = { z: 1, a: 2, m: 3 };
            Reflect.ownKeys(obj).join(',');
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("z,a,m".into()));
    }

    #[test]
    fn e2e_reflect_is_extensible_true() {
        let r = global_eval(r#"Reflect.isExtensible({})"#).unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_prevent_extensions_v2() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.preventExtensions(obj);
            Reflect.isExtensible(obj);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    #[test]
    fn e2e_reflect_define_property_v2() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, 'x', { value: 99 });
            obj.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    #[test]
    fn e2e_reflect_get_own_property_descriptor_v2() {
        let r = global_eval(
            r#"
            var obj = { x: 7 };
            var d = Reflect.getOwnPropertyDescriptor(obj, 'x');
            d.value;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    #[test]
    fn e2e_reflect_construct_basic() {
        let r = global_eval(
            r#"
            function Foo(v) { this.val = v; }
            var obj = Reflect.construct(Foo, [42]);
            obj.val;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    #[test]
    fn e2e_reflect_apply_basic() {
        let r = global_eval(
            r#"
            function add(a, b) { return a + b; }
            Reflect.apply(add, null, [3, 4]);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    #[test]
    fn e2e_proxy_get_trap_with_receiver() {
        let r = global_eval(
            r#"
            var target = { x: 1 };
            var handler = {
                get: function(t, k, r) { return k + '_trapped'; }
            };
            var p = new Proxy(target, handler);
            p.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("x_trapped".into()));
    }

    #[test]
    fn e2e_proxy_set_trap_intercepts() {
        let r = global_eval(
            r#"
            var log = '';
            var target = {};
            var handler = {
                set: function(t, k, v) { log += k + '=' + v; t[k] = v; return true; }
            };
            var p = new Proxy(target, handler);
            p.a = 5;
            log;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a=5".into()));
    }

    #[test]
    fn e2e_proxy_has_trap_v2() {
        let r = global_eval(
            r#"
            var handler = { has: function(t, k) { return k === 'yes'; } };
            var p = new Proxy({}, handler);
            ('yes' in p) + ',' + ('no' in p);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true,false".into()));
    }

    #[test]
    fn e2e_proxy_delete_trap_v2() {
        let r = global_eval(
            r#"
            var deleted = '';
            var handler = { deleteProperty: function(t, k) { deleted = k; return true; } };
            var p = new Proxy({ a: 1 }, handler);
            delete p.a;
            deleted;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_own_keys_trap_v2() {
        let r = global_eval(
            r#"
            var handler = { ownKeys: function(t) { return ['x', 'y']; } };
            var p = new Proxy({}, handler);
            Reflect.ownKeys(p).join(',');
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("x,y".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_apply_trap_v2() {
        let r = global_eval(
            r#"
            var handler = { apply: function(t, thisArg, args) { return args[0] * 2; } };
            var p = new Proxy(function(x) { return x; }, handler);
            p(21);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    #[test]
    fn e2e_proxy_construct_trap_v2() {
        let r = global_eval(
            r#"
            function Base() {}
            var handler = {
                construct: function(t, args) { return { built: args[0] }; }
            };
            var P = new Proxy(Base, handler);
            var obj = new P(99);
            obj.built;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    #[test]
    fn e2e_proxy_is_extensible_trap() {
        let r = global_eval(
            r#"
            var handler = { isExtensible: function(t) { return true; } };
            var p = new Proxy({}, handler);
            Reflect.isExtensible(p);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_proxy_prevent_extensions_trap() {
        let r = global_eval(
            r#"
            var frozen = false;
            var target = {};
            var handler = {
                preventExtensions: function(t) {
                    Object.preventExtensions(t);
                    frozen = true;
                    return true;
                }
            };
            var p = new Proxy(target, handler);
            Reflect.preventExtensions(p);
            frozen;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_proxy_get_prototype_of_trap() {
        let r = global_eval(
            r#"
            var proto = { tag: 'proto' };
            var handler = { getPrototypeOf: function(t) { return proto; } };
            var p = new Proxy({}, handler);
            Reflect.getPrototypeOf(p).tag;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("proto".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_chained_two_levels() {
        let r = global_eval(
            r#"
            var inner = new Proxy({ v: 1 }, { get: function(t,k) { return t[k] + 10; } });
            var outer = new Proxy(inner, { get: function(t,k) { return t[k] + 100; } });
            outer.v;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(111));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_own_keys_via_proxy_own_keys_trap() {
        let r = global_eval(
            r#"
            var handler = { ownKeys: function() { return ['b', 'a']; } };
            var p = new Proxy({}, handler);
            Reflect.ownKeys(p).join(',');
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("b,a".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_revocable_basic_v2() {
        let r = global_eval(
            r#"
            var rev = Proxy.revocable({ x: 5 }, {});
            var before = rev.proxy.x;
            rev.revoke();
            var after;
            try { after = rev.proxy.x; } catch(e) { after = 'revoked'; }
            before + ',' + after;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("5,revoked".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proxy_no_trap_forwarding_all_ops() {
        let r = global_eval(
            r#"
            var obj = { a: 1, b: 2 };
            var p = new Proxy(obj, {});
            p.c = 3;
            delete p.a;
            Reflect.ownKeys(p).join(',');
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("b,c".into()));
    }

    #[test]
    fn e2e_reflect_set_returns_boolean() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.set(obj, 'k', 1) === true;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_keys_es_ordering() {
        let r = global_eval(
            r#"
            var obj = {};
            obj['z'] = 1;
            obj['5'] = 1;
            obj['a'] = 1;
            obj['0'] = 1;
            Object.keys(obj).join(',');
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0,5,z,a".into()));
    }

    #[test]
    fn e2e_reflect_get_prototype_of_null_proto() {
        let r = global_eval(
            r#"
            var obj = Object.create(null);
            Reflect.getPrototypeOf(obj) === null;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_reflect_set_prototype_of_basic() {
        let r = global_eval(
            r#"
            var obj = {};
            var proto = { inherited: 99 };
            Reflect.setPrototypeOf(obj, proto);
            obj.inherited;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    // ── Reflect deep conformance e2e tests ──────────────────────────────

    /// Reflect.apply passes `this` to arrow-like native functions.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_apply_string_concat() {
        let r = global_eval(r#"Reflect.apply(String.prototype.toUpperCase, "abc", [])"#).unwrap();
        assert_eq!(r, JsValue::String("ABC".into()));
    }

    /// Reflect.apply with empty args list returns function default.
    #[test]
    fn e2e_reflect_apply_no_args() {
        let r = global_eval(
            r#"
            function f() { return 42; }
            Reflect.apply(f, undefined, []);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Reflect.apply throws TypeError for non-object argumentsList.
    #[test]
    fn e2e_reflect_apply_non_object_args_throws() {
        let r = global_eval(
            r#"try { Reflect.apply(function(){}, null, "bad"); "no"; } catch(e) { "ok"; }"#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.construct with zero arguments.
    #[test]
    fn e2e_reflect_construct_zero_args() {
        let r = global_eval(
            r#"
            function Empty() { this.ok = true; }
            Reflect.construct(Empty, []).ok;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.construct creates distinct instances.
    #[test]
    fn e2e_reflect_construct_distinct_instances() {
        let r = global_eval(
            r#"
            function Obj() {}
            var a = Reflect.construct(Obj, []);
            var b = Reflect.construct(Obj, []);
            a !== b;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.construct with Array constructor.
    #[test]
    fn e2e_reflect_construct_array() {
        let r = global_eval(
            r#"
            var arr = Reflect.construct(Array, [1, 2, 3]);
            arr.length;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// Reflect.defineProperty returns true and value is accessible.
    #[test]
    fn e2e_reflect_define_property_value_accessible() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", { value: 55, writable: true, enumerable: true, configurable: true });
            obj.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(55));
    }

    /// Reflect.defineProperty with enumerable false hides from Object.keys.
    #[test]
    fn e2e_reflect_define_property_non_enumerable() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "hidden", { value: 1, enumerable: false, configurable: true });
            Object.keys(obj).length;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Reflect.defineProperty non-writable prevents assignment.
    #[test]
    fn e2e_reflect_define_property_non_writable() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", { value: 5, writable: false, configurable: true });
            obj.x = 99;
            obj.x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(5));
    }

    /// Reflect.deleteProperty after defineProperty with configurable: true.
    #[test]
    fn e2e_reflect_delete_configurable_defined_property() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", { value: 1, configurable: true });
            Reflect.deleteProperty(obj, "x") && !("x" in obj);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.get returns undefined for numeric key on plain object.
    #[test]
    fn e2e_reflect_get_numeric_key() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[0] = "zero";
            Reflect.get(obj, 0);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("zero".into()));
    }

    /// Reflect.get on array returns element.
    #[test]
    fn e2e_reflect_get_array_element() {
        let r = global_eval(r#"Reflect.get([10, 20, 30], 1)"#).unwrap();
        assert_eq!(r, JsValue::Smi(20));
    }

    /// Reflect.get on array returns length.
    #[test]
    fn e2e_reflect_get_array_length() {
        let r = global_eval(r#"Reflect.get([1, 2, 3], "length")"#).unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// Reflect.set on array element.
    #[test]
    fn e2e_reflect_set_array_element() {
        let r = global_eval(
            r#"
            var arr = [1, 2, 3];
            Reflect.set(arr, 1, 42);
            arr[1];
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Reflect.has returns true for array index.
    #[test]
    fn e2e_reflect_has_array_index() {
        let r = global_eval(r#"Reflect.has([10, 20], 0)"#).unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.has returns true for "length" on array.
    #[test]
    fn e2e_reflect_has_array_length() {
        let r = global_eval(r#"Reflect.has([1], "length")"#).unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.has checks prototype chain for toString.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_has_inherited_tostring() {
        let r = global_eval(r#"Reflect.has({}, "toString")"#).unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.ownKeys returns integer keys in numeric order first.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_own_keys_numeric_ordering() {
        let r = global_eval(
            r#"
            var obj = {};
            obj["b"] = 1;
            obj["2"] = 1;
            obj["a"] = 1;
            obj["0"] = 1;
            Reflect.ownKeys(obj).join(",");
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0,2,b,a".into()));
    }

    /// Reflect.ownKeys on empty object returns empty array.
    #[test]
    fn e2e_reflect_own_keys_empty_object() {
        let r = global_eval(r#"Reflect.ownKeys({}).length"#).unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Reflect.getOwnPropertyDescriptor reports writable correctly.
    #[test]
    fn e2e_reflect_gopd_writable_field() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", { value: 1, writable: false, configurable: true, enumerable: true });
            Reflect.getOwnPropertyDescriptor(obj, "x").writable;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Reflect.getOwnPropertyDescriptor reports enumerable correctly.
    #[test]
    fn e2e_reflect_gopd_enumerable_field() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", { value: 1, writable: true, configurable: true, enumerable: false });
            Reflect.getOwnPropertyDescriptor(obj, "x").enumerable;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Reflect.getOwnPropertyDescriptor reports configurable correctly.
    #[test]
    fn e2e_reflect_gopd_configurable_field() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.defineProperty(obj, "x", { value: 1, writable: true, configurable: true, enumerable: true });
            Reflect.getOwnPropertyDescriptor(obj, "x").configurable;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.getPrototypeOf on function returns Function.prototype.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_get_prototype_of_function() {
        let r =
            global_eval(r#"Reflect.getPrototypeOf(function(){}) === Function.prototype"#).unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.setPrototypeOf to null removes prototype.
    #[test]
    fn e2e_reflect_set_prototype_of_null() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.setPrototypeOf(obj, null);
            Reflect.getPrototypeOf(obj) === null;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.setPrototypeOf cyclic chain is rejected.
    #[test]
    fn e2e_reflect_set_prototype_of_cyclic_rejected() {
        let r = global_eval(
            r#"
            var a = {};
            var b = {};
            Reflect.setPrototypeOf(a, b);
            Reflect.setPrototypeOf(b, a);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Reflect.isExtensible on frozen object returns false.
    #[test]
    fn e2e_reflect_is_extensible_frozen() {
        let r = global_eval(r#"Reflect.isExtensible(Object.freeze({}))"#).unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Reflect.preventExtensions is idempotent.
    #[test]
    fn e2e_reflect_prevent_extensions_idempotent() {
        let r = global_eval(
            r#"
            var obj = {};
            Reflect.preventExtensions(obj);
            Reflect.preventExtensions(obj);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.preventExtensions blocks new property addition.
    #[test]
    fn e2e_reflect_prevent_extensions_blocks_new_props() {
        let r = global_eval(
            r#"
            var obj = { x: 1 };
            Reflect.preventExtensions(obj);
            Reflect.set(obj, "y", 2);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Reflect.set on non-extensible with existing writable property succeeds.
    #[test]
    fn e2e_reflect_set_non_extensible_existing_writable() {
        let r = global_eval(
            r#"
            var obj = { x: 1 };
            Object.preventExtensions(obj);
            Reflect.set(obj, "x", 2) && obj.x === 2;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Reflect.get with receiver on accessor calls getter with receiver this.
    #[test]
    fn e2e_reflect_get_accessor_receiver_deep() {
        let r = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", {
                get: function () { return this.val * 2; },
                configurable: true
            });
            Reflect.get(obj, "x", { val: 21 });
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Reflect.set with receiver on accessor calls setter on receiver.
    #[test]
    fn e2e_reflect_set_accessor_receiver_deep() {
        let r = global_eval(
            r#"
            var obj = {};
            Object.defineProperty(obj, "x", {
                set: function (v) { this.stored = v + 1; },
                configurable: true
            });
            var recv = {};
            Reflect.set(obj, "x", 10, recv);
            recv.stored;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(11));
    }

    /// Reflect.get returns undefined on non-object target throws TypeError.
    #[test]
    fn e2e_reflect_get_non_object_throws() {
        let r = global_eval(r#"try { Reflect.get(42, "x"); "no"; } catch (e) { "ok"; }"#).unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.set on non-object target throws TypeError.
    #[test]
    fn e2e_reflect_set_non_object_throws() {
        let r =
            global_eval(r#"try { Reflect.set(42, "x", 1); "no"; } catch (e) { "ok"; }"#).unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.has on non-object target throws TypeError.
    #[test]
    fn e2e_reflect_has_non_object_throws() {
        let r = global_eval(r#"try { Reflect.has(42, "x"); "no"; } catch (e) { "ok"; }"#).unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.deleteProperty on non-object throws TypeError.
    #[test]
    fn e2e_reflect_delete_property_non_object_throws() {
        let r =
            global_eval(r#"try { Reflect.deleteProperty(42, "x"); "no"; } catch (e) { "ok"; }"#)
                .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.defineProperty on non-object throws TypeError.
    #[test]
    fn e2e_reflect_define_property_non_object_throws() {
        let r = global_eval(
            r#"try { Reflect.defineProperty(42, "x", { value: 1 }); "no"; } catch (e) { "ok"; }"#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.ownKeys on non-object throws TypeError.
    #[test]
    fn e2e_reflect_own_keys_non_object_throws() {
        let r = global_eval(r#"try { Reflect.ownKeys(42); "no"; } catch (e) { "ok"; }"#).unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.getPrototypeOf on non-object throws TypeError.
    #[test]
    fn e2e_reflect_get_prototype_of_non_object_throws() {
        let r = global_eval(r#"try { Reflect.getPrototypeOf(42); "no"; } catch (e) { "ok"; }"#)
            .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.setPrototypeOf on non-object throws TypeError.
    #[test]
    fn e2e_reflect_set_prototype_of_non_object_throws() {
        let r = global_eval(r#"try { Reflect.setPrototypeOf(42, {}); "no"; } catch (e) { "ok"; }"#)
            .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.isExtensible on non-object throws TypeError.
    #[test]
    fn e2e_reflect_is_extensible_non_object_throws() {
        let r =
            global_eval(r#"try { Reflect.isExtensible(42); "no"; } catch (e) { "ok"; }"#).unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.preventExtensions on non-object throws TypeError.
    #[test]
    fn e2e_reflect_prevent_extensions_non_object_throws() {
        let r = global_eval(r#"try { Reflect.preventExtensions(42); "no"; } catch (e) { "ok"; }"#)
            .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.getOwnPropertyDescriptor on non-object throws TypeError.
    #[test]
    fn e2e_reflect_gopd_non_object_throws() {
        let r = global_eval(
            r#"try { Reflect.getOwnPropertyDescriptor(42, "x"); "no"; } catch (e) { "ok"; }"#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.construct non-constructor newTarget throws TypeError.
    #[test]
    fn e2e_reflect_construct_non_constructor_new_target_throws() {
        let r = global_eval(
            r#"try { Reflect.construct(function(){}, [], 42); "no"; } catch (e) { "ok"; }"#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("ok".into()));
    }

    /// Reflect.apply uses this binding for method call.
    #[test]
    fn e2e_reflect_apply_method_this() {
        let r = global_eval(
            r#"
            var obj = { x: 10, getX: function() { return this.x; } };
            Reflect.apply(obj.getX, { x: 99 }, []);
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    /// Reflect.set returns true as boolean type.
    #[test]
    fn e2e_reflect_set_return_type_boolean() {
        let r = global_eval(r#"typeof Reflect.set({}, "x", 1)"#).unwrap();
        assert_eq!(r, JsValue::String("boolean".into()));
    }

    /// Reflect.has returns boolean type.
    #[test]
    fn e2e_reflect_has_return_type_boolean() {
        let r = global_eval(r#"typeof Reflect.has({}, "x")"#).unwrap();
        assert_eq!(r, JsValue::String("boolean".into()));
    }

    /// Reflect.defineProperty returns boolean type.
    #[test]
    fn e2e_reflect_define_property_return_type_boolean() {
        let r = global_eval(r#"typeof Reflect.defineProperty({}, "x", { value: 1 })"#).unwrap();
        assert_eq!(r, JsValue::String("boolean".into()));
    }

    /// Reflect.deleteProperty returns boolean type.
    #[test]
    fn e2e_reflect_delete_property_return_type_boolean() {
        let r = global_eval(r#"typeof Reflect.deleteProperty({}, "x")"#).unwrap();
        assert_eq!(r, JsValue::String("boolean".into()));
    }

    // ── Property descriptor conformance e2e tests ───────────────────────

    /// Mixed descriptor (both accessor and data fields) throws TypeError.
    #[test]
    fn e2e_define_property_mixed_descriptor_throws() {
        let r = global_eval(
            r#"
            try {
                Object.defineProperty({}, 'x', { value: 1, get: function(){} });
                'no error';
            } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// Mixed descriptor with writable + set throws TypeError.
    #[test]
    fn e2e_define_property_writable_and_set_throws() {
        let r = global_eval(
            r#"
            try {
                Object.defineProperty({}, 'x', { writable: true, set: function(){} });
                'no error';
            } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// Non-configurable property cannot be deleted.
    #[test]
    fn e2e_nonconfig_cannot_delete() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', { value: 1, configurable: false });
            var deleted = delete o.x;
            String(deleted) + ',' + String(o.x)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("false,1".into()));
    }

    /// Non-writable property silently ignores assignment (sloppy mode).
    #[test]
    fn e2e_nonwritable_ignores_assignment() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', { value: 42, writable: false });
            o.x = 99;
            o.x
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// `getOwnPropertyDescriptor` returns correct data descriptor shape.
    #[test]
    fn e2e_gopd_data_descriptor_shape() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', {
                value: 10, writable: true, enumerable: false, configurable: true
            });
            var d = Object.getOwnPropertyDescriptor(o, 'x');
            d.value + ',' + d.writable + ',' + d.enumerable + ',' + d.configurable
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("10,true,false,true".into()));
    }

    /// `getOwnPropertyDescriptor` returns correct accessor descriptor shape.
    #[test]
    fn e2e_gopd_accessor_descriptor_shape() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', {
                get: function(){ return 5; },
                enumerable: true,
                configurable: false
            });
            var d = Object.getOwnPropertyDescriptor(o, 'x');
            (typeof d.get) + ',' + (typeof d.set) + ',' + d.enumerable + ',' + d.configurable
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function,undefined,true,false".into()));
    }

    /// `getOwnPropertyDescriptor` returns undefined for missing property.
    #[test]
    fn e2e_gopd_missing_returns_undefined() {
        let r = global_eval(
            r#"
            var o = { a: 1 };
            typeof Object.getOwnPropertyDescriptor(o, 'b')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("undefined".into()));
    }

    /// `getOwnPropertyDescriptors` returns all own descriptors.
    #[test]
    fn e2e_gopds_returns_all() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'a', { value: 1, enumerable: true, configurable: true, writable: true });
            Object.defineProperty(o, 'b', { value: 2, enumerable: false, configurable: true, writable: false });
            var ds = Object.getOwnPropertyDescriptors(o);
            ds.a.value + ',' + ds.a.enumerable + ',' + ds.b.value + ',' + ds.b.enumerable
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,true,2,false".into()));
    }

    /// `defineProperties` defines multiple properties at once.
    #[test]
    fn e2e_define_properties_multiple() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperties(o, {
                x: { value: 10, writable: true, enumerable: true, configurable: true },
                y: { value: 20, writable: false, enumerable: false, configurable: false }
            });
            String(o.x) + ',' + String(o.y)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("10,20".into()));
    }

    /// `preventExtensions` blocks new property addition.
    #[test]
    fn e2e_prevent_extensions_blocks_new() {
        let r = global_eval(
            r#"
            var o = { a: 1 };
            Object.preventExtensions(o);
            o.b = 2;
            typeof o.b
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("undefined".into()));
    }

    /// `preventExtensions` allows modifying existing properties.
    #[test]
    fn e2e_prevent_extensions_allows_modify() {
        let r = global_eval(
            r#"
            var o = { a: 1 };
            Object.preventExtensions(o);
            o.a = 99;
            o.a
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    /// `isExtensible` returns false after `preventExtensions`.
    #[test]
    fn e2e_is_extensible_after_prevent() {
        let r = global_eval(
            r#"
            var o = {};
            var before = Object.isExtensible(o);
            Object.preventExtensions(o);
            var after = Object.isExtensible(o);
            before + ',' + after
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true,false".into()));
    }

    /// `seal` marks all properties non-configurable.
    #[test]
    fn e2e_seal_marks_nonconfigurable() {
        let r = global_eval(
            r#"
            var o = { a: 1, b: 2 };
            Object.seal(o);
            var da = Object.getOwnPropertyDescriptor(o, 'a');
            var db = Object.getOwnPropertyDescriptor(o, 'b');
            da.configurable + ',' + db.configurable
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("false,false".into()));
    }

    /// `seal` preserves writability.
    #[test]
    fn e2e_seal_preserves_writable() {
        let r = global_eval(
            r#"
            var o = { a: 1 };
            Object.seal(o);
            o.a = 42;
            o.a
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// `isSealed` reflects sealed state.
    #[test]
    fn e2e_is_sealed_reflects_state() {
        let r = global_eval(
            r#"
            var o = { a: 1 };
            var before = Object.isSealed(o);
            Object.seal(o);
            var after = Object.isSealed(o);
            before + ',' + after
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("false,true".into()));
    }

    /// Sealed object rejects new properties via defineProperty.
    #[test]
    fn e2e_sealed_rejects_new_define_property() {
        let r = global_eval(
            r#"
            var o = Object.seal({ a: 1 });
            try {
                Object.defineProperty(o, 'b', { value: 2 });
                'no error';
            } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// `freeze` marks all properties non-writable and non-configurable.
    #[test]
    fn e2e_freeze_marks_nonwritable_nonconfigurable() {
        let r = global_eval(
            r#"
            var o = { a: 1 };
            Object.freeze(o);
            var d = Object.getOwnPropertyDescriptor(o, 'a');
            d.writable + ',' + d.configurable
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("false,false".into()));
    }

    /// Frozen object ignores assignment in sloppy mode.
    #[test]
    fn e2e_freeze_ignores_assignment() {
        let r = global_eval(
            r#"
            var o = Object.freeze({ a: 1 });
            o.a = 99;
            o.a
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// `isFrozen` reflects frozen state.
    #[test]
    fn e2e_is_frozen_reflects_state() {
        let r = global_eval(
            r#"
            var o = { a: 1 };
            var before = Object.isFrozen(o);
            Object.freeze(o);
            var after = Object.isFrozen(o);
            before + ',' + after
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("false,true".into()));
    }

    /// Frozen object also reports as sealed.
    #[test]
    fn e2e_frozen_is_sealed() {
        let r = global_eval("Object.isSealed(Object.freeze({ a: 1 }))").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Primitives are considered frozen and sealed.
    #[test]
    fn e2e_primitives_frozen_sealed() {
        let r = global_eval(
            r#"
            Object.isFrozen(42) + ',' + Object.isSealed('hi') + ',' + Object.isExtensible(true)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true,true,false".into()));
    }

    /// Non-configurable property rejects configurable change via defineProperty.
    #[test]
    fn e2e_nonconfig_rejects_configurable_change() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', { value: 1, configurable: false });
            try {
                Object.defineProperty(o, 'x', { configurable: true });
                'no error';
            } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// Non-configurable + non-writable rejects writable widening.
    #[test]
    fn e2e_nonconfig_nonwritable_rejects_writable_widening() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', { value: 1, writable: false, configurable: false });
            try {
                Object.defineProperty(o, 'x', { writable: true });
                'no error';
            } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// Non-configurable data→accessor conversion throws.
    #[test]
    fn e2e_nonconfig_data_to_accessor_throws() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', { value: 1, configurable: false });
            try {
                Object.defineProperty(o, 'x', { get: function(){ return 2; } });
                'no error';
            } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// Configurable property allows data→accessor conversion.
    #[test]
    fn e2e_configurable_data_to_accessor_ok() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', { value: 1, configurable: true });
            Object.defineProperty(o, 'x', { get: function(){ return 2; }, configurable: true });
            var d = Object.getOwnPropertyDescriptor(o, 'x');
            typeof d.get
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("function".into()));
    }

    /// Redefining non-configurable non-writable with same value succeeds.
    #[test]
    fn e2e_nonconfig_nonwritable_same_value_ok() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', { value: 42, writable: false, configurable: false });
            Object.defineProperty(o, 'x', { value: 42 });
            o.x
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// `Object.freeze` on empty non-extensible object reports frozen.
    #[test]
    fn e2e_empty_non_extensible_is_frozen() {
        let r = global_eval(
            r#"
            var o = {};
            Object.preventExtensions(o);
            Object.isFrozen(o)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── Iteration protocol & for-in/for-of conformance ──────────────────

    /// for-in on string enumerates character indices.
    #[test]
    fn e2e_for_in_string_indices() {
        let r = global_eval("var keys = []; for (var k in 'abc') keys.push(k); keys.join(',')")
            .unwrap();
        assert_eq!(r, JsValue::String("0,1,2".into()));
    }

    /// for-in with continue skips current iteration.
    #[test]
    fn e2e_for_in_continue() {
        let r = global_eval(
            "var o = { a: 1, b: 2, c: 3 }; \
             var keys = []; \
             for (var k in o) { if (k === 'b') continue; keys.push(k); } \
             keys.join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a,c".into()));
    }

    /// for-of with continue skips current iteration.
    #[test]
    fn e2e_for_of_continue() {
        let r = global_eval(
            "var r = []; for (var x of [1,2,3,4]) { if (x === 2) continue; r.push(x); } r.join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,3,4".into()));
    }

    /// for-of with custom Symbol.iterator.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_of_custom_iterator() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var i = 0;
                return {
                    next: function() {
                        i++;
                        if (i <= 3) return { value: i * 10, done: false };
                        return { value: undefined, done: true };
                    }
                };
            };
            var sum = 0;
            for (var v of obj) sum += v;
            sum
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(60));
    }

    /// for-of break calls .return() on the iterator.
    #[test]
    #[ignore] // TODO: hangs in CI – fix iterator return protocol on break
    fn e2e_for_of_break_calls_return() {
        let r = global_eval(
            r#"
            var closed = false;
            var obj = {};
            obj[Symbol.iterator] = function() {
                var i = 0;
                return {
                    next: function() {
                        i++;
                        return { value: i, done: false };
                    },
                    return: function() {
                        closed = true;
                        return { done: true };
                    }
                };
            };
            for (var v of obj) { if (v === 2) break; }
            closed
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Object.seal` on empty non-extensible object reports sealed.
    #[test]
    fn e2e_empty_non_extensible_is_sealed() {
        let r = global_eval(
            r#"
            var o = {};
            Object.preventExtensions(o);
            Object.isSealed(o)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Spread in array literal uses iteration protocol.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_spread_array_literal() {
        let r = global_eval("var a = [1, ...[2, 3], 4]; a.join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3,4".into()));
    }

    /// Spread string in array literal.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_spread_string_in_array() {
        let r = global_eval("var a = [...'hi']; a.join(',')").unwrap();
        assert_eq!(r, JsValue::String("h,i".into()));
    }

    /// Spread in function call uses iteration protocol.
    #[test]
    fn e2e_spread_in_function_call() {
        let r = global_eval("function sum(a, b, c) { return a + b + c; } sum(...[10, 20, 30])")
            .unwrap();
        assert_eq!(r, JsValue::Smi(60));
    }

    /// Destructuring array uses iteration protocol.
    #[test]
    fn e2e_destructuring_array_basic() {
        let r = global_eval("var [a, b, c] = [10, 20, 30]; a + b + c").unwrap();
        assert_eq!(r, JsValue::Smi(60));
    }

    /// Destructuring with rest element.
    #[test]
    fn e2e_destructuring_rest() {
        let r = global_eval("var [first, ...rest] = [1, 2, 3, 4]; rest.join(',')").unwrap();
        assert_eq!(r, JsValue::String("2,3,4".into()));
    }

    /// Destructuring with fewer elements than iterable.
    #[test]
    fn e2e_destructuring_fewer_elements() {
        let r = global_eval("var [a, b] = [10, 20, 30]; a + b").unwrap();
        assert_eq!(r, JsValue::Smi(30));
    }

    /// Destructuring with more elements than iterable gives undefined.
    #[test]
    fn e2e_destructuring_more_elements() {
        let r = global_eval("var [a, b, c] = [10, 20]; c === undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Destructuring from string uses iteration protocol.
    #[test]
    fn e2e_destructuring_string() {
        let r = global_eval("var [a, b, c] = 'xyz'; a + b + c").unwrap();
        assert_eq!(r, JsValue::String("xyz".into()));
    }

    /// Iterator protocol: missing done defaults to false.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_missing_done_defaults_false() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var calls = 0;
                return {
                    next: function() {
                        calls++;
                        if (calls <= 2) return { value: calls };
                        return { done: true };
                    }
                };
            };
            var r = []; for (var v of obj) r.push(v); r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2".into()));
    }

    /// Iterator protocol: truthy string done stops iteration.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iterator_truthy_done() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var calls = 0;
                return {
                    next: function() {
                        calls++;
                        if (calls === 1) return { value: 42, done: "" };
                        return { value: 99, done: "yes" };
                    }
                };
            };
            var r = []; for (var v of obj) r.push(v); r.join(',')
            "#,
        )
        .unwrap();
        // First call: done="" (falsy) → value 42 collected
        // Second call: done="yes" (truthy) → stops
        assert_eq!(r, JsValue::String("42".into()));
    }

    /// Iterator protocol: missing value defaults to undefined.
    #[test]
    fn e2e_iterator_missing_value() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var calls = 0;
                return {
                    next: function() {
                        calls++;
                        if (calls === 1) return { done: false };
                        return { done: true };
                    }
                };
            };
            var r = []; for (var v of obj) r.push(v); r[0] === undefined
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `defineProperty` on non-object throws TypeError.
    #[test]
    fn e2e_define_property_non_object_throws() {
        let r = global_eval(
            r#"
            try { Object.defineProperty(42, 'x', { value: 1 }); 'no'; } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// `defineProperty` descriptor must be an object.
    #[test]
    fn e2e_define_property_descriptor_must_be_object() {
        let r = global_eval(
            r#"
            try { Object.defineProperty({}, 'x', 42); 'no'; } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// `getOwnPropertyDescriptors` on null/undefined throws.
    #[test]
    fn e2e_gopds_null_throws() {
        let r = global_eval(
            r#"
            try { Object.getOwnPropertyDescriptors(null); 'no'; } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// Freeze then defineProperty throws.
    #[test]
    fn e2e_freeze_then_define_property_throws() {
        let r = global_eval(
            r#"
            var o = Object.freeze({ a: 1 });
            try {
                Object.defineProperty(o, 'a', { value: 2 });
                'no error';
            } catch(e) { 'error'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error".into()));
    }

    /// Delete on configurable property succeeds.
    #[test]
    fn e2e_delete_configurable_succeeds() {
        let r = global_eval(
            r#"
            var o = {};
            Object.defineProperty(o, 'x', { value: 1, configurable: true });
            var deleted = delete o.x;
            String(deleted) + ',' + String(o.x)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("true,undefined".into()));
    }

    /// for-in with let binding.
    #[test]
    fn e2e_for_in_let() {
        let r = global_eval(
            "var keys = []; for (let k in { a: 1, b: 2 }) keys.push(k); keys.join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a,b".into()));
    }

    /// for-in with const binding.
    #[test]
    fn e2e_for_in_const() {
        let r =
            global_eval("var keys = []; for (const k in { x: 1 }) keys.push(k); keys.join(',')")
                .unwrap();
        assert_eq!(r, JsValue::String("x".into()));
    }

    /// for-of over generator with early return.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_of_generator_break() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; yield 2; yield 3; yield 4; }
            var r = [];
            for (var v of gen()) { r.push(v); if (v === 2) break; }
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2".into()));
    }

    /// Nested for-of loops.
    #[test]
    fn e2e_for_of_nested_loops() {
        let r = global_eval(
            "var r = []; \
             for (var a of [1, 2]) \
                 for (var b of [10, 20]) \
                     r.push(a + b); \
             r.join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("11,21,12,22".into()));
    }

    /// for-of with object destructuring in loop variable.
    #[test]
    fn e2e_for_of_object_destructuring() {
        let r = global_eval(
            r#"
            var items = [{ name: "a", val: 1 }, { name: "b", val: 2 }];
            var r = [];
            for (var { name, val } of items) r.push(name + val);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a1,b2".into()));
    }

    /// Spread generator in function call.
    #[test]
    fn e2e_spread_generator_in_call() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; yield 2; yield 3; }
            function sum(a, b, c) { return a + b + c; }
            sum(...gen())
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(6));
    }

    /// Spread multiple iterables in array.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_spread_multiple_in_array() {
        let r = global_eval("var a = [...[1, 2], ...[3, 4], 5]; a.join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3,4,5".into()));
    }

    /// for-in prototype chain: three levels deep.
    #[test]
    fn e2e_for_in_deep_proto_chain() {
        let r = global_eval(
            "var gp = { z: 3 }; \
             var p = Object.create(gp); p.y = 2; \
             var o = Object.create(p); o.x = 1; \
             var keys = []; for (var k in o) keys.push(k); \
             keys.join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("x,y,z".into()));
    }

    /// for-of on empty array produces no iterations.
    #[test]
    fn e2e_for_of_empty_array() {
        let r = global_eval("var n = 0; for (var x of []) n++; n").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// for-of on empty string produces no iterations.
    #[test]
    fn e2e_for_of_empty_string() {
        let r = global_eval("var n = 0; for (var c of '') n++; n").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Spread empty array produces empty.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_spread_empty_array() {
        let r = global_eval("[...[]].length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// for-in on number/boolean produces no iterations.
    #[test]
    fn e2e_for_in_primitive_noop() {
        let r =
            global_eval("var n = 0; for (var k in 42) n++; for (var k in true) n++; n").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Destructuring assignment (not declaration).
    #[test]
    fn e2e_destructuring_assignment() {
        let r = global_eval("var a, b; [a, b] = [100, 200]; a + b").unwrap();
        assert_eq!(r, JsValue::Smi(300));
    }

    /// for-of with array of mixed types.
    #[test]
    fn e2e_for_of_mixed_types() {
        let r = global_eval(
            r#"
            var types = [];
            for (var v of [1, "two", true, null]) types.push(typeof v);
            types.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("number,string,boolean,object".into()));
    }

    /// for-in with break stops iteration.
    #[test]
    fn e2e_for_in_break_stops() {
        let r = global_eval(
            "var o = { a: 1, b: 2, c: 3 }; \
             var count = 0; \
             for (var k in o) { count++; if (count === 2) break; } \
             count",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// Spread with custom Symbol.iterator.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_spread_custom_iterator() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var i = 0;
                return {
                    next: function() {
                        i++;
                        if (i <= 3) return { value: i, done: false };
                        return { done: true };
                    }
                };
            };
            var a = [...obj];
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// Destructuring with default values.
    #[test]
    fn e2e_destructuring_default_values() {
        let r = global_eval("var [a = 10, b = 20, c = 30] = [1, 2]; a + b + c").unwrap();
        assert_eq!(r, JsValue::Smi(33));
    }

    /// Array destructuring defaults preserve present values.
    #[test]
    fn e2e_destructuring_array_defaults_preserve_present_values() {
        assert_eval_true("let [a = 1, b = 2] = [10]; a === 10 && b === 2");
    }

    /// Array destructuring defaults apply to missing elements.
    #[test]
    fn e2e_destructuring_array_defaults_apply_to_missing_elements() {
        assert_eval_true("let [a = 1, b = 2, c = 3] = [10]; a === 10 && b === 2 && c === 3");
    }

    /// Array destructuring defaults apply to undefined elements.
    #[test]
    fn e2e_destructuring_array_defaults_apply_to_undefined_elements() {
        assert_eval_true("let [a = 1, b = 2] = [undefined, undefined]; a === 1 && b === 2");
    }

    /// Array destructuring defaults do not apply to null values.
    #[test]
    fn e2e_destructuring_array_defaults_do_not_apply_to_null_values() {
        assert_eval_true("let [a = 1] = [null]; a === null");
    }

    /// Object destructuring defaults apply to missing properties.
    #[test]
    fn e2e_destructuring_object_defaults_apply_to_missing_properties() {
        assert_eval_true("let {a = 1} = {}; a === 1");
    }

    /// Object destructuring defaults apply to undefined properties.
    #[test]
    fn e2e_destructuring_object_defaults_apply_to_undefined_properties() {
        assert_eval_true("let {a = 1} = {a: undefined}; a === 1");
    }

    /// Object destructuring defaults preserve defined properties.
    #[test]
    fn e2e_destructuring_object_defaults_preserve_defined_properties() {
        assert_eval_true("let {a = 1} = {a: 9}; a === 9");
    }

    /// Object destructuring defaults do not apply to null values.
    #[test]
    fn e2e_destructuring_object_defaults_do_not_apply_to_null_values() {
        assert_eval_true("let {a = 1} = {a: null}; a === null");
    }

    /// Object destructuring rename defaults apply when the property is missing.
    #[test]
    fn e2e_destructuring_object_rename_defaults_apply_when_missing() {
        assert_eval_true("let {a: value = 7} = {}; value === 7");
    }

    /// Nested object destructuring extracts inner values.
    #[test]
    fn e2e_destructuring_nested_object_basic() {
        assert_eval_true("let {a: {b}} = {a: {b: 1}}; b === 1");
    }

    /// Deep nested object destructuring extracts inner values.
    #[test]
    fn e2e_destructuring_nested_object_deep() {
        assert_eval_true("let {a: {b: {c}}} = {a: {b: {c: 4}}}; c === 4");
    }

    /// Nested mixed destructuring supports object then array patterns.
    #[test]
    fn e2e_destructuring_nested_mixed_object_then_array() {
        assert_eval_true("let {a: [b, c]} = {a: [1, 2]}; b === 1 && c === 2");
    }

    /// Nested mixed destructuring supports array then object patterns.
    #[test]
    fn e2e_destructuring_nested_mixed_array_then_object() {
        assert_eval_true("let [{a}, [b]] = [{a: 1}, [2]]; a === 1 && b === 2");
    }

    /// Array destructuring rest collects the remaining elements.
    #[test]
    fn e2e_destructuring_array_rest_collects_remaining_elements() {
        assert_eval_true(
            "let [a, ...rest] = [1, 2, 3]; a === 1 && rest.length === 2 && rest[0] === 2 && rest[1] === 3",
        );
    }

    /// Array destructuring rest can be empty.
    #[test]
    fn e2e_destructuring_array_rest_can_be_empty() {
        assert_eval_true("let [a, ...rest] = [1]; a === 1 && rest.length === 0");
    }

    /// Object destructuring rest collects the remaining properties.
    #[test]
    fn e2e_destructuring_object_rest_collects_remaining_properties() {
        assert_eval_true(
            "let {a, ...rest} = {a: 1, b: 2}; a === 1 && rest.b === 2 && rest.a === undefined && Object.keys(rest).length === 1",
        );
    }

    /// Object destructuring rest excludes multiple extracted properties.
    #[test]
    fn e2e_destructuring_object_rest_excludes_extracted_properties() {
        assert_eval_true(
            "let {a, b, ...rest} = {a: 1, b: 2, c: 3, d: 4}; rest.a === undefined && rest.b === undefined && rest.c === 3 && rest.d === 4 && Object.keys(rest).length === 2",
        );
    }

    /// Object destructuring rest excludes computed keys.
    #[test]
    fn e2e_destructuring_object_rest_excludes_computed_keys() {
        assert_eval_true(
            "let key = 'b'; let {a, [key]: value, ...rest} = {a: 1, b: 2, c: 3}; a === 1 && value === 2 && rest.a === undefined && rest.b === undefined && rest.c === 3 && Object.keys(rest).length === 1",
        );
    }

    /// Computed property keys work in object destructuring.
    #[test]
    fn e2e_destructuring_computed_property_keys_work() {
        assert_eval_true("let key = 'answer'; let {[key]: value} = {answer: 42}; value === 42");
    }

    /// Computed property expressions work in object destructuring.
    #[test]
    fn e2e_destructuring_computed_property_expressions_work() {
        assert_eval_true(
            "let prefix = 'na'; let {[prefix + 'me']: value} = {name: 'stator'}; value === 'stator'",
        );
    }

    /// Numeric computed property keys work in object destructuring.
    #[test]
    fn e2e_destructuring_numeric_computed_property_keys_work() {
        assert_eval_true("let {[1]: value} = {1: 99}; value === 99");
    }

    /// Function parameters support object destructuring.
    #[test]
    fn e2e_destructuring_function_parameters_support_object_patterns() {
        assert_eval_true("function f({a, b}) { return a + b; } f({a: 3, b: 4}) === 7");
    }

    /// Function parameters support array destructuring.
    #[test]
    fn e2e_destructuring_function_parameters_support_array_patterns() {
        assert_eval_true("function f([a, b]) { return a * b; } f([3, 4]) === 12");
    }

    /// Function parameters support nested mixed destructuring.
    #[test]
    fn e2e_destructuring_function_parameters_support_nested_mixed_patterns() {
        assert_eval_true("function f([{a}, [b]]) { return a + b; } f([{a: 1}, [2]]) === 3");
    }

    /// Function parameters support object defaults.
    #[test]
    fn e2e_destructuring_function_parameters_support_object_defaults() {
        assert_eval_true("function f({a = 1}) { return a; } f({}) === 1");
    }

    /// Function parameters support array defaults.
    #[test]
    fn e2e_destructuring_function_parameters_support_array_defaults() {
        assert_eval_true("function f([a = 1, b = 2]) { return a + b; } f([10]) === 12");
    }

    /// Object destructuring assignment updates existing bindings.
    #[test]
    fn e2e_destructuring_assignment_supports_object_patterns() {
        assert_eval_true("var a, b; ({a, b} = {a: 5, b: 6}); a === 5 && b === 6");
    }

    /// Array destructuring assignment updates existing bindings.
    #[test]
    fn e2e_destructuring_assignment_supports_array_patterns() {
        assert_eval_true("var a, b; [a, b] = [7, 8]; a === 7 && b === 8");
    }

    /// Nested destructuring assignment updates existing bindings.
    #[test]
    fn e2e_destructuring_assignment_supports_nested_patterns() {
        assert_eval_true(
            "var a, b; ({a: {value: a}, b} = {a: {value: 9}, b: 10}); a === 9 && b === 10",
        );
    }

    /// Object destructuring assignment supports defaults.
    #[test]
    fn e2e_destructuring_assignment_supports_object_defaults() {
        assert_eval_true("var a; ({a = 5} = {a: undefined}); a === 5");
    }

    /// Array destructuring assignment supports defaults.
    #[test]
    fn e2e_destructuring_assignment_supports_array_defaults() {
        assert_eval_true("var a, b; [a = 1, b = 2] = [undefined, 9]; a === 1 && b === 9");
    }

    /// Object destructuring assignment supports rest.
    #[test]
    fn e2e_destructuring_assignment_supports_object_rest() {
        assert_eval_true(
            "var a, rest; ({a, ...rest} = {a: 1, b: 2, c: 3}); a === 1 && rest.b === 2 && rest.c === 3 && rest.a === undefined && Object.keys(rest).length === 2",
        );
    }

    /// Computed property keys work in destructuring assignment.
    #[test]
    fn e2e_destructuring_assignment_supports_computed_property_keys() {
        assert_eval_true("var value; var key = 'z'; ({[key]: value} = {z: 11}); value === 11");
    }

    /// Destructuring can consume Set iterables.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_destructuring_iterable_set_basic() {
        assert_eval_true("let [a, b] = new Set([1, 2]); a === 1 && b === 2");
    }

    /// Destructuring defaults apply when Set iteration stops early.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_destructuring_iterable_set_defaults_apply_to_missing_values() {
        assert_eval_true("let [a = 1, b = 2] = new Set([10]); a === 10 && b === 2");
    }

    /// Destructuring from Set supports rest elements.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_destructuring_iterable_set_supports_rest_elements() {
        assert_eval_true(
            "let [a, ...rest] = new Set([1, 2, 3]); a === 1 && rest.length === 2 && rest[0] === 2 && rest[1] === 3",
        );
    }

    /// Destructuring supports nested mixed iterable inputs.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_destructuring_nested_mixed_iterable_inputs() {
        assert_eval_true("let [{a}, [b]] = [{a: 1}, new Set([2])]; a === 1 && b === 2");
    }

    /// for-of return inside function exits the function and closes iterator.
    #[test]
    fn e2e_for_of_return_inside_function() {
        let r = global_eval(
            r#"
            function f() {
                for (var x of [10, 20, 30, 40]) {
                    if (x === 20) return x;
                }
                return 0;
            }
            f()
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(20));
    }

    /// for-in enumerates array indices as strings.
    #[test]
    fn e2e_for_in_array_indices() {
        let r =
            global_eval("var keys = []; for (var k in [10, 20, 30]) keys.push(k); keys.join(',')")
                .unwrap();
        assert_eq!(r, JsValue::String("0,1,2".into()));
    }

    /// for-of over Set (if available), otherwise test with array.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_of_set_iteration() {
        let r = global_eval(
            "var s = new Set([3, 1, 4, 1, 5]); \
             var r = []; for (var v of s) r.push(v); r.join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("3,1,4,5".into()));
    }

    /// for-of over Map entries.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_of_map_iteration() {
        let r = global_eval(
            r#"
            var m = new Map();
            m.set("a", 1);
            m.set("b", 2);
            var r = [];
            for (var e of m) r.push(e[0] + "=" + e[1]);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a=1,b=2".into()));
    }

    // ── Private class fields / methods conformance ───────────────────────

    /// Basic private instance field with initializer.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_basic() {
        let r = global_eval(
            "class Foo { #x = 42; getX() { return this.#x; } } \
             new Foo().getX()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Private field defaults to undefined when no initializer is given.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_default_undefined() {
        let r = global_eval(
            "class Foo { #x; getX() { return this.#x; } } \
             new Foo().getX()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Undefined);
    }

    /// Private field can be mutated via a setter method.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_setter() {
        let r = global_eval(
            "class Foo { #x = 0; setX(v) { this.#x = v; } getX() { return this.#x; } } \
             let f = new Foo(); f.setX(99); f.getX()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    /// Multiple private fields on the same class.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_multiple() {
        let r = global_eval(
            "class Point { #x = 1; #y = 2; sum() { return this.#x + this.#y; } } \
             new Point().sum()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// Each instance gets its own private field value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_per_instance() {
        let r = global_eval(
            "class C { #v; constructor(v) { this.#v = v; } get() { return this.#v; } } \
             let a = new C(10); let b = new C(20); a.get() + b.get()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(30));
    }

    /// Private method returning a constant.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_method_basic() {
        let r = global_eval(
            "class Foo { #secret() { return 42; } reveal() { return this.#secret(); } } \
             new Foo().reveal()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Private method accessing a private field.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_method_accesses_field() {
        let r = global_eval(
            "class Foo { #x = 10; #double() { return this.#x * 2; } run() { return this.#double(); } } \
             new Foo().run()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(20));
    }

    /// Static private field.
    #[test]
    fn e2e_private_static_field() {
        let r = global_eval(
            "class Counter { \
               static #count = 0; \
               constructor() { Counter.#count++; } \
               static getCount() { return Counter.#count; } \
             } \
             new Counter(); new Counter(); new Counter(); \
             Counter.getCount()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// `#field in obj` — brand check returns true for instances.
    #[test]
    fn e2e_private_in_operator_true() {
        let r = global_eval(
            "class Foo { #x = 1; static has(o) { return #x in o; } } \
             Foo.has(new Foo())",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `#field in obj` — brand check returns false for non-instances.
    #[test]
    fn e2e_private_in_operator_false() {
        let r = global_eval(
            "class Foo { #x = 1; static has(o) { return #x in o; } } \
             Foo.has({})",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Private field not visible via public property enumeration.
    #[test]
    fn e2e_private_field_not_enumerable() {
        let r = global_eval(
            "class Foo { #x = 1; y = 2; } \
             let keys = Object.keys(new Foo()); \
             keys.length",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// Private field with expression initializer.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_expr_initializer() {
        let r = global_eval(
            "class Foo { #x = 3 + 4; getX() { return this.#x; } } \
             new Foo().getX()",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(7));
    }

    // ── Array method edge-case conformance tests ────────────────────────

    /// `Array.from` with an array-like object (has length + indexed props).
    #[test]
    fn e2e_array_from_array_like() {
        let r =
            global_eval(r#"Array.from({length: 3, 0: "a", 1: "b", 2: "c"}).join(",")"#).unwrap();
        assert_eq!(r, JsValue::String("a,b,c".into()));
    }

    /// `Array.from` with mapFn receiving index as second argument.
    #[test]
    fn e2e_array_from_mapfn_index() {
        let r = global_eval("Array.from([10, 20, 30], function(v, i) { return i; }).join(',')")
            .unwrap();
        assert_eq!(r, JsValue::String("0,1,2".into()));
    }

    /// `Array.from` with mapFn that doubles values.
    #[test]
    fn e2e_array_from_mapfn_doubles() {
        let r =
            global_eval("Array.from([1,2,3], function(x) { return x * 2; }).join(',')").unwrap();
        assert_eq!(r, JsValue::String("2,4,6".into()));
    }

    /// `Array.from` on an empty array-like returns empty array.
    #[test]
    fn e2e_array_from_empty_array_like() {
        let r = global_eval("Array.from({length: 0}).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// `Array.from` with a Set produces the set's values.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_from_set() {
        let r =
            global_eval("var s = new Set(); s.add(1); s.add(2); s.add(3); Array.from(s).join(',')")
                .unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// `Array.from` with non-callable mapFn throws TypeError.
    #[test]
    fn e2e_array_from_non_callable_mapfn() {
        let r = global_eval("Array.from([1,2], 42)");
        assert!(r.is_err());
    }

    /// `Array.of` creates single-element array (unlike `Array(5)` which makes length-5).
    #[test]
    fn e2e_array_of_single_element_value() {
        let r = global_eval("Array.of(5)[0]").unwrap();
        assert_eq!(r, JsValue::Smi(5));
    }

    /// `Array.of` with no arguments returns empty array.
    #[test]
    fn e2e_array_of_no_args() {
        let r = global_eval("Array.of().length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// `Array.of` with mixed types.
    #[test]
    fn e2e_array_of_mixed_types() {
        let r = global_eval(r#"Array.of(1, "two", true).length"#).unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// `Array.prototype.flat` with default depth (1).
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flat_depth_one() {
        let r = global_eval("[1, [2, [3]]].flat().join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// `Array.prototype.flat` with depth 0 (no flattening).
    #[test]
    fn e2e_array_flat_depth_zero() {
        let r = global_eval("[1, [2, 3]].flat(0).length").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// `Array.prototype.flat` with depth 2.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flat_depth_two() {
        let r = global_eval("[1, [2, [3, [4]]]].flat(2).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3,4".into()));
    }

    /// `Array.prototype.flat` with Infinity depth.
    #[test]
    fn e2e_array_flat_infinity_deep() {
        let r = global_eval("[1, [2, [3, [4, [5]]]]].flat(Infinity).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3,4,5".into()));
    }

    /// `Array.prototype.flatMap` maps and flattens one level.
    #[test]
    fn e2e_array_flatmap_basic() {
        let r =
            global_eval("[1, 2, 3].flatMap(function(x) { return [x, x * 2]; }).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,2,4,3,6".into()));
    }

    /// `Array.prototype.flatMap` returns non-array values as-is.
    #[test]
    fn e2e_array_flatmap_non_array_return() {
        let r = global_eval("[1, 2, 3].flatMap(function(x) { return x * 10; }).join(',')").unwrap();
        assert_eq!(r, JsValue::String("10,20,30".into()));
    }

    /// `Array.from` honors `thisArg` for `mapFn`.
    #[test]
    fn e2e_array_from_mapfn_this_arg() {
        let r = global_eval(
            "var ctx = { mult: 3 }; \
             Array.from([1, 2, 3], function(v, i) { return v * this.mult + i; }, ctx).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("3,7,11".into()));
    }

    /// `Array.from` prefers the iterable protocol for custom iterables.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_from_custom_iterable() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var i = 0;
                return {
                    next: function() {
                        i++;
                        return i <= 3 ? { value: i * 10, done: false } : { done: true };
                    }
                };
            };
            Array.from(obj).join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("10,20,30".into()));
    }

    /// `Array.from` supports `Map` iterables.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_from_map_iterable() {
        let r = global_eval(
            "Array.from(new Map([['a', 1], ['b', 2]])).map(function(pair) { return pair[0] + pair[1]; }).join('|')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a1|b2".into()));
    }

    /// `Array.from` supports proxy-wrapped array-like objects.
    #[test]
    fn e2e_array_from_proxy_array_like() {
        let r = global_eval(
            "var p = new Proxy({ 0: 'x', 1: 'y', length: 2 }, {}); Array.from(p).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("x,y".into()));
    }

    /// `Array.of` preserves argument order.
    #[test]
    fn e2e_array_of_preserves_order() {
        let r = global_eval("Array.of('a', 'b', 'c').join(',')").unwrap();
        assert_eq!(r, JsValue::String("a,b,c".into()));
    }

    /// `Array.of` does not treat a single numeric argument as a length.
    #[test]
    fn e2e_array_of_single_numeric_is_value() {
        let r = global_eval("Array.of(7).length * 10 + Array.of(7)[0]").unwrap();
        assert_eq!(r, JsValue::Smi(17));
    }

    /// `Array.isArray` returns true for a proxy targeting an array.
    #[test]
    fn e2e_array_is_array_proxy_target_array() {
        let r = global_eval("Array.isArray(new Proxy([], {}))").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Array.isArray` returns false for a proxy targeting a plain object.
    #[test]
    fn e2e_array_is_array_proxy_target_object() {
        let r = global_eval("Array.isArray(new Proxy({ length: 0 }, {}))").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.isArray` throws on revoked proxies.
    #[test]
    fn e2e_array_is_array_revoked_proxy_throws() {
        let r = global_eval(
            "var rev = Proxy.revocable([], {}); rev.revoke(); \
             try { Array.isArray(rev.proxy); false; } catch (e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `flat` treats negative depth like zero.
    #[test]
    fn e2e_array_flat_negative_depth() {
        let r = global_eval("[1, [2, 3]].flat(-1).length").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// `flat` is generic over array-like receivers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flat_array_like_receiver() {
        let r = global_eval("Array.prototype.flat.call({ 0: [1, 2], 1: 3, length: 2 }).join(',')")
            .unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// `flatMap` honors `thisArg`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flatmap_this_arg() {
        let r = global_eval(
            "var ctx = { mult: 4 }; \
             [1, 2].flatMap(function(v) { return [v * this.mult]; }, ctx).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("4,8".into()));
    }

    /// `flatMap` is generic over array-like receivers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flatmap_array_like_receiver() {
        let r = global_eval(
            "Array.prototype.flatMap.call({ 0: 2, 1: 3, length: 2 }, function(v) { return [v, v + 1]; }).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2,3,3,4".into()));
    }

    /// `at` accepts negative indices from the end.
    #[test]
    fn e2e_array_at_negative_boundary() {
        let r = global_eval("[10, 20, 30].at(-3)").unwrap();
        assert_eq!(r, JsValue::Smi(10));
    }

    /// `at` returns undefined when a negative index is still out of range.
    #[test]
    fn e2e_array_at_negative_too_small() {
        let r = global_eval("[10, 20, 30].at(-4)").unwrap();
        assert_eq!(r, JsValue::Undefined);
    }

    /// `findLast` honors `thisArg`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_find_last_this_arg() {
        let r = global_eval(
            "var ctx = { cutoff: 3 }; \
             [1, 2, 3, 4, 5].findLast(function(v) { return v < this.cutoff; }, ctx)",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// `findLastIndex` works on array-like receivers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_find_last_index_array_like() {
        let r = global_eval(
            "Array.prototype.findLastIndex.call({ 0: 1, 1: 4, 2: 6, length: 3 }, function(v) { return v % 2 === 0; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// `toReversed` is generic over array-like receivers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_to_reversed_array_like() {
        let r = global_eval(
            "Array.prototype.toReversed.call({ 0: 'a', 1: 'b', 2: 'c', length: 3 }).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("c,b,a".into()));
    }

    /// `toSorted` honors a compare callback.
    #[test]
    fn e2e_array_to_sorted_compare_fn() {
        let r =
            global_eval("[3, 1, 2].toSorted(function(a, b) { return b - a; }).join(',')").unwrap();
        assert_eq!(r, JsValue::String("3,2,1".into()));
    }

    /// `toSorted` leaves the original array untouched.
    #[test]
    fn e2e_array_to_sorted_non_mutating() {
        let r =
            global_eval("var a = [3, 1, 2]; var b = a.toSorted(); a.join(',') + '|' + b.join(',')")
                .unwrap();
        assert_eq!(r, JsValue::String("3,1,2|1,2,3".into()));
    }

    /// `toSpliced` handles negative start indices.
    #[test]
    fn e2e_array_to_spliced_negative_start() {
        let r = global_eval("[1, 2, 3, 4].toSpliced(-2, 1, 9).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,9,4".into()));
    }

    /// `with` is generic over array-like receivers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_with_array_like_receiver() {
        let r = global_eval(
            "Array.prototype.with.call({ 0: 'a', 1: 'b', length: 2 }, 1, 'z').join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a,z".into()));
    }

    /// `with` throws on negative out-of-range indices.
    #[test]
    fn e2e_array_with_negative_out_of_bounds() {
        let r = global_eval(
            "try { [1, 2].with(-3, 0); false; } catch (e) { e instanceof RangeError; }",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_at_array_like_negative_index() {
        assert_eval_true("Array.prototype.at.call({ 0: 'a', 1: 'b', length: 2 }, -1) === 'b'");
    }

    #[test]
    fn e2e_array_at_string_index_truncates() {
        assert_eval_true("[10, 20, 30].at('1.9') === 20");
    }

    #[test]
    fn e2e_array_at_nan_defaults_to_zero() {
        assert_eval_true("[10, 20, 30].at(NaN) === 10");
    }

    #[test]
    fn e2e_array_at_infinity_returns_undefined() {
        assert_eval_true("[10, 20, 30].at(Infinity) === undefined");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_at_array_like_missing_slot_returns_undefined() {
        assert_eval_true("Array.prototype.at.call({ length: 1 }, 0) === undefined");
    }

    #[test]
    fn e2e_array_find_last_visits_holes() {
        assert_eval_true(
            "var seen = []; [, 1].findLast(function(v, i) { seen.push(i + ':' + String(v)); return false; }); seen.join('|') === '1:1|0:undefined'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_find_last_array_like_visits_missing_indices() {
        assert_eval_true(
            "var seen = []; Array.prototype.findLast.call({ 2: 3, length: 3 }, function(v, i) { seen.push(i + ':' + String(v)); return false; }); seen.join('|') === '2:3|1:undefined|0:undefined'",
        );
    }

    #[test]
    fn e2e_array_find_last_index_can_match_hole_as_undefined() {
        assert_eval_true("[1, , 3].findLastIndex(function(v) { return v === undefined; }) === 1");
    }

    #[test]
    fn e2e_array_find_last_index_reverse_searches() {
        assert_eval_true("[1, 2, 3, 4].findLastIndex(function(v) { return v % 2 === 0; }) === 3");
    }

    #[test]
    fn e2e_array_find_last_non_callable_throws() {
        assert_eval_true(
            "try { [1].findLast(null); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_array_find_last_index_non_callable_throws() {
        assert_eval_true(
            "try { [1].findLastIndex(null); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_array_to_reversed_materializes_holes_as_undefined() {
        assert_eval_true(
            "var r = [1, , 3].toReversed(); r.length === 3 && r[0] === 3 && r[1] === undefined && r[2] === 1 && Object.hasOwn(r, '1')",
        );
    }

    #[test]
    fn e2e_array_to_reversed_leaves_sparse_source_unchanged() {
        assert_eval_true(
            "var a = [1, , 3]; a.toReversed(); a.join(',') === '1,,3' && !Object.hasOwn(a, '1')",
        );
    }

    #[test]
    fn e2e_array_to_reversed_ignores_symbol_species() {
        assert_eval_true(
            "var hits = 0; var a = [1, 2, 3]; var ctor = {}; Object.defineProperty(ctor, Symbol.species, { get: function() { hits++; return function() { return ['bad']; }; } }); a.constructor = ctor; var r = a.toReversed(); hits === 0 && Array.isArray(r) && r.join(',') === '3,2,1'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_to_reversed_propagates_length_errors() {
        assert_eval_true(
            "var p = new Proxy({ length: 1 }, { get: function(target, key) { if (key === 'length') throw new Error('boom'); return target[key]; } }); try { Array.prototype.toReversed.call(p); false; } catch (e) { e.message === 'boom'; }",
        );
    }

    #[test]
    fn e2e_array_to_sorted_default_is_lexicographic() {
        assert_eval_true("[1, 10, 2].toSorted().join(',') === '1,10,2'");
    }

    #[test]
    fn e2e_array_to_sorted_descending_compare_fn() {
        assert_eval_true(
            "[3, 1, 2].toSorted(function(a, b) { return b - a; }).join(',') === '3,2,1'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_to_sorted_non_callable_comparefn_throws_even_for_singleton() {
        assert_eval_true(
            "try { [1].toSorted(null); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_array_to_sorted_undefined_comparefn_is_allowed() {
        assert_eval_true("[1].toSorted(undefined)[0] === 1");
    }

    #[test]
    fn e2e_array_to_sorted_ignores_symbol_species() {
        assert_eval_true(
            "var hits = 0; var a = [3, 1, 2]; var ctor = {}; Object.defineProperty(ctor, Symbol.species, { get: function() { hits++; return function() { return ['bad']; }; } }); a.constructor = ctor; var r = a.toSorted(); hits === 0 && Array.isArray(r) && r.join(',') === '1,2,3'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_to_sorted_propagates_length_errors() {
        assert_eval_true(
            "var p = new Proxy({ 0: 2, 1: 1, length: 2 }, { get: function(target, key) { if (key === 'length') throw new Error('boom'); return target[key]; } }); try { Array.prototype.toSorted.call(p); false; } catch (e) { e.message === 'boom'; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_to_sorted_array_like_receiver() {
        assert_eval_true(
            "Array.prototype.toSorted.call({ 0: 'b', 1: 'a', length: 2 }).join(',') === 'a,b'",
        );
    }

    #[test]
    fn e2e_array_to_spliced_omitted_delete_count_removes_to_end() {
        assert_eval_true("[1, 2, 3].toSpliced(1).join(',') === '1'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_to_spliced_undefined_delete_count_is_zero() {
        assert_eval_true("[1, 2, 3].toSpliced(1, undefined, 9).join(',') === '1,9,2,3'");
    }

    #[test]
    fn e2e_array_to_spliced_negative_start_clamps_to_zero() {
        assert_eval_true("[1, 2, 3].toSpliced(-99, 1, 8).join(',') === '8,2,3'");
    }

    #[test]
    fn e2e_array_to_spliced_can_insert_at_end() {
        assert_eval_true("[1, 2].toSpliced(2, 0, 3, 4).join(',') === '1,2,3,4'");
    }

    #[test]
    fn e2e_array_to_spliced_ignores_symbol_species() {
        assert_eval_true(
            "var hits = 0; var a = [1, 2, 3]; var ctor = {}; Object.defineProperty(ctor, Symbol.species, { get: function() { hits++; return function() { return ['bad']; }; } }); a.constructor = ctor; var r = a.toSpliced(1, 1, 9); hits === 0 && Array.isArray(r) && r.join(',') === '1,9,3'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_to_spliced_propagates_length_errors() {
        assert_eval_true(
            "var p = new Proxy({ 0: 1, length: 1 }, { get: function(target, key) { if (key === 'length') throw new Error('boom'); return target[key]; } }); try { Array.prototype.toSpliced.call(p, 0, 0, 9); false; } catch (e) { e.message === 'boom'; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_to_spliced_array_like_receiver() {
        assert_eval_true(
            "Array.prototype.toSpliced.call({ 0: 'a', 1: 'b', length: 2 }, 1, 0, 'x').join(',') === 'a,x,b'",
        );
    }

    #[test]
    fn e2e_array_with_replaces_without_mutating_source() {
        assert_eval_true(
            "var a = [1, 2, 3]; var b = a.with(1, 9); a.join(',') === '1,2,3' && b.join(',') === '1,9,3'",
        );
    }

    #[test]
    fn e2e_array_with_negative_index_replaces_from_end() {
        assert_eval_true("[1, 2, 3].with(-1, 9).join(',') === '1,2,9'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_with_string_index_truncates() {
        assert_eval_true("[1, 2, 3].with('1.9', 9)[1] === 9");
    }

    #[test]
    fn e2e_array_with_positive_out_of_bounds_throws() {
        assert_eval_true(
            "try { [1, 2].with(2, 0); false; } catch (e) { e instanceof RangeError; }",
        );
    }

    #[test]
    fn e2e_array_with_empty_array_throws() {
        assert_eval_true("try { [].with(0, 1); false; } catch (e) { e instanceof RangeError; }");
    }

    #[test]
    fn e2e_array_with_ignores_symbol_species() {
        assert_eval_true(
            "var hits = 0; var a = [1, 2, 3]; var ctor = {}; Object.defineProperty(ctor, Symbol.species, { get: function() { hits++; return function() { return ['bad']; }; } }); a.constructor = ctor; var r = a.with(1, 9); hits === 0 && Array.isArray(r) && r.join(',') === '1,9,3'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flat_skips_holes_in_source_and_nested_arrays() {
        assert_eval_true(
            "Array.prototype.flat.call({ 0: [1, , 2], 2: 3, length: 3 }).join(',') === '1,2,3'",
        );
    }

    #[test]
    fn e2e_array_flat_depth_two_flattens_two_levels() {
        assert_eval_true("[1, [2, [3]]].flat(2).join(',') === '1,2,3'");
    }

    #[test]
    fn e2e_array_flat_infinity_flattens_fully() {
        assert_eval_true("[1, [2, [3, [4]]]].flat(Infinity).join(',') === '1,2,3,4'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flat_propagates_length_errors() {
        assert_eval_true(
            "var p = new Proxy({ length: 1 }, { get: function(target, key) { if (key === 'length') throw new Error('boom'); return target[key]; } }); try { Array.prototype.flat.call(p); false; } catch (e) { e.message === 'boom'; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flatmap_skips_holes_in_source() {
        assert_eval_true(
            "var r = [, 1].flatMap(function(v) { return [v]; }); r.length === 1 && r[0] === 1",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flatmap_skips_holes_in_returned_arrays() {
        assert_eval_true(
            "var r = [1].flatMap(function() { return [, 2]; }); r.length === 1 && r[0] === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flatmap_array_like_receiver_skips_missing_slots() {
        assert_eval_true(
            "var r = Array.prototype.flatMap.call({ 1: 2, length: 2 }, function(v) { return [v]; }); r.length === 1 && r[0] === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_flatmap_propagates_length_errors() {
        assert_eval_true(
            "var p = new Proxy({ length: 1 }, { get: function(target, key) { if (key === 'length') throw new Error('boom'); return target[key]; } }); try { Array.prototype.flatMap.call(p, function(v) { return [v]; }); false; } catch (e) { e.message === 'boom'; }",
        );
    }

    #[test]
    fn e2e_array_from_prefers_iterator_over_length() {
        assert_eval_true(
            "var obj = { 0: 'x', length: 1 }; obj[Symbol.iterator] = function() { var done = false; return { next: function() { if (done) return { done: true }; done = true; return { value: 'iter', done: false }; } }; }; Array.from(obj).join(',') === 'iter'",
        );
    }

    #[test]
    fn e2e_array_from_mapfn_visits_missing_array_like_indices_as_undefined() {
        assert_eval_true(
            "var seen = []; Array.from({ 1: 'x', length: 3 }, function(v, i) { seen.push(i + ':' + String(v)); return v; }); seen.join('|') === '0:undefined|1:x|2:undefined'",
        );
    }

    #[test]
    fn e2e_array_from_sparse_array_like_materializes_undefined_slots() {
        assert_eval_true(
            "var a = Array.from({ 1: 'x', length: 3 }); a.length === 3 && a[0] === undefined && a[1] === 'x' && a[2] === undefined && Object.hasOwn(a, '0') && Object.hasOwn(a, '2')",
        );
    }

    #[test]
    fn e2e_array_from_non_callable_mapfn_throws_even_for_empty_input() {
        assert_eval_true(
            "try { Array.from({ length: 0 }, null); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    fn e2e_array_from_string_mapfn_with_this_arg() {
        assert_eval_true(
            "Array.from('ab', function(ch, i) { return this.prefix + ch + i; }, { prefix: '_' }).join('|') === '_a0|_b1'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_from_set_preserves_iteration_order() {
        assert_eval_true("Array.from(new Set([3, 1, 3])).join(',') === '3,1'");
    }

    #[test]
    fn e2e_array_of_no_args_returns_empty_array() {
        assert_eval_true("Array.of().length === 0");
    }

    #[test]
    fn e2e_array_of_preserves_undefined_and_null() {
        assert_eval_true(
            "var a = Array.of(undefined, null, 'x'); a.length === 3 && a[0] === undefined && a[1] === null && a[2] === 'x'",
        );
    }

    /// `Array.prototype.group` must not exist (removed Stage 3 TC39 proposal).
    #[test]
    fn e2e_array_group_does_not_exist() {
        let r = global_eval("typeof [].group").unwrap();
        assert_eq!(r, JsValue::String("undefined".into()));
    }

    /// `Array.prototype.groupToMap` must not exist (removed Stage 3 TC39 proposal).
    #[test]
    fn e2e_array_group_to_map_does_not_exist() {
        let r = global_eval("typeof [].groupToMap").unwrap();
        assert_eq!(r, JsValue::String("undefined".into()));
    }

    /// `Array.prototype[Symbol.iterator]` aliases `values`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_symbol_iterator_aliases_values() {
        let r = global_eval("Array.prototype[Symbol.iterator] === Array.prototype.values").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Array.prototype[Symbol.iterator]()` yields array values.
    #[test]
    fn e2e_array_symbol_iterator_yields_values() {
        let r = global_eval("Array.from([4, 5][Symbol.iterator]()).join(',')").unwrap();
        assert_eq!(r, JsValue::String("4,5".into()));
    }

    /// `keys()` yields all indices in order.
    #[test]
    fn e2e_array_keys_iterator_values() {
        let r = global_eval("Array.from(['a', 'b', 'c'].keys()).join(',')").unwrap();
        assert_eq!(r, JsValue::String("0,1,2".into()));
    }

    /// `values()` yields array contents in order.
    #[test]
    fn e2e_array_values_iterator_values() {
        let r = global_eval("Array.from(['a', 'b', 'c'].values()).join(',')").unwrap();
        assert_eq!(r, JsValue::String("a,b,c".into()));
    }

    /// `entries()` yields `[index, value]` pairs.
    #[test]
    fn e2e_array_entries_iterator_pairs() {
        let r = global_eval(
            "Array.from(['a', 'b'].entries()).map(function(pair) { return pair[0] + ':' + pair[1]; }).join('|')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0:a|1:b".into()));
    }

    /// `keys()` is generic over array-like receivers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_keys_array_like_receiver() {
        let r = global_eval(
            "Array.from(Array.prototype.keys.call({ 0: 'a', 2: 'c', length: 3 })).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0,1,2".into()));
    }

    /// `values()` is generic over array-like receivers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_values_array_like_receiver() {
        let r = global_eval(
            "Array.from(Array.prototype.values.call({ 0: 'a', 2: 'c', length: 3 })).join(',')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a,,c".into()));
    }

    /// `entries()` is generic over array-like receivers.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_entries_array_like_receiver() {
        let r = global_eval(
            "Array.from(Array.prototype.entries.call({ 0: 'a', 2: 'c', length: 3 }))\
             .map(function(pair) { return pair[0] + ':' + pair[1]; }).join('|')",
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0:a|1:undefined|2:c".into()));
    }

    /// `Array.prototype.every` returns true for empty arrays.
    #[test]
    fn e2e_array_every_empty() {
        let r = global_eval("[].every(function() { return false; })").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Array.prototype.every` short-circuits on first false.
    #[test]
    fn e2e_array_every_short_circuit() {
        let r = global_eval(
            r#"
            var count = 0;
            [1, 2, 3, 4, 5].every(function(x) { count++; return x < 3; });
            count
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// `Array.prototype.some` returns false for empty arrays.
    #[test]
    fn e2e_array_some_empty() {
        let r = global_eval("[].some(function() { return true; })").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.prototype.some` short-circuits on first true.
    #[test]
    fn e2e_array_some_short_circuit() {
        let r = global_eval(
            r#"
            var count = 0;
            [1, 2, 3, 4, 5].some(function(x) { count++; return x === 2; });
            count
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// `Array.prototype.fill` with start and end.
    #[test]
    fn e2e_array_fill_start_end() {
        let r = global_eval("[1,2,3,4,5].fill(0, 1, 3).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,0,0,4,5".into()));
    }

    /// `Array.prototype.fill` with negative start.
    #[test]
    fn e2e_array_fill_negative_start() {
        let r = global_eval("[1,2,3,4].fill(9, -2).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,9,9".into()));
    }

    /// `Array.prototype.fill` with negative end.
    #[test]
    fn e2e_array_fill_negative_end() {
        let r = global_eval("[1,2,3,4].fill(0, 0, -2).join(',')").unwrap();
        assert_eq!(r, JsValue::String("0,0,3,4".into()));
    }

    /// `Array.prototype.fill` with no start/end fills entire array.
    #[test]
    fn e2e_array_fill_entire() {
        let r = global_eval("[1,2,3].fill(7).join(',')").unwrap();
        assert_eq!(r, JsValue::String("7,7,7".into()));
    }

    /// `Array.prototype.copyWithin` basic positive indices.
    #[test]
    fn e2e_array_copywithin_basic() {
        let r = global_eval("[1,2,3,4,5].copyWithin(0, 3).join(',')").unwrap();
        assert_eq!(r, JsValue::String("4,5,3,4,5".into()));
    }

    /// `Array.prototype.copyWithin` with negative target.
    #[test]
    fn e2e_array_copywithin_negative_target() {
        let r = global_eval("[1,2,3,4,5].copyWithin(-2, 0, 2).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3,1,2".into()));
    }

    /// `Array.prototype.copyWithin` with all negative indices.
    #[test]
    fn e2e_array_copywithin_negative_start() {
        let r = global_eval("[1,2,3,4,5].copyWithin(0, -2).join(',')").unwrap();
        assert_eq!(r, JsValue::String("4,5,3,4,5".into()));
    }

    /// `Array.prototype.includes` finds NaN (SameValueZero).
    #[test]
    fn e2e_array_includes_nan() {
        let r = global_eval("[1, NaN, 3].includes(NaN)").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Array.prototype.includes` with fromIndex.
    #[test]
    fn e2e_array_includes_from_index() {
        let r = global_eval("[1, 2, 3, 4].includes(2, 2)").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.prototype.includes` with negative fromIndex.
    #[test]
    fn e2e_array_includes_negative_from_index() {
        let r = global_eval("[1, 2, 3].includes(1, -1)").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.prototype.includes` finds value at negative fromIndex.
    #[test]
    fn e2e_array_includes_negative_from_index_found() {
        let r = global_eval("[1, 2, 3].includes(3, -1)").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Array.isArray` returns true for literal arrays.
    #[test]
    fn e2e_array_isarray_literal() {
        let r = global_eval("Array.isArray([])").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Array.isArray` returns false for non-arrays.
    #[test]
    fn e2e_array_isarray_object() {
        let r = global_eval("Array.isArray({length: 0})").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.isArray` returns false for string.
    #[test]
    fn e2e_array_isarray_string() {
        let r = global_eval(r#"Array.isArray("abc")"#).unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.isArray` on `Array.prototype` returns true (per spec).
    #[test]
    fn e2e_array_isarray_prototype() {
        let r = global_eval("Array.isArray(Array.prototype)").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Array.prototype.every` with all elements passing.
    #[test]
    fn e2e_array_every_all_pass() {
        let r = global_eval("[2, 4, 6].every(function(x) { return x % 2 === 0; })").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `Array.prototype.some` with no match.
    #[test]
    fn e2e_array_some_no_match() {
        let r = global_eval("[1, 3, 5].some(function(x) { return x % 2 === 0; })").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.prototype.some` with match.
    #[test]
    fn e2e_array_some_match() {
        let r = global_eval("[1, 2, 3].some(function(x) { return x === 2; })").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── Sparse array holes conformance ───────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_map_preserves_hole() {
        assert_eval_true(
            "var r = [1, , 3].map(function(x) { return x * 2; }); r.length === 3 && r[0] === 2 && r[2] === 6 && !Object.hasOwn(r, '1')",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_map_skips_hole_callback() {
        assert_eval_true(
            "var seen = []; [1, , 3].map(function(x, i) { seen.push(i + ':' + x); return x * 2; }); seen.join('|') === '0:1|2:3'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_map_passes_original_array() {
        assert_eval_true(
            "var arr = [1, , 3]; var ok = true; arr.map(function(_x, i, a) { ok = ok && a === arr && (i === 0 || i === 2); return i; }); ok",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_filter_skips_hole_and_compacts() {
        assert_eval_true(
            "var r = [1, , 3].filter(function() { return true; }); r.length === 2 && r[0] === 1 && r[1] === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_filter_skips_hole_callback() {
        assert_eval_true(
            "var seen = []; [1, , 3].filter(function(x, i) { seen.push(i + ':' + x); return true; }); seen.join('|') === '0:1|2:3'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_for_each_skips_hole() {
        assert_eval_true(
            "var seen = []; [1, , 3].forEach(function(x, i) { seen.push(i + ':' + x); }); seen.join('|') === '0:1|2:3'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_for_each_passes_original_array() {
        assert_eval_true(
            "var arr = [1, , 3]; var ok = true; arr.forEach(function(_x, _i, a) { ok = ok && a === arr; }); ok",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_every_skips_hole() {
        assert_eval_true(
            "var seen = []; var ok = [1, , 3].every(function(x, i) { seen.push(i + ':' + x); return x > 0; }); ok && seen.join('|') === '0:1|2:3'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_every_all_holes_never_calls_callback() {
        assert_eval_true(
            "var count = 0; Array(3).every(function() { count++; return false; }) && count === 0",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_some_skips_hole() {
        assert_eval_true(
            "var seen = []; var ok = [1, , 3].some(function(x, i) { seen.push(i + ':' + x); return x === 3; }); ok && seen.join('|') === '0:1|2:3'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_some_all_holes_never_calls_callback() {
        assert_eval_true(
            "var count = 0; !Array(2).some(function() { count++; return true; }) && count === 0",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_reduce_skips_hole_with_initial() {
        assert_eval_true("[1, , 3].reduce(function(acc, x) { return acc + x; }, 0) === 4");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_reduce_skips_leading_hole_without_initial() {
        assert_eval_true("[, 2, 3].reduce(function(acc, x) { return acc + x; }) === 5");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_reduce_all_holes_without_initial_throws() {
        assert_eval_true(
            "try { Array(3).reduce(function(acc, x) { return acc + x; }); false; } catch (e) { e instanceof TypeError; }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_indexof_undefined_ignores_hole() {
        assert_eval_true("[1, , 3].indexOf(undefined) === -1");
    }

    #[test]
    fn e2e_sparse_array_indexof_undefined_finds_explicit_undefined() {
        assert_eval_true("var a = [1, , 3]; a[1] = undefined; a.indexOf(undefined) === 1");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_sparse_array_includes_undefined_ignores_hole() {
        assert_eval_true("[1, , 3].includes(undefined) === false");
    }

    #[test]
    fn e2e_sparse_array_includes_undefined_finds_explicit_undefined() {
        assert_eval_true("var a = [1, , 3]; a[1] = undefined; a.includes(undefined) === true");
    }

    #[test]
    fn e2e_array_constructor_call_creates_sparse_length() {
        assert_eval_true("var a = Array(5); a.length === 5 && Object.keys(a).length === 0");
    }

    #[test]
    fn e2e_array_constructor_new_creates_sparse_length() {
        assert_eval_true("var a = new Array(5); a.length === 5 && Object.keys(a).length === 0");
    }

    #[test]
    fn e2e_array_constructor_has_no_index_property() {
        assert_eval_true("var a = Array(5); !(0 in a) && !(4 in a)");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_constructor_iterator_materializes_undefined() {
        assert_eval_true("Array.from(Array(3)).join('|') === 'undefined|undefined|undefined'");
    }

    #[test]
    fn e2e_array_literal_only_holes_length_is_preserved() {
        assert_eval_true("[,,].length === 2");
    }

    #[test]
    fn e2e_array_literal_trailing_elision_preserves_length() {
        assert_eval_true("[1,,].length === 2");
    }

    #[test]
    fn e2e_delete_creates_hole() {
        assert_eval_true("var a = [1, 2, 3]; delete a[1]; a[1] === undefined && !(1 in a)");
    }

    #[test]
    fn e2e_delete_keeps_length() {
        assert_eval_true("var a = [1, 2, 3]; delete a[1]; a.length === 3");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_delete_hole_skips_indexof_undefined() {
        assert_eval_true("var a = [1, 2, 3]; delete a[1]; a.indexOf(undefined) === -1");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_delete_hole_map_preserves_hole() {
        assert_eval_true(
            "var a = [1, 2, 3]; delete a[1]; var r = a.map(function(x) { return x * 2; }); r.length === 3 && r[0] === 2 && r[2] === 6 && !Object.hasOwn(r, '1')",
        );
    }

    #[test]
    fn e2e_array_from_sparse_array_materializes_undefined() {
        assert_eval_true("var a = Array.from([1, , 3]); a.length === 3 && a[1] === undefined");
    }

    #[test]
    fn e2e_array_from_sparse_array_creates_dense_slot() {
        assert_eval_true("var a = Array.from([1, , 3]); Object.hasOwn(a, '1')");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_spread_sparse_array_materializes_undefined() {
        assert_eval_true("var a = [...[1, , 3]]; a.length === 3 && a[1] === undefined");
    }

    #[test]
    fn e2e_spread_sparse_array_creates_dense_slot() {
        assert_eval_true("var a = [...[1, , 3]]; Object.hasOwn(a, '1')");
    }

    #[test]
    fn e2e_for_of_sparse_array_yields_undefined_for_hole() {
        assert_eval_true(
            "var seen = []; for (var value of [1, , 3]) { seen.push(String(value)); } seen.join('|') === '1|undefined|3'",
        );
    }

    #[test]
    fn e2e_for_of_array_constructor_yields_undefined_for_holes() {
        assert_eval_true(
            "var seen = []; for (var value of Array(2)) { seen.push(String(value)); } seen.join('|') === 'undefined|undefined'",
        );
    }

    #[test]
    fn e2e_object_keys_sparse_array_skips_hole() {
        assert_eval_true("Object.keys([1, , 3]).join(',') === '0,2'");
    }

    #[test]
    fn e2e_object_keys_array_constructor_has_no_indices() {
        assert_eval_true("Object.keys(Array(3)).length === 0");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_sparse_array_uses_null_for_hole() {
        assert_eval_true("JSON.stringify([1, , 3]) === '[1,null,3]'");
    }

    // ΓöÇΓöÇ Error and exception handling conformance ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ

    /// try/catch ΓÇö catch receives the thrown Error object's message.
    #[test]
    fn e2e_try_catch_error_message() {
        let r =
            global_eval(r#"try { throw new Error("boom"); } catch (e) { e.message; }"#).unwrap();
        assert_eq!(r, JsValue::String("boom".into()));
    }

    /// try/catch/finally ΓÇö finally always runs and its side-effect is visible.
    #[test]
    fn e2e_finally_always_runs() {
        let r = global_eval(
            r#"
            var x = 0;
            try { x = 1; } finally { x = 2; }
            x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// finally runs even when an exception is thrown.
    #[test]
    fn e2e_finally_runs_on_throw() {
        let r = global_eval(
            r#"
            var x = 0;
            try {
                try { throw new Error("e"); } finally { x = 99; }
            } catch (e) {}
            x;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    /// finally overrides the return value from try block.
    #[test]
    #[ignore] // TODO: hangs in CI – fix finally-return interaction
    fn e2e_finally_overrides_return() {
        let r = global_eval(
            r#"
            function f() {
                try { return 1; } finally { return 2; }
            }
            f();
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// finally overrides the return value from catch block.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_finally_overrides_catch_return() {
        let r = global_eval(
            r#"
            function f() {
                try { throw new Error("e"); } catch (e) { return 3; } finally { return 4; }
            }
            f();
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(4));
    }

    /// Catch binding is optional (catch without parameter).
    #[test]
    fn e2e_catch_binding_optional() {
        let r = global_eval(
            r#"
            var caught = false;
            try { throw new Error("e"); } catch { caught = true; }
            caught;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// throw a number ΓÇö catch receives the numeric value.
    #[test]
    fn e2e_throw_number() {
        let r = global_eval("try { throw 42; } catch (e) { e; }").unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// throw a string ΓÇö catch receives the string value.
    #[test]
    fn e2e_throw_string() {
        let r = global_eval(r#"try { throw "oops"; } catch (e) { e; }"#).unwrap();
        assert_eq!(r, JsValue::String("oops".into()));
    }

    /// throw null ΓÇö catch receives null.
    #[test]
    fn e2e_throw_null() {
        let r = global_eval("try { throw null; } catch (e) { e === null; }").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// throw undefined ΓÇö catch receives undefined.
    #[test]
    fn e2e_throw_undefined() {
        let r = global_eval("try { throw undefined; } catch (e) { e === undefined; }").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// throw boolean ΓÇö catch receives the boolean value.
    #[test]
    fn e2e_throw_boolean() {
        let r = global_eval("try { throw false; } catch (e) { e; }").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// throw an object literal ΓÇö catch receives the object.
    #[test]
    fn e2e_throw_object() {
        let r = global_eval(r#"try { throw { code: 42 }; } catch (e) { e.code; }"#).unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Re-throw in catch preserves the original error.
    #[test]
    fn e2e_rethrow_preserves_error() {
        let r = global_eval(
            r#"
            try {
                try { throw new Error("original"); }
                catch (e) { throw e; }
            } catch (outer) {
                outer.message;
            }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("original".into()));
    }

    /// Re-throw a primitive value in catch preserves the value.
    #[test]
    fn e2e_rethrow_primitive() {
        let r = global_eval(
            r#"
            try {
                try { throw 99; }
                catch (e) { throw e; }
            } catch (outer) {
                outer;
            }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    /// Nested try/catch ΓÇö inner catch handles, outer does not see it.
    #[test]
    fn e2e_nested_try_catch_inner_handles() {
        let r = global_eval(
            r#"
            var outer_caught = false;
            try {
                try { throw new Error("inner"); }
                catch (e) { /* swallow */ }
            } catch (e) {
                outer_caught = true;
            }
            outer_caught;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Nested try/catch ΓÇö inner does not catch, outer catches.
    #[test]
    fn e2e_nested_try_outer_catches() {
        let r = global_eval(
            r#"
            var which = "none";
            try {
                try { throw new Error("e"); }
                finally { /* no catch, exception propagates */ }
            } catch (e) {
                which = "outer";
            }
            which;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("outer".into()));
    }

    /// try/finally without catch ΓÇö finally runs, exception propagates.
    #[test]
    fn e2e_try_finally_no_catch_propagates() {
        let r = global_eval(
            r#"
            var fin = false;
            try {
                try { throw new Error("propagate"); }
                finally { fin = true; }
            } catch (e) {}
            fin;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// new Error() with no message ΓÇö message defaults to empty string.
    #[test]
    fn e2e_error_no_message() {
        let r = global_eval(r#"var e = new Error(); e.message === "" || e.message === undefined;"#)
            .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Error.prototype.stack is a string (non-standard but expected).
    #[test]
    fn e2e_error_prototype_stack_is_string() {
        let r = global_eval("typeof new Error('test').stack === 'string'").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Error stack trace contains the error message.
    #[test]
    fn e2e_error_stack_contains_message() {
        let r = global_eval(r#"new Error("hello").stack.indexOf("hello") !== -1"#).unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Error.prototype.name is "Error".
    #[test]
    fn e2e_error_name_property_builtin() {
        let r = global_eval("new Error('x').name").unwrap();
        assert_eq!(r, JsValue::String("Error".into()));
    }

    /// TypeError.prototype.name is "TypeError".
    #[test]
    fn e2e_type_error_name_property() {
        let r = global_eval("new TypeError('x').name").unwrap();
        assert_eq!(r, JsValue::String("TypeError".into()));
    }

    /// RangeError.prototype.name is "RangeError".
    #[test]
    fn e2e_range_error_name_property() {
        let r = global_eval("new RangeError('x').name").unwrap();
        assert_eq!(r, JsValue::String("RangeError".into()));
    }

    /// instanceof correctly identifies Error subtypes.
    #[test]
    fn e2e_error_instanceof() {
        let r = global_eval(
            r#"
            var te = new TypeError("t");
            te instanceof TypeError && te instanceof Error;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Error.prototype.toString returns "ErrorName: message".
    #[test]
    fn e2e_error_to_string_builtin() {
        let r = global_eval(r#"new Error("fail").toString()"#).unwrap();
        assert_eq!(r, JsValue::String("Error: fail".into()));
    }

    /// TypeError.prototype.toString returns "TypeError: message".
    #[test]
    fn e2e_type_error_to_string() {
        let r = global_eval(r#"new TypeError("bad").toString()"#).unwrap();
        assert_eq!(r, JsValue::String("TypeError: bad".into()));
    }

    /// Catching a TypeError thrown by the engine (e.g., calling non-function).
    #[test]
    fn e2e_catch_engine_type_error() {
        let r = global_eval(
            r#"
            try {
                var x = 1;
                x();
            } catch (e) {
                e instanceof TypeError;
            }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Custom error subclass via class extends Error.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_custom_error_subclass() {
        let r = global_eval(
            r#"
            class MyError extends Error {
                constructor(msg) { super(msg); this.name = "MyError"; }
            }
            var e = new MyError("custom");
            e.name + ": " + e.message;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("MyError: custom".into()));
    }

    /// Custom error subclass ΓÇö instanceof checks.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_custom_error_instanceof() {
        let r = global_eval(
            r#"
            class AppError extends Error {
                constructor(msg) { super(msg); this.name = "AppError"; }
            }
            var e = new AppError("app");
            e instanceof AppError && e instanceof Error;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// try/catch/finally ΓÇö all three execute in order.
    #[test]
    fn e2e_try_catch_finally_order() {
        let r = global_eval(
            r#"
            var log = "";
            try { log += "T"; throw new Error("e"); }
            catch (e) { log += "C"; }
            finally { log += "F"; }
            log;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("TCF".into()));
    }

    /// finally runs even when no exception is thrown (try/finally path).
    #[test]
    fn e2e_try_finally_no_exception() {
        let r = global_eval(
            r#"
            var log = "";
            try { log += "T"; } finally { log += "F"; }
            log;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("TF".into()));
    }

    /// Exception in catch block is caught by outer try/catch.
    #[test]
    fn e2e_exception_in_catch_caught_by_outer() {
        let r = global_eval(
            r#"
            try {
                try { throw 1; }
                catch (e) { throw 2; }
            } catch (outer) {
                outer;
            }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// finally runs when catch rethrows.
    #[test]
    fn e2e_finally_runs_when_catch_rethrows() {
        let r = global_eval(
            r#"
            var fin = false;
            try {
                try { throw new Error("e"); }
                catch (e) { throw e; }
                finally { fin = true; }
            } catch (e) {}
            fin;
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// throw inside finally replaces the original exception.
    #[test]
    fn e2e_throw_in_finally_replaces_exception() {
        let r = global_eval(
            r#"
            try {
                try { throw new Error("first"); }
                finally { throw new Error("second"); }
            } catch (e) {
                e.message;
            }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("second".into()));
    }

    // ΓöÇΓöÇ Generator and iterator protocol conformance ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ

    /// Generator.prototype.next() basic ΓÇö yields values in order.
    #[test]
    fn e2e_generator_next_basic() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; yield 2; yield 3; }
            var g = gen();
            var a = g.next();
            var b = g.next();
            var c = g.next();
            var d = g.next();
            a.value + ',' + a.done + ',' +
            b.value + ',' + b.done + ',' +
            c.value + ',' + c.done + ',' +
            String(d.value) + ',' + d.done
            "#,
        )
        .unwrap();
        assert_eq!(
            r,
            JsValue::String("1,false,2,false,3,false,undefined,true".into())
        );
    }

    /// Generator.prototype.next(value) ΓÇö pass values into yield expressions.
    #[test]
    fn e2e_generator_next_with_value() {
        let r = global_eval(
            r#"
            function* gen() {
                var a = yield 'first';
                var b = yield 'second';
                return a + b;
            }
            var g = gen();
            g.next();
            g.next(10);
            g.next(20).value
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(30));
    }

    /// Generator return value ΓÇö `return value` inside generator sets done:true.
    #[test]
    fn e2e_generator_return_value() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; return 42; yield 3; }
            var g = gen();
            var a = g.next();
            var b = g.next();
            var c = g.next();
            a.value + ',' + a.done + ',' +
            b.value + ',' + b.done + ',' +
            String(c.value) + ',' + c.done
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,false,42,true,undefined,true".into()));
    }

    /// Generator.prototype.return(value) ΓÇö early termination.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_return_method() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; yield 2; yield 3; }
            var g = gen();
            var a = g.next();
            var b = g.return(99);
            var c = g.next();
            a.value + ',' + a.done + ',' +
            b.value + ',' + b.done + ',' +
            String(c.value) + ',' + c.done
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,false,99,true,undefined,true".into()));
    }

    /// Generator.prototype.return on already-completed generator.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_return_on_completed() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; }
            var g = gen();
            g.next();
            g.next();
            var r = g.return(42);
            r.value + ',' + r.done
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("42,true".into()));
    }

    /// Generator.prototype.throw ΓÇö throws into a generator with try/catch.
    #[test]
    fn e2e_generator_throw_with_catch() {
        let r = global_eval(
            r#"
            function* gen() {
                try {
                    yield 1;
                    yield 2;
                } catch(e) {
                    yield 'caught: ' + e;
                }
            }
            var g = gen();
            g.next();
            var r = g.throw('oops');
            r.value
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("caught: oops".into()));
    }

    /// Generator.prototype.throw on a generator without catch propagates error.
    #[test]
    fn e2e_generator_throw_uncaught() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; yield 2; }
            var g = gen();
            g.next();
            try { g.throw('boom'); 'no error'; } catch(e) { 'error: ' + e; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("error: boom".into()));
    }

    /// yield* delegation to an array (iterable).
    #[test]
    fn e2e_yield_star_array() {
        let r = global_eval(
            r#"
            function* gen() { yield* [10, 20, 30]; }
            var g = gen();
            var a = g.next().value;
            var b = g.next().value;
            var c = g.next().value;
            a + ',' + b + ',' + c
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("10,20,30".into()));
    }

    /// yield* delegation to another generator.
    #[test]
    #[ignore] // TODO: hangs in CI – yield* delegation infinite loop
    fn e2e_yield_star_generator() {
        let r = global_eval(
            r#"
            function* inner() { yield 'a'; yield 'b'; }
            function* outer() { yield 1; yield* inner(); yield 2; }
            var r = [];
            var g = outer();
            var step;
            while (!(step = g.next()).done) r.push(step.value);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,a,b,2".into()));
    }

    /// Generator as iterable ΓÇö for-of iterates yielded values.
    #[test]
    fn e2e_generator_for_of() {
        let r = global_eval(
            r#"
            function* gen() { yield 10; yield 20; yield 30; }
            var sum = 0;
            for (var v of gen()) sum += v;
            sum
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(60));
    }

    /// Generator expression ΓÇö `var gen = function*() { ... }`.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_expression() {
        let r = global_eval(
            r#"
            var gen = function*() { yield 1; yield 2; };
            var g = gen();
            g.next().value + ',' + g.next().value
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2".into()));
    }

    /// Infinite generator ΓÇö partial consumption with break.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_infinite_generator() {
        let r = global_eval(
            r#"
            function* count() { var i = 0; while (true) yield i++; }
            var g = count();
            var r = [];
            for (var i = 0; i < 5; i++) r.push(g.next().value);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0,1,2,3,4".into()));
    }

    /// Generator with no yields ΓÇö immediately done.
    #[test]
    fn e2e_generator_no_yields() {
        let r = global_eval(
            r#"
            function* gen() { return 42; }
            var g = gen();
            var a = g.next();
            a.value + ',' + a.done
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("42,true".into()));
    }

    /// Bare yield (no argument) yields undefined.
    #[test]
    fn e2e_generator_bare_yield() {
        let r = global_eval(
            r#"
            function* gen() { yield; yield; }
            var g = gen();
            var a = g.next();
            String(a.value) + ',' + a.done
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("undefined,false".into()));
    }

    /// Generator with arguments passed to the factory function.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_with_arguments() {
        let r = global_eval(
            r#"
            function* range(start, end) {
                for (var i = start; i < end; i++) yield i;
            }
            var r = [];
            for (var v of range(3, 7)) r.push(v);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("3,4,5,6".into()));
    }

    /// Multiple generators can run independently.
    #[test]
    fn e2e_generator_independent_instances() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; yield 2; yield 3; }
            var g1 = gen();
            var g2 = gen();
            var a = g1.next().value;
            var b = g2.next().value;
            var c = g1.next().value;
            var d = g2.next().value;
            a + ',' + b + ',' + c + ',' + d
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,1,2,2".into()));
    }

    /// Generator next() after completion always returns done:true.
    #[test]
    fn e2e_generator_next_after_done() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; }
            var g = gen();
            g.next();
            g.next();
            var a = g.next();
            var b = g.next();
            String(a.value) + ',' + a.done + ',' + String(b.value) + ',' + b.done
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("undefined,true,undefined,true".into()));
    }

    /// Spread generator into array literal.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_spread_into_array() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; yield 2; yield 3; }
            var a = [...gen()];
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// Nested generators ΓÇö outer yields from inner via yield*.
    #[test]
    fn e2e_nested_yield_star() {
        let r = global_eval(
            r#"
            function* a() { yield 1; yield 2; }
            function* b() { yield* a(); yield* a(); }
            var r = [];
            for (var v of b()) r.push(v);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2,1,2".into()));
    }

    /// Generator with try/finally ΓÇö finally runs on normal completion.
    #[test]
    fn e2e_generator_try_finally_normal() {
        let r = global_eval(
            r#"
            var log = [];
            function* gen() {
                try { yield 1; yield 2; }
                finally { log.push('finally'); }
            }
            var g = gen();
            g.next();
            g.next();
            g.next();
            log.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("finally".into()));
    }

    /// Generator with try/finally ΓÇö finally runs on .return() call.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_try_finally_return() {
        let r = global_eval(
            r#"
            var log = [];
            function* gen() {
                try { yield 1; yield 2; }
                finally { log.push('finally'); }
            }
            var g = gen();
            g.next();
            var ret = g.return(99);
            ret.value + ',' + ret.done + ',' + log.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("99,true,finally".into()));
    }

    /// Generator typeof is "object".
    #[test]
    fn e2e_generator_typeof() {
        let r = global_eval("function* gen() { yield 1; } typeof gen()").unwrap();
        assert_eq!(r, JsValue::String("object".into()));
    }

    /// Generator return(value) on not-yet-started generator.
    #[test]
    fn e2e_generator_return_before_start() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; yield 2; }
            var g = gen();
            var r = g.return(42);
            r.value + ',' + r.done
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("42,true".into()));
    }

    /// yield* returns the inner generator's return value.
    #[test]
    fn e2e_yield_star_return_value() {
        let r = global_eval(
            r#"
            function* inner() { yield 1; return 'done'; }
            function* outer() { var x = yield* inner(); yield x; }
            var g = outer();
            g.next();
            g.next().value
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("done".into()));
    }

    /// Generator.prototype.throw on not-yet-started generator completes it.
    #[test]
    fn e2e_generator_throw_before_start() {
        let r = global_eval(
            r#"
            function* gen() { yield 1; }
            var g = gen();
            try { g.throw('err'); 'no error'; } catch(e) { 'caught'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("caught".into()));
    }

    /// Infinite generator consumed via for-of with break.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_infinite_generator_for_of_break() {
        let r = global_eval(
            r#"
            function* naturals() { var i = 1; while (true) yield i++; }
            var r = [];
            for (var v of naturals()) {
                r.push(v);
                if (v >= 5) break;
            }
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2,3,4,5".into()));
    }

    /// Generator with computed yield values.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_computed_yields() {
        let r = global_eval(
            r#"
            function* fib() {
                var a = 0, b = 1;
                while (true) {
                    yield a;
                    var t = a + b;
                    a = b;
                    b = t;
                }
            }
            var g = fib();
            var r = [];
            for (var i = 0; i < 8; i++) r.push(g.next().value);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0,1,1,2,3,5,8,13".into()));
    }

    /// yield* returns the delegate's final return value.
    #[test]
    fn e2e_yield_star_propagates_return_value_to_outer_return() {
        assert_eval_true(
            r#"
            function* inner() { yield 1; return 42; }
            function* outer() { return yield* inner(); }
            var it = outer();
            var a = it.next();
            var b = it.next();
            a.value === 1 && a.done === false &&
            b.value === 42 && b.done === true
            "#,
        );
    }

    /// yield* forwards throw() into the delegate where it can be caught.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_yield_star_throw_caught_by_inner() {
        assert_eval_true(
            r#"
            function* inner() {
                try { yield 1; }
                catch (e) { yield 'caught:' + e; }
            }
            function* outer() { yield* inner(); }
            var it = outer();
            it.next();
            var r = it.throw('boom');
            r.value === 'caught:boom' && r.done === false
            "#,
        );
    }

    /// Uncaught throw() during yield* propagates to the caller.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_yield_star_throw_propagates_uncaught() {
        let r = global_eval(
            r#"
            function* inner() { yield 1; }
            function* outer() { yield* inner(); }
            var it = outer();
            it.next();
            try { it.throw('boom'); 'nope'; } catch (e) { e; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("boom".into()));
    }

    /// yield* over a plain iterable completes with undefined.
    #[test]
    fn e2e_yield_star_array_completion_value_is_undefined() {
        assert_eval_true(
            r#"
            function* gen() {
                var doneValue = yield* [1, 2];
                return doneValue === undefined;
            }
            var it = gen();
            it.next();
            it.next();
            it.next().value === true
            "#,
        );
    }

    /// yield* requires an iterable delegate.
    #[test]
    fn e2e_yield_star_non_iterable_throws_type_error() {
        assert_eval_type_error(
            r#"
            function* gen() { yield* 1; }
            gen().next();
            "#,
        );
    }

    /// Values sent with next() flow through yield* into the delegate.
    #[test]
    fn e2e_yield_star_passes_next_value_into_inner() {
        assert_eval_true(
            r#"
            function* inner() {
                var sent = yield 1;
                return sent;
            }
            function* outer() { return yield* inner(); }
            var it = outer();
            it.next();
            var r = it.next(9);
            r.value === 9 && r.done === true
            "#,
        );
    }

    /// yield* return() runs the delegate's finally block.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_yield_star_return_runs_inner_finally() {
        assert_eval_true(
            r#"
            var log = [];
            function* inner() {
                try { yield 1; yield 2; }
                finally { log.push('inner'); }
            }
            function* outer() { yield* inner(); }
            var it = outer();
            it.next();
            var r = it.return(7);
            r.value === 7 && r.done === true && log.join(',') === 'inner'
            "#,
        );
    }

    /// yield* throw() also runs the delegate's finally block.
    #[test]
    fn e2e_yield_star_throw_runs_inner_finally() {
        assert_eval_true(
            r#"
            var log = [];
            function* inner() {
                try { yield 1; }
                finally { log.push('inner'); }
            }
            function* outer() { yield* inner(); }
            var it = outer();
            it.next();
            try { it.throw('boom'); } catch (e) {}
            log.join(',') === 'inner'
            "#,
        );
    }

    /// After return(), next() remains done forever.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_return_then_next_stays_done() {
        assert_eval_true(
            r#"
            function* gen() { yield 1; yield 2; }
            var it = gen();
            it.next();
            it.return(5);
            var r = it.next();
            r.value === undefined && r.done === true
            "#,
        );
    }

    /// return() before first next() also leaves the generator closed.
    #[test]
    fn e2e_generator_return_before_start_then_next_done() {
        assert_eval_true(
            r#"
            function* gen() { yield 1; }
            var it = gen();
            var r = it.return(8);
            var n = it.next();
            r.value === 8 && r.done === true &&
            n.value === undefined && n.done === true
            "#,
        );
    }

    /// A caught throw() can resume once, then next() reports completion.
    #[test]
    fn e2e_generator_throw_caught_then_next_done() {
        assert_eval_true(
            r#"
            function* gen() {
                try { yield 1; }
                catch (e) { yield e; }
            }
            var it = gen();
            it.next();
            it.throw(5);
            var r = it.next();
            r.value === undefined && r.done === true
            "#,
        );
    }

    /// throw() unwinds through finally blocks.
    #[test]
    fn e2e_generator_throw_runs_finally_block() {
        assert_eval_true(
            r#"
            var finallyRan = false;
            function* gen() {
                try { yield 1; }
                finally { finallyRan = true; }
            }
            var it = gen();
            it.next();
            try { it.throw('x'); } catch (e) {}
            finallyRan
            "#,
        );
    }

    /// A completed generator stays done even after throw() is attempted.
    #[test]
    fn e2e_generator_throw_after_completion_keeps_next_done() {
        assert_eval_true(
            r#"
            function* gen() { yield 1; }
            var it = gen();
            it.next();
            it.next();
            try { it.throw('late'); } catch (e) {}
            var r = it.next();
            r.value === undefined && r.done === true
            "#,
        );
    }

    /// throw() before the first next() closes the generator.
    #[test]
    fn e2e_generator_throw_before_start_then_next_done() {
        assert_eval_true(
            r#"
            function* gen() { yield 1; }
            var it = gen();
            try { it.throw('x'); } catch (e) {}
            var r = it.next();
            r.value === undefined && r.done === true
            "#,
        );
    }

    /// Normal completion still leaves next() permanently done.
    #[test]
    fn e2e_generator_normal_completion_then_next_stays_done() {
        assert_eval_true(
            r#"
            function* gen() { yield 1; return 2; }
            var it = gen();
            it.next();
            it.next();
            var r = it.next();
            r.value === undefined && r.done === true
            "#,
        );
    }

    /// return() produces the required iterator-result shape.
    #[test]
    fn e2e_generator_return_result_has_done_true() {
        assert_eval_true(
            r#"
            function* gen() { yield 1; }
            var r = gen().return(33);
            r.value === 33 && r.done === true
            "#,
        );
    }

    /// Generator function .prototype is an object distinct from GeneratorFunction.prototype.
    #[test]
    fn e2e_generator_function_prototype_is_object_not_generator_function_prototype() {
        assert_eval_true(
            r#"
            function* gen() {}
            typeof gen.prototype === 'object' &&
            gen.prototype !== GeneratorFunction.prototype
            "#,
        );
    }

    /// Generator function .prototype.constructor points back to the function.
    #[test]
    fn e2e_generator_function_prototype_constructor_points_back() {
        assert_eval_true(
            r#"
            function* gen() {}
            gen.prototype.constructor === gen
            "#,
        );
    }

    /// Generator instances inherit from the function's own .prototype object.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_instance_prototype_is_function_prototype_property() {
        assert_eval_true(
            r#"
            function* gen() {}
            Object.getPrototypeOf(gen()) === gen.prototype
            "#,
        );
    }

    /// Generator instances are their own synchronous iterators.
    #[test]
    fn e2e_generator_instance_symbol_iterator_returns_self() {
        assert_eval_true(
            r#"
            function* gen() { yield 1; }
            var it = gen();
            it[Symbol.iterator]() === it
            "#,
        );
    }

    /// Generator expressions produce callable generator functions with object .prototype.
    #[test]
    fn e2e_generator_expression_has_object_prototype_property() {
        assert_eval_true(
            r#"
            var gen = function*() { yield 1; };
            typeof gen === 'function' && typeof gen.prototype === 'object'
            "#,
        );
    }

    /// Object literal generator methods yield values in order.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_object_method_yields_values() {
        assert_eval_true(
            r#"
            var obj = { *method() { yield 1; yield 2; } };
            var it = obj.method();
            it.next().value === 1 && it.next().value === 2
            "#,
        );
    }

    /// Class generator methods yield values in order.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_class_method_yields_values() {
        assert_eval_true(
            r#"
            class C { *method() { yield 3; yield 4; } }
            var it = new C().method();
            it.next().value === 3 && it.next().value === 4
            "#,
        );
    }

    /// Object literal generator methods keep the inferred method name.
    #[test]
    fn e2e_generator_object_method_name_is_preserved() {
        assert_eval_true("({ *method() {} }).method.name === 'method'");
    }

    /// Class generator methods keep the inferred method name.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_class_method_name_is_preserved() {
        assert_eval_true("class C { *method() {} } new C().method.name === 'method'");
    }

    /// Generator expressions still create instances linked to their .prototype.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_generator_expression_instances_use_generator_prototype_chain() {
        assert_eval_true(
            r#"
            var gen = function*() { yield 1; };
            Object.getPrototypeOf(gen()) === gen.prototype
            "#,
        );
    }

    /// yield in a generator parameter default is an early SyntaxError.
    #[test]
    fn e2e_generator_param_default_yield_is_syntax_error() {
        assert_eval_syntax_error("function* gen(a = yield 1) {}");
    }

    /// yield* in a generator parameter default is also a SyntaxError.
    #[test]
    fn e2e_generator_param_default_yield_star_is_syntax_error() {
        assert_eval_syntax_error("function* gen(a = yield* []) {}");
    }

    /// yield inside object-pattern defaults in generator params is rejected.
    #[test]
    fn e2e_generator_object_pattern_default_yield_is_syntax_error() {
        assert_eval_syntax_error("function* gen({ a = yield 1 }) {}");
    }

    /// yield inside array-pattern defaults in generator params is rejected.
    #[test]
    fn e2e_generator_array_pattern_default_yield_is_syntax_error() {
        assert_eval_syntax_error("function* gen([a = yield 1]) {}");
    }

    /// Object generator method parameter defaults reject yield.
    #[test]
    fn e2e_generator_object_method_param_default_yield_is_syntax_error() {
        assert_eval_syntax_error("({ *method(a = yield 1) {} })");
    }

    /// Class generator method parameter defaults reject yield.
    #[test]
    fn e2e_generator_class_method_param_default_yield_is_syntax_error() {
        assert_eval_syntax_error("class C { *method(a = yield 1) {} }");
    }

    /// Async generator parameter defaults also reject yield.
    #[test]
    fn e2e_async_generator_param_default_yield_is_syntax_error() {
        assert_eval_syntax_error("async function* gen(a = yield 1) {}");
    }

    /// Async generators await promise values before exposing them.
    #[test]
    fn e2e_async_generator_yield_awaits_promise_before_exposing_value() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() { yield await Promise.resolve(5); }
            async function f() {
                var r = await gen().next();
                return r.value === 5 && r.done === false;
            }
            f()
            "#,
        );
    }

    /// for await...of awaits promise values yielded from async generators.
    #[test]
    fn e2e_async_generator_for_await_awaits_yielded_promises() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() { yield Promise.resolve(7); }
            async function f() {
                var out = [];
                for await (const x of gen()) out.push(x);
                return out.length === 1 && out[0] === 7;
            }
            f()
            "#,
        );
    }

    /// for await...of follows the async iteration protocol on async generators.
    #[test]
    fn e2e_async_generator_for_await_consumes_async_iteration_protocol() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() { yield 1; yield 2; yield 3; }
            async function f() {
                var sum = 0;
                for await (const x of gen()) sum += x;
                return sum === 6;
            }
            f()
            "#,
        );
    }

    /// Async generator return() resolves to an iterator result.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_async_generator_return_resolves_iterator_result() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() { yield 1; }
            async function f() {
                var it = gen();
                await it.next();
                var r = await it.return(9);
                return r.value === 9 && r.done === true;
            }
            f()
            "#,
        );
    }

    /// Async generator return() triggers finally blocks.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_async_generator_return_runs_finally() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() {
                try { yield 1; }
                finally { globalThis.closed = true; }
            }
            async function f() {
                globalThis.closed = false;
                var it = gen();
                await it.next();
                await it.return(0);
                return globalThis.closed;
            }
            f()
            "#,
        );
    }

    /// After async return(), next() stays done.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_async_generator_return_after_done_keeps_next_done() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() { yield 1; }
            async function f() {
                var it = gen();
                await it.next();
                await it.return(2);
                var r = await it.next();
                return r.value === undefined && r.done === true;
            }
            f()
            "#,
        );
    }

    /// Async generator throw() can be caught inside the generator.
    #[test]
    fn e2e_async_generator_throw_is_caught_inside() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() {
                try { yield 1; }
                catch (e) { yield 'caught:' + e; }
            }
            async function f() {
                var it = gen();
                await it.next();
                var r = await it.throw('x');
                return r.value === 'caught:x' && r.done === false;
            }
            f()
            "#,
        );
    }

    /// Uncaught async generator throw() rejects the returned promise.
    #[test]
    fn e2e_async_generator_throw_rejects_when_uncaught() {
        assert_eval_rejected_promise_reason(
            r#"
            async function* gen() { yield 1; }
            async function f() {
                var it = gen();
                await it.next();
                return await it.throw('boom');
            }
            f()
            "#,
            JsValue::String("boom".into()),
        );
    }

    /// After a caught async throw(), the following next() can observe completion.
    #[test]
    fn e2e_async_generator_throw_then_next_done() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() {
                try { yield 1; }
                catch (e) { yield 2; }
            }
            async function f() {
                var it = gen();
                await it.next();
                await it.throw('x');
                var r = await it.next();
                return r.value === undefined && r.done === true;
            }
            f()
            "#,
        );
    }

    /// next() after async return() always stays done.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_async_generator_next_after_return_stays_done() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() { yield 1; yield 2; }
            async function f() {
                var it = gen();
                await it.next();
                await it.return(4);
                var r1 = await it.next();
                var r2 = await it.next();
                return r1.done === true && r1.value === undefined &&
                       r2.done === true && r2.value === undefined;
            }
            f()
            "#,
        );
    }

    /// Async generators are their own async iterator.
    #[test]
    fn e2e_async_generator_symbol_async_iterator_returns_self() {
        assert_eval_true(
            r#"
            async function* gen() { yield 1; }
            var it = gen();
            it[Symbol.asyncIterator]() === it
            "#,
        );
    }

    /// Async yield* preserves the delegate's completion value.
    #[test]
    fn e2e_async_generator_yield_star_preserves_return_value() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* inner() { yield 2; return 5; }
            async function* outer() { var x = yield* inner(); yield x; }
            async function f() {
                var it = outer();
                var a = await it.next();
                var b = await it.next();
                return a.value === 2 && b.value === 5;
            }
            f()
            "#,
        );
    }

    /// Breaking from for await...of closes the async generator.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_async_generator_for_await_break_runs_finally() {
        assert_eval_fulfilled_promise_true(
            r#"
            async function* gen() {
                try { yield 1; yield 2; }
                finally { globalThis.asyncFinally = 'done'; }
            }
            async function f() {
                globalThis.asyncFinally = '';
                for await (const x of gen()) { break; }
                return globalThis.asyncFinally === 'done';
            }
            f()
            "#,
        );
    }

    /// Async generator expressions are supported.
    #[test]
    fn e2e_async_generator_expression_yields_values() {
        assert_eval_fulfilled_promise_true(
            r#"
            var gen = async function*() { yield 1; yield 2; };
            async function f() {
                var it = gen();
                var a = await it.next();
                var b = await it.next();
                return a.value === 1 && b.value === 2;
            }
            f()
            "#,
        );
    }

    /// Async generator object methods are supported.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_async_generator_object_method_yields_values() {
        assert_eval_fulfilled_promise_true(
            r#"
            var obj = { async *method() { yield 1; yield 2; } };
            async function f() {
                var it = obj.method();
                var a = await it.next();
                var b = await it.next();
                return a.value === 1 && b.value === 2;
            }
            f()
            "#,
        );
    }

    /// Async generator class methods are supported.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_async_generator_class_method_yields_values() {
        assert_eval_fulfilled_promise_true(
            r#"
            class C { async *method() { yield 3; yield 4; } }
            async function f() {
                var it = new C().method();
                var a = await it.next();
                var b = await it.next();
                return a.value === 3 && b.value === 4;
            }
            f()
            "#,
        );
    }

    // ΓöÇΓöÇ Type coercion & conversion conformance ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ

    // -- ToNumber edge cases --

    /// Unary `+` on empty string → 0.
    #[test]
    fn e2e_to_number_empty_string() {
        let r = global_eval("+''").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Unary `+` on whitespace-only string → 0.
    #[test]
    fn e2e_to_number_whitespace_string() {
        let r = global_eval("+' '").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Unary `+` on hex literal string → 16.
    #[test]
    fn e2e_to_number_hex_string() {
        let r = global_eval("+'0x10'").unwrap();
        assert_eq!(r, JsValue::Smi(16));
    }

    /// Unary `+` on "Infinity" string → Infinity.
    #[test]
    fn e2e_to_number_infinity_string() {
        let r = global_eval("+'Infinity'").unwrap();
        assert_eq!(r, JsValue::HeapNumber(f64::INFINITY));
    }

    /// Unary `+` on scientific notation string → 100.
    #[test]
    fn e2e_to_number_scientific_notation() {
        let r = global_eval("+'1e2'").unwrap();
        assert_eq!(r, JsValue::Smi(100));
    }

    /// Unary `+` on string with surrounding whitespace → 42.
    #[test]
    fn e2e_to_number_whitespace_around() {
        let r = global_eval("+'  42  '").unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// Unary `+` on `null` → 0.
    #[test]
    fn e2e_to_number_null() {
        let r = global_eval("+null").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Unary `+` on `true` → 1.
    #[test]
    fn e2e_to_number_true() {
        let r = global_eval("+true").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// Unary `+` on `false` → 0.
    #[test]
    fn e2e_to_number_false() {
        let r = global_eval("+false").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    // -- ToString --

    /// `String(null)` → "null".
    #[test]
    fn e2e_to_string_null() {
        let r = global_eval("String(null)").unwrap();
        assert_eq!(r, JsValue::String("null".into()));
    }

    /// `String(undefined)` → "undefined".
    #[test]
    fn e2e_to_string_undefined() {
        let r = global_eval("String(undefined)").unwrap();
        assert_eq!(r, JsValue::String("undefined".into()));
    }

    /// `String(true)` → "true".
    #[test]
    fn e2e_to_string_true() {
        let r = global_eval("String(true)").unwrap();
        assert_eq!(r, JsValue::String("true".into()));
    }

    /// `String(false)` → "false".
    #[test]
    fn e2e_to_string_false() {
        let r = global_eval("String(false)").unwrap();
        assert_eq!(r, JsValue::String("false".into()));
    }

    // -- Abstract equality (==) --

    /// `null == undefined` → true.
    #[test]
    fn e2e_abstract_eq_null_undefined() {
        let r = global_eval("null == undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `null == 0` → false.
    #[test]
    fn e2e_abstract_eq_null_zero() {
        let r = global_eval("null == 0").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `"" == 0` → true.
    #[test]
    fn e2e_abstract_eq_empty_string_zero() {
        let r = global_eval("'' == 0").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `"" == false` → true.
    #[test]
    fn e2e_abstract_eq_empty_string_false() {
        let r = global_eval("'' == false").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `undefined == null` → true (symmetric).
    #[test]
    fn e2e_abstract_eq_undefined_null() {
        let r = global_eval("undefined == null").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // -- Strict equality (===) --

    /// `NaN === NaN` → false.
    #[test]
    fn e2e_strict_eq_nan_nan() {
        let r = global_eval("NaN === NaN").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `NaN !== NaN` → true.
    #[test]
    fn e2e_strict_neq_nan_nan() {
        let r = global_eval("NaN !== NaN").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Type mismatch: `1 === '1'` → false.
    #[test]
    fn e2e_strict_eq_type_mismatch() {
        let r = global_eval("1 === '1'").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    // -- Comparison operators --

    /// String lexicographic: `"b" > "a"` → true.
    #[test]
    fn e2e_compare_string_gt() {
        let r = global_eval("'b' > 'a'").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// String lexicographic: `"10" < "9"` → true (char-by-char).
    #[test]
    fn e2e_compare_string_lexicographic() {
        let r = global_eval("'10' < '9'").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Mixed types: `2 < "10"` → true (string coerced to number).
    #[test]
    fn e2e_compare_mixed_types() {
        let r = global_eval("2 < '10'").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // -- Unary operators --

    /// Negate: `-5` → -5.
    #[test]
    fn e2e_unary_negate() {
        let r = global_eval("var x = 5; -x").unwrap();
        assert_eq!(r, JsValue::Smi(-5));
    }

    /// Bitwise NOT: `~0` → -1.
    #[test]
    fn e2e_bitwise_not_zero_v2() {
        let r = global_eval("~0").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// Bitwise NOT: `~-1` → 0.
    #[test]
    fn e2e_bitwise_not_neg_one() {
        let r = global_eval("~-1").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Bitwise NOT uses ToInt32: `~NaN` → -1 (ToInt32(NaN) is 0).
    #[test]
    fn e2e_bitwise_not_nan_v2() {
        let r = global_eval("~NaN").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    // -- Boolean coercion (!value) --

    /// `!0` → true (0 is falsy).
    #[test]
    fn e2e_logical_not_zero() {
        let r = global_eval("!0").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `!""` → true (empty string is falsy).
    #[test]
    fn e2e_logical_not_empty_string() {
        let r = global_eval("!''").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `!null` → true (null is falsy).
    #[test]
    fn e2e_logical_not_null() {
        let r = global_eval("!null").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `!undefined` → true (undefined is falsy).
    #[test]
    fn e2e_logical_not_undefined() {
        let r = global_eval("!undefined").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `!1` → false (1 is truthy).
    #[test]
    fn e2e_logical_not_one() {
        let r = global_eval("!1").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `!!"hello"` → true (non-empty string is truthy).
    #[test]
    fn e2e_double_not_string() {
        let r = global_eval("!!'hello'").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `!!0` → false (double-not preserves falsiness).
    #[test]
    fn e2e_double_not_zero() {
        let r = global_eval("!!0").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `!!NaN` → false (NaN is falsy).
    #[test]
    fn e2e_double_not_nan() {
        let r = global_eval("!!NaN").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `!!""` → false (empty string is falsy).
    #[test]
    fn e2e_double_not_empty_string() {
        let r = global_eval("!!''").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Array ToPrimitive: `[1] == 1` → true.
    #[test]
    fn e2e_abstract_eq_array_number() {
        let r = global_eval("[1] == 1").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Empty array ToPrimitive: `[] == 0` → true ("" == 0).
    #[test]
    fn e2e_abstract_eq_empty_array_zero() {
        let r = global_eval("[] == 0").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    fn e2e_define_property_data_to_accessor_updates_descriptor_shape() {
        let result = global_eval(
            "var o = { x: 1 }; \
             Object.defineProperty(o, 'x', { get: function() { return 42; }, configurable: true }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === undefined && d.writable === undefined && typeof d.get === 'function'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_own_data_property_shadows_prototype_getter() {
        let result = global_eval(
            "var p = { get x() { return 1; } }; \
             var o = Object.create(p); \
             Object.defineProperty(o, 'x', { value: 42, writable: true, configurable: true }); \
             o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_own_data_property_blocks_prototype_getter_this_access() {
        let result = global_eval(
            "var p = { get x() { return this.y; } }; \
             var o = Object.create(p); \
             o.y = 1; \
             Object.defineProperty(o, 'x', { value: 42, writable: true, configurable: true }); \
             o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_child_inherits_getter() {
        let result = global_eval(
            "class Parent { get x() { return this.y; } } \
             class Child extends Parent {} \
             var c = new Child(); \
             c.y = 42; \
             c.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_child_inherits_setter() {
        let result = global_eval(
            "class Parent { set x(v) { this.y = v; } } \
             class Child extends Parent {} \
             var c = new Child(); \
             c.x = 42; \
             c.y",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_inherited_accessor_round_trip() {
        let result = global_eval(
            "class Parent { \
                get x() { return this._x; } \
                set x(v) { this._x = v; } \
             } \
             class Child extends Parent {} \
             var c = new Child(); \
             c.x = 42; \
             c.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_object_create_descriptor_getter() {
        let result = global_eval(
            "var o = Object.create({}, { \
                x: { get: function() { return 42; }, configurable: true } \
             }); \
             o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_object_create_descriptor_setter() {
        let result = global_eval(
            "var o = Object.create({}, { \
                x: { set: function(v) { this.y = v; }, configurable: true } \
             }); \
             o.x = 42; \
             o.y",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_object_create_descriptor_getter_and_setter() {
        let result = global_eval(
            "var o = Object.create({}, { \
                x: { \
                    get: function() { return this._x; }, \
                    set: function(v) { this._x = v; }, \
                    configurable: true \
                } \
             }); \
             o.x = 42; \
             o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_object_create_null_proto_descriptor_getter() {
        let result = global_eval(
            "var o = Object.create(null, { \
                x: { get: function() { return 42; }, configurable: true } \
             }); \
             o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_throwing_getter_propagates_string() {
        let result = global_eval(
            "var o = { get x() { throw 'boom'; } }; \
             try { o.x; 'no'; } catch (e) { e; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("boom".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_throwing_inherited_getter_propagates() {
        let result = global_eval(
            "var p = { get x() { throw 'boom'; } }; \
             var o = Object.create(p); \
             try { o.x; 'no'; } catch (e) { e; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("boom".into()));
    }

    #[test]
    fn e2e_configurable_accessor_replace_getter_with_setter() {
        let result = global_eval(
            "var seen = 0; \
             var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: true }); \
             Object.defineProperty(o, 'x', { get: undefined, set: function(v) { seen = v; } }); \
             o.x = 42; \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             seen === 42 && d.get === undefined && typeof d.set === 'function'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_configurable_accessor_replace_setter_with_getter() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { set: function(v) { this._x = v; }, configurable: true }); \
             Object.defineProperty(o, 'x', { set: undefined, get: function() { return 42; } }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             o.x === 42 && d.set === undefined && typeof d.get === 'function'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_getter_overrides_existing_data_value_after_redefinition() {
        let result = global_eval(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: true, configurable: true }); \
             Object.defineProperty(o, 'x', { get: function() { return 42; }, configurable: true }); \
             o.x",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_inherited_setter_assignment_returns_stored_value() {
        let result = global_eval(
            "var p = { set x(v) { this.y = v; } }; \
             var o = Object.create(p); \
             (o.x = 42) === 42 && o.y === 42",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── JSON deep edge-case tests ───────────────────────────────────────────

    // 1. JSON.parse reviver — walks all properties, transforms values
    #[test]
    fn e2e_json_parse_reviver_transforms_values() {
        let result = global_eval(
            r#"JSON.stringify(JSON.parse('{"a":1,"b":2}', function(k, v) {
                return typeof v === "number" ? v * 10 : v;
            }))"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":10,"b":20}"#.into()));
    }

    // 2. JSON.parse reviver — deletes properties by returning undefined
    #[test]
    fn e2e_json_parse_reviver_deletes_properties() {
        let result = global_eval(
            r#"JSON.stringify(JSON.parse('{"a":1,"b":2,"c":3}', function(k, v) {
                if (k === "b") return undefined;
                return v;
            }))"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"c":3}"#.into()));
    }

    // 3. JSON.parse reviver — receives correct key/value for nested objects
    #[test]
    fn e2e_json_parse_reviver_nested_object() {
        let result = global_eval(
            r#"var keys = [];
            JSON.parse('{"a":{"b":1}}', function(k, v) { if (k !== "") keys.push(k); return v; });
            keys.join(",")"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("b,a".into()));
    }

    // 4. JSON.parse with Unicode escapes — \u0041 → "A"
    #[test]
    fn e2e_json_parse_unicode_escape() {
        let result = global_eval(r#"JSON.parse('"\\u0041\\u0042\\u0043"')"#).unwrap();
        assert_eq!(result, JsValue::String("ABC".into()));
    }

    // 5. JSON.parse with Unicode escape — non-ASCII \u00E9 → é
    #[test]
    fn e2e_json_parse_unicode_escape_non_ascii() {
        let result = global_eval(r#"JSON.parse('"caf\\u00E9"')"#).unwrap();
        assert_eq!(result, JsValue::String("café".into()));
    }

    // 6. JSON.parse error handling — invalid JSON throws SyntaxError
    #[test]
    fn e2e_json_parse_invalid_json_syntax_error() {
        let result = global_eval(r#"JSON.parse("{invalid}")"#);
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), StatorError::SyntaxError(_)));
    }

    // 7. JSON.parse error handling — trailing comma is invalid
    #[test]
    fn e2e_json_parse_trailing_comma_error() {
        let result = global_eval(r#"JSON.parse("[1,2,3,]")"#);
        assert!(result.is_err());
    }

    // 8. JSON.parse error handling — empty input
    #[test]
    fn e2e_json_parse_empty_input_error() {
        let result = global_eval(r#"JSON.parse("")"#);
        assert!(result.is_err());
    }

    // 9. JSON.stringify replacer array — only include listed keys
    #[test]
    fn e2e_json_stringify_replacer_array() {
        let result = global_eval(r#"JSON.stringify({a: 1, b: 2, c: 3}, ["a", "c"])"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"c":3}"#.into()));
    }

    // 10. JSON.stringify replacer function — transform values
    #[test]
    fn e2e_json_stringify_replacer_function() {
        let result = global_eval(
            r#"JSON.stringify({a: 1, b: "hello", c: true}, function(k, v) {
                if (typeof v === "number") return v * 2;
                return v;
            })"#,
        )
        .unwrap();
        assert_eq!(
            result,
            JsValue::String(r#"{"a":2,"b":"hello","c":true}"#.into())
        );
    }

    // 11. JSON.stringify replacer function — omit properties by returning undefined
    #[test]
    fn e2e_json_stringify_replacer_fn_omits() {
        let result = global_eval(
            r#"JSON.stringify({a: 1, b: 2, c: 3}, function(k, v) {
                if (k === "b") return undefined;
                return v;
            })"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"c":3}"#.into()));
    }

    // 12. JSON.stringify space parameter — number indent
    #[test]
    fn e2e_json_stringify_space_number() {
        let result = global_eval(r#"JSON.stringify({a: 1}, null, 2)"#).unwrap();
        assert_eq!(result, JsValue::String("{\n  \"a\": 1\n}".into()));
    }

    // 13. JSON.stringify space parameter — string prefix
    #[test]
    fn e2e_json_stringify_space_string() {
        let result = global_eval(r#"JSON.stringify({a: 1}, null, "\t")"#).unwrap();
        assert_eq!(result, JsValue::String("{\n\t\"a\": 1\n}".into()));
    }

    // 14. JSON.stringify toJSON — custom serialization method
    #[test]
    fn e2e_json_stringify_to_json_method_v2() {
        let result = global_eval(
            r#"var obj = { val: 42, toJSON: function() { return "custom:" + this.val; } };
            JSON.stringify(obj)"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#""custom:42""#.into()));
    }

    // 15. JSON.stringify special values — undefined omitted in objects
    #[test]
    fn e2e_json_stringify_undefined_in_object() {
        let result = global_eval(r#"JSON.stringify({a: 1, b: undefined, c: 3})"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"c":3}"#.into()));
    }

    // 16. JSON.stringify special values — undefined becomes null in arrays
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_undefined_in_array() {
        let result = global_eval(r#"JSON.stringify([1, undefined, 3])"#).unwrap();
        assert_eq!(result, JsValue::String("[1,null,3]".into()));
    }

    // 17. JSON.stringify special values — Infinity → null
    #[test]
    fn e2e_json_stringify_infinity_to_null() {
        let result = global_eval(r#"JSON.stringify(Infinity)"#).unwrap();
        assert_eq!(result, JsValue::String("null".into()));
    }

    // 18. JSON.stringify special values — NaN → null
    #[test]
    fn e2e_json_stringify_nan_to_null() {
        let result = global_eval(r#"JSON.stringify(NaN)"#).unwrap();
        assert_eq!(result, JsValue::String("null".into()));
    }

    // 19. JSON.stringify special values — -Infinity → null
    #[test]
    fn e2e_json_stringify_neg_infinity_to_null() {
        let result = global_eval(r#"JSON.stringify(-Infinity)"#).unwrap();
        assert_eq!(result, JsValue::String("null".into()));
    }

    // 20. JSON.stringify special values — function omitted from object
    #[test]
    fn e2e_json_stringify_function_omitted() {
        let result = global_eval(r#"JSON.stringify({a: 1, b: function() {}, c: 3})"#).unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"c":3}"#.into()));
    }

    // 21. JSON round-trip — parse(stringify(x)) for objects
    #[test]
    fn e2e_json_round_trip_object() {
        let result = global_eval(
            r#"var obj = {a: 1, b: "hello", c: true, d: null};
            JSON.stringify(JSON.parse(JSON.stringify(obj))) === JSON.stringify(obj)"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // 22. JSON round-trip — parse(stringify(x)) for arrays
    #[test]
    fn e2e_json_round_trip_array() {
        let result = global_eval(
            r#"var arr = [1, "two", true, null, [5, 6]];
            JSON.stringify(JSON.parse(JSON.stringify(arr))) === JSON.stringify(arr)"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // 23. JSON round-trip — parse(stringify(x)) for nested objects
    #[test]
    fn e2e_json_round_trip_nested() {
        let result = global_eval(
            r#"var obj = {a: {b: {c: 42}}};
            JSON.parse(JSON.stringify(obj)).a.b.c"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    // 24. JSON.stringify with Proxy — should serialize through proxy traps
    #[test]
    fn e2e_json_stringify_proxy() {
        let result = global_eval(
            r#"var target = {a: 1, b: 2};
            var proxy = new Proxy(target, {});
            JSON.stringify(proxy)"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":1,"b":2}"#.into()));
    }

    // 25. JSON.stringify with Proxy — get trap intercepts values
    #[test]
    fn e2e_json_stringify_proxy_get_trap() {
        let result = global_eval(
            r#"var target = {a: 1, b: 2};
            var proxy = new Proxy(target, {
                get: function(t, k) { return t[k] * 10; }
            });
            JSON.stringify(proxy)"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String(r#"{"a":10,"b":20}"#.into()));
    }

    // 26. JSON.parse — deeply nested valid JSON
    #[test]
    fn e2e_json_parse_deeply_nested() {
        let result = global_eval(r#"JSON.parse('{"a":{"b":{"c":[1,2,3]}}}').a.b.c[1]"#).unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    // 27. JSON.stringify — empty object and array
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_json_stringify_empty_containers() {
        let result = global_eval(r#"JSON.stringify({}) + "|" + JSON.stringify([])"#).unwrap();
        assert_eq!(result, JsValue::String("{}|[]".into()));
    }

    // 28. JSON.stringify — null value
    #[test]
    fn e2e_json_stringify_null() {
        let result = global_eval(r#"JSON.stringify(null)"#).unwrap();
        assert_eq!(result, JsValue::String("null".into()));
    }

    // 29. JSON.stringify — boolean values
    #[test]
    fn e2e_json_stringify_booleans() {
        let result = global_eval(r#"JSON.stringify(true) + "|" + JSON.stringify(false)"#).unwrap();
        assert_eq!(result, JsValue::String("true|false".into()));
    }

    // 30. JSON.stringify — string escaping of special characters
    #[test]
    fn e2e_json_stringify_string_escaping() {
        let result = global_eval(r#"JSON.stringify("hello\nworld")"#).unwrap();
        assert_eq!(result, JsValue::String(r#""hello\nworld""#.into()));
    }

    // 31. JSON.stringify — top-level undefined returns undefined
    #[test]
    fn e2e_json_stringify_undefined_returns_undefined() {
        let result = global_eval(r#"JSON.stringify(undefined)"#).unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    // 32. JSON.parse — surrogate pair emoji
    #[test]
    fn e2e_json_parse_surrogate_pair() {
        let result = global_eval(r#"JSON.parse('"\\uD83D\\uDE00"')"#).unwrap();
        assert_eq!(result, JsValue::String("😀".into()));
    }

    // 33. JSON.stringify space parameter clamped to 10
    #[test]
    fn e2e_json_stringify_space_clamped_to_10() {
        let result = global_eval(r#"JSON.stringify({a: 1}, null, 20)"#).unwrap();
        // 10 spaces max
        assert_eq!(result, JsValue::String("{\n          \"a\": 1\n}".into()));
    }

    // ΓöÇΓöÇ Map/Set/WeakMap/WeakSet deep conformance tests ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_negative_zero_key_normalized() {
        let result = global_eval(
            "var m = new Map(); m.set(-0, 'a'); \
             var k; m.forEach(function(v, key) { k = key; }); \
             1 / k === Infinity",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_negative_zero_and_positive_zero_same_key() {
        let result = global_eval(
            "var m = new Map(); m.set(-0, 'neg'); m.set(0, 'pos'); m.size === 1 && m.get(0) === 'pos'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_nan_key_identity() {
        let result = global_eval(
            "var m = new Map(); m.set(NaN, 'val'); m.has(NaN) && m.get(NaN) === 'val' && m.size === 1",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_nan_key_deduplicates() {
        let result = global_eval(
            "var m = new Map(); m.set(NaN, 1); m.set(NaN, 2); m.size === 1 && m.get(NaN) === 2",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_constructor_from_another_map_v2() {
        let result = global_eval(
            "var a = new Map([['x', 1], ['y', 2]]); var b = new Map(a); \
             b.size === 2 && b.get('x') === 1 && b.get('y') === 2",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_constructor_iterable_deduplicates_last_wins() {
        let result =
            global_eval("var m = new Map([['a', 1], ['a', 2]]); m.size === 1 && m.get('a') === 2")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_set_chaining_multiple() {
        let result = global_eval(
            "var m = new Map(); var r = m.set('a', 1).set('b', 2).set('c', 3); \
             r === m && m.size === 3",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_delete_returns_boolean_v2() {
        let result = global_eval(
            "var m = new Map([['a', 1]]); var r1 = m.delete('a'); var r2 = m.delete('a'); \
             r1 === true && r2 === false",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_clear_empties_map() {
        let result = global_eval(
            "var m = new Map([['a', 1], ['b', 2]]); m.clear(); m.size === 0 && !m.has('a')",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_map_to_string_tag_v2() {
        let result = global_eval("var m = new Map(); m[Symbol.toStringTag] === 'Map'").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_negative_zero_value_normalized() {
        let result = global_eval(
            "var s = new Set(); s.add(-0); \
             var v; s.forEach(function(val) { v = val; }); \
             1 / v === Infinity",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_negative_zero_and_positive_zero_same_value() {
        let result = global_eval("var s = new Set(); s.add(-0); s.add(0); s.size === 1").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_nan_deduplicates() {
        let result =
            global_eval("var s = new Set(); s.add(NaN); s.add(NaN); s.size === 1 && s.has(NaN)")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_constructor_deduplicates() {
        let result = global_eval(
            "var s = new Set([1, 2, 2, 3, 3, 3]); s.size === 3 && s.has(1) && s.has(2) && s.has(3)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_delete_returns_boolean_v2() {
        let result = global_eval(
            "var s = new Set([1, 2]); var r1 = s.delete(1); var r2 = s.delete(1); \
             r1 === true && r2 === false && s.size === 1",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_clear_empties_set() {
        let result =
            global_eval("var s = new Set([1, 2, 3]); s.clear(); s.size === 0 && !s.has(1)")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_set_to_string_tag_v2() {
        let result = global_eval("var s = new Set(); s[Symbol.toStringTag] === 'Set'").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_rejects_primitive_key() {
        let result = global_eval(
            "var wm = new WeakMap(); \
             try { wm.set(42, 'val'); false; } catch(e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_rejects_string_key() {
        let result = global_eval(
            "var wm = new WeakMap(); \
             try { wm.set('str', 'val'); false; } catch(e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_no_size_property_v2() {
        let result = global_eval("var wm = new WeakMap(); wm.size === undefined").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_object_key_works() {
        let result = global_eval(
            "var wm = new WeakMap(); var k = {}; wm.set(k, 'hello'); wm.get(k) === 'hello'",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_delete_returns_boolean() {
        let result = global_eval(
            "var wm = new WeakMap(); var k = {}; wm.set(k, 1); \
             var r1 = wm.delete(k); var r2 = wm.delete(k); \
             r1 === true && r2 === false",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakmap_to_string_tag_v2() {
        let result =
            global_eval("var wm = new WeakMap(); wm[Symbol.toStringTag] === 'WeakMap'").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_rejects_primitive_value() {
        let result = global_eval(
            "var ws = new WeakSet(); \
             try { ws.add(42); false; } catch(e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_no_size_property_v2() {
        let result = global_eval("var ws = new WeakSet(); ws.size === undefined").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_object_value_works() {
        let result =
            global_eval("var ws = new WeakSet(); var o = {}; ws.add(o); ws.has(o)").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_weakset_to_string_tag_v2() {
        let result =
            global_eval("var ws = new WeakSet(); ws[Symbol.toStringTag] === 'WeakSet'").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_map_constructor_non_iterable_throws() {
        let result =
            global_eval("try { new Map(123); false; } catch(e) { e instanceof TypeError; }")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_set_constructor_non_iterable_throws() {
        let result =
            global_eval("try { new Set(123); false; } catch(e) { e instanceof TypeError; }")
                .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_map_constructor_null_creates_empty() {
        let result = global_eval("var m = new Map(null); m.size === 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    #[test]
    fn e2e_set_constructor_null_creates_empty() {
        let result = global_eval("var s = new Set(null); s.size === 0").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    // ── Set composition methods (ES2025) ────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_union_basic() {
        assert_eval_true(
            "var r = new Set([1, 2]).union(new Set([2, 3])); r.size === 3 && r.has(1) && r.has(2) && r.has(3)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_union_preserves_insertion_order() {
        assert_eval_true(
            "var out = []; new Set([3, 1]).union(new Set([1, 2])).forEach(function(v) { out.push(v); }); out.join(',') === '3,1,2'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_union_returns_new_set_without_mutating_receiver() {
        assert_eval_true(
            "var a = new Set([1, 2]); var r = a.union(new Set([2, 3])); r !== a && a.size === 2 && !a.has(3) && r.size === 3 && r.has(3)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_union_accepts_map_keys() {
        assert_eval_true(
            "var r = new Set(['a']).union(new Map([['b', 1], ['a', 2]])); r.size === 2 && r.has('a') && r.has('b')",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_union_accepts_custom_set_like() {
        assert_eval_true(
            r#"
            function iter(items) {
                var i = 0;
                return { next: function() {
                    if (i < items.length) return { value: items[i++], done: false };
                    return { done: true };
                }};
            }
            var other = {
                data: [2, 4],
                get size() { return this.data.length; },
                has: function(v) { return v === 2 || v === 4; },
                keys: function() { return iter(this.data); }
            };
            var r = new Set([1, 2]).union(other);
            r.size === 3 && r.has(1) && r.has(2) && r.has(4)
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_union_uses_keys_iterator() {
        assert_eval_true(
            r#"
            function iter(items) {
                var i = 0;
                return { next: function() {
                    if (i < items.length) return { value: items[i++], done: false };
                    return { done: true };
                }};
            }
            var other = {
                get size() { return 2; },
                has: function(v) { return v === 2 || v === 5; },
                keys: function() { return iter([2, 5]); }
            };
            var r = new Set([1, 2]).union(other);
            r.size === 3 && r.has(5)
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_intersection_basic() {
        assert_eval_true(
            "var r = new Set([1, 2, 3]).intersection(new Set([2, 4, 3])); r.size === 2 && r.has(2) && r.has(3)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_intersection_preserves_receiver_order() {
        assert_eval_true(
            "var out = []; new Set([3, 1, 2]).intersection(new Set([2, 3])).forEach(function(v) { out.push(v); }); out.join(',') === '3,2'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_intersection_accepts_map_keys() {
        assert_eval_true(
            "var r = new Set(['x', 'y', 'z']).intersection(new Map([['y', 1], ['x', 2]])); r.size === 2 && r.has('x') && r.has('y') && !r.has('z')",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_intersection_accepts_custom_set_like() {
        assert_eval_true(
            r#"
            var receiverSeen = false;
            var other = {
                get size() { return 2; },
                has: function(v) { receiverSeen = receiverSeen || this === other; return v === 2 || v === 4; },
                keys: function() { return { next: function() { return { done: true }; } }; }
            };
            var r = new Set([1, 2, 4]).intersection(other);
            receiverSeen && r.size === 2 && r.has(2) && r.has(4)
            "#,
        );
    }

    #[test]
    fn e2e_set_intersection_with_empty_other_is_empty() {
        assert_eval_true("new Set([1, 2]).intersection(new Set()).size === 0");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_difference_basic() {
        assert_eval_true(
            "var r = new Set([1, 2, 3]).difference(new Set([2, 4])); r.size === 2 && r.has(1) && r.has(3) && !r.has(2)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_difference_preserves_receiver_order() {
        assert_eval_true(
            "var out = []; new Set([3, 1, 2]).difference(new Set([2])).forEach(function(v) { out.push(v); }); out.join(',') === '3,1'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_difference_accepts_map_keys() {
        assert_eval_true(
            "var r = new Set(['a', 'b', 'c']).difference(new Map([['b', 1], ['x', 2]])); r.size === 2 && r.has('a') && r.has('c') && !r.has('b')",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_difference_accepts_custom_set_like() {
        assert_eval_true(
            r#"
            var other = {
                get size() { return 1; },
                has: function(v) { return v === 2; },
                keys: function() { return { next: function() { return { done: true }; } }; }
            };
            var r = new Set([1, 2, 3]).difference(other);
            r.size === 2 && r.has(1) && r.has(3) && !r.has(2)
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_difference_does_not_mutate_receiver() {
        assert_eval_true(
            "var a = new Set([1, 2, 3]); var r = a.difference(new Set([2])); a.size === 3 && a.has(2) && r.size === 2 && !r.has(2)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_symmetric_difference_basic() {
        assert_eval_true(
            "var r = new Set([1, 2, 3]).symmetricDifference(new Set([2, 4])); r.size === 3 && r.has(1) && r.has(3) && r.has(4) && !r.has(2)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_symmetric_difference_preserves_expected_order() {
        assert_eval_true(
            "var out = []; new Set([3, 1, 2]).symmetricDifference(new Set([2, 4, 5])).forEach(function(v) { out.push(v); }); out.join(',') === '3,1,4,5'",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_symmetric_difference_accepts_map_keys() {
        assert_eval_true(
            "var r = new Set(['a', 'b']).symmetricDifference(new Map([['b', 1], ['c', 2]])); r.size === 2 && r.has('a') && r.has('c') && !r.has('b')",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_symmetric_difference_accepts_custom_set_like() {
        assert_eval_true(
            r#"
            function iter(items) {
                var i = 0;
                return { next: function() {
                    if (i < items.length) return { value: items[i++], done: false };
                    return { done: true };
                }};
            }
            var other = {
                data: [2, 4],
                get size() { return this.data.length; },
                has: function(v) { return v === 2 || v === 4; },
                keys: function() { return iter(this.data); }
            };
            var r = new Set([1, 2, 3]).symmetricDifference(other);
            r.size === 3 && r.has(1) && r.has(3) && r.has(4)
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_symmetric_difference_does_not_mutate_receiver() {
        assert_eval_true(
            "var a = new Set([1, 2]); var r = a.symmetricDifference(new Set([2, 3])); a.size === 2 && a.has(2) && r.size === 2 && r.has(1) && r.has(3)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_symmetric_difference_deduplicates_other_iterator_values() {
        assert_eval_true(
            r#"
            function iter(items) {
                var i = 0;
                return { next: function() {
                    if (i < items.length) return { value: items[i++], done: false };
                    return { done: true };
                }};
            }
            var other = {
                get size() { return 3; },
                has: function(v) { return v === 2 || v === 4; },
                keys: function() { return iter([2, 4, 4]); }
            };
            var r = new Set([1, 2]).symmetricDifference(other);
            r.size === 2 && r.has(1) && r.has(4)
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_subset_of_true() {
        assert_eval_true("new Set([1, 2]).isSubsetOf(new Set([1, 2, 3])) === true");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_subset_of_false() {
        assert_eval_true("new Set([1, 4]).isSubsetOf(new Set([1, 2, 3])) === false");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_subset_of_accepts_map_keys() {
        assert_eval_true(
            "new Set(['a', 'b']).isSubsetOf(new Map([['a', 1], ['b', 2], ['c', 3]])) === true",
        );
    }

    #[test]
    fn e2e_set_is_subset_of_accepts_custom_set_like() {
        assert_eval_true(
            r#"
            var other = {
                get size() { return 3; },
                has: function(v) { return v === 1 || v === 2 || v === 3; },
                keys: function() { return { next: function() { return { done: true }; } }; }
            };
            new Set([1, 3]).isSubsetOf(other) === true
            "#,
        );
    }

    #[test]
    fn e2e_set_is_subset_of_uses_size_short_circuit() {
        assert_eval_true(
            r#"
            var hasCalls = 0;
            var other = {
                get size() { return 1; },
                has: function(v) { hasCalls++; return true; },
                keys: function() { return { next: function() { return { done: true }; } }; }
            };
            new Set([1, 2]).isSubsetOf(other) === false && hasCalls === 0
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_superset_of_true() {
        assert_eval_true("new Set([1, 2, 3]).isSupersetOf(new Set([1, 3])) === true");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_superset_of_false() {
        assert_eval_true("new Set([1, 2]).isSupersetOf(new Set([1, 3])) === false");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_superset_of_accepts_map_keys() {
        assert_eval_true(
            "new Set(['a', 'b', 'c']).isSupersetOf(new Map([['a', 1], ['c', 2]])) === true",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_superset_of_accepts_custom_set_like() {
        assert_eval_true(
            r#"
            function iter(items) {
                var i = 0;
                return { next: function() {
                    if (i < items.length) return { value: items[i++], done: false };
                    return { done: true };
                }};
            }
            var other = {
                data: [2, 3],
                get size() { return this.data.length; },
                has: function(v) { return v === 2 || v === 3; },
                keys: function() { return iter(this.data); }
            };
            new Set([1, 2, 3]).isSupersetOf(other) === true
            "#,
        );
    }

    #[test]
    fn e2e_set_is_superset_of_uses_size_short_circuit() {
        assert_eval_true(
            r#"
            var keysCalls = 0;
            var other = {
                get size() { return 3; },
                has: function(v) { return true; },
                keys: function() { keysCalls++; return { next: function() { return { done: true }; } }; }
            };
            new Set([1, 2]).isSupersetOf(other) === false && keysCalls === 0
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_disjoint_from_true() {
        assert_eval_true("new Set([1, 2]).isDisjointFrom(new Set([3, 4])) === true");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_disjoint_from_false() {
        assert_eval_true("new Set([1, 2]).isDisjointFrom(new Set([2, 4])) === false");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_set_is_disjoint_from_accepts_map_keys() {
        assert_eval_true(
            "new Set(['a', 'b']).isDisjointFrom(new Map([['c', 1], ['d', 2]])) === true",
        );
    }

    #[test]
    fn e2e_set_is_disjoint_from_accepts_custom_set_like() {
        assert_eval_true(
            r#"
            var other = {
                get size() { return 2; },
                has: function(v) { return v === 4 || v === 5; },
                keys: function() {
                    var i = 4;
                    return { next: function() {
                        if (i <= 5) return { value: i++, done: false };
                        return { done: true };
                    }};
                }
            };
            new Set([1, 2, 3]).isDisjointFrom(other) === true
            "#,
        );
    }

    #[test]
    fn e2e_set_is_disjoint_from_uses_smaller_receiver_branch() {
        assert_eval_true(
            r#"
            var hasCalls = 0;
            var keysCalls = 0;
            var other = {
                get size() { return 3; },
                has: function(v) { hasCalls++; return false; },
                keys: function() { keysCalls++; return { next: function() { return { done: true }; } }; }
            };
            new Set([1, 2]).isDisjointFrom(other) === true && hasCalls === 2 && keysCalls === 0
            "#,
        );
    }

    #[test]
    fn e2e_set_is_disjoint_from_uses_smaller_other_branch() {
        assert_eval_true(
            r#"
            var hasCalls = 0;
            var keysCalls = 0;
            var other = {
                get size() { return 1; },
                has: function(v) { hasCalls++; return false; },
                keys: function() {
                    keysCalls++;
                    var done = false;
                    return { next: function() {
                        if (!done) { done = true; return { value: 5, done: false }; }
                        return { done: true };
                    }};
                }
            };
            new Set([1, 2, 3]).isDisjointFrom(other) === true && hasCalls === 0 && keysCalls === 1
            "#,
        );
    }

    #[test]
    fn e2e_set_union_requires_has_property() {
        assert_eval_type_error(
            "new Set([1]).union({ size: 0, keys: function() { return { next: function() { return { done: true }; } }; } })",
        );
    }

    #[test]
    fn e2e_set_intersection_requires_size_property() {
        assert_eval_type_error(
            "new Set([1]).intersection({ has: function() { return false; }, keys: function() { return { next: function() { return { done: true }; } }; } })",
        );
    }

    #[test]
    fn e2e_set_difference_requires_callable_has() {
        assert_eval_type_error(
            "new Set([1]).difference({ size: 0, has: 1, keys: function() { return { next: function() { return { done: true }; } }; } })",
        );
    }

    #[test]
    fn e2e_set_symmetric_difference_requires_keys_iterator() {
        assert_eval_type_error(
            "new Set([1]).symmetricDifference({ size: 0, has: function() { return false; } })",
        );
    }

    #[test]
    fn e2e_set_is_subset_of_requires_has_property() {
        assert_eval_type_error(
            "new Set([1]).isSubsetOf({ size: 0, keys: function() { return { next: function() { return { done: true }; } }; } })",
        );
    }

    #[test]
    fn e2e_set_is_superset_of_requires_size_property() {
        assert_eval_type_error(
            "new Set([1]).isSupersetOf({ has: function() { return false; }, keys: function() { return { next: function() { return { done: true }; } }; } })",
        );
    }

    #[test]
    fn e2e_set_is_disjoint_from_requires_callable_has() {
        assert_eval_type_error(
            "new Set([1]).isDisjointFrom({ size: 0, has: null, keys: function() { return { next: function() { return { done: true }; } }; } })",
        );
    }

    // ═══════════════════════════════════════════════════════════════════════
    // E2E conformance: variable hoisting and scoping (30+ tests)
    // ═══════════════════════════════════════════════════════════════════════

    // ── var hoisting to function scope ───────────────────────────────────

    #[test]
    fn e2e_var_hoisted_undefined_before_assignment() {
        let result = global_eval("function f() { var r = x; var x = 5; return r; } f()").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_var_in_block_visible_outside() {
        let result = global_eval("function f() { { var x = 42; } return x; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_var_in_if_visible_outside() {
        let result =
            global_eval("function f() { if (true) { var x = 99; } return x; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    #[test]
    fn e2e_var_in_if_else_visible_outside() {
        let result = global_eval(
            "function f() { if (false) { var x = 1; } else { var y = 2; } return y; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_var_in_while_visible_outside() {
        let result = global_eval(
            "function f() { var i = 0; while (i < 1) { var x = 10; i++; } return x; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(10));
    }

    #[test]
    fn e2e_var_in_try_catch_visible_outside() {
        let result = global_eval(
            "function f() { try { var x = 1; throw 0; } catch(e) { var y = 2; } return x + y; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── var in for-loop body visible outside ─────────────────────────────

    #[test]
    fn e2e_var_in_for_init_visible_after() {
        let result =
            global_eval("function f() { for (var i = 0; i < 3; i++) {} return i; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_var_in_for_body_visible_after() {
        let result = global_eval(
            "function f() { for (var i = 0; i < 1; i++) { var x = 77; } return x; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(77));
    }

    #[test]
    fn e2e_var_in_for_in_visible_after() {
        let result = global_eval("function f() { for (var k in {a:1}) {} return k; } f()").unwrap();
        assert_eq!(result, JsValue::String("a".into()));
    }

    // ── Duplicate var declarations allowed ───────────────────────────────

    #[test]
    fn e2e_duplicate_var_allowed() {
        let result = global_eval("function f() { var x = 1; var x = 2; return x; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_duplicate_var_no_init_keeps_value() {
        let result = global_eval("function f() { var x = 5; var x; return x; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    fn e2e_duplicate_var_across_blocks() {
        let result =
            global_eval("function f() { var x = 1; { var x = 2; } return x; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    // ── Hoisted function declarations override var of same name ─────────

    #[test]
    fn e2e_fn_decl_overrides_var() {
        let result =
            global_eval("function f() { var g; function g() { return 42; } return g(); } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_fn_decl_hoisted_before_var_init() {
        let result =
            global_eval("function f() { var r = typeof g; function g() {} return r; } f()")
                .unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    #[test]
    fn e2e_var_init_overwrites_fn_decl() {
        let result =
            global_eval("function f() { var g = 99; function g() { return 1; } return g; } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    // ── let/const TDZ ───────────────────────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_let_tdz_throws() {
        let result = global_eval(
            "function f() { try { return x; } catch(e) { return 'caught'; } let x = 1; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("caught".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_const_tdz_throws() {
        let result = global_eval(
            "function f() { try { return x; } catch(e) { return 'caught'; } const x = 1; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("caught".into()));
    }

    #[test]
    fn e2e_let_tdz_in_block_shadows_outer() {
        let result = global_eval(
            "var x = 'outer'; var r; { try { r = x; } catch(e) { r = 'tdz'; } let x = 'inner'; } r",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("tdz".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_let_tdz_assignment_throws() {
        let result = global_eval(
            "function f() { try { x = 5; } catch(e) { return 'caught'; } let x; return x; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("caught".into()));
    }

    // ── const reassignment ──────────────────────────────────────────────

    #[test]
    fn e2e_hoisting_const_reassignment_throws() {
        let result = global_eval("const x = 1; x = 2;");
        assert!(result.is_err(), "const reassignment should throw");
    }

    // ── let/const block scoping ─────────────────────────────────────────

    #[test]
    fn e2e_hoisting_let_not_visible_outside_block() {
        let result = global_eval("{ let x = 1; } typeof x").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_hoisting_const_not_visible_outside_block() {
        let result = global_eval("{ const x = 1; } typeof x").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_let_separate_blocks_independent() {
        let result =
            global_eval("var r1, r2; { let x = 10; r1 = x; } { let x = 20; r2 = x; } r1 + r2")
                .unwrap();
        assert_eq!(result, JsValue::Smi(30));
    }

    #[test]
    fn e2e_let_in_for_not_visible_outside() {
        let result = global_eval("for (let i = 0; i < 3; i++) {} typeof i").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    // ── Function declarations in blocks (Annex B) ───────────────────────

    #[test]
    fn e2e_annex_b_fn_in_block_visible_in_function() {
        let result =
            global_eval("function f() { { function g() { return 42; } } return g(); } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_annex_b_fn_in_block_undefined_before_block() {
        let result = global_eval(
            "function f() { var r = typeof g; { function g() { return 1; } } return r; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_annex_b_fn_in_if_visible_in_function() {
        let result = global_eval(
            "function f() { if (true) { function g() { return 7; } } return g(); } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_annex_b_fn_in_block_at_program_level() {
        let result = global_eval("{ function inner() { return 55; } } inner()").unwrap();
        assert_eq!(result, JsValue::Smi(55));
    }

    // ── Combined scoping scenarios ──────────────────────────────────────

    #[test]
    fn e2e_var_and_let_coexist_in_function() {
        let result = global_eval(
            "function f() { var a = 1; let b = 2; { var c = 3; let d = 4; } return a + b + c; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    #[test]
    fn e2e_nested_function_var_hoisting() {
        let result = global_eval(
            "function outer() { function inner() { return x; var x = 10; } return inner(); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    #[test]
    fn e2e_var_in_switch_visible_outside() {
        let result =
            global_eval("function f() { switch(1) { case 1: var x = 42; break; } return x; } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_let_in_switch_block_scoped() {
        let result = global_eval("switch(1) { case 1: let x = 42; break; } typeof x").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_switch_uses_strict_equality_for_case_matching() {
        let result = global_eval(
            "var result = 'none'; switch ('1') { case 1: result = 'number'; break; case '1': result = 'string'; break; default: result = 'default'; } result",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("string".into()));
    }

    #[test]
    fn e2e_switch_does_not_match_nan() {
        let result =
            global_eval("var value = 0 / 0; switch (value) { case value: 1; default: 2; }")
                .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_switch_matches_objects_by_identity() {
        let result = global_eval(
            "var marker = {}; var other = {}; switch (marker) { case other: 0; case marker: 1; default: 2; }",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_switch_falls_through_without_break() {
        let result = global_eval(
            "var value = 0; switch (2) { case 1: value = 1; break; case 2: value = value + 2; case 3: value = value + 3; break; default: value = 99; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    fn e2e_switch_default_can_fall_through() {
        let result = global_eval(
            "var value = ''; switch (0) { case 1: value = 'one'; break; default: value = value + 'd'; case 2: value = value + '2'; case 3: value = value + '3'; break; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("d23".into()));
    }

    #[test]
    fn e2e_switch_default_clause_can_be_first() {
        let result = global_eval(
            "var value = ''; switch (9) { default: value = 'default'; break; case 1: value = 'one'; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("default".into()));
    }

    #[test]
    fn e2e_switch_default_clause_can_be_middle() {
        let result = global_eval(
            "var value = ''; switch (9) { case 1: value = 'one'; break; default: value = 'default'; case 3: value = value + ':three'; break; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("default:three".into()));
    }

    #[test]
    fn e2e_switch_default_clause_can_be_last() {
        let result = global_eval(
            "var value = ''; switch (9) { case 1: value = 'one'; break; case 2: value = 'two'; break; default: value = 'default'; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("default".into()));
    }

    #[test]
    fn e2e_switch_match_after_default_skips_default_when_default_is_first() {
        let result = global_eval(
            "var value = ''; switch (2) { default: value = value + 'd'; case 1: value = value + '1'; break; case 2: value = value + '2'; break; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("2".into()));
    }

    #[test]
    fn e2e_switch_match_after_default_skips_default_when_default_is_middle() {
        let result = global_eval(
            "var value = ''; switch (3) { case 1: value = value + '1'; break; default: value = value + 'd'; case 3: value = value + '3'; break; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("3".into()));
    }

    #[test]
    fn e2e_switch_match_before_default_falls_through_default() {
        let result = global_eval(
            "var value = ''; switch (1) { case 1: value = value + '1'; default: value = value + 'd'; case 2: value = value + '2'; break; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1d2".into()));
    }

    #[test]
    fn e2e_switch_return_exits_function_on_case() {
        let result = global_eval(
            "function f(value) { switch (value) { case 1: return 'case'; default: return 'default'; } } f(1)",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("case".into()));
    }

    #[test]
    fn e2e_switch_return_exits_function_on_default() {
        let result = global_eval(
            "function f(value) { switch (value) { case 1: return 'case'; default: return 'default'; } } f(2)",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("default".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_const_in_switch_block_scoped() {
        let result = global_eval("switch (1) { case 1: const x = 42; break; } typeof x").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_switch_duplicate_let_across_cases_is_syntax_error() {
        let result =
            global_eval("switch (1) { case 1: let x = 1; break; case 2: let x = 2; break; }")
                .unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_switch_duplicate_const_across_cases_is_syntax_error() {
        let result =
            global_eval("switch (1) { case 1: const x = 1; break; case 2: const x = 2; break; }")
                .unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_switch_braces_give_each_case_its_own_let_scope() {
        let result = global_eval(
            "function f(value) { switch (value) { case 1: { let x = 1; return x; } case 2: { let x = 2; return x; } default: return 3; } } f(2)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_switch_braces_give_each_case_its_own_const_scope() {
        let result = global_eval(
            "function f(value) { switch (value) { case 1: { const x = 1; return x; } case 2: { const x = 2; return x; } default: return 3; } } f(1)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_switch_case_expressions_stop_after_first_match() {
        let result = global_eval(
            "var log = ''; function tag(n) { log = log + n; return n; } var value = 0; switch (2) { case tag(1): value = 1; break; case tag(2): value = 2; break; case tag(3): value = 3; break; } log + ':' + value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("12:2".into()));
    }

    #[test]
    fn e2e_switch_case_expressions_continue_in_order_past_default() {
        let result = global_eval(
            "var log = ''; function tag(n) { log = log + n; return n; } var value = ''; switch (3) { case tag(1): value = 'one'; break; default: value = 'default'; break; case tag(3): value = 'three'; break; } log + ':' + value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("13:three".into()));
    }

    #[test]
    fn e2e_switch_no_match_evaluates_all_case_expressions_before_default() {
        let result = global_eval(
            "var log = ''; function tag(n) { log = log + n; return n; } var value = ''; switch (9) { case tag(1): value = 'one'; break; default: value = 'default'; break; case tag(2): value = 'two'; break; } log + ':' + value",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("12:default".into()));
    }

    #[test]
    fn e2e_debug_global_mutation_basic() {
        // Test 1: Basic global mutation through function call
        let r1 = global_eval("var x = 0; function inc() { x = x + 1; } inc(); x").unwrap();
        eprintln!("DEBUG T1 basic mutation: {:?}", r1);
        assert_eq!(
            r1,
            JsValue::Smi(1),
            "basic global var mutation through function call"
        );
    }

    #[test]
    fn e2e_debug_global_mutation_string_concat() {
        // Test 2: String concat global mutation
        let r2 = global_eval("var s = ''; function add(v) { s = s + v; } add('a'); s").unwrap();
        eprintln!("DEBUG T2 string concat: {:?}", r2);
        assert_eq!(
            r2,
            JsValue::String("a".into()),
            "string concat global mutation"
        );
    }

    #[test]
    fn e2e_debug_global_mutation_multi_call() {
        // Test 3: Multiple calls
        let r3 = global_eval("var s = ''; function add(v) { s = s + v; } add('a'); add('b'); s")
            .unwrap();
        eprintln!("DEBUG T3 multi call: {:?}", r3);
        assert_eq!(r3, JsValue::String("ab".into()), "multi-call string concat");
    }

    #[test]
    fn e2e_debug_global_mutation_with_return() {
        // Test 4: Function returns AND mutates global
        let r4 = global_eval(
            "var s = ''; function tag(n) { s = s + n; return n; } var r = tag(1); s + ':' + r",
        )
        .unwrap();
        eprintln!("DEBUG T4 return+mutate: {:?}", r4);
        assert_eq!(
            r4,
            JsValue::String("1:1".into()),
            "function return + global mutation"
        );
    }

    #[test]
    fn e2e_debug_global_mutation_in_switch_expr() {
        // Test 5: Minimal switch with function call in case expr
        let r5 = global_eval("var s = ''; function tag(n) { s = s + n; return n; } switch(1) { case tag(1): break; } s").unwrap();
        eprintln!("DEBUG T5 switch case expr: {:?}", r5);
        assert_eq!(
            r5,
            JsValue::String("1".into()),
            "global mutation in switch case expression"
        );
    }

    #[test]
    fn e2e_break_inside_switch_only_exits_switch() {
        let result = global_eval(
            "var hits = 0; for (var i = 0; i < 3; i++) { switch (i) { case 1: break; default: hits = hits + 1; } } hits",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    #[test]
    fn e2e_break_label_can_exit_labeled_switch() {
        let result = global_eval(
            "var value = 0; outer: switch (2) { case 2: value = 1; break outer; value = 2; default: value = 3; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_switch_rejects_multiple_default_clauses() {
        let result = global_eval("switch (1) { default: 1; default: 2; }").unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    fn e2e_label_can_target_expression_statement() {
        let result = global_eval("done: 1 + 2; 7").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_label_can_target_if_statement() {
        let result = global_eval(
            "var value = 0; done: if (true) { value = 1; break done; value = 2; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_break_label_exits_nested_block() {
        let result =
            global_eval("var value = 0; outer: { value = 1; { break outer; } value = 2; } value")
                .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_break_label_exits_outer_loop_from_inner_loop() {
        let result = global_eval(
            "var hits = 0; outer: for (var i = 0; i < 3; i++) { for (var j = 0; j < 3; j++) { hits = hits + 1; break outer; } } hits",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_continue_label_continues_outer_loop_from_inner_loop() {
        let result = global_eval(
            "var hits = 0; outer: for (var i = 0; i < 3; i++) { for (var j = 0; j < 3; j++) { hits = hits + 1; continue outer; } } hits",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_continue_label_can_target_middle_loop() {
        let result = global_eval(
            "var sum = 0; outer: for (var i = 0; i < 3; i++) { middle: for (var j = 0; j < 3; j++) { for (var k = 0; k < 3; k++) { if (k < 1) { sum = sum + 1; } else { continue middle; } sum = sum + 10; } } } sum",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    #[test]
    fn e2e_nested_labeled_loops_break_inner_label() {
        let result = global_eval(
            "var hits = 0; outer: for (var i = 0; i < 2; i++) { inner: for (var j = 0; j < 3; j++) { hits = hits + 1; break inner; } hits = hits + 10; } hits",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(22));
    }

    #[test]
    fn e2e_nested_labeled_loops_break_outer_label() {
        let result = global_eval(
            "var hits = 0; outer: for (var i = 0; i < 3; i++) { middle: for (var j = 0; j < 3; j++) { hits = hits + 1; break outer; } } hits",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_labeled_block_break_exits_only_target_block() {
        let result = global_eval(
            "var value = 0; outer: { value = 1; inner: { value = value + 1; break inner; value = 99; } value = value + 1; } value",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    #[test]
    fn e2e_labeled_block_inside_loop_breaks_only_block() {
        let result = global_eval(
            "var hits = 0; for (var i = 0; i < 2; i++) { block: { hits = hits + 1; break block; hits = hits + 100; } hits = hits + 10; } hits",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(22));
    }

    #[test]
    fn e2e_label_on_switch_inside_loop_can_continue_outer_loop() {
        let result = global_eval(
            "var hits = 0; outer: for (var i = 0; i < 3; i++) { dispatch: switch (i) { case 0: hits = hits + 1; continue outer; case 1: hits = hits + 10; break dispatch; default: hits = hits + 100; } hits = hits + 1000; } hits",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2111));
    }

    #[test]
    fn e2e_continue_non_loop_label_is_syntax_error() {
        let result = global_eval("label: { continue label; }").unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    fn e2e_break_undefined_label_is_syntax_error() {
        let result = global_eval("label: { break missing; }").unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    fn e2e_duplicate_labels_are_syntax_error() {
        let result = global_eval("dup: dup: 1").unwrap_err();
        assert!(matches!(result, StatorError::SyntaxError(_)));
    }

    #[test]
    fn e2e_var_hoisted_across_nested_blocks() {
        let result =
            global_eval("function f() { { { { var deep = 99; } } } return deep; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    #[test]
    fn e2e_function_hoisting_before_code_program() {
        let result = global_eval("var r = f(); function f() { return 'hoisted'; } r").unwrap();
        assert_eq!(result, JsValue::String("hoisted".into()));
    }

    #[test]
    fn e2e_function_hoisting_inside_function() {
        let result = global_eval(
            "function outer() { var r = inner(); function inner() { return 7; } return r; } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_var_hoisted_in_catch_block() {
        let result =
            global_eval("function f() { try { throw 1; } catch(e) { var x = 42; } return x; } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_let_tdz_function_param_shadows() {
        let result = global_eval(
            "function f(x) { { try { return x; } catch(e) { return 'tdz'; } let x = 99; } } f(1)",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("tdz".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_tdz_typeof_let_throws_reference_error() {
        let result =
            global_eval("function f() { try { return typeof value; } catch (e) { return e.name; } let value = 1; } f()")
                .unwrap();
        assert_eq!(result, JsValue::String("ReferenceError".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_tdz_typeof_const_throws_reference_error() {
        let result = global_eval(
            "function f() { try { return typeof value; } catch (e) { return e.name; } const value = 1; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("ReferenceError".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_switch_tdz_spans_entire_block_for_let() {
        let result = global_eval(
            "function f(tag) { switch (tag) { case 0: try { return x; } catch (e) { return e.name; } case 1: let x = 1; return x; default: return 'none'; } } f(0)",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("ReferenceError".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_switch_tdz_spans_entire_block_for_const() {
        let result = global_eval(
            "function f(tag) { switch (tag) { case 0: try { return x; } catch (e) { return e.name; } case 1: const x = 1; return x; default: return 'none'; } } f(0)",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("ReferenceError".into()));
    }

    #[test]
    fn e2e_nested_block_let_shadowing_keeps_outer_value() {
        let result = global_eval("let x = 'outer'; { let x = 'inner'; } x").unwrap();
        assert_eq!(result, JsValue::String("outer".into()));
    }

    #[test]
    fn e2e_nested_block_const_shadowing_keeps_outer_value() {
        let result = global_eval("const x = 'outer'; { const x = 'inner'; } x").unwrap();
        assert_eq!(result, JsValue::String("outer".into()));
    }

    #[test]
    fn e2e_var_inside_block_hoists_to_function_scope() {
        let result =
            global_eval("function f() { if (true) { var x = 42; } return x; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    #[test]
    fn e2e_let_inside_if_does_not_leak() {
        let result = global_eval("if (true) { let hidden = 1; } typeof hidden").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_const_inside_if_does_not_leak() {
        let result = global_eval("if (true) { const hidden = 1; } typeof hidden").unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_closure_captures_outer_var_binding() {
        let result = global_eval(
            "function outer() { var x = 5; return function() { return x; }; } outer()()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_closure_captures_outer_let_binding() {
        let result = global_eval(
            "function outer() { let x = 6; return function() { return x; }; } outer()()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(6));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_closure_observes_var_updates() {
        let result = global_eval(
            "function outer() { var x = 1; var read = function() { return x; }; x = 9; return read(); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_closure_observes_let_updates() {
        let result = global_eval(
            "function outer() { let x = 2; var read = function() { return x; }; x = 8; return read(); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(8));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_closure_instances_keep_separate_var_state() {
        let result = global_eval(
            "function makeCounter() { var x = 0; return function() { x = x + 1; return x; }; } var a = makeCounter(); var b = makeCounter(); a() + ',' + a() + ',' + b()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("1,2,1".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_var_closures_share_final_binding() {
        let result = global_eval(
            "function f() { var out = []; var fns = []; for (var i = 0; i < 3; i++) { fns.push(function() { return i; }); } for (var j = 0; j < 3; j++) out.push(fns[j]()); return out.join(','); } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("3,3,3".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_let_closures_get_fresh_bindings() {
        let result = global_eval(
            "function f() { var out = []; var fns = []; for (let i = 0; i < 3; i++) { fns.push(function() { return i; }); } for (var j = 0; j < 3; j++) out.push(fns[j]()); return out.join(','); } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("0,1,2".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_let_closures_keep_iteration_assignment() {
        let result = global_eval(
            "function f() { var out = []; var fns = []; for (let i = 0; i < 3; i++) { i = i + 10; fns.push(function() { return i; }); } for (var j = 0; j < 3; j++) out.push(fns[j]()); return out.join(','); } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("10,11,12".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_for_let_closure_inside_nested_block_uses_iteration_binding() {
        let result = global_eval(
            "function f() { var out = []; var fns = []; for (let i = 0; i < 3; i++) { { fns.push(function() { return i; }); } } for (var j = 0; j < 3; j++) out.push(fns[j]()); return out.join(','); } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("0,1,2".into()));
    }

    #[test]
    fn e2e_function_decl_hoists_before_first_statement_in_function() {
        let result = global_eval(
            "function outer() { return inner(); function inner() { return 12; } } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(12));
    }

    #[test]
    fn e2e_strict_block_function_is_block_scoped() {
        let result = global_eval(
            "function f() { 'use strict'; { function g() { return 1; } } return typeof g; } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_sloppy_block_function_uses_annex_b_binding() {
        let result = global_eval(
            "function f() { if (true) { function g() { return 21; } } return g(); } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(21));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_const_reassignment_in_function_reports_type_error_name() {
        let result = global_eval(
            "function f() { const x = 1; try { x = 2; } catch (e) { return e.name; } } f()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("TypeError".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_const_reassignment_in_block_reports_type_error_name() {
        let result =
            global_eval("{ const x = 1; try { x = 2; } catch (e) { x; return e.name; } }").unwrap();
        assert_eq!(result, JsValue::String("TypeError".into()));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arguments_mapped_param_reads_arguments_assignment() {
        let result = global_eval("function f(a) { arguments[0] = 7; return a; } f(1)").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arguments_mapped_arguments_reads_param_assignment() {
        let result = global_eval("function f(a) { a = 9; return arguments[0]; } f(1)").unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    fn e2e_arguments_unmapped_param_ignores_arguments_assignment() {
        let result =
            global_eval("function f(a) { 'use strict'; arguments[0] = 7; return a; } f(1)")
                .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    fn e2e_arguments_unmapped_arguments_ignore_param_assignment() {
        let result =
            global_eval("function f(a) { 'use strict'; a = 9; return arguments[0]; } f(1)")
                .unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_arguments_callee_sloppy_mode_returns_function_name() {
        let result =
            global_eval("function outer() { return arguments.callee.name; } outer()").unwrap();
        assert_eq!(result, JsValue::String("outer".into()));
    }

    #[test]
    fn e2e_direct_eval_reads_outer_var_binding() {
        let result =
            global_eval("function outer() { var x = 7; return eval('x'); } outer()").unwrap();
        assert_eq!(result, JsValue::Smi(7));
    }

    #[test]
    fn e2e_direct_eval_reads_outer_parameter_binding() {
        let result = global_eval("function outer(x) { return eval('x'); } outer(13)").unwrap();
        assert_eq!(result, JsValue::Smi(13));
    }

    #[test]
    fn e2e_direct_eval_var_leaks_to_calling_scope() {
        let result =
            global_eval("function outer() { eval('var leaked = 9'); return leaked; } outer()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(9));
    }

    #[test]
    fn e2e_direct_strict_eval_reads_outer_var_without_leaking() {
        let result = global_eval(
            "function outer() { var x = 4; return eval(\"'use strict'; x\"); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_direct_strict_eval_does_not_leak_var_declaration() {
        let result = global_eval(
            "function outer() { eval(\"'use strict'; var hidden = 5\"); return typeof hidden; } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_direct_eval_declared_function_is_visible_in_caller_scope() {
        let result = global_eval(
            "function outer() { eval('function inner() { return 17; }'); return inner(); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(17));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_direct_strict_eval_declared_function_is_not_visible_after_eval() {
        let result = global_eval(
            "function outer() { eval(\"'use strict'; function inner() { return 17; }\"); return typeof inner; } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("undefined".into()));
    }

    #[test]
    fn e2e_direct_eval_can_update_outer_var_through_closure_binding() {
        let result =
            global_eval("function outer() { var x = 1; eval('x = 11'); return x; } outer()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(11));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_nested_closure_reads_updated_outer_binding_after_eval() {
        let result = global_eval(
            "function outer() { var x = 1; var read = function() { return x; }; eval('x = 14'); return read(); } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(14));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_closure_can_read_function_body_let_binding() {
        let result = global_eval(
            "function outer() { let x = 22; return function() { return x; }; } outer()()",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(22));
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_function_body_let_is_in_tdz_before_declaration() {
        let result = global_eval(
            "function outer() { try { return x; } catch (e) { return e.name; } let x = 22; } outer()",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("ReferenceError".into()));
    }

    // ── Iterator protocol deep conformance tests ────────────────────────

    /// Custom Symbol.iterator: for-of consumes all values.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_custom_symbol_iterator_for_of() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 3) return { value: n * 100, done: false };
                        return { value: undefined, done: true };
                    }
                };
            };
            var r = []; for (var v of obj) r.push(v); r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("100,200,300".into()));
    }

    /// Iterator .return() is called on break in for-of.
    #[test]
    #[ignore] // TODO: hangs in CI – fix iterator return protocol on break
    fn e2e_iter_return_called_on_break() {
        let r = global_eval(
            r#"
            var log = [];
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        log.push('next' + n);
                        return { value: n, done: n > 5 };
                    },
                    return: function() {
                        log.push('return');
                        return { done: true };
                    }
                };
            };
            for (var v of obj) { if (v === 2) break; }
            log.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("next1,next2,return".into()));
    }

    /// Iterator .return() NOT called on normal completion.
    #[test]
    fn e2e_iter_return_not_called_on_normal_completion() {
        let r = global_eval(
            r#"
            var returnCalled = false;
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 2) return { value: n, done: false };
                        return { done: true };
                    },
                    return: function() {
                        returnCalled = true;
                        return { done: true };
                    }
                };
            };
            for (var v of obj) { }
            returnCalled
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// Iterator .return() called when returning from function inside for-of.
    #[test]
    #[ignore] // TODO: hangs in CI – fix iterator return-on-function-return
    fn e2e_iter_return_called_on_function_return() {
        let r = global_eval(
            r#"
            var returnCalled = false;
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        return { value: n, done: n > 10 };
                    },
                    return: function() {
                        returnCalled = true;
                        return { done: true };
                    }
                };
            };
            function f() {
                for (var v of obj) {
                    if (v === 3) return v;
                }
            }
            f();
            returnCalled
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Spread in array literal uses custom iterator protocol.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iter_spread_array_uses_custom_iterator() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 3) return { value: n * 10, done: false };
                        return { done: true };
                    }
                };
            };
            var a = [0, ...obj, 40];
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("0,10,20,30,40".into()));
    }

    /// Spread custom iterator in function call arguments.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iter_spread_custom_in_call() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 3) return { value: n, done: false };
                        return { done: true };
                    }
                };
            };
            function sum(a, b, c) { return a + b + c; }
            sum(...obj)
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(6));
    }

    /// Array destructuring uses iterator protocol with custom Symbol.iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_destructuring_uses_custom_iterator() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 3) return { value: n * 11, done: false };
                        return { done: true };
                    }
                };
            };
            var [a, b, c] = obj;
            a + ',' + b + ',' + c
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("11,22,33".into()));
    }

    /// Array destructuring with rest uses custom iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_destructuring_rest_custom_iterator() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 4) return { value: n, done: false };
                        return { done: true };
                    }
                };
            };
            var [first, ...rest] = obj;
            first + '|' + rest.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1|2,3,4".into()));
    }

    /// for-of on number throws TypeError.
    #[test]
    fn e2e_iter_for_of_number_throws() {
        let r = global_eval(
            r#"
            try { for (var x of 42) {} 'no error'; } catch(e) { e instanceof TypeError ? 'TypeError' : 'other'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("TypeError".into()));
    }

    /// for-of on boolean throws TypeError.
    #[test]
    fn e2e_iter_for_of_boolean_throws() {
        let r = global_eval(
            r#"
            try { for (var x of true) {} 'no error'; } catch(e) { e instanceof TypeError ? 'TypeError' : 'other'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("TypeError".into()));
    }

    /// for-of on null throws TypeError.
    #[test]
    fn e2e_iter_for_of_null_throws() {
        let r = global_eval(
            r#"
            try { for (var x of null) {} 'no error'; } catch(e) { e instanceof TypeError ? 'TypeError' : 'other'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("TypeError".into()));
    }

    /// for-of on undefined throws TypeError.
    #[test]
    fn e2e_iter_for_of_undefined_throws() {
        let r = global_eval(
            r#"
            try { for (var x of undefined) {} 'no error'; } catch(e) { e instanceof TypeError ? 'TypeError' : 'other'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("TypeError".into()));
    }

    /// for-of on plain object without Symbol.iterator throws TypeError.
    #[test]
    fn e2e_iter_for_of_plain_object_throws() {
        let r = global_eval(
            r#"
            try { for (var x of {a:1}) {} 'no error'; } catch(e) { e instanceof TypeError ? 'TypeError' : 'other'; }
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("TypeError".into()));
    }

    /// Iterator result with done: 0 (falsy) continues iteration.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_done_zero_is_falsy() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n === 1) return { value: 'a', done: 0 };
                        if (n === 2) return { value: 'b', done: false };
                        return { done: true };
                    }
                };
            };
            var r = []; for (var v of obj) r.push(v); r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a,b".into()));
    }

    /// Iterator result with done: 1 (truthy) stops iteration.
    #[test]
    fn e2e_iter_done_one_is_truthy() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                return {
                    next: function() { return { value: 99, done: 1 }; }
                };
            };
            var r = []; for (var v of obj) r.push(v); r.length
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// Iterator result with done: null (falsy) continues.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_done_null_is_falsy() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n === 1) return { value: 'x', done: null };
                        return { done: true };
                    }
                };
            };
            var r = []; for (var v of obj) r.push(v); r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("x".into()));
    }

    /// Iterator value defaults to undefined when missing.
    #[test]
    fn e2e_iter_missing_value_is_undefined() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n === 1) return { done: false };
                        return { done: true };
                    }
                };
            };
            var r; for (var v of obj) r = v; r === undefined
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Nested for-of with custom iterators.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_nested_custom_iterators() {
        let r = global_eval(
            r#"
            function makeIter(items) {
                var obj = {};
                obj[Symbol.iterator] = function() {
                    var i = 0;
                    return {
                        next: function() {
                            if (i < items.length) return { value: items[i++], done: false };
                            return { done: true };
                        }
                    };
                };
                return obj;
            }
            var r = [];
            for (var a of makeIter([1, 2])) {
                for (var b of makeIter([10, 20])) {
                    r.push(a + b);
                }
            }
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("11,21,12,22".into()));
    }

    /// for-of with let binding and custom iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_for_of_let_binding() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 3) return { value: n, done: false };
                        return { done: true };
                    }
                };
            };
            var r = [];
            for (let v of obj) r.push(v);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// for-of with const binding and custom iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_for_of_const_binding() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 2) return { value: n * 5, done: false };
                        return { done: true };
                    }
                };
            };
            var r = [];
            for (const v of obj) r.push(v);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("5,10".into()));
    }

    /// Custom iterator yielding objects.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iter_yields_objects() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var items = [{ x: 1 }, { x: 2 }];
                var i = 0;
                return {
                    next: function() {
                        if (i < items.length) return { value: items[i++], done: false };
                        return { done: true };
                    }
                };
            };
            var sum = 0;
            for (var item of obj) sum += item.x;
            sum
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// Stateful iterator: each for-of creates a fresh iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_fresh_iterator_each_loop() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 3) return { value: n, done: false };
                        return { done: true };
                    }
                };
            };
            var r1 = []; for (var v of obj) r1.push(v);
            var r2 = []; for (var v of obj) r2.push(v);
            r1.join(',') + '|' + r2.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2,3|1,2,3".into()));
    }

    /// for-of continue does NOT call .return().
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_continue_does_not_call_return() {
        let r = global_eval(
            r#"
            var returnCalled = false;
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 3) return { value: n, done: false };
                        return { done: true };
                    },
                    return: function() {
                        returnCalled = true;
                        return { done: true };
                    }
                };
            };
            var r = [];
            for (var v of obj) { if (v === 2) continue; r.push(v); }
            returnCalled + '|' + r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("false|1,3".into()));
    }

    /// Destructuring with default values and custom iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_destructuring_defaults_custom() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var items = [10, undefined];
                var i = 0;
                return {
                    next: function() {
                        if (i < items.length) return { value: items[i++], done: false };
                        return { done: true };
                    }
                };
            };
            var [a = 1, b = 2, c = 3] = obj;
            a + ',' + b + ',' + c
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("10,2,3".into()));
    }

    /// Spread of empty custom iterator.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iter_spread_empty_custom() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                return {
                    next: function() { return { done: true }; }
                };
            };
            var a = [...obj];
            a.length
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// for-of with throw in body calls .return() on iterator.
    #[test]
    #[ignore] // TODO: hangs in CI – fix iterator return-on-throw
    fn e2e_iter_return_called_on_throw() {
        let r = global_eval(
            r#"
            var returnCalled = false;
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        return { value: n, done: n > 10 };
                    },
                    return: function() {
                        returnCalled = true;
                        return { done: true };
                    }
                };
            };
            try {
                for (var v of obj) {
                    if (v === 2) throw new Error('stop');
                }
            } catch(e) {}
            returnCalled
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// Nested for-of break only closes inner iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_nested_break_closes_inner_only() {
        let r = global_eval(
            r#"
            var outerReturns = 0;
            var innerReturns = 0;
            function makeIter(name, count) {
                var obj = {};
                obj[Symbol.iterator] = function() {
                    var n = 0;
                    return {
                        next: function() {
                            n++;
                            if (n <= count) return { value: n, done: false };
                            return { done: true };
                        },
                        return: function() {
                            if (name === 'outer') outerReturns++;
                            else innerReturns++;
                            return { done: true };
                        }
                    };
                };
                return obj;
            }
            var r = [];
            for (var a of makeIter('outer', 2)) {
                for (var b of makeIter('inner', 3)) {
                    r.push(a + '-' + b);
                    if (b === 2) break;
                }
            }
            r.join(',') + '|' + outerReturns + '|' + innerReturns
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1-1,1-2,2-1,2-2|0|2".into()));
    }

    /// for-of with object destructuring and custom iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_for_of_object_destructuring_custom() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var items = [{ a: 1, b: 2 }, { a: 3, b: 4 }];
                var i = 0;
                return {
                    next: function() {
                        if (i < items.length) return { value: items[i++], done: false };
                        return { done: true };
                    }
                };
            };
            var r = [];
            for (var { a, b } of obj) r.push(a + b);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("3,7".into()));
    }

    /// new Set() with custom iterable.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iter_set_from_custom_iterable() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var items = [1, 2, 2, 3, 3, 3];
                var i = 0;
                return {
                    next: function() {
                        if (i < items.length) return { value: items[i++], done: false };
                        return { done: true };
                    }
                };
            };
            var s = new Set(obj);
            s.size
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// new Map() with custom iterable of [key, value] pairs.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_map_from_custom_iterable() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var items = [["a", 1], ["b", 2]];
                var i = 0;
                return {
                    next: function() {
                        if (i < items.length) return { value: items[i++], done: false };
                        return { done: true };
                    }
                };
            };
            var m = new Map(obj);
            m.get("a") + m.get("b")
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// Array.from with custom iterable.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_array_from_custom_iterable() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 3) return { value: n * 2, done: false };
                        return { done: true };
                    }
                };
            };
            var a = Array.from(obj);
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2,4,6".into()));
    }

    /// for-of generator: .return() terminates generator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_generator_return_on_break() {
        let r = global_eval(
            r#"
            var finallyRan = false;
            function* gen() {
                try { yield 1; yield 2; yield 3; }
                finally { finallyRan = true; }
            }
            for (var v of gen()) { if (v === 1) break; }
            finallyRan
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// String iteration yields code points (including multi-byte).
    #[test]
    fn e2e_iter_string_code_points() {
        let r = global_eval("var r = []; for (var c of 'AB') r.push(c); r.join(',')").unwrap();
        assert_eq!(r, JsValue::String("A,B".into()));
    }

    /// Spread string produces individual characters.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iter_spread_string_chars() {
        let r = global_eval("[...'abc'].join('-')").unwrap();
        assert_eq!(r, JsValue::String("a-b-c".into()));
    }

    /// Destructuring string yields characters.
    #[test]
    fn e2e_iter_destructuring_string_chars() {
        let r = global_eval("var [a, b, c] = 'XYZ'; a + b + c").unwrap();
        assert_eq!(r, JsValue::String("XYZ".into()));
    }

    /// Iterator without .return() method — break still works.
    #[test]
    #[ignore] // TODO: hangs in CI – fix for-of break with custom iterator
    fn e2e_iter_break_without_return_method() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        return { value: n, done: n > 100 };
                    }
                };
            };
            var last;
            for (var v of obj) { last = v; if (v === 3) break; }
            last
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// for-of with array destructuring in loop variable.
    #[test]
    fn e2e_iter_for_of_array_destructuring_in_head() {
        let r = global_eval(
            r#"
            var pairs = [[1, 'a'], [2, 'b'], [3, 'c']];
            var r = [];
            for (var [num, letter] of pairs) r.push(letter + num);
            r.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a1,b2,c3".into()));
    }

    /// Spread generator into array.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_iter_spread_generator_into_array() {
        let r = global_eval(
            r#"
            function* g() { yield 10; yield 20; yield 30; }
            var a = [...g()];
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("10,20,30".into()));
    }

    /// Destructuring assignment (not declaration) with custom iterator.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_destructuring_assignment_custom() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var items = [100, 200];
                var i = 0;
                return {
                    next: function() {
                        if (i < items.length) return { value: items[i++], done: false };
                        return { done: true };
                    }
                };
            };
            var a, b;
            [a, b] = obj;
            a + b
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(300));
    }

    /// Multiple spreads of same iterable create independent iterators.
    #[test]
    #[ignore] // TODO: custom iterator support needed
    fn e2e_iter_multiple_spread_independent() {
        let r = global_eval(
            r#"
            var obj = {};
            obj[Symbol.iterator] = function() {
                var n = 0;
                return {
                    next: function() {
                        n++;
                        if (n <= 2) return { value: n, done: false };
                        return { done: true };
                    }
                };
            };
            var a = [...obj, ...obj];
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2,1,2".into()));
    }

    // ── Error.cause and subtype conformance tests ────────────────────────

    /// Error with cause: `new Error("x", { cause: 42 }).cause` → 42
    #[test]
    fn e2e_error_cause_number() {
        let result = global_eval(r#"new Error("x", { cause: 42 }).cause"#).unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Error with cause: string value
    #[test]
    fn e2e_error_cause_string() {
        let result = global_eval(r#"new Error("x", { cause: "root" }).cause"#).unwrap();
        assert_eq!(result, JsValue::String("root".into()));
    }

    /// Error with cause: another error
    #[test]
    fn e2e_error_cause_is_error() {
        let result = global_eval(
            r#"var inner = new Error("inner"); var outer = new Error("outer", { cause: inner }); outer.cause.message"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("inner".into()));
    }

    /// TypeError supports cause option
    #[test]
    fn e2e_type_error_cause_v2() {
        let result = global_eval(r#"new TypeError("bad", { cause: "reason" }).cause"#).unwrap();
        assert_eq!(result, JsValue::String("reason".into()));
    }

    /// RangeError supports cause option
    #[test]
    fn e2e_range_error_cause() {
        let result = global_eval(r#"new RangeError("oor", { cause: 99 }).cause"#).unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// ReferenceError supports cause option
    #[test]
    fn e2e_reference_error_cause() {
        let result = global_eval(r#"new ReferenceError("x", { cause: null }).cause"#).unwrap();
        assert_eq!(result, JsValue::Null);
    }

    /// SyntaxError supports cause option
    #[test]
    fn e2e_syntax_error_cause() {
        let result = global_eval(r#"new SyntaxError("bad", { cause: false }).cause"#).unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// URIError supports cause option
    #[test]
    fn e2e_uri_error_cause() {
        let result = global_eval(r#"new URIError("bad", { cause: true }).cause"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// EvalError supports cause option
    #[test]
    fn e2e_eval_error_cause() {
        let result = global_eval(r#"new EvalError("bad", { cause: 0 }).cause"#).unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// AggregateError supports cause option (third arg)
    #[test]
    fn e2e_aggregate_error_cause_v2() {
        let result =
            global_eval(r#"new AggregateError([], "msg", { cause: "root" }).cause"#).unwrap();
        assert_eq!(result, JsValue::String("root".into()));
    }

    /// AggregateError .errors returns an array
    #[test]
    fn e2e_aggregate_error_errors_length() {
        let result = global_eval(
            r#"var e = new AggregateError([new Error("a"), new Error("b")], "two"); e.errors.length"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// AggregateError .errors[0] is an Error
    #[test]
    fn e2e_aggregate_error_errors_element_name() {
        let result = global_eval(
            r#"var e = new AggregateError([new TypeError("t")], "one"); e.errors[0].name"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("TypeError".into()));
    }

    /// AggregateError empty errors
    #[test]
    fn e2e_aggregate_error_empty_errors() {
        let result = global_eval(r#"new AggregateError([], "none").errors.length"#).unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// Error.prototype.name default is "Error"
    #[test]
    fn e2e_error_prototype_name_default() {
        let result = global_eval("Error.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("Error".into()));
    }

    /// Error.prototype.message default is ""
    #[test]
    fn e2e_error_prototype_message_default_v2() {
        let result = global_eval("Error.prototype.message").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    /// TypeError.prototype.name is "TypeError"
    #[test]
    fn e2e_type_error_prototype_name_v2() {
        let result = global_eval("TypeError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("TypeError".into()));
    }

    /// RangeError.prototype.name is "RangeError"
    #[test]
    fn e2e_range_error_prototype_name_v2() {
        let result = global_eval("RangeError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("RangeError".into()));
    }

    /// SyntaxError.prototype.name is "SyntaxError"
    #[test]
    fn e2e_syntax_error_prototype_name_v2() {
        let result = global_eval("SyntaxError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("SyntaxError".into()));
    }

    /// ReferenceError.prototype.name is "ReferenceError"
    #[test]
    fn e2e_reference_error_prototype_name_v2() {
        let result = global_eval("ReferenceError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("ReferenceError".into()));
    }

    /// URIError.prototype.name is "URIError"
    #[test]
    fn e2e_uri_error_prototype_name_v2() {
        let result = global_eval("URIError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("URIError".into()));
    }

    /// EvalError.prototype.name is "EvalError"
    #[test]
    fn e2e_eval_error_prototype_name_v2() {
        let result = global_eval("EvalError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("EvalError".into()));
    }

    /// AggregateError.prototype.name is "AggregateError"
    #[test]
    fn e2e_aggregate_error_prototype_name_v2() {
        let result = global_eval("AggregateError.prototype.name").unwrap();
        assert_eq!(result, JsValue::String("AggregateError".into()));
    }

    /// Error.prototype.toString exists and is a function
    #[test]
    fn e2e_error_prototype_tostring_exists() {
        let result = global_eval("typeof Error.prototype.toString").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// `new Error("msg").toString()` uses toString from prototype
    #[test]
    fn e2e_error_tostring_coercion() {
        let result = global_eval(r#"var e = new Error("fail"); "" + e"#).unwrap();
        assert_eq!(result, JsValue::String("Error: fail".into()));
    }

    /// `new RangeError("x").toString()` → "RangeError: x"
    #[test]
    fn e2e_range_error_tostring() {
        let result = global_eval(r#"new RangeError("x").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("RangeError: x".into()));
    }

    /// `new SyntaxError("y").toString()` → "SyntaxError: y"
    #[test]
    fn e2e_syntax_error_tostring() {
        let result = global_eval(r#"new SyntaxError("y").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("SyntaxError: y".into()));
    }

    /// `new ReferenceError("z").toString()` → "ReferenceError: z"
    #[test]
    fn e2e_reference_error_tostring() {
        let result = global_eval(r#"new ReferenceError("z").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("ReferenceError: z".into()));
    }

    /// `new AggregateError([], "a").toString()` → "AggregateError: a"
    #[test]
    fn e2e_aggregate_error_tostring() {
        let result = global_eval(r#"new AggregateError([], "a").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("AggregateError: a".into()));
    }

    /// `new Error("").toString()` → "Error" (empty message)
    #[test]
    fn e2e_error_tostring_empty_message() {
        let result = global_eval(r#"new Error("").toString()"#).unwrap();
        assert_eq!(result, JsValue::String("Error".into()));
    }

    /// instanceof: `new Error() instanceof Error` → true
    #[test]
    fn e2e_error_instanceof_error() {
        let result = global_eval(r#"new Error("x") instanceof Error"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// instanceof: `new TypeError() instanceof TypeError` → true
    #[test]
    fn e2e_type_error_instanceof_type_error() {
        let result = global_eval(r#"new TypeError("x") instanceof TypeError"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// instanceof: `new TypeError() instanceof Error` → true (subtype)
    #[test]
    fn e2e_type_error_instanceof_error() {
        let result = global_eval(r#"new TypeError("x") instanceof Error"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// instanceof: `new RangeError() instanceof RangeError` → true
    #[test]
    fn e2e_range_error_instanceof_range_error() {
        let result = global_eval(r#"new RangeError("x") instanceof RangeError"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// instanceof: `new RangeError() instanceof Error` → true (subtype)
    #[test]
    fn e2e_range_error_instanceof_error() {
        let result = global_eval(r#"new RangeError("x") instanceof Error"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// instanceof: `new AggregateError([]) instanceof AggregateError` → true
    #[test]
    fn e2e_aggregate_error_instanceof_aggregate() {
        let result =
            global_eval(r#"new AggregateError([], "x") instanceof AggregateError"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// instanceof: `new AggregateError([]) instanceof Error` → true
    #[test]
    fn e2e_aggregate_error_instanceof_error_v2() {
        let result = global_eval(r#"new AggregateError([], "x") instanceof Error"#).unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// instanceof negative: `new Error() instanceof TypeError` → false
    #[test]
    fn e2e_error_not_instanceof_type_error() {
        let result = global_eval(r#"new Error("x") instanceof TypeError"#).unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// instanceof negative: `42 instanceof Error` → false
    #[test]
    fn e2e_number_not_instanceof_error() {
        let result = global_eval("42 instanceof Error").unwrap();
        assert_eq!(result, JsValue::Boolean(false));
    }

    /// Error constructor: `.name` property on constructor object
    #[test]
    fn e2e_error_constructor_name() {
        let result = global_eval("Error.name").unwrap();
        assert_eq!(result, JsValue::String("Error".into()));
    }

    /// TypeError constructor: `.name` property
    #[test]
    fn e2e_type_error_constructor_name() {
        let result = global_eval("TypeError.name").unwrap();
        assert_eq!(result, JsValue::String("TypeError".into()));
    }

    /// Error.prototype.constructor === Error
    #[test]
    fn e2e_error_prototype_constructor_identity() {
        let result = global_eval("Error.prototype.constructor === Error").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// TypeError.prototype.constructor === TypeError
    #[test]
    fn e2e_type_error_prototype_constructor_identity() {
        let result = global_eval("TypeError.prototype.constructor === TypeError").unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Error without message: `.message` → ""
    #[test]
    fn e2e_error_no_message_arg() {
        let result = global_eval("new Error().message").unwrap();
        assert_eq!(result, JsValue::String("".into()));
    }

    /// Error.captureStackTrace exists
    #[test]
    fn e2e_error_capture_stack_trace_exists_v2() {
        let result = global_eval("typeof Error.captureStackTrace").unwrap();
        assert_eq!(result, JsValue::String("function".into()));
    }

    /// Error.stackTraceLimit is a number
    #[test]
    fn e2e_error_stack_trace_limit_type() {
        let result = global_eval("typeof Error.stackTraceLimit").unwrap();
        assert_eq!(result, JsValue::String("number".into()));
    }

    fn assert_e2e_true(script: &str) {
        let result = global_eval(script).unwrap();
        assert_eq!(result, JsValue::Boolean(true), "script failed: {script}");
    }

    macro_rules! e2e_true_test {
        ($(#[$meta:meta])* $name:ident, $script:expr) => {
            $(#[$meta])*
            #[test]
            fn $name() {
                assert_e2e_true($script);
            }
        };
    }

    #[test]
    fn e2e_w18a_error_instance_name() {
        assert_e2e_true(r#"new Error("boom").name === "Error""#);
    }

    #[test]
    fn e2e_w18a_error_instance_constructor() {
        assert_e2e_true(r#"new Error("boom").constructor === Error"#);
    }

    #[test]
    fn e2e_w18a_error_instanceof_chain() {
        assert_e2e_true(r#"new Error("boom") instanceof Error"#);
    }

    #[test]
    fn e2e_w18a_error_to_string_variants() {
        assert_e2e_true(
            r#"new Error("boom").toString() === "Error: boom" && new Error().toString() === "Error""#,
        );
    }

    #[test]
    fn e2e_w18a_error_stack_and_cause() {
        assert_e2e_true(
            r#"let e = new Error("boom", { cause: 1 }); typeof e.stack === "string" && e.cause === 1"#,
        );
    }

    #[test]
    fn e2e_w18a_type_error_instance_name() {
        assert_e2e_true(r#"new TypeError("boom").name === "TypeError""#);
    }

    #[test]
    fn e2e_w18a_type_error_instance_constructor() {
        assert_e2e_true(r#"new TypeError("boom").constructor === TypeError"#);
    }

    #[test]
    fn e2e_w18a_type_error_instanceof_chain() {
        assert_e2e_true(
            r#"new TypeError("boom") instanceof TypeError && new TypeError("boom") instanceof Error"#,
        );
    }

    #[test]
    fn e2e_w18a_type_error_to_string_variants() {
        assert_e2e_true(
            r#"new TypeError("boom").toString() === "TypeError: boom" && new TypeError().toString() === "TypeError""#,
        );
    }

    #[test]
    fn e2e_w18a_type_error_stack_and_cause() {
        assert_e2e_true(
            r#"let e = new TypeError("boom", { cause: 2 }); typeof e.stack === "string" && e.cause === 2"#,
        );
    }

    #[test]
    fn e2e_w18a_range_error_instance_name() {
        assert_e2e_true(r#"new RangeError("boom").name === "RangeError""#);
    }

    #[test]
    fn e2e_w18a_range_error_instance_constructor() {
        assert_e2e_true(r#"new RangeError("boom").constructor === RangeError"#);
    }

    #[test]
    fn e2e_w18a_range_error_instanceof_chain() {
        assert_e2e_true(
            r#"new RangeError("boom") instanceof RangeError && new RangeError("boom") instanceof Error"#,
        );
    }

    #[test]
    fn e2e_w18a_range_error_to_string_variants() {
        assert_e2e_true(
            r#"new RangeError("boom").toString() === "RangeError: boom" && new RangeError().toString() === "RangeError""#,
        );
    }

    #[test]
    fn e2e_w18a_range_error_stack_and_cause() {
        assert_e2e_true(
            r#"let e = new RangeError("boom", { cause: 3 }); typeof e.stack === "string" && e.cause === 3"#,
        );
    }

    #[test]
    fn e2e_w18a_syntax_error_instance_name() {
        assert_e2e_true(r#"new SyntaxError("boom").name === "SyntaxError""#);
    }

    #[test]
    fn e2e_w18a_syntax_error_instance_constructor() {
        assert_e2e_true(r#"new SyntaxError("boom").constructor === SyntaxError"#);
    }

    #[test]
    fn e2e_w18a_syntax_error_instanceof_chain() {
        assert_e2e_true(
            r#"new SyntaxError("boom") instanceof SyntaxError && new SyntaxError("boom") instanceof Error"#,
        );
    }

    #[test]
    fn e2e_w18a_syntax_error_to_string_variants() {
        assert_e2e_true(
            r#"new SyntaxError("boom").toString() === "SyntaxError: boom" && new SyntaxError().toString() === "SyntaxError""#,
        );
    }

    #[test]
    fn e2e_w18a_syntax_error_stack_and_cause() {
        assert_e2e_true(
            r#"let e = new SyntaxError("boom", { cause: 4 }); typeof e.stack === "string" && e.cause === 4"#,
        );
    }

    #[test]
    fn e2e_w18a_reference_error_instance_name() {
        assert_e2e_true(r#"new ReferenceError("boom").name === "ReferenceError""#);
    }

    #[test]
    fn e2e_w18a_reference_error_instance_constructor() {
        assert_e2e_true(r#"new ReferenceError("boom").constructor === ReferenceError"#);
    }

    #[test]
    fn e2e_w18a_reference_error_instanceof_chain() {
        assert_e2e_true(
            r#"new ReferenceError("boom") instanceof ReferenceError && new ReferenceError("boom") instanceof Error"#,
        );
    }

    #[test]
    fn e2e_w18a_reference_error_to_string_variants() {
        assert_e2e_true(
            r#"new ReferenceError("boom").toString() === "ReferenceError: boom" && new ReferenceError().toString() === "ReferenceError""#,
        );
    }

    #[test]
    fn e2e_w18a_reference_error_stack_and_cause() {
        assert_e2e_true(
            r#"let e = new ReferenceError("boom", { cause: 5 }); typeof e.stack === "string" && e.cause === 5"#,
        );
    }

    #[test]
    fn e2e_w18a_uri_error_instance_name() {
        assert_e2e_true(r#"new URIError("boom").name === "URIError""#);
    }

    #[test]
    fn e2e_w18a_uri_error_instance_constructor() {
        assert_e2e_true(r#"new URIError("boom").constructor === URIError"#);
    }

    #[test]
    fn e2e_w18a_uri_error_instanceof_chain() {
        assert_e2e_true(
            r#"new URIError("boom") instanceof URIError && new URIError("boom") instanceof Error"#,
        );
    }

    #[test]
    fn e2e_w18a_uri_error_to_string_variants() {
        assert_e2e_true(
            r#"new URIError("boom").toString() === "URIError: boom" && new URIError().toString() === "URIError""#,
        );
    }

    #[test]
    fn e2e_w18a_uri_error_stack_and_cause() {
        assert_e2e_true(
            r#"let e = new URIError("boom", { cause: 6 }); typeof e.stack === "string" && e.cause === 6"#,
        );
    }

    #[test]
    fn e2e_w18a_eval_error_instance_name() {
        assert_e2e_true(r#"new EvalError("boom").name === "EvalError""#);
    }

    #[test]
    fn e2e_w18a_eval_error_instance_constructor() {
        assert_e2e_true(r#"new EvalError("boom").constructor === EvalError"#);
    }

    #[test]
    fn e2e_w18a_eval_error_instanceof_chain() {
        assert_e2e_true(
            r#"new EvalError("boom") instanceof EvalError && new EvalError("boom") instanceof Error"#,
        );
    }

    #[test]
    fn e2e_w18a_eval_error_to_string_variants() {
        assert_e2e_true(
            r#"new EvalError("boom").toString() === "EvalError: boom" && new EvalError().toString() === "EvalError""#,
        );
    }

    #[test]
    fn e2e_w18a_eval_error_stack_and_cause() {
        assert_e2e_true(
            r#"let e = new EvalError("boom", { cause: 7 }); typeof e.stack === "string" && e.cause === 7"#,
        );
    }

    #[test]
    fn e2e_w18a_aggregate_error_instance_name() {
        assert_e2e_true(r#"new AggregateError([], "boom").name === "AggregateError""#);
    }

    #[test]
    fn e2e_w18a_aggregate_error_instance_constructor() {
        assert_e2e_true(r#"new AggregateError([], "boom").constructor === AggregateError"#);
    }

    #[test]
    fn e2e_w18a_aggregate_error_instanceof_chain() {
        assert_e2e_true(
            r#"new AggregateError([], "boom") instanceof AggregateError && new AggregateError([], "boom") instanceof Error"#,
        );
    }

    #[test]
    fn e2e_w18a_aggregate_error_to_string_variants() {
        assert_e2e_true(
            r#"new AggregateError([], "boom").toString() === "AggregateError: boom" && new AggregateError([]).toString() === "AggregateError""#,
        );
    }

    #[test]
    fn e2e_w18a_aggregate_error_stack_and_cause() {
        assert_e2e_true(
            r#"let e = new AggregateError([], "boom", { cause: 8 }); typeof e.stack === "string" && e.cause === 8"#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w18a_aggregate_error_errors_own_descriptor() {
        assert_e2e_true(
            r#"let e = new AggregateError([1, 2], "boom");
               let d = Object.getOwnPropertyDescriptor(e, "errors");
               Array.isArray(e.errors) &&
               d !== undefined &&
               d.value === e.errors &&
               d.enumerable === false &&
               d.writable === true &&
               d.configurable === true &&
               Object.getOwnPropertyNames(e).includes("errors") &&
               Reflect.ownKeys(e).includes("errors")"#,
        );
    }

    #[test]
    fn e2e_w18a_error_message_own_descriptor() {
        assert_e2e_true(
            r#"let e = new Error("boom");
               let d = Object.getOwnPropertyDescriptor(e, "message");
               d !== undefined &&
               d.value === "boom" &&
               d.enumerable === false &&
               d.writable === true &&
               d.configurable === true"#,
        );
    }

    #[test]
    fn e2e_w18a_error_stack_own_descriptor() {
        assert_e2e_true(
            r#"let e = new TypeError("boom");
               let d = Object.getOwnPropertyDescriptor(e, "stack");
               d !== undefined && typeof d.value === "string" && d.enumerable === false"#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w18a_error_cause_own_descriptor() {
        assert_e2e_true(
            r#"let e = new SyntaxError("boom", { cause: 9 });
               let d = Object.getOwnPropertyDescriptor(e, "cause");
               d !== undefined &&
               d.value === 9 &&
               d.enumerable === false &&
               Object.getOwnPropertyNames(e).includes("cause")"#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w18a_subclass_type_error_instanceof_chain() {
        assert_e2e_true(
            r#"class MyErr extends TypeError {}
               let e = new MyErr("boom");
               e instanceof MyErr && e instanceof TypeError && e instanceof Error"#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w18a_subclass_type_error_constructor_and_prototype() {
        assert_e2e_true(
            r#"class MyErr extends TypeError {}
               let e = new MyErr("boom");
               e.constructor === MyErr &&
               Object.getPrototypeOf(e) === MyErr.prototype &&
               Object.getPrototypeOf(MyErr.prototype) === TypeError.prototype"#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w18a_subclass_type_error_name_to_string_stack_and_cause() {
        assert_e2e_true(
            r#"class MyErr extends TypeError {
                   constructor(message, cause) {
                       super(message, { cause });
                   }
               }
               let e = new MyErr("boom", 10);
               e.name === "TypeError" &&
               e.toString() === "TypeError: boom" &&
               typeof e.stack === "string" &&
               e.cause === 10"#,
        );
    }

    // ── w21j: Error message consistency & subclass conformance ─────────

    // 1. Error .message is own property (not inherited from prototype)
    #[test]
    fn e2e_w21j_error_message_is_own_property() {
        assert_e2e_true(
            r#"let e = new Error("hello");
               e.hasOwnProperty("message") === true"#,
        );
    }

    // 2. Error .name is inherited from prototype (not own)
    #[test]
    fn e2e_w21j_error_name_is_inherited() {
        assert_e2e_true(
            r#"let e = new Error("hello");
               e.hasOwnProperty("name") === false && e.name === "Error""#,
        );
    }

    // 3. Error .stack is a string
    #[test]
    fn e2e_w21j_error_stack_is_string() {
        assert_e2e_true(r#"typeof new Error("x").stack === "string""#);
    }

    // 4a. TypeError has correct .name
    #[test]
    fn e2e_w21j_type_error_name() {
        assert_e2e_true(r#"new TypeError("x").name === "TypeError""#);
    }

    // 4b. RangeError has correct .name
    #[test]
    fn e2e_w21j_range_error_name() {
        assert_e2e_true(r#"new RangeError("x").name === "RangeError""#);
    }

    // 4c. ReferenceError has correct .name
    #[test]
    fn e2e_w21j_reference_error_name() {
        assert_e2e_true(r#"new ReferenceError("x").name === "ReferenceError""#);
    }

    // 4d. SyntaxError has correct .name
    #[test]
    fn e2e_w21j_syntax_error_name() {
        assert_e2e_true(r#"new SyntaxError("x").name === "SyntaxError""#);
    }

    // 4e. URIError has correct .name
    #[test]
    fn e2e_w21j_uri_error_name() {
        assert_e2e_true(r#"new URIError("x").name === "URIError""#);
    }

    // 4f. EvalError has correct .name
    #[test]
    fn e2e_w21j_eval_error_name() {
        assert_e2e_true(r#"new EvalError("x").name === "EvalError""#);
    }

    // 5. new TypeError("msg").message === "msg" && .name === "TypeError"
    #[test]
    fn e2e_w21j_type_error_message_and_name() {
        assert_e2e_true(
            r#"let e = new TypeError("msg");
               e.message === "msg" && e.name === "TypeError""#,
        );
    }

    // 6a. Error .constructor === Error
    #[test]
    fn e2e_w21j_error_constructor_identity() {
        assert_e2e_true(r#"new Error("x").constructor === Error"#);
    }

    // 6b. TypeError .constructor === TypeError
    #[test]
    fn e2e_w21j_type_error_constructor_identity() {
        assert_e2e_true(r#"new TypeError("x").constructor === TypeError"#);
    }

    // 6c. RangeError .constructor === RangeError
    #[test]
    fn e2e_w21j_range_error_constructor_identity() {
        assert_e2e_true(r#"new RangeError("x").constructor === RangeError"#);
    }

    // 6d. ReferenceError .constructor === ReferenceError
    #[test]
    fn e2e_w21j_reference_error_constructor_identity() {
        assert_e2e_true(r#"new ReferenceError("x").constructor === ReferenceError"#);
    }

    // 6e. SyntaxError .constructor === SyntaxError
    #[test]
    fn e2e_w21j_syntax_error_constructor_identity() {
        assert_e2e_true(r#"new SyntaxError("x").constructor === SyntaxError"#);
    }

    // 6f. URIError .constructor === URIError
    #[test]
    fn e2e_w21j_uri_error_constructor_identity() {
        assert_e2e_true(r#"new URIError("x").constructor === URIError"#);
    }

    // 6g. EvalError .constructor === EvalError
    #[test]
    fn e2e_w21j_eval_error_constructor_identity() {
        assert_e2e_true(r#"new EvalError("x").constructor === EvalError"#);
    }

    // 7a. AggregateError .errors is own array property
    #[test]
    fn e2e_w21j_aggregate_error_errors_is_own_array() {
        assert_e2e_true(
            r#"let e = new AggregateError([1, 2, 3], "agg");
               e.hasOwnProperty("errors") && Array.isArray(e.errors) && e.errors.length === 3"#,
        );
    }

    // 7b. AggregateError message works
    #[test]
    fn e2e_w21j_aggregate_error_message() {
        assert_e2e_true(r#"new AggregateError([], "hello").message === "hello""#);
    }

    // 7c. AggregateError cause works
    #[test]
    fn e2e_w21j_aggregate_error_cause() {
        assert_e2e_true(
            r#"let e = new AggregateError([], "msg", { cause: "reason" });
               e.cause === "reason""#,
        );
    }

    // 7d. AggregateError .constructor === AggregateError
    #[test]
    fn e2e_w21j_aggregate_error_constructor_identity() {
        assert_e2e_true(r#"new AggregateError([], "x").constructor === AggregateError"#);
    }

    // 7e. AggregateError errors contents are correct
    #[test]
    fn e2e_w21j_aggregate_error_errors_contents() {
        assert_e2e_true(
            r#"let e = new AggregateError([10, 20], "oops");
               e.errors[0] === 10 && e.errors[1] === 20"#,
        );
    }

    // 8. Custom error subclass via class extends Error
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21j_custom_error_subclass() {
        assert_e2e_true(
            r#"class MyError extends Error {
                   constructor(msg) { super(msg); this.name = "MyError"; }
               }
               let e = new MyError("custom");
               e.name === "MyError" && e.message === "custom" && e instanceof Error"#,
        );
    }

    // 9a. Error.prototype.toString — "name: message" format
    #[test]
    fn e2e_w21j_error_to_string_name_colon_message() {
        assert_e2e_true(r#"new Error("boom").toString() === "Error: boom""#);
    }

    // 9b. Error.prototype.toString — missing message returns just name
    #[test]
    fn e2e_w21j_error_to_string_no_message() {
        assert_e2e_true(r#"new Error().toString() === "Error""#);
    }

    // 9c. Error.prototype.toString — empty name returns just message
    #[test]
    fn e2e_w21j_error_to_string_empty_name() {
        assert_e2e_true(r#"let e = new Error("hi"); e.name = ""; e.toString() === "hi""#);
    }

    // 9d. Error.prototype.toString — both empty returns empty string
    #[test]
    fn e2e_w21j_error_to_string_both_empty() {
        assert_e2e_true(r#"let e = new Error(); e.name = ""; e.toString() === """#);
    }

    // 10a. try/catch instanceof TypeError
    #[test]
    fn e2e_w21j_catch_instanceof_type_error() {
        assert_e2e_true(
            r#"let result = false;
               try { null.foo; } catch (e) { result = e instanceof TypeError; }
               result"#,
        );
    }

    // 10b. instanceof Error for TypeError
    #[test]
    fn e2e_w21j_type_error_instanceof_error() {
        assert_e2e_true(r#"new TypeError("x") instanceof Error"#);
    }

    // 10c. instanceof Error for RangeError
    #[test]
    fn e2e_w21j_range_error_instanceof_error() {
        assert_e2e_true(r#"new RangeError("x") instanceof Error"#);
    }

    // 11. Error without message: new Error().message === ""
    #[test]
    fn e2e_w21j_error_without_message_is_empty_string() {
        assert_e2e_true(r#"new Error().message === """#);
    }

    // 12. Error.captureStackTrace — may not exist; should not throw
    #[test]
    fn e2e_w21j_capture_stack_trace_no_throw() {
        assert_e2e_true(
            r#"let ok = true;
               try {
                   if (typeof Error.captureStackTrace === "function") {
                       let obj = {};
                       Error.captureStackTrace(obj);
                   }
               } catch (e) { ok = false; }
               ok"#,
        );
    }

    // 13. Error.prototype.name === "Error"
    #[test]
    fn e2e_w21j_error_prototype_name() {
        assert_e2e_true(r#"Error.prototype.name === "Error""#);
    }

    // 14. TypeError.prototype.name === "TypeError"
    #[test]
    fn e2e_w21j_type_error_prototype_name() {
        assert_e2e_true(r#"TypeError.prototype.name === "TypeError""#);
    }

    // 15. Error.prototype.message === ""
    #[test]
    fn e2e_w21j_error_prototype_message_is_empty() {
        assert_e2e_true(r#"Error.prototype.message === """#);
    }

    // 16. Error .stack is own property
    #[test]
    fn e2e_w21j_error_stack_is_own() {
        assert_e2e_true(r#"new Error("x").hasOwnProperty("stack")"#);
    }

    // 17. Error.prototype.toString is a function
    #[test]
    fn e2e_w21j_error_prototype_to_string_is_function() {
        assert_e2e_true(r#"typeof Error.prototype.toString === "function""#);
    }

    // 18. AggregateError instanceof Error
    #[test]
    fn e2e_w21j_aggregate_error_instanceof_error() {
        assert_e2e_true(r#"new AggregateError([], "x") instanceof Error"#);
    }

    // 19. All subclass prototypes inherit from Error.prototype
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21j_subclass_prototypes_inherit_error_prototype() {
        assert_e2e_true(
            r#"Object.getPrototypeOf(TypeError.prototype) === Error.prototype &&
               Object.getPrototypeOf(RangeError.prototype) === Error.prototype &&
               Object.getPrototypeOf(ReferenceError.prototype) === Error.prototype &&
               Object.getPrototypeOf(SyntaxError.prototype) === Error.prototype &&
               Object.getPrototypeOf(URIError.prototype) === Error.prototype &&
               Object.getPrototypeOf(EvalError.prototype) === Error.prototype"#,
        );
    }

    // 20. Error cause property propagates through subclass
    #[test]
    fn e2e_w21j_subclass_error_cause_propagation() {
        assert_e2e_true(
            r#"let inner = new Error("root");
               let outer = new TypeError("wrap", { cause: inner });
               outer.cause === inner && outer.cause.message === "root""#,
        );
    }

    // 21. Error without message has .message === "" for all subclasses
    #[test]
    fn e2e_w21j_subclass_no_message_is_empty_string() {
        assert_e2e_true(
            r#"new TypeError().message === "" &&
               new RangeError().message === "" &&
               new ReferenceError().message === "" &&
               new SyntaxError().message === "" &&
               new URIError().message === "" &&
               new EvalError().message === """#,
        );
    }

    // 22. Error.stackTraceLimit exists
    #[test]
    fn e2e_w21j_error_stack_trace_limit_exists() {
        assert_e2e_true(r#"typeof Error.stackTraceLimit === "number""#);
    }

    // 23. TypeError.prototype.toString returns "TypeError: msg"
    #[test]
    fn e2e_w21j_type_error_to_string_format() {
        assert_e2e_true(r#"new TypeError("fail").toString() === "TypeError: fail""#);
    }

    // ── w23i: error types, messages, stack traces, and toString ─────────

    e2e_true_test!(
        e2e_w23i_error_name_error,
        r#"new Error("x").name === "Error""#
    );
    e2e_true_test!(
        e2e_w23i_error_name_type_error,
        r#"new TypeError("x").name === "TypeError""#
    );
    e2e_true_test!(
        e2e_w23i_error_name_range_error,
        r#"new RangeError("x").name === "RangeError""#
    );
    e2e_true_test!(
        e2e_w23i_error_name_reference_error,
        r#"new ReferenceError("x").name === "ReferenceError""#
    );
    e2e_true_test!(
        e2e_w23i_error_name_syntax_error,
        r#"new SyntaxError("x").name === "SyntaxError""#
    );
    e2e_true_test!(
        e2e_w23i_error_name_uri_error,
        r#"new URIError("x").name === "URIError""#
    );
    e2e_true_test!(
        e2e_w23i_error_name_eval_error,
        r#"new EvalError("x").name === "EvalError""#
    );

    e2e_true_test!(
        e2e_w23i_error_message_exact_error,
        r#"new Error(" punctuation: [] {} ! ").message === " punctuation: [] {} ! ""#
    );
    e2e_true_test!(
        e2e_w23i_error_message_exact_type_error,
        r#"new TypeError("two  spaces").message === "two  spaces""#
    );
    e2e_true_test!(
        e2e_w23i_error_message_exact_range_error,
        r#"new RangeError("value: -1").message === "value: -1""#
    );
    e2e_true_test!(
        e2e_w23i_error_message_exact_reference_error,
        r#"new ReferenceError("missing binding").message === "missing binding""#
    );
    e2e_true_test!(
        e2e_w23i_error_message_exact_syntax_error,
        r#"new SyntaxError("bad token near ;").message === "bad token near ;""#
    );
    e2e_true_test!(
        e2e_w23i_error_message_exact_uri_error,
        r#"new URIError("% broken").message === "% broken""#
    );
    e2e_true_test!(
        e2e_w23i_error_message_exact_eval_error,
        r#"new EvalError("eval failed softly").message === "eval failed softly""#
    );

    e2e_true_test!(
        e2e_w23i_error_stack_is_string_without_message,
        r#"let e = new Error(); typeof e.stack === "string""#
    );
    e2e_true_test!(
        e2e_w23i_error_stack_is_string_with_empty_message,
        r#"let e = new RangeError(""); typeof e.stack === "string""#
    );
    e2e_true_test!(
        e2e_w23i_aggregate_error_stack_is_string,
        r#"let e = new AggregateError([], "agg"); typeof e.stack === "string""#
    );

    e2e_true_test!(
        e2e_w23i_error_to_string_error_with_message,
        r#"new Error("boom").toString() === "Error: boom""#
    );
    e2e_true_test!(
        e2e_w23i_error_to_string_error_without_message,
        r#"new Error().toString() === "Error""#
    );
    e2e_true_test!(
        e2e_w23i_error_to_string_type_error_without_message,
        r#"new TypeError("").toString() === "TypeError""#
    );
    e2e_true_test!(
        e2e_w23i_error_to_string_uses_custom_name,
        r#"let e = new Error("boom"); e.name = "CustomName"; e.toString() === "CustomName: boom""#
    );
    e2e_true_test!(
        e2e_w23i_error_to_string_uses_message_when_name_empty,
        r#"let e = new Error("boom"); e.name = ""; e.toString() === "boom""#
    );

    e2e_true_test!(
        e2e_w23i_eval_syntax_error_has_line_column,
        r#"try { eval("function {"); false; } catch (e) { e instanceof SyntaxError && e.message.indexOf("at 1:") !== -1 }"#
    );
    e2e_true_test!(
        e2e_w23i_eval_syntax_error_tracks_multiline_source,
        r#"try { eval("\nlet = 1;"); false; } catch (e) { e instanceof SyntaxError && e.message.indexOf("at 2:") !== -1 }"#
    );
    e2e_true_test!(
        e2e_w23i_eval_syntax_error_stack_mentions_syntax_error,
        r#"try { eval("if ("); false; } catch (e) { typeof e.stack === "string" && e.stack.indexOf("SyntaxError: at 1:") === 0 }"#
    );

    e2e_true_test!(
        e2e_w23i_type_error_message_not_a_function_primitive,
        r#"try { (1)(); false; } catch (e) { e instanceof TypeError && e.message.indexOf("not a function") !== -1 }"#
    );
    e2e_true_test!(
        e2e_w23i_type_error_message_not_a_function_object,
        r#"try { ({})() ; false; } catch (e) { e instanceof TypeError && e.message.indexOf("not a function") !== -1 }"#
    );
    e2e_true_test!(
        e2e_w23i_type_error_message_not_an_object,
        r#"try { Reflect.get(1, "x"); false; } catch (e) { e instanceof TypeError && e.message.indexOf("not an object") !== -1 }"#
    );
    e2e_true_test!(
        e2e_w23i_type_error_message_cannot_read_property_null,
        r#"try { null.foo; false; } catch (e) { e instanceof TypeError && e.message.indexOf("reading 'foo'") !== -1 }"#
    );
    e2e_true_test!(
        e2e_w23i_type_error_message_cannot_read_property_undefined,
        r#"try { let x; x["bar"]; false; } catch (e) { e instanceof TypeError && e.message.indexOf("reading 'bar'") !== -1 }"#
    );

    e2e_true_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_w23i_range_error_invalid_array_length_constructor,
        r#"try { new Array(-1); false; } catch (e) { e instanceof RangeError && e.message === "Invalid array length" }"#
    );
    e2e_true_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_w23i_range_error_invalid_array_length_assignment,
        r#"try { let a = []; a.length = -1; false; } catch (e) { e instanceof RangeError && e.message === "Invalid array length" }"#
    );
    e2e_true_test!(
        e2e_w23i_range_error_to_fixed_precision,
        r#"try { (1).toFixed(101); false; } catch (e) { e instanceof RangeError && e.message.indexOf("toFixed()") !== -1 && e.message.indexOf("0 and 100") !== -1 }"#
    );
    e2e_true_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_w23i_range_error_stack_overflow,
        r#"try { (function f() { return f(); })(); false; } catch (e) { e instanceof RangeError && e.message === "Maximum call stack size exceeded" }"#
    );

    e2e_true_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_w23i_reference_error_undeclared_variable_access,
        r#"try { missingBinding; false; } catch (e) { e instanceof ReferenceError && e.message === "missingBinding is not defined" }"#
    );
    e2e_true_test!(
        e2e_w23i_reference_error_tdz_violation,
        r#"try { valueBeforeInit; let valueBeforeInit = 1; false; } catch (e) { e instanceof ReferenceError && e.message === "Cannot access 'valueBeforeInit' before initialization" }"#
    );
    e2e_true_test!(
        e2e_w23i_reference_error_this_before_super,
        r#"class Base {} class Derived extends Base { constructor() { this.x = 1; super(); } } try { new Derived(); false; } catch (e) { e instanceof ReferenceError && e.message.indexOf("before accessing 'this'") !== -1 }"#
    );

    e2e_true_test!(
        e2e_w23i_rethrow_preserves_original_stack_for_error_object,
        r#"let firstStack = ""; let sameObject = false; let firstError; try { try { throw new Error("boom"); } catch (e) { firstError = e; firstStack = e.stack; throw e; } } catch (e) { sameObject = e === firstError; sameObject && firstStack === e.stack && e.message === "boom"; }"#
    );
    e2e_true_test!(
        e2e_w23i_rethrow_preserves_original_stack_for_engine_error,
        r#"let firstStack = ""; try { try { null.boom; } catch (e) { firstStack = e.stack; throw e; } } catch (e) { e instanceof TypeError && firstStack === e.stack && e.message.indexOf("reading 'boom'") !== -1 }"#
    );

    e2e_true_test!(
        e2e_w23i_error_cause_can_chain_error_objects,
        r#"let inner = new Error("inner"); let outer = new Error("outer", { cause: inner }); outer.cause === inner && outer.cause.message === "inner""#
    );
    e2e_true_test!(
        e2e_w23i_type_error_cause_can_chain_error_objects,
        r#"let inner = new Error("root"); let outer = new TypeError("wrap", { cause: inner }); outer.cause === inner && outer.cause.message === "root""#
    );
    e2e_true_test!(
        e2e_w23i_error_cause_preserves_non_error_values,
        r#"let outer = new Error("outer", { cause: 123 }); outer.cause === 123"#
    );
    e2e_true_test!(
        e2e_w23i_aggregate_error_cause_can_chain_error_objects,
        r#"let inner = new Error("inner"); let outer = new AggregateError([inner], "outer", { cause: inner }); outer.cause === inner && outer.errors[0] === inner"#
    );

    e2e_true_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_w23i_custom_error_subclass_name_override_in_to_string,
        r#"class MyError extends Error { constructor(message) { super(message); this.name = "MyError"; } } new MyError("boom").toString() === "MyError: boom""#
    );
    e2e_true_test!(
        #[ignore] // TODO: conformance — not yet passing
        e2e_w23i_custom_type_error_subclass_prototype_name_override_in_to_string,
        r#"class FancyTypeError extends TypeError {} FancyTypeError.prototype.name = "FancyTypeError"; new FancyTypeError("boom").toString() === "FancyTypeError: boom""#
    );

    e2e_true_test!(
        e2e_w23i_aggregate_error_prototype_name_exact,
        r#"AggregateError.prototype.name === "AggregateError""#
    );

    // ── Number deep conformance e2e tests ───────────────────────────────

    /// Number() with no args returns 0.
    #[test]
    fn e2e_number_call_no_args() {
        assert_eval_true("Number() === 0");
    }

    /// Number("123") coerces string to number.
    #[test]
    fn e2e_number_coerce_string() {
        assert_eval_true("Number('123') === 123");
    }

    /// Number(true) returns 1.
    #[test]
    fn e2e_number_coerce_true() {
        assert_eval_true("Number(true) === 1");
    }

    /// Number(false) returns 0.
    #[test]
    fn e2e_number_coerce_false() {
        assert_eval_true("Number(false) === 0");
    }

    /// Number(null) returns 0.
    #[test]
    fn e2e_number_coerce_null() {
        assert_eval_true("Number(null) === 0");
    }

    /// Number(undefined) returns NaN.
    #[test]
    fn e2e_number_coerce_undefined() {
        assert_eval_true("Number.isNaN(Number(undefined))");
    }

    /// Number("") returns 0.
    #[test]
    fn e2e_number_coerce_empty_string() {
        assert_eval_true("Number('') === 0");
    }

    /// Number("  ") returns 0 (whitespace only).
    #[test]
    fn e2e_number_coerce_whitespace() {
        assert_eval_true("Number('  ') === 0");
    }

    /// Number("0x1A") parses hex.
    #[test]
    fn e2e_number_coerce_hex() {
        assert_eval_true("Number('0x1A') === 26");
    }

    /// Number.EPSILON is a positive value close to machine epsilon.
    #[test]
    fn e2e_number_epsilon_value() {
        assert_eval_true("Number.EPSILON === 2.220446049250313e-16");
    }

    /// Number.MAX_SAFE_INTEGER equals 2^53 - 1.
    #[test]
    fn e2e_number_max_safe_integer_value() {
        assert_eval_true("Number.MAX_SAFE_INTEGER === 9007199254740991");
    }

    /// Number.MIN_SAFE_INTEGER equals -(2^53 - 1).
    #[test]
    fn e2e_number_min_safe_integer_value() {
        assert_eval_true("Number.MIN_SAFE_INTEGER === -9007199254740991");
    }

    /// Number.isSafeInteger(42) returns true.
    #[test]
    fn e2e_number_is_safe_integer_42() {
        assert_eval_true("Number.isSafeInteger(42) === true");
    }

    /// Number.isSafeInteger(3.14) returns false.
    #[test]
    fn e2e_number_is_safe_integer_float_v2() {
        assert_eval_true("Number.isSafeInteger(3.14) === false");
    }

    /// Number.isSafeInteger(NaN) returns false.
    #[test]
    fn e2e_number_is_safe_integer_nan() {
        assert_eval_true("Number.isSafeInteger(NaN) === false");
    }

    /// Number.isSafeInteger(Infinity) returns false.
    #[test]
    fn e2e_number_is_safe_integer_infinity() {
        assert_eval_true("Number.isSafeInteger(Infinity) === false");
    }

    /// Number.isSafeInteger("42") returns false (no coercion).
    #[test]
    fn e2e_number_is_safe_integer_no_coerce() {
        assert_eval_true("Number.isSafeInteger('42') === false");
    }

    /// toFixed(2) basic rounding.
    #[test]
    fn e2e_to_fixed_basic() {
        let result = global_eval("(3.14159).toFixed(2)").unwrap();
        assert_eq!(result, JsValue::String("3.14".into()));
    }

    /// toFixed(0) rounds to integer.
    #[test]
    fn e2e_to_fixed_zero_digits() {
        let result = global_eval("(1.5).toFixed(0)").unwrap();
        assert_eq!(result, JsValue::String("2".into()));
    }

    /// toFixed on NaN returns "NaN".
    #[test]
    fn e2e_to_fixed_nan() {
        let result = global_eval("NaN.toFixed(2)").unwrap();
        assert_eq!(result, JsValue::String("NaN".into()));
    }

    /// toFixed with no args defaults to 0 digits.
    #[test]
    fn e2e_to_fixed_no_args() {
        let result = global_eval("(1.7).toFixed()").unwrap();
        assert_eq!(result, JsValue::String("2".into()));
    }

    /// toFixed range error for digits > 100.
    #[test]
    fn e2e_to_fixed_range_error() {
        let result = global_eval(
            "try { (1).toFixed(101); 'no error' } catch(e) { e instanceof RangeError }",
        );
        assert_eq!(result.unwrap(), JsValue::Boolean(true));
    }

    /// toExponential(2) formats in scientific notation.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_basic() {
        let result = global_eval("(123456).toExponential(2)").unwrap();
        assert_eq!(result, JsValue::String("1.23e+5".into()));
    }

    /// toExponential on zero.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_zero() {
        let result = global_eval("(0).toExponential(2)").unwrap();
        assert_eq!(result, JsValue::String("0.00e+0".into()));
    }

    /// toExponential with no args uses minimal digits.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_no_args() {
        let result = global_eval("(100).toExponential()").unwrap();
        assert_eq!(result, JsValue::String("1e+2".into()));
    }

    /// toExponential on NaN returns "NaN".
    #[test]
    fn e2e_to_exponential_nan() {
        let result = global_eval("NaN.toExponential(2)").unwrap();
        assert_eq!(result, JsValue::String("NaN".into()));
    }

    /// toPrecision(5) formats with significant digits.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_precision_basic() {
        let result = global_eval("(123.456).toPrecision(5)").unwrap();
        assert_eq!(result, JsValue::String("123.46".into()));
    }

    /// toPrecision with no args returns ToString(number).
    #[test]
    fn e2e_to_precision_no_args() {
        let result = global_eval("(123.456).toPrecision()").unwrap();
        assert_eq!(result, JsValue::String("123.456".into()));
    }

    /// toPrecision range error for precision 0.
    #[test]
    fn e2e_to_precision_range_error() {
        let result = global_eval(
            "try { (1).toPrecision(0); 'no error' } catch(e) { e instanceof RangeError }",
        );
        assert_eq!(result.unwrap(), JsValue::Boolean(true));
    }

    /// toString(16) for hex conversion.
    #[test]
    fn e2e_to_string_hex() {
        let result = global_eval("(255).toString(16)").unwrap();
        assert_eq!(result, JsValue::String("ff".into()));
    }

    /// toString(2) for binary conversion.
    #[test]
    fn e2e_to_string_binary() {
        let result = global_eval("(10).toString(2)").unwrap();
        assert_eq!(result, JsValue::String("1010".into()));
    }

    /// toString(8) for octal conversion.
    #[test]
    fn e2e_to_string_octal() {
        let result = global_eval("(8).toString(8)").unwrap();
        assert_eq!(result, JsValue::String("10".into()));
    }

    /// toString(36) for base-36 conversion.
    #[test]
    fn e2e_to_string_base36() {
        let result = global_eval("(35).toString(36)").unwrap();
        assert_eq!(result, JsValue::String("z".into()));
    }

    /// toString() defaults to radix 10.
    #[test]
    fn e2e_to_string_default_radix() {
        let result = global_eval("(42).toString()").unwrap();
        assert_eq!(result, JsValue::String("42".into()));
    }

    /// toString with invalid radix throws RangeError.
    #[test]
    fn e2e_to_string_invalid_radix() {
        let result =
            global_eval("try { (1).toString(1); 'no error' } catch(e) { e instanceof RangeError }");
        assert_eq!(result.unwrap(), JsValue::Boolean(true));
    }

    /// toString with radix 37 throws RangeError.
    #[test]
    fn e2e_to_string_radix_37() {
        let result = global_eval(
            "try { (1).toString(37); 'no error' } catch(e) { e instanceof RangeError }",
        );
        assert_eq!(result.unwrap(), JsValue::Boolean(true));
    }

    /// Number.prototype.valueOf returns the number.
    #[test]
    fn e2e_number_valueof() {
        let result = global_eval("(42).valueOf()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Number.isNaN does not coerce — returns false for "NaN" string.
    #[test]
    fn e2e_number_is_nan_no_coerce_str() {
        assert_eval_true("Number.isNaN('NaN') === false");
    }

    /// Number.isFinite does not coerce — returns false for "42" string.
    #[test]
    fn e2e_number_is_finite_no_coerce_str() {
        assert_eval_true("Number.isFinite('42') === false");
    }

    /// Number.isInteger(5.0) returns true.
    #[test]
    fn e2e_number_is_integer_whole() {
        assert_eval_true("Number.isInteger(5.0) === true");
    }

    /// Number.isInteger(5.5) returns false.
    #[test]
    fn e2e_number_is_integer_fraction() {
        assert_eval_true("Number.isInteger(5.5) === false");
    }

    /// Number.parseInt works through Number constructor.
    #[test]
    fn e2e_number_parseint() {
        assert_eval_true("Number.parseInt('0xff', 16) === 255");
    }

    /// Number.parseFloat works through Number constructor.
    #[test]
    fn e2e_number_parsefloat() {
        assert_eval_true("Number.parseFloat('3.14') === 3.14");
    }

    /// Number.NaN is NaN.
    #[test]
    fn e2e_number_nan_constant_v2() {
        assert_eval_true("Number.isNaN(Number.NaN)");
    }

    /// Number.POSITIVE_INFINITY is Infinity.
    #[test]
    fn e2e_number_positive_infinity_v2() {
        assert_eval_true("Number.POSITIVE_INFINITY === Infinity");
    }

    /// Number.NEGATIVE_INFINITY is -Infinity.
    #[test]
    fn e2e_number_negative_infinity_v2() {
        assert_eval_true("Number.NEGATIVE_INFINITY === -Infinity");
    }

    /// toFixed(-0) returns "0".
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_fixed_negative_zero() {
        let result = global_eval("(-0).toFixed(1)").unwrap();
        assert_eq!(result, JsValue::String("0.0".into()));
    }

    // ── Deep Number / Math numeric conformance tests ────────────────────────

    #[test]
    fn e2e_number_epsilon_exact_value() {
        assert_eval_true("Number.EPSILON === 2.220446049250313e-16");
    }

    #[test]
    fn e2e_number_max_value_exact_value() {
        assert_eval_true("Number.MAX_VALUE === 1.7976931348623157e+308");
    }

    #[test]
    fn e2e_number_min_value_exact_value() {
        assert_eval_true("Number.MIN_VALUE === 5e-324");
    }

    #[test]
    fn e2e_number_max_safe_integer_exact_value() {
        assert_eval_true("Number.MAX_SAFE_INTEGER === 9007199254740991");
    }

    #[test]
    fn e2e_number_min_safe_integer_exact_value() {
        assert_eval_true("Number.MIN_SAFE_INTEGER === -9007199254740991");
    }

    #[test]
    fn e2e_number_is_safe_integer_max_boundary() {
        assert_eval_true("Number.isSafeInteger(Number.MAX_SAFE_INTEGER) === true");
    }

    #[test]
    fn e2e_number_is_safe_integer_min_boundary() {
        assert_eval_true("Number.isSafeInteger(Number.MIN_SAFE_INTEGER) === true");
    }

    #[test]
    fn e2e_number_is_safe_integer_above_max_boundary() {
        assert_eval_true("Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1) === false");
    }

    #[test]
    fn e2e_number_is_safe_integer_below_min_boundary() {
        assert_eval_true("Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1) === false");
    }

    #[test]
    fn e2e_number_is_safe_integer_negative_zero() {
        assert_eval_true("Number.isSafeInteger(-0) === true");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_fixed_rounds_exact_half_up() {
        assert_eval_true("(1.25).toFixed(1) === '1.3'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_fixed_rounds_negative_exact_half_up() {
        assert_eval_true("(-1.25).toFixed(1) === '-1.3'");
    }

    #[test]
    fn e2e_to_fixed_small_fraction_rounds_down_to_zero() {
        assert_eval_true("(0.00008).toFixed(3) === '0.000'");
    }

    #[test]
    fn e2e_to_fixed_negative_small_fraction_preserves_sign() {
        assert_eval_true("(-0.00008).toFixed(3) === '-0.000'");
    }

    #[test]
    fn e2e_to_fixed_coerces_string_digits() {
        assert_eval_true("(1).toFixed('2') === '1.00'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_fixed_truncates_negative_fractional_digits_toward_zero() {
        assert_eval_true("(1.2).toFixed(-0.9) === '1'");
    }

    #[test]
    fn e2e_to_fixed_rejects_infinite_digits() {
        assert_eval_true(
            "try { (1).toFixed(Infinity); false } catch (e) { e instanceof RangeError }",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_fixed_large_number_uses_to_string() {
        assert_eval_true("(1e21).toFixed(0) === '1e+21'");
    }

    #[test]
    fn e2e_to_fixed_binary_rounding_case_one() {
        assert_eval_true("(1.005).toFixed(2) === '1.00'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_fixed_binary_rounding_case_two() {
        assert_eval_true("(0.615).toFixed(2) === '0.62'");
    }

    #[test]
    fn e2e_to_fixed_large_integer_precision_case() {
        assert_eval_true("(1000000000000000128).toFixed(0) === '1000000000000000128'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_rounds_exact_half_up() {
        assert_eval_true("(1.25).toExponential(1) === '1.3e+0'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_rounds_negative_exact_half_up() {
        assert_eval_true("(-1.25).toExponential(1) === '-1.3e+0'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_rounding_carries_into_exponent() {
        assert_eval_true("(99.5).toExponential(1) === '1.0e+2'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_zero_fraction_digits() {
        assert_eval_true("(0).toExponential(0) === '0e+0'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_negative_zero_has_no_sign() {
        assert_eval_true("(-0).toExponential(2) === '0.00e+0'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_coerces_string_digits() {
        assert_eval_true("(1).toExponential('2') === '1.00e+0'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_truncates_fractional_digits_toward_zero() {
        assert_eval_true("(1).toExponential(-0.9) === '1e+0'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_rejects_infinite_digits() {
        assert_eval_true(
            "try { (1).toExponential(Infinity); false } catch (e) { e instanceof RangeError }",
        );
    }

    #[test]
    fn e2e_to_exponential_nan_no_arg() {
        assert_eval_true("NaN.toExponential() === 'NaN'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_exponential_shortest_form_no_arg() {
        assert_eval_true("(123.456).toExponential() === '1.23456e+2'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_precision_uses_exponential_below_negative_six_exponent() {
        assert_eval_true("(1e-7).toPrecision(1) === '1e-7'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_precision_uses_fixed_at_negative_six_exponent() {
        assert_eval_true("(1e-6).toPrecision(1) === '0.000001'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_precision_small_fraction_keeps_significant_digits() {
        assert_eval_true("(0.000123).toPrecision(2) === '0.00012'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_precision_rounds_exact_half_up() {
        assert_eval_true("(12.5).toPrecision(2) === '13'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_precision_rounding_carries_into_exponent() {
        assert_eval_true("(99.5).toPrecision(2) === '1.0e+2'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_precision_single_digit_hundred() {
        assert_eval_true("(100).toPrecision(1) === '1e+2'");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_to_precision_preserves_trailing_zeroes() {
        assert_eval_true("(100).toPrecision(3) === '100'");
    }

    #[test]
    fn e2e_to_precision_zero_padding() {
        assert_eval_true("(0).toPrecision(4) === '0.000'");
    }

    #[test]
    fn e2e_to_precision_coerces_string_precision() {
        assert_eval_true("(1).toPrecision('2') === '1.0'");
    }

    #[test]
    fn e2e_to_precision_rejects_fractional_precision_below_one() {
        assert_eval_true(
            "try { (1).toPrecision(-0.9); false } catch (e) { e instanceof RangeError }",
        );
    }

    #[test]
    fn e2e_to_precision_rejects_infinite_precision() {
        assert_eval_true(
            "try { (1).toPrecision(Infinity); false } catch (e) { e instanceof RangeError }",
        );
    }

    #[test]
    fn e2e_math_fround_matches_float32_rounding() {
        assert_eval_true("Math.fround(1.337) === 1.3370000123977661");
    }

    #[test]
    fn e2e_math_fround_preserves_negative_zero() {
        assert_eval_true("Object.is(Math.fround(-0), -0)");
    }

    #[test]
    fn e2e_math_fround_nan_is_nan() {
        assert_eval_true("Number.isNaN(Math.fround(NaN))");
    }

    #[test]
    fn e2e_math_cbrt_basic() {
        assert_eval_true("Math.cbrt(27) === 3");
    }

    #[test]
    fn e2e_math_cbrt_preserves_negative_zero() {
        assert_eval_true("Object.is(Math.cbrt(-0), -0)");
    }

    #[test]
    fn e2e_math_log2_basic() {
        assert_eval_true("Math.log2(8) === 3");
    }

    #[test]
    fn e2e_math_log10_basic() {
        assert_eval_true("Math.log10(1000) === 3");
    }

    #[test]
    fn e2e_math_log1p_negative_one() {
        assert_eval_true("Math.log1p(-1) === -Infinity");
    }

    #[test]
    fn e2e_math_expm1_zero() {
        assert_eval_true("Math.expm1(0) === 0");
    }

    #[test]
    fn e2e_math_sinh_zero() {
        assert_eval_true("Math.sinh(0) === 0");
    }

    #[test]
    fn e2e_math_cosh_zero() {
        assert_eval_true("Math.cosh(0) === 1");
    }

    #[test]
    fn e2e_math_tanh_zero() {
        assert_eval_true("Math.tanh(0) === 0");
    }

    #[test]
    fn e2e_math_asinh_preserves_negative_zero() {
        assert_eval_true("Object.is(Math.asinh(-0), -0)");
    }

    #[test]
    fn e2e_math_acosh_one() {
        assert_eval_true("Math.acosh(1) === 0");
    }

    #[test]
    fn e2e_math_atanh_preserves_negative_zero() {
        assert_eval_true("Object.is(Math.atanh(-0), -0)");
    }

    #[test]
    fn e2e_math_sign_negative_value() {
        assert_eval_true("Math.sign(-5) === -1");
    }

    #[test]
    fn e2e_math_sign_negative_zero() {
        assert_eval_true("Object.is(Math.sign(-0), -0)");
    }

    #[test]
    fn e2e_math_sign_positive_zero() {
        assert_eval_true("Object.is(Math.sign(0), 0)");
    }

    #[test]
    fn e2e_math_sign_nan_is_nan() {
        assert_eval_true("Number.isNaN(Math.sign(NaN))");
    }

    #[test]
    fn e2e_math_trunc_positive_value() {
        assert_eval_true("Math.trunc(13.9) === 13");
    }

    #[test]
    fn e2e_math_trunc_negative_value() {
        assert_eval_true("Math.trunc(-13.9) === -13");
    }

    #[test]
    fn e2e_math_trunc_negative_fraction_returns_negative_zero() {
        assert_eval_true("Object.is(Math.trunc(-0.9), -0)");
    }

    /// Negative number toString(16).
    #[test]
    fn e2e_to_string_negative_hex() {
        let result = global_eval("(-255).toString(16)").unwrap();
        assert_eq!(result, JsValue::String("-ff".into()));
    }

    // ── Object utility method conformance tests ─────────────────────────────

    // ── Object.assign ───────────────────────────────────────────────────────

    /// Object.assign copies enumerable own properties from multiple sources.
    #[test]
    fn e2e_object_assign_multiple_sources_v2() {
        assert_eval_true(
            "var t = {}; Object.assign(t, {a:1}, {b:2}, {c:3}); \
             t.a === 1 && t.b === 2 && t.c === 3",
        );
    }

    /// Object.assign: later source overwrites earlier.
    #[test]
    fn e2e_object_assign_overwrite() {
        assert_eval_true("var t = Object.assign({}, {x:1}, {x:2}); t.x === 2");
    }

    /// Object.assign skips non-enumerable properties.
    #[test]
    fn e2e_object_assign_skips_non_enumerable() {
        assert_eval_true(
            "var s = {}; \
             Object.defineProperty(s, 'hidden', {value:42, enumerable:false}); \
             s.visible = 1; \
             var t = Object.assign({}, s); \
             t.visible === 1 && t.hidden === undefined",
        );
    }

    /// Object.assign returns the target object.
    #[test]
    fn e2e_object_assign_returns_target_v2() {
        assert_eval_true("var t = {}; Object.assign(t, {a:1}) === t");
    }

    /// Object.assign skips null/undefined sources.
    #[test]
    fn e2e_object_assign_null_source_ignored() {
        assert_eval_true(
            "var t = Object.assign({a:1}, null, undefined, {b:2}); \
             t.a === 1 && t.b === 2",
        );
    }

    /// Object.assign throws on null target.
    #[test]
    fn e2e_object_assign_null_target_throws() {
        let result = global_eval(
            "try { Object.assign(null, {}); false } catch(e) { e instanceof TypeError }",
        );
        assert_eq!(result.unwrap(), JsValue::Boolean(true));
    }

    /// Object.assign copies symbol-keyed properties.
    #[test]
    fn e2e_object_assign_copies_symbol_keys() {
        assert_eval_true(
            "var sym = Symbol('k'); \
             var src = {}; src[sym] = 42; \
             var t = Object.assign({}, src); \
             t[sym] === 42",
        );
    }

    // ── Object.fromEntries ──────────────────────────────────────────────────

    /// Object.fromEntries creates object from array of pairs.
    #[test]
    fn e2e_object_from_entries_basic_pairs() {
        assert_eval_true(
            "var o = Object.fromEntries([['a',1],['b',2]]); \
             o.a === 1 && o.b === 2",
        );
    }

    /// Object.fromEntries: later duplicate key overwrites earlier.
    #[test]
    fn e2e_object_from_entries_duplicate_overwrites() {
        assert_eval_true("var o = Object.fromEntries([['x',1],['x',2]]); o.x === 2");
    }

    /// Object.fromEntries round-trips with Object.entries.
    #[test]
    fn e2e_object_from_entries_round_trip_entries() {
        assert_eval_true(
            "var o = {a:1, b:2}; \
             var o2 = Object.fromEntries(Object.entries(o)); \
             o2.a === 1 && o2.b === 2",
        );
    }

    /// Object.fromEntries with empty array returns empty object.
    #[test]
    fn e2e_object_from_entries_empty_v2() {
        assert_eval_true("Object.keys(Object.fromEntries([])).length === 0");
    }

    /// Object.fromEntries throws on null/undefined.
    #[test]
    fn e2e_object_from_entries_null_throws() {
        let result = global_eval(
            "try { Object.fromEntries(null); false } catch(e) { e instanceof TypeError }",
        );
        assert_eq!(result.unwrap(), JsValue::Boolean(true));
    }

    // ── Object.getOwnPropertyDescriptors ────────────────────────────────────

    /// getOwnPropertyDescriptors returns descriptors for all own properties.
    #[test]
    fn e2e_get_own_property_descriptors_basic() {
        assert_eval_true(
            "var o = {a:1, b:2}; \
             var d = Object.getOwnPropertyDescriptors(o); \
             d.a.value === 1 && d.b.value === 2 && \
             d.a.writable === true && d.a.enumerable === true && d.a.configurable === true",
        );
    }

    /// getOwnPropertyDescriptors includes non-enumerable properties.
    #[test]
    fn e2e_get_own_property_descriptors_non_enumerable() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value:42, writable:false, enumerable:false, configurable:false}); \
             var d = Object.getOwnPropertyDescriptors(o); \
             d.x.value === 42 && d.x.writable === false && \
             d.x.enumerable === false && d.x.configurable === false",
        );
    }

    /// getOwnPropertyDescriptors on array returns index + length descriptors.
    #[test]
    fn e2e_get_own_property_descriptors_array() {
        assert_eval_true(
            "var d = Object.getOwnPropertyDescriptors([10, 20]); \
             d['0'].value === 10 && d['1'].value === 20 && \
             d.length.value === 2",
        );
    }

    /// getOwnPropertyDescriptors on empty object returns empty object.
    #[test]
    fn e2e_get_own_property_descriptors_empty() {
        assert_eval_true("Object.keys(Object.getOwnPropertyDescriptors({})).length === 0");
    }

    // ── Object.hasOwn ───────────────────────────────────────────────────────

    /// Object.hasOwn returns true for own property.
    #[test]
    fn e2e_object_has_own_true_v2() {
        assert_eval_true("Object.hasOwn({a:1}, 'a')");
    }

    /// Object.hasOwn returns false for missing property.
    #[test]
    fn e2e_object_has_own_false_v2() {
        assert_eval_true("Object.hasOwn({a:1}, 'b') === false");
    }

    /// Object.hasOwn does not traverse prototype chain.
    #[test]
    fn e2e_object_has_own_no_prototype() {
        assert_eval_true(
            "var parent = {inherited: 1}; \
             var child = Object.create(parent); \
             Object.hasOwn(child, 'inherited') === false",
        );
    }

    /// Object.hasOwn works on arrays (index check).
    #[test]
    fn e2e_object_has_own_array_index_v2() {
        assert_eval_true(
            "Object.hasOwn([10,20,30], '1') === true && \
             Object.hasOwn([10,20,30], '5') === false",
        );
    }

    /// Object.hasOwn detects non-enumerable own properties.
    #[test]
    fn e2e_object_has_own_non_enumerable() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value:1, enumerable:false}); \
             Object.hasOwn(o, 'x')",
        );
    }

    /// Object.hasOwn detects accessor properties.
    #[test]
    fn e2e_object_has_own_accessor() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'g', {get: function(){return 1}, enumerable:true, configurable:true}); \
             Object.hasOwn(o, 'g')",
        );
    }

    // ── Object.entries / Object.values ───────────────────────────────────────

    /// Object.values returns only enumerable own values.
    #[test]
    fn e2e_object_values_enumerable_only() {
        assert_eval_true(
            "var o = {a:1, b:2}; \
             Object.defineProperty(o, 'c', {value:3, enumerable:false}); \
             var v = Object.values(o); \
             v.length === 2 && v.indexOf(1) !== -1 && v.indexOf(2) !== -1",
        );
    }

    /// Object.entries returns [key, value] pairs.
    #[test]
    fn e2e_object_entries_pairs() {
        assert_eval_true(
            "var e = Object.entries({x:10}); \
             e.length === 1 && e[0][0] === 'x' && e[0][1] === 10",
        );
    }

    /// Object.entries skips non-enumerable properties.
    #[test]
    fn e2e_object_entries_skips_non_enumerable() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'hidden', {value:1, enumerable:false}); \
             o.visible = 2; \
             Object.entries(o).length === 1",
        );
    }

    /// Object.values on string returns characters.
    #[test]
    fn e2e_object_values_string_chars() {
        assert_eval_true(
            "var v = Object.values('hi'); v[0] === 'h' && v[1] === 'i' && v.length === 2",
        );
    }

    /// Object.entries orders integer keys before string keys.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_entries_integer_ordering() {
        assert_eval_true(
            "var o = {}; o.b = 2; o['1'] = 'one'; o.a = 1; o['0'] = 'zero'; \
             var e = Object.entries(o); \
             e[0][0] === '0' && e[1][0] === '1' && e[2][0] === 'b' && e[3][0] === 'a'",
        );
    }

    // ── Object.getOwnPropertyNames ──────────────────────────────────────────

    /// getOwnPropertyNames includes non-enumerable properties.
    #[test]
    fn e2e_get_own_property_names_includes_non_enumerable() {
        assert_eval_true(
            "var o = {a:1}; \
             Object.defineProperty(o, 'b', {value:2, enumerable:false}); \
             var n = Object.getOwnPropertyNames(o); \
             n.indexOf('a') !== -1 && n.indexOf('b') !== -1",
        );
    }

    /// getOwnPropertyNames on array returns indices and 'length'.
    #[test]
    fn e2e_get_own_property_names_array() {
        assert_eval_true(
            "var n = Object.getOwnPropertyNames([10,20]); \
             n.indexOf('0') !== -1 && n.indexOf('1') !== -1 && n.indexOf('length') !== -1",
        );
    }

    /// getOwnPropertyNames does not include symbol keys.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_get_own_property_names_excludes_symbols() {
        assert_eval_true(
            "var o = {}; o[Symbol('s')] = 1; o.a = 2; \
             var n = Object.getOwnPropertyNames(o); \
             n.length === 1 && n[0] === 'a'",
        );
    }

    // ── Object.getOwnPropertySymbols ────────────────────────────────────────

    /// getOwnPropertySymbols returns symbol keys.
    #[test]
    fn e2e_get_own_property_symbols_basic() {
        assert_eval_true(
            "var sym = Symbol('test'); \
             var o = {}; o[sym] = 'val'; o.str = 'str'; \
             var s = Object.getOwnPropertySymbols(o); \
             s.length === 1",
        );
    }

    /// getOwnPropertySymbols returns empty for no-symbol objects.
    #[test]
    fn e2e_get_own_property_symbols_empty() {
        assert_eval_true("Object.getOwnPropertySymbols({a:1, b:2}).length === 0");
    }

    /// `Object.getOwnPropertySymbols` preserves insertion order.
    #[test]
    fn e2e_get_own_property_symbols_preserves_order() {
        assert_eval_true(
            r#"
            var a = Symbol("a");
            var b = Symbol("b");
            var o = {};
            o[b] = 1;
            o[a] = 2;
            var syms = Object.getOwnPropertySymbols(o);
            syms.length === 2 && syms[0] === b && syms[1] === a
            "#,
        );
    }

    /// `Object.getOwnPropertySymbols` ignores inherited symbol keys.
    #[test]
    fn e2e_get_own_property_symbols_skips_inherited() {
        assert_eval_true(
            r#"
            var inherited = Symbol("inherited");
            var own = Symbol("own");
            var proto = {};
            proto[inherited] = 1;
            var obj = Object.create(proto);
            obj[own] = 2;
            var syms = Object.getOwnPropertySymbols(obj);
            syms.length === 1 && syms[0] === own
            "#,
        );
    }

    // ── Object.create ───────────────────────────────────────────────────────

    /// Object.create(null) creates object with null prototype.
    #[test]
    fn e2e_object_create_null_no_methods() {
        assert_eval_true(
            "var o = Object.create(null); \
             Object.getPrototypeOf(o) === null",
        );
    }

    /// Object.create with property descriptors.
    #[test]
    fn e2e_object_create_with_descriptors_v2() {
        assert_eval_true(
            "var o = Object.create(null, { \
               x: {value: 42, writable: true, enumerable: true, configurable: true}, \
               y: {value: 'hi', writable: false, enumerable: true, configurable: false} \
             }); \
             o.x === 42 && o.y === 'hi'",
        );
    }

    /// Object.create inherits from proto.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_create_inherits_proto() {
        assert_eval_true(
            "var proto = {greet: function() { return 'hello' }}; \
             var o = Object.create(proto); \
             o.greet() === 'hello'",
        );
    }

    /// Object.create rejects non-object, non-null proto.
    #[test]
    fn e2e_object_create_rejects_number_proto() {
        let result =
            global_eval("try { Object.create(42); false } catch(e) { e instanceof TypeError }");
        assert_eq!(result.unwrap(), JsValue::Boolean(true));
    }

    // ── Object.is ───────────────────────────────────────────────────────────

    /// Object.is: NaN equals NaN.
    #[test]
    fn e2e_object_is_nan_nan_v2() {
        assert_eval_true("Object.is(NaN, NaN)");
    }

    /// Object.is: +0 !== -0.
    #[test]
    fn e2e_object_is_pos_neg_zero() {
        assert_eval_true("Object.is(0, -0) === false");
    }

    /// Object.is: -0 !== +0 (symmetric).
    #[test]
    fn e2e_object_is_neg_pos_zero() {
        assert_eval_true("Object.is(-0, 0) === false");
    }

    /// Object.is: same primitives.
    #[test]
    fn e2e_object_is_same_primitives() {
        assert_eval_true(
            "Object.is(1, 1) && Object.is('a', 'a') && \
             Object.is(true, true) && Object.is(null, null) && \
             Object.is(undefined, undefined)",
        );
    }

    /// Object.is: different primitives.
    #[test]
    fn e2e_object_is_different_primitives() {
        assert_eval_true(
            "Object.is(1, 2) === false && \
             Object.is('a', 'b') === false && \
             Object.is(true, false) === false && \
             Object.is(null, undefined) === false",
        );
    }

    /// Object.is: object identity (same ref vs different ref).
    #[test]
    fn e2e_object_is_identity() {
        assert_eval_true("var o = {}; Object.is(o, o) === true && Object.is({}, {}) === false");
    }

    // ── Object.keys with integer ordering ───────────────────────────────────

    /// Object.keys orders integer indices before string keys.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_object_keys_integer_ordering() {
        assert_eval_true(
            "var o = {}; o.b = 1; o['2'] = 2; o.a = 3; o['0'] = 4; \
             var k = Object.keys(o); \
             k[0] === '0' && k[1] === '2' && k[2] === 'b' && k[3] === 'a'",
        );
    }

    /// Object.keys excludes symbol-keyed properties.
    #[test]
    fn e2e_object_keys_excludes_symbols() {
        assert_eval_true(
            "var o = {a:1}; o[Symbol('s')] = 2; \
             Object.keys(o).length === 1 && Object.keys(o)[0] === 'a'",
        );
    }

    // ── Cross-method consistency tests ──────────────────────────────────────

    /// Object.keys length matches Object.values length.
    #[test]
    fn e2e_keys_values_same_length() {
        assert_eval_true(
            "var o = {a:1,b:2,c:3}; \
             Object.keys(o).length === Object.values(o).length",
        );
    }

    /// Object.entries length matches Object.keys length.
    #[test]
    fn e2e_entries_keys_same_length() {
        assert_eval_true(
            "var o = {x:10,y:20}; \
             Object.entries(o).length === Object.keys(o).length",
        );
    }

    /// Object.fromEntries + Object.entries round-trip preserves all keys.
    #[test]
    fn e2e_from_entries_entries_roundtrip_keys() {
        assert_eval_true(
            "var o = {a:1, b:2, c:3}; \
             var o2 = Object.fromEntries(Object.entries(o)); \
             Object.keys(o2).length === 3 && o2.a === 1 && o2.b === 2 && o2.c === 3",
        );
    }

    /// getOwnPropertyNames is superset of keys for objects with
    /// non-enumerable properties.
    #[test]
    fn e2e_get_own_property_names_superset_of_keys() {
        assert_eval_true(
            "var o = {a:1}; \
             Object.defineProperty(o, 'b', {value:2, enumerable:false}); \
             Object.getOwnPropertyNames(o).length > Object.keys(o).length",
        );
    }

    /// Object.assign + Object.is: assigned NaN is same NaN.
    #[test]
    fn e2e_assign_preserves_nan() {
        assert_eval_true("var t = Object.assign({}, {v: NaN}); Object.is(t.v, NaN)");
    }

    // ── Property descriptor conformance tests ───────────────────────────────

    // 1. Object.defineProperty — writable, enumerable, configurable flags

    #[test]
    fn e2e_define_property_writable_true_allows_assignment() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, writable: true}); \
             o.x = 2; \
             o.x === 2",
        );
    }

    #[test]
    fn e2e_define_property_writable_false_ignores_strict_assignment() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, writable: false}); \
             o.x = 99; \
             o.x === 1",
        );
    }

    #[test]
    fn e2e_define_property_enumerable_true_in_keys() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'a', {value: 1, enumerable: true}); \
             Object.keys(o).indexOf('a') !== -1",
        );
    }

    #[test]
    fn e2e_define_property_enumerable_false_not_in_keys() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'a', {value: 1, enumerable: false}); \
             Object.keys(o).indexOf('a') === -1",
        );
    }

    #[test]
    fn e2e_define_property_configurable_true_allows_delete() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, configurable: true}); \
             delete o.x; \
             o.x === undefined",
        );
    }

    #[test]
    fn e2e_define_property_configurable_false_prevents_delete() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, configurable: false}); \
             delete o.x; \
             o.x === 1",
        );
    }

    // 2. Object.getOwnPropertyDescriptor — returns correct descriptor object

    #[test]
    fn e2e_gopd_returns_all_four_data_keys() {
        assert_eval_true(
            "var o = {x: 42}; \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             'value' in d && 'writable' in d && 'enumerable' in d && 'configurable' in d",
        );
    }

    #[test]
    fn e2e_gopd_data_values_correct() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 7, writable: false, enumerable: true, configurable: false}); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 7 && d.writable === false && d.enumerable === true && d.configurable === false",
        );
    }

    #[test]
    fn e2e_gopd_missing_property_returns_undefined() {
        assert_eval_true(
            "var o = {}; \
             Object.getOwnPropertyDescriptor(o, 'nope') === undefined",
        );
    }

    #[test]
    fn e2e_gopd_inherited_property_returns_undefined() {
        assert_eval_true(
            "var parent = {x: 1}; \
             var child = Object.create(parent); \
             Object.getOwnPropertyDescriptor(child, 'x') === undefined",
        );
    }

    // 3. Accessor descriptors: {get, set, enumerable, configurable}

    #[test]
    fn e2e_accessor_getter_invoked_on_read() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 get: function() { return 99; }, \
                 enumerable: true, configurable: true \
             }); \
             o.x === 99",
        );
    }

    #[test]
    fn e2e_accessor_setter_invoked_on_write() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 set: function(v) { this._x = v * 2; }, \
                 get: function() { return this._x; }, \
                 configurable: true \
             }); \
             o.x = 5; \
             o.x === 10",
        );
    }

    #[test]
    fn e2e_gopd_accessor_shape() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 get: function() { return 1; }, \
                 set: function(v) {}, \
                 enumerable: true, configurable: false \
             }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             typeof d.get === 'function' && typeof d.set === 'function' && \
             d.enumerable === true && d.configurable === false && \
             d.value === undefined && d.writable === undefined",
        );
    }

    #[test]
    fn e2e_accessor_only_getter_set_is_undefined() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 get: function() { return 1; }, \
                 configurable: true \
             }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.set === undefined",
        );
    }

    // 4. Data descriptors: {value, writable, enumerable, configurable}

    #[test]
    fn e2e_data_descriptor_all_false_defaults() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 42}); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 42 && d.writable === false && \
             d.enumerable === false && d.configurable === false",
        );
    }

    #[test]
    fn e2e_data_descriptor_all_true() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 value: 'hello', writable: true, enumerable: true, configurable: true \
             }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 'hello' && d.writable === true && \
             d.enumerable === true && d.configurable === true",
        );
    }

    #[test]
    fn e2e_ordinary_property_descriptor_wec() {
        assert_eval_true(
            "var o = {x: 1}; \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.writable === true && d.enumerable === true && d.configurable === true",
        );
    }

    // 5. Non-configurable → non-writable transition allowed

    #[test]
    fn e2e_nonconfig_writable_true_to_false_allowed() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, writable: true, configurable: false}); \
             Object.defineProperty(o, 'x', {value: 1, writable: false}); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.writable === false",
        );
    }

    #[test]
    fn e2e_nonconfig_narrow_writable_preserves_value() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 42, writable: true, configurable: false}); \
             Object.defineProperty(o, 'x', {writable: false}); \
             o.x === 42",
        );
    }

    // 6. Reconfiguring non-configurable throws TypeError

    #[test]
    fn e2e_nonconfig_to_config_throws_typeerror() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, configurable: false}); \
             try { \
                 Object.defineProperty(o, 'x', {configurable: true}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_nonconfig_change_enumerable_throws() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, enumerable: false, configurable: false}); \
             try { \
                 Object.defineProperty(o, 'x', {enumerable: true}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_nonconfig_nonwritable_value_change_throws() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false}); \
             try { \
                 Object.defineProperty(o, 'x', {value: 2}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_nonconfig_nonwritable_same_value_noop() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false}); \
             Object.defineProperty(o, 'x', {value: 1}); \
             o.x === 1",
        );
    }

    #[test]
    fn e2e_nonconfig_widen_writable_throws() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, writable: false, configurable: false}); \
             try { \
                 Object.defineProperty(o, 'x', {writable: true}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_nonconfig_accessor_change_getter_throws() {
        assert_eval_true(
            "var o = {}; \
             var g1 = function() { return 1; }; \
             Object.defineProperty(o, 'x', {get: g1, configurable: false}); \
             try { \
                 Object.defineProperty(o, 'x', {get: function() { return 2; }}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_nonconfig_data_to_accessor_throws_v2() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, configurable: false}); \
             try { \
                 Object.defineProperty(o, 'x', {get: function() { return 2; }}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_nonconfig_accessor_to_data_throws() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {get: function() { return 1; }, configurable: false}); \
             try { \
                 Object.defineProperty(o, 'x', {value: 2}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    // 7. Object.defineProperties — multiple at once

    #[test]
    fn e2e_define_properties_sets_multiple() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperties(o, { \
                 a: {value: 1, writable: true, enumerable: true, configurable: true}, \
                 b: {value: 2, writable: false, enumerable: true, configurable: false} \
             }); \
             o.a === 1 && o.b === 2",
        );
    }

    #[test]
    fn e2e_define_properties_respects_attributes() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperties(o, { \
                 x: {value: 10, writable: false, enumerable: false, configurable: false}, \
                 y: {value: 20, writable: true, enumerable: true, configurable: true} \
             }); \
             var dx = Object.getOwnPropertyDescriptor(o, 'x'); \
             var dy = Object.getOwnPropertyDescriptor(o, 'y'); \
             dx.writable === false && dx.enumerable === false && \
             dy.writable === true && dy.enumerable === true",
        );
    }

    #[test]
    fn e2e_define_properties_returns_target() {
        assert_eval_true(
            "var o = {}; \
             var r = Object.defineProperties(o, {a: {value: 1}}); \
             r === o",
        );
    }

    #[test]
    fn e2e_define_properties_non_object_throws() {
        assert_eval_true(
            "try { \
                 Object.defineProperties(42, {}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    // 8. Descriptor on arrays

    #[test]
    fn e2e_array_gopd_index() {
        assert_eval_true(
            "var a = [10, 20, 30]; \
             var d = Object.getOwnPropertyDescriptor(a, '1'); \
             d.value === 20 && d.writable === true && \
             d.enumerable === true && d.configurable === true",
        );
    }

    #[test]
    fn e2e_array_gopd_length() {
        assert_eval_true(
            "var a = [1, 2, 3]; \
             var d = Object.getOwnPropertyDescriptor(a, 'length'); \
             d.value === 3 && d.writable === true && \
             d.enumerable === false && d.configurable === false",
        );
    }

    #[test]
    fn e2e_define_property_array_index() {
        assert_eval_true(
            "var a = [1, 2, 3]; \
             Object.defineProperty(a, '1', {value: 99}); \
             a[1] === 99",
        );
    }

    #[test]
    fn e2e_define_property_array_length_truncate() {
        assert_eval_true(
            "var a = [1, 2, 3, 4, 5]; \
             Object.defineProperty(a, 'length', {value: 2}); \
             a.length === 2",
        );
    }

    // 9. Default descriptor values

    #[test]
    fn e2e_define_property_defaults_writable_false() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1}); \
             Object.getOwnPropertyDescriptor(o, 'x').writable === false",
        );
    }

    #[test]
    fn e2e_define_property_defaults_enumerable_false() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1}); \
             Object.getOwnPropertyDescriptor(o, 'x').enumerable === false",
        );
    }

    #[test]
    fn e2e_define_property_defaults_configurable_false() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1}); \
             Object.getOwnPropertyDescriptor(o, 'x').configurable === false",
        );
    }

    #[test]
    fn e2e_define_property_empty_descriptor_generic() {
        assert_eval_true(
            "var o = {x: 5}; \
             Object.defineProperty(o, 'x', {}); \
             o.x === 5",
        );
    }

    // 10. Additional conformance edge cases

    #[test]
    fn e2e_configurable_data_to_accessor_allowed() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, configurable: true}); \
             Object.defineProperty(o, 'x', { \
                 get: function() { return 42; }, configurable: true \
             }); \
             o.x === 42",
        );
    }

    #[test]
    fn e2e_configurable_accessor_to_data_allowed() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 get: function() { return 1; }, configurable: true \
             }); \
             Object.defineProperty(o, 'x', {value: 99, configurable: true}); \
             o.x === 99",
        );
    }

    #[test]
    fn e2e_configurable_redefine_all_attributes() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, writable: false, enumerable: false, configurable: true}); \
             Object.defineProperty(o, 'x', {value: 2, writable: true, enumerable: true, configurable: true}); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 2 && d.writable === true && d.enumerable === true",
        );
    }

    #[test]
    fn e2e_define_property_on_non_object_throws() {
        assert_eval_true(
            "try { \
                 Object.defineProperty(42, 'x', {value: 1}); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_define_property_descriptor_not_object_throws() {
        assert_eval_true(
            "try { \
                 Object.defineProperty({}, 'x', 42); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_define_property_mixed_data_accessor_throws() {
        assert_eval_true(
            "try { \
                 Object.defineProperty({}, 'x', { \
                     value: 1, get: function() { return 2; } \
                 }); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_define_property_writable_and_set_throws_v2() {
        assert_eval_true(
            "try { \
                 Object.defineProperty({}, 'x', { \
                     writable: true, set: function(v) {} \
                 }); \
                 false; \
             } catch(e) { \
                 e instanceof TypeError; \
             }",
        );
    }

    #[test]
    fn e2e_generic_descriptor_preserves_writable() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, writable: true, configurable: true}); \
             Object.defineProperty(o, 'x', {enumerable: true}); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.writable === true && d.enumerable === true",
        );
    }

    #[test]
    fn e2e_generic_descriptor_only_configurable_preserves_rest() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 value: 5, writable: true, enumerable: true, configurable: true \
             }); \
             Object.defineProperty(o, 'x', {configurable: false}); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 5 && d.writable === true && d.enumerable === true && d.configurable === false",
        );
    }

    #[test]
    fn e2e_nonconfig_same_enumerable_noop() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1, enumerable: true, configurable: false}); \
             Object.defineProperty(o, 'x', {enumerable: true}); \
             o.x === 1",
        );
    }

    #[test]
    fn e2e_define_property_returns_target_object() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', {value: 1}) === o",
        );
    }

    #[test]
    fn e2e_gopd_string_index() {
        assert_eval_true(
            "var d = Object.getOwnPropertyDescriptor('hello', '0'); \
             d.value === 'h' && d.writable === false && \
             d.enumerable === true && d.configurable === false",
        );
    }

    #[test]
    fn e2e_gopd_string_length() {
        assert_eval_true(
            "var d = Object.getOwnPropertyDescriptor('abc', 'length'); \
             d.value === 3 && d.writable === false",
        );
    }

    // ── RegExp advanced conformance e2e tests ────────────────────────────

    // ── Named capture groups ─────────────────────────────────────────────

    /// Named groups: accessing groups on exec result.
    #[test]
    fn e2e_regexp_named_group_exec_access() {
        assert_eval_true(
            r#"var m = /(?<first>\w+)\s(?<last>\w+)/.exec("John Smith");
            m.groups.first === "John" && m.groups.last === "Smith""#,
        );
    }

    /// Named groups: captured value appears both as numbered and named.
    #[test]
    fn e2e_regexp_named_group_numbered_and_named() {
        assert_eval_true(
            r#"var m = /(?<x>a)(b)/.exec("ab");
            m[1] === "a" && m[2] === "b" && m.groups.x === "a""#,
        );
    }

    /// Named groups: non-participating named group is undefined.
    #[test]
    fn e2e_regexp_named_group_nonparticipating() {
        assert_eval_true(
            r#"var m = /(?<a>a)|(?<b>b)/.exec("b");
            m.groups.a === undefined && m.groups.b === "b""#,
        );
    }

    /// Named groups: replace with $<name>.
    #[test]
    fn e2e_regexp_named_group_replace_syntax() {
        assert_eval_true(
            r#"var r = "2024-07".replace(/(?<y>\d{4})-(?<m>\d{2})/, "$<m>/$<y>");
            r === "07/2024""#,
        );
    }

    // ── dotAll flag (s) ──────────────────────────────────────────────────

    /// dotAll: dot matches newline with s flag.
    #[test]
    fn e2e_regexp_dotall_matches_newline() {
        assert_eval_true(r#"new RegExp("a.b", "s").test("a\nb")"#);
    }

    /// dotAll: dot does NOT match newline without s flag.
    #[test]
    fn e2e_regexp_no_dotall_rejects_newline() {
        assert_eval_true(r#"!new RegExp("a.b", "").test("a\nb")"#);
    }

    /// dotAll: flag accessor returns true.
    #[test]
    fn e2e_regexp_dotall_flag_accessor() {
        assert_eval_true(r#"new RegExp(".", "s").dotAll === true"#);
    }

    /// dotAll: flag appears in flags string.
    #[test]
    fn e2e_regexp_dotall_in_flags_string() {
        assert_eval_true(r#"new RegExp(".", "gs").flags === "gs""#);
    }

    // ── Unicode flag (u) ─────────────────────────────────────────────────

    /// Unicode: \\p{L} matches word characters with u flag.
    #[test]
    fn e2e_regexp_unicode_property_escape() {
        assert_eval_true(r#"new RegExp("\\p{L}+", "u").test("café")"#);
    }

    /// Unicode: flag accessor returns true.
    #[test]
    fn e2e_regexp_unicode_flag_accessor() {
        assert_eval_true(r#"new RegExp(".", "u").unicode === true"#);
    }

    /// Unicode: surrogate pair handled correctly.
    #[test]
    fn e2e_regexp_unicode_emoji_match() {
        assert_eval_true(
            r#"var m = new RegExp(".", "u").exec("\u{1F600}");
            m[0] === "\u{1F600}""#,
        );
    }

    // ── Lookbehind assertions ────────────────────────────────────────────

    /// Positive lookbehind: (?<=...) matches preceded text.
    #[test]
    fn e2e_regexp_positive_lookbehind() {
        assert_eval_true(
            r#"var m = new RegExp("(?<=\\$)\\d+").exec("price $100");
            m[0] === "100""#,
        );
    }

    /// Negative lookbehind: (?<!...) rejects preceded text.
    #[test]
    fn e2e_regexp_negative_lookbehind() {
        assert_eval_true(
            r#"var m = new RegExp("(?<!\\$)\\d+").exec("100 items");
            m[0] === "100""#,
        );
    }

    /// Positive lookbehind: no match when lookbehind fails.
    #[test]
    fn e2e_regexp_positive_lookbehind_no_match() {
        assert_eval_true(r#"new RegExp("(?<=x)y").exec("ay") === null"#);
    }

    // ── RegExp.prototype.flags ───────────────────────────────────────────

    /// flags: canonical order is dgimsuy.
    #[test]
    fn e2e_regexp_flags_canonical_order() {
        assert_eval_true(r#"new RegExp(".", "ysmig").flags === "gimsy""#);
    }

    /// flags: single flag preserved.
    #[test]
    fn e2e_regexp_flags_single() {
        assert_eval_true(r#"new RegExp(".", "i").flags === "i""#);
    }

    /// flags: empty when no flags.
    #[test]
    fn e2e_regexp_flags_none() {
        assert_eval_true(r#"new RegExp(".").flags === """#);
    }

    // ── RegExp.prototype.source ──────────────────────────────────────────

    /// source: returns pattern text.
    #[test]
    fn e2e_regexp_source_returns_pattern() {
        assert_eval_true(r#"new RegExp("abc").source === "abc""#);
    }

    /// source: empty pattern returns "(?:)".
    #[test]
    fn e2e_regexp_source_empty() {
        assert_eval_true(r#"new RegExp("").source === "(?:)""#);
    }

    /// source: forward slash is escaped.
    #[test]
    fn e2e_regexp_source_escapes_fwd_slash() {
        assert_eval_true(r#"new RegExp("a/b").source === "a\\/b""#);
    }

    // ── Symbol.match ─────────────────────────────────────────────────────

    /// Symbol.match: non-global returns exec-like result.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_symbol_match_nonglobal() {
        assert_eval_true(
            r#"var m = "foo 42 bar".match(/\d+/);
            m[0] === "42" && m.index === 4"#,
        );
    }

    /// Symbol.match: global returns all matches.
    #[test]
    fn e2e_regexp_symbol_match_global() {
        assert_eval_true(
            r#"var m = "a1 b2 c3".match(/\d+/g);
            m.length === 3 && m[0] === "1" && m[1] === "2" && m[2] === "3""#,
        );
    }

    /// Symbol.match: returns null on no match.
    #[test]
    fn e2e_regexp_symbol_match_null() {
        assert_eval_true(r#""hello".match(/\d+/) === null"#);
    }

    // ── Symbol.replace ───────────────────────────────────────────────────

    /// Symbol.replace: string replacement with capture.
    #[test]
    fn e2e_regexp_symbol_replace_capture() {
        assert_eval_true(r#""2024-07".replace(/(\d{4})-(\d{2})/, "$2/$1") === "07/2024""#);
    }

    /// Symbol.replace: global replacement.
    #[test]
    fn e2e_regexp_symbol_replace_global() {
        assert_eval_true(r#""a1 b2 c3".replace(/\d+/g, "N") === "aN bN cN""#);
    }

    /// Symbol.replace: $& inserts matched text.
    #[test]
    fn e2e_regexp_symbol_replace_dollar_amp() {
        assert_eval_true(r#""hello".replace(/l+/, "[$&]") === "he[ll]o""#);
    }

    // ── Symbol.search ────────────────────────────────────────────────────

    /// Symbol.search: returns index of first match.
    #[test]
    fn e2e_regexp_symbol_search_found() {
        assert_eval_true(r#""hello world".search(/world/) === 6"#);
    }

    /// Symbol.search: returns -1 on no match.
    #[test]
    fn e2e_regexp_symbol_search_not_found() {
        assert_eval_true(r#""hello".search(/xyz/) === -1"#);
    }

    // ── Symbol.split ─────────────────────────────────────────────────────

    /// Symbol.split: basic split by regex.
    #[test]
    fn e2e_regexp_symbol_split_basic() {
        assert_eval_true(
            r#"var parts = "a,b,,c".split(/,/);
            parts.length === 4 && parts[0] === "a" && parts[2] === """#,
        );
    }

    /// Symbol.split: capture groups included in result.
    #[test]
    fn e2e_regexp_symbol_split_with_captures() {
        assert_eval_true(
            r#"var parts = "a1b2c".split(/(\d)/);
            parts.length === 5 && parts[1] === "1" && parts[3] === "2""#,
        );
    }

    /// Symbol.split: non-participating capture is undefined.
    #[test]
    fn e2e_regexp_symbol_split_undefined_capture() {
        assert_eval_true(
            r#"var parts = "a-b".split(/-(x)?/);
            parts[0] === "a" && parts[1] === undefined && parts[2] === "b""#,
        );
    }

    macro_rules! string_symbol_dispatch_test {
        ($(#[$meta:meta])* $name:ident, $script:expr) => {
            $(#[$meta])*
            #[test]
            fn $name() {
                assert_eval_true($script);
            }
        };
    }

    // ── String protocol dispatch e2e tests ─────────────────────────────────

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `String.prototype.match` delegates to custom `@@match`.
        e2e_string_match_custom_symbol_dispatch,
        r#"var matcher = {}; Object.defineProperty(matcher, Symbol.match, { value: function(s) { return "ok:" + s; } }); "abc".match(matcher) === "ok:abc""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@match` receives the source string.
        e2e_string_match_custom_symbol_receives_input,
        r#"var seen = ""; var matcher = {}; Object.defineProperty(matcher, Symbol.match, { value: function(s) { seen = s; return null; } }); "abc".match(matcher) === null && seen === "abc""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@match` receives the matcher as `this`.
        e2e_string_match_custom_symbol_this_binding,
        r#"var matcher = {}; Object.defineProperty(matcher, Symbol.match, { value: function(s) { return this === matcher && s === "abc"; } }); "abc".match(matcher) === true"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Inherited `@@match` participates in `String.prototype.match`.
        e2e_string_match_custom_symbol_inherited,
        r#"var proto = {}; Object.defineProperty(proto, Symbol.match, { value: function(s) { return "proto:" + s; } }); var matcher = Object.create(proto); "abc".match(matcher) === "proto:abc""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Non-callable `@@match` throws.
        e2e_string_match_custom_symbol_non_callable_throws,
        r#"var matcher = {}; Object.defineProperty(matcher, Symbol.match, { value: 123 }); try { "abc".match(matcher); false; } catch (e) { e instanceof TypeError; }"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `undefined` `@@match` falls back to string coercion.
        e2e_string_match_custom_symbol_undefined_falls_back,
        r#"var matcher = { toString: function() { return "b"; } }; Object.defineProperty(matcher, Symbol.match, { value: undefined }); var m = "abc".match(matcher); m[0] === "b" && m.index === 1"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `String.prototype.replace` delegates to custom `@@replace`.
        e2e_string_replace_custom_symbol_dispatch,
        r#"var replacer = {}; Object.defineProperty(replacer, Symbol.replace, { value: function(s, r) { return "R:" + s + ":" + r; } }); "abc".replace(replacer, "X") === "R:abc:X""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@replace` receives a string replacement.
        e2e_string_replace_custom_symbol_receives_string_replacement,
        r#"var seen = ""; var replacer = {}; Object.defineProperty(replacer, Symbol.replace, { value: function(s, r) { seen = r; return s; } }); "abc".replace(replacer, "X") === "abc" && seen === "X""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@replace` receives a functional replacer unchanged.
        e2e_string_replace_custom_symbol_receives_function_replacement,
        r#"var fn = function() {}; var ok = false; var replacer = {}; Object.defineProperty(replacer, Symbol.replace, { value: function(s, r) { ok = r === fn && s === "abc"; return "done"; } }); "abc".replace(replacer, fn) === "done" && ok"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@replace` receives the replacer as `this`.
        e2e_string_replace_custom_symbol_this_binding,
        r#"var replacer = {}; Object.defineProperty(replacer, Symbol.replace, { value: function(s, r) { return this === replacer && s === "abc" && r === "X"; } }); "abc".replace(replacer, "X") === true"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Inherited `@@replace` participates in `String.prototype.replace`.
        e2e_string_replace_custom_symbol_inherited,
        r#"var proto = {}; Object.defineProperty(proto, Symbol.replace, { value: function(s, r) { return s + ":" + r; } }); var replacer = Object.create(proto); "abc".replace(replacer, "X") === "abc:X""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Non-callable `@@replace` throws.
        e2e_string_replace_custom_symbol_non_callable_throws,
        r#"var replacer = {}; Object.defineProperty(replacer, Symbol.replace, { value: 123 }); try { "abc".replace(replacer, "X"); false; } catch (e) { e instanceof TypeError; }"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `undefined` `@@replace` falls back to string coercion.
        e2e_string_replace_custom_symbol_undefined_falls_back,
        r#"var replacer = { toString: function() { return "b"; } }; Object.defineProperty(replacer, Symbol.replace, { value: undefined }); "abca".replace(replacer, "X") === "aXca""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Functional regexp replacement receives capture, index, and input.
        e2e_regexp_replace_function_receives_capture_index_input,
        r#""abc123".replace(/(\d+)/, function(m, d, idx, input) { return d + ":" + idx + ":" + input; }) === "abc123:3:abc123""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Functional regexp replacement receives named groups.
        e2e_regexp_replace_function_receives_named_groups,
        r#""2024-07".replace(/(?<y>\d{4})-(?<m>\d{2})/, function(m, y, mo, idx, input, groups) { return groups.m + "/" + groups.y; }) === "07/2024""#
    );

    string_symbol_dispatch_test!(
        /// `$1` substitutions use captured groups.
        e2e_regexp_replace_dollar_1_substitution,
        r#""abc123".replace(/(\d)(\d)(\d)/, "$3$2$1") === "abc321""#
    );

    string_symbol_dispatch_test!(
        /// `$&` substitutions use the matched text.
        e2e_regexp_replace_dollar_ampersand_substitution,
        r#""hello".replace(/l+/, "<$&>") === "he<ll>o""#
    );

    string_symbol_dispatch_test!(
        /// ``$``` substitutions use the prefix.
        e2e_regexp_replace_dollar_backtick_substitution,
        r#""abc123def".replace(/\d+/, "$`") === "abcabcdef""#
    );

    string_symbol_dispatch_test!(
        /// `$'` substitutions use the suffix.
        e2e_regexp_replace_dollar_quote_substitution,
        r#""abc123def".replace(/\d+/, "$'") === "abcdefdef""#
    );

    string_symbol_dispatch_test!(
        /// `$<name>` substitutions use named captures.
        e2e_regexp_replace_named_group_string_substitution,
        r#""2024-07".replace(/(?<y>\d{4})-(?<m>\d{2})/, "$<m>/$<y>") === "07/2024""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Global functional regexp replacement visits each match.
        e2e_regexp_replace_global_functional_replacer,
        r#""a1 b2".replace(/\d/g, function(m) { return "[" + m + "]"; }) === "a[1] b[2]""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `String.prototype.search` delegates to custom `@@search`.
        e2e_string_search_custom_symbol_dispatch,
        r#"var searcher = {}; Object.defineProperty(searcher, Symbol.search, { value: function(s) { return 7; } }); "abc".search(searcher) === 7"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@search` receives the source string.
        e2e_string_search_custom_symbol_receives_input,
        r#"var seen = ""; var searcher = {}; Object.defineProperty(searcher, Symbol.search, { value: function(s) { seen = s; return -1; } }); "abc".search(searcher) === -1 && seen === "abc""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@search` receives the searcher as `this`.
        e2e_string_search_custom_symbol_this_binding,
        r#"var searcher = {}; Object.defineProperty(searcher, Symbol.search, { value: function(s) { return this === searcher && s === "abc"; } }); "abc".search(searcher) === true"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Inherited `@@search` participates in `String.prototype.search`.
        e2e_string_search_custom_symbol_inherited,
        r#"var proto = {}; Object.defineProperty(proto, Symbol.search, { value: function(s) { return s.length; } }); var searcher = Object.create(proto); "abc".search(searcher) === 3"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Non-callable `@@search` throws.
        e2e_string_search_custom_symbol_non_callable_throws,
        r#"var searcher = {}; Object.defineProperty(searcher, Symbol.search, { value: 123 }); try { "abc".search(searcher); false; } catch (e) { e instanceof TypeError; }"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `undefined` `@@search` falls back to string coercion.
        e2e_string_search_custom_symbol_undefined_falls_back,
        r#"var searcher = { toString: function() { return "b"; } }; Object.defineProperty(searcher, Symbol.search, { value: undefined }); "abc".search(searcher) === 1"#
    );

    string_symbol_dispatch_test!(
        /// RegExp search preserves the original `lastIndex`.
        e2e_string_search_regexp_preserves_last_index_v2,
        r#"var re = /a/g; re.lastIndex = 2; "aba".search(re) === 0 && re.lastIndex === 2"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// RegExp search reports UTF-16 indices.
        e2e_string_search_regexp_reports_utf16_index,
        r#""😀a".search(/a/) === 2"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `String.prototype.split` delegates to custom `@@split`.
        e2e_string_split_custom_symbol_dispatch,
        r#"var splitter = {}; Object.defineProperty(splitter, Symbol.split, { value: function(s, limit) { return ["x", String(limit), s]; } }); var out = "abc".split(splitter, 5); Array.isArray(out) && out.length === 3 && out[0] === "x" && out[1] === "5" && out[2] === "abc""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@split` receives the limit argument.
        e2e_string_split_custom_symbol_receives_limit,
        r#"var got = 0; var splitter = {}; Object.defineProperty(splitter, Symbol.split, { value: function(s, limit) { got = limit; return []; } }); "abc".split(splitter, 7).length === 0 && got === 7"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@split` receives the splitter as `this`.
        e2e_string_split_custom_symbol_this_binding,
        r#"var splitter = {}; Object.defineProperty(splitter, Symbol.split, { value: function(s, limit) { return this === splitter && s === "abc" && limit === 3 ? ["ok"] : ["bad"]; } }); "abc".split(splitter, 3)[0] === "ok""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Inherited `@@split` participates in `String.prototype.split`.
        e2e_string_split_custom_symbol_inherited,
        r#"var proto = {}; Object.defineProperty(proto, Symbol.split, { value: function(s, limit) { return [s, String(limit)]; } }); var splitter = Object.create(proto); var out = "abc".split(splitter, 2); out.length === 2 && out[0] === "abc" && out[1] === "2""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Non-callable `@@split` throws.
        e2e_string_split_custom_symbol_non_callable_throws,
        r#"var splitter = {}; Object.defineProperty(splitter, Symbol.split, { value: 123 }); try { "abc".split(splitter); false; } catch (e) { e instanceof TypeError; }"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `undefined` `@@split` falls back to string coercion.
        e2e_string_split_custom_symbol_undefined_falls_back,
        r#"var splitter = { toString: function() { return "b"; } }; Object.defineProperty(splitter, Symbol.split, { value: undefined }); var out = "abcb".split(splitter); out.length === 3 && out[0] === "a" && out[1] === "c" && out[2] === """#
    );

    string_symbol_dispatch_test!(
        /// RegExp split honours the limit argument.
        e2e_string_split_regexp_limit,
        r#"var out = "a,b,c".split(/,/, 2); out.length === 2 && out[0] === "a" && out[1] === "b""#
    );

    string_symbol_dispatch_test!(
        /// RegExp split with limit `0` returns an empty array.
        e2e_string_split_regexp_zero_limit,
        r#"var out = "a,b,c".split(/,/, 0); Array.isArray(out) && out.length === 0"#
    );

    string_symbol_dispatch_test!(
        /// RegExp split includes capture groups.
        e2e_string_split_regexp_includes_captures,
        r#"var out = "a1b2c".split(/(\d)/); out.length === 5 && out[1] === "1" && out[3] === "2""#
    );

    string_symbol_dispatch_test!(
        /// Zero-width regexp split produces individual characters.
        e2e_string_split_regexp_zero_width_characters,
        r#"var out = "ab".split(/(?:)/); out.length === 2 && out[0] === "a" && out[1] === "b""#
    );

    string_symbol_dispatch_test!(
        /// RegExp split ignores the original `lastIndex`.
        e2e_string_split_regexp_ignores_last_index,
        r#"var re = /,/g; re.lastIndex = 2; var out = "a,b,c".split(re); out.length === 3 && out[0] === "a" && out[2] === "c" && re.lastIndex === 2"#
    );

    string_symbol_dispatch_test!(
        /// Sticky regexps participate correctly in split.
        e2e_string_split_regexp_sticky_behavior,
        r#"var out = "abac".split(/a/y); out.length === 3 && out[0] === "" && out[1] === "b" && out[2] === "c""#
    );

    // ── RegExp replace/split/exec deep conformance ───────────────────────

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Functional replacers receive the whole match and captures.
        e2e_regexp_replace_function_receives_match_and_captures_deep,
        r#""12-34".replace(/(\d+)-(\d+)/, function(m, a, b) { return m + "|" + a + "|" + b; }) === "12-34|12|34""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Functional replacers receive the UTF-16 offset.
        e2e_regexp_replace_function_receives_utf16_offset_deep,
        r#""😀12".replace(/(\d+)/, function(m, a, off) { return a + ":" + off; }) === "😀12:2""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Functional replacers receive the original input string.
        e2e_regexp_replace_function_receives_input_string_deep,
        r#""ab12cd".replace(/(\d+)/, function(m, a, off, input) { return input === "ab12cd" && off === 2 ? "[" + a + "]" : "bad"; }) === "ab[12]cd""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Named-group replacers receive a null-prototype groups object.
        e2e_regexp_replace_function_groups_null_proto_deep,
        r#""2024-07".replace(/(?<year>\d{4})-(?<month>\d{2})/, function(m, y, mo, off, input, groups) { return Object.getPrototypeOf(groups) === null && groups.year === y && groups.month === mo ? "ok" : "bad"; }) === "ok""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Non-participating named groups are undefined in replacers.
        e2e_regexp_replace_function_groups_undefined_entry_deep,
        r#""a".replace(/(?<x>a)|(?<y>b)/, function(m, x, y, off, input, groups) { return groups.x === "a" && groups.y === undefined ? "ok" : "bad"; }) === "ok""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Replacers without named groups do not receive a groups argument.
        e2e_regexp_replace_function_without_groups_argument_deep,
        r#""12".replace(/(\d+)/, function(m, a, off, input) { return arguments.length === 4 ? "ok" : "bad"; }) === "ok""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Global functional replacement visits every match.
        e2e_regexp_replace_function_global_visits_all_matches_deep,
        r#""a1b2c3".replace(/(\d)/g, function(m, d, off) { return "[" + d + ":" + off + "]"; }) === "a[1:1]b[2:3]c[3:5]""#
    );

    string_symbol_dispatch_test!(
        /// `$$` inserts a literal dollar in regexp replacement.
        e2e_regexp_replace_substitution_dollar_dollar_deep,
        r#""abc".replace(/b/, "$$") === "a$c""#
    );

    string_symbol_dispatch_test!(
        /// `$&` inserts the matched text in regexp replacement.
        e2e_regexp_replace_substitution_dollar_amp_deep,
        r#""abc".replace(/b/, "<$&>") === "a<b>c""#
    );

    string_symbol_dispatch_test!(
        /// ``$``` inserts the prefix in regexp replacement.
        e2e_regexp_replace_substitution_prefix_deep,
        r#""abc123def".replace(/\d+/, "$`") === "abcabcdef""#
    );

    string_symbol_dispatch_test!(
        /// `$'` inserts the suffix in regexp replacement.
        e2e_regexp_replace_substitution_suffix_deep,
        r#""abc123def".replace(/\d+/, "$'") === "abcdefdef""#
    );

    string_symbol_dispatch_test!(
        /// `$1` expands the first capture in regexp replacement.
        e2e_regexp_replace_substitution_capture_one_deep,
        r#""abc123def".replace(/(\d)(\d)(\d)/, "[$1]") === "abc[1]def""#
    );

    string_symbol_dispatch_test!(
        /// `$10` falls back to `$1` plus a literal `0` when capture 10 is absent.
        e2e_regexp_replace_substitution_capture_ten_fallback_deep,
        r#""abc123def".replace(/(\d)(\d)(\d)/, "$10") === "abc10def""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Invalid two-digit captures remain literal text.
        e2e_regexp_replace_substitution_invalid_two_digit_capture_deep,
        r#""abc123def".replace(/(\d)(\d)(\d)/, "$99") === "abc$99def""#
    );

    string_symbol_dispatch_test!(
        /// `$<name>` expands named captures in regexp replacement.
        e2e_regexp_replace_substitution_named_capture_deep,
        r#""2024-07".replace(/(?<y>\d{4})-(?<m>\d{2})/, "$<m>/$<y>") === "07/2024""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Missing named captures produce the empty string.
        e2e_regexp_replace_substitution_missing_named_capture_deep,
        r#""2024-07".replace(/(?<y>\d{4})-(?<m>\d{2})/, "$<missing>") === ""#
    );

    string_symbol_dispatch_test!(
        /// `$<name>` stays literal when the regexp has no named captures.
        e2e_regexp_replace_substitution_named_capture_literal_without_groups_deep,
        r#""a".replace(/a/, "$<x>") === "$<x>""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Direct `@@replace` supports global replacements.
        e2e_regexp_symbol_replace_direct_global_deep,
        r#"var re = /\d/g; re[Symbol.replace]("a1b2c3", "X") === "aXbXcX""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Direct `@@replace` supports functional replacers with groups.
        e2e_regexp_symbol_replace_direct_function_named_groups_deep,
        r#"var re = /(?<year>\d{4})-(?<month>\d{2})/; re[Symbol.replace]("2024-07", function(m, y, mo, off, input, groups) { return groups.month + "/" + groups.year + "@" + off; }) === "07/2024@0""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `String.prototype.replace` with a string search passes the match, offset, and input.
        e2e_string_replace_function_string_search_signature_deep,
        r#""zabz".replace("ab", function(m, off, input) { return m + ":" + off + ":" + input; }) === "zab:1:zabzz""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Direct `@@split` returns an array for basic matches.
        e2e_regexp_symbol_split_direct_basic_deep,
        r#"var re = /,/; var out = re[Symbol.split]("a,b,c"); Array.isArray(out) && out.length === 3 && out[0] === "a" && out[2] === "c""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Direct `@@split` honours the limit argument.
        e2e_regexp_symbol_split_direct_limit_deep,
        r#"var re = /,/; var out = re[Symbol.split]("a,b,c", 2); out.length === 2 && out[0] === "a" && out[1] === "b""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Direct `@@split` with limit `0` returns an empty array.
        e2e_regexp_symbol_split_direct_zero_limit_deep,
        r#"var re = /,/; var out = re[Symbol.split]("a,b,c", 0); Array.isArray(out) && out.length === 0"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Direct `@@split` includes capture groups in the result.
        e2e_regexp_symbol_split_direct_captures_deep,
        r#"var re = /(\d)/; var out = re[Symbol.split]("a1b2c"); out.length === 5 && out[1] === "1" && out[3] === "2""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Direct `@@split` includes undefined for non-participating captures.
        e2e_regexp_symbol_split_direct_undefined_capture_deep,
        r#"var re = /-(x)?/; var out = re[Symbol.split]("a-b"); out.length === 3 && out[0] === "a" && out[1] === undefined && out[2] === "b""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Zero-width direct `@@split` produces individual characters.
        e2e_regexp_symbol_split_direct_zero_width_characters_deep,
        r#"var re = /(?:)/; var out = re[Symbol.split]("ab"); out.length === 2 && out[0] === "a" && out[1] === "b""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Zero-width direct `@@split` respects the limit argument.
        e2e_regexp_symbol_split_direct_zero_width_limit_deep,
        r#"var re = /(?:)/; var out = re[Symbol.split]("ab", 1); out.length === 1 && out[0] === "a""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Empty input with an empty-match regexp splits to an empty array.
        e2e_regexp_symbol_split_direct_empty_input_empty_match_deep,
        r#"var re = /(?:)/; var out = re[Symbol.split](""); Array.isArray(out) && out.length === 0"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// No-match direct `@@split` returns the original string.
        e2e_regexp_symbol_split_direct_no_match_deep,
        r#"var re = /\d+/; var out = re[Symbol.split]("abc"); out.length === 1 && out[0] === "abc""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Lookahead matches can split without consuming characters.
        e2e_regexp_symbol_split_direct_lookahead_deep,
        r#"var re = /(?=b)/; var out = re[Symbol.split]("abc"); out.length === 2 && out[0] === "a" && out[1] === "bc""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Plain regexps are scanned sticky-style during split.
        e2e_regexp_symbol_split_direct_plain_scans_sticky_style_deep,
        r#"var re = /a/; var out = re[Symbol.split]("baab"); out.length === 3 && out[0] === "b" && out[1] === "" && out[2] === "b""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Sticky regexps produce the same split result.
        e2e_regexp_symbol_split_direct_sticky_flag_deep,
        r#"var re = /a/y; var out = re[Symbol.split]("baab"); out.length === 3 && out[0] === "b" && out[1] === "" && out[2] === "b""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Direct `@@split` preserves the original `lastIndex`.
        e2e_regexp_symbol_split_direct_preserves_last_index_deep,
        r#"var re = /a/g; re.lastIndex = 2; re[Symbol.split]("baab"); re.lastIndex === 2"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Capture groups count toward the split limit.
        e2e_regexp_symbol_split_direct_capture_limit_deep,
        r#"var re = /(\d)/; var out = re[Symbol.split]("a1b2c", 4); out.length === 4 && out[0] === "a" && out[1] === "1" && out[2] === "b" && out[3] === "2""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Splitting at the end keeps a trailing empty string.
        e2e_regexp_symbol_split_direct_trailing_empty_deep,
        r#"var re = /,/; var out = re[Symbol.split]("a,"); out.length === 2 && out[0] === "a" && out[1] === """#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Splitting at the start keeps a leading empty string.
        e2e_regexp_symbol_split_direct_leading_empty_deep,
        r#"var re = /,/; var out = re[Symbol.split](",a"); out.length === 2 && out[0] === "" && out[1] === "a""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Adjacent matches keep empty strings between separators.
        e2e_regexp_symbol_split_direct_adjacent_matches_deep,
        r#"var re = /,/; var out = re[Symbol.split]("a,,b"); out.length === 3 && out[0] === "a" && out[1] === "" && out[2] === "b""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Global regexps split correctly and preserve empties.
        e2e_regexp_symbol_split_direct_global_flag_deep,
        r#"var re = /a/g; var out = re[Symbol.split]("baab"); out.length === 3 && out[0] === "b" && out[1] === "" && out[2] === "b""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Empty-input optional matches still return an empty array.
        e2e_regexp_symbol_split_direct_empty_input_optional_match_deep,
        r#"var re = /a?/; var out = re[Symbol.split](""); Array.isArray(out) && out.length === 0"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Lookaheads at the start do not create an extra leading empty string.
        e2e_regexp_symbol_split_direct_lookahead_at_start_deep,
        r#"var re = /(?=a)/; var out = re[Symbol.split]("ab"); out.length === 1 && out[0] === "ab""#
    );

    string_symbol_dispatch_test!(
        /// `exec` groups objects have a null prototype.
        e2e_regexp_exec_groups_null_proto_deep,
        r#"var m = /(?<x>a)/.exec("a"); Object.getPrototypeOf(m.groups) === null && m.groups.x === "a""#
    );

    string_symbol_dispatch_test!(
        /// `exec` groups objects expose undefined for missing named groups.
        e2e_regexp_exec_groups_undefined_entry_deep,
        r#"var m = /(?<x>a)|(?<y>b)/.exec("a"); m.groups.x === "a" && m.groups.y === undefined"#
    );

    string_symbol_dispatch_test!(
        /// `exec` with `/d` exposes an array-like indices result.
        e2e_regexp_exec_indices_array_like_deep,
        r#"var m = /(\d+)/d.exec("a42"); Array.isArray(m.indices) && m.indices.length === 2 && m.indices[0][0] === 1 && m.indices[0][1] === 3"#
    );

    string_symbol_dispatch_test!(
        /// `exec` with `/d` exposes null-prototype named indices groups.
        e2e_regexp_exec_indices_groups_null_proto_deep,
        r#"var m = /(?<num>\d+)/d.exec("a42"); Object.getPrototypeOf(m.indices.groups) === null && m.indices.groups.num[0] === 1 && m.indices.groups.num[1] === 3"#
    );

    string_symbol_dispatch_test!(
        /// `exec` without named groups leaves `indices.groups` undefined.
        e2e_regexp_exec_indices_groups_undefined_deep,
        r#"var m = /(\d+)/d.exec("a42"); m.indices.groups === undefined"#
    );

    string_symbol_dispatch_test!(
        /// `exec` with `/d` exposes capture index pairs.
        e2e_regexp_exec_indices_capture_pairs_deep,
        r#"var m = /(\d+)-(\d+)/d.exec("a12-34b"); m.indices[1][0] === 1 && m.indices[1][1] === 3 && m.indices[2][0] === 4 && m.indices[2][1] === 6"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `String.prototype.matchAll` delegates to custom `@@matchAll`.
        e2e_string_match_all_custom_symbol_dispatch,
        r#"var matcher = {}; Object.defineProperty(matcher, Symbol.matchAll, { value: function(s) { return [s, s.toUpperCase()][Symbol.iterator](); } }); var out = Array.from("ab".matchAll(matcher)); out.length === 2 && out[0] === "ab" && out[1] === "AB""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@matchAll` receives the matcher as `this`.
        e2e_string_match_all_custom_symbol_this_binding,
        r#"var matcher = {}; Object.defineProperty(matcher, Symbol.matchAll, { value: function(s) { return [this === matcher && s === "ab"][Symbol.iterator](); } }); Array.from("ab".matchAll(matcher))[0] === true"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Inherited `@@matchAll` participates in `String.prototype.matchAll`.
        e2e_string_match_all_custom_symbol_inherited,
        r#"var proto = {}; Object.defineProperty(proto, Symbol.matchAll, { value: function(s) { return [s.length][Symbol.iterator](); } }); var matcher = Object.create(proto); Array.from("abcd".matchAll(matcher))[0] === 4"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Non-callable `@@matchAll` throws.
        e2e_string_match_all_custom_symbol_non_callable_throws,
        r#"var matcher = {}; Object.defineProperty(matcher, Symbol.matchAll, { value: 123 }); try { Array.from("ab".matchAll(matcher)); false; } catch (e) { e instanceof TypeError; }"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// `undefined` `@@matchAll` falls back to string coercion.
        e2e_string_match_all_custom_symbol_undefined_falls_back,
        r#"var matcher = { toString: function() { return "a"; } }; Object.defineProperty(matcher, Symbol.matchAll, { value: undefined }); Array.from("aba".matchAll(matcher)).length === 2"#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// Custom `@@matchAll` does not require a global regexp.
        e2e_string_match_all_custom_symbol_no_global_requirement,
        r#"var matcher = {}; Object.defineProperty(matcher, Symbol.matchAll, { value: function(s) { return [s + "!"][Symbol.iterator](); } }); Array.from("ab".matchAll(matcher))[0] === "ab!""#
    );

    string_symbol_dispatch_test!(
        #[ignore] // TODO: conformance — not yet passing
        /// RegExp `matchAll` preserves the original `lastIndex`.
        e2e_string_match_all_regexp_preserves_last_index,
        r#"var re = /a/g; re.lastIndex = 1; var out = Array.from("baaa".matchAll(re)); re.lastIndex === 1 && out.length === 3 && out[0].index === 1 && out[2].index === 3"#
    );

    // ── RegExp constructor ───────────────────────────────────────────────

    /// Constructor: string pattern and flags.
    #[test]
    fn e2e_regexp_constructor_string() {
        assert_eval_true(
            r#"var re = new RegExp("\\d+", "g");
            re.source === "\\d+" && re.flags === "g" && re.global === true"#,
        );
    }

    /// Constructor: from existing regexp preserves source.
    #[test]
    fn e2e_regexp_constructor_clone() {
        assert_eval_true(
            r#"var a = new RegExp("abc", "gi");
            var b = new RegExp(a);
            b.source === "abc" && b.flags === "gi""#,
        );
    }

    /// Constructor: from existing regexp overrides flags.
    #[test]
    fn e2e_regexp_constructor_override_flags() {
        assert_eval_true(
            r#"var a = new RegExp("abc", "gi");
            var b = new RegExp(a, "m");
            b.flags === "m" && b.global === false && b.multiline === true"#,
        );
    }

    /// Constructor: undefined pattern yields empty.
    #[test]
    fn e2e_regexp_constructor_undefined_pattern() {
        assert_eval_true(r#"new RegExp().source === "(?:)""#);
    }

    // ── exec with lastIndex and sticky/global ────────────────────────────

    /// exec: global advances lastIndex.
    #[test]
    fn e2e_regexp_exec_global_last_index() {
        assert_eval_true(
            r#"var re = /\d+/g;
            var m1 = re.exec("a1 b2");
            var li1 = re.lastIndex;
            var m2 = re.exec("a1 b2");
            m1[0] === "1" && li1 === 2 && m2[0] === "2""#,
        );
    }

    /// exec: sticky only matches at lastIndex.
    #[test]
    fn e2e_regexp_exec_sticky_at_last_index() {
        assert_eval_true(
            r#"var re = /\d+/y;
            re.lastIndex = 1;
            var m = re.exec("a123");
            m[0] === "123""#,
        );
    }

    /// exec: sticky failure resets lastIndex to 0.
    #[test]
    fn e2e_regexp_exec_sticky_fail_resets() {
        assert_eval_true(
            r#"var re = /\d+/y;
            re.lastIndex = 0;
            var m = re.exec("abc");
            m === null && re.lastIndex === 0"#,
        );
    }

    /// exec: global exhaustion resets lastIndex.
    #[test]
    fn e2e_regexp_exec_global_exhaustion() {
        assert_eval_true(
            r#"var re = /a/g;
            re.exec("a"); re.exec("a");
            re.lastIndex === 0"#,
        );
    }

    /// exec: result has correct length including captures.
    #[test]
    fn e2e_regexp_exec_result_length() {
        assert_eval_true(
            r#"var m = /(\d+)-(\d+)/.exec("12-34");
            m.length === 3 && m[0] === "12-34" && m[1] === "12" && m[2] === "34""#,
        );
    }

    // ── Additional conformance tests ─────────────────────────────────────

    /// hasIndices (d flag): exec returns indices.
    #[test]
    fn e2e_regexp_has_indices_exec() {
        assert_eval_true(
            r#"var m = new RegExp("(\\d+)", "d").exec("abc 42 end");
            m.indices[0][0] === 4 && m.indices[0][1] === 6 && m.indices[1][0] === 4"#,
        );
    }

    /// hasIndices: named group indices.
    #[test]
    fn e2e_regexp_has_indices_named() {
        assert_eval_true(
            r#"var m = new RegExp("(?<num>\\d+)", "d").exec("abc 42");
            m.indices.groups.num[0] === 4 && m.indices.groups.num[1] === 6"#,
        );
    }

    /// RegExp.escape: escapes syntax characters.
    #[test]
    fn e2e_regexp_escape_syntax_chars() {
        assert_eval_true(r#"RegExp.escape("a.b+c") === "a\\.b\\+c""#);
    }

    /// toString: returns /source/flags format.
    #[test]
    fn e2e_regexp_tostring_format() {
        assert_eval_true(r#"new RegExp("abc", "gi").toString() === "/abc/gi""#);
    }

    /// test: returns boolean false for non-match.
    #[test]
    fn e2e_regexp_test_returns_false() {
        assert_eval_true(r#"new RegExp("xyz").test("abc") === false"#);
    }

    /// matchAll: returns iterator of match objects with groups.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_regexp_matchall_named_groups() {
        assert_eval_true(
            r#"var results = [];
            for (var m of "a1 b2".matchAll(/(?<letter>[a-z])(?<digit>\d)/g)) {
                results.push(m.groups.letter + m.groups.digit);
            }
            results.join(",") === "a1,b2""#,
        );
    }

    /// replaceAll with global regexp.
    #[test]
    fn e2e_regexp_replace_all_global() {
        assert_eval_true(r#""aXbXc".replaceAll(/X/g, "-") === "a-b-c""#);
    }

    /// search: preserves lastIndex on global regexp.
    #[test]
    fn e2e_regexp_search_preserves_last_index() {
        assert_eval_true(
            r#"var re = /a/g;
            re.lastIndex = 5;
            "ba".search(re);
            re.lastIndex === 5"#,
        );
    }

    /// split: limit parameter respected.
    #[test]
    fn e2e_regexp_split_with_limit() {
        assert_eval_true(
            r#"var parts = "a,b,c,d".split(/,/, 2);
            parts.length === 2 && parts[0] === "a" && parts[1] === "b""#,
        );
    }

    // ══════════════════════════════════════════════════════════════════
    //  ES2022+ conformance – comprehensive e2e tests
    // ══════════════════════════════════════════════════════════════════

    // ── 1. String.raw ────────────────────────────────────────────────

    /// `String.raw` with manual template object produces interleaved output.
    #[test]
    fn e2e_string_raw_manual_template() {
        assert_eval_true("String.raw({raw: ['a', 'b', 'c']}, 'X', 'Y') === 'aXbYc'");
    }

    /// `String.raw` with single segment and no substitutions.
    #[test]
    fn e2e_string_raw_single_segment() {
        assert_eval_true("String.raw({raw: ['hello']}) === 'hello'");
    }

    /// `String.raw` ignores extra substitutions beyond template gaps.
    #[test]
    fn e2e_string_raw_extra_subs_ignored() {
        assert_eval_true("String.raw({raw: ['a', 'b']}, 'X', 'EXTRA') === 'aXb'");
    }

    /// `String.raw` with fewer substitutions than gaps fills remaining
    /// segments without substitution.
    #[test]
    fn e2e_string_raw_fewer_subs() {
        assert_eval_true("String.raw({raw: ['a', 'b', 'c']}, 'X') === 'aXbc'");
    }

    /// `String.raw` preserves backslashes literally.
    #[test]
    fn e2e_string_raw_preserves_backslash() {
        assert_eval_true(r#"String.raw({raw: ['C:\\Users']}) === 'C:\\Users'"#);
    }

    /// `String.raw` with empty raw array returns empty string.
    #[test]
    fn e2e_string_raw_empty_raw() {
        assert_eval_true("String.raw({raw: []}) === ''");
    }

    // ── 2. Object.hasOwn ─────────────────────────────────────────────

    /// `Object.hasOwn` returns true for own data property.
    #[test]
    fn e2e_object_has_own_data_property() {
        assert_eval_true("Object.hasOwn({x: 1}, 'x') === true");
    }

    /// `Object.hasOwn` returns false for missing property.
    #[test]
    fn e2e_object_has_own_missing() {
        assert_eval_true("Object.hasOwn({x: 1}, 'y') === false");
    }

    /// `Object.hasOwn` returns false for inherited toString.
    #[test]
    fn e2e_has_own_inherited_to_string() {
        assert_eval_true("Object.hasOwn({}, 'toString') === false");
    }

    /// `Object.hasOwn` works on null-prototype objects.
    #[test]
    fn e2e_has_own_null_prototype_obj() {
        assert_eval_true("var o = Object.create(null); o.x = 42; Object.hasOwn(o, 'x') === true");
    }

    /// `Object.hasOwn` returns true for numeric array indices.
    #[test]
    fn e2e_has_own_array_numeric_index() {
        assert_eval_true("Object.hasOwn([10, 20, 30], '1') === true");
    }

    /// `Object.hasOwn` returns false for out-of-bounds array index.
    #[test]
    fn e2e_has_own_array_index_oob() {
        assert_eval_true("Object.hasOwn([10, 20], '5') === false");
    }

    // ── 3. Array.prototype.at ────────────────────────────────────────

    /// `Array.prototype.at` with positive index returns correct element.
    #[test]
    fn e2e_array_at_positive_index() {
        assert_eval_true("[10, 20, 30].at(1) === 20");
    }

    /// `Array.prototype.at` with negative index wraps from end.
    #[test]
    fn e2e_array_at_negative_wrap() {
        assert_eval_true("[10, 20, 30].at(-1) === 30");
    }

    /// `Array.prototype.at` with -length returns first element.
    #[test]
    fn e2e_array_at_negative_equals_length() {
        assert_eval_true("[10, 20, 30].at(-3) === 10");
    }

    /// `Array.prototype.at` out of bounds returns undefined.
    #[test]
    fn e2e_array_at_out_of_bounds() {
        assert_eval_true("[10, 20].at(5) === undefined");
    }

    /// `Array.prototype.at` with negative out of bounds returns undefined.
    #[test]
    fn e2e_array_at_neg_out_of_bounds() {
        assert_eval_true("[10, 20].at(-5) === undefined");
    }

    /// `Array.prototype.at` on empty array always returns undefined.
    #[test]
    fn e2e_array_at_empty() {
        assert_eval_true("[].at(0) === undefined");
    }

    // ── 4. String.prototype.at ───────────────────────────────────────

    /// `String.prototype.at` positive index returns correct char.
    #[test]
    fn e2e_string_at_pos_index() {
        assert_eval_true("'hello'.at(1) === 'e'");
    }

    /// `String.prototype.at` with negative index wraps from end.
    #[test]
    fn e2e_string_at_negative_wrap() {
        assert_eval_true("'hello'.at(-1) === 'o'");
    }

    /// `String.prototype.at` out of bounds returns undefined.
    #[test]
    fn e2e_string_at_oob() {
        assert_eval_true("'hi'.at(10) === undefined");
    }

    /// `String.prototype.at` on empty string returns undefined.
    #[test]
    fn e2e_string_at_empty() {
        assert_eval_true("''.at(0) === undefined");
    }

    /// `String.prototype.at` with -length returns first character.
    #[test]
    fn e2e_string_at_neg_equals_length() {
        assert_eval_true("'abc'.at(-3) === 'a'");
    }

    // ── 5. String.prototype.replaceAll ───────────────────────────────

    /// `replaceAll` replaces all occurrences of a plain string.
    #[test]
    fn e2e_replace_all_basic() {
        assert_eval_true("'abcabc'.replaceAll('b', 'X') === 'aXcaXc'");
    }

    /// `replaceAll` with no matches returns original string.
    #[test]
    fn e2e_replace_all_no_match() {
        assert_eval_true("'hello'.replaceAll('z', 'X') === 'hello'");
    }

    /// `replaceAll` with empty search inserts between every character.
    #[test]
    fn e2e_replace_all_empty_search() {
        assert_eval_true("'ab'.replaceAll('', '-') === '-a-b-'");
    }

    /// `replaceAll` replaces with empty string to delete.
    #[test]
    fn e2e_replace_all_delete() {
        assert_eval_true("'aXbXc'.replaceAll('X', '') === 'abc'");
    }

    /// `replaceAll` is case-sensitive.
    #[test]
    fn e2e_replace_all_case_sensitive() {
        assert_eval_true("'AaBbAa'.replaceAll('A', 'x') === 'xaBbxa'");
    }

    // ── 6. Promise.any / AggregateError ──────────────────────────────

    /// `AggregateError` constructor creates error with errors array.
    #[test]
    fn e2e_aggregate_error_constructor() {
        assert_eval_true(
            "var e = new AggregateError([1, 2, 3], 'all failed'); \
             e.errors.length === 3 && e.message === 'all failed'",
        );
    }

    /// `AggregateError` is an instance of its constructor.
    #[test]
    fn e2e_aggregate_error_is_instance() {
        assert_eval_true("var e = new AggregateError([], 'msg'); e instanceof AggregateError");
    }

    /// `AggregateError` name property equals "AggregateError".
    #[test]
    fn e2e_aggregate_error_name_prop() {
        assert_eval_true("new AggregateError([], 'msg').name === 'AggregateError'");
    }

    /// `AggregateError` supports cause option (ES2022).
    #[test]
    fn e2e_aggregate_error_cause_opt() {
        assert_eval_true(
            "var e = new AggregateError([], 'msg', {cause: 'root'}); \
             e.cause === 'root'",
        );
    }

    // ── 7. Numeric separators ────────────────────────────────────────

    /// Decimal numeric separator: `1_000_000` equals 1000000.
    #[test]
    fn e2e_numeric_sep_decimal() {
        assert_eval_true("1_000_000 === 1000000");
    }

    /// Hex numeric separator: `0xFF_FF` equals 65535.
    #[test]
    fn e2e_numeric_sep_hex() {
        assert_eval_true("0xFF_FF === 65535");
    }

    /// Binary numeric separator: `0b1010_0001` equals 161.
    #[test]
    fn e2e_numeric_sep_binary() {
        assert_eval_true("0b1010_0001 === 161");
    }

    /// Octal numeric separator: `0o77_77` equals 4095.
    #[test]
    fn e2e_numeric_sep_octal() {
        assert_eval_true("0o77_77 === 4095");
    }

    /// Floating-point numeric separator: `1_000.5` equals 1000.5.
    #[test]
    fn e2e_numeric_sep_float() {
        assert_eval_true("1_000.5 === 1000.5");
    }

    // ── 8. Logical assignment operators ──────────────────────────────

    /// `||=` assigns when LHS is falsy.
    #[test]
    fn e2e_logical_or_assign_falsy() {
        assert_eval_true("var x = 0; x ||= 42; x === 42");
    }

    /// `||=` does not assign when LHS is truthy.
    #[test]
    fn e2e_logical_or_assign_truthy() {
        assert_eval_true("var x = 1; x ||= 42; x === 1");
    }

    /// `&&=` assigns when LHS is truthy.
    #[test]
    fn e2e_logical_and_assign_truthy() {
        assert_eval_true("var x = 1; x &&= 42; x === 42");
    }

    /// `&&=` does not assign when LHS is falsy.
    #[test]
    fn e2e_logical_and_assign_falsy() {
        assert_eval_true("var x = 0; x &&= 42; x === 0");
    }

    /// `??=` assigns when LHS is null.
    #[test]
    fn e2e_nullish_assign_null() {
        assert_eval_true("var x = null; x ??= 42; x === 42");
    }

    /// `??=` assigns when LHS is undefined.
    #[test]
    fn e2e_nullish_assign_undefined() {
        assert_eval_true("var x = undefined; x ??= 42; x === 42");
    }

    /// `??=` does not assign when LHS is zero (falsy but defined).
    #[test]
    fn e2e_nullish_assign_zero() {
        assert_eval_true("var x = 0; x ??= 42; x === 0");
    }

    /// `??=` does not assign when LHS is empty string.
    #[test]
    fn e2e_nullish_assign_empty_string() {
        assert_eval_true("var x = ''; x ??= 'default'; x === ''");
    }

    /// `||=` on object properties.
    #[test]
    fn e2e_logical_or_assign_property() {
        assert_eval_true("var o = {a: null}; o.a ||= 99; o.a === 99");
    }

    /// `&&=` on object properties.
    #[test]
    fn e2e_logical_and_assign_property() {
        assert_eval_true("var o = {a: 5}; o.a &&= 10; o.a === 10");
    }

    // ── 9. Private class fields (#field in obj) ─────────────────────

    /// Private field access inside class method.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_access() {
        assert_eval_true(
            "class C { #x = 42; get() { return this.#x; } } \
             new C().get() === 42",
        );
    }

    /// Private field is not accessible outside class.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_not_external() {
        let result = global_eval("class C { #x = 1; } new C().#x");
        assert!(
            result.is_err(),
            "Private field access outside class should fail"
        );
    }

    /// `#field in obj` brand check returns true for class instances.
    #[test]
    fn e2e_private_brand_check_true() {
        assert_eval_true(
            "class C { #x = 1; static has(o) { return #x in o; } } \
             C.has(new C()) === true",
        );
    }

    /// `#field in obj` brand check returns false for plain objects.
    #[test]
    fn e2e_private_brand_check_false() {
        assert_eval_true(
            "class C { #x = 1; static has(o) { return #x in o; } } \
             C.has({}) === false",
        );
    }

    #[test]
    fn e2e_private_field_wrong_receiver_type_error() {
        assert_eval_type_error(
            "class C { #x = 1; read(o) { return o.#x; } } \
             new C().read({})",
        );
    }

    #[test]
    fn e2e_private_field_null_receiver_type_error() {
        assert_eval_type_error(
            "class C { #x = 1; read(o) { return o.#x; } } \
             new C().read(null)",
        );
    }

    #[test]
    fn e2e_private_method_wrong_receiver_type_error() {
        assert_eval_type_error(
            "class C { #m() { return 1; } call(o) { return o.#m(); } } \
             new C().call({})",
        );
    }

    #[test]
    fn e2e_private_method_non_writable() {
        assert_eval_type_error(
            "class C { #m() { return 1; } set() { this.#m = 2; } } \
             new C().set()",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_method_reachable_from_nested_closure() {
        assert_eval_true(
            "class C { #x = 4; #m() { return this.#x; } make() { return () => this.#m(); } } \
             let fnRef = new C().make(); \
             fnRef() === 4",
        );
    }

    #[test]
    fn e2e_private_static_field_class_access() {
        assert_eval_true(
            "class C { static #x = 7; static read() { return C.#x; } } \
             C.read() === 7",
        );
    }

    #[test]
    fn e2e_private_static_field_wrong_receiver_type_error() {
        assert_eval_type_error(
            "class C { static #x = 7; static read(o) { return o.#x; } } \
             C.read(new C())",
        );
    }

    #[test]
    fn e2e_private_static_method_class_access() {
        assert_eval_true(
            "class C { static #m() { return 9; } static call() { return C.#m(); } } \
             C.call() === 9",
        );
    }

    #[test]
    fn e2e_private_static_method_wrong_receiver_type_error() {
        assert_eval_type_error(
            "class C { static #m() { return 9; } static call(o) { return o.#m(); } } \
             C.call({})",
        );
    }

    #[test]
    fn e2e_private_static_method_non_writable() {
        assert_eval_type_error(
            "class C { static #m() { return 1; } static set() { C.#m = 2; } } \
             C.set()",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_accessor_getter_behavior() {
        assert_eval_true(
            "class C { #value = 21; get #x() { return this.#value * 2; } read() { return this.#x; } } \
             new C().read() === 42",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_accessor_setter_behavior() {
        assert_eval_true(
            "class C { #value = 0; set #x(v) { this.#value = v + 1; } run() { this.#x = 9; return this.#value; } } \
             new C().run() === 10",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_accessor_getter_setter_pair() {
        assert_eval_true(
            "class C { #value = 1; get #x() { return this.#value; } set #x(v) { this.#value = v; } run() { this.#x = 7; return this.#x; } } \
             new C().run() === 7",
        );
    }

    #[test]
    fn e2e_private_accessor_wrong_receiver_type_error() {
        assert_eval_type_error(
            "class C { #value = 1; get #x() { return this.#value; } read(o) { return o.#x; } } \
             new C().read({})",
        );
    }

    #[test]
    fn e2e_private_static_accessor_getter_setter_behavior() {
        assert_eval_true(
            "class C { static #value = 1; static get #x() { return this.#value; } static set #x(v) { this.#value = v * 2; } static run() { this.#x = 6; return this.#x; } } \
             C.run() === 12",
        );
    }

    #[test]
    fn e2e_private_static_accessor_wrong_receiver_type_error() {
        assert_eval_type_error(
            "class C { static #value = 1; static get #x() { return this.#value; } static read(o) { return o.#x; } } \
             C.read({})",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_in_operator_subclass_instance_true() {
        assert_eval_true(
            "class Base { #x = 1; static has(o) { return #x in o; } } \
             class Child extends Base {} \
             Base.has(new Child()) === true",
        );
    }

    #[test]
    fn e2e_private_in_operator_same_name_other_class_false() {
        assert_eval_true(
            "class A { #x = 1; static has(o) { return #x in o; } } \
             class B { #x = 2; } \
             A.has(new B()) === false",
        );
    }

    #[test]
    fn e2e_private_static_in_operator_class_true() {
        assert_eval_true(
            "class C { static #x = 1; static has(o) { return #x in o; } } \
             C.has(C) === true",
        );
    }

    #[test]
    fn e2e_private_static_in_operator_instance_false() {
        assert_eval_true(
            "class C { static #x = 1; static has(o) { return #x in o; } } \
             C.has(new C()) === false",
        );
    }

    #[test]
    fn e2e_private_static_in_operator_subclass_false() {
        assert_eval_true(
            "class Base { static #x = 1; static has(o) { return #x in o; } } \
             class Child extends Base {} \
             Base.has(Child) === false",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_fields_in_subclass_inherit_parent_access() {
        assert_eval_true(
            "class Base { #x = 5; getBase() { return this.#x; } } \
             class Child extends Base {} \
             new Child().getBase() === 5",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_fields_in_subclass_keep_own_fields() {
        assert_eval_true(
            "class Base { #x = 5; getBase() { return this.#x; } } \
             class Child extends Base { #y = 8; getChild() { return this.#y; } } \
             let c = new Child(); \
             c.getBase() === 5 && c.getChild() === 8",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_shadowing_parent_child() {
        assert_eval_true(
            "class Base { #x = 1; getBase() { return this.#x; } } \
             class Child extends Base { #x = 2; getChild() { return this.#x; } sum() { return this.getBase() * 10 + this.getChild(); } } \
             new Child().sum() === 12",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_method_shadowing_parent_child() {
        assert_eval_true(
            "class Base { #m() { return 1; } callBase() { return this.#m(); } } \
             class Child extends Base { #m() { return 2; } callChild() { return this.#m(); } } \
             let c = new Child(); \
             c.callBase() === 1 && c.callChild() === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_nested_closure_read() {
        assert_eval_true(
            "class C { #x = 3; make() { let self = this; return function() { return self.#x; }; } } \
             new C().make()() === 3",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_nested_arrow_update() {
        assert_eval_true(
            "class C { #x = 1; run() { let bump = () => { this.#x = this.#x + 1; return this.#x; }; return bump() === 2 && this.#x === 2; } } \
             new C().run() === true",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_closure_survives_after_method_return() {
        assert_eval_true(
            "class C { #x = 11; make() { return () => this.#x; } } \
             let read = new C().make(); \
             read() === 11",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_brand_isolated_between_classes() {
        assert_eval_true(
            "class A { #x = 1; static has(o) { return #x in o; } get() { return this.#x; } } \
             class B { #x = 2; static has(o) { return #x in o; } get() { return this.#x; } } \
             let a = new A(); \
             let b = new B(); \
             A.has(a) && !A.has(b) && B.has(b) && !B.has(a) && a.get() === 1 && b.get() === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_brand_shadowing_adds_both_brands() {
        assert_eval_true(
            "class Base { #x = 1; static hasBase(o) { return #x in o; } getBase() { return this.#x; } } \
             class Child extends Base { #x = 2; static hasChild(o) { return #x in o; } getChild() { return this.#x; } } \
             let c = new Child(); \
             Base.hasBase(c) && Child.hasChild(c) && c.getBase() === 1 && c.getChild() === 2",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_initializer_with_sibling_private_access() {
        assert_eval_true(
            "class C { #x = 6; #y = this.#x + 1; sum() { return this.#x + this.#y; } } \
             new C().sum() === 13",
        );
    }

    #[test]
    fn e2e_private_static_field_not_inherited_by_subclass_receiver() {
        assert_eval_type_error(
            "class Base { static #x = 1; static read(o) { return o.#x; } } \
             class Child extends Base {} \
             Base.read(Child)",
        );
    }

    #[test]
    fn e2e_private_static_method_not_inherited_by_subclass_receiver() {
        assert_eval_type_error(
            "class Base { static #m() { return 1; } static read(o) { return o.#m(); } } \
             class Child extends Base {} \
             Base.read(Child)",
        );
    }

    #[test]
    fn e2e_private_static_accessor_not_inherited_by_subclass_receiver() {
        assert_eval_type_error(
            "class Base { static #value = 1; static get #x() { return this.#value; } static read(o) { return o.#x; } } \
             class Child extends Base {} \
             Base.read(Child)",
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_method_can_access_parent_private_field_on_subclass_instance() {
        assert_eval_true(
            "class Base { #x = 10; #m() { return this.#x; } callBase() { return this.#m(); } } \
             class Child extends Base { #y = 1; getY() { return this.#y; } } \
             let c = new Child(); \
             c.callBase() === 10 && c.getY() === 1",
        );
    }

    // ── 10. Error.cause ──────────────────────────────────────────────

    /// `Error` with cause option sets `.cause` property.
    #[test]
    fn e2e_error_cause_basic() {
        assert_eval_true("var e = new Error('fail', {cause: 'root'}); e.cause === 'root'");
    }

    /// `Error` without cause option has undefined `.cause`.
    #[test]
    fn e2e_error_no_cause() {
        assert_eval_true("new Error('msg').cause === undefined");
    }

    /// Error cause chaining: outer error wraps inner error.
    #[test]
    fn e2e_error_cause_chaining() {
        assert_eval_true(
            "var inner = new Error('inner'); \
             var outer = new Error('outer', {cause: inner}); \
             outer.cause.message === 'inner'",
        );
    }

    /// `TypeError` also supports cause option (ES2022).
    #[test]
    fn e2e_type_error_with_cause_option() {
        assert_eval_true(
            "var e = new TypeError('bad', {cause: 42}); \
             e.cause === 42 && e.message === 'bad'",
        );
    }

    // ── 11. Cross-feature interactions ───────────────────────────────

    /// `Object.hasOwn` + `Object.create(null)`: null-prototype object.
    #[test]
    fn e2e_has_own_create_null_missing() {
        assert_eval_true("var o = Object.create(null); Object.hasOwn(o, 'toString') === false");
    }

    /// `Array.prototype.at` with `replaceAll` pipeline.
    #[test]
    fn e2e_array_at_replace_all_combo() {
        assert_eval_true("'a-b-c'.split('-').at(-1) === 'c'");
    }

    /// Logical assignment with numeric separator literals.
    #[test]
    fn e2e_logical_assign_numeric_sep() {
        assert_eval_true("var x = null; x ??= 1_000; x === 1000");
    }

    /// `String.raw` with numeric expressions as substitutions.
    #[test]
    fn e2e_string_raw_numeric_subs() {
        assert_eval_true("String.raw({raw: ['val=', '!']}, 42) === 'val=42!'");
    }

    /// `AggregateError` with cause and errors together.
    #[test]
    fn e2e_aggregate_error_cause_and_errors() {
        assert_eval_true(
            "var e = new AggregateError(['a', 'b'], 'msg', {cause: 'root'}); \
             e.errors.length === 2 && e.cause === 'root'",
        );
    }

    /// Private field with default value of zero is not nullish.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_private_field_default_zero() {
        assert_eval_true(
            "class C { #x = 0; get() { return this.#x; } } \
             new C().get() === 0",
        );
    }

    // ── Getter / Setter conformance tests ────────────────────────────────

    // 1. Object literal getter returns value
    #[test]
    fn e2e_getter_basic_object_literal() {
        assert_eval_true("var o = { get x() { return 42; } }; o.x === 42");
    }

    // 2. Object literal setter stores value via closure
    #[test]
    fn e2e_setter_basic_object_literal() {
        assert_eval_true(
            "var o = { _v: 0, get v() { return this._v; }, set v(x) { this._v = x; } }; \
             o.v = 10; o.v === 10",
        );
    }

    // 3. Getter with no setter — read returns getter result
    #[test]
    fn e2e_getter_only_read() {
        let r = global_eval("var o = { get x() { return 'hello'; } }; o.x").unwrap();
        assert_eq!(r, JsValue::String("hello".into()));
    }

    // 4. Setter-only property — read returns undefined
    #[test]
    fn e2e_setter_only_read_returns_undefined() {
        assert_eval_true("var o = { set x(v) { this._x = v; } }; o.x === undefined");
    }

    // 5. Setter invoked on assignment
    #[test]
    fn e2e_setter_invoked_on_assign() {
        assert_eval_true(
            "var o = { _v: 0, set v(x) { this._v = x * 2; }, get v() { return this._v; } }; \
             o.v = 5; o.v === 10",
        );
    }

    // 6. Getter/setter with this — correct receiver
    #[test]
    fn e2e_getter_setter_this_binding() {
        assert_eval_true(
            "var o = { name: 'world', get greeting() { return 'hello ' + this.name; } }; \
             o.greeting === 'hello world'",
        );
    }

    // 7. Setter with this — mutates correct receiver
    #[test]
    fn e2e_setter_this_mutates_receiver() {
        assert_eval_true(
            "var o = { _count: 0, set count(v) { this._count = v; }, get count() { return this._count; } }; \
             o.count = 7; o._count === 7",
        );
    }

    // 8. Object.defineProperty with get/set
    #[test]
    fn e2e_define_property_accessor() {
        assert_eval_true(
            "var o = {}; var stored = 0; \
             Object.defineProperty(o, 'x', { \
               get: function() { return stored; }, \
               set: function(v) { stored = v; } \
             }); \
             o.x = 42; o.x === 42",
        );
    }

    // 9. Object.defineProperty — getter only
    #[test]
    fn e2e_define_property_getter_only() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'pi', { get: function() { return 3.14; } }); \
             o.pi === 3.14",
        );
    }

    // 10. Object.getOwnPropertyDescriptor on accessor
    #[test]
    fn e2e_get_own_property_descriptor_accessor_v2() {
        assert_eval_true(
            "var o = { get x() { return 1; } }; \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             typeof d.get === 'function' && d.set === undefined",
        );
    }

    // 11. Object.getOwnPropertyDescriptor — enumerable/configurable
    #[test]
    fn e2e_descriptor_accessor_enumerable_configurable() {
        assert_eval_true(
            "var o = { get x() { return 1; } }; \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.enumerable === true && d.configurable === true",
        );
    }

    // 12. Object.getOwnPropertyDescriptor — has no value/writable
    #[test]
    fn e2e_descriptor_accessor_no_value_writable() {
        assert_eval_true(
            "var o = { get x() { return 1; } }; \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === undefined && d.writable === undefined",
        );
    }

    // 13. Getter/setter pair via defineProperty — descriptor reports both
    #[test]
    fn e2e_descriptor_getter_setter_pair() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
               get: function() { return 1; }, \
               set: function(v) {} \
             }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             typeof d.get === 'function' && typeof d.set === 'function'",
        );
    }

    // 14. Class getter
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_getter() {
        assert_eval_true(
            "class C { get x() { return 99; } } \
             var c = new C(); c.x === 99",
        );
    }

    // 15. Class setter
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_setter() {
        assert_eval_true(
            "class C { \
               constructor() { this._v = 0; } \
               get v() { return this._v; } \
               set v(x) { this._v = x; } \
             } \
             var c = new C(); c.v = 42; c.v === 42",
        );
    }

    // 16. Class getter/setter pair — this binding
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_getter_setter_this() {
        assert_eval_true(
            "class C { \
               constructor() { this._name = 'init'; } \
               get name() { return this._name; } \
               set name(v) { this._name = v.toUpperCase(); } \
             } \
             var c = new C(); c.name = 'hello'; c.name === 'HELLO'",
        );
    }

    // 17. Static getter in class
    #[test]
    fn e2e_class_static_getter() {
        assert_eval_true(
            "class C { static get answer() { return 42; } } \
             C.answer === 42",
        );
    }

    // 18. Static setter in class
    #[test]
    fn e2e_class_static_setter() {
        assert_eval_true(
            "class C { \
               static get val() { return C._val || 0; } \
               static set val(v) { C._val = v; } \
             } \
             C.val = 7; C.val === 7",
        );
    }

    // 19. Inherited getter from prototype chain
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_inherited_getter_prototype() {
        assert_eval_true(
            "var parent = { get x() { return 'from parent'; } }; \
             var child = Object.create(parent); \
             child.x === 'from parent'",
        );
    }

    // 20. Inherited setter from prototype chain
    #[test]
    fn e2e_inherited_setter_prototype() {
        assert_eval_true(
            "var parent = { _v: 0, set v(x) { this._v = x; }, get v() { return this._v; } }; \
             var child = Object.create(parent); \
             child.v = 55; child._v === 55",
        );
    }

    // 21. Inherited getter with correct this (receiver is child)
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_inherited_getter_this_receiver() {
        assert_eval_true(
            "var parent = { get id() { return this._id; } }; \
             var child = Object.create(parent); \
             child._id = 'child-id'; \
             child.id === 'child-id'",
        );
    }

    // 22. Computed property getter
    #[test]
    fn e2e_computed_property_getter() {
        assert_eval_true(
            "var key = 'foo'; \
             var o = { get [key]() { return 'bar'; } }; \
             o.foo === 'bar'",
        );
    }

    // 23. Computed property setter
    #[test]
    fn e2e_computed_property_setter() {
        assert_eval_true(
            "var key = 'val'; \
             var o = { _v: 0, get [key]() { return this._v; }, set [key](x) { this._v = x; } }; \
             o.val = 100; o.val === 100",
        );
    }

    // 24. Getter returning different types
    #[test]
    fn e2e_getter_returns_object() {
        assert_eval_true(
            "var o = { get arr() { return [1, 2, 3]; } }; \
             o.arr.length === 3",
        );
    }

    // 25. Getter called every access (not cached)
    #[test]
    fn e2e_getter_called_every_access() {
        assert_eval_true(
            "var count = 0; \
             var o = { get x() { count = count + 1; return count; } }; \
             var a = o.x; var b = o.x; b === 2",
        );
    }

    // 26. Setter receives correct value
    #[test]
    fn e2e_setter_receives_value() {
        assert_eval_true(
            "var received = null; \
             var o = { set x(v) { received = v; } }; \
             o.x = 'test'; received === 'test'",
        );
    }

    // 27. Getter/setter .name for object literal
    #[test]
    fn e2e_getter_name_object_literal() {
        assert_eval_true(
            "var o = { get myProp() { return 1; } }; \
             var d = Object.getOwnPropertyDescriptor(o, 'myProp'); \
             d.get.name === 'get myProp'",
        );
    }

    // 28. Setter .name for object literal
    #[test]
    fn e2e_setter_name_object_literal() {
        assert_eval_true(
            "var o = { set myProp(v) {} }; \
             var d = Object.getOwnPropertyDescriptor(o, 'myProp'); \
             d.set.name === 'set myProp'",
        );
    }

    // 29. Class getter .name
    #[test]
    fn e2e_class_getter_name() {
        assert_eval_true(
            "class C { get myProp() { return 1; } } \
             var d = Object.getOwnPropertyDescriptor(C.prototype, 'myProp'); \
             d.get.name === 'get myProp'",
        );
    }

    // 30. Class setter .name
    #[test]
    fn e2e_class_setter_name() {
        assert_eval_true(
            "class C { set myProp(v) {} } \
             var d = Object.getOwnPropertyDescriptor(C.prototype, 'myProp'); \
             d.set.name === 'set myProp'",
        );
    }

    // 31. Multiple getters/setters on same object
    #[test]
    fn e2e_multiple_getters_setters() {
        assert_eval_true(
            "var o = { \
               get a() { return 1; }, \
               get b() { return 2; }, \
               set c(v) { this._c = v; }, \
               get c() { return this._c; } \
             }; \
             o.a === 1 && o.b === 2 && (o.c = 3, o.c === 3)",
        );
    }

    // 32. Getter on Object.keys includes accessor names
    #[test]
    fn e2e_accessor_in_object_keys() {
        assert_eval_true(
            "var o = { get x() { return 1; }, y: 2 }; \
             var k = Object.keys(o); \
             k.indexOf('x') >= 0 && k.indexOf('y') >= 0",
        );
    }

    // 33. Accessor property in for...in
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_accessor_property_in_for_in() {
        assert_eval_true(
            "var o = { get x() { return 1; }, y: 2 }; \
             var keys = []; for (var k in o) { keys.push(k); } \
             keys.indexOf('x') >= 0 && keys.indexOf('y') >= 0",
        );
    }

    // 34. Overriding inherited getter with own property
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_override_inherited_getter() {
        assert_eval_true(
            "var parent = { get x() { return 'parent'; } }; \
             var child = Object.create(parent); \
             child.x = 'child'; \
             child.x === 'child'",
        );
    }

    // 35. Class with both instance and static getter
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_class_instance_and_static_getter() {
        assert_eval_true(
            "class C { \
               get x() { return 'instance'; } \
               static get x() { return 'static'; } \
              } \
             var c = new C(); c.x === 'instance' && C.x === 'static'",
        );
    }

    // ══════════════════════════════════════════════════════════════════════
    // Well-known symbols deep conformance — e2e tests
    // ══════════════════════════════════════════════════════════════════════

    // ── @@species ────────────────────────────────────────────────────────

    #[test]
    fn e2e_wk_species_array_identity() {
        assert_eval_true("Array[Symbol.species] === Array");
    }

    #[test]
    fn e2e_wk_species_map_identity() {
        assert_eval_true("Map[Symbol.species] === Map");
    }

    #[test]
    fn e2e_wk_species_set_identity() {
        assert_eval_true("Set[Symbol.species] === Set");
    }

    #[test]
    fn e2e_wk_species_regexp_identity() {
        assert_eval_true("RegExp[Symbol.species] === RegExp");
    }

    #[test]
    fn e2e_wk_species_promise_identity() {
        assert_eval_true("Promise[Symbol.species] === Promise");
    }

    #[test]
    fn e2e_wk_species_arraybuffer_identity() {
        assert_eval_true("ArrayBuffer[Symbol.species] === ArrayBuffer");
    }

    #[test]
    fn e2e_wk_species_typeof_array() {
        assert_eval_true("typeof Array[Symbol.species] === 'function'");
    }

    #[test]
    fn e2e_wk_species_array_slice_returns_array() {
        assert_eval_true("Array.isArray([1,2,3].slice(1))");
    }

    #[test]
    fn e2e_wk_species_array_map_returns_array() {
        assert_eval_true("Array.isArray([1,2,3].map(function(x) { return x * 2; }))");
    }

    #[test]
    fn e2e_wk_species_array_filter_returns_array() {
        assert_eval_true("Array.isArray([1,2,3,4].filter(function(x) { return x > 2; }))");
    }

    // ── @@hasInstance ────────────────────────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_wk_has_instance_basic_function() {
        assert_eval_true(
            "function Foo() {} \
             var f = new Foo(); \
             f instanceof Foo",
        );
    }

    #[test]
    fn e2e_wk_has_instance_custom_static() {
        assert_eval_true(
            r#"
            var Checker = {};
            Checker[Symbol.hasInstance] = function(inst) { return inst.cool === true; };
            var a = { cool: true };
            var b = { cool: false };
            a[Symbol.hasInstance] !== undefined || (Checker[Symbol.hasInstance](a) === true && Checker[Symbol.hasInstance](b) === false)
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_wk_has_instance_class_override() {
        assert_eval_true(
            r#"
            class EvenChecker {
                static [Symbol.hasInstance](instance) {
                    return typeof instance === 'number' && instance % 2 === 0;
                }
            }
            EvenChecker[Symbol.hasInstance](4) && !EvenChecker[Symbol.hasInstance](3)
            "#,
        );
    }

    #[test]
    fn e2e_wk_has_instance_instanceof_non_callable_throws() {
        assert_eval_type_error("({}) instanceof 42");
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_wk_has_instance_array_instanceof() {
        assert_eval_true("[] instanceof Array");
    }

    #[test]
    fn e2e_wk_has_instance_error_instanceof() {
        assert_eval_true("try { undefined.x } catch(e) { e instanceof TypeError }");
    }

    #[test]
    fn e2e_wk_has_instance_function_proto_has_method() {
        assert_eval_true("typeof Function.prototype[Symbol.hasInstance] === 'function'");
    }

    // ── @@isConcatSpreadable ────────────────────────────────────────────

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_wk_concat_spreadable_default_array() {
        assert_eval_true("[1,2].concat([3,4]).length === 4");
    }

    #[test]
    fn e2e_wk_concat_spreadable_false_prevents_spread() {
        assert_eval_true(
            r#"
            var a = [3, 4];
            a[Symbol.isConcatSpreadable] = false;
            var r = [1, 2].concat(a);
            r.length === 3
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_wk_concat_spreadable_true_on_object() {
        assert_eval_true(
            r#"
            var obj = { 0: 'a', 1: 'b', length: 2 };
            obj[Symbol.isConcatSpreadable] = true;
            var r = ['x'].concat(obj);
            r.length === 3 && r[1] === 'a' && r[2] === 'b'
            "#,
        );
    }

    #[test]
    fn e2e_wk_concat_spreadable_default_object_not_spread() {
        assert_eval_true(
            r#"
            var obj = { 0: 'a', 1: 'b', length: 2 };
            var r = ['x'].concat(obj);
            r.length === 2
            "#,
        );
    }

    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_wk_concat_spreadable_undefined_falls_back() {
        assert_eval_true(
            r#"
            var a = [3, 4];
            a[Symbol.isConcatSpreadable] = undefined;
            var r = [1, 2].concat(a);
            r.length === 4
            "#,
        );
    }

    #[test]
    fn e2e_wk_concat_spreadable_symbol_exists() {
        assert_eval_true("typeof Symbol.isConcatSpreadable === 'symbol'");
    }

    #[test]
    fn e2e_wk_concat_spreadable_description() {
        assert_eval_true("Symbol.isConcatSpreadable.description === 'Symbol.isConcatSpreadable'");
    }

    // ── @@unscopables ───────────────────────────────────────────────────

    #[test]
    fn e2e_wk_unscopables_array_proto_has_it() {
        assert_eval_true("typeof Array.prototype[Symbol.unscopables] === 'object'");
    }

    #[test]
    fn e2e_wk_unscopables_includes_find() {
        assert_eval_true("Array.prototype[Symbol.unscopables].find === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_findIndex() {
        assert_eval_true("Array.prototype[Symbol.unscopables].findIndex === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_at() {
        assert_eval_true("Array.prototype[Symbol.unscopables].at === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_findLast() {
        assert_eval_true("Array.prototype[Symbol.unscopables].findLast === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_findLastIndex() {
        assert_eval_true("Array.prototype[Symbol.unscopables].findLastIndex === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_flat() {
        assert_eval_true("Array.prototype[Symbol.unscopables].flat === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_flatMap() {
        assert_eval_true("Array.prototype[Symbol.unscopables].flatMap === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_includes() {
        assert_eval_true("Array.prototype[Symbol.unscopables].includes === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_values() {
        assert_eval_true("Array.prototype[Symbol.unscopables].values === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_keys() {
        assert_eval_true("Array.prototype[Symbol.unscopables].keys === true");
    }

    #[test]
    fn e2e_wk_unscopables_includes_entries() {
        assert_eval_true("Array.prototype[Symbol.unscopables].entries === true");
    }

    #[test]
    fn e2e_wk_unscopables_excludes_map() {
        assert_eval_true("Array.prototype[Symbol.unscopables].map === undefined");
    }

    #[test]
    fn e2e_wk_unscopables_symbol_description() {
        assert_eval_true("Symbol.unscopables.description === 'Symbol.unscopables'");
    }

    // ── @@toPrimitive ───────────────────────────────────────────────────

    #[test]
    fn e2e_wk_to_primitive_custom_number() {
        assert_eval_true(
            r#"
            var obj = {};
            obj[Symbol.toPrimitive] = function(hint) {
                if (hint === 'number') return 42;
                if (hint === 'string') return 'hello';
                return true;
            };
            +obj === 42
            "#,
        );
    }

    #[test]
    fn e2e_wk_to_primitive_custom_string() {
        assert_eval_true(
            r#"
            var obj = {};
            obj[Symbol.toPrimitive] = function(hint) {
                if (hint === 'number') return 42;
                if (hint === 'string') return 'hello';
                return true;
            };
            String(obj) === 'hello'
            "#,
        );
    }

    #[test]
    fn e2e_wk_to_primitive_custom_default() {
        assert_eval_true(
            r#"
            var obj = {};
            obj[Symbol.toPrimitive] = function(hint) {
                return hint;
            };
            obj + '' === 'default'
            "#,
        );
    }

    #[test]
    fn e2e_wk_to_primitive_date_string_hint() {
        assert_eval_true("typeof String(new Date()) === 'string'");
    }

    #[test]
    fn e2e_wk_to_primitive_date_number_hint() {
        assert_eval_true("typeof (+new Date()) === 'number'");
    }

    #[test]
    fn e2e_wk_to_primitive_non_primitive_throws() {
        assert_eval_type_error(
            r#"
            var obj = {};
            obj[Symbol.toPrimitive] = function(hint) { return {}; };
            +obj
            "#,
        );
    }

    #[test]
    fn e2e_wk_to_primitive_symbol_exists() {
        assert_eval_true("typeof Symbol.toPrimitive === 'symbol'");
    }

    #[test]
    fn e2e_wk_to_primitive_symbol_description() {
        assert_eval_true("Symbol.toPrimitive.description === 'Symbol.toPrimitive'");
    }

    #[test]
    fn e2e_wk_to_primitive_date_default_prefers_string() {
        assert_eval_true("typeof (new Date() + '') === 'string'");
    }

    // ── Cross-cutting well-known symbol tests ───────────────────────────

    #[test]
    fn e2e_wk_symbol_species_is_symbol_type() {
        assert_eval_true("typeof Symbol.species === 'symbol'");
    }

    #[test]
    fn e2e_wk_symbol_has_instance_is_symbol_type() {
        assert_eval_true("typeof Symbol.hasInstance === 'symbol'");
    }

    #[test]
    fn e2e_wk_symbol_unscopables_is_symbol_type() {
        assert_eval_true("typeof Symbol.unscopables === 'symbol'");
    }

    #[test]
    fn e2e_wk_all_well_known_are_unique() {
        assert_eval_true(
            "Symbol.species !== Symbol.hasInstance && \
             Symbol.hasInstance !== Symbol.isConcatSpreadable && \
             Symbol.isConcatSpreadable !== Symbol.unscopables && \
             Symbol.unscopables !== Symbol.toPrimitive && \
             Symbol.toPrimitive !== Symbol.iterator",
        );
    }

    #[test]
    fn e2e_wk_species_not_in_symbol_for_registry() {
        assert_eval_true("Symbol.keyFor(Symbol.species) === undefined");
    }

    #[test]
    fn e2e_wk_has_instance_not_in_symbol_for_registry() {
        assert_eval_true("Symbol.keyFor(Symbol.hasInstance) === undefined");
    }

    // ── Array.fromAsync e2e tests ────────────────────────────────────────

    /// `Array.fromAsync` with sync array returns a promise.
    #[test]
    fn e2e_array_from_async_returns_promise() {
        assert_eval_true("typeof Array.fromAsync([1,2,3]) === 'object'");
    }

    /// `Array.fromAsync` with sync array resolves to array.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_from_async_sync_array() {
        let result = global_eval(
            r#"
            var p = Array.fromAsync([10, 20, 30]);
            var arr = p.__value__;
            arr.length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Array.fromAsync` with mapFn applies mapping.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_from_async_with_map_fn() {
        let result = global_eval(
            r#"
            var p = Array.fromAsync([1, 2, 3], function(x) { return x * 2; });
            var arr = p.__value__;
            arr[0] + arr[1] + arr[2]
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(12));
    }

    /// `Array.fromAsync` with empty array.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_from_async_empty() {
        let result = global_eval(
            r#"
            var p = Array.fromAsync([]);
            var arr = p.__value__;
            arr.length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `Array.fromAsync.length` is 1.
    #[test]
    fn e2e_array_from_async_length_prop() {
        let result = global_eval("Array.fromAsync.length").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// `Array.fromAsync.name` is "fromAsync".
    #[test]
    fn e2e_array_from_async_name_prop() {
        let result = global_eval("Array.fromAsync.name").unwrap();
        assert_eq!(result, JsValue::String("fromAsync".into()));
    }

    /// `Array.fromAsync` rejects non-function mapFn.
    #[test]
    fn e2e_array_from_async_non_function_map_fn_throws() {
        let result = global_eval("Array.fromAsync([1], 42)");
        assert!(result.is_err());
    }

    // ── Additional Object.groupBy e2e tests ─────────────────────────────

    /// `Object.groupBy` with duplicate key gathers all.
    #[test]
    fn e2e_object_group_by_duplicate_keys() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,1,1], function(n) { return "x"; });
            r.x.length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    /// `Object.groupBy` with mixed types in callback return.
    #[test]
    fn e2e_object_group_by_coerces_to_string() {
        let result = global_eval(
            r#"
            var r = Object.groupBy([1,2,3], function(n) { return n; });
            typeof r
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("object".into()));
    }

    // ── Additional Map.groupBy e2e tests ────────────────────────────────

    /// `Map.groupBy` with empty array returns empty map.
    #[test]
    fn e2e_map_group_by_empty_v2() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([], function(n) { return n; });
            m.size
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// `Map.groupBy` all elements in same group.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_map_group_by_single_group_v2() {
        let result = global_eval(
            r#"
            var m = Map.groupBy([1,2,3], function() { return "k"; });
            m.get("k").length
            "#,
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(3));
    }

    // ── Array.prototype comprehensive edge-case e2e tests ───────────────

    // ── splice ──────────────────────────────────────────────────────────

    /// `splice` with negative start counts from end.
    #[test]
    fn e2e_array_splice_negative_start() {
        let r = global_eval(
            r#"
            var a = [1,2,3,4,5];
            a.splice(-2, 1);
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2,3,5".into()));
    }

    /// `splice` returns the removed elements.
    #[test]
    fn e2e_array_splice_return_value() {
        let r = global_eval("[1,2,3,4,5].splice(1, 2).join(',')").unwrap();
        assert_eq!(r, JsValue::String("2,3".into()));
    }

    /// `splice` with zero deleteCount inserts without removing.
    #[test]
    fn e2e_array_splice_insert_no_delete() {
        let r = global_eval(
            r#"
            var a = [1,2,3];
            a.splice(1, 0, 10, 20);
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,10,20,2,3".into()));
    }

    /// `splice` with deleteCount larger than remaining length.
    #[test]
    fn e2e_array_splice_large_delete_count() {
        let r = global_eval(
            r#"
            var a = [1,2,3,4,5];
            a.splice(2, 100);
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2".into()));
    }

    /// `splice` with no deleteCount removes to end.
    #[test]
    fn e2e_array_splice_no_delete_count() {
        let r = global_eval(
            r#"
            var a = [1,2,3,4,5];
            a.splice(2);
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,2".into()));
    }

    /// `splice` with insertion and deletion simultaneously.
    #[test]
    fn e2e_array_splice_replace() {
        let r = global_eval(
            r#"
            var a = [1,2,3,4,5];
            a.splice(1, 2, 10, 20, 30);
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("1,10,20,30,4,5".into()));
    }

    // ── slice ───────────────────────────────────────────────────────────

    /// `slice` with both negative indices.
    #[test]
    fn e2e_array_slice_both_negative() {
        let r = global_eval("[1,2,3,4,5].slice(-3, -1).join(',')").unwrap();
        assert_eq!(r, JsValue::String("3,4".into()));
    }

    /// `slice` with start beyond length returns empty.
    #[test]
    fn e2e_array_slice_start_beyond_length() {
        let r = global_eval("[1,2,3].slice(10).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// `slice` with no arguments returns shallow copy.
    #[test]
    fn e2e_array_slice_shallow_copy() {
        let r = global_eval(
            r#"
            var a = [1,2,3];
            var b = a.slice();
            b.length === 3 && b[0] === 1 && b[2] === 3
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `slice` with negative start that exceeds length clamps to 0.
    #[test]
    fn e2e_array_slice_neg_start_clamp() {
        let r = global_eval("[1,2,3].slice(-100).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    // ── concat ──────────────────────────────────────────────────────────

    /// `concat` flattens one level of arrays.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_concat_basic() {
        let r = global_eval("[1,2].concat([3,4],[5]).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3,4,5".into()));
    }

    /// `concat` does not flatten nested arrays (only one level).
    #[test]
    fn e2e_array_concat_nested_not_flattened() {
        let r = global_eval("[1].concat([[2,3]]).length").unwrap();
        assert_eq!(r, JsValue::Smi(2));
    }

    /// `concat` with non-array values appends them.
    #[test]
    fn e2e_array_concat_non_array() {
        let r = global_eval("[1].concat(2, 3).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// `concat` with empty arrays.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_concat_empty() {
        let r = global_eval("[].concat([],[]).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    /// `concat` with Symbol.isConcatSpreadable false prevents spreading.
    #[test]
    fn e2e_array_concat_not_spreadable() {
        let r = global_eval(
            r#"
            var a = [3,4];
            a[Symbol.isConcatSpreadable] = false;
            var r = [1,2].concat(a);
            r.length
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// `concat` with Symbol.isConcatSpreadable true on object.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_concat_spreadable_object() {
        let r = global_eval(
            r#"
            var obj = { length: 2, 0: 'a', 1: 'b' };
            obj[Symbol.isConcatSpreadable] = true;
            [].concat(obj).join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("a,b".into()));
    }

    // ── indexOf / lastIndexOf ───────────────────────────────────────────

    /// `indexOf` uses strict equality (NaN !== NaN).
    #[test]
    fn e2e_array_indexof_nan() {
        let r = global_eval("[1, NaN, 3].indexOf(NaN)").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// `indexOf` with positive fromIndex skips earlier elements.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_indexof_from_index() {
        let r = global_eval("[1, 2, 3, 2, 1].indexOf(2, 2)").unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// `indexOf` with negative fromIndex.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_indexof_negative_from() {
        let r = global_eval("[1, 2, 3, 2, 1].indexOf(2, -2)").unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// `indexOf` returns -1 for not found.
    #[test]
    fn e2e_array_indexof_not_found() {
        let r = global_eval("[1, 2, 3].indexOf(99)").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// `indexOf` strict equality (no type coercion).
    #[test]
    fn e2e_array_indexof_strict_equality() {
        let r = global_eval(r#"["1", "2", "3"].indexOf(2)"#).unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// `lastIndexOf` finds the last occurrence.
    #[test]
    fn e2e_array_lastindexof_basic() {
        let r = global_eval("[1, 2, 3, 2, 1].lastIndexOf(2)").unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// `lastIndexOf` uses strict equality (NaN !== NaN).
    #[test]
    fn e2e_array_lastindexof_nan() {
        let r = global_eval("[NaN, 1, NaN].lastIndexOf(NaN)").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// `lastIndexOf` with fromIndex limits search.
    #[test]
    fn e2e_array_lastindexof_from_index() {
        let r = global_eval("[1, 2, 3, 2, 1].lastIndexOf(2, 2)").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// `lastIndexOf` with negative fromIndex.
    #[test]
    fn e2e_array_lastindexof_negative_from() {
        let r = global_eval("[1, 2, 3, 2, 1].lastIndexOf(2, -3)").unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    /// `lastIndexOf` strict equality check.
    #[test]
    fn e2e_array_lastindexof_strict() {
        let r = global_eval(r#"[1, "1", 1].lastIndexOf("1")"#).unwrap();
        assert_eq!(r, JsValue::Smi(1));
    }

    // ── every / some ────────────────────────────────────────────────────

    /// `every` passes index as second argument.
    #[test]
    fn e2e_array_every_index_arg() {
        let r = global_eval("[0, 1, 2].every(function(val, idx) { return val === idx; })").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `every` returns true for single-element pass.
    #[test]
    fn e2e_array_every_single_element() {
        let r = global_eval("[42].every(function(x) { return x > 0; })").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `some` passes index as second argument.
    #[test]
    fn e2e_array_some_index_arg() {
        let r = global_eval(
            "[10, 20, 30].some(function(val, idx) { return idx === 2 && val === 30; })",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `some` returns true on first match and stops.
    #[test]
    fn e2e_array_some_early_return() {
        let r = global_eval(
            r#"
            var count = 0;
            [false, false, true, false].some(function(x) { count++; return x; });
            count
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    // ── reduce / reduceRight ────────────────────────────────────────────

    /// `reduce` sum with initial value.
    #[test]
    fn e2e_array_reduce_sum_initial() {
        let r = global_eval("[1,2,3,4].reduce(function(a, b) { return a + b; }, 0)").unwrap();
        assert_eq!(r, JsValue::Smi(10));
    }

    /// `reduce` without initial value uses first element.
    #[test]
    fn e2e_array_reduce_no_initial() {
        let r = global_eval("[1,2,3,4].reduce(function(a, b) { return a + b; })").unwrap();
        assert_eq!(r, JsValue::Smi(10));
    }

    /// `reduce` on single element without initial returns that element.
    #[test]
    fn e2e_array_reduce_single_no_initial() {
        let r = global_eval("[42].reduce(function(a, b) { return a + b; })").unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// `reduce` on empty array without initial throws TypeError.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_array_reduce_empty_no_initial_throws() {
        let r = global_eval(
            "try { [].reduce(function(a, b) { return a + b; }); false; } \
             catch(e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `reduce` passes index and array.
    #[test]
    fn e2e_array_reduce_index_arg() {
        let r = global_eval("[10,20,30].reduce(function(acc, val, idx) { return acc + idx; }, 0)")
            .unwrap();
        assert_eq!(r, JsValue::Smi(3));
    }

    /// `reduceRight` processes from right to left.
    #[test]
    fn e2e_array_reduce_right_order() {
        let r =
            global_eval(r#"[1,2,3].reduceRight(function(a, b) { return a + "" + b; })"#).unwrap();
        assert_eq!(r, JsValue::String("321".into()));
    }

    /// `reduceRight` without initial value uses last element.
    #[test]
    fn e2e_array_reduce_right_no_initial() {
        let r = global_eval("[1,2,3,4].reduceRight(function(a, b) { return a - b; })").unwrap();
        assert_eq!(r, JsValue::Smi(-2));
    }

    /// `reduceRight` on empty array without initial throws TypeError.
    #[test]
    fn e2e_array_reduce_right_empty_throws() {
        let r = global_eval(
            "try { [].reduceRight(function(a, b) { return a + b; }); false; } \
             catch(e) { e instanceof TypeError; }",
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `reduceRight` on single element without initial returns that element.
    #[test]
    fn e2e_array_reduce_right_single_no_initial() {
        let r = global_eval("[99].reduceRight(function(a, b) { return a + b; })").unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    // ── fill ────────────────────────────────────────────────────────────

    /// `fill` with both negative start and end.
    #[test]
    fn e2e_array_fill_both_negative() {
        let r = global_eval("[1,2,3,4,5].fill(0, -4, -1).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,0,0,0,5".into()));
    }

    /// `fill` when start >= end does nothing.
    #[test]
    fn e2e_array_fill_start_ge_end() {
        let r = global_eval("[1,2,3].fill(0, 2, 1).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// `fill` on empty array is no-op.
    #[test]
    fn e2e_array_fill_empty() {
        let r = global_eval("[].fill(9).length").unwrap();
        assert_eq!(r, JsValue::Smi(0));
    }

    // ── copyWithin ──────────────────────────────────────────────────────

    /// `copyWithin` overlapping forward region.
    #[test]
    fn e2e_array_copywithin_overlap_forward() {
        let r = global_eval("[1,2,3,4,5].copyWithin(1, 0, 3).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,1,2,3,5".into()));
    }

    /// `copyWithin` all negative indices.
    #[test]
    fn e2e_array_copywithin_all_negative() {
        let r = global_eval("[1,2,3,4,5].copyWithin(-3, -4, -1).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,2,3,4".into()));
    }

    /// `copyWithin` when target exceeds length does nothing.
    #[test]
    fn e2e_array_copywithin_target_beyond() {
        let r = global_eval("[1,2,3].copyWithin(10, 0).join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    // ── entries / keys / values iterators ───────────────────────────────

    /// `keys()` iterator protocol via next().
    #[test]
    fn e2e_array_keys_next_protocol() {
        let r = global_eval(
            r#"
            var it = [10, 20, 30].keys();
            var a = it.next();
            var b = it.next();
            var c = it.next();
            var d = it.next();
            a.value === 0 && b.value === 1 && c.value === 2 && d.done === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `values()` iterator protocol via next().
    #[test]
    fn e2e_array_values_next_protocol() {
        let r = global_eval(
            r#"
            var it = [10, 20, 30].values();
            var a = it.next();
            var b = it.next();
            var c = it.next();
            var d = it.next();
            a.value === 10 && b.value === 20 && c.value === 30 && d.done === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `entries()` iterator protocol via next().
    #[test]
    fn e2e_array_entries_next_protocol() {
        let r = global_eval(
            r#"
            var it = ['a', 'b'].entries();
            var a = it.next();
            var b = it.next();
            var c = it.next();
            a.value[0] === 0 && a.value[1] === 'a' &&
            b.value[0] === 1 && b.value[1] === 'b' &&
            c.done === true
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `keys()` on empty array gives done immediately.
    #[test]
    fn e2e_array_keys_empty_done() {
        let r = global_eval("[].keys().next().done").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `values()` on empty array gives done immediately.
    #[test]
    fn e2e_array_values_empty_done() {
        let r = global_eval("[].values().next().done").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── Array.isArray ───────────────────────────────────────────────────

    /// `Array.isArray` returns false for null.
    #[test]
    fn e2e_array_isarray_null() {
        let r = global_eval("Array.isArray(null)").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.isArray` returns false for undefined.
    #[test]
    fn e2e_array_isarray_undefined() {
        let r = global_eval("Array.isArray(undefined)").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.isArray` returns false for a number.
    #[test]
    fn e2e_array_isarray_number() {
        let r = global_eval("Array.isArray(42)").unwrap();
        assert_eq!(r, JsValue::Boolean(false));
    }

    /// `Array.isArray` returns true for new Array().
    #[test]
    fn e2e_array_isarray_new_array() {
        let r = global_eval("Array.isArray(new Array(3))").unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    // ── toString / toLocaleString / join ─────────────────────────────────

    /// `join` with custom separator.
    #[test]
    fn e2e_array_join_custom_sep() {
        let r = global_eval("[1, 2, 3].join(' - ')").unwrap();
        assert_eq!(r, JsValue::String("1 - 2 - 3".into()));
    }

    /// `join` with empty string separator.
    #[test]
    fn e2e_array_join_empty_sep() {
        let r = global_eval("[1, 2, 3].join('')").unwrap();
        assert_eq!(r, JsValue::String("123".into()));
    }

    /// `join` treats null/undefined elements as empty strings.
    #[test]
    fn e2e_array_join_null_undefined() {
        let r = global_eval("[1, null, undefined, 4].join(',')").unwrap();
        assert_eq!(r, JsValue::String("1,,,4".into()));
    }

    /// `join` with no argument uses comma.
    #[test]
    fn e2e_array_join_default_comma() {
        let r = global_eval("[1, 2, 3].join()").unwrap();
        assert_eq!(r, JsValue::String("1,2,3".into()));
    }

    /// `join` on empty array returns empty string.
    #[test]
    fn e2e_array_join_empty_array() {
        let r = global_eval("[].join('-')").unwrap();
        assert_eq!(r, JsValue::String("".into()));
    }

    /// `join` on single element omits separator.
    #[test]
    fn e2e_array_join_single_element() {
        let r = global_eval("[42].join('-')").unwrap();
        assert_eq!(r, JsValue::String("42".into()));
    }

    /// `toString` delegates to join.
    #[test]
    fn e2e_array_tostring_delegates_join() {
        let r = global_eval("[1, null, 3].toString()").unwrap();
        assert_eq!(r, JsValue::String("1,,3".into()));
    }

    /// `toLocaleString` on null/undefined elements.
    #[test]
    fn e2e_array_tolocalestring_null_undefined() {
        let r = global_eval("[1, null, undefined, 4].toLocaleString()").unwrap();
        assert_eq!(r, JsValue::String("1,,,4".into()));
    }

    // ── Additional splice edge cases ────────────────────────────────────

    /// `splice` on empty array with no args returns empty.
    #[test]
    fn e2e_array_splice_empty_no_args() {
        let r = global_eval(
            r#"
            var a = [];
            var r = a.splice();
            r.length === 0 && a.length === 0
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::Boolean(true));
    }

    /// `splice` negative start that exceeds length clamps to 0.
    #[test]
    fn e2e_array_splice_neg_start_clamp() {
        let r = global_eval(
            r#"
            var a = [1,2,3];
            a.splice(-100, 1);
            a.join(',')
            "#,
        )
        .unwrap();
        assert_eq!(r, JsValue::String("2,3".into()));
    }

    // ── Additional indexOf/lastIndexOf ──────────────────────────────────

    /// `indexOf` on empty array returns -1.
    #[test]
    fn e2e_array_indexof_empty() {
        let r = global_eval("[].indexOf(1)").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    /// `lastIndexOf` on empty array returns -1.
    #[test]
    fn e2e_array_lastindexof_empty() {
        let r = global_eval("[].lastIndexOf(1)").unwrap();
        assert_eq!(r, JsValue::Smi(-1));
    }

    // ── Additional reduce edge cases ────────────────────────────────────

    /// `reduce` with initial value on empty array returns initial.
    #[test]
    fn e2e_array_reduce_empty_with_initial() {
        let r = global_eval("[].reduce(function(a, b) { return a + b; }, 42)").unwrap();
        assert_eq!(r, JsValue::Smi(42));
    }

    /// `reduceRight` with initial value on empty array returns initial.
    #[test]
    fn e2e_array_reduce_right_empty_with_initial() {
        let r = global_eval("[].reduceRight(function(a, b) { return a + b; }, 99)").unwrap();
        assert_eq!(r, JsValue::Smi(99));
    }

    // ══════════════════════════════════════════════════════════════════════
    // Property descriptor validation & defineProperty deep conformance
    // ══════════════════════════════════════════════════════════════════════

    // ── 1. Accessor vs data descriptor mutual exclusivity ───────────────

    /// value + get in same descriptor → TypeError.
    #[test]
    fn e2e_desc_mutual_excl_value_and_get() {
        assert_eval_true(
            "try { \
                 Object.defineProperty({}, 'x', { value: 1, get: function() { return 2; } }); \
                 false; \
             } catch(e) { e instanceof TypeError; }",
        );
    }

    /// value + set in same descriptor → TypeError.
    #[test]
    fn e2e_desc_mutual_excl_value_and_set() {
        assert_eval_true(
            "try { \
                 Object.defineProperty({}, 'x', { value: 1, set: function(v) {} }); \
                 false; \
             } catch(e) { e instanceof TypeError; }",
        );
    }

    /// writable + get in same descriptor → TypeError.
    #[test]
    fn e2e_desc_mutual_excl_writable_and_get() {
        assert_eval_true(
            "try { \
                 Object.defineProperty({}, 'x', { writable: false, get: function() { return 1; } }); \
                 false; \
             } catch(e) { e instanceof TypeError; }",
        );
    }

    /// writable + set in same descriptor → TypeError.
    #[test]
    fn e2e_desc_mutual_excl_writable_and_set() {
        assert_eval_true(
            "try { \
                 Object.defineProperty({}, 'x', { writable: true, set: function(v) {} }); \
                 false; \
             } catch(e) { e instanceof TypeError; }",
        );
    }

    /// value + writable + get + set all together → TypeError.
    #[test]
    fn e2e_desc_mutual_excl_all_four() {
        assert_eval_true(
            "try { \
                 Object.defineProperty({}, 'x', { \
                     value: 1, writable: true, get: function() {}, set: function(v) {} \
                 }); \
                 false; \
             } catch(e) { e instanceof TypeError; }",
        );
    }

    // ── 2. defineProperty on non-extensible object ──────────────────────

    /// Adding new property to `Object.preventExtensions({})` → TypeError.
    #[test]
    fn e2e_define_prop_non_extensible_new_throws() {
        assert_eval_true(
            "var o = Object.preventExtensions({}); \
             try { \
                 Object.defineProperty(o, 'x', { value: 1 }); \
                 false; \
             } catch(e) { e instanceof TypeError; }",
        );
    }

    /// Redefining existing property on non-extensible object is allowed.
    #[test]
    fn e2e_define_prop_non_extensible_existing_ok() {
        assert_eval_true(
            "var o = { x: 1 }; \
             Object.preventExtensions(o); \
             Object.defineProperty(o, 'x', { value: 2, writable: true, enumerable: true, configurable: true }); \
             o.x === 2",
        );
    }

    /// Sealed object: existing property can still have its value changed
    /// if writable is true.
    #[test]
    fn e2e_define_prop_sealed_change_value_writable() {
        assert_eval_true("var o = { x: 1 }; Object.seal(o); o.x = 42; o.x === 42");
    }

    /// Sealed object: adding a new property → TypeError.
    #[test]
    fn e2e_define_prop_sealed_new_throws() {
        assert_eval_true(
            "var o = Object.seal({}); \
             try { Object.defineProperty(o, 'y', { value: 1 }); false; } \
             catch(e) { e instanceof TypeError; }",
        );
    }

    // ── 3. Non-configurable writable transitions ────────────────────────

    /// Non-configurable + writable:true → writable:false is allowed.
    #[test]
    fn e2e_nonconfig_writable_narrow_allowed() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 10, writable: true, configurable: false }); \
             Object.defineProperty(o, 'x', { writable: false }); \
             Object.getOwnPropertyDescriptor(o, 'x').writable === false",
        );
    }

    /// Non-configurable + writable:false → writable:true is NOT allowed.
    #[test]
    fn e2e_nonconfig_writable_widen_throws() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 10, writable: false, configurable: false }); \
             try { Object.defineProperty(o, 'x', { writable: true }); false; } \
             catch(e) { e instanceof TypeError; }",
        );
    }

    /// After narrowing writable, property value cannot be changed.
    #[test]
    fn e2e_nonconfig_narrowed_writable_blocks_assignment() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 5, writable: true, configurable: false }); \
             Object.defineProperty(o, 'x', { writable: false }); \
             o.x = 99; o.x === 5",
        );
    }

    /// Non-configurable, writable:true allows value update via defineProperty.
    #[test]
    fn e2e_nonconfig_writable_value_update_ok() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: true, configurable: false }); \
             Object.defineProperty(o, 'x', { value: 2 }); \
             o.x === 2",
        );
    }

    // ── 4. Non-configurable accessor: cannot change get/set ─────────────

    /// Non-configurable accessor: changing getter → TypeError.
    #[test]
    fn e2e_nonconfig_accessor_getter_change_throws() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: false }); \
             try { \
                 Object.defineProperty(o, 'x', { get: function() { return 2; } }); \
                 false; \
             } catch(e) { e instanceof TypeError; }",
        );
    }

    /// Non-configurable accessor: changing setter → TypeError.
    #[test]
    fn e2e_nonconfig_accessor_setter_change_throws() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 get: function() { return 1; }, \
                 set: function(v) { this._v = v; }, \
                 configurable: false \
             }); \
             try { \
                 Object.defineProperty(o, 'x', { set: function(v) { this._v2 = v; } }); \
                 false; \
             } catch(e) { e instanceof TypeError; }",
        );
    }

    /// Non-configurable accessor: redefining with identical getter is OK.
    #[test]
    fn e2e_nonconfig_accessor_same_getter_noop() {
        assert_eval_true(
            "var g = function() { return 42; }; \
             var o = {}; \
             Object.defineProperty(o, 'x', { get: g, configurable: false }); \
             Object.defineProperty(o, 'x', { get: g }); \
             o.x === 42",
        );
    }

    // ── 5. getOwnPropertyDescriptor shape ───────────────────────────────

    /// Data descriptor shape has value, writable, enumerable, configurable.
    #[test]
    fn e2e_gopd_data_shape_complete() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 7, writable: true, enumerable: true, configurable: true }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 7 && d.writable === true && d.enumerable === true && d.configurable === true && \
             d.get === undefined && d.set === undefined",
        );
    }

    /// Accessor descriptor shape has get, set, enumerable, configurable.
    #[test]
    fn e2e_gopd_accessor_shape_complete() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { \
                 get: function() { return 1; }, \
                 set: function(v) {}, \
                 enumerable: true, configurable: true \
             }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             typeof d.get === 'function' && typeof d.set === 'function' && \
             d.enumerable === true && d.configurable === true && \
             d.value === undefined && d.writable === undefined",
        );
    }

    /// Data descriptor from literal object.
    #[test]
    fn e2e_gopd_literal_data_shape() {
        assert_eval_true(
            "var d = Object.getOwnPropertyDescriptor({ a: 3 }, 'a'); \
             d.value === 3 && d.writable === true && d.enumerable === true && d.configurable === true",
        );
    }

    /// getOwnPropertyDescriptor returns undefined for non-existent key.
    #[test]
    fn e2e_gopd_missing_returns_undefined_v2() {
        assert_eval_true("Object.getOwnPropertyDescriptor({}, 'nope') === undefined");
    }

    // ── 6. defineProperties processes in order ──────────────────────────

    /// defineProperties applies descriptors in order.
    #[test]
    fn e2e_define_properties_order() {
        assert_eval_true(
            "var order = []; \
             var o = {}; \
             Object.defineProperties(o, { \
                 a: { value: 1, writable: true, enumerable: true, configurable: true }, \
                 b: { value: 2, writable: true, enumerable: true, configurable: true }, \
                 c: { value: 3, writable: true, enumerable: true, configurable: true } \
             }); \
             o.a === 1 && o.b === 2 && o.c === 3",
        );
    }

    /// defineProperties with getter and data property mixed.
    #[test]
    fn e2e_define_properties_mixed_accessor_data() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperties(o, { \
                 a: { value: 10, writable: true, enumerable: true, configurable: true }, \
                 b: { get: function() { return 20; }, enumerable: true, configurable: true } \
             }); \
             o.a === 10 && o.b === 20",
        );
    }

    /// defineProperties returns the target object.
    #[test]
    fn e2e_define_properties_returns_target_v2() {
        assert_eval_true("var o = {}; Object.defineProperties(o, { a: { value: 1 } }) === o");
    }

    // ── 7. Property attribute defaults ──────────────────────────────────

    /// defineProperty with only value: defaults are all false.
    #[test]
    fn e2e_define_prop_defaults_all_false() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 99 }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.writable === false && d.enumerable === false && d.configurable === false && d.value === 99",
        );
    }

    /// Accessor descriptor defaults: enumerable=false, configurable=false.
    #[test]
    fn e2e_define_prop_accessor_defaults_false() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; } }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.enumerable === false && d.configurable === false",
        );
    }

    /// Empty descriptor = generic descriptor, preserves existing attributes.
    #[test]
    fn e2e_define_prop_empty_desc_preserves() {
        assert_eval_true(
            "var o = { x: 42 }; \
             Object.defineProperty(o, 'x', {}); \
             o.x === 42",
        );
    }

    // ── 8. Reflect.defineProperty returns boolean ───────────────────────

    /// Reflect.defineProperty returns true on success.
    #[test]
    fn e2e_reflect_define_property_returns_true() {
        assert_eval_true(
            "var o = {}; \
             Reflect.defineProperty(o, 'x', { value: 1, writable: true, enumerable: true, configurable: true }) === true",
        );
    }

    /// Reflect.defineProperty returns false for non-extensible + new prop.
    #[test]
    fn e2e_reflect_define_property_non_extensible_false() {
        assert_eval_true(
            "var o = Object.preventExtensions({}); \
             Reflect.defineProperty(o, 'x', { value: 1 }) === false",
        );
    }

    /// Reflect.defineProperty returns false for non-configurable violation.
    #[test]
    fn e2e_reflect_define_property_nonconfig_writable_widen_false() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { value: 1, writable: false, configurable: false }); \
             Reflect.defineProperty(o, 'x', { writable: true }) === false",
        );
    }

    /// Reflect.defineProperty does NOT throw (unlike Object.defineProperty).
    #[test]
    fn e2e_reflect_define_property_no_throw_on_failure() {
        assert_eval_true(
            "var o = Object.preventExtensions({}); \
             var threw = false; \
             try { var r = Reflect.defineProperty(o, 'x', { value: 1 }); } \
             catch(e) { threw = true; } \
             threw === false && r === false",
        );
    }

    /// Reflect.defineProperty succeeds on existing prop of non-extensible obj.
    #[test]
    fn e2e_reflect_define_property_existing_on_non_ext() {
        assert_eval_true(
            "var o = { x: 1 }; Object.preventExtensions(o); \
             Reflect.defineProperty(o, 'x', { value: 2, writable: true, enumerable: true, configurable: true }) === true && o.x === 2",
        );
    }

    /// Reflect.defineProperty with accessor descriptor returns true.
    #[test]
    fn e2e_reflect_define_property_accessor_returns_true() {
        assert_eval_true(
            "var o = {}; \
             Reflect.defineProperty(o, 'x', { \
                 get: function() { return 7; }, configurable: true \
             }) === true && o.x === 7",
        );
    }

    // ── 9. defineProperty with Symbol keys ──────────────────────────────

    /// defineProperty with Symbol key sets a data value.
    #[test]
    fn e2e_define_prop_symbol_key_data() {
        assert_eval_true(
            "var s = Symbol('test'); \
             var o = {}; \
             Object.defineProperty(o, s, { value: 42, writable: true, enumerable: true, configurable: true }); \
             o[s] === 42",
        );
    }

    /// defineProperty with Symbol key sets accessor.
    #[test]
    fn e2e_define_prop_symbol_key_accessor() {
        assert_eval_true(
            "var s = Symbol('acc'); \
             var o = {}; \
             Object.defineProperty(o, s, { \
                 get: function() { return 'hello'; }, configurable: true \
             }); \
             o[s] === 'hello'",
        );
    }

    /// getOwnPropertyDescriptor with Symbol key.
    #[test]
    fn e2e_gopd_symbol_key() {
        assert_eval_true(
            "var s = Symbol('desc'); \
             var o = {}; \
             Object.defineProperty(o, s, { value: 7, writable: false, enumerable: true, configurable: false }); \
             var d = Object.getOwnPropertyDescriptor(o, s); \
             d.value === 7 && d.writable === false && d.enumerable === true && d.configurable === false",
        );
    }

    /// Reflect.defineProperty with Symbol key.
    #[test]
    fn e2e_reflect_define_prop_symbol_key() {
        assert_eval_true(
            "var s = Symbol('ref'); \
             var o = {}; \
             Reflect.defineProperty(o, s, { value: 99, writable: true, enumerable: true, configurable: true }) === true && o[s] === 99",
        );
    }

    /// Symbol key shows up in getOwnPropertySymbols.
    #[test]
    fn e2e_define_prop_symbol_in_own_symbols() {
        assert_eval_true(
            "var s = Symbol('vis'); \
             var o = {}; \
             Object.defineProperty(o, s, { value: 1, enumerable: true }); \
             Object.getOwnPropertySymbols(o).indexOf(s) >= 0",
        );
    }

    // ── 10. Accessor property interactions with prototype chain ─────────

    /// Accessor on proto, reading through child.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_accessor_getter_read() {
        assert_eval_true(
            "var parent = {}; \
             Object.defineProperty(parent, 'x', { \
                 get: function() { return this._x * 2; }, \
                 set: function(v) { this._x = v; }, \
                 enumerable: true, configurable: true \
             }); \
             var child = Object.create(parent); \
             child.x = 5; \
             child.x === 10",
        );
    }

    /// Accessor on proto, own data property shadows it.
    #[test]
    fn e2e_proto_accessor_shadowed_by_own_data() {
        assert_eval_true(
            "var parent = {}; \
             Object.defineProperty(parent, 'x', { \
                 get: function() { return 'from_proto'; }, \
                 configurable: true \
             }); \
             var child = Object.create(parent); \
             Object.defineProperty(child, 'x', { value: 'own', writable: true, configurable: true }); \
             child.x === 'own'",
        );
    }

    /// Data on proto, accessor on own object overrides.
    #[test]
    fn e2e_proto_data_own_accessor_overrides() {
        assert_eval_true(
            "var parent = { x: 'proto_val' }; \
             var child = Object.create(parent); \
             Object.defineProperty(child, 'x', { \
                 get: function() { return 'own_accessor'; }, configurable: true \
             }); \
             child.x === 'own_accessor'",
        );
    }

    /// Accessor setter on proto is invoked when writing to child.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_accessor_setter_this_binding() {
        assert_eval_true(
            "var parent = {}; \
             Object.defineProperty(parent, 'x', { \
                 get: function() { return this._x; }, \
                 set: function(v) { this._x = v + 100; }, \
                 configurable: true \
             }); \
             var child = Object.create(parent); \
             child.x = 5; \
             child._x === 105 && child.x === 105",
        );
    }

    /// Accessor on proto does NOT show in hasOwnProperty.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_accessor_not_own() {
        assert_eval_true(
            "var parent = {}; \
             Object.defineProperty(parent, 'x', { \
                 get: function() { return 1; }, configurable: true \
             }); \
             var child = Object.create(parent); \
             child.hasOwnProperty('x') === false && 'x' in child === true",
        );
    }

    /// Multiple levels of prototype chain with accessors.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_chain_multi_level_accessor() {
        assert_eval_true(
            "var a = {}; \
             Object.defineProperty(a, 'x', { \
                 get: function() { return 'level_a'; }, configurable: true \
             }); \
             var b = Object.create(a); \
             var c = Object.create(b); \
             c.x === 'level_a'",
        );
    }

    /// Own data property overrides accessor several levels up.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_proto_chain_own_shadows_deep_accessor() {
        assert_eval_true(
            "var a = {}; \
             Object.defineProperty(a, 'x', { \
                 get: function() { return 'deep'; }, configurable: true \
             }); \
             var b = Object.create(a); \
             var c = Object.create(b); \
             Object.defineProperty(c, 'x', { value: 'shallow', writable: true, configurable: true }); \
             c.x === 'shallow' && b.x === 'deep'",
        );
    }

    // ── Additional conformance edge cases ───────────────────────────────

    /// Frozen object: defineProperty with same value/attrs is OK.
    #[test]
    fn e2e_frozen_redefine_same_value_ok() {
        assert_eval_true(
            "var o = Object.freeze({ x: 1 }); \
             Object.defineProperty(o, 'x', { value: 1 }); \
             o.x === 1",
        );
    }

    /// Frozen object: changing value → TypeError.
    #[test]
    fn e2e_frozen_change_value_throws() {
        assert_eval_true(
            "var o = Object.freeze({ x: 1 }); \
             try { Object.defineProperty(o, 'x', { value: 2 }); false; } \
             catch(e) { e instanceof TypeError; }",
        );
    }

    /// defineProperties with accessor and data mixed.
    #[test]
    fn e2e_define_properties_accessor_and_data_order() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperties(o, { \
                 first: { value: 1, writable: true, enumerable: true, configurable: true }, \
                 second: { get: function() { return 2; }, enumerable: true, configurable: true } \
             }); \
             o.first === 1 && o.second === 2",
        );
    }

    /// Object.getOwnPropertyDescriptor on a sealed property.
    #[test]
    fn e2e_gopd_sealed_property() {
        assert_eval_true(
            "var o = Object.seal({ x: 5 }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 5 && d.writable === true && d.configurable === false",
        );
    }

    /// Object.getOwnPropertyDescriptor on a frozen property.
    #[test]
    fn e2e_gopd_frozen_property() {
        assert_eval_true(
            "var o = Object.freeze({ x: 5 }); \
             var d = Object.getOwnPropertyDescriptor(o, 'x'); \
             d.value === 5 && d.writable === false && d.configurable === false",
        );
    }

    /// Reflect.defineProperty mixed data+accessor → returns false.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_reflect_define_property_mixed_returns_false() {
        assert_eval_true(
            "Reflect.defineProperty({}, 'x', { value: 1, get: function() {} }) === false",
        );
    }

    /// Non-configurable accessor: cannot convert to data property.
    #[test]
    fn e2e_nonconfig_accessor_to_data_via_reflect() {
        assert_eval_true(
            "var o = {}; \
             Object.defineProperty(o, 'x', { get: function() { return 1; }, configurable: false }); \
             Reflect.defineProperty(o, 'x', { value: 2 }) === false",
        );
    }

    // ---------------------------------------------------------------
    // Exotic object behaviors conformance (w21f)
    // ---------------------------------------------------------------

    // --- 1. String exotic objects ---

    /// String exotic: indexed property access on new String("abc").
    #[test]
    fn e2e_w21f_string_exotic_indexed_access() {
        assert_e2e_true(
            r#"var s = new String("abc"); s[0] === "a" && s[1] === "b" && s[2] === "c""#,
        );
    }

    /// String exotic: .length is own property.
    #[test]
    fn e2e_w21f_string_exotic_length() {
        assert_e2e_true(r#"var s = new String("hello"); s.length === 5"#);
    }

    /// String exotic: typeof wrapper is "object".
    #[test]
    fn e2e_w21f_string_exotic_typeof() {
        assert_e2e_true(r#"typeof new String("abc") === "object""#);
    }

    /// String exotic: ownKeys returns indices then "length".
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_string_exotic_own_keys() {
        assert_e2e_true(
            r#"var s = new String("ab"); var k = Object.getOwnPropertyNames(s); k[0] === "0" && k[1] === "1" && k[k.length - 1] === "length""#,
        );
    }

    /// String exotic: indexed properties are not writable.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_string_exotic_index_not_writable() {
        assert_e2e_true(
            r#"var s = new String("abc"); var d = Object.getOwnPropertyDescriptor(s, "0"); d.writable === false && d.enumerable === true"#,
        );
    }

    // --- 2. Arguments exotic (non-strict) ---

    /// Arguments in sloppy mode: arguments reflects parameters.
    #[test]
    fn e2e_w21f_arguments_sloppy_reflects_params() {
        assert_e2e_true(
            "function f(a, b) { return arguments[0] === a && arguments[1] === b; } f(10, 20)",
        );
    }

    /// Arguments: arguments.length matches actual args count.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_length() {
        assert_e2e_true("function f() { return arguments.length; } f(1, 2, 3) === 3");
    }

    /// Arguments: callee in sloppy mode refers to function itself.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_callee_sloppy() {
        assert_e2e_true("function f() { return arguments.callee === f; } f()");
    }

    /// Arguments: Symbol.iterator makes arguments iterable.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_symbol_iterator() {
        assert_e2e_true(
            "function f() { var sum = 0; for (var x of arguments) sum += x; return sum; } f(1, 2, 3) === 6",
        );
    }

    /// Arguments in sloppy mode: mutation of param reflects in arguments.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_sloppy_param_mutation() {
        assert_e2e_true("function f(a) { a = 99; return arguments[0] === 99; } f(1)");
    }

    /// Arguments in sloppy mode: mutation of arguments[0] reflects in param.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_sloppy_arg_mutation() {
        assert_e2e_true("function f(a) { arguments[0] = 42; return a === 42; } f(1)");
    }

    // --- 3. Arguments in strict mode ---

    /// Strict mode: arguments.callee throws TypeError.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_strict_callee_throws() {
        assert_e2e_true(
            r#""use strict"; function f() { try { arguments.callee; return false; } catch(e) { return e instanceof TypeError; } } f()"#,
        );
    }

    /// Strict mode: arguments is not mapped to parameters.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_strict_no_mapping() {
        assert_e2e_true(
            r#""use strict"; function f(a) { a = 99; return arguments[0] !== 99; } f(1)"#,
        );
    }

    /// Strict mode: arguments reverse mapping also absent.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_strict_no_reverse_mapping() {
        assert_e2e_true(
            r#""use strict"; function f(a) { arguments[0] = 42; return a !== 42; } f(1)"#,
        );
    }

    // --- 4. Bound functions ---

    /// bind: bound function preserves thisArg.
    #[test]
    fn e2e_w21f_bind_this_arg() {
        assert_e2e_true(
            "var obj = { x: 42 }; function f() { return this.x; } var bf = f.bind(obj); bf() === 42",
        );
    }

    /// bind: bound function pre-fills arguments.
    #[test]
    fn e2e_w21f_bind_partial_args() {
        assert_e2e_true(
            "function add(a, b) { return a + b; } var add5 = add.bind(null, 5); add5(3) === 8",
        );
    }

    /// bind: .name is "bound X".
    #[test]
    fn e2e_w21f_bind_name() {
        assert_e2e_true(r#"function foo() {} var bf = foo.bind(null); bf.name === "bound foo""#);
    }

    /// bind: .length is adjusted by bound args.
    #[test]
    fn e2e_w21f_bind_length() {
        assert_e2e_true("function f(a, b, c) {} var bf = f.bind(null, 1); bf.length === 2");
    }

    /// bind: instanceof works with bound function.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_bind_instanceof() {
        assert_e2e_true(
            "function Foo() {} var BF = Foo.bind(null); var obj = new BF(); obj instanceof Foo",
        );
    }

    // --- 5. Bound function as constructor ---

    /// new on bound function ignores thisArg.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_bound_new_ignores_this_arg() {
        assert_e2e_true(
            "function Ctor(x) { this.x = x; } \
             var BC = Ctor.bind({ x: 999 }, 42); \
             var obj = new BC(); \
             obj.x === 42",
        );
    }

    /// new on bound function passes bound args.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_bound_new_bound_args() {
        assert_e2e_true(
            "function Ctor(a, b) { this.sum = a + b; } \
             var BC = Ctor.bind(null, 10); \
             var obj = new BC(20); \
             obj.sum === 30",
        );
    }

    /// new on double-bound function.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_bound_new_double_bind() {
        assert_e2e_true(
            "function Ctor(a, b, c) { this.r = a + b + c; } \
             var B1 = Ctor.bind(null, 1); \
             var B2 = B1.bind(null, 2); \
             var obj = new B2(3); \
             obj.r === 6",
        );
    }

    // --- 6. Integer-indexed exotic (TypedArray) ---

    /// TypedArray: element access by index.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_typed_array_index_access() {
        assert_e2e_true("var ta = new Uint8Array([10, 20, 30]); ta[0] === 10 && ta[2] === 30");
    }

    /// TypedArray: out-of-bounds index returns undefined, not prototype chain.
    #[test]
    fn e2e_w21f_typed_array_oob_undefined() {
        assert_e2e_true("var ta = new Uint8Array(3); ta[100] === undefined");
    }

    /// TypedArray: setting out-of-bounds index is silently ignored.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_typed_array_oob_set_ignored() {
        assert_e2e_true(
            "var ta = new Uint8Array(2); ta[5] = 99; ta.length === 2 && ta[5] === undefined",
        );
    }

    /// TypedArray: numeric index doesn't go to prototype.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_typed_array_no_proto_index() {
        assert_e2e_true(
            "var proto = Uint8Array.prototype; Object.defineProperty(proto, '0', { value: 777, configurable: true }); \
             var ta = new Uint8Array(1); var result = ta[0] === 0; \
             delete proto['0']; result",
        );
    }

    // --- 7. Array exotic ---

    /// Array: setting .length truncates elements.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_array_length_truncates() {
        assert_e2e_true(
            "var a = [1, 2, 3, 4, 5]; a.length = 2; a.length === 2 && a[2] === undefined",
        );
    }

    /// Array: assigning to integer index auto-extends length.
    #[test]
    fn e2e_w21f_array_index_extends_length() {
        assert_e2e_true("var a = []; a[9] = 'x'; a.length === 10");
    }

    /// Array: setting .length to 0 clears array.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_array_length_zero_clears() {
        assert_e2e_true("var a = [1, 2, 3]; a.length = 0; a.length === 0 && a[0] === undefined");
    }

    /// Array: Object.keys on sparse array only shows defined indices.
    #[test]
    fn e2e_w21f_array_sparse_keys() {
        assert_e2e_true(
            r#"var a = []; a[2] = "x"; var k = Object.keys(a); k.length === 1 && k[0] === "2""#,
        );
    }

    // --- 8. Proxy as prototype ---

    /// Proxy as prototype: get trap intercepts property access.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_proxy_as_prototype_get() {
        assert_e2e_true(
            "var handler = { get: function(t, p) { return p === 'x' ? 42 : undefined; } }; \
             var proto = new Proxy({}, handler); \
             var obj = Object.create(proto); \
             obj.x === 42",
        );
    }

    /// Proxy as prototype: has trap intercepts 'in' operator.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_proxy_as_prototype_has() {
        assert_e2e_true(
            "var handler = { has: function(t, p) { return p === 'secret'; } }; \
             var proto = new Proxy({}, handler); \
             var obj = Object.create(proto); \
             'secret' in obj",
        );
    }

    /// Proxy: set trap is invoked.
    #[test]
    fn e2e_w21f_proxy_set_trap() {
        assert_e2e_true(
            "var log = []; \
             var p = new Proxy({}, { set: function(t, k, v) { log.push(k); t[k] = v; return true; } }); \
             p.a = 1; \
             log[0] === 'a' && p.a === 1",
        );
    }

    /// Proxy: apply trap for function proxy.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_proxy_apply_trap() {
        assert_e2e_true(
            "var p = new Proxy(function(x) { return x * 2; }, { \
                 apply: function(t, thisArg, args) { return t.apply(thisArg, args) + 100; } \
             }); \
             p(5) === 110",
        );
    }

    // --- 9. Revoked proxy throws TypeError ---

    /// Revoked proxy: get throws TypeError.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_revoked_proxy_get_throws() {
        assert_e2e_true(
            "var r = Proxy.revocable({}, {}); r.revoke(); \
             try { r.proxy.x; false; } catch(e) { e instanceof TypeError; }",
        );
    }

    /// Revoked proxy: set throws TypeError.
    #[test]
    fn e2e_w21f_revoked_proxy_set_throws() {
        assert_e2e_true(
            "var r = Proxy.revocable({}, {}); r.revoke(); \
             try { r.proxy.x = 1; false; } catch(e) { e instanceof TypeError; }",
        );
    }

    /// Revoked proxy: has throws TypeError.
    #[test]
    fn e2e_w21f_revoked_proxy_has_throws() {
        assert_e2e_true(
            "var r = Proxy.revocable({}, {}); r.revoke(); \
             try { 'x' in r.proxy; false; } catch(e) { e instanceof TypeError; }",
        );
    }

    /// Revoked proxy: deleteProperty throws TypeError.
    #[test]
    fn e2e_w21f_revoked_proxy_delete_throws() {
        assert_e2e_true(
            "var r = Proxy.revocable({}, {}); r.revoke(); \
             try { delete r.proxy.x; false; } catch(e) { e instanceof TypeError; }",
        );
    }

    /// Revoked proxy: ownKeys throws TypeError.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_revoked_proxy_ownkeys_throws() {
        assert_e2e_true(
            "var r = Proxy.revocable({}, {}); r.revoke(); \
             try { Object.keys(r.proxy); false; } catch(e) { e instanceof TypeError; }",
        );
    }

    // --- 10. arguments.length is own, deletable ---

    /// arguments.length is an own property.
    #[test]
    fn e2e_w21f_arguments_length_own() {
        assert_e2e_true("function f() { return arguments.hasOwnProperty('length'); } f(1, 2)");
    }

    /// arguments.length is deletable.
    #[test]
    fn e2e_w21f_arguments_length_deletable() {
        assert_e2e_true(
            "function f() { delete arguments.length; return arguments.length === undefined; } f(1, 2)",
        );
    }

    /// arguments.length reflects actual argument count, not formal params.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_length_actual_count() {
        assert_e2e_true("function f(a) { return arguments.length; } f(1, 2, 3) === 3");
    }

    /// arguments: extra args beyond params accessible.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_arguments_extra_args() {
        assert_e2e_true(
            "function f(a) { return arguments[1] + arguments[2]; } f(1, 10, 20) === 30",
        );
    }

    // --- Additional exotic edge cases ---

    /// String exotic: valueOf returns primitive.
    #[test]
    fn e2e_w21f_string_exotic_valueof() {
        assert_e2e_true(r#"var s = new String("hello"); s.valueOf() === "hello""#);
    }

    /// Bound function: bind of bind preserves .name chain.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w21f_bind_of_bind_name() {
        assert_e2e_true(
            r#"function bar() {} var b1 = bar.bind(null); var b2 = b1.bind(null); b2.name === "bound bound bar""#,
        );
    }

    /// Array: deleting element doesn't change length.
    #[test]
    fn e2e_w21f_array_delete_no_length_change() {
        assert_e2e_true("var a = [1, 2, 3]; delete a[1]; a.length === 3 && a[1] === undefined");
    }

    /// Proxy construct trap.
    #[test]
    fn e2e_w21f_proxy_construct_trap() {
        assert_e2e_true(
            "function Foo(x) { this.x = x; } \
             var P = new Proxy(Foo, { \
                 construct: function(target, args) { return { x: args[0] * 10 }; } \
             }); \
             new P(3).x === 30",
        );
    }

    /// bind: length is 0 when all params are bound.
    #[test]
    fn e2e_w21f_bind_length_zero_all_bound() {
        assert_e2e_true("function f(a, b) {} var bf = f.bind(null, 1, 2); bf.length === 0");
    }

    /// bind: length doesn't go negative.
    #[test]
    fn e2e_w21f_bind_length_no_negative() {
        assert_e2e_true("function f(a) {} var bf = f.bind(null, 1, 2, 3); bf.length === 0");
    }

    /// Array exotic: length is own property descriptor.
    #[test]
    fn e2e_w21f_array_length_own_descriptor() {
        assert_e2e_true(
            "var a = [1, 2]; var d = Object.getOwnPropertyDescriptor(a, 'length'); \
             d.value === 2 && d.writable === true && d.enumerable === false && d.configurable === false",
        );
    }

    /// TypedArray: .length reflects buffer size.
    #[test]
    fn e2e_w21f_typed_array_length() {
        assert_e2e_true("var ta = new Int32Array(5); ta.length === 5");
    }

    // ---------------------------------------------------------------
    // Tail-position forms and control-flow completion-value tests
    // ---------------------------------------------------------------

    /// Ternary: true branch is tail position.
    #[test]
    fn e2e_w22h_ternary_true_branch_tail() {
        let result = global_eval("function f() { return true ? 42 : 99; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Ternary: false branch is tail position.
    #[test]
    fn e2e_w22h_ternary_false_branch_tail() {
        let result = global_eval("function f() { return false ? 42 : 99; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// Ternary with function calls in both branches.
    #[test]
    fn e2e_w22h_ternary_call_both_branches() {
        let result = global_eval(
            "function a() { return 10; } function b() { return 20; } \
             function f(c) { return c ? a() : b(); } f(true) + f(false)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(30));
    }

    /// Logical AND: right side is tail position when left is truthy.
    #[test]
    fn e2e_w22h_logical_and_tail_truthy() {
        let result = global_eval("function f() { return 1 && 42; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Logical AND: short-circuits on falsy left.
    #[test]
    fn e2e_w22h_logical_and_tail_falsy() {
        let result = global_eval("function f() { return 0 && 42; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// Logical OR: right side is tail position when left is falsy.
    #[test]
    fn e2e_w22h_logical_or_tail_falsy() {
        let result = global_eval("function f() { return 0 || 42; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Logical OR: short-circuits on truthy left.
    #[test]
    fn e2e_w22h_logical_or_tail_truthy() {
        let result = global_eval("function f() { return 1 || 42; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// Nullish coalescing: right side when left is null.
    #[test]
    fn e2e_w22h_nullish_coalesce_null() {
        let result = global_eval("function f() { return null ?? 42; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Nullish coalescing: right side when left is undefined.
    #[test]
    fn e2e_w22h_nullish_coalesce_undefined() {
        let result = global_eval("function f() { return undefined ?? 42; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Nullish coalescing: left side when non-nullish (0 is non-nullish).
    #[test]
    fn e2e_w22h_nullish_coalesce_zero() {
        let result = global_eval("function f() { return 0 ?? 42; } f()").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// Comma: last expression is tail position.
    #[test]
    fn e2e_w22h_comma_tail_position() {
        let result = global_eval("function f() { return (1, 2, 42); } f()").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Comma with side effects: all expressions evaluated, last returned.
    #[test]
    fn e2e_w22h_comma_side_effects() {
        let result = global_eval(
            "var x = 0; function f() { return (x = 10, x = x + 5, x); } \
             var r = f(); r === 15 && x === 15",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Direct eval in tail position.
    #[test]
    fn e2e_w22h_eval_tail_position() {
        let result = global_eval(r#"function f() { return eval("42"); } f()"#).unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Direct eval calling a function in tail position.
    #[test]
    fn e2e_w22h_eval_call_tail_position() {
        let result =
            global_eval(r#"function g() { return 99; } function f() { return eval("g()"); } f()"#)
                .unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// try/catch: completion value is from try block when no error.
    #[test]
    fn e2e_w22h_try_catch_completion_no_error() {
        let result = global_eval("try { 1 } catch(e) { 2 }").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// try/catch: completion value is from catch block when error thrown.
    #[test]
    fn e2e_w22h_try_catch_completion_with_error() {
        let result = global_eval("try { throw 'err'; } catch(e) { 2 }").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// try/finally: finally does NOT override the completion value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w22h_try_finally_completion_value() {
        let result = global_eval("try { 1 } finally { 3 }").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// try/catch/finally: finally does NOT override completion value.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w22h_try_catch_finally_completion() {
        let result = global_eval("try { 1 } catch(e) { 2 } finally { 3 }").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// try/catch/finally with thrown error: catch value is kept, finally doesn't override.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w22h_try_catch_finally_thrown() {
        let result = global_eval("try { throw 'err'; } catch(e) { 2 } finally { 3 }").unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// finally side effects run but don't change the completion value.
    #[test]
    fn e2e_w22h_finally_side_effects() {
        let result = global_eval(
            "var x = 0; var r = (function() { try { return 1; } finally { x = 99; } })(); \
             r === 1 && x === 99",
        )
        .unwrap();
        assert_eq!(result, JsValue::Boolean(true));
    }

    /// Nested try/finally: inner finally runs before outer.
    #[test]
    fn e2e_w22h_nested_try_finally_order() {
        let result = global_eval(
            r#"var log = "";
            try {
                try { log += "a"; } finally { log += "b"; }
                log += "c";
            } finally { log += "d"; }
            log"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("abcd".into()));
    }

    /// Nested try/finally with throw: inner finally runs before outer catch.
    #[test]
    fn e2e_w22h_nested_try_finally_throw() {
        let result = global_eval(
            r#"var log = "";
            try {
                try { throw "err"; } finally { log += "inner"; }
            } catch(e) { log += "catch"; } finally { log += "outer"; }
            log"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("innercatchouter".into()));
    }

    /// Labeled block with break propagates completion value.
    #[test]
    fn e2e_w22h_labeled_break_completion() {
        let result = global_eval("var x = 0; lbl: { x = 1; break lbl; x = 2; } x").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// Labeled nested blocks: break exits only the named block.
    #[test]
    fn e2e_w22h_labeled_nested_break() {
        let result = global_eval(
            r#"var log = "";
            outer: { log += "a"; inner: { log += "b"; break outer; log += "c"; } log += "d"; }
            log"#,
        )
        .unwrap();
        assert_eq!(result, JsValue::String("ab".into()));
    }

    /// Switch: basic completion value from matching case.
    #[test]
    fn e2e_w22h_switch_completion_basic() {
        let result =
            global_eval("var r = 0; switch(2) { case 1: r = 1; break; case 2: r = 2; break; } r")
                .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// Switch: fall-through accumulates side effects.
    #[test]
    fn e2e_w22h_switch_fall_through() {
        let result = global_eval(
            "var r = 0; switch(1) { case 1: r = r + 1; case 2: r = r + 10; break; case 3: r = r + 100; } r",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(11));
    }

    /// Switch: default clause as fallback.
    #[test]
    fn e2e_w22h_switch_default_fallback() {
        let result = global_eval(
            "var r = 0; switch(99) { case 1: r = 1; break; default: r = 42; break; } r",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// Switch: default falls through to next case.
    #[test]
    fn e2e_w22h_switch_default_fall_through() {
        let result = global_eval(
            "var r = 0; switch(99) { default: r = r + 1; case 1: r = r + 10; break; case 2: r = 100; } r",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(11));
    }

    /// Switch: no matching case and no default yields no side effects.
    #[test]
    fn e2e_w22h_switch_no_match() {
        let result =
            global_eval("var r = 0; switch(99) { case 1: r = 1; case 2: r = 2; } r").unwrap();
        assert_eq!(result, JsValue::Smi(0));
    }

    /// do-while: completion value is the body result.
    #[test]
    fn e2e_w22h_do_while_completion() {
        let result = global_eval("var r = 0; do { r = 42; } while (false); r").unwrap();
        assert_eq!(result, JsValue::Smi(42));
    }

    /// do-while: multiple iterations accumulate.
    #[test]
    fn e2e_w22h_do_while_multiple_iterations() {
        let result =
            global_eval("var r = 0; var i = 0; do { r = r + 1; i = i + 1; } while (i < 5); r")
                .unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// if/else: true branch completion value.
    #[test]
    fn e2e_w22h_if_else_true_branch() {
        let result =
            global_eval("function f() { if (true) { return 1; } else { return 2; } } f()").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// if/else: false branch completion value.
    #[test]
    fn e2e_w22h_if_else_false_branch() {
        let result =
            global_eval("function f() { if (false) { return 1; } else { return 2; } } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// if without else: completion is body when true.
    #[test]
    fn e2e_w22h_if_no_else_true() {
        let result = global_eval("if (true) { 1 }").unwrap();
        assert_eq!(result, JsValue::Smi(1));
    }

    /// if without else: completion is undefined when false.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w22h_if_no_else_false() {
        let result = global_eval("if (false) { 1 }").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// Empty statement: completion is undefined.
    #[test]
    #[ignore] // TODO: conformance — not yet passing
    fn e2e_w22h_empty_statement_completion() {
        let result = global_eval("if (true) ;").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// Empty block: completion is undefined.
    #[test]
    fn e2e_w22h_empty_block_completion() {
        let result = global_eval("{}").unwrap();
        assert_eq!(result, JsValue::Undefined);
    }

    /// for loop: completion value is last expression evaluated in body.
    #[test]
    fn e2e_w22h_for_loop_completion() {
        let result =
            global_eval("var r = 0; for (var i = 0; i < 5; i++) { r = r + 1; } r").unwrap();
        assert_eq!(result, JsValue::Smi(5));
    }

    /// for loop with break: completion value reflects early exit.
    #[test]
    fn e2e_w22h_for_loop_break() {
        let result =
            global_eval("var r = 0; for (var i = 0; i < 10; i++) { if (i === 3) break; r = i; } r")
                .unwrap();
        assert_eq!(result, JsValue::Smi(2));
    }

    /// for loop: zero iterations means no body evaluation.
    #[test]
    fn e2e_w22h_for_loop_zero_iterations() {
        let result = global_eval("var r = 99; for (var i = 0; i < 0; i++) { r = 0; } r").unwrap();
        assert_eq!(result, JsValue::Smi(99));
    }

    /// Chained ternaries in tail position.
    #[test]
    fn e2e_w22h_chained_ternary_tail() {
        let result = global_eval(
            "function f(x) { return x === 1 ? 'a' : x === 2 ? 'b' : 'c'; } \
             f(1) + f(2) + f(3)",
        )
        .unwrap();
        assert_eq!(result, JsValue::String("abc".into()));
    }

    /// Logical AND with function call on right side in tail position.
    #[test]
    fn e2e_w22h_logical_and_call_tail() {
        let result =
            global_eval("function g() { return 77; } function f() { return true && g(); } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(77));
    }

    /// Logical OR with function call on right side in tail position.
    #[test]
    fn e2e_w22h_logical_or_call_tail() {
        let result =
            global_eval("function g() { return 88; } function f() { return false || g(); } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(88));
    }

    /// Nullish coalescing with function call on right side in tail position.
    #[test]
    fn e2e_w22h_nullish_coalesce_call_tail() {
        let result =
            global_eval("function g() { return 66; } function f() { return null ?? g(); } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(66));
    }

    /// Comma with function call as last expression in tail position.
    #[test]
    fn e2e_w22h_comma_call_tail() {
        let result =
            global_eval("function g() { return 55; } function f() { return (1, 2, g()); } f()")
                .unwrap();
        assert_eq!(result, JsValue::Smi(55));
    }

    /// while loop: completion value after iterations.
    #[test]
    fn e2e_w22h_while_loop_completion() {
        let result =
            global_eval("var r = 0; var i = 0; while (i < 4) { r = r + 1; i = i + 1; } r").unwrap();
        assert_eq!(result, JsValue::Smi(4));
    }

    /// Nested if/else completion values.
    #[test]
    fn e2e_w22h_nested_if_else_completion() {
        let result = global_eval(
            "function f(a, b) { if (a) { if (b) { return 1; } else { return 2; } } else { return 3; } } \
             f(true, true) * 100 + f(true, false) * 10 + f(false, false)",
        )
        .unwrap();
        assert_eq!(result, JsValue::Smi(123));
    }
}