feat: Set/Map 构造器接收可迭代实参 + size 访问器 + ES2024 set-methods

crates/oxide_builtins/src/iterator.rs

@@ -353,7 +353,8 @@ fn is_typed_array_value(value: JsValue) -> bool {
     !ptr.is_null() && unsafe { &*ptr }.is_typed_array_obj()
 }
 
-fn is_callable(value: JsValue) -> bool {
+/// 判断值是否为可调用对象（native 或字节码函数）。
+pub(crate) fn is_callable(value: JsValue) -> bool {
     if !value.is_object() {
         return false;
     }
@@ -361,6 +362,86 @@ fn is_callable(value: JsValue) -> bool {
     !ptr.is_null() && unsafe { &*ptr }.is_function()
 }
 
+/// 把 `call_function_sync` 返回的 `Err` 文本恢复为原始异常值；
+/// 无保留的 uncaught 值时回退为普通 TypeError。
+pub(crate) fn engine_error<H: VmHost>(vm: &mut H, err: &str) -> JsValue {
+    vm.take_uncaught_value()
+        .unwrap_or_else(|| crate::error::create_type_error(vm, err))
+}
+
+/// IteratorClose：异常退出时调用迭代器包装器的 `return()`（转发给内层迭代器），
+/// 丢弃 return 自身抛出的错误，保留在途异常。
+pub(crate) fn close_iterator<H: VmHost>(vm: &mut H, iterator: JsValue) {
+    if !iterator.is_object() {
+        return;
+    }
+    let iter_obj = unsafe { &*iterator.as_js_object_ptr() };
+    let return_si = vm.kernel_core().perm_interner().intern("return").0;
+    if let Ok(ret) = vm.ordinary_get(iter_obj, return_si, iterator) {
+        if is_callable(ret) {
+            let _ = vm.call_function_sync(ret, iterator, &[]);
+        }
+    }
+}
+
+/// 遍历可迭代值，把每个元素交给 `on_elem`。
+///
+/// # 步骤
+/// 1. 经迭代协议取迭代器包装器，逐次 `next` 读取 `{done, value}`。
+/// 2. 每个元素调用 `on_elem`；元素读取或回调抛错时先 IteratorClose 再透传原异常。
+///
+/// # 返回值
+/// - `Ok(())`：迭代完成；
+/// - `Err`：迭代或回调抛出的原异常值（任意类型）。
+pub(crate) fn iterate_elements<H: VmHost, F>(vm: &mut H, iterable: JsValue, mut on_elem: F) -> Result<(), JsValue>
+where
+    F: FnMut(&mut H, JsValue) -> Result<(), JsValue>,
+{
+    let iterator = make_iterator_for_value(vm, iterable)?;
+    iterate_iterator(vm, iterator, &mut on_elem)
+}
+
+/// 遍历一个已取得的迭代器对象（带 `next`），把每个元素交给 `on_elem`。
+/// 与 [`iterate_elements`] 的差异：入参是迭代器本身而非可迭代值，
+/// 用于 Set 方法从 SetRecord 的 `keys` 方法返回值继续取元素。
+///
+/// # 副作用
+/// 迭代或回调抛错时调用迭代器的 `return()`（IteratorClose）后透传原异常。
+pub(crate) fn iterate_iterator<H: VmHost, F>(vm: &mut H, iterator: JsValue, mut on_elem: F) -> Result<(), JsValue>
+where
+    F: FnMut(&mut H, JsValue) -> Result<(), JsValue>,
+{
+    let next_si = vm.kernel_core().perm_interner().intern("next").0;
+    let done_si = vm.kernel_core().perm_interner().intern("done").0;
+    let value_si = vm.kernel_core().perm_interner().intern("value").0;
+    let run: Result<(), JsValue> = (|| {
+        loop {
+            let iter_obj = unsafe { &*iterator.as_js_object_ptr() };
+            let next_fn = vm.ordinary_get(iter_obj, next_si, iterator).map_err(|e| engine_error(vm, &e))?;
+            let result = vm
+                .call_function_sync(next_fn, iterator, &[])
+                .map_err(|e| engine_error(vm, &e))?;
+            if !result.is_object() {
+                return Err(crate::error::create_type_error(vm, "iterator result is not an object"));
+            }
+            let result_obj = unsafe { &*result.as_js_object_ptr() };
+            let done = vm.ordinary_get(result_obj, done_si, result).map_err(|e| engine_error(vm, &e))?;
+            if oxide_runtime_api::to_boolean(done) {
+                break;
+            }
+            let elem = vm
+                .ordinary_get(result_obj, value_si, result)
+                .map_err(|e| engine_error(vm, &e))?;
+            on_elem(vm, elem)?;
+        }
+        Ok(())
+    })();
+    if run.is_err() {
+        close_iterator(vm, iterator);
+    }
+    run
+}
+
 fn is_map_value(value: JsValue) -> bool {
     if !value.is_object() {
         return false;
@@ -442,7 +523,12 @@ fn map_set_step<H: VmHost>(
             };
             make_iter_result(vm, value, false)
         }
-        None => make_iter_result(vm, JsValue::undefined(), true),
+        None => {
+            // 迭代器已耗尽：把下标推进到永不匹配的哨兵值，使后续 next() 恒返回 done，
+            // 即使集合之后又新增元素也不会"复活"。
+            vm.set_or_create_prop_value(wrapper, index_si, JsValue::int(i32::MAX));
+            make_iter_result(vm, JsValue::undefined(), true)
+        }
     }
 }
 

crates/oxide_builtins/src/map.rs

@@ -150,10 +150,92 @@ pub fn drop_map_native(obj: &mut JsObject) -> u64 {
     }
 }
 
