Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

171 KB
Raw Blame
use super::*;

#[test]
fn stream_dictionary_arguments_preserve_required_members_and_staged_strategy_validation() {
    let mut vm = new_parsed_test_vm(
        "https://stream-dictionary-args.test/",
        "<!doctype html><body><iframe id=child></iframe></body>",
    );
    let result = vm.eval(r#"
        (() => {
          const assert = (ok, message) => { if (!ok) throw new Error(message); };
          const child = document.getElementById('child').contentWindow;
          const marker = {};
          for (const realm of [window, child]) {
            for (const C of [realm.CountQueuingStrategy, realm.ByteLengthQueuingStrategy]) {
              for (const args of [[], [undefined], [null], [{}], [{highWaterMark: undefined}]]) {
                let error;
                try { new C(...args); } catch (caught) {error = caught;}
                assert(error instanceof realm.TypeError, 'required highWaterMark in callee realm');
              }
              for (const highWaterMark of [NaN, Infinity, -1, 0]) {
                assert(Object.is(new C({highWaterMark}).highWaterMark, highWaterMark), 'unrestricted highWaterMark');
              }
              let reads = 0;
              const strategy = new C({
                get highWaterMark() {reads++; return {valueOf() {reads++; return 2;}};},
                get size() {throw 'size must not be read';}
              });
              assert(strategy.highWaterMark === 2 && reads === 2, 'one member read and one conversion');
              let error;
              try {new C({highWaterMark: {valueOf() {throw marker;}}});} catch (caught) {error = caught;}
              assert(error === marker, 'numeric exception identity');
            }
            const reads = [];
            let error;
            try {
              new realm.TransformStream({
                get start() {reads.push('transformer');}
              }, {
                get highWaterMark() {reads.push('writable.highWaterMark'); return -1;},
                get size() {reads.push('writable.size');}
              }, {
                get highWaterMark() {reads.push('readable.highWaterMark'); return 0;}
              });
            } catch (caught) {error = caught;}
            assert(error instanceof realm.RangeError, 'strategy validation realm');
            assert(reads.join() === 'writable.highWaterMark,writable.size', 'stop before readable strategy and transformer: ' + reads);
          }
          return 'ok';
        })()
    "#).unwrap();
    assert_eq!(result, "ok");
}

mod compression;
mod intrinsic_promises;
mod transform_finish;

fn stream_test_vm() -> StandaloneScriptVmHarness {
    new_storage_test_vm("https://stream-runtime.test/")
}

#[test]
fn stream_constructor_dictionaries_follow_webidl_order_and_callback_conversion() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
JSON.stringify((() => {
  const reads = [];
  const calls = [];
  const receivers = [];
  const dictionary = (prefix, keys, values) => {
    const object = {};
    for (const key of keys) {
      Object.defineProperty(object, key, {
        get() {
          reads.push(`${prefix}.${key}`);
          return values[key];
        }
      });
    }
    return object;
  };
  const callback = (label, body = () => {}) => new Proxy(
    function(...args) {
      receivers.push(this === objects[label]);
      body(...args);
    },
    {
      apply(target, receiver, args) {
        calls.push(label);
        return Reflect.apply(target, receiver, args);
      }
    }
  );
  const objects = {};

  objects.readable = dictionary(
    "readable",
    ["autoAllocateChunkSize", "cancel", "pull", "start", "type"],
    {
      autoAllocateChunkSize: undefined,
      cancel: undefined,
      pull: undefined,
      start: callback("readable", controller => controller.close()),
      type: undefined
    }
  );
  const readableStrategy = dictionary(
    "readableStrategy",
    ["highWaterMark", "size"],
    { highWaterMark: 1, size: undefined }
  );
  new ReadableStream(objects.readable, readableStrategy);

  objects.writable = dictionary(
    "writable",
    ["abort", "close", "start", "type", "write"],
    {
      abort: undefined,
      close: undefined,
      start: callback("writable"),
      type: undefined,
      write: undefined
    }
  );
  const writableStrategy = dictionary(
    "writableStrategy",
    ["highWaterMark", "size"],
    { highWaterMark: 1, size: undefined }
  );
  new WritableStream(objects.writable, writableStrategy);

  objects.transform = dictionary(
    "transform",
    ["cancel", "flush", "readableType", "start", "transform", "writableType"],
    {
      cancel: undefined,
      flush: undefined,
      readableType: undefined,
      start: callback("transform"),
      transform: undefined,
      writableType: undefined
    }
  );
  const transformWritableStrategy = dictionary(
    "transformWritableStrategy",
    ["highWaterMark", "size"],
    { highWaterMark: 1, size: undefined }
  );
  const transformReadableStrategy = dictionary(
    "transformReadableStrategy",
    ["highWaterMark", "size"],
    { highWaterMark: 0, size: undefined }
  );
  new TransformStream(
    objects.transform,
    transformWritableStrategy,
    transformReadableStrategy
  );

  const marker = new Error("dictionary getter");
  const abruptReads = [];
  const abrupt = {};
  for (const key of ["abort", "close", "start", "type", "write"]) {
    Object.defineProperty(abrupt, key, {
      get() {
        abruptReads.push(key);
        if (key === "start") {
          throw marker;
        }
        return undefined;
      }
    });
  }
  let abruptIdentity = false;
  try {
    new WritableStream(abrupt, {
      get highWaterMark() {
        abruptReads.push("strategy");
        return 1;
      }
    });
  } catch (error) {
    abruptIdentity = error === marker;
  }

  let nullMemberError = "none";
  try {
    new WritableStream({ write: null });
  } catch (error) {
    nullMemberError = error && error.name;
  }

  const revoked = Proxy.revocable(function() {}, {});
  revoked.revoke();
  let revokedAccepted = true;
  try {
    new WritableStream({ write: revoked.proxy });
  } catch {
    revokedAccepted = false;
  }

  return {
    reads,
    calls,
    receivers,
    abruptReads,
    abruptIdentity,
    nullMemberError,
    revokedAccepted
  };
})())
"#,
        )
        .expect("Streams Web IDL dictionary conversion should evaluate");

    assert_eq!(
        result,
        r#"{"reads":["readableStrategy.highWaterMark","readableStrategy.size","readable.autoAllocateChunkSize","readable.cancel","readable.pull","readable.start","readable.type","writableStrategy.highWaterMark","writableStrategy.size","writable.abort","writable.close","writable.start","writable.type","writable.write","transformWritableStrategy.highWaterMark","transformWritableStrategy.size","transformReadableStrategy.highWaterMark","transformReadableStrategy.size","transform.cancel","transform.flush","transform.readableType","transform.start","transform.transform","transform.writableType"],"calls":["readable","writable","transform"],"receivers":[true,true,true],"abruptReads":["strategy","abort","close","start"],"abruptIdentity":true,"nullMemberError":"TypeError","revokedAccepted":true}"#
    );
}

#[test]
fn stream_webidl_algorithms_preserve_receivers_controllers_and_promise_results() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__streamWebIdlFacts = [];
  globalThis.__streamWebIdlEvents = [];
  const facts = globalThis.__streamWebIdlFacts;
  const events = globalThis.__streamWebIdlEvents;

  let sourceController;
  const source = {
    start(controller) {
      sourceController = controller;
      controller.enqueue("readable");
      controller.close();
    }
  };
  const readable = new ReadableStream(source, {
    highWaterMark: 3,
    size: new Proxy(
      function(chunk) {
        "use strict";
        facts.push({
          name: "size",
          receiver: this === undefined,
          chunk,
          argumentCount: arguments.length
        });
        return {
          valueOf() {
            events.push("size:valueOf");
            return 2;
          }
        };
      },
      {
        apply(target, receiver, args) {
          events.push(`size:apply:${receiver === undefined}`);
          return Reflect.apply(target, receiver, args);
        }
      }
    )
  });
  readable.getReader().read().then(result => {
    events.push(`readable:${result.value}`);
  });

  let sinkController;
  const sink = {
    start(controller) {
      sinkController = controller;
      facts.push({
        name: "sink-start",
        receiver: this === sink,
        argumentCount: arguments.length
      });
    },
    write(chunk, controller) {
      facts.push({
        name: "sink-write",
        receiver: this === sink,
        controller: controller === sinkController,
        chunk,
        argumentCount: arguments.length
      });
      return {
        then(resolve) {
          events.push("sink:thenable");
          resolve();
        }
      };
    }
  };
  new WritableStream(sink).getWriter().write("writable").then(() => {
    events.push("sink:fulfilled");
  });

  let transformController;
  const transformer = {
    start(controller) {
      transformController = controller;
      facts.push({
        name: "transform-start",
        receiver: this === transformer,
        argumentCount: arguments.length
      });
    },
    transform(chunk, controller) {
      facts.push({
        name: "transform",
        receiver: this === transformer,
        controller: controller === transformController,
        chunk,
        argumentCount: arguments.length
      });
      controller.enqueue(`${chunk}!`);
      return {
        then(resolve) {
          events.push("transform:thenable");
          resolve();
        }
      };
    }
  };
  const transformed = new TransformStream(
    transformer,
    undefined,
    { highWaterMark: 1 }
  );
  transformed.readable.getReader().read().then(result => {
    events.push(`transform:read:${result.value}`);
  });
  transformed.writable.getWriter().write("chunk").then(() => {
    events.push("transform:fulfilled");
  });

  const marker = new Error("sink write marker");
  new WritableStream({
    write() {
      throw marker;
    }
  }).getWriter().write("throw").then(
    () => events.push("throw:fulfilled"),
    error => events.push(`throw:${error === marker}`)
  );
})()
"#,
    )
    .expect("Streams Web IDL callback semantics should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__streamWebIdlEvents)")
            .expect("Streams Web IDL callback promises should drain");
        if events.contains("transform:fulfilled")
            && events.contains("sink:fulfilled")
            && events.contains("throw:true")
        {
            break;
        }
    }

    let result = vm
        .eval(
            r#"
JSON.stringify({
  facts: globalThis.__streamWebIdlFacts,
  observations: {
    sizeProxyAppliedWithUndefinedReceiver:
      __streamWebIdlEvents.includes("size:apply:true"),
    sizeResultConvertedToNumber:
      __streamWebIdlEvents.includes("size:valueOf"),
    readableChunkDelivered:
      __streamWebIdlEvents.includes("readable:readable"),
    transformedChunkDelivered:
      __streamWebIdlEvents.includes("transform:read:chunk!"),
    thrownReasonPreserved:
      __streamWebIdlEvents.includes("throw:true"),
    sinkThenableBeforeFulfilled:
      __streamWebIdlEvents.indexOf("sink:thenable") <
      __streamWebIdlEvents.indexOf("sink:fulfilled"),
    transformThenableBeforeFulfilled:
      __streamWebIdlEvents.indexOf("transform:thenable") <
      __streamWebIdlEvents.indexOf("transform:fulfilled")
  }
})
"#,
        )
        .expect("Streams Web IDL callback results should evaluate");

    assert_eq!(
        result,
        r#"{"facts":[{"name":"size","receiver":true,"chunk":"readable","argumentCount":1},{"name":"sink-start","receiver":true,"argumentCount":1},{"name":"transform-start","receiver":true,"argumentCount":1},{"name":"sink-write","receiver":true,"controller":true,"chunk":"writable","argumentCount":2},{"name":"transform","receiver":true,"controller":true,"chunk":"chunk","argumentCount":2}],"observations":{"sizeProxyAppliedWithUndefinedReceiver":true,"sizeResultConvertedToNumber":true,"readableChunkDelivered":true,"transformedChunkDelivered":true,"thrownReasonPreserved":true,"sinkThenableBeforeFulfilled":true,"transformThenableBeforeFulfilled":true}}"#
    );
}

#[test]
fn transform_stream_cancel_callback_uses_one_shared_terminal_residence() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__transformCancelCallbackEvents = [];
  const events = globalThis.__transformCancelCallbackEvents;

  const readableReason = new Error("readable reason");
  const readableTransformer = {
    cancel(reason) {
      events.push(`readable:${this === readableTransformer}:${reason === readableReason}`);
      return {
        then(resolve) {
          events.push("readable:thenable");
          resolve();
        }
      };
    }
  };
  new TransformStream(readableTransformer).readable.cancel(readableReason).then(
    () => events.push("readable:fulfilled"),
    error => events.push(`readable:rejected:${error && error.name}`)
  );

  const abortReason = new Error("abort reason");
  const abortTransformer = {
    cancel(reason) {
      events.push(`abort:${this === abortTransformer}:${reason === abortReason}`);
    },
    flush() {
      events.push("abort:unexpected-flush");
    }
  };
  new TransformStream(abortTransformer).writable.abort(abortReason).then(
    () => events.push("abort:fulfilled"),
    error => events.push(`abort:rejected:${error && error.name}`)
  );

  const nestedCancelReason = new Error("nested cancel");
  const nestedAbortReason = new Error("nested abort");
  let nestedCalls = 0;
  let nestedAbortPromise;
  let nested;
  nested = new TransformStream({
    cancel(reason) {
      events.push(`nested:${++nestedCalls}:${reason === nestedCancelReason}`);
      nestedAbortPromise = nested.writable.abort(nestedAbortReason);
    },
    flush() {
      events.push("nested:unexpected-flush");
    }
  });
  const nestedCancelPromise = nested.readable.cancel(nestedCancelReason);
  nested.writable.getWriter().closed.catch(error => {
    events.push(`nested:closed:${error === nestedAbortReason}`);
  });
  Promise.allSettled([nestedCancelPromise, nestedAbortPromise]).then(results => {
    events.push(
      `nested:settled:${nestedCalls}:${results[0].status}:${results[1].status}`
    );
  });
})()
"#,
    )
    .expect("TransformStream cancel callback setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__transformCancelCallbackEvents)")
            .expect("TransformStream cancel callback promises should drain");
        if events.contains("nested:settled") {
            break;
        }
    }

    assert_eq!(
        vm.eval(
            r#"
JSON.stringify({
  readableCallback:
    __transformCancelCallbackEvents.includes("readable:true:true"),
  readableThenableAssimilated:
    __transformCancelCallbackEvents.indexOf("readable:thenable") <
    __transformCancelCallbackEvents.indexOf("readable:fulfilled"),
  abortCallback:
    __transformCancelCallbackEvents.includes("abort:true:true"),
  abortFulfilled:
    __transformCancelCallbackEvents.includes("abort:fulfilled"),
  nestedSharedFinish:
    __transformCancelCallbackEvents.includes("nested:settled:1:fulfilled:fulfilled") &&
    __transformCancelCallbackEvents.includes("nested:closed:true"),
  unexpectedFlush:
    __transformCancelCallbackEvents.some(event =>
      event.includes("unexpected-flush")
    )
})
"#
        )
        .expect("TransformStream cancel callback results should evaluate"),
        r#"{"readableCallback":true,"readableThenableAssimilated":true,"abortCallback":true,"abortFulfilled":true,"nestedSharedFinish":true,"unexpectedFlush":false}"#
    );
}

#[test]
fn stream_webidl_callbacks_use_and_retire_with_the_exact_callback_realm() {
    let mut vm = stream_test_vm();
    vm.eval(
        r#"
(() => {
  const root =
    document.documentElement ||
    document.appendChild(document.createElement("html"));
  const body = document.body || root.appendChild(document.createElement("body"));
  const frame = document.createElement("iframe");
  body.appendChild(frame);
  globalThis.__streamCallbackFrame = frame;
})()
"#,
    )
    .expect("Streams callback child Realm setup should evaluate");
    materialize_single_child_default_realm_for_test(&mut vm, "Streams callback child Realm setup");

    vm.eval(
        r#"
(() => {
  const frame = __streamCallbackFrame;
  const child = frame.contentWindow;
  globalThis.__streamCallbackChild = child;
  globalThis.__streamCallbackRealmEvents = [];

  const source = {};
  source.pull = child.Function(
    "source",
    `return function(controller) {
      parent.__streamCallbackRealmEvents.push({
        callbackRealm: globalThis === parent.__streamCallbackChild,
        receiver: this === source,
        controllerRealm:
          Object.getPrototypeOf(controller).constructor ===
          parent.ReadableStreamDefaultController,
        argumentCount: arguments.length
      });
      controller.close();
    };`
  )(source);
  new ReadableStream(source).getReader().read();

  let releaseStart;
  const startGate = new Promise(resolve => {
    releaseStart = resolve;
  });
  const retiredSource = {
    start() {
      return startGate;
    },
    pull: child.Function(
      `parent.__streamCallbackRealmEvents.push("retired-callback-ran");`
    )
  };
  const retiredRead = new ReadableStream(retiredSource).getReader().read();
  retiredRead.then(
    () => __streamCallbackRealmEvents.push("retired:fulfilled"),
    error => __streamCallbackRealmEvents.push(`retired:${error && error.name}`)
  );
  // The implicit start result of the first stream is promise-resolved. Retire
  // the child Realm only after that normal pull has had its start reaction,
  // so this test keeps the successful and retired callback cases independent.
  Promise.resolve().then(() => {
    frame.remove();
    releaseStart();
  });
})()
"#,
    )
    .expect("Streams callback Realm/retirement setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__streamCallbackRealmEvents)")
            .expect("Streams callback Realm/retirement promises should drain");
        if events.contains("retired:TypeError") {
            break;
        }
    }

    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__streamCallbackRealmEvents)")
            .expect("Streams callback Realm/retirement results should evaluate"),
        r#"[{"callbackRealm":true,"receiver":true,"controllerRealm":true,"argumentCount":1},"retired:TypeError"]"#
    );
}

#[test]
fn writable_stream_writer_release_lock_rejects_ready_closed_and_operations() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writerReleaseResults = [];
  const writable = new WritableStream();
  const writer = writable.getWriter();
  writer.releaseLock();
  try {
    void writer.desiredSize;
    globalThis.__writerReleaseResults.push("desired:missing");
  } catch (error) {
    globalThis.__writerReleaseResults.push(`desired:${error.name}`);
  }
  writer.closed.then(
    () => globalThis.__writerReleaseResults.push("closed:fulfilled"),
    error => {
      globalThis.__writerReleaseError = error;
      globalThis.__writerReleaseResults.push(`closed:${error.name}`);
    }
  );
  writer.ready.then(
    () => globalThis.__writerReleaseResults.push("ready:fulfilled"),
    error => globalThis.__writerReleaseResults.push(
      `ready:${error.name}:${error === globalThis.__writerReleaseError}`
    )
  );
  writer.write("x").then(
    () => globalThis.__writerReleaseResults.push("write:fulfilled"),
    error => globalThis.__writerReleaseResults.push(`write:${error.name}`)
  );
  writer.close().then(
    () => globalThis.__writerReleaseResults.push("close:fulfilled"),
    error => globalThis.__writerReleaseResults.push(`close:${error.name}`)
  );
  writer.abort().then(
    () => globalThis.__writerReleaseResults.push("abort:fulfilled"),
    error => globalThis.__writerReleaseResults.push(`abort:${error.name}`)
  );
})()
"#,
    )
    .expect("writable writer releaseLock setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("JSON.stringify(globalThis.__writerReleaseResults.sort())")
            .expect("writable writer releaseLock promises should drain");
        if result.contains("write:TypeError") && result.contains("ready:TypeError:true") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__writerReleaseResults.sort())")
        .expect("writable writer releaseLock results should evaluate");
    assert_eq!(
        result,
        r#"["abort:TypeError","close:TypeError","closed:TypeError","desired:TypeError","ready:TypeError:true","write:TypeError"]"#
    );
}

