/*
 * Portable portions adapted from Test262 at revision
 * 250f204f23a9249ff204be2baec29600faae7b75. Exact source paths are cited
 * beside the corresponding tests below.
 *
 * Copyright (C) 2013-2017 the V8 project authors. All rights reserved.
 * Copyright (C) 2018 Valerie Young. All rights reserved.
 * Copyright (C) 2020 Alexey Shvayka. All rights reserved.
 * Copyright (C) 2022 Kevin Gibbons. All rights reserved.
 * Copyright Ecma International. All rights reserved.
 * Test262 portions are governed by the BSD license in LICENSE.test262.
 */
import { describe, expect, test } from "bun:test"
import { Effect } from "effect"
import { CodeMode } from "../src/index.js"

const execute = (code: string) => Effect.runPromise(CodeMode.execute({ code, tools: {} }))

const value = async (code: string) => {
  const result = await execute(code)
  if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
  return result.value
}

describe("confined generators", () => {
  // test/built-ins/GeneratorPrototype/next/return-yield-expr.js
  test("is lazy and preserves next(value), nested suspension, return, and exhaustion", async () => {
    expect(
      await value(`
        const events = []
        function* generate() {
          events.push("start")
          const received = yield 1 + (yield 2)
          return received
        }
        const iterator = generate()
        const before = events.slice()
        const first = iterator.next(99)
        const second = iterator.next(3)
        const third = iterator.next(7)
        const fourth = iterator.next(8)
        return [before, events, first, second, third, fourth]
      `),
    ).toEqual([
      [],
      ["start"],
      { value: 2, done: false },
      { value: 4, done: false },
      { value: 7, done: true },
      { value: null, done: true },
    ])
  })

  test("routes throw and return through catch and finally", async () => {
    expect(
      await value(`
        function* generate() {
          try {
            try { yield "try" } catch (error) { yield "caught " + error }
          } finally {
            yield "finally"
          }
        }
        const iterator = generate()
        return [iterator.next(), iterator.throw("boom"), iterator.return("done"), iterator.next()]
      `),
    ).toEqual([
      { value: "try", done: false },
      { value: "caught boom", done: false },
      { value: "finally", done: false },
      { value: "done", done: true },
    ])
  })

  test("throws into a suspended generator and after exhaustion", async () => {
    expect(
      await value(`
        function* generate() { yield 1 }
        const iterator = generate()
        iterator.next()
        let suspended
        let exhausted
        try { iterator.throw("first") } catch (error) { suspended = error }
        try { iterator.throw("second") } catch (error) { exhausted = error }
        return [suspended, exhausted, iterator.next()]
      `),
    ).toEqual(["first", "second", { value: null, done: true }])
  })

  test("rejects synchronous generator reentry", async () => {
    expect(
      await value(`
        let iterator
        function* generate() {
          try { iterator.next() } catch (error) { return error.name }
        }
        iterator = generate()
        return iterator.next()
      `),
    ).toEqual({ value: "TypeError", done: true })
  })

  test("delegates yield*, forwards next values, and receives the delegate return value", async () => {
    expect(
      await value(`
        function* inner() {
          const input = yield 1
          return input * 2
        }
        function* outer() {
          const result = yield* inner()
          return result + 1
        }
        const iterator = outer()
        return [iterator.next(), iterator.next(4)]
      `),
    ).toEqual([
      { value: 1, done: false },
      { value: 9, done: true },
    ])
  })

  test("delegates throw and return to custom iterators", async () => {
    expect(
      await value(`
        const calls = []
        let step = 0
        const delegate = {
          [Symbol.iterator]: () => delegate,
          next(...args) {
            calls.push(["next", args.length, args[0]])
            step += 1
            return step === 1 ? { value: "one", done: false } : { value: "end", done: true }
          },
          throw(value) {
            calls.push(["throw", value])
            return { value: "recovered", done: false }
          },
          return(value) {
            calls.push(["return", value])
            return { value: value + "!", done: true }
          },
        }
        function* generate() { return yield* delegate }
        const iterator = generate()
        const first = iterator.next()
        const second = iterator.throw("x")
        const third = iterator.return("stop")
        return [first, second, third, calls]
      `),
    ).toEqual([
      { value: "one", done: false },
      { value: "recovered", done: false },
      { value: "stop!", done: true },
      [
        ["next", 1, null],
        ["throw", "x"],
        ["return", "stop"],
      ],
    ])
  })

  test("uses the missing-throw delegation path for built-in iterables", async () => {
    expect(
      await value(`
        function* generate() { yield* [1, 2] }
        const iterator = generate()
        iterator.next()
        try { iterator.throw("boom") } catch (error) { return error.name }
      `),
    ).toBe("TypeError")
  })

  test("exposes only the appropriate iterator symbol and works in for...of", async () => {
    expect(
      await value(`
        function* generate() { yield 1; yield 2 }
        const iterator = generate()
        const symbols = [iterator[Symbol.iterator]() === iterator, iterator[Symbol.asyncIterator]]
        const values = []
        for (const item of iterator) values.push(item)
        return [symbols, values]
      `),
    ).toEqual([
      [true, null],
      [1, 2],
    ])
  })

  test("accepts generator methods as iterator acquisition results", async () => {
    expect(
      await value(`
        const sync = {
          *[Symbol.iterator]() { yield 1; yield 2 },
        }
        const asynchronous = {
          async *[Symbol.asyncIterator]() { yield 3; yield 4 },
        }
        const values = []
        for (const item of sync) values.push(item)
        for await (const item of asynchronous) values.push(item)
        return values
      `),
    ).toEqual([1, 2, 3, 4])
  })

  test("closes a generator when for...of exits abruptly", async () => {
    expect(
      await value(`
        const events = []
        function* generate() {
          try { yield 1; yield 2 } finally { events.push("closed") }
        }
        for (const item of generate()) break
        return events
      `),
    ).toEqual(["closed"])
  })

  test("async generator requests are promises and execute in request order", async () => {
    expect(
      await value(`
        const events = []
        async function* generate() {
          events.push("start")
          const input = yield Promise.resolve(1)
          events.push("received " + input)
          return Promise.resolve(3)
        }
        const iterator = generate()
        const first = iterator.next()
        const second = iterator.next(2)
        const third = iterator.next(4)
        const promiseFlags = [first instanceof Promise, second instanceof Promise, third instanceof Promise]
        return [promiseFlags, await Promise.all([first, second, third]), events]
      `),
    ).toEqual([
      [true, true, true],
      [
        { value: 1, done: false },
        { value: 3, done: true },
        { value: null, done: true },
      ],
      ["start", "received 2"],
    ])
  })

  test("keeps requests queued while a completed generator adopts return values", async () => {
    expect(
      await value(`
        const events = []
        let resolve
        const pending = new Promise((done) => { resolve = done })
        async function* generate() { return 1 }
        const iterator = generate()
        const first = iterator.next()
        const returned = iterator.return(pending)
        const later = first.then(() => iterator.next()).then(() => events.push("later"))
        returned.then(() => events.push("returned"))
        await first
        await Promise.resolve()
        const before = events.slice()
        resolve(9)
        await Promise.all([returned, later])
        return [before, events]
      `),
    ).toEqual([[], ["returned", "later"]])
  })

  test("serializes requests made after async generator exhaustion", async () => {
    expect(
      await value(`
        const events = []
        let resolve
        const pending = new Promise((done) => { resolve = done })
        async function* generate() { return 1 }
        const iterator = generate()
        await iterator.next()
        const returned = iterator.return(pending).then(() => events.push("returned"))
        const later = iterator.next().then(() => events.push("later"))
        await Promise.resolve()
        const before = events.slice()
        resolve(9)
        await Promise.all([returned, later])
        return [before, events]
      `),
    ).toEqual([[], ["returned", "later"]])
  })

  test("async generators adopt yielded, returned, and return-request promises", async () => {
    expect(
      await value(`
        async function* yielded() { yield Promise.resolve(1) }
        async function* returned() { return Promise.resolve(2) }
        async function* pending() { yield 0 }
        const first = yielded()
        const second = returned()
        const third = pending()
        const exhausted = returned()
        await third.next()
        await exhausted.next()
        return await Promise.all([
          first.next(),
          second.next(),
          third.return(Promise.resolve(3)),
          exhausted.return(Promise.resolve(4)),
        ])
      `),
    ).toEqual([
      { value: 1, done: false },
      { value: 2, done: true },
      { value: 3, done: true },
      { value: 4, done: true },
    ])
  })

  test("awaits return-request promises before injecting completion", async () => {
    expect(
      await value(`
        const events = []
        async function* generate() {
          try {
            yield 1
          } catch (error) {
            events.push("caught " + error)
            yield "recovered"
          } finally {
            events.push("finally")
          }
        }
        const iterator = generate()
        const first = await iterator.next()
        const returned = await iterator.return(Promise.reject("bad"))
        const beforeNext = events.slice()
        const last = await iterator.next()
        return [first, returned, beforeNext, last, events]
      `),
    ).toEqual([
      { value: 1, done: false },
      { value: "recovered", done: false },
      ["caught bad"],
      { value: null, done: true },
      ["caught bad", "finally"],
    ])
  })

  test("loop consumers call iterator next with no arguments", async () => {
    expect(
      await value(`
        const calls = []
        let syncStep = 0
        const sync = {
          [Symbol.iterator]: () => sync,
          next(...args) {
            calls.push(["sync", args.length])
            syncStep += 1
            return { value: syncStep, done: syncStep > 1 }
          },
        }
        let asyncStep = 0
        const asynchronous = {
          [Symbol.asyncIterator]: () => asynchronous,
          async next(...args) {
            calls.push(["async", args.length])
            asyncStep += 1
            return { value: asyncStep, done: asyncStep > 1 }
          },
        }
        for (const item of sync) {}
        for await (const item of asynchronous) {}
        return calls
      `),
    ).toEqual([
      ["sync", 0],
      ["sync", 0],
      ["async", 0],
      ["async", 0],
    ])
  })

  test("supports async generators in for await...of and keeps them out of for...of", async () => {
    expect(
      await value(`
        async function* generate() { yield 1; yield await Promise.resolve(2) }
        const values = []
        for await (const item of generate()) values.push(item)
        let name
        try { for (const item of generate()) {} } catch (error) { name = error.name }
        return [values, name]
      `),
    ).toEqual([[1, 2], "TypeError"])
  })

  test("keeps generator references opaque at the data boundary", async () => {
    const result = await execute(`function* generate() { yield 1 } return generate()`)
    expect(result.ok).toBe(false)
    if (result.ok) return
    expect(result.error.kind).toBe("InvalidDataValue")
  })

  // test/built-ins/GeneratorPrototype/return/from-state-suspended-start.js
  // test/built-ins/GeneratorPrototype/throw/from-state-suspended-start.js
  // test/built-ins/GeneratorPrototype/return/from-state-completed.js
  // test/built-ins/GeneratorPrototype/throw/from-state-completed.js
  test("honors sync return and throw in suspended-start and completed states", async () => {
    expect(
      await value(`
        const events = []
        function* generate() { events.push("body"); yield 1 }

        const returned = generate()
        const startReturn = returned.return(7)
        const afterReturn = returned.next()

        const thrown = generate()
        let startThrow
        try { thrown.throw("start") } catch (error) { startThrow = error }
        const afterThrow = thrown.next()
        let completedThrow
        try { thrown.throw("completed") } catch (error) { completedThrow = error }

        return [startReturn, afterReturn, startThrow, afterThrow, completedThrow, events]
      `),
    ).toEqual([
      { value: 7, done: true },
      { value: null, done: true },
      "start",
      { value: null, done: true },
      "completed",
      [],
    ])
  })

  // test/built-ins/AsyncGeneratorPrototype/return/return-suspendedStart-promise.js
  // test/built-ins/AsyncGeneratorPrototype/throw/throw-suspendedStart.js
  // test/built-ins/AsyncGeneratorPrototype/return/return-state-completed.js
  // test/built-ins/AsyncGeneratorPrototype/throw/throw-state-completed.js
  test("honors async return and throw in suspended-start and completed states", async () => {
    expect(
      await value(`
        const events = []
        async function* generate() { events.push("body"); yield 1 }

        const returned = generate()
        const startReturn = await returned.return(Promise.resolve(7))
        const afterReturn = await returned.next()

        const thrown = generate()
        let startThrow
        try { await thrown.throw("start") } catch (error) { startThrow = error }
        const afterThrow = await thrown.next()
        let completedThrow
        try { await thrown.throw("completed") } catch (error) { completedThrow = error }

        return [startReturn, afterReturn, startThrow, afterThrow, completedThrow, events]
      `),
    ).toEqual([
      { value: 7, done: true },
      { value: null, done: true },
      "start",
      { value: null, done: true },
      "completed",
      [],
    ])
  })

  // test/built-ins/AsyncGeneratorPrototype/return/return-suspendedYield-try-finally.js
  // test/built-ins/AsyncGeneratorPrototype/return/return-suspendedYield-try-finally-return.js
  // test/built-ins/AsyncGeneratorPrototype/throw/throw-suspendedYield-try-finally-throw.js
  test("runs finally yields and lets finally completions override requests", async () => {
    expect(
      await value(`
        async function* yielding() {
          try { yield 1 } finally { yield 2 }
        }
        async function* returning() {
          try { yield 1 } finally { return "override" }
        }
        async function* throwing() {
          try { yield 1 } finally { throw "override" }
        }

        const first = yielding()
        await first.next()
        const finallyYield = await first.return("sent")
        const preservedReturn = await first.next()

        const second = returning()
        await second.next()
        const overriddenReturn = await second.return("sent")

        const third = throwing()
        await third.next()
        let overriddenThrow
        try { await third.throw("sent") } catch (error) { overriddenThrow = error }
        return [finallyYield, preservedReturn, overriddenReturn, overriddenThrow]
      `),
    ).toEqual([{ value: 2, done: false }, { value: "sent", done: true }, { value: "override", done: true }, "override"])
  })

  // test/language/statements/async-generator/yield-promise-reject-next-catch.js
  // test/language/statements/async-generator/yield-promise-reject-next-yield-star-sync-iterator.js
  test("rejects yielded promises and closes direct and sync-delegating async generators", async () => {
    expect(
      await value(`
        async function* direct() { yield Promise.reject("direct") }
        async function* delegated() { yield* [Promise.reject("delegated"), "unreachable"] }
        const results = []
        for (const iterator of [direct(), delegated()]) {
          try { await iterator.next() } catch (error) { results.push(error) }
          results.push(await iterator.next())
        }
        return results
      `),
    ).toEqual(["direct", { value: null, done: true }, "delegated", { value: null, done: true }])
  })

  // test/built-ins/AsyncFromSyncIteratorPrototype/next/for-await-iterator-next-rejected-promise-close.js
  // test/built-ins/AsyncFromSyncIteratorPrototype/next/yield-iterator-next-rejected-promise-close.js
  // test/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-rejected-promise-close.js
  test("closes sync iterators when async-from-sync values reject", async () => {
    expect(
      await value(`
        const events = []
        function* loopSource() {
          try { yield Promise.reject("loop") } finally { events.push("loop close") }
        }
        let loopError
        try { for await (const item of loopSource()) {} } catch (error) { loopError = error }

        function* yieldSource() {
          try { yield Promise.reject("yield") } finally { events.push("yield close") }
        }
        async function* delegate() { yield* yieldSource() }
        let yieldError
        try { await delegate().next() } catch (error) { yieldError = error }

        const throwing = {
          [Symbol.iterator]: () => throwing,
          next: () => ({ value: 1, done: false }),
          throw: () => ({ value: Promise.reject("throw"), done: false }),
          return: () => { events.push("throw close"); return {} },
        }
        async function* throwDelegate() { yield* throwing }
        const iterator = throwDelegate()
        await iterator.next()
        let throwError
        try { await iterator.throw("sent") } catch (error) { throwError = error }
        return [loopError, yieldError, throwError, events]
      `),
    ).toEqual(["loop", "yield", "throw", ["loop close", "yield close", "throw close"]])
  })

  test("does not close rejected terminal or delegated return values", async () => {
    expect(
      await value(`
        const events = []
        const terminal = {
          [Symbol.iterator]: () => terminal,
          next: () => ({ value: Promise.reject("terminal"), done: true }),
          return: () => { events.push("terminal close"); return {} },
        }
        let terminalError
        try { for await (const item of terminal) {} } catch (error) { terminalError = error }

        let returnCount = 0
        const returned = {
          [Symbol.iterator]: () => returned,
          next: () => ({ value: 1, done: false }),
          return: () => {
            returnCount += 1
            return { value: Promise.reject("return"), done: false }
          },
        }
        async function* delegate() { yield* returned }
        const iterator = delegate()
        await iterator.next()
        let returnError
        try { await iterator.return("sent") } catch (error) { returnError = error }
        return [terminalError, returnError, returnCount, events]
      `),
    ).toEqual(["terminal", "return", 1, []])
  })

  test("serializes a mixed async next, throw, return, and next request queue", async () => {
    expect(
      await value(`
        async function* generate() {
          try {
            try { yield 1; yield 2 } catch (error) { yield "caught " + error }
          } finally {
            yield "finally"
          }
        }
        const iterator = generate()
        const first = iterator.next()
        const thrown = iterator.throw("x")
        const returned = iterator.return("done")
        const last = iterator.next()
        return await Promise.all([first, thrown, returned, last])
      `),
    ).toEqual([
      { value: 1, done: false },
      { value: "caught x", done: false },
      { value: "finally", done: false },
      { value: "done", done: true },
    ])
  })

  // test/built-ins/AsyncGeneratorPrototype/next/request-queue-order.js
  // test/built-ins/AsyncGeneratorPrototype/throw/request-queue-order-state-executing.js
  // test/built-ins/AsyncGeneratorPrototype/return/request-queue-order-state-executing.js
  test("orders async requests enqueued while generators are executing", async () => {
    expect(
      await value(`
        const events = []
        let returned, returnRequest
        async function* returnWhileExecuting() {
          returnRequest = returned.return(42).then((result) => events.push(["return", result]))
          yield 1
        }
        returned = returnWhileExecuting()
        const firstReturn = returned.next().then((result) => events.push(["first return", result]))
        await Promise.all([firstReturn, returnRequest])

        let thrown, throwRequest
        async function* throwWhileExecuting() {
          throwRequest = thrown.throw("boom").catch((error) => events.push(["throw", error]))
          yield 2
        }
        thrown = throwWhileExecuting()
        const firstThrow = thrown.next().then((result) => events.push(["first throw", result]))
        await Promise.all([firstThrow, throwRequest])

        async function* queued() { yield "first"; yield "second" }
        const iterator = queued()
        const first = iterator.next()
        const second = iterator.next()
        const third = iterator.next()
        await Promise.all([
          third.then(() => events.push("third")),
          second.then(() => events.push("second")),
          first.then(() => events.push("first")),
        ])
        return events
      `),
    ).toEqual([
      ["first return", { value: 1, done: false }],
      ["return", { value: 42, done: true }],
      ["first throw", { value: 2, done: false }],
      ["throw", "boom"],
      "first",
      "second",
      "third",
    ])
  })

  // test/language/statements/async-generator/yield-star-promise-not-unwrapped.js
  // test/language/statements/async-generator/yield-star-sync-next.js
  test("preserves async iterator promise values but unwraps async-from-sync values", async () => {
    expect(
      await value(`
        const asyncValue = Promise.resolve("async")
        const asynchronous = {
          [Symbol.asyncIterator]: () => asynchronous,
          next: () => ({ value: asyncValue, done: false }),
        }
        const syncValue = Promise.resolve("sync")
        const synchronous = {
          [Symbol.iterator]: () => synchronous,
          next: () => ({ value: syncValue, done: false }),
        }
        async function* delegate(value) { yield* value }
        const asyncResult = await delegate(asynchronous).next()
        const syncResult = await delegate(synchronous).next()
        return [asyncResult.value === asyncValue, await asyncResult.value, syncResult]
      `),
    ).toEqual([true, "async", { value: "sync", done: false }])
  })

  test("captures delegated result done before awaiting async-from-sync values", async () => {
    expect(
      await value(`
        const result = { value: Promise.resolve(1), done: false }
        result.value.then(() => { result.done = true })
        const source = {
          [Symbol.iterator]: () => source,
          next: () => result,
        }
        async function* delegate() { yield* source }
        return await delegate().next()
      `),
    ).toEqual({ value: 1, done: false })
  })

  // test/language/statements/async-generator/yield-star-async-next.js
  // test/language/statements/async-generator/yield-star-sync-return.js
  // test/language/statements/async-generator/yield-star-async-throw.js
  test("forwards next, return, and throw through sync and async yield delegates", async () => {
    expect(
      await value(`
        const calls = []
        const make = (symbol, label) => {
          let step = 0
          const iterator = {
            [symbol]: () => iterator,
            next(...args) {
              calls.push([label, "next", args.length, args[0]])
              step += 1
              return { value: step, done: false }
            },
            return(value) {
              calls.push([label, "return", value])
              return { value: value + "!", done: true }
            },
            throw(value) {
              calls.push([label, "throw", value])
              return { value: "caught " + value, done: false }
            },
          }
          return iterator
        }
        async function* delegate(iterator) { return yield* iterator }
        const sync = delegate(make(Symbol.iterator, "sync"))
        const asynchronous = delegate(make(Symbol.asyncIterator, "async"))
        const results = [await sync.next(9), await sync.next(2), await sync.throw("x"), await sync.return("stop")]
        results.push(await asynchronous.next(9), await asynchronous.next(3), await asynchronous.throw("y"))
        return [results, calls]
      `),
    ).toEqual([
      [
        { value: 1, done: false },
        { value: 2, done: false },
        { value: "caught x", done: false },
        { value: "stop!", done: true },
        { value: 1, done: false },
        { value: 2, done: false },
        { value: "caught y", done: false },
      ],
      [
        ["sync", "next", 1, null],
        ["sync", "next", 1, 2],
        ["sync", "throw", "x"],
        ["sync", "return", "stop"],
        ["async", "next", 1, null],
        ["async", "next", 1, 3],
        ["async", "throw", "y"],
      ],
    ])
  })

  // test/language/statements/async-generator/yield-star-sync-return.js
  // test/language/statements/async-generator/yield-star-async-throw.js
  test("continues delegation when return and throw report done false", async () => {
    expect(
      await value(`
        let returns = 0
        const synchronous = {
          [Symbol.iterator]: () => synchronous,
          next: () => ({ value: "next", done: false }),
          return(value) {
            returns += 1
            return { value: returns === 1 ? "return pending" : value, done: returns > 1 }
          },
        }
        let throws = 0
        const asynchronous = {
          [Symbol.asyncIterator]: () => asynchronous,
          next: () => ({ value: "next", done: false }),
          throw(value) {
            throws += 1
            return { value: throws === 1 ? "throw pending" : value, done: throws > 1 }
          },
        }
        async function* delegate(iterator) { return yield* iterator }
        const returned = delegate(synchronous)
        const thrown = delegate(asynchronous)
        return [
          await returned.next(),
          await returned.return("first"),
          await returned.return("second"),
          await thrown.next(),
          await thrown.throw("first"),
          await thrown.throw("second"),
        ]
      `),
    ).toEqual([
      { value: "next", done: false },
      { value: "return pending", done: false },
      { value: "second", done: true },
      { value: "next", done: false },
      { value: "throw pending", done: false },
      { value: "second", done: true },
    ])
  })

  // test/language/expressions/yield/star-rhs-iter-nrml-next-call-non-obj.js
  // test/language/expressions/yield/star-rhs-iter-thrw-thrw-call-non-obj.js
  // test/language/expressions/yield/star-rhs-iter-rtrn-rtrn-call-non-obj.js
  // test/language/statements/async-generator/yield-star-next-not-callable-number-throw.js
  test("rejects malformed yield delegate methods and iterator results", async () => {
    expect(
      await value(`
        const run = (iterator, operation) => {
          function* generate() {
            try { yield* iterator } catch (error) { return error.name }
          }
          const value = generate()
          const first = value.next()
          return operation === "next" ? first : value[operation]()
        }
        const iterable = (fields) => ({ [Symbol.iterator]: () => fields })
        const nextResult = run(iterable({ next: () => 1 }), "next")
        const throwResult = run(iterable({ next: () => ({ done: false }), throw: () => 1 }), "throw")
        const returnResult = run(iterable({ next: () => ({ done: false }), return: () => 1 }), "return")

        const badAsync = {
          [Symbol.asyncIterator]: () => ({ next: 1 }),
        }
        async function* asynchronous() {
          try { yield* badAsync } catch (error) { return error.name }
        }
        return [nextResult, throwResult, returnResult, await asynchronous().next()]
      `),
    ).toEqual([
      { value: "TypeError", done: true },
      { value: "TypeError", done: true },
      { value: "TypeError", done: true },
      { value: "TypeError", done: true },
    ])
  })

  // test/language/expressions/yield/captured-free-vars.js
  // test/language/statements/generators/dflt-params-ref-prior.js
  // test/language/expressions/generators/dflt-params-ref-prior.js
  // test/language/expressions/object/method-definition/generator-no-yield.js
  test("supports declaration, expression, and method forms with closures and parameters", async () => {
    expect(
      await value(`
        const captured = 4
        function* declaration(x, y = x, ...rest) { yield captured + y + rest[0] }
        const expression = function* (x, y = x) { yield captured + y }
        const object = { *method({ value }, extra = 1) { return captured + value + extra } }
        return [declaration(2, undefined, 3).next(), expression(5).next(), object.method({ value: 6 }).next()]
      `),
    ).toEqual([
      { value: 9, done: false },
      { value: 9, done: false },
      { value: 11, done: true },
    ])
  })

  // test/language/expressions/assignment/dstr/array-elem-iter-nrml-close.js
  test("steps holes and rest and closes array binding and assignment patterns early", async () => {
    expect(
      await value(`
        const events = []
        function* binding() {
          try { events.push("b1"); yield 1; events.push("b2"); yield 2; events.push("b3"); yield 3; yield 4 }
          finally { events.push("binding close") }
        }
        const [first, , third] = binding()
        function* assignment() {
          try { yield 5; yield 6; yield 7 }
          finally { events.push("assignment close") }
        }
        let head, rest
        ;[head, ...rest] = assignment()
        return [first, third, head, rest, events]
      `),
    ).toEqual([1, 3, 5, [6, 7], ["b1", "b2", "b3", "binding close", "assignment close"]])
  })

  // test/language/statements/variable/dstr/ary-ptrn-elem-id-init-throws.js
  // test/language/expressions/assignment/dstr/array-elem-iter-thrw-close-err.js
  test("closes on destructuring defaults and preserves the binding error over return failure", async () => {
    expect(
      await value(`
        const events = []
        const iterator = {
          [Symbol.iterator]: () => iterator,
          next: () => ({ value: undefined, done: false }),
          return: () => { events.push("close"); throw "close error" },
        }
        let caught
        try {
          const [value = (() => { throw "binding error" })()] = iterator
        } catch (error) { caught = error }
        return [caught, events]
      `),
    ).toEqual(["binding error", ["close"]])
  })

  test("does not close an exhausted iterator when a destructuring default fails", async () => {
    expect(
      await value(`
        const events = []
        const iterator = {
          [Symbol.iterator]: () => iterator,
          next: () => ({ done: true }),
          return: () => { events.push("close"); return {} },
        }
        try { const [item = (() => { throw "default" })()] = iterator } catch {}
        return events
      `),
    ).toEqual([])
  })

  test("consumes generators in array and argument spread without awaiting yielded promises", async () => {
    expect(
      await value(`
        function* values() { yield 1; yield Promise.resolve(2); yield 3 }
        const array = [...values()]
        const args = ((...items) => items)(...values())
        return [array[0], array[1] instanceof Promise, await array[1], args[2]]
      `),
    ).toEqual([1, true, 2, 3])
  })

  test("constructs Map, Set, and URLSearchParams from generators lazily", async () => {
    expect(
      await value(`
        const events = []
        function* pairs() { events.push(1); yield ["a", 1]; events.push(2); yield ["b", 2] }
        function* values() { yield 1; yield 1; yield 2 }
        const map = new Map(pairs())
        const set = new Set(values())
        const params = new URLSearchParams(pairs())
        return [map.get("b"), [...set], params.toString(), events]
      `),
    ).toEqual([2, [1, 2], "a=1&b=2", [1, 2, 1, 2]])
  })

  test("keeps built-in collection iteration live during callbacks", async () => {
    expect(
      await value(`
        const map = new Map([[1, 1], [2, 2]])
        const mapped = Array.from(map, (entry, index) => {
          if (index === 0) map.set(3, 3)
          return entry[0]
        })
        const set = new Set([1, 2])
        const grouped = Map.groupBy(set, (item, index) => {
          if (index === 0) set.add(3)
          return "items"
        })
        return [mapped, grouped.get("items")]
      `),
    ).toEqual([
      [1, 2, 3],
      [1, 2, 3],
    ])
  })

  test("keeps built-in collection iteration live in loops and yield delegation", async () => {
    expect(
      await value(`
        const map = new Map([[1, 1], [2, 2]])
        const mapValues = []
        for (const [key] of map) {
          mapValues.push(key)
          if (key === 1) map.set(3, 3)
        }
        const set = new Set([1, 2])
        const setValues = []
        for await (const item of set) {
          setValues.push(item)
          if (item === 1) set.add(3)
        }
        const params = new URLSearchParams("a=1&b=2")
        function* delegate() { yield* params }
        const iterator = delegate()
        const first = iterator.next()
        params.append("c", "3")
        return [mapValues, setValues, first, iterator.next(), iterator.next()]
      `),
    ).toEqual([
      [1, 2, 3],
      [1, 2, 3],
      { value: ["a", "1"], done: false },
      { value: ["b", "2"], done: false },
      { value: ["c", "3"], done: false },
    ])
  })

  test("preserves async-from-sync turns for built-in loop completion and close", async () => {
    expect(
      await value(`
        const completed = []
        Promise.resolve().then(() => completed.push("reaction"))
        for await (const item of []) {}
        completed.push("after")

        const closed = []
        for await (const item of [1]) {
          Promise.resolve().then(() => closed.push("reaction"))
          break
        }
        closed.push("after")
        return [completed, closed]
      `),
    ).toEqual([
      ["reaction", "after"],
      ["reaction", "after"],
    ])
  })

  test("reads iterator return only when closing", async () => {
    expect(
      await value(`
        const events = []
        const iterator = {
          [Symbol.iterator]: () => iterator,
          next() {
            iterator.return = () => { events.push("new"); return {} }
            return { value: 1, done: false }
          },
          return: () => { events.push("old"); return {} },
        }
        const [item] = iterator
        return [item, events]
      `),
    ).toEqual([1, ["new"]])
  })

  test("accepts iterable URLSearchParams entry pairs", async () => {
    expect(
      await value(`
        function* pair() { yield "a"; yield 1 }
        function* entries() { yield pair() }
        return new URLSearchParams(entries()).toString()
      `),
    ).toBe("a=1")
  })

  test("converts URLSearchParams pair elements before requesting the next", async () => {
    expect(
      await value(`
        const events = []
        function* pair() {
          try {
            events.push("first")
            yield (function* () {})()
            events.push("second")
            yield 2
          } finally { events.push("pair close") }
        }
        function* entries() {
          try { yield pair() } finally { events.push("outer close") }
        }
        let name
        try { new URLSearchParams(entries()) } catch (error) { name = error.name }
        return [events, name]
      `),
    ).toEqual([["first", "pair close", "outer close"], "Error"])
  })

  test("validates URLSearchParams pair lengths after converting the outer sequence", async () => {
    expect(
      await value(`
        const events = []
        function* entries() {
          try {
            events.push("one")
            yield ["a"]
            events.push("two")
            yield ["b", 2]
          } finally { events.push("outer close") }
        }
        let name
        try { new URLSearchParams(entries()) } catch (error) { name = error.name }
        return [events, name]
      `),
    ).toEqual([["one", "two", "outer close"], "TypeError"])
  })

  test("closes entry constructors when a generator yields a malformed entry", async () => {
    expect(
      await value(`
        const events = []
        function* mapEntries() { try { yield ["a", 1]; yield null } finally { events.push("map close") } }
        function* parameterEntries() { try { yield ["a"]; yield ["b", 2] } finally { events.push("params close") } }
        const names = []
        try { new Map(mapEntries()) } catch (error) { names.push(error.name) }
        try { new URLSearchParams(parameterEntries()) } catch (error) { names.push(error.name) }
        return [names, events]
      `),
    ).toEqual([
      ["TypeError", "TypeError"],
      ["map close", "params close"],
    ])
  })

  // test/built-ins/Array/from/iter-map-fn-args.js
  // test/built-ins/Array/from/iter-map-fn-err.js
  test("interleaves Array.from mapping and closes when its mapper fails", async () => {
    expect(
      await value(`
        const events = []
        function* source() {
          try { events.push("next 1"); yield 1; events.push("next 2"); yield 2 }
          finally { events.push("close") }
        }
        const mapped = Array.from(source(), (item) => { events.push("map " + item); return item * 2 })
        let caught
        try { Array.from(source(), (item) => { throw "mapper " + item }) } catch (error) { caught = error }
        return [mapped, caught, events]
      `),
    ).toEqual([[2, 4], "mapper 1", ["next 1", "map 1", "next 2", "map 2", "close", "next 1", "close"]])
  })

  test("reads array-like Array.from values immediately before mapping", async () => {
    expect(
      await value(`
        const source = { 0: 1, 1: 2, length: 2 }
        return Array.from(source, (item, index) => {
          if (index === 0) source[1] = 9
          return item
        })
      `),
    ).toEqual([1, 9])
  })

  test("interleaves Object.groupBy and Map.groupBy callbacks and closes on callback failure", async () => {
    expect(
      await value(`
        const events = []
        function* source() { try { events.push("next"); yield 1; events.push("next"); yield 2 } finally { events.push("close") } }
        const object = Object.groupBy(source(), (item) => { events.push("object " + item); return item % 2 })
        const map = Map.groupBy(source(), (item) => { events.push("map " + item); return item % 2 })
        let caught
        try { Object.groupBy(source(), () => { throw "callback" }) } catch (error) { caught = error }
        return [object, Object.fromEntries(map), caught, events]
      `),
    ).toEqual([
      { 0: [2], 1: [1] },
      { 0: [2], 1: [1] },
      "callback",
      ["next", "object 1", "next", "object 2", "close", "next", "map 1", "next", "map 2", "close", "next", "close"],
    ])
  })

  test("consumes Promise combinator generators in order and observes rejections", async () => {
    expect(
      await value(`
        function* items() { yield Promise.resolve(1); yield Promise.reject("bad"); yield 3 }
        const settled = await Promise.allSettled(items())
        let all, any
        try { await Promise.all(items()) } catch (error) { all = error }
        try { await Promise.any((function* () { yield Promise.reject("a"); yield Promise.reject("b") })()) }
        catch (error) { any = error.errors }
        const race = await Promise.race((function* () { yield 4; yield Promise.resolve(5) })())
        return [settled, all, any, race]
      `),
    ).toEqual([
      [
        { status: "fulfilled", value: 1 },
        { status: "rejected", reason: "bad" },
        { status: "fulfilled", value: 3 },
      ],
      "bad",
      ["a", "b"],
      4,
    ])
  })

  test("finishes Promise combinator iterator consumption before returning the promise", async () => {
    expect(
      await value(`
        const events = []
        function* items() { events.push("first"); yield 1; events.push("second"); yield 2 }
        const promise = Promise.all(items())
        events.push("after call")
        await promise
        return events
      `),
    ).toEqual(["first", "second", "after call"])
  })

  // test/built-ins/Object/fromEntries/iterator-closed-for-null-entry.js
  test("closes Object.fromEntries on malformed entries and consumes valid generators", async () => {
    expect(
      await value(`
        const events = []
        function* valid() { yield ["a", 1]; yield ["b", 2] }
        function* invalid() { try { yield ["a", 1]; yield null; yield ["c", 3] } finally { events.push("close") } }
        let name
        try { Object.fromEntries(invalid()) } catch (error) { name = error.name }
        return [Object.fromEntries(valid()), name, events]
      `),
    ).toEqual([{ a: 1, b: 2 }, "TypeError", ["close"]])
  })

  test("consumes AggregateError and Math.sumPrecise generators and closes on invalid numbers", async () => {
    expect(
      await value(`
        const events = []
        function* errors() { yield "a"; yield "b" }
        function* numbers() { yield 1e30; yield 0.1; yield -1e30 }
        function* invalid() { try { yield 1; yield "bad"; yield 2 } finally { events.push("close") } }
        const aggregate = new AggregateError(errors(), "message")
        let name
        try { Math.sumPrecise(invalid()) } catch (error) { name = error.name }
        return [aggregate.errors, aggregate.message, Math.sumPrecise(numbers()), name, events]
      `),
    ).toEqual([["a", "b"], "message", 0.1, "TypeError", ["close"]])
  })

  test("rejects async generators in every synchronous iterable consumer", async () => {
    expect(
      await value(`
        async function* source() { yield ["a", 1] }
        const checks = [
          () => [...source()],
          () => ((...items) => items)(...source()),
          () => { const [item] = source(); return item },
          () => Array.from(source()),
          () => new Map(source()),
          () => new Set(source()),
          () => new URLSearchParams(source()),
          () => Object.fromEntries(source()),
          () => Object.groupBy(source(), (item) => item),
          () => Math.sumPrecise(source()),
          () => new AggregateError(source()),
        ]
        const names = []
        for (const check of checks) {
          try { check() } catch (error) { names.push(error.name) }
        }
        try { await Promise.all(source()) } catch (error) { names.push(error.name) }
        return names
      `),
    ).toEqual(Array(12).fill("TypeError"))
  })

  // test/built-ins/Array/from/iter-get-iter-err.js
  // test/built-ins/Array/from/iter-adv-err.js
  test("does not close when iterator acquisition or next-result validation fails", async () => {
    expect(
      await value(`
        const events = []
        const acquisition = { [Symbol.iterator]: () => { events.push("acquire"); throw "acquisition" } }
        const malformed = {
          [Symbol.iterator]: () => malformed,
          next: () => { events.push("next"); return 1 },
          return: () => { events.push("close"); return {} },
        }
        for (const source of [acquisition, malformed]) {
          try { Array.from(source) } catch {}
        }
        return events
      `),
    ).toEqual(["acquire", "next"])
  })

  test("reports synchronous iterator failures before queued promise reactions", async () => {
    expect(
      await value(`
        const events = []
        Promise.resolve().then(() => events.push("reaction"))
        const iterator = {
          [Symbol.iterator]: () => iterator,
          next: () => { throw "next" },
        }
        try { Array.from(iterator) } catch { events.push("catch") }
        await Promise.resolve()
        return events
      `),
    ).toEqual(["catch", "reaction"])
  })
})