-/// `Map` 构造函数：创建带空 IndexMap native 数据的 Map 对象。
-pub fn map_constructor<H: VmHost>(vm: &mut H, _args: &[u8]) -> NativeResult {
+/// `Map` 构造函数：创建带空 IndexMap native 数据的 Map 对象，若提供可迭代实参
+/// 则逐元素（须为对象）取 `[0]`/`[1]` 作为键值调用 set。
+///
+/// # 步骤
+/// 1. 校验 NewTarget：`this` 的原型须是 Map.prototype（普通调用 `Map()` 抛 TypeError）。
+/// 2. 创建空 Map。
+/// 3. 取 adder = Get(map, "set")，要求可调用（否则 TypeError）。
+/// 4. 对可迭代实参逐元素：元素须为对象（否则 TypeError），读 `0`/`1` 属性后调用 adder。
+///
+/// # 边界与前提
+/// - 无实参或实参为 null/undefined 时返回空 Map，不触碰 adder。
+/// - 任一环节抛错先 IteratorClose 再透传。
+pub fn map_constructor<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let is_new_call = this_val.is_object() && {
+        let map_proto = vm.session().builtin_world().map_proto.as_ptr() as *mut JsObject;
+        // 沿原型链查找 Map.prototype：`new Map()` 直接命中，子类 `super()` 经
+        // 子类 prototype 链命中；普通调用（global/undefined）不命中。
+        let this_ptr = this_val.as_js_object_ptr();
+        if this_ptr.is_null() {
+            false
+        } else {
+            let mut proto = unsafe { &*this_ptr }.proto();
+            let mut found = false;
+            for _ in 0..16 {
+                if !proto.is_object() {
+                    break;
+                }
+                let proto_ptr = proto.as_js_object_ptr();
+                if proto_ptr.is_null() {
+                    break;
+                }
+                if std::ptr::eq(proto_ptr, map_proto) {
+                    found = true;
+                    break;
+                }
+                proto = unsafe { &*proto_ptr }.proto();
+            }
+            found
+        }
+    };
+    if !is_new_call {
+        return NativeResult::Err(crate::error::create_type_error(vm, "Map must be called with new"));
+    }
+
     let map_obj = alloc_map(vm);
-    NativeResult::Ok(JsValue::from_js_object(map_obj))
+    let map_val = JsValue::from_js_object(map_obj);
+
+    if args.len() > 1 {
+        let iterable = vm.reg(args[1]);
+        if !iterable.is_undefined() && !iterable.is_null() {
+            let map_ref = unsafe { &*map_obj };
+            let set_si = vm.kernel_core().perm_interner().intern("set").0;
+            let adder = match vm.ordinary_get(map_ref, set_si, map_val) {
+                Ok(v) => v,
+                Err(err) => return NativeResult::Err(crate::iterator::engine_error(vm, &err)),
+            };
+            if !crate::iterator::is_callable(adder) {
+                return NativeResult::Err(crate::error::create_type_error(vm, "Map.set is not callable"));
+            }
+            let key_si = vm.kernel_core().perm_interner().intern("0").0;
+            let value_si = vm.kernel_core().perm_interner().intern("1").0;
+            if let Err(err) = crate::iterator::iterate_elements(vm, iterable, |vm, item| {
+                if !item.is_object() {
+                    return Err(crate::error::create_type_error(vm, "iterator value is not an entry object"));
+                }
+                let item_obj = unsafe { &*item.as_js_object_ptr() };
+                let k = match vm.ordinary_get(item_obj, key_si, item) {
+                    Ok(v) => v,
+                    Err(err) => return Err(crate::iterator::engine_error(vm, &err)),
+                };
+                let v = match vm.ordinary_get(item_obj, value_si, item) {
+                    Ok(v) => v,
+                    Err(err) => return Err(crate::iterator::engine_error(vm, &err)),
+                };
+                match vm.call_function_sync(adder, map_val, &[k, v]) {
+                    Ok(_) => Ok(()),
+                    Err(err) => Err(crate::iterator::engine_error(vm, &err)),
+                }
+            }) {
+                return NativeResult::Err(err);
+            }
+        }
+    }
+
+    NativeResult::Ok(map_val)
 }
 
 /// `Map.prototype.set(key, value)`：插入/更新键值对，返回 this。