#[test]
fn writable_stream_writer_desired_size_reflects_closing_and_errored_state() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
JSON.stringify((() => {
  const closingWriter = new WritableStream().getWriter();
  closingWriter.close();
  const errored = new WritableStream({
    start(controller) {
      controller.error(new Error("boom"));
    }
  }).getWriter();
  return {
    closing: closingWriter.desiredSize,
    errored: errored.desiredSize
  };
})())
"#,
        )
        .expect("writable writer desiredSize states should evaluate");

    assert_eq!(result, r#"{"closing":1,"errored":null}"#);
}

#[test]
fn writable_stream_ready_residence_is_created_for_observable_backpressure() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableReadyResidenceResult = "pending";
  let resolveWrite;
  let reportWriteStarted;
  const writeStarted = new Promise(resolve => { reportWriteStarted = resolve; });
  const writable = new WritableStream({
    write() {
      reportWriteStarted();
      return new Promise(resolve => { resolveWrite = resolve; });
    }
  }, new CountQueuingStrategy({ highWaterMark: 1 }));
  const writer = writable.getWriter();
  const before = writer.ready;
  const write = writer.write("chunk");
  const during1 = writer.ready;
  const during2 = writer.ready;
  let readySettled = false;
  during1.then(() => { readySettled = true; });

  Promise.resolve().then(async () => {
    const pendingBeforeSinkSettlement = !readySettled;
    await writeStarted;
    resolveWrite();
    await Promise.all([write, during1]);
    globalThis.__writableReadyResidenceResult = JSON.stringify({
      replacedResolvedPromise: before !== during1,
      stableWhileBackpressured: during1 === during2,
      pendingBeforeSinkSettlement,
      settledAfterWrite: readySettled,
      desiredSize: writer.desiredSize
    });
  }).catch(error => {
    globalThis.__writableReadyResidenceResult =
      `error:${error && error.name}:${error && error.message}`;
  });
})()
"#,
    )
    .expect("writable ready residence setup should evaluate");

    for _ in 0..16 {
        let result = vm
            .eval("globalThis.__writableReadyResidenceResult")
            .expect("writable ready residence should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__writableReadyResidenceResult")
        .expect("writable ready residence result should evaluate");
    assert_eq!(
        result,
        r#"{"replacedResolvedPromise":true,"stableWhileBackpressured":true,"pendingBeforeSinkSettlement":true,"settledAfterWrite":true,"desiredSize":1}"#
    );
}

#[test]
fn writable_stream_queue_total_uses_incremental_double_arithmetic() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableQueueTotalResult = "pending";
  const failures = [];
  const check = (label, actual, expected) => {
    if (!Object.is(actual, expected)) {
      failures.push({ label, actual, expected });
    }
  };
  const setup = () => new WritableStream({}, {
    size(chunk) {
      return chunk;
    },
    highWaterMark: 0
  }).getWriter();

  (async () => {
    {
      const writer = setup();
      const writes = [writer.write(2), writer.write(Number.MAX_SAFE_INTEGER)];
      check("large/queued", writer.desiredSize, 0 - 2 - Number.MAX_SAFE_INTEGER);
      await Promise.all(writes);
      check("large/settled", writer.desiredSize, 0);
    }

    {
      const writer = setup();
      const writes = [writer.write(1e-16), writer.write(1)];
      check("tiny-clamp/queued", writer.desiredSize, 0 - 1e-16 - 1);
      await Promise.all(writes);
      check("tiny-clamp/settled", writer.desiredSize, 0);
    }

    {
      const writer = setup();
      const writes = [writer.write(1e-16), writer.write(1), writer.write(2e-16)];
      check("tiny-positive/queued", writer.desiredSize, 0 - 1e-16 - 1 - 2e-16);
      await Promise.all(writes);
      check(
        "tiny-positive/settled",
        writer.desiredSize,
        0 - 1e-16 - 1 - 2e-16 + 1e-16 + 1 + 2e-16
      );
    }

    {
      const writer = setup();
      const writes = [writer.write(2e-16), writer.write(1)];
      check("tiny-zero/queued", writer.desiredSize, 0 - 2e-16 - 1);
      await Promise.all(writes);
      check("tiny-zero/settled", writer.desiredSize, 0 - 2e-16 - 1 + 2e-16 + 1);
    }

    globalThis.__writableQueueTotalResult = JSON.stringify(failures);
  })().catch(error => {
    globalThis.__writableQueueTotalResult =
      `error:${error && error.name}:${error && error.message}`;
  });
})()
"#,
    )
    .expect("WritableStream floating-point queue total setup should evaluate");

    for _ in 0..24 {
        let result = vm
            .eval("globalThis.__writableQueueTotalResult")
            .expect("WritableStream floating-point queue total should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__writableQueueTotalResult")
        .expect("WritableStream floating-point queue total result should evaluate");
    assert_eq!(result, "[]");
}

#[test]
fn writable_stream_reentrant_strategy_preserves_nested_write_order() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableReentrantWriteResult = "pending";
  const events = [];
  let writer;
  const writable = new WritableStream({
    write(chunk) {
      events.push(`sink.write:${chunk}`);
    }
  }, {
    size(chunk) {
      events.push(`size:${chunk}`);
      if (chunk > 0) {
        writer.write(chunk - 1).then(
          () => events.push(`writer.write done:${chunk - 1}`),
          error => events.push(`writer.write error:${chunk - 1}:${error && error.name}`)
        );
      }
      return chunk;
    }
  });
  writer = writable.getWriter();
  writer.write(2).then(
    () => {
      events.push("writer.write done:2");
      globalThis.__writableReentrantWriteResult = JSON.stringify(events);
    },
    error => {
      globalThis.__writableReentrantWriteResult =
        `error:${error && error.name}:${error && error.message}`;
    }
  );
})()
"#,
    )
    .expect("WritableStream reentrant write setup should evaluate");

    for _ in 0..24 {
        let result = vm
            .eval("globalThis.__writableReentrantWriteResult")
            .expect("WritableStream reentrant writes should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__writableReentrantWriteResult")
        .expect("WritableStream reentrant write result should evaluate");
    assert_eq!(
        result,
        r#"["size:2","size:1","size:0","sink.write:0","sink.write:1","writer.write done:0","sink.write:2","writer.write done:1","writer.write done:2"]"#
    );
}

#[test]
fn writable_stream_reentrant_strategy_honors_error_close_and_abort() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableReentrantTerminalResult = "pending";
  const error1 = { name: "error1" };

  (async () => {
    const errorCase = await (async () => {
      const order = [];
      const sink = [];
      let controller;
      const writable = new WritableStream({
        start(value) {
          controller = value;
        },
        write() {
          sink.push("write");
        }
      }, {
        size() {
          controller.error(error1);
          return 1;
        }
      });
      const writer = writable.getWriter();
      const ready1 = writer.ready.then(
        () => order.push("ready1"),
        error => order.push(`ready1-error:${error === error1}`)
      );
      const write = writer.write("a").then(
        () => order.push("write-fulfilled"),
        error => order.push(`write:${error === error1}`)
      );
      const ready2 = writer.ready.then(
        () => order.push("ready2-fulfilled"),
        error => order.push(`ready2:${error === error1}`)
      );
      const closed = writer.closed.then(
        () => order.push("closed-fulfilled"),
        error => order.push(`closed:${error === error1}`)
      );
      await Promise.all([ready1, write, ready2, closed]);
      return { order, sink };
    })();

    const closeCase = await (async () => {
      const sink = [];
      let writer;
      let closePromise;
      const writable = new WritableStream({
        write() {
          sink.push("write");
        },
        close() {
          sink.push("close");
        }
      }, {
        size() {
          closePromise = writer.close();
          return 1;
        }
      });
      writer = writable.getWriter();
      const write = writer.write("a").then(
        () => "fulfilled",
        error => error && error.name
      );
      const [writeResult] = await Promise.all([write, closePromise]);
      return { writeResult, sink };
    })();

    const abortCase = await (async () => {
      const sink = [];
      let writer;
      let abortPromise;
      const writable = new WritableStream({
        write() {
          sink.push("write");
        },
        abort(reason) {
          sink.push(`abort:${reason === error1}`);
        }
      }, {
        size() {
          abortPromise = writer.abort(error1);
          return 1;
        }
      });
      writer = writable.getWriter();
      const write = writer.write("a").then(
        () => "fulfilled",
        error => `rejected:${error === error1}`
      );
      const [writeResult] = await Promise.all([write, abortPromise]);
      return { writeResult, sink };
    })();

    globalThis.__writableReentrantTerminalResult = JSON.stringify({
      errorCase,
      closeCase,
      abortCase
    });
  })().catch(error => {
    globalThis.__writableReentrantTerminalResult =
      `error:${error && error.name}:${error && error.message}`;
  });
})()
"#,
    )
    .expect("WritableStream reentrant terminal setup should evaluate");

    for _ in 0..32 {
        let result = vm
            .eval("globalThis.__writableReentrantTerminalResult")
            .expect("WritableStream reentrant terminal operations should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__writableReentrantTerminalResult")
        .expect("WritableStream reentrant terminal result should evaluate");
    assert_eq!(
        result,
        r#"{"errorCase":{"order":["ready1","write:true","ready2:true","closed:true"],"sink":[]},"closeCase":{"writeResult":"TypeError","sink":["close"]},"abortCase":{"writeResult":"rejected:true","sink":["abort:true"]}}"#
    );
}

#[test]
fn writable_stream_reentrant_strategy_release_revalidates_writer_ownership() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableReentrantReleaseResult = "pending";

  (async () => {
    const released = await (async () => {
      const sink = [];
      let writer;
      const writable = new WritableStream({
        write() {
          sink.push("write");
        }
      }, {
        size() {
          writer.releaseLock();
          return 1;
        }
      });
      writer = writable.getWriter();
      const write = writer.write("a").then(
        () => "fulfilled",
        error => error && error.name
      );
      const ready = writer.ready.then(
        () => "fulfilled",
        error => error && error.name
      );
      const closed = writer.closed.then(
        () => "fulfilled",
        error => error && error.name
      );
      const [writeResult, readyResult, closedResult] = await Promise.all([
        write,
        ready,
        closed
      ]);
      return { writeResult, readyResult, closedResult, sink };
    })();

    const reacquired = await (async () => {
      const sink = [];
      let writable;
      let writer1;
      let writer2;
      let write2;
      let close2;
      let closed2;
      const strategy = {
        size(chunk) {
          if (chunk > 0) {
            writer1.releaseLock();
            writer2 = writable.getWriter();
            write2 = writer2.write(0);
            close2 = writer2.close();
            closed2 = writer2.closed;
          }
          return 1;
        }
      };
      writable = new WritableStream({
        write(chunk) {
          sink.push(`write:${chunk}`);
        },
        close() {
          sink.push("close");
        }
      }, strategy);
      writer1 = writable.getWriter();
      const write1 = writer1.write(1).then(
        () => "fulfilled",
        error => error && error.name
      );
      const ready1 = writer1.ready.then(
        () => "fulfilled",
        error => error && error.name
      );
      const closed1 = writer1.closed.then(
        () => "fulfilled",
        error => error && error.name
      );
      const [write1Result, ready1Result, closed1Result, write2Result, close2Result,
        closed2Result] = await Promise.all([
          write1,
          ready1,
          closed1,
          write2.then(() => "fulfilled", error => error && error.name),
          close2.then(() => "fulfilled", error => error && error.name),
          closed2.then(() => "fulfilled", error => error && error.name)
        ]);
      return {
        write1Result,
        ready1Result,
        closed1Result,
        write2Result,
        close2Result,
        closed2Result,
        sink
      };
    })();

    globalThis.__writableReentrantReleaseResult = JSON.stringify({
      released,
      reacquired
    });
  })().catch(error => {
    globalThis.__writableReentrantReleaseResult =
      `error:${error && error.name}:${error && error.message}`;
  });
})()
"#,
    )
    .expect("WritableStream reentrant release setup should evaluate");

    for _ in 0..40 {
        let result = vm
            .eval("globalThis.__writableReentrantReleaseResult")
            .expect("WritableStream reentrant release operations should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__writableReentrantReleaseResult")
        .expect("WritableStream reentrant release result should evaluate");
    assert_eq!(
        result,
        r#"{"released":{"writeResult":"TypeError","readyResult":"TypeError","closedResult":"TypeError","sink":[]},"reacquired":{"write1Result":"TypeError","ready1Result":"TypeError","closed1Result":"TypeError","write2Result":"fulfilled","close2Result":"fulfilled","closed2Result":"fulfilled","sink":["write:0","close"]}}"#
    );
}

#[test]
fn writable_stream_error_with_undefined_reason_rejects_writer_promises() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableUndefinedErrorResults = [];
  const writable = new WritableStream({
    start(controller) {
      controller.error();
    }
  });
  const writer = writable.getWriter();
  globalThis.__writableUndefinedErrorResults.push(
    `desired:${writer.desiredSize === null}`
  );
  writer.ready.then(
    () => globalThis.__writableUndefinedErrorResults.push("ready:fulfilled"),
    error => globalThis.__writableUndefinedErrorResults.push(
      `ready:${error === undefined}`
    )
  );
  writer.closed.then(
    () => globalThis.__writableUndefinedErrorResults.push("closed:fulfilled"),
    error => globalThis.__writableUndefinedErrorResults.push(
      `closed:${error === undefined}`
    )
  );
  writer.write("x").then(
    () => globalThis.__writableUndefinedErrorResults.push("write:fulfilled"),
    error => globalThis.__writableUndefinedErrorResults.push(
      `write:${error === undefined}`
    )
  );
  writer.abort().then(
    () => globalThis.__writableUndefinedErrorResults.push("abort:fulfilled"),
    error => globalThis.__writableUndefinedErrorResults.push(
      `abort:${error === undefined}`
    )
  );
})()
"#,
    )
    .expect("writable undefined error setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("JSON.stringify(globalThis.__writableUndefinedErrorResults.sort())")
            .expect("writable undefined error promises should drain");
        if result.contains("abort:fulfilled") && result.contains("write:true") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__writableUndefinedErrorResults.sort())")
        .expect("writable undefined error results should evaluate");
    assert_eq!(
        result,
        // The start algorithm has not fulfilled yet, so the stream is still
        // `erroring`, not `errored`. Chromium rejects this pending abort with
        // the stored error (which is undefined here).
        r#"["abort:true","closed:true","desired:true","ready:true","write:true"]"#
    );
}

#[test]
fn writable_stream_abort_during_start_defers_close_rejection_until_abort_settles() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableAbortStartOrder = "pending";
  const error = new Error("abort");
  const events = [];
  const writable = new WritableStream();
  const writer = writable.getWriter();
  const write1 = writer.write(1);
  const abort = writer.abort(error);
  const write2 = writer.write(2);
  const close = writer.close();
  write1.catch(() => events.push("write1"));
  abort.then(() => events.push("abort"));
  write2.catch(() => events.push("write2"));
  close.catch(() => events.push("close"));
  Promise.all([
    write1.catch(() => {}),
    abort,
    write2.catch(() => {}),
    close.catch(() => {})
  ]).then(() => {
    globalThis.__writableAbortStartOrder = JSON.stringify(events);
  });
})()
"#,
    )
    .expect("WritableStream abort-during-start setup should evaluate");

    for _ in 0..16 {
        let result = vm
            .eval("globalThis.__writableAbortStartOrder")
            .expect("WritableStream abort-during-start promises should drain");
        if result != "pending" {
            break;
        }
    }
    let result = vm
        .eval("globalThis.__writableAbortStartOrder")
        .expect("WritableStream abort-during-start order should evaluate");
    assert_eq!(result, r#"["write2","write1","abort","close"]"#);
}

#[test]
fn writable_stream_abort_without_reason_uses_abort_error_for_controller_signal() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableDefaultSignalReason = "pending";
  let controller;
  let notifyWrite;
  const writeCalled = new Promise(resolve => { notifyWrite = resolve; });
  const writable = new WritableStream({
    start(value) { controller = value; },
    write() {
      notifyWrite();
      return new Promise(() => {});
    }
  });
  const writer = writable.getWriter();
  writer.write(1);
  writeCalled.then(() => {
    writer.abort();
    globalThis.__writableDefaultSignalReason = JSON.stringify({
      aborted: controller.signal.aborted,
      domException: controller.signal.reason instanceof DOMException,
      name: controller.signal.reason && controller.signal.reason.name
    });
  });
})()
"#,
    )
    .expect("WritableStream default signal reason setup should evaluate");

    for _ in 0..16 {
        let result = vm
            .eval("globalThis.__writableDefaultSignalReason")
            .expect("WritableStream default signal reason should drain");
        if result != "pending" {
            break;
        }
    }
    let result = vm
        .eval("globalThis.__writableDefaultSignalReason")
        .expect("WritableStream default signal reason should evaluate");
    assert_eq!(
        result,
        r#"{"aborted":true,"domException":true,"name":"AbortError"}"#
    );
}

#[test]
fn writable_stream_size_strategy_error_rejects_closed_and_pipe_to() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableSizeErrorResults = [];
  const sizeError = new RangeError("bad size");
  const direct = new WritableStream({}, {
    highWaterMark: 1,
    size() {
      throw sizeError;
    }
  });
  const writer = direct.getWriter();
  writer.closed.then(
    () => globalThis.__writableSizeErrorResults.push("closed:fulfilled"),
    error => globalThis.__writableSizeErrorResults.push(
      `closed:${error === sizeError}:${error.name}:${writer.desiredSize === null}`
    )
  );
  writer.write("direct").then(
    () => globalThis.__writableSizeErrorResults.push("write:fulfilled"),
    error => globalThis.__writableSizeErrorResults.push(
      `write:${error === sizeError}:${error.name}`
    )
  );

  const readable = new ReadableStream({
    start(controller) {
      controller.enqueue("pipe");
    },
    cancel(reason) {
      globalThis.__writableSizeErrorResults.push(`cancel:${reason === sizeError}`);
    }
  });
  const pipedWritable = new WritableStream({}, {
    highWaterMark: 1,
    size() {
      throw sizeError;
    }
  });
  pipedWritable.getWriter().releaseLock();
  readable.pipeTo(pipedWritable).then(
    () => globalThis.__writableSizeErrorResults.push("pipe:fulfilled"),
    error => globalThis.__writableSizeErrorResults.push(
      `pipe:${error === sizeError}:${readable.locked}:${pipedWritable.locked}`
    )
  );
})()
"#,
    )
    .expect("writable size strategy error setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("JSON.stringify(globalThis.__writableSizeErrorResults.sort())")
            .expect("writable size strategy error promises should drain");
        if result.contains("closed:true:RangeError:true")
            && result.contains("pipe:true:false:false")
        {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__writableSizeErrorResults.sort())")
        .expect("writable size strategy error results should evaluate");
    assert_eq!(
        result,
        r#"["cancel:true","closed:true:RangeError:true","pipe:true:false:false","write:true:RangeError"]"#
    );
}

