feat: Iterator.zip 支持 longest 与 strict 模式及 padding 填充

Cargo.lock

@@ -1160,7 +1160,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_builtins"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "chrono",
  "fast-float",
@@ -1185,7 +1185,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_bytecode"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "num-bigint",
  "oxide_log",
@@ -1193,7 +1193,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_cfg"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxide_bytecode",
  "oxide_emit",
@@ -1204,7 +1204,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_cli"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "ansi_term",
  "bumpalo",
@@ -1228,7 +1228,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_code_cache"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "lru",
  "oxide_bytecode",
@@ -1237,7 +1237,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_compiler"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1258,7 +1258,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_dce"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1272,7 +1272,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_emit"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "num-bigint",
  "oxc_allocator",
@@ -1288,7 +1288,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_engine"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxide_bytecode",
  "oxide_compiler",
@@ -1300,7 +1300,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_fold"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "num-bigint",
  "oxide_bytecode",
@@ -1312,7 +1312,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_ir"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxide_bytecode",
  "oxide_log",
@@ -1321,7 +1321,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_kernel"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "bumpalo",
  "dashmap",
@@ -1335,7 +1335,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_liveness"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1347,7 +1347,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_log"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "tracing",
  "tracing-appender",
@@ -1356,11 +1356,11 @@ dependencies = [
 
 [[package]]
 name = "oxide_net"
-version = "0.19.26"
+version = "0.19.27"
 
 [[package]]
 name = "oxide_parser"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxc_allocator",
  "oxc_ast",
@@ -1375,7 +1375,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_regalloc"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxide_bytecode",
  "oxide_cfg",
@@ -1391,7 +1391,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_runtime_api"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "num-bigint",
  "num-traits",
@@ -1404,7 +1404,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_test262"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "oxide_bytecode",
  "oxide_compiler",
@@ -1424,7 +1424,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_types"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "bumpalo",
  "dashmap",
@@ -1437,7 +1437,7 @@ dependencies = [
 
 [[package]]
 name = "oxide_vm"
-version = "0.19.26"
+version = "0.19.27"
 dependencies = [
  "bumpalo",
  "chrono",

Cargo.toml

@@ -25,7 +25,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.19.26"
+version = "0.19.27"
 edition = "2021"
 license = "MIT"
 rust-version = "1.80"

crates/oxide_builtins/src/iterator.rs

@@ -234,6 +234,26 @@ pub(crate) fn iterator_record_step<H: VmHost>(
     Ok(Some(value))
 }
 
+/// 调用缓存的 next 取一步，只读结果对象的 `done`（对应规范 IteratorStep，
+/// 不读 value getter）。
+///
+/// # 返回值
+/// - `Ok(true)`：迭代完成（done=true）；
+/// - `Ok(false)`：未耗尽（done=false，不读 value）；
+/// - `Err`：next 抛错 / 结果非对象 / done getter 抛错（透传原值，不关底层）。
+pub(crate) fn iterator_step_done_only<H: VmHost>(
+    vm: &mut H, next: JsValue, iterated: JsValue,
+) -> Result<bool, JsValue> {
+    let result = vm.call_function_sync(next, iterated, &[]).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_si = vm.perm_intern("done");
+    let done = vm.ordinary_get(result_obj, done_si, result).map_err(|e| engine_error(vm, &e))?;
+    Ok(oxide_runtime_api::to_boolean(done))
+}
+
 /// IteratorClose：延迟 GetMethod(iterator, "return") 并调用，按 completion 形态决定
 /// 错误胜者（throw → 原错误胜出；正常 → return 相关错误胜出）。
 ///
@@ -443,7 +463,9 @@ fn get_iterator_flattenable<H: VmHost>(vm: &mut H, value: JsValue) -> Result<(Js
 ///
 /// # 返回
 /// - `Ok((iter, next))`：迭代器 + GetIteratorDirect 缓存的 next。
-fn get_iterator_strict<H: VmHost>(vm: &mut H, value: JsValue) -> Result<(JsValue, JsValue), JsValue> {
+fn get_iterator_strict<H: VmHost>(
+    vm: &mut H, what: &str, value: JsValue,
+) -> Result<(JsValue, JsValue), JsValue> {
     let obj = unsafe { &*value.as_js_object_ptr() };
     let sym_iter_si = encode_symbol_key(vm.realm_id(), 0);
     let method = match vm.ordinary_get(obj, sym_iter_si, value) {
@@ -451,13 +473,16 @@ fn get_iterator_strict<H: VmHost>(vm: &mut H, value: JsValue) -> Result<(JsValue
         Err(err) => return Err(engine_error(vm, &err)),
     };
     if !is_callable(method) {
-        return Err(crate::error::create_type_error(vm, "Iterator.zip iterables is not iterable"));
+        return Err(crate::error::create_type_error(
+            vm,
+            &format!("Iterator.zip {what} is not iterable"),
+        ));
     }
     let iter = vm.call_function_sync(method, value, &[]).map_err(|e| engine_error(vm, &e))?;
     if !iter.is_object() {
         return Err(crate::error::create_type_error(
             vm,
-            "Iterator.zip iterables @@iterator returned a non-object",
+            &format!("Iterator.zip {what} @@iterator returned a non-object"),
         ));
     }
     get_iterator_direct(vm, iter)
@@ -1261,7 +1286,8 @@ fn helper_step_flat_map<H: VmHost>(
 /// `iterables` 对象、读 options（mode 严格字符串校验，longest 时读 padding），
 /// 再全 GetIterator 取 `inputIter`，元素收集循环（IteratorStepValue 骤发逆序关
 /// 已收集元素迭代器；元素经 GetIteratorFlattenable 骤发逆序关含 inputIter），
-/// 最后建 zip wrapper。
+/// longest 且 padding 为对象时预计算 padding 数组（骤发逆序关元素迭代器、
+/// padding 迭代器不关；未耗尽收口正常关），最后建 zip wrapper。
 ///
 /// # 步骤
 /// 1. `iterables` 非对象 → TypeError（options 不读）。
@@ -1269,7 +1295,9 @@ fn helper_step_flat_map<H: VmHost>(
 ///    String 包装对象拒绝、不触发 toPrimitive，无效 mode 不读 padding）。
 /// 3. longest 模式读 `padding`（undefined 或对象，其余 TypeError）。
 /// 4. GetIterator（无鸭子回退）取 inputIter；元素收集循环骤发逆序关后透传。
-/// 5. 建 zip wrapper（`__kind__`=5）。
+/// 5. longest 且 padding 为对象：GetIterator(padding) 加升序步进至多元素数次
+///    预计算 padding 数组（耗尽余位填 undefined，未耗尽正常关）。
+/// 6. 建 zip wrapper（`__kind__`=5）。
 pub fn iterator_zip<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let iterables = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
     let options = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
@@ -1324,7 +1352,7 @@ pub fn iterator_zip<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     } else {
         JsValue::undefined()
     };
-    let (input_iter, input_next) = match get_iterator_strict(vm, iterables) {
+    let (input_iter, input_next) = match get_iterator_strict(vm, "iterables", iterables) {
         Ok(pair) => pair,
         Err(v) => return NativeResult::Err(v),
     };
@@ -1347,13 +1375,57 @@ pub fn iterator_zip<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
             }
         }
     }
-    NativeResult::Ok(make_iterator_zip_helper(vm, &zips, mode, padding))
+    // longest 且 padding 为对象：预计算 padding 数组（长度恒为元素数，耗尽后余位
+    // 填 undefined）。骤发（GetIterator 与 next/done/value getter）逆序关已收集
+    // 元素迭代器而 padding 迭代器不关，透传原值；全部步进后未耗尽则正常关，
+    // 关闭骤发同样逆序关元素迭代器透传。
+    let padding_value = if mode == 1 && padding.is_object() {
+        let (padding_iter, padding_next) = match get_iterator_strict(vm, "padding", padding) {
+            Ok(pair) => pair,
+            Err(v) => {
+                close_zip_pairs(vm, &zips, None, Some(v));
+                return NativeResult::Err(v);
+            }
+        };
+        let mut pad_values: Vec<JsValue> = Vec::new();
+        let mut using_iterator = true;
+        for _ in 0..zips.len() {
+            if using_iterator {
+                match iterator_record_step(vm, padding_next, padding_iter) {
+                    Ok(Some(value)) => pad_values.push(value),
+                    Ok(None) => {
+                        using_iterator = false;
+                        pad_values.push(JsValue::undefined());
+                    }
+                    Err(v) => {
+                        close_zip_pairs(vm, &zips, None, Some(v));
+                        return NativeResult::Err(v);
+                    }
+                }
+            } else {
+                pad_values.push(JsValue::undefined());
+            }
+        }
+        if using_iterator {
+            if let Err(v) = iterator_close_record(vm, padding_iter, None) {
+                close_zip_pairs(vm, &zips, None, Some(v));
+                return NativeResult::Err(v);
+            }
+        }
+        make_array_from_list(vm, &pad_values)
+    } else {
+        JsValue::undefined()
+    };
+    NativeResult::Ok(make_iterator_zip_helper(vm, &zips, mode, padding_value))
 }
 
 /// 建 zip wrapper：空对象挂 `%IteratorHelperPrototype%`，写 `__zips__`（元素
 /// 迭代器对数组，每元素为 [iter, next] 对）、`__open__`（位掩码，初始全 1）、
 /// `__mode__`（0/1/2）、`__state__`（0）、`__kind__`（5）、`__padding__` 槽。
 ///
+/// `__padding__` 存预计算 padding 数组（longest 且 padding 为对象时，长度恒为
+/// 元素数）或 undefined；步进期按 done 位下标取落点值。
+///
 /// 独立构造器（不复用 [`make_iterator_helper`]）：槽位布局不同，zip 无
 /// `__inner__`/`__next__` 槽。
 fn make_iterator_zip_helper<H: VmHost>(
@@ -1467,10 +1539,13 @@ fn close_zip_pairs<H: VmHost>(
     }
 }
 
-/// zip 推进（shortest 臂加 mode 分派骨架）：升序步进开放迭代器，收集到钉在
-/// `__results__` 槽的新数组；done 清位后 shortest 逆序关其余开放迭代器（正常
-/// 完成）收口；abrupt 清位后逆序关其余（原值胜出）透传；longest/strict 臂
-/// 未实现，此处按 longest 的 undefined 填充语义降级保 wrapper 健壮。
+/// zip 推进：升序步进开放迭代器，收集到钉在 `__results__` 槽的新数组。三 mode
+/// 臂：shortest done 位逆序关其余开放迭代器（正常完成）收口；longest done 位填
+/// 预计算 `padding[i]`（越界 undefined）续行、全耗尽收口；strict done 位 i 非 0
+/// 逆序关全部开放迭代器（throw 完成，新 TypeError 胜出）后抛新 TypeError，i 为 0
+/// 升序余者扫描（只读 done，已关位视 done 不重调 next），首个骤发逆序关全部开放
+/// 迭代器透传原值、首个未耗尽逆序关全部开放迭代器抛新 TypeError、全耗尽正常收口；
+/// 步进骤发清位后逆序关其余（原值胜出）透传。
 fn helper_step_zip<H: VmHost>(
     vm: &mut H, this_val: JsValue, helper: &mut JsObject,
 ) -> Result<Option<JsValue>, JsValue> {
@@ -1491,6 +1566,9 @@ fn helper_step_zip<H: VmHost>(
     }
     let mode_si = vm.perm_intern(MODE_PROP);
     let mode = read_slot_int(vm, helper, mode_si, 0);
+    // longest 臂落点值来自预计算 padding 数组（用户调用窗口前读取）。
+    let padding_si = vm.perm_intern(PADDING_PROP);
+    let padding_val = vm.ordinary_get(helper, padding_si, this_val).unwrap_or(JsValue::undefined());
     let array_proto = vm.builtin_proto(ProtoKind::ArrayProto);
     let arr = vm.alloc_object(JsObject::new_array(
         EMPTY_SHAPE_ID,
@@ -1503,6 +1581,21 @@ fn helper_step_zip<H: VmHost>(
     let mut arr_len = 0usize;
     for i in 0..iter_count {
         if !zip_bit_open(open, i) {
+            // 已关迭代器：longest 臂填 padding 落点续行（结果数组每个输入恒有
+            // 一槽）；shortest/strict 首 done 即返回，本臂不会到达已关位。
+            if mode == 1 {
+                let pad = if padding_val.is_object() {
+                    let pad_obj = unsafe { &*padding_val.as_js_object_ptr() };
+                    pad_obj.get_prop_at(i)
+                } else {
+                    JsValue::undefined()
+                };
+                // SAFETY: arr 是刚经统一入口分配的数组对象，元素区已就绪。
+                unsafe {
+                    (*arr).set_prop_at(arr_len, pad);
+                }
+                arr_len += 1;
+            }
             continue;
         }
         // 每次用户调用窗口后重读槽位（回调可改写 wrapper 槽）。
@@ -1534,13 +1627,67 @@ fn helper_step_zip<H: VmHost>(
                         Err(v) => Err(v),
                     };
                 }
-                // longest/strict 臂未实现：按 longest 的 undefined 填充语义降级。
+                if mode == 2 {
+                    // strict：i 非 0 done → 逆序关全部开放迭代器（throw 完成，新
+                    // TypeError 胜出）后抛新 TypeError。
+                    if i != 0 {
+                        let type_err = crate::error::create_type_error(
+                            vm,
+                            "Iterator.zip strict mode: iterators are not all the same length",
+                        );
+                        let _ = close_remaining_open(vm, this_val, helper, open, iter_count, Some(type_err));
+                        return Err(type_err);
+                    }
+                    // i 为 0：升序余者扫描（只读 done，已关位视 done 不重调 next）。
+                    for k in 1..iter_count {
+                        if !zip_bit_open(open, k) {
+                            continue;
+                        }
+                        let pair_val = zips_obj.get_prop_at(k);
+                        if !pair_val.is_object() {
+                            continue;
+                        }
+                        let pair_obj = unsafe { &*pair_val.as_js_object_ptr() };
+                        let iter_k = pair_obj.get_prop_at(0);
+                        let next_k = pair_obj.get_prop_at(1);
+                        match iterator_step_done_only(vm, next_k, iter_k) {
+                            Err(v) => {
+                                open = zip_bit_clear(open, k);
+                                vm.set_or_create_prop_value(helper, open_si, JsValue::int(open));
+                                let _ = close_remaining_open(vm, this_val, helper, open, iter_count, Some(v));
+                                return Err(v);
+                            }
+                            Ok(true) => {
+                                // done 位移出开放集（不重调 next，不参与关全部）。
+                                open = zip_bit_clear(open, k);
+                                vm.set_or_create_prop_value(helper, open_si, JsValue::int(open));
+                            }
+                            Ok(false) => {
+                                let type_err = crate::error::create_type_error(
+                                    vm,
+                                    "Iterator.zip strict mode: iterators are not all the same length",
+                                );
+                                let _ = close_remaining_open(vm, this_val, helper, open, iter_count, Some(type_err));
+                                return Err(type_err);
+                            }
+                        }
+                    }
+                    // 全耗尽：正常收口。
+                    return Ok(None);
+                }
+                // longest：done 位填 padding[i]（越界 undefined）续行。
                 if !zip_bit_open(open, 0) && (0..iter_count).all(|k| !zip_bit_open(open, k)) {
                     return Ok(None);
                 }
+                let pad = if padding_val.is_object() {
+                    let pad_obj = unsafe { &*padding_val.as_js_object_ptr() };
+                    pad_obj.get_prop_at(i)
+                } else {
+                    JsValue::undefined()
+                };
                 // SAFETY: 同上一分支。
                 unsafe {
-                    (*arr).set_prop_at(arr_len, JsValue::undefined());
+                    (*arr).set_prop_at(arr_len, pad);
                 }
                 arr_len += 1;
             }

crates/oxide_vm/tests/builtins_iterator_tests.rs

@@ -2703,3 +2703,340 @@ fn iterator_zip_reentrancy_guard() {
     .unwrap();
     assert!(r.as_bool(), "executing reentry on return throws TypeError");
 }
+
+#[test]
+fn iterator_zip_longest_basic_values_and_padding() {
+    // longest 基本值与 padding 落点：无 padding 填 undefined、padding 数组、
+    // padding 迭代器（耗尽余位 undefined、无限迭代器步进至多 iterCount 次）。
+    let mut vm = Vm::new();
+    let bool_cases = [
+        (
+            "var it = Iterator.zip([[1,2,3],[4,5]], {mode: 'longest'}); \
+             var r1 = it.next().value; var r2 = it.next().value; var r3 = it.next(); \
+             r1[0] === 1 && r1[1] === 4 && r2[0] === 2 && r2[1] === 5 \
+             && r3.value[0] === 3 && r3.value[1] === undefined && r3.done === false \
+             && it.next().done === true",
+            true,
+        ),
+        (
+            "var it = Iterator.zip([[1,2],[3,4,5]], {mode: 'longest', padding: ['p','q']}); \
+             var r1 = it.next().value; var r2 = it.next().value; var r3 = it.next(); \
+             r1[0] === 1 && r1[1] === 3 && r2[0] === 2 && r2[1] === 4 \
+             && r3.value[0] === 'p' && r3.value[1] === 5 && it.next().done === true",
+            true,
+        ),
+        (
+            "var it = Iterator.zip([[1,2],[3,4,5]], {mode: 'longest', padding: []}); \
+             it.next(); it.next(); var r3 = it.next().value; r3[0] === undefined && r3[1] === 5 \
+             && it.next().done === true",
+            true,
+        ),
+        (
+            "var pads = { [Symbol.iterator]() { return {v: 0, next() { this.v++; return {value: this.v, done: false}; }}; } }; \
+             var it = Iterator.zip([[1,2],[3,4,5]], {mode: 'longest', padding: pads}); \
+             it.next(); it.next(); var r3 = it.next().value; r3[0] === 1 && r3[1] === 5",
+            true,
+        ),
+        (
+            "var steps = 0; var rets = 0; \
+             var infinite = { [Symbol.iterator]() { var self = this; return { next() { steps++; return {value: steps, done: false}; }, \
+               return() { rets++; return {done: true}; } }; } }; \
+             var it = Iterator.zip([[1,2],[3]], {mode: 'longest', padding: infinite}); \
+             it.next(); it.next(); it.next(); \
+             steps === 2 && rets === 1",
+            true,
+        ),
+    ];
+    for (src, expected) in bool_cases {
+        let result = eval(&mut vm, src).unwrap();
+        assert_eq!(result.as_bool(), expected, "for {}", src);
+    }
+}
+
+#[test]
+fn iterator_zip_strict_basic_values() {
+    // strict 基本值：等长正常收口，不等长 done 位抛 TypeError。
+    let mut vm = Vm::new();
+    let bool_cases = [
+        (
+            "var it = Iterator.zip([[1,2,3],[4,5,6]], {mode: 'strict'}); \
+             it.next().value[0] === 1 && it.next().value[1] === 5 && it.next().value[0] === 3 \
+             && it.next().done === true",
+            true,
+        ),
+        (
+            "var ok = false; try { \
+              var it = Iterator.zip([[1,2,3],[4,5]], {mode: 'strict'}); \
+              it.next(); it.next(); it.next(); \
+            } catch (e) { ok = e instanceof TypeError; } ok",
+            true,
+        ),
+        (
+            "var ok = false; try { \
+              var it = Iterator.zip([[1,2],[3,4,5]], {mode: 'strict'}); \
+              it.next(); it.next(); it.next(); \
+            } catch (e) { ok = e instanceof TypeError; } ok",
+            true,
+        ),
+    ];
+    for (src, expected) in bool_cases {
+        let result = eval(&mut vm, src).unwrap();
+        assert_eq!(result.as_bool(), expected, "for {}", src);
+    }
+}
+
+#[test]
+fn iterator_zip_strict_done_close_order() {
+    // strict done 位 i 非 0：逆序关全部开放迭代器（throw 完成，return 错误被吞），
+    // 抛新 TypeError；done 位迭代器不关。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var log = [];
+            var first = { next() { log.push('first next'); return {done: false}; },
+              return() { log.push('first return'); throw new RangeError('x'); } };
+            var second = { next() { log.push('second next'); return {done: true}; },
+              return() { log.push('second return'); } };
+            var third = { next() { log.push('third next'); },
+              return() { log.push('third return'); throw new ReferenceError('boom'); } };
+            var it = Iterator.zip([first, second, third], {mode: 'strict'});
+            var threw = false;
+            try { it.next(); } catch (e) { threw = e instanceof TypeError; }
+            return threw + '|' + JSON.stringify(log);
+          })()",
+    )
+    .unwrap();
+    assert_eq!(
+        to_str(&vm, r),
+        "true|[\"first next\",\"second next\",\"third return\",\"first return\"]",
+        "strict i not zero: close all open in reverse, new TypeError wins"
+    );
+}
+
+#[test]
+fn iterator_zip_strict_i_is_zero_scan() {
+    // strict done 位 i 为 0：升序余者扫描（只读 done），三臂——全耗尽正常收口、
+    // 首个未耗尽逆序关全部开放抛新 TypeError、骤发逆序关全部透传原值。
+    let mut vm = Vm::new();
+    // 全耗尽：正常收口，无 return 调用。
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var log = [];
+            function makeIter(name) {
+              return { next() { log.push(name + ' next'); return {done: true}; },
+                return() { log.push(name + ' return'); } };
+            }
+            var it = Iterator.zip([makeIter('a'), makeIter('b'), makeIter('c')], {mode: 'strict'});
+            var result = it.next();
+            return (result.done === true) + '|' + JSON.stringify(log);
+          })()",
+    )
+    .unwrap();
+    assert_eq!(
+        to_str(&vm, r),
+        "true|[\"a next\",\"b next\",\"c next\"]",
+        "strict i zero all exhausted: normal completion, no return calls"
+    );
+    // 首个未耗尽：逆序关全部开放（含已关位不重调 next），抛新 TypeError。
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var log = [];
+            var first = { next() { log.push('first next'); return {done: true}; },
+              return() { log.push('first return'); } };
+            var second = { next() { log.push('second next'); return {done: true}; },
+              return() { log.push('second return'); } };
+            var third = { next() { log.push('third next'); return {done: false}; },
+              return() { log.push('third return'); throw new RangeError('x'); } };
+            var fourth = { next() { log.push('fourth next'); },
+              return() { log.push('fourth return'); throw new ReferenceError('boom'); } };
+            var it = Iterator.zip([first, second, third, fourth], {mode: 'strict'});
+            var threw = false;
+            try { it.next(); } catch (e) { threw = e instanceof TypeError; }
+            return threw + '|' + JSON.stringify(log);
+          })()",
+    )
+    .unwrap();
+    assert_eq!(
+        to_str(&vm, r),
+        "true|[\"first next\",\"second next\",\"third next\",\"fourth return\",\"third return\"]",
+        "strict i zero not exhausted: close all open in reverse, new TypeError wins"
+    );
+    // 骤发：首个骤发逆序关全部开放（原值胜出），骤发位不关。
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var log = [];
+            var first = { next() { log.push('first next'); return {done: true}; },
+              return() { log.push('first return'); } };
+            var second = { next() { log.push('second next'); throw new RangeError('boom'); },
+              return() { log.push('second return'); } };
+            var third = { next() { log.push('third next'); },
+              return() { log.push('third return'); throw new ReferenceError('x'); } };
+            var fourth = { next() { log.push('fourth next'); },
+              return() { log.push('fourth return'); throw new ReferenceError('y'); } };
+            var it = Iterator.zip([first, second, third, fourth], {mode: 'strict'});
+            var threw = false;
+            try { it.next(); } catch (e) { threw = e instanceof RangeError; }
+            return threw + '|' + JSON.stringify(log);
+          })()",
+    )
+    .unwrap();
+    assert_eq!(
+        to_str(&vm, r),
+        "true|[\"first next\",\"second next\",\"fourth return\",\"third return\"]",
+        "strict i zero scan abrupt: close all open in reverse, original value wins"
+    );
+}
+
+#[test]
+fn iterator_zip_longest_abrupt_close_order() {
+    // longest 步进骤发：清位后逆序关其余开放迭代器（原值胜出），done 位不关。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var log = [];
+            var empty = { next() { log.push('empty next'); return {done: true}; },
+              return() { log.push('empty return'); } };
+            var first = { next() { log.push('first next'); throw new RangeError('boom'); },
+              return() { log.push('first return'); } };
+            var second = { next() { log.push('second next'); },
+              return() { log.push('second return'); throw new ReferenceError('x'); } };
+            var third = { next() { log.push('third next'); },
+              return() { log.push('third return'); throw new ReferenceError('y'); } };
+            var it = Iterator.zip([empty, first, second, third], {mode: 'longest'});
+            var threw = false;
+            try { it.next(); } catch (e) { threw = e instanceof RangeError; }
+            return threw + '|' + JSON.stringify(log);
+          })()",
+    )
+    .unwrap();
+    assert_eq!(
+        to_str(&vm, r),
+        "true|[\"empty next\",\"first next\",\"third return\",\"second return\"]",
+        "longest abrupt: done slot not closed, rest closed in reverse, original wins"
+    );
+}
+
+#[test]
+fn iterator_zip_padding_precompute_abrupt() {
+    // padding 预计算骤发（GetIterator 与 next/done/value getter）：逆序关元素
+    // 迭代器，padding 迭代器不关，透传原值。
+    let mut vm = Vm::new();
+    // GetIterator 骤发（Symbol.iterator 抛错）。
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var log = [];
+            var first = { next() { log.push('unexpected next'); },
+              return() { log.push('first return'); throw new ReferenceError('x'); } };
+            var second = { next() { log.push('unexpected next'); },
+              return() { log.push('second return'); throw new ReferenceError('y'); } };
+            var third = { next() { log.push('unexpected next'); },
+              get return() { log.push('third return'); throw new ReferenceError('z'); } };
+            var padding = { [Symbol.iterator]() { throw new RangeError('boom'); } };
+            var threw = false;
+            try { Iterator.zip([first, second, third], {mode: 'longest', padding}); }
+            catch (e) { threw = e instanceof RangeError; }
+            return threw + '|' + JSON.stringify(log);
+          })()",
+    )
+    .unwrap();
+    assert_eq!(
+        to_str(&vm, r),
+        "true|[\"third return\",\"second return\",\"first return\"]",
+        "padding GetIterator abrupt: close element iterators in reverse, padding not closed"
+    );
+    // 步进骤发（next 抛错 / done getter 抛错 / value getter 抛错）。
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var log = [];
+            function makeElements() {
+              return [
+                { next() { log.push('unexpected next'); },
+                  return() { log.push('first return'); throw new ReferenceError('x'); } },
+                { next() { log.push('unexpected next'); },
+                  return() { log.push('second return'); throw new ReferenceError('y'); } },
+                { next() { log.push('unexpected next'); },
+                  get return() { log.push('third return'); throw new ReferenceError('z'); } }
+              ];
+            }
+            var padding = { [Symbol.iterator]() { return this; },
+              next() { throw new RangeError('boom'); } };
+            var threw = false;
+            try { Iterator.zip(makeElements(), {mode: 'longest', padding}); }
+            catch (e) { threw = e instanceof RangeError; }
+            var l1 = JSON.stringify(log);
+            log.length = 0;
+            var padding2 = { [Symbol.iterator]() { return this; },
+              next() { return { get done() { throw new RangeError('boom'); } }; } };
+            try { Iterator.zip(makeElements(), {mode: 'longest', padding: padding2}); }
+            catch (e) { threw = threw && e instanceof RangeError; }
+            var l2 = JSON.stringify(log);
+            log.length = 0;
+            var padding3 = { [Symbol.iterator]() { return this; },
+              next() { return { done: false, get value() { throw new RangeError('boom'); } }; } };
+            try { Iterator.zip(makeElements(), {mode: 'longest', padding: padding3}); }
+            catch (e) { threw = threw && e instanceof RangeError; }
+            var l3 = JSON.stringify(log);
+            return threw + '|' + l1 + '|' + l2 + '|' + l3;
+          })()",
+    )
+    .unwrap();
+    assert_eq!(
+        to_str(&vm, r),
+        "true|[\"third return\",\"second return\",\"first return\"]|[\"third return\",\"second return\",\"first return\"]|[\"third return\",\"second return\",\"first return\"]",
+        "padding step abrupt (next/done/value): close element iterators in reverse, original wins"
+    );
+}
+
+#[test]
+fn iterator_zip_padding_not_exhausted_close() {
+    // padding 未耗尽收口：正常关 padding 迭代器，关闭骤发逆序关元素迭代器透传。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var log = [];
+            var first = { next() { log.push('unexpected next'); },
+              return() { log.push('first return'); throw new ReferenceError('x'); } };
+            var second = { next() { log.push('unexpected next'); },
+              return() { log.push('second return'); throw new ReferenceError('y'); } };
+            var third = { next() { log.push('unexpected next'); },
+              get return() { log.push('third return'); throw new ReferenceError('z'); } };
+            var padding = { [Symbol.iterator]() { return this; },
+              next() { return {done: false}; },
+              return() { log.push('padding return'); throw new RangeError('boom'); } };
+            var threw = false;
+            try { Iterator.zip([first, second, third], {mode: 'longest', padding}); }
+            catch (e) { threw = e instanceof RangeError; }
+            return threw + '|' + JSON.stringify(log);
+          })()",
+    )
+    .unwrap();
+    assert_eq!(
+        to_str(&vm, r),
+        "true|[\"padding return\",\"third return\",\"second return\",\"first return\"]",
+        "padding not exhausted: normal close, abrupt close passes through element iterators"
+    );
+    // 耗尽：不关 padding 迭代器。
+    let r = eval(
+        &mut vm,
+        "(() => {
+            var rets = 0;
+            var padding = { [Symbol.iterator]() { return this; },
+              next() { if (this.v === undefined) { this.v = 1; return {done: false, value: 'p0'}; } return {done: true}; },
+              return() { rets++; return {done: true}; } };
+            var it = Iterator.zip([[1,2],[3]], {mode: 'longest', padding});
+            var r1 = it.next(); var r2 = it.next();
+            return r1.value[0] === 1 && r1.value[1] === 3 && r2.value[0] === 2 \
+              && r2.value[1] === undefined && rets === 0 && it.next().done === true;
+          })()",
+    )
+    .unwrap();
+    assert!(r.as_bool(), "padding exhausted exactly at iterCount: no close, done landing undefined");
+}