test(oom): cover iterator helper recovery guard

Author: chrisbbreuer

docs/threads/testing.md

@@ -135,10 +135,10 @@ heap-cap witnesses also cover no-GIL `ArrayBuffer` byte-slab recovery while a
 real peer thread is running and publishing roots to the abort-safe parallel
 collector, plus the trace-sensitive async-generator request lock guard that
 keeps allocation-failure recovery out of mutable generator side-store critical
-sections. A separate deferred-generator witness roots a suspended generator and
-checks that no-GIL allocation-failure recovery aborts instead of sweeping while
-parallel tracing has deferred the generator's mutable execution buffers to a
-world-stopped finish.
+sections. Separate deferred-generator and deferred-iterator-helper witnesses
+root suspended/mid-helper state and check that no-GIL allocation-failure
+recovery aborts instead of sweeping while parallel tracing has deferred mutable
+execution/helper buffers to a world-stopped finish.
 
 `zig build threads-test` runs the green WebKit PR-249 allowlist from
 `reference/webkit-249/threads-tests`. CI shards the serialized/GIL leg with

src/context.zig

@@ -12818,6 +12818,76 @@ test "parallel_js heap_limit_bytes fails closed with deferred generator tracing"
     try std.testing.expect(ctx.gc_par_deferred_rounds.load(.monotonic) > before_deferred_rounds);
 }
 
+test "parallel_js heap_limit_bytes fails closed with deferred iterator helper tracing" {
+    // #36 sibling policy witness for Iterator Helper cells. The parallel tracer
+    // defers helper state for the same reason as generators: mutable helper
+    // fields change around callback/source-iterator execution. No-GIL
+    // allocation-failure recovery must therefore abort rather than reporting a
+    // safe sweep while a rooted helper remains deferred.
+    if (builtin.single_threaded) return error.SkipZigTest;
+    const ctx = try Context.createWithTestingOptions(std.testing.allocator, .{
+        .enable_threads = true,
+        .enable_gc = true,
+        .parallel_gc = true,
+        .parallel_js = true,
+        .heap_limit_bytes = 8 * 1024 * 1024,
+    });
+    defer ctx.destroy();
+
+    const prepared = try ctx.evaluate(
+        \\(() => {
+        \\  const source = Iterator.from([1, 2, 3, 4, 5]);
+        \\  globalThis.__deferredRecoveryHelper =
+        \\    source.map(x => ({ value: x + 1 })).filter(o => o.value % 2 === 0);
+        \\  return globalThis.__deferredRecoveryHelper.next().value.value;
+        \\})();
+    );
+    try std.testing.expectEqual(@as(f64, 2), prepared.asNum());
+
+    var sibling: jsthread.ThreadRecord = .{ .id = 999, .gil = ctx.gil.?, .ctx = ctx };
+    {
+        ctx.gil.?.lockApi();
+        defer ctx.gil.?.unlockApi();
+        try ctx.reserveJsThreadsLocked(1);
+        ctx.js_threads.appendAssumeCapacity(&sibling);
+    }
+    defer {
+        ctx.gil.?.lockApi();
+        var i: usize = ctx.js_threads.items.len;
+        while (i > 0) {
+            i -= 1;
+            if (ctx.js_threads.items[i] == &sibling) {
+                _ = ctx.js_threads.swapRemove(i);
+                break;
+            }
+        }
+        ctx.gil.?.unlockApi();
+    }
+
+    const before_attempts = ctx.gc_par_attempts.load(.monotonic);
+    const before_collections = ctx.gc_par_collections.load(.monotonic);
+    const before_aborts = ctx.gc_par_aborts.load(.monotonic);
+    const before_round_aborts = ctx.gc_par_round_limit_aborts.load(.monotonic);
+    const before_deferred_rounds = ctx.gc_par_deferred_rounds.load(.monotonic);
+
+    const gc_saved = gc_mod.setActiveHeap(ctx.gc);
+    defer _ = gc_mod.setActiveHeap(gc_saved);
+    const ss_saved = stack_scan.enter(@frameAddress());
+    defer stack_scan.leave(ss_saved);
+    var machine = ctx.interpreter();
+    try ctx.pushActiveInterpreter(&machine);
+    defer ctx.popActiveInterpreter(&machine);
+    const ai_saved = gc_mod.setActiveInterpreter(&machine);
+    defer _ = gc_mod.setActiveInterpreter(ai_saved);
+
+    try std.testing.expect(!ctx.collectForAllocationFailure(&machine));
+    try std.testing.expect(ctx.gc_par_attempts.load(.monotonic) > before_attempts);
+    try std.testing.expectEqual(before_collections, ctx.gc_par_collections.load(.monotonic));
+    try std.testing.expect(ctx.gc_par_aborts.load(.monotonic) > before_aborts);
+    try std.testing.expect(ctx.gc_par_round_limit_aborts.load(.monotonic) > before_round_aborts);
+    try std.testing.expect(ctx.gc_par_deferred_rounds.load(.monotonic) > before_deferred_rounds);
+}
+
 test "parallel_js (M3): sync wait peers publish roots for mid-script parallel GC" {
     // Sync property waits, Condition waits, and contended Lock acquisition are
     // not frozen `gc_parked` peers: they periodically pump tasks between short