#[test]
fn writable_stream_abort_rejects_closed_without_calling_method_apply_or_call() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableAbortMethodResults = [];
  function sinkMethod() {}
  sinkMethod.apply = () => globalThis.__writableAbortMethodResults.push("apply");
  sinkMethod.call = () => globalThis.__writableAbortMethodResults.push("call");
  const sink = {
    start: sinkMethod,
    write: sinkMethod,
    close: sinkMethod,
    abort: sinkMethod
  };

  const writer1 = new WritableStream(sink).getWriter();
  writer1.write("a");
  writer1.close();
  writer1.closed.then(
    () => globalThis.__writableAbortMethodResults.push("writer1:closed"),
    error => globalThis.__writableAbortMethodResults.push(`writer1:${error && error.name}`)
  );

  const abortReason = new Error("abort");
  abortReason.name = "abortReason";
  const writer2 = new WritableStream(sink).getWriter();
  writer2.abort(abortReason);
  writer2.closed.then(
    () => globalThis.__writableAbortMethodResults.push("writer2:fulfilled"),
    error => globalThis.__writableAbortMethodResults.push(
      `writer2:${error === abortReason}:${error.name}`
    )
  );

  const writer3 = new WritableStream({
    start: sinkMethod,
    write: sinkMethod,
    close: sinkMethod
  }).getWriter();
  writer3.abort(abortReason);
  writer3.closed.then(
    () => globalThis.__writableAbortMethodResults.push("writer3:fulfilled"),
    error => globalThis.__writableAbortMethodResults.push(
      `writer3:${error === abortReason}:${error.name}`
    )
  );
})()
"#,
    )
    .expect("writable abort method setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("JSON.stringify(globalThis.__writableAbortMethodResults.sort())")
            .expect("writable abort method promises should drain");
        if result.contains("writer1:closed") && result.contains("writer3:true:abortReason") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__writableAbortMethodResults.sort())")
        .expect("writable abort method results should evaluate");
    assert_eq!(
        result,
        r#"["writer1:closed","writer2:true:abortReason","writer3:true:abortReason"]"#
    );
}

#[test]
fn stream_constructors_preserve_subclass_prototypes() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
JSON.stringify((() => {
  class ReadableSubclass extends ReadableStream {
    extraFunction() {
      return true;
    }
  }
  class WritableSubclass extends WritableStream {
    extraFunction() {
      return true;
    }
  }
  class TransformSubclass extends TransformStream {
    extraFunction() {
      return true;
    }
  }

  const readable = new ReadableSubclass();
  const writable = new WritableSubclass();
  const transform = new TransformSubclass();
  const readableLocked = Object.getOwnPropertyDescriptor(
    ReadableStream.prototype, "locked"
  ).get;
  const writableLocked = Object.getOwnPropertyDescriptor(
    WritableStream.prototype, "locked"
  ).get;

  return {
    readableInstance:
      readable instanceof ReadableStream && readable instanceof ReadableSubclass,
    readableBrand: readableLocked.call(readable) === readable.locked,
    readableExtra: readable.extraFunction(),
    writableInstance:
      writable instanceof WritableStream && writable instanceof WritableSubclass,
    writableBrand: writableLocked.call(writable) === writable.locked,
    writableExtra: writable.extraFunction(),
    transformInstance:
      transform instanceof TransformStream && transform instanceof TransformSubclass,
    transformExtra: transform.extraFunction()
  };
})())
"#,
        )
        .expect("stream subclass constructor probe should evaluate");

    assert_eq!(
        result,
        r#"{"readableInstance":true,"readableBrand":true,"readableExtra":true,"writableInstance":true,"writableBrand":true,"writableExtra":true,"transformInstance":true,"transformExtra":true}"#
    );
}

#[test]
fn readable_reader_access_transitions_acquire_release_and_reject_locked_cancel() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableAccessResult = "pending";
  const readable = new ReadableStream();
  const before = readable.locked;
  const reader = readable.getReader();
  const acquired = readable.locked;
  const closed = reader.closed.then(
    () => "closed:fulfilled",
    error => `closed:${error && error.name}`
  );
  const cancel = readable.cancel().then(
    () => "cancel:fulfilled",
    error => `cancel:${error && error.name}`
  );
  reader.releaseLock();
  const released = readable.locked;
  reader.releaseLock();
  const releasedAgain = readable.locked;
  const replacement = readable.getReader();
  const reacquired = readable.locked;

  const byteStream = new ReadableStream({ type: "bytes" });
  const byobReader = byteStream.getReader({ mode: "byob" });
  const byobAcquired = byteStream.locked;
  byobReader.releaseLock();

  Promise.all([closed, cancel]).then(values => {
    globalThis.__readableAccessResult = JSON.stringify({
      before,
      acquired,
      released,
      releasedAgain,
      reacquired,
      byobAcquired,
      byobReleased: byteStream.locked,
      values
    });
    replacement.releaseLock();
  });
})()
"#,
    )
    .expect("ReadableStream access transition setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableAccessResult")
            .expect("ReadableStream access transition promises should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableAccessResult")
        .expect("ReadableStream access transition result should evaluate");
    assert_eq!(
        result,
        r#"{"before":false,"acquired":true,"released":false,"releasedAgain":false,"reacquired":true,"byobAcquired":true,"byobReleased":false,"values":["closed:TypeError","cancel:TypeError"]}"#
    );
}

#[test]
fn readable_stream_tee_inside_strategy_size_fans_out_current_enqueue() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableTeeResult = "pending";
  function readableStreamToArray(readable) {
    const reader = readable.getReader();
    const chunks = [];
    function pump() {
      return reader.read().then(result => {
        if (result.done) {
          return chunks;
        }
        chunks.push(result.value);
        return pump();
      });
    }
    return pump();
  }

  let controller;
  let branch1;
  let branch2;
  const readable = new ReadableStream({
    start(c) {
      controller = c;
    }
  }, {
    size() {
      [branch1, branch2] = readable.tee();
      return 1;
    }
  });
  controller.enqueue("a");
  const locked = readable.locked;
  controller.close();
  Promise.all([
    readableStreamToArray(branch1),
    readableStreamToArray(branch2)
  ]).then(
    ([first, second]) => {
      globalThis.__readableTeeResult = JSON.stringify({ locked, first, second });
    },
    error => {
      globalThis.__readableTeeResult = `error:${error && error.name}:${error && error.message}`;
    }
  );
})()
"#,
    )
    .expect("ReadableStream tee inside size setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableTeeResult")
            .expect("ReadableStream tee inside size should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableTeeResult")
        .expect("ReadableStream tee inside size result should evaluate");
    assert_eq!(result, r#"{"locked":true,"first":["a"],"second":["a"]}"#);
}

#[test]
fn readable_stream_size_reentry_commits_to_current_queue_generation() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableSizeReentryResult = "pending";
  const events = [];
  let controller;
  let reader;
  let readInsideSize;
  let drainInsideSize = false;
  const readable = new ReadableStream({
    start(c) {
      controller = c;
    }
  }, {
    size(chunk) {
      events.push(`size:${chunk}`);
      if (drainInsideSize) {
        drainInsideSize = false;
        readInsideSize = reader.read();
      }
      return 1;
    }
  });

  controller.enqueue("seed");
  reader = readable.getReader();
  drainInsideSize = true;
  controller.enqueue("outer");
  controller.close();

  Promise.all([readInsideSize, reader.read(), reader.read()]).then(
    ([first, second, terminal]) => {
      globalThis.__readableSizeReentryResult = JSON.stringify({
        events,
        first,
        second,
        terminal
      });
    },
    error => {
      globalThis.__readableSizeReentryResult =
        `error:${error && error.name}:${error && error.message}`;
    }
  );
})()
"#,
    )
    .expect("ReadableStream size reentry setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableSizeReentryResult")
            .expect("ReadableStream size reentry should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableSizeReentryResult")
        .expect("ReadableStream size reentry result should evaluate");
    assert_eq!(
        result,
        r#"{"events":["size:seed","size:outer"],"first":{"value":"seed","done":false},"second":{"value":"outer","done":false},"terminal":{"done":true}}"#
    );
}

#[test]
fn readable_stream_queue_total_uses_incremental_double_arithmetic() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableQueueTotalResult = "pending";
  const failures = [];
  const check = (label, actual, expected) => {
    if (!Object.is(actual, expected)) {
      failures.push({ label, actual, expected });
    }
  };
  const setup = () => {
    let controller;
    const readable = new ReadableStream({
      start(value) {
        controller = value;
      }
    }, {
      size(chunk) {
        return chunk;
      },
      highWaterMark: 0
    });
    return { controller, reader: readable.getReader() };
  };

  (async () => {
    {
      const { controller, reader } = setup();
      controller.enqueue(2);
      check("large/enqueue-1", controller.desiredSize, 0 - 2);
      controller.enqueue(Number.MAX_SAFE_INTEGER);
      check(
        "large/enqueue-2",
        controller.desiredSize,
        0 - Number.MAX_SAFE_INTEGER - 2
      );
      await reader.read();
      check(
        "large/dequeue-1",
        controller.desiredSize,
        0 - Number.MAX_SAFE_INTEGER - 2 + 2
      );
      await reader.read();
      check("large/dequeue-2", controller.desiredSize, 0);
    }

    {
      const { controller, reader } = setup();
      controller.enqueue(1e-16);
      check("tiny-clamp/enqueue-1", controller.desiredSize, 0 - 1e-16);
      controller.enqueue(1);
      check("tiny-clamp/enqueue-2", controller.desiredSize, 0 - 1e-16 - 1);
      await reader.read();
      check("tiny-clamp/dequeue-1", controller.desiredSize, 0 - 1e-16 - 1 + 1e-16);
      await reader.read();
      check("tiny-clamp/dequeue-2", controller.desiredSize, 0);
    }

    {
      const { controller, reader } = setup();
      controller.enqueue(1e-16);
      check("tiny-positive/enqueue-1", controller.desiredSize, 0 - 1e-16);
      controller.enqueue(1);
      check("tiny-positive/enqueue-2", controller.desiredSize, 0 - 1e-16 - 1);
      controller.enqueue(2e-16);
      check(
        "tiny-positive/enqueue-3",
        controller.desiredSize,
        0 - 1e-16 - 1 - 2e-16
      );
      await reader.read();
      check(
        "tiny-positive/dequeue-1",
        controller.desiredSize,
        0 - 1e-16 - 1 - 2e-16 + 1e-16
      );
      await reader.read();
      check(
        "tiny-positive/dequeue-2",
        controller.desiredSize,
        0 - 1e-16 - 1 - 2e-16 + 1e-16 + 1
      );
      await reader.read();
      check(
        "tiny-positive/dequeue-3",
        controller.desiredSize,
        0 - 1e-16 - 1 - 2e-16 + 1e-16 + 1 + 2e-16
      );
    }

    {
      const { controller, reader } = setup();
      controller.enqueue(2e-16);
      check("tiny-zero/enqueue-1", controller.desiredSize, 0 - 2e-16);
      controller.enqueue(1);
      check("tiny-zero/enqueue-2", controller.desiredSize, 0 - 2e-16 - 1);
      await reader.read();
      check("tiny-zero/dequeue-1", controller.desiredSize, 0 - 2e-16 - 1 + 2e-16);
      await reader.read();
      check("tiny-zero/dequeue-2", controller.desiredSize, 0);
    }

    globalThis.__readableQueueTotalResult = JSON.stringify(failures);
  })().catch(error => {
    globalThis.__readableQueueTotalResult =
      `error:${error && error.name}:${error && error.message}`;
  });
})()
"#,
    )
    .expect("ReadableStream floating-point queue total setup should evaluate");

    for _ in 0..16 {
        let result = vm
            .eval("globalThis.__readableQueueTotalResult")
            .expect("ReadableStream floating-point queue total should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableQueueTotalResult")
        .expect("ReadableStream floating-point queue total result should evaluate");
    assert_eq!(result, "[]");
}

#[test]
fn readable_stream_reentrant_strategies_match_chromium_wpt() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableReentrantWpt = {};
  const results = globalThis.__readableReentrantWpt;
  const error = new Error("error1");
  const spin = async (count = 12) => {
    for (let i = 0; i < count; ++i) await Promise.resolve();
  };
  const collect = async readable => {
    const reader = readable.getReader();
    const chunks = [];
    while (true) {
      const result = await reader.read();
      if (result.done) return chunks;
      chunks.push(result.value);
    }
  };
  const run = (name, body) => {
    results[name] = "pending";
    Promise.resolve().then(body).then(
      value => { results[name] = value; },
      failure => {
        results[name] = `unexpected:${failure && failure.name}:${failure && failure.message}`;
      }
    );
  };

  run("nestedEnqueue", async () => {
    let controller;
    let calls = 0;
    const readable = new ReadableStream({
      start(value) { controller = value; }
    }, {
      size() {
        calls += 1;
        if (calls < 2) controller.enqueue("b");
        return 1;
      }
    });
    controller.enqueue("a");
    controller.close();
    return { chunks: await collect(readable), calls };
  });

  run("closeEmptyQueue", async () => {
    let controller;
    const readable = new ReadableStream({
      start(value) { controller = value; }
    }, {
      size() {
        controller.close();
        return 1;
      }
    });
    controller.enqueue("a");
    return collect(readable);
  });

  run("closeQueued", async () => {
    let controller;
    let calls = 0;
    const readable = new ReadableStream({
      start(value) { controller = value; }
    }, {
      size() {
        calls += 1;
        if (calls === 2) controller.close();
        return 1;
      }
    });
    controller.enqueue("a");
    controller.enqueue("b");
    return collect(readable);
  });

  run("error", async () => {
    let controller;
    const readable = new ReadableStream({
      start(value) { controller = value; }
    }, {
      size() {
        controller.error(error);
        return 1;
      }
    });
    controller.enqueue("a");
    try {
      await readable.getReader().read();
      return "fulfilled";
    } catch (failure) {
      return failure === error ? "same-error" : "other-error";
    }
  });

  run("desiredSize", async () => {
    let controller;
    const observed = [];
    const readable = new ReadableStream({
      start(value) { controller = value; }
    }, {
      size() {
        observed.push(controller.desiredSize);
        return 1;
      },
      highWaterMark: 1
    });
    controller.enqueue("a");
    controller.close();
    return { observed, chunks: await collect(readable) };
  });

  run("cancel", async () => {
    let controller;
    let cancelPromise;
    const observations = [];
    let readable;
    readable = new ReadableStream({
      start(value) { controller = value; },
      cancel(reason) {
        observations.push(reason === error ? "same-reason" : "other-reason");
        try {
          controller.enqueue();
          observations.push("enqueue-fulfilled");
        } catch (failure) {
          observations.push(`enqueue-${failure && failure.name}`);
        }
      }
    }, {
      size() {
        cancelPromise = readable.cancel(error);
        return 1;
      },
      highWaterMark: Infinity
    });
    controller.enqueue("a");
    const reader = readable.getReader();
    await Promise.all([reader.closed, cancelPromise]);
    return observations;
  });

  run("pipeTo", async () => {
    let controller;
    let pipePromise;
    const events = [];
    const writable = new WritableStream({
      write(chunk) { events.push(`write:${chunk}`); },
      close() { events.push("close"); }
    });
    let readable;
    readable = new ReadableStream({
      start(value) { controller = value; }
    }, {
      size() {
        if (!pipePromise) pipePromise = readable.pipeTo(writable);
        return 1;
      },
      highWaterMark: 1
    });
    controller.enqueue("a");
    controller.enqueue("a");
    await spin();
    controller.close();
    await pipePromise;
    return events;
  });

  run("read", async () => {
    let controller;
    let reader;
    let readPromise;
    let readResolved = false;
    let calls = 0;
    const readable = new ReadableStream({
      start(value) { controller = value; }
    }, {
      size() {
        readPromise = reader.read();
        calls += 1;
        return 1;
      },
      highWaterMark: 0
    });
    reader = readable.getReader();
    controller.enqueue("a");
    readPromise.then(() => { readResolved = true; });
    await spin();
    const resolvedBeforeSecondEnqueue = readResolved;
    controller.enqueue("b");
    const first = await readPromise;
    const second = await reader.read();
    return {
      resolvedBeforeSecondEnqueue,
      calls,
      values: [first.value, first.done, second.value, second.done]
    };
  });

  run("getReader", async () => {
    let controller;
    let reader;
    const readable = new ReadableStream({
      start(value) { controller = value; }
    }, {
      size() {
        reader = readable.getReader();
        return 1;
      }
    });
    controller.enqueue("a");
    const result = await reader.read();
    return [result.value, result.done];
  });
})()
"#,
    )
    .expect("ReadableStream reentrant WPT cases should initialize");

    for _ in 0..64 {
        let result = vm
            .eval("JSON.stringify(globalThis.__readableReentrantWpt)")
            .expect("ReadableStream reentrant WPT cases should drain");
        if !result.contains("pending") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__readableReentrantWpt)")
        .expect("ReadableStream reentrant WPT result should evaluate");
    assert_eq!(
        result,
        r#"{"nestedEnqueue":{"chunks":["b","a"],"calls":2},"closeEmptyQueue":[],"closeQueued":["a","b"],"error":"same-error","desiredSize":{"observed":[1],"chunks":["a"]},"cancel":["same-reason","enqueue-TypeError"],"pipeTo":["write:a","write:a","close"],"read":{"resolvedBeforeSecondEnqueue":false,"calls":1,"values":["b",false,"a",false]},"getReader":["a",false]}"#
    );
}