@@ -205,6 +287,29 @@ pub fn map_clear<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     NativeResult::Ok(JsValue::undefined())
 }
 
+/// `Map.prototype.forEach(callbackfn, thisArg)`：按插入序对每个键值对调用回调，
+/// 回调参数为 `(value, key, map)`。迭代期间新增的键值对也会被访问。
+pub fn map_for_each<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_map_inner(vm, this_val));
+    let callback = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    if !crate::iterator::is_callable(callback) {
+        return NativeResult::Err(crate::error::create_type_error(vm, "callback is not a function"));
+    }
+    let this_arg = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
+    // 按下标迭代：每次回调后重新读当前下标（支持迭代期间插入）。
+    let mut index = 0usize;
+    loop {
+        let entry = unsafe { (*inner).get_index(index).map(|(key, value)| (key.0, *value)) };
+        let Some((key, value)) = entry else { break };
+        index += 1;
+        if let Err(err) = vm.call_function_sync(callback, this_arg, &[value, key, this_val]) {
+            return NativeResult::Err(crate::iterator::engine_error(vm, &err));
+        }
+    }
+    NativeResult::Ok(JsValue::undefined())
+}
+
 /// `Map.prototype.size` getter：返回键值对数量。
 pub fn map_size<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });

crates/oxide_builtins/src/set.rs