#[test]
fn transform_stream_reentrant_readable_strategy_matches_chromium_wpt() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__transformReentrantWpt = {};
  const results = globalThis.__transformReentrantWpt;
  const error = new Error("error1");
  const spin = async (count = 16) => {
    for (let i = 0; i < count; ++i) await Promise.resolve();
  };
  const collect = async readable => {
    const reader = readable.getReader();
    const chunks = [];
    while (true) {
      const result = await reader.read();
      if (result.done) return chunks;
      chunks.push(result.value);
    }
  };
  const run = (name, body) => {
    results[name] = "pending";
    Promise.resolve().then(body).then(
      value => { results[name] = value; },
      failure => {
        results[name] = `unexpected:${failure && failure.name}:${failure && failure.message}`;
      }
    );
  };

  run("nestedEnqueue", async () => {
    let controller;
    let calls = 0;
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        calls += 1;
        if (calls < 2) controller.enqueue("b");
        return 1;
      },
      highWaterMark: Infinity
    });
    const writer = transform.writable.getWriter();
    await Promise.all([writer.write("a"), writer.close()]);
    return { chunks: await collect(transform.readable), calls };
  });

  run("terminate", async () => {
    let controller;
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        controller.terminate();
        return 1;
      },
      highWaterMark: Infinity
    });
    await transform.writable.getWriter().write("a");
    return collect(transform.readable);
  });

  run("error", async () => {
    let controller;
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        controller.error(error);
        return 1;
      },
      highWaterMark: Infinity
    });
    const writer = transform.writable.getWriter();
    writer.closed.catch(() => {});
    await writer.write("a");
    try {
      await transform.readable.getReader().read();
      return "fulfilled";
    } catch (failure) {
      return failure === error ? "same-error" : "other-error";
    }
  });

  run("desiredSize", async () => {
    let controller;
    const observed = [];
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        observed.push(controller.desiredSize);
        return 1;
      },
      highWaterMark: 1
    });
    const writer = transform.writable.getWriter();
    await Promise.all([writer.write("a"), writer.close()]);
    return { observed, chunks: await collect(transform.readable) };
  });

  run("cancel", async () => {
    let cancelPromise;
    const transform = new TransformStream({}, undefined, {
      size() {
        cancelPromise = transform.readable.cancel(error);
        return 1;
      },
      highWaterMark: Infinity
    });
    const writer = transform.writable.getWriter();
    const closed = writer.closed.then(
      () => "closed-fulfilled",
      failure => failure === error ? "closed-same-error" : "closed-other-error"
    );
    await writer.write("a");
    await cancelPromise;
    return closed;
  });

  run("pipeTo", async () => {
    let controller;
    let pipePromise;
    const events = [];
    const writable = new WritableStream({
      write(chunk) { events.push(`write:${chunk}`); },
      close() { events.push("close"); }
    });
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        if (!pipePromise) pipePromise = transform.readable.pipeTo(writable);
        return 1;
      },
      highWaterMark: 1
    });
    await spin();
    controller.enqueue("a");
    controller.enqueue("a");
    await spin();
    controller.terminate();
    await pipePromise;
    return events;
  });

  run("read", async () => {
    let controller;
    let reader;
    let readPromise;
    let calls = 0;
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        readPromise = reader.read();
        calls += 1;
        return 1;
      },
      highWaterMark: 0
    });
    reader = transform.readable.getReader();
    const writer = transform.writable.getWriter();
    let writeResolved = false;
    const writePromise = writer.write("b").then(() => { writeResolved = true; });
    await spin();
    const resolvedBeforeEnqueue = writeResolved;
    controller.enqueue("a");
    await spin();
    const result = await readPromise;
    await writePromise;
    return {
      resolvedBeforeEnqueue,
      writeResolved,
      calls,
      value: [result.value, result.done]
    };
  });

  run("nestedWriterWrite", async () => {
    let writer;
    let nestedWrite;
    let calls = 0;
    const transform = new TransformStream({}, undefined, {
      size() {
        calls += 1;
        if (calls < 2) nestedWrite = writer.write("a");
        return 1;
      },
      highWaterMark: Infinity
    });
    writer = transform.writable.getWriter();
    await spin();
    const outerWrite = writer.write("b");
    await Promise.all([nestedWrite, outerWrite, writer.close()]);
    return { chunks: await collect(transform.readable), calls };
  });

  run("syncNestedWriterWrite", async () => {
    let controller;
    let writer;
    let nestedWrite;
    let calls = 0;
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        calls += 1;
        if (calls < 2) nestedWrite = writer.write("a");
        return 1;
      },
      highWaterMark: Infinity
    });
    writer = transform.writable.getWriter();
    await spin();
    controller.enqueue("b");
    await Promise.all([nestedWrite, writer.close()]);
    return { chunks: await collect(transform.readable), calls };
  });

  run("close", async () => {
    let controller;
    let writer;
    let closePromise;
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        closePromise = writer.close();
        return 1;
      },
      highWaterMark: 1
    });
    writer = transform.writable.getWriter();
    const reader = transform.readable.getReader();
    await spin();
    controller.enqueue("a");
    const first = await reader.read();
    const second = await reader.read();
    await closePromise;
    return [first.value, first.done, second.value === undefined, second.done];
  });

  run("abort", async () => {
    let abortPromise;
    let controller;
    const transform = new TransformStream({
      start(value) { controller = value; }
    }, undefined, {
      size() {
        abortPromise = transform.writable.abort(error);
        return 1;
      },
      highWaterMark: 1
    });
    const reader = transform.readable.getReader();
    await spin();
    controller.enqueue("a");
    const first = await reader.read();
    let rejection;
    try {
      await reader.read();
      rejection = "fulfilled";
    } catch (failure) {
      rejection = failure === error ? "same-error" : "other-error";
    }
    await abortPromise;
    return [first.value, first.done, rejection];
  });
})()
"#,
    )
    .expect("TransformStream reentrant WPT cases should initialize");

    for _ in 0..96 {
        let result = vm
            .eval("JSON.stringify(globalThis.__transformReentrantWpt)")
            .expect("TransformStream reentrant WPT cases should drain");
        if !result.contains("pending") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__transformReentrantWpt)")
        .expect("TransformStream reentrant WPT result should evaluate");
    assert_eq!(
        result,
        r#"{"nestedEnqueue":{"chunks":["b","a"],"calls":2},"terminate":[],"error":"same-error","desiredSize":{"observed":[1],"chunks":["a"]},"cancel":"closed-same-error","pipeTo":["write:a","write:a","close"],"read":{"resolvedBeforeEnqueue":false,"writeResolved":true,"calls":1,"value":["b",false]},"nestedWriterWrite":{"chunks":["b","a"],"calls":2},"syncNestedWriterWrite":{"chunks":["a","b"],"calls":2},"close":["a",false,true,true],"abort":["a",false,"same-error"]}"#
    );
}

#[test]
fn transform_stream_backpressure_matches_chromium_wpt() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__transformBackpressureWpt = "pending";
  const spin = async (count = 16) => {
    for (let i = 0; i < count; ++i) await Promise.resolve();
  };
  (async () => {
    const results = {};

    {
      const events = [];
      let settled = false;
      const transform = new TransformStream({
        transform(chunk, controller) {
          events.push(chunk);
          controller.enqueue(chunk);
        }
      });
      transform.writable.getWriter().write("a").then(
        () => { settled = true; },
        () => { settled = true; }
      );
      await spin();
      results.noReader = { events, settled };
    }

    {
      const events = [];
      const transform = new TransformStream({
        transform(chunk, controller) {
          events.push(chunk);
          controller.enqueue(chunk);
        }
      }, undefined, { highWaterMark: 1 });
      const writer = transform.writable.getWriter();
      let firstSettled = false;
      let secondSettled = false;
      writer.write("a").then(() => { firstSettled = true; });
      writer.write("b").then(() => { secondSettled = true; });
      await spin();
      results.hwmOne = { events, firstSettled, secondSettled };
    }

    {
      const events = [];
      const transform = new TransformStream({
        transform(chunk) { events.push(chunk); }
      }, undefined, { highWaterMark: 1 });
      const writer = transform.writable.getWriter();
      await Promise.all([0, 1, 2, 3].map(chunk => writer.write(chunk)));
      results.discard = events;
    }

    {
      const transform = new TransformStream(undefined, undefined, {
        highWaterMark: 0
      });
      const writer = transform.writable.getWriter();
      const reader = transform.readable.getReader();
      const readPromise = reader.read();
      const writePromise = writer.write("a");
      const read = await readPromise;
      await writePromise;
      results.readBeforeWrite = [read.value, read.done];
    }

    {
      let called = false;
      const transform = new TransformStream({
        transform() { called = true; }
      }, undefined, { highWaterMark: Infinity });
      await spin();
      const writePromise = transform.writable.getWriter().write();
      results.synchronous = called;
      await writePromise;
    }

    {
      const ordering = {};
      for (const highWaterMark of [0, 1, 2, Infinity]) {
        const events = [];
        let index = 0;
        const source = new ReadableStream({
          pull(controller) {
            index += 1;
            events.push(`pull:${index}`);
            if (index <= 3) controller.enqueue(index);
            else controller.close();
          }
        }, { highWaterMark: 1 });
        const output = source.pipeThrough(new TransformStream({
          transform(chunk, controller) {
            events.push(`transform:${chunk}`);
            controller.enqueue(chunk);
          }
        }, { highWaterMark: 1 }, { highWaterMark }));
        const reader = output.getReader();
        while (!(await reader.read()).done) {}
        ordering[String(highWaterMark)] = events;
      }
      results.pipeOrdering = ordering;
    }

    {
      let resolveTransform;
      let transformCalled = false;
      const transform = new TransformStream({
        transform() {
          transformCalled = true;
          return new Promise(resolve => { resolveTransform = resolve; });
        }
      }, undefined, { highWaterMark: Infinity });
      const writer = transform.writable.getWriter();
      await spin();
      const writePromise = writer.write("a");
      const whileBlocked = {
        transformCalled,
        desiredSize: writer.desiredSize
      };
      resolveTransform();
      await writePromise;
      await spin();
      results.blocking = {
        whileBlocked,
        desiredSizeAfter: writer.desiredSize
      };
    }

    globalThis.__transformBackpressureWpt = JSON.stringify(results);
  })().catch(error => {
    globalThis.__transformBackpressureWpt =
      `error:${error && error.name}:${error && error.message}`;
  });
})()
"#,
    )
    .expect("TransformStream backpressure WPT cases should initialize");

    for _ in 0..96 {
        let result = vm
            .eval("globalThis.__transformBackpressureWpt")
            .expect("TransformStream backpressure WPT cases should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__transformBackpressureWpt")
        .expect("TransformStream backpressure WPT result should evaluate");
    assert_eq!(
        result,
        r#"{"noReader":{"events":[],"settled":false},"hwmOne":{"events":["a"],"firstSettled":true,"secondSettled":false},"discard":[0,1,2,3],"readBeforeWrite":["a",false],"synchronous":true,"pipeOrdering":{"0":["pull:1","pull:2","transform:1","pull:3","transform:2","pull:4","transform:3"],"1":["pull:1","pull:2","transform:1","pull:3","transform:2","pull:4","transform:3"],"2":["pull:1","pull:2","transform:1","pull:3","transform:2","pull:4","transform:3"],"Infinity":["pull:1","pull:2","transform:1","pull:3","transform:2","pull:4","transform:3"]},"blocking":{"whileBlocked":{"transformCalled":true,"desiredSize":0},"desiredSizeAfter":1}}"#
    );
}

#[test]
fn readable_stream_queue_writes_ignore_array_prototype_indexed_setters() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableQueuePrototypeResult = "pending";
  let controller;
  const readable = new ReadableStream({
    start(c) {
      controller = c;
    }
  });
  const previous = Object.getOwnPropertyDescriptor(Array.prototype, "0");
  let setterCalls = 0;
  let enqueueError = null;
  Object.defineProperty(Array.prototype, "0", {
    configurable: true,
    set() {
      setterCalls += 1;
    }
  });
  try {
    controller.enqueue("chunk");
  } catch (error) {
    enqueueError = error && error.name;
  } finally {
    if (previous) {
      Object.defineProperty(Array.prototype, "0", previous);
    } else {
      delete Array.prototype[0];
    }
  }
  controller.close();
  readable.getReader().read().then(
    result => {
      globalThis.__readableQueuePrototypeResult = JSON.stringify({
        setterCalls,
        enqueueError,
        value: result.value,
        done: result.done
      });
    },
    error => {
      globalThis.__readableQueuePrototypeResult =
        `error:${error && error.name}:${error && error.message}`;
    }
  );
})()
"#,
    )
    .expect("ReadableStream queue prototype pollution setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableQueuePrototypeResult")
            .expect("ReadableStream queue prototype pollution should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableQueuePrototypeResult")
        .expect("ReadableStream queue prototype pollution result should evaluate");
    assert_eq!(
        result,
        r#"{"setterCalls":0,"enqueueError":null,"value":"chunk","done":false}"#
    );
}

#[test]
fn readable_stream_tee_copies_existing_queue_and_close_to_branches() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableTeeExistingResult = "pending";
  function readableStreamToArray(readable) {
    const reader = readable.getReader();
    const chunks = [];
    function pump() {
      return reader.read().then(result => {
        if (result.done) {
          return chunks;
        }
        chunks.push(result.value);
        return pump();
      });
    }
    return pump();
  }

  const readable = new ReadableStream({
    start(controller) {
      controller.enqueue("a");
      controller.enqueue("b");
      controller.close();
    }
  });
  const branches = readable.tee();
  Promise.all([
    readableStreamToArray(branches[0]),
    readableStreamToArray(branches[1])
  ]).then(
    ([first, second]) => {
      globalThis.__readableTeeExistingResult = JSON.stringify({
        locked: readable.locked,
        first,
        second
      });
    },
    error => {
      globalThis.__readableTeeExistingResult =
        `error:${error && error.name}:${error && error.message}`;
    }
  );
})()
"#,
    )
    .expect("ReadableStream tee existing queue setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableTeeExistingResult")
            .expect("ReadableStream tee existing queue should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableTeeExistingResult")
        .expect("ReadableStream tee existing queue result should evaluate");
    assert_eq!(
        result,
        r#"{"locked":true,"first":["a","b"],"second":["a","b"]}"#
    );
}

#[test]
fn readable_stream_tee_internal_read_does_not_assimilate_iterator_result_thenables() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const state = globalThis.__teeThenInterception = {
    intercepted: [],
    events: [],
    settled: false,
    rejected: null
  };
  let callCount = 0;
  Object.prototype.then = function(resolve) {
    if (!this.done) state.intercepted.push(this.value);
    const replacement = Object.create(null);
    replacement.done = ++callCount === 3;
    replacement.value = callCount;
    resolve(replacement);
    if (replacement.done) delete Object.prototype.then;
  };

  const source = new ReadableStream({
    start(controller) {
      controller.enqueue("a");
      controller.close();
    }
  });
  const [branch1, branch2] = source.tee();
  branch1.pipeTo(new WritableStream({
    write(chunk) { state.events.push(`write:${chunk}`); },
    close() { state.events.push("close"); }
  })).then(
    () => {
      delete Object.prototype.then;
      branch2.cancel();
      state.settled = true;
    },
    error => {
      delete Object.prototype.then;
      state.rejected = error && error.name;
      state.settled = true;
    }
  );
})()
"#,
    )
    .expect("tee then-interception setup should evaluate");

    for _ in 0..12 {
        let settled = vm
            .eval("globalThis.__teeThenInterception.settled")
            .expect("tee then-interception should drain microtasks");
        if settled == "true" {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__teeThenInterception)")
        .expect("tee then-interception result should evaluate");
    assert_eq!(
        result,
        r#"{"intercepted":[],"events":["write:a","close"],"settled":true,"rejected":null}"#
    );
}

#[test]
fn readable_stream_tee_rejects_locked_and_invalid_receivers() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
JSON.stringify((() => {
  const results = [];
  const readable = new ReadableStream();
  const reader = readable.getReader();
  try {
    readable.tee();
    results.push("locked:missing");
  } catch (error) {
    results.push(`locked:${error.name}`);
  }
  reader.releaseLock();
  try {
    ReadableStream.prototype.tee.call({});
    results.push("invalid:missing");
  } catch (error) {
    results.push(`invalid:${error.name}`);
  }
  return results;
})())
"#,
        )
        .expect("ReadableStream tee receiver errors should evaluate");

    assert_eq!(result, r#"["locked:TypeError","invalid:TypeError"]"#);
}

#[test]
fn readable_stream_tee_canceling_both_branches_aggregates_reasons() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableTeeCancelResult = "pending";
  const reason1 = new Error("first");
  const reason2 = new Error("second");
  let cancelReason;
  const readable = new ReadableStream({
    cancel(reason) {
      cancelReason = reason;
    }
  });
  const [branch1, branch2] = readable.tee();
  Promise.all([
    branch1.cancel(reason1),
    branch2.cancel(reason2)
  ]).then(
    () => {
      globalThis.__readableTeeCancelResult = JSON.stringify({
        isArray: Array.isArray(cancelReason),
        first: cancelReason && cancelReason[0] === reason1,
        second: cancelReason && cancelReason[1] === reason2
      });
    },
    error => {
      globalThis.__readableTeeCancelResult = `error:${error && error.name}`;
    }
  );
})()
"#,
    )
    .expect("ReadableStream tee cancel aggregation setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableTeeCancelResult")
            .expect("ReadableStream tee cancel aggregation should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableTeeCancelResult")
        .expect("ReadableStream tee cancel aggregation result should evaluate");
    assert_eq!(result, r#"{"isArray":true,"first":true,"second":true}"#);
}

#[test]
fn readable_stream_tee_rejects_branch_cancel_when_original_cancel_throws() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableTeeCancelRejectResult = "pending";
  const cancelError = { name: "cancelError" };
  const readable = new ReadableStream({
    cancel() {
      throw cancelError;
    }
  });
  const [branch1, branch2] = readable.tee();
  Promise.all([
    branch1.cancel().then(
      () => "first:fulfilled",
      error => `first:${error === cancelError}:${error && error.name}`
    ),
    branch2.cancel().then(
      () => "second:fulfilled",
      error => `second:${error === cancelError}:${error && error.name}`
    )
  ]).then(results => {
    globalThis.__readableTeeCancelRejectResult = JSON.stringify(results.sort());
  });
})()
"#,
    )
    .expect("ReadableStream tee cancel rejection setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableTeeCancelRejectResult")
            .expect("ReadableStream tee cancel rejection should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableTeeCancelRejectResult")
        .expect("ReadableStream tee cancel rejection result should evaluate");
    assert_eq!(
        result,
        r#"["first:true:cancelError","second:true:cancelError"]"#
    );
}

#[test]
fn readable_stream_tee_pulls_once_when_branches_have_capacity() {
    let mut vm = stream_test_vm();

    let initial = vm
        .eval(
            r#"
JSON.stringify((() => {
  globalThis.__readableTeeInitialPullEvents = [];
  const readable = new ReadableStream({
    pull() {
      globalThis.__readableTeeInitialPullEvents.push("pull");
    }
  }, { highWaterMark: 0 });
  readable.tee();
  return globalThis.__readableTeeInitialPullEvents;
})())
"#,
        )
        .expect("ReadableStream tee initial pull should evaluate");
    assert_eq!(initial, "[]");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__readableTeeInitialPullEvents)")
            .expect("ReadableStream tee initial pull should drain start reactions");
        if events != "[]" {
            break;
        }
    }
    let result = vm
        .eval("JSON.stringify(globalThis.__readableTeeInitialPullEvents)")
        .expect("ReadableStream tee initial pull result should evaluate");

    assert_eq!(result, r#"["pull"]"#);
}

#[test]
fn readable_stream_tee_pulls_again_after_both_branch_queues_drain() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableTeePullResult = "pending";
  const events = [];
  let next = 0;
  const readable = new ReadableStream({
    pull(controller) {
      next += 1;
      events.push(`pull:${next}`);
      controller.enqueue(next);
    }
  }, { highWaterMark: 0 });
  const [reader1, reader2] = readable.tee().map(branch => branch.getReader());
  Promise.all([
    reader1.read(),
    reader2.read()
  ]).then(
    results => {
      globalThis.__readableTeePullResult = JSON.stringify({
        events,
        values: results.map(result => result.value)
      });
    },
    error => {
      globalThis.__readableTeePullResult = `error:${error && error.name}:${error && error.message}`;
    }
  );
})()
"#,
    )
    .expect("ReadableStream tee branch pull setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableTeePullResult")
            .expect("ReadableStream tee branch pull should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableTeePullResult")
        .expect("ReadableStream tee branch pull result should evaluate");
    assert_eq!(result, r#"{"events":["pull:1","pull:2"],"values":[1,1]}"#);
}

#[test]
fn readable_stream_tee_propagates_original_pull_error_after_branch_demand() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__readableTeePullErrorResult = "pending";
  const pullError = { name: "pullError" };
  const readable = new ReadableStream({
    start(controller) {
      controller.enqueue("a");
      controller.enqueue("b");
    },
    pull() {
      throw pullError;
    }
  });
  const [reader1, reader2] = readable.tee().map(branch => branch.getReader());
  const closed1 = reader1.closed.then(
    () => "closed1:fulfilled",
    error => `closed1:${error === pullError}:${error && error.name}`
  );
  const closed2 = reader2.closed.then(
    () => "closed2:fulfilled",
    error => `closed2:${error === pullError}:${error && error.name}`
  );
  reader1.read().then(first => {
    return reader1.read().then(second => {
      return Promise.all([
        closed1,
        closed2,
        Promise.resolve(`read1:${first.value}:${first.done}`),
        Promise.resolve(`read2:${second.value}:${second.done}`),
        reader2.read().then(
          () => "read3:fulfilled",
          error => `read3:${error === pullError}:${error && error.name}`
        ),
        reader1.read().then(
          () => "read4:fulfilled",
          error => `read4:${error === pullError}:${error && error.name}`
        )
      ]);
    });
  }).then(results => {
    globalThis.__readableTeePullErrorResult = JSON.stringify(results.sort());
  }, error => {
    globalThis.__readableTeePullErrorResult = `error:${error && error.name}:${error && error.message}`;
  });
})()
"#,
    )
    .expect("ReadableStream tee pull error setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__readableTeePullErrorResult")
            .expect("ReadableStream tee pull error should drain");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval("globalThis.__readableTeePullErrorResult")
        .expect("ReadableStream tee pull error result should evaluate");
    assert_eq!(
        result,
        r#"["closed1:true:pullError","closed2:true:pullError","read1:a:false","read2:b:false","read3:true:pullError","read4:true:pullError"]"#
    );
}

#[test]
fn readable_stream_tee_stops_pulling_after_source_errors_with_both_branches_reading() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__teeStopsAfterError = {
    events: [],
    phase: "setup",
    reads: "pending",
    closed: "pending"
  };
  const state = globalThis.__teeStopsAfterError;
  const error = { name: "tee-error" };
  const readable = new ReadableStream({
    start(controller) {
      state.sourceController = controller;
    },
    pull() {
      state.events.push(`pull:${state.phase}`);
    }
  }, { highWaterMark: 0 });
  const [reader1, reader2] = readable.tee().map(branch => branch.getReader());
  state.controller = null;
  state.readable = readable;
  state.error = error;
  state.reader1 = reader1;
  state.reader2 = reader2;
})()
"#,
    )
    .expect("tee terminal pull setup should evaluate");

    for _ in 0..8 {
        if vm
            .eval("globalThis.__teeStopsAfterError.events.length")
            .expect("initial tee pull should drain")
            == "1"
        {
            break;
        }
    }
    vm.eval(
        r#"
(() => {
  const state = globalThis.__teeStopsAfterError;
  state.phase = "enqueue";
  state.sourceController.enqueue("a");
  Promise.all([state.reader1.read(), state.reader2.read()]).then(() => {
    state.reads = "done";
    state.phase = "reads-done";
  });
})()
"#,
    )
    .expect("tee branch reads should start");

    for _ in 0..8 {
        if vm
            .eval("globalThis.__teeStopsAfterError.reads")
            .expect("tee branch reads should drain")
            == "done"
        {
            break;
        }
    }
    vm.eval(
        r#"
(() => {
  const state = globalThis.__teeStopsAfterError;
  Promise.all([
    state.reader1.closed.catch(error => error),
    state.reader2.closed.catch(error => error)
  ]).then(() => { state.closed = "done"; });
  state.phase = "error-call";
  state.sourceController.error(state.error);
  state.phase = "error-returned";
})()
"#,
    )
    .expect("tee source error should evaluate");
    for _ in 0..8 {
        let _ = vm
            .eval("globalThis.__teeStopsAfterError.closed")
            .expect("tee source error should drain");
    }

    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__teeStopsAfterError.events)")
            .expect("tee source pull events should evaluate"),
        r#"["pull:setup","pull:enqueue"]"#
    );
}

#[test]
fn writable_stream_release_lock_rejects_ready_before_closed() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__writableReleaseOrdering = [];
  const ws = new WritableStream();
  const writer = ws.getWriter();
  writer.ready.then(() => {
    const writerPromise = writer.write("dummy");
    const readyPromise = writer.ready.catch(() => {
      globalThis.__writableReleaseOrdering.push("ready");
    });
    const closedPromise = writer.closed.catch(() => {
      globalThis.__writableReleaseOrdering.push("closed");
    });
    writer.releaseLock();
    Promise.all([readyPromise, closedPromise]).then(() => {
      globalThis.__writableReleaseOrdering.push(
        `order:${globalThis.__writableReleaseOrdering.join(",")}`
      );
      return Promise.all([writerPromise, ws.abort()]);
    }).then(
      () => globalThis.__writableReleaseOrdering.push("done"),
      error => globalThis.__writableReleaseOrdering.push(`error:${error && error.name}`)
    );
  });
})()
"#,
    )
    .expect("writable release ordering setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("JSON.stringify(globalThis.__writableReleaseOrdering)")
            .expect("writable release ordering promises should drain");
        if result.contains("\"done\"") || result.contains("\"error:") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__writableReleaseOrdering)")
        .expect("writable release ordering result should evaluate");
    assert_eq!(result, r#"["ready","closed","order:ready,closed","done"]"#);
}

#[test]
fn transform_stream_terminate_then_error_with_queued_chunk_errors_readable() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const error1 = new Error("error1");
  const ts = new TransformStream({
    start(controller) {
      controller.enqueue(0);
      controller.terminate();
      controller.error(error1);
    }
  });
  globalThis.__transformTerminateResults = [];
  ts.writable.abort().then(
    () => globalThis.__transformTerminateResults.push("abort:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`abort:${error.name}`)
  );
  ts.readable.cancel().then(
    () => globalThis.__transformTerminateResults.push("cancel:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`cancel:${error === error1}:${error.message}`)
  );
  ts.readable.getReader().closed.then(
    () => globalThis.__transformTerminateResults.push("closed:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`closed:${error === error1}:${error.message}`)
  );
})()
"#,
    )
    .expect("terminate/error queued setup should evaluate");

    let result = vm
        .eval("JSON.stringify(globalThis.__transformTerminateResults.sort())")
        .expect("terminate/error queued promises should settle");

    assert_eq!(
        result,
        r#"["abort:TypeError","cancel:true:error1","closed:true:error1"]"#
    );
}

#[test]
fn transform_stream_terminate_then_error_without_queued_chunk_keeps_readable_closed() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const error1 = new Error("error1");
  const ts = new TransformStream({
    start(controller) {
      controller.terminate();
      controller.error(error1);
    }
  });
  globalThis.__transformTerminateResults = [];
  ts.writable.abort().then(
    () => globalThis.__transformTerminateResults.push("abort:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`abort:${error.name}`)
  );
  ts.readable.cancel().then(
    () => globalThis.__transformTerminateResults.push("cancel:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`cancel:${error === error1}:${error.message}`)
  );
  ts.readable.getReader().closed.then(
    () => globalThis.__transformTerminateResults.push("closed:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`closed:${error === error1}:${error.message}`)
  );
})()
"#,
    )
    .expect("terminate/error empty setup should evaluate");

    let result = vm
        .eval("JSON.stringify(globalThis.__transformTerminateResults.sort())")
        .expect("terminate/error empty promises should settle");

    assert_eq!(
        result,
        r#"["abort:TypeError","cancel:fulfilled","closed:fulfilled"]"#
    );
}

#[test]
fn transform_stream_terminate_inside_flush_allows_writer_close_to_succeed() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const ts = new TransformStream({
    flush(controller) {
      controller.terminate();
    }
  });
  const writer = ts.writable.getWriter();
  const reader = ts.readable.getReader();
  globalThis.__transformTerminateResults = [];
  writer.close().then(
    () => globalThis.__transformTerminateResults.push("close:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`close:${error.name}`)
  );
  writer.closed.then(
    () => globalThis.__transformTerminateResults.push("writerClosed:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`writerClosed:${error.name}`)
  );
  reader.closed.then(
    () => globalThis.__transformTerminateResults.push("readerClosed:fulfilled"),
    error => globalThis.__transformTerminateResults.push(`readerClosed:${error.name}`)
  );
})()
"#,
    )
    .expect("terminate in flush setup should evaluate");

    let result = vm
        .eval("JSON.stringify(globalThis.__transformTerminateResults.sort())")
        .expect("terminate in flush promises should settle");

    assert_eq!(
        result,
        r#"["close:fulfilled","readerClosed:fulfilled","writerClosed:fulfilled"]"#
    );
}

#[test]
fn transform_stream_writable_abort_errors_readable_with_abort_reason() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const abortReason = new Error("abort reason");
  abortReason.name = "abortReason";
  const ts = new TransformStream();
  const reader = ts.readable.getReader();
  globalThis.__transformAbortResults = [];
  ts.writable.abort(abortReason).then(
    () => globalThis.__transformAbortResults.push("abort:fulfilled"),
    error => globalThis.__transformAbortResults.push(`abort:${error.name}`)
  );
  reader.read().then(
    () => globalThis.__transformAbortResults.push("read:fulfilled"),
    error => globalThis.__transformAbortResults.push(`read:${error === abortReason}:${error.name}`)
  );
})()
"#,
    )
    .expect("writable abort setup should evaluate");

    let result = vm
        .eval("JSON.stringify(globalThis.__transformAbortResults.sort())")
        .expect("writable abort promises should settle");

    assert_eq!(result, r#"["abort:fulfilled","read:true:abortReason"]"#);
}

#[test]
fn transform_stream_writer_abort_reason_wins_over_following_readable_cancel() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const abortReason = new Error("abort reason");
  abortReason.name = "abortReason";
  const cancelReason = new Error("cancel reason");
  cancelReason.name = "cancelReason";
  const ts = new TransformStream();
  const writer = ts.writable.getWriter();
  globalThis.__transformAbortResults = [];
  writer.abort(abortReason).then(
    () => globalThis.__transformAbortResults.push("abort:fulfilled"),
    error => globalThis.__transformAbortResults.push(`abort:${error.name}`)
  );
  ts.readable.cancel(cancelReason).then(
    () => globalThis.__transformAbortResults.push("cancel:fulfilled"),
    error => globalThis.__transformAbortResults.push(`cancel:${error === abortReason}:${error.name}`)
  );
  writer.closed.then(
    () => globalThis.__transformAbortResults.push("closed:fulfilled"),
    error => globalThis.__transformAbortResults.push(`closed:${error === abortReason}:${error.name}`)
  );
})()
"#,
    )
    .expect("writer abort/cancel setup should evaluate");

    let result = vm
        .eval("JSON.stringify(globalThis.__transformAbortResults.sort())")
        .expect("writer abort/cancel promises should settle");

    assert_eq!(
        result,
        r#"["abort:fulfilled","cancel:fulfilled","closed:true:abortReason"]"#
    );
}

#[test]
fn transform_stream_controller_error_after_readable_cancel_preserves_cancel_result() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const controllerReason = new Error("controller reason");
  controllerReason.name = "controllerReason";
  const cancelReason = new Error("cancel reason");
  cancelReason.name = "cancelReason";
  let controller;
  const ts = new TransformStream({
    start(c) {
      controller = c;
    }
  });
  const writer = ts.writable.getWriter();
  globalThis.__transformCancelResults = [];
  ts.readable.cancel(cancelReason).then(
    () => globalThis.__transformCancelResults.push("cancel:fulfilled"),
    error => globalThis.__transformCancelResults.push(`cancel:${error.name}`)
  );
  controller.error(controllerReason);
  writer.closed.then(
    () => globalThis.__transformCancelResults.push("closed:fulfilled"),
    error => globalThis.__transformCancelResults.push(`closed:${error === controllerReason}:${error.name}`)
  );
})()
"#,
    )
    .expect("controller error after cancel setup should evaluate");

    let result = vm
        .eval("JSON.stringify(globalThis.__transformCancelResults.sort())")
        .expect("controller error after cancel promises should settle");

    assert_eq!(
        result,
        r#"["cancel:fulfilled","closed:true:controllerReason"]"#
    );
}

#[test]
fn transform_stream_strategy_size_error_keeps_controller_error_reason() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const controllerReason = new URIError("controller reason");
  const sizeError = new Error("redundant error");
  let controller;
  globalThis.__transformStrategyPriorityEvents = [];
  const strategy = {
    highWaterMark: 1,
    size() {
      controller.error(controllerReason);
      throw sizeError;
    }
  };
  const ts = new TransformStream({
    start(c) {
      controller = c;
    },
    transform(chunk, c) {
      try {
        c.enqueue(chunk);
      } catch (error) {
        globalThis.__transformStrategyPriorityEvents.push(
          `enqueue:${error === sizeError}:${error.message}`
        );
      }
    }
  }, undefined, strategy);
  const writer = ts.writable.getWriter();
  writer.write("chunk").then(
    () => globalThis.__transformStrategyPriorityEvents.push("write:fulfilled"),
    error => globalThis.__transformStrategyPriorityEvents.push(`write:${error.message}`)
  );
  writer.closed.catch(error => {
    globalThis.__transformStrategyPriorityEvents.push(
      `writerClosed:${error === controllerReason}:${error.name}:${error.message}`
    );
  });
  ts.readable.getReader().closed.catch(error => {
    globalThis.__transformStrategyPriorityEvents.push(
      `readableClosed:${error === controllerReason}:${error.name}:${error.message}`
    );
  });
})()
"#,
    )
    .expect("strategy size first error setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("JSON.stringify(globalThis.__transformStrategyPriorityEvents.sort())")
            .expect("strategy size first error promises should settle");
        if result.contains("writerClosed") && result.contains("readableClosed") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__transformStrategyPriorityEvents.sort())")
        .expect("strategy size first error result should evaluate");
    assert_eq!(
        result,
        r#"["enqueue:false:controller reason","readableClosed:true:URIError:controller reason","write:fulfilled","writerClosed:true:URIError:controller reason"]"#
    );
}

#[test]
fn transform_stream_strategy_size_uncaught_error_rethrows_size_error() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
(() => {
  const controllerReason = new URIError("controller reason");
  const sizeError = new Error("redundant error");
  let controller;
  try {
    new TransformStream({
      start(c) {
        controller = c;
        c.enqueue("chunk");
      },
      transform() {}
    }, undefined, {
      size() {
        controller.error(controllerReason);
        throw sizeError;
      }
    });
    return "no throw";
  } catch (error) {
    return `${error === sizeError}:${error.name}:${error.message}`;
  }
})()
"#,
        )
        .expect("strategy size uncaught error probe should evaluate");

    assert_eq!(result, "false:URIError:controller reason");
}

#[test]
fn readable_stream_pipe_through_uses_internal_pipe_and_validates_pair() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeThroughInternalEvents = [];
  const originalPipeTo = ReadableStream.prototype.pipeTo;
  ReadableStream.prototype.pipeTo = () => globalThis.__pipeThroughInternalEvents.push("patched-pipeTo");
  try {
    const source = new ReadableStream({
      start(controller) {
        controller.enqueue("a");
        controller.close();
      }
    });
    const readable = new ReadableStream();
    const writable = new WritableStream({
      write(chunk) {
        globalThis.__pipeThroughInternalEvents.push(`write:${chunk}`);
      },
      close() {
        globalThis.__pipeThroughInternalEvents.push("close");
      }
    });
    globalThis.__pipeThroughInternalEvents.push(source.pipeThrough({ readable, writable }) === readable);
  } finally {
    ReadableStream.prototype.pipeTo = originalPipeTo;
  }
})()
"#,
    )
    .expect("pipeThrough internal pipe probe should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeThroughInternalEvents)")
            .expect("pipeThrough internal pipe events should drain microtasks");
        if events.contains("close") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__pipeThroughInternalEvents)")
        .expect("pipeThrough internal pipe events should settle");
    assert_eq!(result, r#"[true,"write:a","close"]"#);
}

#[test]
fn readable_stream_pipe_through_preserves_pair_getter_errors() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
(() => {
  const source = new ReadableStream();
  const readableError = new Error("readable threw");
  const writableError = new Error("writable threw");
  const out = [];
  try {
    source.pipeThrough({
      get readable() {
        throw readableError;
      },
      get writable() {
        throw writableError;
      }
    }, {
      get preventAbort() {
        throw new Error("options threw");
      }
    });
  } catch (error) {
    out.push(error === readableError, error.message);
  }
  try {
    source.pipeThrough({
      readable: new ReadableStream(),
      get writable() {
        throw writableError;
      }
    });
  } catch (error) {
    out.push(error === writableError, error.message);
  }
  return JSON.stringify(out);
})()
"#,
        )
        .expect("pipeThrough getter error probe should evaluate");

    assert_eq!(result, r#"[true,"readable threw",true,"writable threw"]"#);
}

#[test]
fn readable_stream_pipe_through_validates_signal_and_locked_writable() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
(() => {
  const out = [];
  const source = new ReadableStream();
  const pair = { readable: new ReadableStream(), writable: new WritableStream() };
  try {
    source.pipeThrough(pair, { signal: null });
  } catch (error) {
    out.push(error.name);
  }
  const lockedWritable = new WritableStream();
  lockedWritable.getWriter();
  try {
    source.pipeThrough({ readable: new ReadableStream(), writable: lockedWritable });
  } catch (error) {
    out.push(error.name);
  }
  const controller = new AbortController();
  out.push(source.pipeThrough({
    readable: new ReadableStream(),
    writable: new WritableStream()
  }, { signal: controller.signal }) instanceof ReadableStream);
  return JSON.stringify(out);
})()
"#,
        )
        .expect("pipeThrough validation probe should evaluate");

    assert_eq!(result, r#"["TypeError","TypeError",true]"#);
}

#[test]
fn readable_stream_pipe_through_rejects_forged_stream_prototypes() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
(() => {
  const out = [];
  const forgedReadable = Object.create(ReadableStream.prototype);
  const forgedWritable = Object.create(WritableStream.prototype);
  const validPair = () => ({ readable: new ReadableStream(), writable: new WritableStream() });
  try {
    ReadableStream.prototype.pipeThrough.call(forgedReadable, validPair());
    out.push("forged-this accepted");
  } catch (error) {
    out.push(error.name);
  }
  let writableGetterCalled = false;
  try {
    new ReadableStream().pipeThrough({
      readable: forgedReadable,
      get writable() {
        writableGetterCalled = true;
        return new WritableStream();
      }
    });
    out.push("forged-readable accepted");
  } catch (error) {
    out.push(error.name, writableGetterCalled);
  }
  let readableGetterCalled = false;
  try {
    new ReadableStream().pipeThrough({
      get readable() {
        readableGetterCalled = true;
        return new ReadableStream();
      },
      writable: forgedWritable
    });
    out.push("forged-writable accepted");
  } catch (error) {
    out.push(readableGetterCalled, error.name);
  }
  return JSON.stringify(out);
})()
"#,
        )
        .expect("pipeThrough strict brand probe should evaluate");

    assert_eq!(
        result,
        r#"["TypeError","TypeError",false,true,"TypeError"]"#
    );
}