@@ -20,20 +20,32 @@ macro_rules! native_try {
 #[derive(Clone, Copy)]
 pub struct SetKey(pub JsValue);
 
+/// 把 int/double 数值统一归一化为可比较的位模式：NaN 用专属哨兵、±0 归 +0，
+/// 使 `0`(int) 与 `0.0`/`-0.0`(double) 视为同一键，且 NaN 与任何数值都不同。
+fn numeric_key_bits(val: JsValue) -> Option<u64> {
+    let d = if val.is_int() {
+        val.as_int() as f64
+    } else if val.is_double() {
+        val.as_double()
+    } else {
+        return None;
+    };
+    if d.is_nan() {
+        // 哨兵必须避开 0 与所有合法 f64 位模式碰撞（f64 位模式永不为 1）。
+        Some(1)
+    } else if d == 0.0 {
+        Some(0.0f64.to_bits())
+    } else {
+        Some(d.to_bits())
+    }
+}
+
 impl PartialEq for SetKey {
     fn eq(&self, other: &Self) -> bool {
-        if self.0.is_double() && other.0.is_double() {
-            let a = self.0.as_double();
-            let b = other.0.as_double();
-            if a.is_nan() && b.is_nan() {
-                return true;
-            }
-            if a == 0.0 && b == 0.0 {
-                return true;
-            }
+        if let (Some(a), Some(b)) = (numeric_key_bits(self.0), numeric_key_bits(other.0)) {
             return a == b;
         }
-        // SAFETY: JsValue 是 8 字节 NaN-box Copy 值；此处以原始位定义非 double 值的同一性。
+        // SAFETY: JsValue 是 8 字节 NaN-box Copy 值；此处以原始位定义非数值值的同一性。
         unsafe { std::mem::transmute::<JsValue, u64>(self.0) == std::mem::transmute::<JsValue, u64>(other.0) }
     }
 }
@@ -42,15 +54,8 @@ impl Eq for SetKey {}
 
 impl Hash for SetKey {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        if self.0.is_double() {
-            let d = self.0.as_double();
-            if d.is_nan() {
-                0u64.hash(state);
-            } else if d == 0.0 {
-                0.0f64.to_bits().hash(state);
-            } else {
-                d.to_bits().hash(state);
-            }
+        if let Some(bits) = numeric_key_bits(self.0) {
+            bits.hash(state);
         } else {
             // SAFETY: JsValue 是 8 字节 NaN-box Copy 值；哈希原始位与上面的相等判定一致。
             unsafe { std::mem::transmute::<JsValue, u64>(self.0).hash(state) }
@@ -186,10 +191,77 @@ pub fn drop_set_native(obj: &mut JsObject) -> u64 {
     }
 }
 
-/// `Set` 构造函数：创建带空 IndexSet native 数据的 Set 对象。
-pub fn set_constructor<H: VmHost>(vm: &mut H, _args: &[u8]) -> NativeResult {
+/// `Set` 构造函数：创建带空 IndexSet native 数据的 Set 对象，若提供可迭代实参
+/// 则按插入序逐个 add。
+///
+/// # 步骤
+/// 1. 校验 NewTarget：`this` 的原型须是 Set.prototype（普通调用 `Set()` 抛 TypeError）。
+/// 2. 创建空 Set。
+/// 3. 取 adder = Get(set, "add")，要求可调用（否则 TypeError）。
+/// 4. 对可迭代实参逐元素调用 adder（异常时先 IteratorClose 再透传）。
+///
+/// # 边界与前提
+/// - 无实参或实参为 null/undefined 时返回空 Set，不触碰 adder。
+pub fn set_constructor<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let is_new_call = this_val.is_object() && {
+        let set_proto = vm.session().builtin_world().set_proto.as_ptr() as *mut JsObject;
+        // 沿原型链查找 Set.prototype：`new Set()` 直接命中，子类 `super()` 经
+        // 子类 prototype 链命中；普通调用（global/undefined）不命中。
+        let this_ptr = this_val.as_js_object_ptr();
+        if this_ptr.is_null() {
+            false
+        } else {
+            let mut proto = unsafe { &*this_ptr }.proto();
+            let mut found = false;
+            for _ in 0..16 {
+                if !proto.is_object() {
+                    break;
+                }
+                let proto_ptr = proto.as_js_object_ptr();
+                if proto_ptr.is_null() {
+                    break;
+                }
+                if std::ptr::eq(proto_ptr, set_proto) {
+                    found = true;
+                    break;
+                }
+                proto = unsafe { &*proto_ptr }.proto();
+            }
+            found
+        }
+    };
+    if !is_new_call {
+        return NativeResult::Err(crate::error::create_type_error(vm, "Set must be called with new"));
+    }
+
     let set_obj = alloc_set(vm);
-    NativeResult::Ok(JsValue::from_js_object(set_obj))
+    let set_val = JsValue::from_js_object(set_obj);
+
+    if args.len() > 1 {
+        let iterable = vm.reg(args[1]);
+        if !iterable.is_undefined() && !iterable.is_null() {
+            let set_ref = unsafe { &*set_obj };
+            let add_si = vm.kernel_core().perm_interner().intern("add").0;
+            let adder = match vm.ordinary_get(set_ref, add_si, set_val) {
+                Ok(v) => v,
+                Err(err) => return NativeResult::Err(crate::iterator::engine_error(vm, &err)),
+            };
+            if !crate::iterator::is_callable(adder) {
+                return NativeResult::Err(crate::error::create_type_error(vm, "Set.add is not callable"));
+            }
+            if let Err(err) = crate::iterator::iterate_elements(vm, iterable, |vm, elem| {
+                match vm.call_function_sync(adder, set_val, &[elem]) {
+                    Ok(_) => Ok(()),
+                    Err(err) => Err(crate::iterator::engine_error(vm, &err)),
+                }
+            }) {
+                return NativeResult::Err(err);
+            }
+        }
+    }
+
+    NativeResult::Ok(set_val)
 }
 
 /// `Set.prototype.add(value)`：插入元素，返回 this。
@@ -231,6 +303,29 @@ pub fn set_clear<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     NativeResult::Ok(JsValue::undefined())
 }
 
+/// `Set.prototype.forEach(callbackfn, thisArg)`：按插入序对每个值调用回调，
+/// 回调参数为 `(value, value, set)`。迭代期间新增的元素也会被访问。
+pub fn set_for_each<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_set_inner(vm, this_val));
+    let callback = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    if !crate::iterator::is_callable(callback) {
+        return NativeResult::Err(crate::error::create_type_error(vm, "callback is not a function"));
+    }
+    let this_arg = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
+    // 按下标迭代：每次回调后重新读当前下标（支持迭代期间插入）。
+    let mut index = 0usize;
+    loop {
+        let value = unsafe { (*inner).get_index(index).map(|elem| elem.0) };
+        let Some(value) = value else { break };
+        index += 1;
+        if let Err(err) = vm.call_function_sync(callback, this_arg, &[value, value, this_val]) {
+            return NativeResult::Err(crate::iterator::engine_error(vm, &err));
+        }
+    }
+    NativeResult::Ok(JsValue::undefined())
+}
+
 /// `Set.prototype.size` getter：返回元素数量。
 pub fn set_size<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
@@ -271,3 +366,369 @@ pub fn set_keys<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
         crate::iterator::set_values_iter_next::<H> as *const (),
     ))
 }