#[test]
fn readable_stream_pipe_through_duck_typed_pass_through_drains_async_pulls() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeThroughDuckTypedEvents = [];
  function duckTypedPassThroughTransform() {
    let enqueueInReadable;
    let closeReadable;
    return {
      writable: new WritableStream({
        write(chunk) {
          globalThis.__pipeThroughDuckTypedEvents.push(`write:${chunk}`);
          enqueueInReadable(chunk);
        },
        close() {
          globalThis.__pipeThroughDuckTypedEvents.push("close-writable");
          closeReadable();
        }
      }),
      readable: new ReadableStream({
        start(controller) {
          enqueueInReadable = controller.enqueue.bind(controller);
          closeReadable = controller.close.bind(controller);
        }
      })
    };
  }
  function readableStreamToArray(readable) {
    const reader = readable.getReader();
    const chunks = [];
    function pump() {
      return reader.read().then(result => {
        if (result.done) {
          return chunks;
        }
        chunks.push(result.value);
        return pump();
      });
    }
    return pump();
  }
  let current = 0;
  const source = new ReadableStream({
    start() {
      return Promise.resolve();
    },
    pull(controller) {
      current += 1;
      globalThis.__pipeThroughDuckTypedEvents.push(`pull:${current}`);
      if (current <= 5) {
        controller.enqueue(current);
      } else {
        controller.close();
      }
      return Promise.resolve();
    }
  });
  globalThis.__pipeThroughDuckTypedResult = "pending";
  const readableEnd = source.pipeThrough(duckTypedPassThroughTransform());
  readableStreamToArray(readableEnd).then(
    chunks => {
      globalThis.__pipeThroughDuckTypedEvents.push("resolved");
      globalThis.__pipeThroughDuckTypedResult = JSON.stringify(chunks);
    },
    error => {
      globalThis.__pipeThroughDuckTypedEvents.push("rejected");
      globalThis.__pipeThroughDuckTypedResult = `error:${error && error.message}`;
    }
  );
})()
"#,
    )
    .expect("duck-typed pass-through pipeThrough setup should evaluate");

    for _ in 0..16 {
        let result = vm
            .eval("globalThis.__pipeThroughDuckTypedResult")
            .expect("duck-typed pass-through pipeThrough should drain microtasks");
        if result != "pending" {
            break;
        }
    }
    let result = vm
        .eval(
            "JSON.stringify({ result: globalThis.__pipeThroughDuckTypedResult, events: globalThis.__pipeThroughDuckTypedEvents })",
        )
        .expect("duck-typed pass-through pipeThrough should settle");

    assert_eq!(
        result,
        r#"{"result":"[1,2,3,4,5]","events":["pull:1","write:1","pull:2","write:2","pull:3","write:3","pull:4","write:4","pull:5","write:5","pull:6","close-writable","resolved"]}"#
    );
}

#[test]
fn readable_pipe_delivers_enqueued_chunk_while_pull_promise_remains_pending() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pendingPullPipeResult = {
    direct: [],
    transform: [],
    directSettled: false,
    transformSettled: false
  };
  const result = globalThis.__pendingPullPipeResult;
  const never = () => new Promise(() => {});

  const directSource = new ReadableStream({
    pull(controller) {
      result.direct.push("pull");
      controller.enqueue("direct");
      return never();
    }
  }, { highWaterMark: 0 });
  directSource.pipeTo(new WritableStream({
    write(chunk) { result.direct.push(`write:${chunk}`); }
  })).then(
    () => { result.directSettled = true; },
    () => { result.directSettled = true; }
  );

  const transformSource = new ReadableStream({
    pull(controller) {
      result.transform.push("pull");
      controller.enqueue("transform");
      return never();
    }
  }, { highWaterMark: 0 });
  const output = transformSource.pipeThrough(new TransformStream({
    transform(chunk, controller) {
      result.transform.push(`transform:${chunk}`);
      controller.enqueue(chunk);
    }
  }));
  output.getReader().read().then(
    value => {
      result.transform.push(`read:${value.value}:${value.done}`);
      result.transformSettled = true;
    },
    () => { result.transformSettled = true; }
  );
})()
"#,
    )
    .expect("pending pull pipe cases should initialize");

    for _ in 0..16 {
        let result = vm
            .eval("JSON.stringify(globalThis.__pendingPullPipeResult)")
            .expect("pending pull pipe cases should drain");
        if result.contains("write:direct") && result.contains("read:transform:false") {
            break;
        }
    }

    let result = vm
        .eval("JSON.stringify(globalThis.__pendingPullPipeResult)")
        .expect("pending pull pipe result should evaluate");
    assert_eq!(
        result,
        r#"{"direct":["pull","write:direct"],"transform":["pull","transform:transform","read:transform:false"],"directSettled":false,"transformSettled":true}"#
    );
}

#[test]
fn readable_stream_pending_read_pulls_after_async_start() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__asyncStartReadEvents = [];
  let pulls = 0;
  const stream = new ReadableStream({
    start() {
      globalThis.__asyncStartReadEvents.push("start");
      return Promise.resolve();
    },
    pull(controller) {
      pulls += 1;
      globalThis.__asyncStartReadEvents.push(`pull:${pulls}`);
      controller.enqueue(`chunk:${pulls}`);
    }
  }, { highWaterMark: 0 });
  stream.getReader().read().then(
    result => globalThis.__asyncStartReadEvents.push(`${result.value}:${result.done}`),
    error => globalThis.__asyncStartReadEvents.push(`error:${error && error.name}`)
  );
})()
"#,
    )
    .expect("async start pending read setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__asyncStartReadEvents)")
            .expect("async start pending read should drain microtasks");
        if events.contains("chunk:1:false") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__asyncStartReadEvents)")
        .expect("async start pending read should settle");
    assert_eq!(events, r#"["start","pull:1","chunk:1:false"]"#);
}

#[test]
fn readable_stream_pipe_through_handles_writable_error_and_prevent_abort() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeThroughErrorEvents = [];
  const sinkError = new Error("sink");
  const source = new ReadableStream({
    pull() {
      globalThis.__pipeThroughErrorEvents.push("pull");
    },
    cancel() {
      globalThis.__pipeThroughErrorEvents.push("cancel");
    }
  }, { highWaterMark: 0 });
  const erroredWritable = new WritableStream({
    start(controller) {
      globalThis.__pipeThroughErrorEvents.push(`writable-error:${typeof controller.error}`);
      controller.error(sinkError);
    }
  });
  source.pipeThrough(
    { writable: erroredWritable, readable: new ReadableStream() },
    { preventCancel: true }
  );

  const erroredSource = new ReadableStream({
    start(controller) {
      controller.error();
    }
  });
  const notAbortedWritable = new WritableStream({
    close() {
      globalThis.__pipeThroughErrorEvents.push("close");
    },
    abort() {
      globalThis.__pipeThroughErrorEvents.push("abort");
    }
  });
  erroredSource
    .pipeTo(notAbortedWritable, { preventAbort: true })
    .catch(error => {
      globalThis.__pipeThroughErrorEvents.push(`prevent-abort:${String(error)}`);
    });
})()
"#,
    )
    .expect("pipeThrough error/preventAbort setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeThroughErrorEvents)")
            .expect("pipeThrough error/preventAbort should drain microtasks");
        if events.contains("prevent-abort:undefined") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeThroughErrorEvents)")
        .expect("pipeThrough error/preventAbort events should settle");
    assert_eq!(
        events,
        r#"["writable-error:function","prevent-abort:undefined"]"#
    );
}

#[test]
fn readable_stream_pipe_through_prevent_close_keeps_writable_open() {
    let mut vm = stream_test_vm();

    let result = vm
        .eval(
            r#"
(() => {
  const events = [];
  const source = new ReadableStream({
    start(controller) {
      controller.close();
    }
  });
  const pair = {
    readable: new ReadableStream(),
    writable: new WritableStream({
      close() {
        events.push("close");
      }
    })
  };
  source.pipeThrough(pair, { preventClose: true });
  return JSON.stringify(events);
})()
"#,
        )
        .expect("pipeThrough preventClose probe should evaluate");

    assert_eq!(result, r#"[]"#);
}

#[test]
fn readable_stream_pipe_to_validates_brand_and_locked_as_rejected_promises() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToValidationEvents = [];
  function observe(label, thunk) {
    try {
      const result = thunk();
      globalThis.__pipeToValidationEvents.push(`${label}:returned:${result instanceof Promise}`);
      result.then(
        () => globalThis.__pipeToValidationEvents.push(`${label}:fulfilled`),
        error => globalThis.__pipeToValidationEvents.push(`${label}:rejected:${error && error.name}`)
      );
    } catch (error) {
      globalThis.__pipeToValidationEvents.push(`${label}:threw:${error && error.name}`);
    }
  }

  observe("bad-this", () => ReadableStream.prototype.pipeTo.call({}, new WritableStream()));
  observe("bad-dest", () => new ReadableStream().pipeTo({}));

  const lockedReadable = new ReadableStream();
  lockedReadable.getReader();
  observe("source-locked", () => lockedReadable.pipeTo(new WritableStream()));

  const lockedWritable = new WritableStream();
  lockedWritable.getWriter();
  observe("dest-locked", () => new ReadableStream().pipeTo(lockedWritable));
})()
"#,
    )
    .expect("pipeTo validation setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToValidationEvents)")
            .expect("pipeTo validation should drain promise reactions");
        if events.matches(":rejected:TypeError").count() == 4 {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToValidationEvents.sort())")
        .expect("pipeTo validation events should settle");
    assert_eq!(
        events,
        r#"["bad-dest:rejected:TypeError","bad-dest:returned:true","bad-this:rejected:TypeError","bad-this:returned:true","dest-locked:rejected:TypeError","dest-locked:returned:true","source-locked:rejected:TypeError","source-locked:returned:true"]"#
    );
}

#[test]
fn readable_stream_pipe_options_reject_non_object_values_with_entrypoint_semantics() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeOptionConversionEvents = [];
  function observePipeTo(label, options) {
    try {
      const promise = new ReadableStream().pipeTo(new WritableStream(), options);
      globalThis.__pipeOptionConversionEvents.push(`${label}:returned:${promise instanceof Promise}`);
      promise.then(
        () => globalThis.__pipeOptionConversionEvents.push(`${label}:fulfilled`),
        error => globalThis.__pipeOptionConversionEvents.push(`${label}:rejected:${error && error.name}`)
      );
    } catch (error) {
      globalThis.__pipeOptionConversionEvents.push(`${label}:threw:${error && error.name}`);
    }
  }
  function observePipeThrough(label, options) {
    try {
      new ReadableStream().pipeThrough(new TransformStream(), options);
      globalThis.__pipeOptionConversionEvents.push(`${label}:returned`);
    } catch (error) {
      globalThis.__pipeOptionConversionEvents.push(`${label}:threw:${error && error.name}`);
    }
  }

  observePipeTo("pipeTo-symbol", Symbol("options"));
  observePipeTo("pipeTo-boolean", true);
  observePipeThrough("pipeThrough-symbol", Symbol("options"));
  observePipeThrough("pipeThrough-boolean", true);
})()
"#,
    )
    .expect("pipe options conversion setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeOptionConversionEvents)")
            .expect("pipe options conversion promise reactions should drain");
        if events.matches(":rejected:TypeError").count() == 2 {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeOptionConversionEvents.sort())")
        .expect("pipe options conversion events should settle");
    assert_eq!(
        events,
        r#"["pipeThrough-boolean:threw:TypeError","pipeThrough-symbol:threw:TypeError","pipeTo-boolean:rejected:TypeError","pipeTo-boolean:returned:true","pipeTo-symbol:rejected:TypeError","pipeTo-symbol:returned:true"]"#
    );
}

#[test]
fn readable_stream_pipe_to_aborts_on_signal_and_honors_prevent_flags() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeAbortEvents = [];

  const reason = new Error("pipe abort");
  const controller = new AbortController();
  const readable = new ReadableStream({
    pull() {
      globalThis.__pipeAbortEvents.push("pull");
    },
    cancel(value) {
      globalThis.__pipeAbortEvents.push(`cancel:${value === reason}`);
    }
  }, { highWaterMark: 0 });
  const writable = new WritableStream({
    abort(value) {
      globalThis.__pipeAbortEvents.push(`abort:${value === reason}`);
    }
  });
  readable.pipeTo(writable, { signal: controller.signal }).then(
    () => globalThis.__pipeAbortEvents.push("pipe:fulfilled"),
    value => globalThis.__pipeAbortEvents.push(
      `pipe:${value === reason}:${readable.locked}:${writable.locked}`
    )
  );
  globalThis.__pipeAbortEvents.push(`locked:${readable.locked}:${writable.locked}`);
  Promise.resolve().then(() => {
    globalThis.__pipeAbortEvents.push("abort-call");
    controller.abort(reason);
    globalThis.__pipeAbortEvents.push(`after:${readable.locked}:${writable.locked}`);
  });

  const preventedReason = new Error("prevented abort");
  const preventedController = new AbortController();
  const preventedReadable = new ReadableStream({
    cancel() {
      globalThis.__pipeAbortEvents.push("prevented-cancel");
    }
  }, { highWaterMark: 0 });
  const preventedWritable = new WritableStream({
    abort() {
      globalThis.__pipeAbortEvents.push("prevented-abort");
    }
  });
  preventedController.abort(preventedReason);
  preventedReadable.pipeTo(preventedWritable, {
    signal: preventedController.signal,
    preventAbort: true,
    preventCancel: true
  }).then(
    () => globalThis.__pipeAbortEvents.push("prevented-pipe:fulfilled"),
    value => globalThis.__pipeAbortEvents.push(
      `prevented-pipe:${value === preventedReason}:` +
      `${preventedReadable.locked}:${preventedWritable.locked}`
    )
  );
  globalThis.__pipeAbortEvents.push(
    `prevented-locked:${preventedReadable.locked}:${preventedWritable.locked}`
  );
})()
"#,
    )
    .expect("pipeTo abort signal setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeAbortEvents)")
            .expect("pipeTo abort signal events should drain");
        if events.contains("pipe:true:false:false")
            && events.contains("prevented-pipe:true:false:false")
        {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeAbortEvents)")
        .expect("pipeTo abort signal events should settle");
    assert_eq!(
        events,
        // Chromium retains both locks until the abort/cancel action promises
        // settle; abort dispatch itself only claims shutdown. An already
        // aborted signal follows the same asynchronous shutdown path even
        // when both propagation actions are prevented.
        r#"["locked:true:true","prevented-locked:true:true","pull","abort-call","after:true:true","abort:true","cancel:true","prevented-pipe:true:false:false","pipe:true:false:false"]"#
    );
}

#[test]
fn readable_stream_pipe_abort_actions_own_all_rejections() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeAbortRejectionEvents = [];
  addEventListener("unhandledrejection", event => {
    globalThis.__pipeAbortRejectionEvents.push(`unhandled:${event.reason.message}`);
    event.preventDefault();
  });

  function abortedController() {
    const controller = new AbortController();
    controller.abort(new Error("signal"));
    return controller;
  }

  const sourceError = new Error("source-only");
  new ReadableStream({
    cancel() { return Promise.reject(sourceError); }
  }, { highWaterMark: 0 })
    .pipeTo(new WritableStream(), { signal: abortedController().signal })
    .catch(error => globalThis.__pipeAbortRejectionEvents.push(`source:${error.message}`));

  const sinkError = new Error("sink-only");
  new ReadableStream({}, { highWaterMark: 0 })
    .pipeTo(new WritableStream({
      abort() { return Promise.reject(sinkError); }
    }), { signal: abortedController().signal })
    .catch(error => globalThis.__pipeAbortRejectionEvents.push(`sink:${error.message}`));

  const sourceSecondError = new Error("source-second");
  const sinkFirstError = new Error("sink-first");
  new ReadableStream({
    cancel() { return Promise.reject(sourceSecondError); }
  }, { highWaterMark: 0 })
    .pipeTo(new WritableStream({
      abort() { return Promise.reject(sinkFirstError); }
    }), { signal: abortedController().signal })
    .catch(error => globalThis.__pipeAbortRejectionEvents.push(`both:${error.message}`));

  const pendingPullError = new Error("pending-pull");
  let rejectCancel;
  const cancelPromise = new Promise((_, reject) => { rejectCancel = reject; });
  const pendingPullController = new AbortController();
  new ReadableStream({
    async pull() { await cancelPromise; },
    cancel(reason) { rejectCancel(reason); }
  })
    .pipeTo(new WritableStream(), { signal: pendingPullController.signal })
    .catch(error => globalThis.__pipeAbortRejectionEvents.push(`pending:${error.message}`));
  Promise.resolve().then(() => pendingPullController.abort(pendingPullError));
})()
"#,
    )
    .expect("pipe abort rejection ownership setup should evaluate");

    for _ in 0..8 {
        vm.eval("0")
            .expect("pipe abort rejection ownership checkpoint should evaluate");
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeAbortRejectionEvents.sort())")
        .expect("pipe abort rejection ownership events should evaluate");
    assert_eq!(
        events,
        r#"["both:sink-first","pending:pending-pull","sink:sink-only","source:source-only"]"#
    );
}

#[test]
fn readable_stream_pipe_source_error_during_write_waits_for_published_write() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeReentrantSourceErrorEvents = [];
  const sourceError = new Error("source failed during write");
  let readableController;
  const readable = new ReadableStream({
    start(controller) { readableController = controller; }
  });
  let resolveWrite;
  const writable = new WritableStream({
    write() {
      globalThis.__pipeReentrantSourceErrorEvents.push("write");
      readableController.error(sourceError);
      return new Promise(resolve => { resolveWrite = resolve; });
    }
  });
  readable.pipeTo(writable, { preventAbort: true }).then(
    () => globalThis.__pipeReentrantSourceErrorEvents.push("pipe:fulfilled"),
    error => globalThis.__pipeReentrantSourceErrorEvents.push(
      `pipe:${error === sourceError}:${readable.locked}:${writable.locked}`
    )
  );
  readableController.enqueue("chunk");
  globalThis.__resolvePipeReentrantWrite = () => {
    globalThis.__pipeReentrantSourceErrorEvents.push("write:resolve");
    resolveWrite();
  };
})()
"#,
    )
    .expect("reentrant source error pipe setup should evaluate");

    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__pipeReentrantSourceErrorEvents)")
            .expect("reentrant source error must wait for write publication"),
        r#"["write"]"#
    );

    vm.eval("globalThis.__resolvePipeReentrantWrite()")
        .expect("reentrant source error write should resolve");
    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeReentrantSourceErrorEvents)")
            .expect("reentrant source error pipe should drain");
        if events.contains("pipe:true:false:false") {
            break;
        }
    }
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__pipeReentrantSourceErrorEvents)")
            .expect("reentrant source error pipe events should settle"),
        r#"["write","write:resolve","pipe:true:false:false"]"#
    );
}

#[test]
fn readable_stream_pipe_prefers_an_already_erroring_destination_reason() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeErroringDestinationResult = "pending";
  const sourceError = new Error("source");
  const destinationError = new Error("destination");
  const events = [];
  const source = new ReadableStream({
    start(controller) { controller.error(sourceError); }
  });
  const destination = new WritableStream({
    start(controller) { controller.error(destinationError); },
    abort() { events.push("abort"); }
  });
  source.pipeTo(destination).then(
    () => { globalThis.__pipeErroringDestinationResult = "fulfilled"; },
    error => {
      globalThis.__pipeErroringDestinationResult = JSON.stringify({
        destinationError: error === destinationError,
        events,
        sourceLocked: source.locked,
        destinationLocked: destination.locked
      });
    }
  );
})()
"#,
    )
    .expect("erroring destination pipe setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__pipeErroringDestinationResult")
            .expect("erroring destination pipe should drain");
        if result != "pending" {
            break;
        }
    }
    assert_eq!(
        vm.eval("globalThis.__pipeErroringDestinationResult")
            .expect("erroring destination pipe should settle"),
        r#"{"destinationError":true,"events":[],"sourceLocked":false,"destinationLocked":false}"#
    );
}