+
+/// SetRecord 协议：读取参数对象的 `size`/`has`/`keys` 并校验。
+///
+/// # 步骤
+/// 1. 参数非对象抛 TypeError。
+/// 2. `size` 经 ToNumber 转换，为 NaN 抛 TypeError。
+/// 3. `has`/`keys` 须可调用，否则抛 TypeError。
+///
+/// # 返回值
+/// `(对象, size, has, keys)`。
+fn get_set_record<H: VmHost>(vm: &mut H, other: JsValue) -> Result<(JsValue, f64, JsValue, JsValue), JsValue> {
+    if !other.is_object() {
+        return Err(crate::error::create_type_error(vm, "argument is not an object"));
+    }
+    let obj = unsafe { &*other.as_js_object_ptr() };
+    let size_si = vm.kernel_core().perm_interner().intern("size").0;
+    let raw_size = vm
+        .ordinary_get(obj, size_si, other)
+        .map_err(|e| crate::iterator::engine_error(vm, &e))?;
+    let num_size = match oxide_runtime_api::to_number_full(raw_size, vm) {
+        Ok(n) => n,
+        Err(err) => return Err(crate::error::create_type_error(vm, &err)),
+    };
+    if num_size.is_nan() {
+        return Err(crate::error::create_type_error(vm, "size must be a number"));
+    }
+    let has_si = vm.kernel_core().perm_interner().intern("has").0;
+    let has = vm
+        .ordinary_get(obj, has_si, other)
+        .map_err(|e| crate::iterator::engine_error(vm, &e))?;
+    if !crate::iterator::is_callable(has) {
+        return Err(crate::error::create_type_error(vm, "has must be callable"));
+    }
+    let keys_si = vm.kernel_core().perm_interner().intern("keys").0;
+    let keys = vm
+        .ordinary_get(obj, keys_si, other)
+        .map_err(|e| crate::iterator::engine_error(vm, &e))?;
+    if !crate::iterator::is_callable(keys) {
+        return Err(crate::error::create_type_error(vm, "keys must be callable"));
+    }
+    Ok((other, num_size, has, keys))
+}
+
+/// 把 -0.0 归一化为 +0.0（集合运算把 `-0𝔽` 当 `+0𝔽` 处理）。
+fn normalize_neg_zero(value: JsValue) -> JsValue {
+    if value.is_double() {
+        let d = value.as_double();
+        if d == 0.0 && d.is_sign_negative() {
+            return JsValue::float(0.0);
+        }
+    }
+    value
+}
+
+/// 用一个已填充的 `SetInner` 创建普通 Set 对象（原型为 Set.prototype）。
+fn alloc_set_with_inner<H: VmHost>(vm: &mut H, inner: SetInner) -> JsValue {
+    let set_proto = vm.session().builtin_world().set_proto.as_ptr() as *mut JsObject;
+    let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(set_proto));
+    obj.set_set(true);
+    obj.set_native_data(Box::into_raw(Box::new(inner)) as *mut u8);
+    JsValue::from_js_object(vm.alloc_object(obj))
+}
+
+/// 回调控制流：`Continue` 继续迭代，`Stop` 提前终止并 IteratorClose。
+enum KeysFlow {
+    Continue,
+    Stop,
+}
+
+/// 调用 SetRecord 的 `keys` 方法取得迭代器并逐元素回调。
+///
+/// # 步骤
+/// 1. `Call(keys, set)` 得迭代器对象（非对象抛 TypeError）。
+/// 2. 逐次 `next` 读取 `{done, value}` 交给 `f`。
+/// 3. 迭代抛错或 `f` 返回 `Stop` 时先 IteratorClose 再返回。
+///
+/// # 返回值
+/// `Ok(Continue)` 迭代耗尽；`Ok(Stop)` 回调提前终止；`Err` 透传异常。
+fn iterate_record_keys<H: VmHost, F>(
+    vm: &mut H, set: JsValue, keys_method: JsValue, mut f: F,
+) -> Result<KeysFlow, JsValue>
+where
+    F: FnMut(&mut H, JsValue) -> Result<KeysFlow, JsValue>,
+{
+    let iter = match vm.call_function_sync(keys_method, set, &[]) {
+        Ok(v) => v,
+        Err(err) => return Err(crate::iterator::engine_error(vm, &err)),
+    };
+    if !iter.is_object() {
+        return Err(crate::error::create_type_error(vm, "keys() result is not an object"));
+    }
+    let next_si = vm.kernel_core().perm_interner().intern("next").0;
+    let done_si = vm.kernel_core().perm_interner().intern("done").0;
+    let value_si = vm.kernel_core().perm_interner().intern("value").0;
+    let mut flow = KeysFlow::Continue;
+    let run: Result<(), JsValue> = (|| {
+        loop {
+            let iter_obj = unsafe { &*iter.as_js_object_ptr() };
+            let next_fn = vm
+                .ordinary_get(iter_obj, next_si, iter)
+                .map_err(|e| crate::iterator::engine_error(vm, &e))?;
+            let result = vm
+                .call_function_sync(next_fn, iter, &[])
+                .map_err(|e| crate::iterator::engine_error(vm, &e))?;
+            if !result.is_object() {
+                return Err(crate::error::create_type_error(vm, "iterator result is not an object"));
+            }
+            let result_obj = unsafe { &*result.as_js_object_ptr() };
+            let done = vm
+                .ordinary_get(result_obj, done_si, result)
+                .map_err(|e| crate::iterator::engine_error(vm, &e))?;
+            if oxide_runtime_api::to_boolean(done) {
+                break;
+            }
+            let value = vm
+                .ordinary_get(result_obj, value_si, result)
+                .map_err(|e| crate::iterator::engine_error(vm, &e))?;
+            flow = f(vm, value)?;
+            if matches!(flow, KeysFlow::Stop) {
+                break;
+            }
+        }
+        Ok(())
+    })();
+    if run.is_err() || matches!(flow, KeysFlow::Stop) {
+        crate::iterator::close_iterator(vm, iter);
+    }
+    run.map(|()| flow)
+}
+
+/// `Set.prototype.union(other)`：返回 this 与 other 的并集（新 Set，顺序为 this 在前）。
+///
+/// # 步骤
+/// 1. 取 SetRecord，复制 this 的 [[SetData]]。
+/// 2. 经 other 的 `keys()` 迭代追加缺失元素，`-0𝔽` 归一化为 `+0𝔽`。
+///
+/// # 注意事项
+/// 只调用 other 的 `keys`，不调用 `has`。
+pub fn set_union<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_set_inner(vm, this_val));
+    let other = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    let (rec_set, _size, _has, rec_keys) = match get_set_record(vm, other) {
+        Ok(r) => r,
+        Err(err) => return NativeResult::Err(err),
+    };
+    let mut result: SetInner = unsafe { (*inner).clone() };
+    let flow = match iterate_record_keys(vm, rec_set, rec_keys, |_vm, value| {
+        result.insert(SetKey(normalize_neg_zero(value)));
+        Ok(KeysFlow::Continue)
+    }) {
+        Ok(f) => f,
+        Err(err) => return NativeResult::Err(err),
+    };
+    debug_assert!(matches!(flow, KeysFlow::Continue));
+    NativeResult::Ok(alloc_set_with_inner(vm, result))
+}
+
+/// `Set.prototype.intersection(other)`：返回 this 与 other 的交集（新 Set）。
+///
+/// # 步骤
+/// 1. 取 SetRecord。
+/// 2. this 元素数 ≤ other 时：遍历 this，保留 other 的 `has(e)` 为真的元素（顺序为 this）。
+/// 3. 否则遍历 other 的 `keys()`，保留 this 中含有的元素（顺序为 other）。
+pub fn set_intersection<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_set_inner(vm, this_val));
+    let other = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    let (rec_set, rec_size, rec_has, rec_keys) = match get_set_record(vm, other) {
+        Ok(r) => r,
+        Err(err) => return NativeResult::Err(err),
+    };
+    let this_size = unsafe { (*inner).len() } as f64;
+    let mut result = SetInner::new();
+    if this_size <= rec_size {
+        let entries: Vec<JsValue> = unsafe { (*inner).iter().map(|k| k.0).collect() };
+        for e in entries {
+            let in_other = match vm.call_function_sync(rec_has, rec_set, &[e]) {
+                Ok(v) => v,
+                Err(err) => return NativeResult::Err(crate::iterator::engine_error(vm, &err)),
+            };
+            if oxide_runtime_api::to_boolean(in_other) {
+                result.insert(SetKey(e));
+            }
+        }
+    } else {
+        match iterate_record_keys(vm, rec_set, rec_keys, |_vm, value| {
+            let value = normalize_neg_zero(value);
+            if unsafe { (*inner).contains(&SetKey(value)) } {
+                result.insert(SetKey(value));
+            }
+            Ok(KeysFlow::Continue)
+        }) {
+            Ok(_) => {}
+            Err(err) => return NativeResult::Err(err),
+        }
+    }
+    NativeResult::Ok(alloc_set_with_inner(vm, result))
+}
+
+/// `Set.prototype.difference(other)`：返回 this 中不在 other 的元素（新 Set）。
+///
+/// # 步骤
+/// 1. 取 SetRecord。
+/// 2. this 元素数 ≤ other 时：遍历 this，保留 other 的 `has(e)` 为假的元素。
+/// 3. 否则复制 this，经 other 的 `keys()` 逐个移除存在的元素。
+pub fn set_difference<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_set_inner(vm, this_val));
+    let other = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    let (rec_set, rec_size, rec_has, rec_keys) = match get_set_record(vm, other) {
+        Ok(r) => r,
+        Err(err) => return NativeResult::Err(err),
+    };
+    let this_size = unsafe { (*inner).len() } as f64;
+    let mut result = SetInner::new();
+    if this_size <= rec_size {
+        let entries: Vec<JsValue> = unsafe { (*inner).iter().map(|k| k.0).collect() };
+        for e in entries {
+            let in_other = match vm.call_function_sync(rec_has, rec_set, &[e]) {
+                Ok(v) => v,
+                Err(err) => return NativeResult::Err(crate::iterator::engine_error(vm, &err)),
+            };
+            if !oxide_runtime_api::to_boolean(in_other) {
+                result.insert(SetKey(e));
+            }
+        }
+    } else {
+        unsafe {
+            for k in (*inner).iter() {
+                result.insert(*k);
+            }
+        }
+        match iterate_record_keys(vm, rec_set, rec_keys, |_vm, value| {
+            result.shift_remove(&SetKey(normalize_neg_zero(value)));
+            Ok(KeysFlow::Continue)
+        }) {
+            Ok(_) => {}
+            Err(err) => return NativeResult::Err(err),
+        }
+    }
+    NativeResult::Ok(alloc_set_with_inner(vm, result))
+}
+
+/// `Set.prototype.symmetricDifference(other)`：返回对称差集（新 Set）。
+///
+/// # 步骤
+/// 1. 取 SetRecord，复制 this 的 [[SetData]]。
+/// 2. 经 other 的 `keys()`：元素已在结果中则移除，否则追加。
+pub fn set_symmetric_difference<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_set_inner(vm, this_val));
+    let other = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    let (rec_set, _size, _has, rec_keys) = match get_set_record(vm, other) {
+        Ok(r) => r,
+        Err(err) => return NativeResult::Err(err),
+    };
+    let mut result: SetInner = unsafe { (*inner).clone() };
+    match iterate_record_keys(vm, rec_set, rec_keys, |_vm, value| {
+        let key = SetKey(normalize_neg_zero(value));
+        if result.shift_remove(&key) {
+            // 已在结果中（交集部分）→ 移除。
+        } else {
+            result.insert(key);
+        }
+        Ok(KeysFlow::Continue)
+    }) {
+        Ok(_) => {}
+        Err(err) => return NativeResult::Err(err),
+    }
+    NativeResult::Ok(alloc_set_with_inner(vm, result))
+}
+
+/// `Set.prototype.isSubsetOf(other)`：this 的每个元素都在 other 中。
+/// this 元素数 > other 的 size 时直接返回 false；否则遍历 this 调 other 的 `has`。
+pub fn set_is_subset_of<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_set_inner(vm, this_val));
+    let other = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    let (rec_set, rec_size, rec_has, _rec_keys) = match get_set_record(vm, other) {
+        Ok(r) => r,
+        Err(err) => return NativeResult::Err(err),
+    };
+    if (unsafe { (*inner).len() }) as f64 > rec_size {
+        return NativeResult::Ok(JsValue::bool(false));
+    }
+    let entries: Vec<JsValue> = unsafe { (*inner).iter().map(|k| k.0).collect() };
+    for e in entries {
+        let in_other = match vm.call_function_sync(rec_has, rec_set, &[e]) {
+            Ok(v) => v,
+            Err(err) => return NativeResult::Err(crate::iterator::engine_error(vm, &err)),
+        };
+        if !oxide_runtime_api::to_boolean(in_other) {
+            return NativeResult::Ok(JsValue::bool(false));
+        }
+    }
+    NativeResult::Ok(JsValue::bool(true))
+}
+
+/// `Set.prototype.isSupersetOf(other)`：other 的每个元素都在 this 中。
+/// this 元素数 < other 的 size 时直接返回 false；否则经 other 的 `keys()` 逐元素
+/// 检查，提前发现不在时终止并 IteratorClose。
+pub fn set_is_superset_of<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_set_inner(vm, this_val));
+    let other = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    let (rec_set, rec_size, _has, rec_keys) = match get_set_record(vm, other) {
+        Ok(r) => r,
+        Err(err) => return NativeResult::Err(err),
+    };
+    if ((unsafe { (*inner).len() }) as f64) < rec_size {
+        return NativeResult::Ok(JsValue::bool(false));
+    }
+    let flow = match iterate_record_keys(vm, rec_set, rec_keys, |_vm, value| {
+        if !unsafe { (*inner).contains(&SetKey(normalize_neg_zero(value))) } {
+            Ok(KeysFlow::Stop)
+        } else {
+            Ok(KeysFlow::Continue)
+        }
+    }) {
+        Ok(f) => f,
+        Err(err) => return NativeResult::Err(err),
+    };
+    NativeResult::Ok(JsValue::bool(matches!(flow, KeysFlow::Continue)))
+}
+
+/// `Set.prototype.isDisjointFrom(other)`：this 与 other 无公共元素。
+/// this 元素数 ≤ other 时遍历 this 调 other 的 `has`；否则遍历 other 的 `keys()`。
+pub fn set_is_disjoint_from<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_set_inner(vm, this_val));
+    let other = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    let (rec_set, rec_size, rec_has, rec_keys) = match get_set_record(vm, other) {
+        Ok(r) => r,
+        Err(err) => return NativeResult::Err(err),
+    };
+    let this_size = unsafe { (*inner).len() } as f64;
+    let disjoint = if this_size <= rec_size {
+        let entries: Vec<JsValue> = unsafe { (*inner).iter().map(|k| k.0).collect() };
+        let mut disjoint = true;
+        for e in entries {
+            let in_other = match vm.call_function_sync(rec_has, rec_set, &[e]) {
+                Ok(v) => v,
+                Err(err) => return NativeResult::Err(crate::iterator::engine_error(vm, &err)),
+            };
+            if oxide_runtime_api::to_boolean(in_other) {
+                disjoint = false;
+                break;
+            }
+        }
+        disjoint
+    } else {
+        match iterate_record_keys(vm, rec_set, rec_keys, |_vm, value| {
+            if unsafe { (*inner).contains(&SetKey(normalize_neg_zero(value))) } {
+                Ok(KeysFlow::Stop)
+            } else {
+                Ok(KeysFlow::Continue)
+            }
+        }) {
+            Ok(KeysFlow::Continue) => true,
+            Ok(KeysFlow::Stop) => false,
+            Err(err) => return NativeResult::Err(err),
+        }
+    };
+    NativeResult::Ok(JsValue::bool(disjoint))
+}