#[test]
fn readable_stream_pipe_to_signal_uses_internal_abort_algorithm() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeAbortAlgorithmEvents = [];
  const originalAdd = AbortSignal.prototype.addEventListener;
  const originalRemove = AbortSignal.prototype.removeEventListener;
  AbortSignal.prototype.addEventListener = function() {
    globalThis.__pipeAbortAlgorithmEvents.push("patched-add");
    throw new Error("patched addEventListener should not be used");
  };
  AbortSignal.prototype.removeEventListener = function() {
    globalThis.__pipeAbortAlgorithmEvents.push("patched-remove");
    throw new Error("patched removeEventListener should not be used");
  };

  const reason = new Error("algorithm abort");
  const controller = new AbortController();
  const readable = new ReadableStream({
    pull() {
      globalThis.__pipeAbortAlgorithmEvents.push("pull");
    },
    cancel(value) {
      globalThis.__pipeAbortAlgorithmEvents.push(`cancel:${value === reason}`);
    }
  }, { highWaterMark: 0 });
  const writable = new WritableStream({
    abort(value) {
      globalThis.__pipeAbortAlgorithmEvents.push(`abort:${value === reason}`);
    }
  });
  const pipePromise = readable.pipeTo(writable, { signal: controller.signal });
  controller.signal.dispatchEvent(new Event("abort"));
  globalThis.__pipeAbortAlgorithmEvents.push(
    `after-dispatch:${readable.locked}:${writable.locked}`
  );
  Promise.resolve().then(() => controller.abort(reason));
  pipePromise.then(
    () => globalThis.__pipeAbortAlgorithmEvents.push("pipe:fulfilled"),
    value => {
      globalThis.__pipeAbortAlgorithmEvents.push(
        `pipe:${value === reason}:${readable.locked}:${writable.locked}`
      );
      AbortSignal.prototype.addEventListener = originalAdd;
      AbortSignal.prototype.removeEventListener = originalRemove;
    }
  );
})()
"#,
    )
    .expect("pipeTo internal abort algorithm setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeAbortAlgorithmEvents)")
            .expect("pipeTo internal abort algorithm events should drain");
        if events.contains("pipe:true:false:false") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeAbortAlgorithmEvents)")
        .expect("pipeTo internal abort algorithm events should settle");
    assert_eq!(
        events,
        r#"["after-dispatch:true:true","pull","abort:true","cancel:true","pipe:true:false:false"]"#
    );
}

#[test]
fn readable_stream_pipe_to_locks_both_streams_and_releases_on_close() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToLockEvents = [];
  let controller;
  const readable = new ReadableStream({
    start(c) {
      controller = c;
    }
  }, { highWaterMark: 0 });
  const writable = new WritableStream({
    close() {
      globalThis.__pipeToLockEvents.push("close");
    }
  });
  readable.pipeTo(writable).then(
    () => globalThis.__pipeToLockEvents.push(`settled:${readable.locked}:${writable.locked}`),
    error => globalThis.__pipeToLockEvents.push(`rejected:${error && error.name}`)
  );
  globalThis.__pipeToLockEvents.push(`locked:${readable.locked}:${writable.locked}`);
  controller.close();
})()
"#,
    )
    .expect("pipeTo lock setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToLockEvents)")
            .expect("pipeTo lock events should drain microtasks");
        if events.contains("settled:false:false") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToLockEvents)")
        .expect("pipeTo lock events should settle");
    assert_eq!(
        events,
        r#"["locked:true:true","close","settled:false:false"]"#
    );
}

#[test]
fn readable_stream_pipe_to_does_not_write_synchronously_from_enqueue() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToAsyncEnqueueEvents = [];
  let controller;
  const readable = new ReadableStream({
    start(c) {
      controller = c;
    }
  }, { highWaterMark: 0 });
  const writable = new WritableStream({
    write(chunk) {
      globalThis.__pipeToAsyncEnqueueEvents.push(`write:${chunk}`);
    },
    close() {
      globalThis.__pipeToAsyncEnqueueEvents.push("close");
    }
  });
  readable.pipeTo(writable).then(
    () => globalThis.__pipeToAsyncEnqueueEvents.push("pipe:fulfilled"),
    error => globalThis.__pipeToAsyncEnqueueEvents.push(`pipe:rejected:${error && error.name}`)
  );
  Promise.resolve().then(() => {
    globalThis.__pipeToAsyncEnqueueEvents.push("before-enqueue");
    controller.enqueue("chunk");
    globalThis.__pipeToAsyncEnqueueEvents.push(
      `after-enqueue:${globalThis.__pipeToAsyncEnqueueEvents.includes("write:chunk")}`
    );
    controller.close();
  });
})()
"#,
    )
    .expect("pipeTo async enqueue setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToAsyncEnqueueEvents)")
            .expect("pipeTo async enqueue events should drain microtasks");
        if events.contains("pipe:fulfilled") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToAsyncEnqueueEvents)")
        .expect("pipeTo async enqueue events should settle");
    assert_eq!(
        events,
        r#"["before-enqueue","after-enqueue:false","write:chunk","close","pipe:fulfilled"]"#
    );
}

#[test]
fn readable_stream_pipe_to_waits_when_destination_desired_size_is_zero() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToBackpressureEvents = [];
  const error = new Error("backpressured");
  let writableController;
  const readable = new ReadableStream({
    start(controller) {
      controller.enqueue("a");
      controller.enqueue("b");
      controller.close();
    },
    pull() {
      globalThis.__pipeToBackpressureEvents.push("pull");
    },
    cancel(reason) {
      globalThis.__pipeToBackpressureEvents.push(`cancel:${reason === error}`);
    }
  });
  const writable = new WritableStream({
    start(controller) {
      writableController = controller;
    },
    write(chunk) {
      globalThis.__pipeToBackpressureEvents.push(`write:${chunk}`);
    }
  }, new CountQueuingStrategy({ highWaterMark: 0 }));
  readable.pipeTo(writable, { preventCancel: true }).then(
    () => globalThis.__pipeToBackpressureEvents.push("pipe:fulfilled"),
    reason => globalThis.__pipeToBackpressureEvents.push(
      `pipe:${reason === error}:${readable.locked}:${writable.locked}`
    )
  );
  Promise.resolve().then(() => {
    globalThis.__pipeToBackpressureEvents.push(
      `before-error:${globalThis.__pipeToBackpressureEvents.includes("pull")}:` +
      `${globalThis.__pipeToBackpressureEvents.includes("write:a")}`
    );
    writableController.error(error);
  });
})()
"#,
    )
    .expect("pipeTo backpressure setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToBackpressureEvents)")
            .expect("pipeTo backpressure events should drain microtasks");
        if events.contains("pipe:true:false:false") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToBackpressureEvents)")
        .expect("pipeTo backpressure events should settle");
    assert_eq!(
        events,
        r#"["before-error:false:false","pipe:true:false:false"]"#
    );
}

#[test]
fn writable_stream_serializes_sink_writes_behind_in_flight_write() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__sinkWriteQueueEvents = [];
  let resolveFirst;
  const writable = new WritableStream({
    write(chunk) {
      globalThis.__sinkWriteQueueEvents.push(`write:${chunk}`);
      if (chunk === "a") {
        return new Promise(resolve => {
          resolveFirst = resolve;
          globalThis.__resolveFirstSinkWrite = resolve;
        });
      }
      return undefined;
    }
  }, new CountQueuingStrategy({ highWaterMark: 3 }));
  const writer = writable.getWriter();
  writer.write("a").then(() => globalThis.__sinkWriteQueueEvents.push("first:fulfilled"));
  writer.write("b").then(() => globalThis.__sinkWriteQueueEvents.push("second:fulfilled"));
  Promise.resolve().then(() => {
    globalThis.__sinkWriteQueueEvents.push(
      `checkpoint:${globalThis.__sinkWriteQueueEvents.includes("write:b")}`
    );
  });
})()
"#,
    )
    .expect("writable sink write queue setup should evaluate");

    let events = vm
        .eval("JSON.stringify(globalThis.__sinkWriteQueueEvents)")
        .expect("writable sink write queue should reach checkpoint");
    assert_eq!(events, r#"["write:a","checkpoint:false"]"#);

    vm.eval("globalThis.__resolveFirstSinkWrite()")
        .expect("first sink write should resolve");
    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__sinkWriteQueueEvents)")
            .expect("writable sink write queue should drain");
        if events.contains("second:fulfilled") {
            break;
        }
    }

    let result = vm
        .eval(
            r#"
(() => {
  const events = globalThis.__sinkWriteQueueEvents;
  return JSON.stringify({
    writeA: events.indexOf("write:a"),
    writeB: events.indexOf("write:b"),
    first: events.indexOf("first:fulfilled"),
    second: events.indexOf("second:fulfilled")
  });
})()
"#,
        )
        .expect("writable sink write queue final state should evaluate");
    assert_eq!(result, r#"{"writeA":0,"writeB":2,"first":3,"second":4}"#);
}

#[test]
fn writable_stream_queues_sink_close_behind_in_flight_writes() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__sinkCloseQueueEvents = [];
  let resolveFirst;
  let resolveClose;
  const writable = new WritableStream({
    write(chunk) {
      globalThis.__sinkCloseQueueEvents.push(`write:${chunk}`);
      if (chunk === "a") {
        return new Promise(resolve => {
          resolveFirst = resolve;
          globalThis.__resolveFirstSinkCloseWrite = resolve;
        });
      }
      return undefined;
    },
    close() {
      globalThis.__sinkCloseQueueEvents.push("sink:close");
      return new Promise(resolve => {
        resolveClose = resolve;
      });
    }
  }, new CountQueuingStrategy({ highWaterMark: 3 }));
  const writer = writable.getWriter();
  writer.write("a").then(() => globalThis.__sinkCloseQueueEvents.push("first:fulfilled"));
  writer.write("b").then(() => globalThis.__sinkCloseQueueEvents.push("second:fulfilled"));
  writer.close().then(() => globalThis.__sinkCloseQueueEvents.push("close:fulfilled"));
  globalThis.__resolveQueuedSinkClose = () => resolveClose();
})()
"#,
    )
    .expect("writable sink close queue setup should evaluate");

    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__sinkCloseQueueEvents)")
            .expect("queued sink close should wait behind the first write"),
        r#"["write:a"]"#
    );

    vm.eval("globalThis.__resolveFirstSinkCloseWrite()")
        .expect("first queued sink write should resolve");
    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__sinkCloseQueueEvents)")
            .expect("queued sink close should advance");
        if events.contains("sink:close") {
            break;
        }
    }
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__sinkCloseQueueEvents)")
            .expect("queued sink close should start after both writes"),
        r#"["write:a","write:b","first:fulfilled","sink:close","second:fulfilled"]"#
    );

    vm.eval("globalThis.__resolveQueuedSinkClose()")
        .expect("queued sink close should resolve");
    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__sinkCloseQueueEvents)")
            .expect("queued sink close fulfillment should drain");
        if events.contains("close:fulfilled") {
            break;
        }
    }
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__sinkCloseQueueEvents)")
            .expect("queued sink close should settle"),
        r#"["write:a","write:b","first:fulfilled","sink:close","second:fulfilled","close:fulfilled"]"#
    );
}

#[test]
fn writable_sink_queue_resumes_large_burst_after_in_flight_write() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const writeTotal = 1026;
  globalThis.__sinkBurstWrites = 0;
  globalThis.__sinkBurstSettled = 0;
  globalThis.__sinkBurstResult = "pending";
  const writable = new WritableStream({
    write(chunk) {
      globalThis.__sinkBurstWrites += 1;
      if (chunk === 0) {
        return new Promise(resolve => {
          globalThis.__resolveSinkBurstFirst = resolve;
        });
      }
      return undefined;
    }
  }, new CountQueuingStrategy({ highWaterMark: 2048 }));
  const writer = writable.getWriter();
  const writes = Array.from({ length: writeTotal }, (_, chunk) =>
    writer.write(chunk).then(() => {
      globalThis.__sinkBurstSettled += 1;
    })
  );
  Promise.all(writes).then(
    () => { globalThis.__sinkBurstResult = "fulfilled"; },
    error => { globalThis.__sinkBurstResult = `rejected:${error && error.name}`; }
  );
})()
"#,
    )
    .expect("writable sink burst setup should evaluate");

    vm.eval("globalThis.__resolveSinkBurstFirst()")
        .expect("first writable sink write should resolve");
    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__sinkBurstResult")
            .expect("writable sink continuation should drain microtasks");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval(
            "JSON.stringify({ result: globalThis.__sinkBurstResult, writes: globalThis.__sinkBurstWrites, settled: globalThis.__sinkBurstSettled })",
        )
        .expect("writable sink continuation result should evaluate");
    assert_eq!(
        result,
        r#"{"result":"fulfilled","writes":1026,"settled":1026}"#
    );
}

#[test]
fn transform_writable_queue_resumes_large_burst_after_in_flight_write() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const writeTotal = 1026;
  let resolveFirst;
  globalThis.__transformBurstRuns = 0;
  globalThis.__transformBurstSettled = 0;
  globalThis.__transformBurstResult = "pending";
  const transform = new TransformStream({
    transform(chunk, controller) {
      globalThis.__transformBurstRuns += 1;
      controller.enqueue(chunk);
      if (chunk === 0) {
        return new Promise(resolve => {
          globalThis.__resolveTransformBurstFirst = resolve;
        });
      }
      return undefined;
    }
  }, { highWaterMark: 2048 }, { highWaterMark: 2048 });
  const writer = transform.writable.getWriter();
  const writes = Array.from({ length: writeTotal }, (_, chunk) =>
    writer.write(chunk).then(() => {
      globalThis.__transformBurstSettled += 1;
    })
  );
  Promise.all(writes).then(
    () => { globalThis.__transformBurstResult = "fulfilled"; },
    error => {
      globalThis.__transformBurstResult = `rejected:${error && error.name}`;
    }
  );
})()
"#,
    )
    .expect("transform writable burst setup should evaluate");

    vm.eval("globalThis.__resolveTransformBurstFirst()")
        .expect("first transform write should resolve");
    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__transformBurstResult")
            .expect("transform writable continuation should drain microtasks");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval(
            "JSON.stringify({ result: globalThis.__transformBurstResult, runs: globalThis.__transformBurstRuns, settled: globalThis.__transformBurstSettled })",
        )
        .expect("transform writable continuation result should evaluate");
    assert_eq!(
        result,
        r#"{"result":"fulfilled","runs":1026,"settled":1026}"#
    );
}

#[test]
fn readable_pipe_drain_completes_large_ready_burst() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  const chunkTotal = 1026;
  globalThis.__pipeBurstWrites = 0;
  globalThis.__pipeBurstResult = "pending";
  const readable = new ReadableStream({
    start(controller) {
      for (let chunk = 0; chunk < chunkTotal; chunk += 1) {
        controller.enqueue(chunk);
      }
      controller.close();
    }
  }, new CountQueuingStrategy({ highWaterMark: 2048 }));
  const writable = new WritableStream({
    write() {
      globalThis.__pipeBurstWrites += 1;
    }
  }, new CountQueuingStrategy({ highWaterMark: 2048 }));
  readable.pipeTo(writable).then(
    () => { globalThis.__pipeBurstResult = "fulfilled"; },
    error => { globalThis.__pipeBurstResult = `rejected:${error && error.name}`; }
  );
})()
"#,
    )
    .expect("readable pipe burst setup should evaluate");

    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__pipeBurstResult")
            .expect("readable pipe continuation should drain microtasks");
        if result != "pending" {
            break;
        }
    }

    let result = vm
        .eval(
            "JSON.stringify({ result: globalThis.__pipeBurstResult, writes: globalThis.__pipeBurstWrites })",
        )
        .expect("readable pipe continuation result should evaluate");
    assert_eq!(result, r#"{"result":"fulfilled","writes":1026}"#);
}

#[test]
fn readable_stream_pipe_to_queues_writes_until_previous_sink_write_finishes() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToQueuedWriteEvents = [];
  const unread = ["b", "c", "d"];
  let resolveFirst;
  const readable = new ReadableStream({
    pull(controller) {
      const chunk = unread.shift();
      globalThis.__pipeToQueuedWriteEvents.push(`pull:${chunk}`);
      controller.enqueue(chunk);
      if (unread.length === 0) {
        controller.close();
      }
    }
  }, new CountQueuingStrategy({ highWaterMark: 0 }));
  const writable = new WritableStream({
    write(chunk) {
      globalThis.__pipeToQueuedWriteEvents.push(`write:${chunk}`);
      if (!resolveFirst) {
        return new Promise(resolve => {
          resolveFirst = resolve;
          globalThis.__resolvePipeFirstSinkWrite = resolve;
        });
      }
      return undefined;
    },
    close() {
      globalThis.__pipeToQueuedWriteEvents.push("close");
    }
  }, new CountQueuingStrategy({ highWaterMark: 3 }));
  const writer = writable.getWriter();
  writer.write("a");
  globalThis.__pipeToQueuedWriteEvents.push(`desired:${writer.desiredSize}`);
  writer.releaseLock();
  readable.pipeTo(writable).then(
    () => globalThis.__pipeToQueuedWriteEvents.push("pipe:fulfilled"),
    error => globalThis.__pipeToQueuedWriteEvents.push(`pipe:rejected:${error && error.name}`)
  );
  globalThis.__pipeToQueuedWriteUnread = () => unread.length;
})()
"#,
    )
    .expect("pipeTo queued write setup should evaluate");

    for _ in 0..8 {
        let unread = vm
            .eval("String(globalThis.__pipeToQueuedWriteUnread())")
            .expect("pipeTo queued write unread length should evaluate");
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToQueuedWriteEvents)")
            .expect("pipeTo queued write events should evaluate");
        if unread == "1" && !events.contains("write:b") {
            break;
        }
    }

    let before = vm
        .eval(
            r#"
JSON.stringify({
  unread: globalThis.__pipeToQueuedWriteUnread(),
  wroteB: globalThis.__pipeToQueuedWriteEvents.includes("write:b"),
  events: globalThis.__pipeToQueuedWriteEvents
})
"#,
        )
        .expect("pipeTo queued write pre-resolution state should evaluate");
    assert_eq!(
        before,
        r#"{"unread":1,"wroteB":false,"events":["desired:2","pull:b","write:a","pull:c"]}"#
    );

    vm.eval("globalThis.__resolvePipeFirstSinkWrite()")
        .expect("first pipe sink write should resolve");
    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToQueuedWriteEvents)")
            .expect("pipeTo queued write final events should drain");
        if events.contains("pipe:fulfilled") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToQueuedWriteEvents)")
        .expect("pipeTo queued write final events should evaluate");
    // PipeTo owns its first read before the sink's existing write settles.
    // Once that write releases backpressure, dequeuing each source-prefill
    // chunk opens the next HWM slot before the following sink write.
    assert_eq!(
        events,
        r#"["desired:2","pull:b","write:a","pull:c","write:b","pull:d","write:c","write:d","close","pipe:fulfilled"]"#
    );
}

#[test]
fn readable_stream_pipe_to_waits_for_async_destination_close() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToAsyncCloseEvents = [];
  let resolveClose;
  const readable = new ReadableStream({
    start(controller) {
      controller.close();
    }
  });
  const writable = new WritableStream({
    close() {
      globalThis.__pipeToAsyncCloseEvents.push("close:start");
      return new Promise(resolve => {
        resolveClose = () => {
          globalThis.__pipeToAsyncCloseEvents.push("close:resolve");
          resolve();
        };
      });
    }
  });
  readable.pipeTo(writable).then(
    () => globalThis.__pipeToAsyncCloseEvents.push(
      `pipe:fulfilled:${readable.locked}:${writable.locked}`
    ),
    error => globalThis.__pipeToAsyncCloseEvents.push(`pipe:rejected:${error && error.name}`)
  );
  globalThis.__pipeToAsyncCloseEvents.push(`locked:${readable.locked}:${writable.locked}`);
  globalThis.__resolvePipeToAsyncClose = () => resolveClose();
})()
"#,
    )
    .expect("pipeTo async close setup should evaluate");

    let before = vm
        .eval(
            r#"
JSON.stringify({
  events: globalThis.__pipeToAsyncCloseEvents,
  settled: globalThis.__pipeToAsyncCloseEvents.some(event => event.startsWith("pipe:"))
})
"#,
        )
        .expect("pipeTo async close pending state should evaluate");
    assert_eq!(
        before,
        r#"{"events":["locked:true:true","close:start"],"settled":false}"#
    );

    vm.eval("globalThis.__resolvePipeToAsyncClose()")
        .expect("pipeTo async close should resolve");
    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToAsyncCloseEvents)")
            .expect("pipeTo async close should drain microtasks");
        if events.contains("pipe:fulfilled:false:false") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToAsyncCloseEvents)")
        .expect("pipeTo async close events should settle");
    assert_eq!(
        events,
        r#"["locked:true:true","close:start","close:resolve","pipe:fulfilled:false:false"]"#
    );
}

#[test]
fn readable_stream_pipe_to_rejects_async_destination_close() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToAsyncCloseRejectEvents = [];
  const closeError = new Error("async close failed");
  let rejectClose;
  const readable = new ReadableStream({
    start(controller) {
      controller.close();
    }
  });
  const writable = new WritableStream({
    close() {
      globalThis.__pipeToAsyncCloseRejectEvents.push("close:start");
      return new Promise((_, reject) => {
        rejectClose = () => {
          globalThis.__pipeToAsyncCloseRejectEvents.push("close:reject");
          reject(closeError);
        };
      });
    }
  });
  readable.pipeTo(writable).then(
    () => globalThis.__pipeToAsyncCloseRejectEvents.push("pipe:fulfilled"),
    error => globalThis.__pipeToAsyncCloseRejectEvents.push(
      `pipe:${error === closeError}:${readable.locked}:${writable.locked}`
    )
  );
  globalThis.__pipeToAsyncCloseRejectEvents.push(`locked:${readable.locked}:${writable.locked}`);
  globalThis.__rejectPipeToAsyncClose = () => rejectClose();
})()
"#,
    )
    .expect("pipeTo async close rejection setup should evaluate");

    let before = vm
        .eval("JSON.stringify(globalThis.__pipeToAsyncCloseRejectEvents)")
        .expect("pipeTo async close rejection pending events should evaluate");
    assert_eq!(before, r#"["locked:true:true","close:start"]"#);

    vm.eval("globalThis.__rejectPipeToAsyncClose()")
        .expect("pipeTo async close should reject");
    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToAsyncCloseRejectEvents)")
            .expect("pipeTo async close rejection should drain microtasks");
        if events.contains("pipe:true:false:false") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToAsyncCloseRejectEvents)")
        .expect("pipeTo async close rejection events should settle");
    assert_eq!(
        events,
        r#"["locked:true:true","close:start","close:reject","pipe:true:false:false"]"#
    );
}

#[test]
fn readable_stream_pipe_to_prevent_close_waits_for_pending_write() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToPreventClosePendingEvents = [];
  let resolveWrite;
  const readable = new ReadableStream({
    start(controller) {
      controller.enqueue("chunk");
      controller.close();
    }
  });
  const writable = new WritableStream({
    write(chunk) {
      globalThis.__pipeToPreventClosePendingEvents.push(`write:${chunk}`);
      return new Promise(resolve => {
        resolveWrite = () => {
          globalThis.__pipeToPreventClosePendingEvents.push("write:resolve");
          resolve();
        };
      });
    },
    close() {
      globalThis.__pipeToPreventClosePendingEvents.push("close");
    }
  });
  readable.pipeTo(writable, { preventClose: true }).then(
    () => globalThis.__pipeToPreventClosePendingEvents.push(
      `pipe:fulfilled:${readable.locked}:${writable.locked}`
    ),
    error => globalThis.__pipeToPreventClosePendingEvents.push(`pipe:rejected:${error && error.name}`)
  );
  globalThis.__resolvePipeToPreventCloseWrite = () => resolveWrite();
})()
"#,
    )
    .expect("pipeTo preventClose pending write setup should evaluate");

    let before = vm
        .eval(
            r#"
JSON.stringify({
  events: globalThis.__pipeToPreventClosePendingEvents,
  settled: globalThis.__pipeToPreventClosePendingEvents.some(event => event.startsWith("pipe:"))
})
"#,
        )
        .expect("pipeTo preventClose pending state should evaluate");
    assert_eq!(before, r#"{"events":["write:chunk"],"settled":false}"#);

    vm.eval("globalThis.__resolvePipeToPreventCloseWrite()")
        .expect("pipeTo preventClose write should resolve");
    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToPreventClosePendingEvents)")
            .expect("pipeTo preventClose should drain microtasks");
        if events.contains("pipe:fulfilled:false:false") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToPreventClosePendingEvents)")
        .expect("pipeTo preventClose events should settle");
    assert_eq!(
        events,
        r#"["write:chunk","write:resolve","pipe:fulfilled:false:false"]"#
    );
}

#[test]
fn readable_stream_pipe_to_rejects_write_errors_and_honors_prevent_cancel() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToWriteRejectEvents = [];
  function run(label, options) {
    const readable = new ReadableStream({
      start(controller) {
        controller.enqueue(label);
      },
      cancel(reason) {
        globalThis.__pipeToWriteRejectEvents.push(`${label}:cancel:${String(reason)}:${reason === undefined}`);
      }
    });
    const writable = new WritableStream({
      write(chunk) {
        globalThis.__pipeToWriteRejectEvents.push(`${label}:write:${chunk}`);
        return Promise.reject(undefined);
      }
    });
    readable.pipeTo(writable, options).then(
      () => globalThis.__pipeToWriteRejectEvents.push(`${label}:pipe:fulfilled`),
      reason => globalThis.__pipeToWriteRejectEvents.push(`${label}:pipe:${String(reason)}:${reason === undefined}`)
    );
  }
  run("cancel", {});
  run("prevent", { preventCancel: true });
})()
"#,
    )
    .expect("pipeTo write rejection setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToWriteRejectEvents)")
            .expect("pipeTo write rejection should drain microtasks");
        if events.contains("prevent:pipe:undefined:true")
            && events.contains("cancel:pipe:undefined:true")
        {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToWriteRejectEvents.sort())")
        .expect("pipeTo write rejection events should settle");
    assert_eq!(
        events,
        r#"["cancel:cancel:undefined:true","cancel:pipe:undefined:true","cancel:write:cancel","prevent:pipe:undefined:true","prevent:write:prevent"]"#
    );
}

#[test]
fn readable_stream_pipe_to_rejects_sync_close_throw_and_releases_locks() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeToCloseThrowEvents = [];
  const closeError = new Error("close failed");
  const readable = new ReadableStream({
    start(controller) {
      controller.close();
    }
  });
  const writable = new WritableStream({
    close() {
      globalThis.__pipeToCloseThrowEvents.push("close");
      throw closeError;
    }
  });
  readable.pipeTo(writable).then(
    () => globalThis.__pipeToCloseThrowEvents.push("pipe:fulfilled"),
    error => globalThis.__pipeToCloseThrowEvents.push(
      `pipe:${error === closeError}:${readable.locked}:${writable.locked}`
    )
  );
})()
"#,
    )
    .expect("pipeTo close throw setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeToCloseThrowEvents)")
            .expect("pipeTo close throw should drain microtasks");
        if events.contains("pipe:true:false:false") {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeToCloseThrowEvents)")
        .expect("pipeTo close throw events should settle");
    assert_eq!(events, r#"["close","pipe:true:false:false"]"#);
}

#[test]
fn readable_stream_pipe_options_getter_errors_keep_entrypoint_semantics_and_order() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
(() => {
  globalThis.__pipeOptionErrorEvents = [];
  class ThrowingOptions {
    constructor(name) {
      this.name = name;
      this.touched = [];
    }
    get preventClose() {
      this.maybeThrow("preventClose");
      return false;
    }
    get preventAbort() {
      this.maybeThrow("preventAbort");
      return false;
    }
    get preventCancel() {
      this.maybeThrow("preventCancel");
      return false;
    }
    get signal() {
      this.maybeThrow("signal");
      return undefined;
    }
    maybeThrow(name) {
      this.touched.push(name);
      if (this.name === name) {
        throw new Error(name);
      }
    }
  }
  for (const name of ["preventAbort", "preventCancel", "preventClose", "signal"]) {
    const pipeToOptions = new ThrowingOptions(name);
    try {
      const promise = new ReadableStream().pipeTo(new WritableStream(), pipeToOptions);
      globalThis.__pipeOptionErrorEvents.push(`pipeTo:${name}:returned:${promise instanceof Promise}`);
      promise.then(
        () => globalThis.__pipeOptionErrorEvents.push(`pipeTo:${name}:fulfilled`),
        error => globalThis.__pipeOptionErrorEvents.push(
          `pipeTo:${name}:rejected:${error.message}:${pipeToOptions.touched.join(",")}`
        )
      );
    } catch (error) {
      globalThis.__pipeOptionErrorEvents.push(`pipeTo:${name}:threw:${error.message}`);
    }

    const pipeThroughOptions = new ThrowingOptions(name);
    try {
      new ReadableStream().pipeThrough(new TransformStream(), pipeThroughOptions);
      globalThis.__pipeOptionErrorEvents.push(`pipeThrough:${name}:returned`);
    } catch (error) {
      globalThis.__pipeOptionErrorEvents.push(
        `pipeThrough:${name}:threw:${error.message}:${pipeThroughOptions.touched.join(",")}`
      );
    }
  }
})()
"#,
    )
    .expect("pipe option getter error setup should evaluate");

    for _ in 0..8 {
        let events = vm
            .eval("JSON.stringify(globalThis.__pipeOptionErrorEvents)")
            .expect("pipe option getter errors should drain promise reactions");
        if events.matches(":rejected:").count() == 4 {
            break;
        }
    }

    let events = vm
        .eval("JSON.stringify(globalThis.__pipeOptionErrorEvents.sort())")
        .expect("pipe option getter error events should settle");
    assert_eq!(
        events,
        r#"["pipeThrough:preventAbort:threw:preventAbort:preventAbort","pipeThrough:preventCancel:threw:preventCancel:preventAbort,preventCancel","pipeThrough:preventClose:threw:preventClose:preventAbort,preventCancel,preventClose","pipeThrough:signal:threw:signal:preventAbort,preventCancel,preventClose,signal","pipeTo:preventAbort:rejected:preventAbort:preventAbort","pipeTo:preventAbort:returned:true","pipeTo:preventCancel:rejected:preventCancel:preventAbort,preventCancel","pipeTo:preventCancel:returned:true","pipeTo:preventClose:rejected:preventClose:preventAbort,preventCancel,preventClose","pipeTo:preventClose:returned:true","pipeTo:signal:rejected:signal:preventAbort,preventCancel,preventClose,signal","pipeTo:signal:returned:true"]"#
    );
}

#[test]
fn readable_cancel_uses_intrinsic_promise_chaining() {
    let mut vm = new_storage_test_vm("https://shared-binding-regression.test/");
    vm.eval(
        r#"
        globalThis.cancelResults = [];
        globalThis.cancelThenReads = 0;
        const reason = new Error('cancel reason');
        const streams = [
            new ReadableStream({cancel() { return 'ignored'; }}),
            new ReadableStream({cancel() { throw reason; }})
        ];
        const descriptor = Object.getOwnPropertyDescriptor(Promise.prototype, 'then');
        try {
            Object.defineProperty(Promise.prototype, 'then', {configurable: true, get() {
                cancelThenReads++;
                throw new Error('internal chaining must not read public then');
            }});
            for (const stream of streams) {
                const result = stream.cancel(reason);
                descriptor.value.call(result,
                    value => cancelResults.push(value === undefined),
                    error => cancelResults.push(error === reason)
                );
            }
        } finally {
            Object.defineProperty(Promise.prototype, 'then', descriptor);
        }
    "#,
    )
    .unwrap();
    for _ in 0..8 {
        if vm.eval("cancelResults.length === 2").unwrap() == "true" {
            break;
        }
    }
    assert_eq!(
        vm.eval("JSON.stringify([cancelThenReads, cancelResults])")
            .unwrap(),
        "[0,[true,true]]"
    );
}

#[test]
fn readable_stream_from_preserves_async_sequence_and_cancellation_semantics() {
    let mut vm = stream_test_vm();

    vm.eval(
        r#"
globalThis.__readableStreamFromResult = "";
(async () => {
  const descriptor = Object.getOwnPropertyDescriptor(ReadableStream, "from");
  const facts = {
    surface: [
      typeof descriptor.value,
      descriptor.value.name,
      descriptor.value.length,
      descriptor.enumerable,
      descriptor.writable,
      descriptor.configurable
    ]
  };

  let nullError = "none";
  try {
    ReadableStream.from(null);
  } catch (error) {
    nullError = error.name;
  }
  facts.nullError = nullError;

  const openMarker = new Error("open marker");
  let openIdentity = false;
  try {
    ReadableStream.from({
      [Symbol.asyncIterator]() {
        throw openMarker;
      }
    });
  } catch (error) {
    openIdentity = error === openMarker;
  }
  facts.openIdentity = openIdentity;

  const syncReader = ReadableStream.from([
    Promise.resolve("a"),
    "b"
  ]).getReader();
  facts.syncValues = [
    (await syncReader.read()).value,
    (await syncReader.read()).value,
    (await syncReader.read()).done
  ];

  let nextCalls = 0;
  const asyncIterator = {
    async next() {
      nextCalls += 1;
      return nextCalls === 1
        ? { value: "async", done: false }
        : { value: undefined, done: true };
    },
    [Symbol.asyncIterator]() {
      return this;
    }
  };
  const asyncReader = ReadableStream.from(asyncIterator).getReader();
  facts.asyncValues = [
    (await asyncReader.read()).value,
    (await asyncReader.read()).done,
    nextCalls
  ];

  const finishedReader = ReadableStream.from({
    next() {
      return Promise.resolve({
        done: true,
        get value() {
          throw new Error("finished iteration value must not be read");
        }
      });
    },
    [Symbol.asyncIterator]() {
      return this;
    }
  }).getReader();
  facts.finishedSkipsValue = (await finishedReader.read()).done;

  const nextMarker = new Error("next marker");
  const rejectedReader = ReadableStream.from({
    next() {
      throw nextMarker;
    },
    [Symbol.asyncIterator]() {
      return this;
    }
  }).getReader();
  facts.nextIdentity = await rejectedReader.read().then(
    () => false,
    error => error === nextMarker
  );

  const cancelReason = new Error("cancel reason");
  let returnReason;
  let releaseReturn;
  const cancelReader = ReadableStream.from({
    next() {
      throw new Error("next must not run");
    },
    return(reason) {
      returnReason = reason;
      return new Promise(resolve => {
        releaseReturn = () => resolve({ done: true });
      });
    },
    [Symbol.asyncIterator]() {
      return this;
    }
  }).getReader();
  let cancelSettled = false;
  const cancelPromise = cancelReader.cancel(cancelReason).then(() => {
    cancelSettled = true;
  });
  await Promise.resolve();
  facts.cancelPending = !cancelSettled && returnReason === cancelReason;
  releaseReturn();
  await cancelPromise;
  facts.cancelSettled = cancelSettled;

  const undefinedReturnReader = ReadableStream.from({
    next() {
      throw new Error("next must not run");
    },
    return() {},
    [Symbol.asyncIterator]() {
      return this;
    }
  }).getReader();
  facts.undefinedReturnRejects = await undefinedReturnReader.cancel().then(
    () => false,
    error => error instanceof TypeError
  );

  let reentrantReader;
  let reentrantReturns = 0;
  const reentrantStream = ReadableStream.from({
    async next() {
      await reentrantReader.cancel();
      return { value: "ignored", done: false };
    },
    async return() {
      reentrantReturns += 1;
    },
    [Symbol.asyncIterator]() {
      return this;
    }
  });
  reentrantReader = reentrantStream.getReader();
  facts.reentrant = [
    (await reentrantReader.read()).done,
    reentrantReturns
  ];

  globalThis.__readableStreamFromResult = JSON.stringify(facts);
})().catch(error => {
  globalThis.__readableStreamFromResult = `ERROR:${error && error.stack || error}`;
});
"#,
    )
    .expect("ReadableStream.from setup should evaluate");

    let mut result = String::new();
    for _ in 0..32 {
        result = vm
            .eval("globalThis.__readableStreamFromResult")
            .expect("ReadableStream.from reactions should drain");
        if !result.is_empty() {
            break;
        }
    }

    assert_eq!(
        result,
        r#"{"surface":["function","from",1,true,true,true],"nullError":"TypeError","openIdentity":true,"syncValues":["a","b",true],"asyncValues":["async",true,2],"finishedSkipsValue":true,"nextIdentity":true,"cancelPending":true,"cancelSettled":true,"undefinedReturnRejects":true,"reentrant":[true,1]}"#
    );
}

#[test]
fn readable_stream_from_does_not_inherit_author_start_algorithms() {
    let mut vm = stream_test_vm();
    vm.eval(r#"
      globalThis.internalSourceResult = null;
      (async () => {
        const before = Object.getOwnPropertyDescriptor(Object.prototype, 'start');
        let reads = 0;
        Object.defineProperty(Object.prototype, 'start', {
          configurable: true,
          get() { reads++; throw Error('inherited start must not run'); }
        });
        try {
          const reader = ReadableStream.from([7]).getReader();
          const first = await reader.read();
          const last = await reader.read();
          return JSON.stringify([first.value, first.done, last.done, reads]);
        } finally {
          if (before) Object.defineProperty(Object.prototype, 'start', before);
          else delete Object.prototype.start;
        }
      })().then(value => internalSourceResult = value, error => internalSourceResult = String(error));
    "#).unwrap();
    for _ in 0..32 {
        if vm.eval("String(internalSourceResult !== null)").unwrap() == "true" {
            break;
        }
    }
    assert_eq!(vm.eval("internalSourceResult").unwrap(), "[7,false,true,0]");
}