@sproutboat/runtime 0.15.0 → 0.17.0

package/src/native-fetch-prelude.js

@@ -1,3 +1,2317 @@
+// WEB STREAMS: generated by gen-streams.ts, do not edit.
+/* oxlint-disable -- generated third-party implementation */
+// web-streams-polyfill 4.3.0, MIT, copyright Mattias Buelens (see WEB_STREAMS_LICENSE)
+  function e() {}
+  function t(e) {
+    return typeof e == "object" && e !== null || typeof e == "function";
+  }
+  var r = e;
+  function o(e, t) {
+    try {
+      Object.defineProperty(e, "name", { value: t, configurable: true });
+    } catch (e) {}
+  }
+  var n = Promise;
+  var i = Promise.resolve.bind(n);
+  var a = Promise.prototype.then;
+  var s = Promise.reject.bind(n);
+  var l = i;
+  function u(e) {
+    return new n(e);
+  }
+  function c(e) {
+    return u((t) => t(e));
+  }
+  function d(e) {
+    return s(e);
+  }
+  function f(e, t, r) {
+    return a.call(e, t, r);
+  }
+  function h(e, t, o) {
+    f(f(e, t, o), undefined, r);
+  }
+  function b(e, t) {
+    h(e, t);
+  }
+  function _(e, t) {
+    h(e, undefined, t);
+  }
+  function m(e, t, r) {
+    return f(e, t, r);
+  }
+  function p(e) {
+    f(e, undefined, r);
+  }
+  var y = (e) => {
+    if (typeof queueMicrotask == "function")
+      y = queueMicrotask;
+    else {
+      const e = c(undefined);
+      y = (t) => f(e, t);
+    }
+    return y(e);
+  };
+  function S(e, t, r) {
+    if (typeof e != "function")
+      throw new TypeError("Argument is not a function");
+    return Function.prototype.apply.call(e, t, r);
+  }
+  function g(e, t, r) {
+    try {
+      return c(S(e, t, r));
+    } catch (e) {
+      return d(e);
+    }
+  }
+
+  class v {
+    constructor() {
+      this._cursor = 0, this._size = 0, this._front = { _elements: [], _next: undefined }, this._back = this._front, this._cursor = 0, this._size = 0;
+    }
+    get length() {
+      return this._size;
+    }
+    push(e) {
+      const t = this._back;
+      let r = t;
+      t._elements.length === 16383 && (r = { _elements: [], _next: undefined }), t._elements.push(e), r !== t && (this._back = r, t._next = r), ++this._size;
+    }
+    shift() {
+      const e = this._front;
+      let t = e;
+      const r = this._cursor;
+      let o = r + 1;
+      const n = e._elements, i = n[r];
+      return o === 16384 && (t = e._next, o = 0), --this._size, this._cursor = o, e !== t && (this._front = t), n[r] = undefined, i;
+    }
+    forEach(e) {
+      let t = this._cursor, r = this._front, o = r._elements;
+      for (;!(t === o.length && r._next === undefined || t === o.length && (r = r._next, o = r._elements, t = 0, o.length === 0)); )
+        e(o[t]), ++t;
+    }
+    peek() {
+      const e = this._front, t = this._cursor;
+      return e._elements[t];
+    }
+  }
+  var w = Symbol("[[AbortSteps]]");
+  var R = Symbol("[[ErrorSteps]]");
+  var T = Symbol("[[CancelSteps]]");
+  var P = Symbol("[[PullSteps]]");
+  var C = Symbol("[[CanPullSyncSteps]]");
+  var q = Symbol("[[ReleaseSteps]]");
+  function E(e, t) {
+    e._ownerReadableStream = t, t._reader = e, t._state === "readable" ? j(e) : t._state === "closed" ? function(e) {
+      j(e), z(e);
+    }(e) : k(e, t._storedError);
+  }
+  function W(e, t) {
+    return Mr(e._ownerReadableStream, t);
+  }
+  function O(e) {
+    const t = e._ownerReadableStream;
+    t._state === "readable" ? A(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : function(e, t) {
+      k(e, t);
+    }(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t._readableStreamController[q](), t._reader = undefined, e._ownerReadableStream = undefined;
+  }
+  function B(e) {
+    return new TypeError("Cannot " + e + " a stream using a released reader");
+  }
+  function j(e) {
+    e._closedPromise = u((t, r) => {
+      e._closedPromise_resolve = t, e._closedPromise_reject = r;
+    });
+  }
+  function k(e, t) {
+    j(e), A(e, t);
+  }
+  function A(e, t) {
+    e._closedPromise_reject !== undefined && (p(e._closedPromise), e._closedPromise_reject(t), e._closedPromise_resolve = undefined, e._closedPromise_reject = undefined);
+  }
+  function z(e) {
+    e._closedPromise_resolve !== undefined && (e._closedPromise_resolve(undefined), e._closedPromise_resolve = undefined, e._closedPromise_reject = undefined);
+  }
+  var D = Number.isFinite || function(e) {
+    return typeof e == "number" && isFinite(e);
+  };
+  var F = Math.trunc || function(e) {
+    return e < 0 ? Math.ceil(e) : Math.floor(e);
+  };
+  function L(e, t) {
+    if (e !== undefined && (typeof (r = e) != "object" && typeof r != "function"))
+      throw new TypeError(`${t} is not an object.`);
+    var r;
+  }
+  function I(e, t) {
+    if (typeof e != "function")
+      throw new TypeError(`${t} is not a function.`);
+  }
+  function $(e, t) {
+    if (!function(e) {
+      return typeof e == "object" && e !== null || typeof e == "function";
+    }(e))
+      throw new TypeError(`${t} is not an object.`);
+  }
+  function M(e, t, r) {
+    if (e === undefined)
+      throw new TypeError(`Parameter ${t} is required in '${r}'.`);
+  }
+  function Y(e, t, r) {
+    if (e === undefined)
+      throw new TypeError(`${t} is required in '${r}'.`);
+  }
+  function x(e) {
+    return Number(e);
+  }
+  function Q(e) {
+    return e === 0 ? 0 : e;
+  }
+  function N(e, t) {
+    const r = Number.MAX_SAFE_INTEGER;
+    let o = Number(e);
+    if (o = Q(o), !D(o))
+      throw new TypeError(`${t} is not a finite number`);
+    if (o = function(e) {
+      return Q(F(e));
+    }(o), o < 0 || o > r)
+      throw new TypeError(`${t} is outside the accepted range of 0 to ${r}, inclusive`);
+    return D(o) && o !== 0 ? o : 0;
+  }
+  function H(e, t) {
+    if (!Ir(e))
+      throw new TypeError(`${t} is not a ReadableStream.`);
+  }
+  function V(e) {
+    return new ReadableStreamDefaultReader(e);
+  }
+  function U(e, t) {
+    e._reader._readRequests.push(t);
+  }
+  function G(e, t, r) {
+    const o = e._reader._readRequests.shift();
+    r ? o._closeSteps() : o._chunkSteps(t);
+  }
+  function X(e) {
+    return e._reader._readRequests.length;
+  }
+  function J(e) {
+    const t = e._reader;
+    return t !== undefined && !!ee(t);
+  }
+
+  class ReadableStreamDefaultReader {
+    constructor(e) {
+      if (M(e, 1, "ReadableStreamDefaultReader"), H(e, "First parameter"), $r(e))
+        throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+      E(this, e), this._readRequests = new v;
+    }
+    get closed() {
+      return ee(this) ? this._closedPromise : d(ne("closed"));
+    }
+    cancel(e = undefined) {
+      return ee(this) ? this._ownerReadableStream === undefined ? d(B("cancel")) : W(this, e) : d(ne("cancel"));
+    }
+    read() {
+      if (!ee(this))
+        return d(ne("read"));
+      if (this._ownerReadableStream === undefined)
+        return d(B("read from"));
+      const e = re(this) ? new Z : new K;
+      return te(this, e), e._promise;
+    }
+    releaseLock() {
+      if (!ee(this))
+        throw ne("releaseLock");
+      this._ownerReadableStream !== undefined && function(e) {
+        O(e);
+        const t = new TypeError("Reader was released");
+        oe(e, t);
+      }(this);
+    }
+  }
+  Object.defineProperties(ReadableStreamDefaultReader.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), o(ReadableStreamDefaultReader.prototype.cancel, "cancel"), o(ReadableStreamDefaultReader.prototype.read, "read"), o(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultReader", configurable: true });
+
+  class K {
+    constructor() {
+      this._promise = u((e, t) => {
+        this._resolvePromise = e, this._rejectPromise = t;
+      });
+    }
+    _chunkSteps(e) {
+      this._resolvePromise({ value: e, done: false });
+    }
+    _closeSteps() {
+      this._resolvePromise({ value: undefined, done: true });
+    }
+    _errorSteps(e) {
+      this._rejectPromise(e);
+    }
+  }
+
+  class Z {
+    constructor() {
+      this._promise = undefined;
+    }
+    _chunkSteps(e) {
+      this._promise = l({ value: e, done: false });
+    }
+    _closeSteps() {
+      this._promise = l({ value: undefined, done: true });
+    }
+    _errorSteps(e) {
+      this._promise = d(e);
+    }
+  }
+  function ee(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_readRequests") && e instanceof ReadableStreamDefaultReader);
+  }
+  function te(e, t) {
+    const r = e._ownerReadableStream;
+    r._disturbed = true, r._state === "closed" ? t._closeSteps() : r._state === "errored" ? t._errorSteps(r._storedError) : r._readableStreamController[P](t);
+  }
+  function re(e) {
+    const t = e._ownerReadableStream;
+    return t._state === "closed" || (t._state === "errored" || t._readableStreamController[C]());
+  }
+  function oe(e, t) {
+    const r = e._readRequests;
+    e._readRequests = new v, r.forEach((e) => {
+      e._errorSteps(t);
+    });
+  }
+  function ne(e) {
+    return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`);
+  }
+  var ie;
+  var ae;
+  var se;
+  function le(e) {
+    return e.slice();
+  }
+  function ue(e, t, r, o, n) {
+    new Uint8Array(e).set(new Uint8Array(r, o, n), t);
+  }
+  var ce = (e) => (ce = typeof e.transfer == "function" ? (e) => e.transfer() : typeof structuredClone == "function" ? (e) => structuredClone(e, { transfer: [e] }) : (e) => e, ce(e));
+  var de = (e) => (de = typeof e.detached == "boolean" ? (e) => e.detached : (e) => e.byteLength === 0, de(e));
+  function fe(e, t, r) {
+    if (e.slice)
+      return e.slice(t, r);
+    const o = r - t, n = new ArrayBuffer(o);
+    return ue(n, 0, e, t, o), n;
+  }
+  function he(e, t) {
+    const r = e[t];
+    if (r != null) {
+      if (typeof r != "function")
+        throw new TypeError(`${String(t)} is not a function`);
+      return r;
+    }
+  }
+  function be(e) {
+    try {
+      const { done: t, value: r } = e;
+      return f(l(r), (e) => ({ done: t, value: e }));
+    } catch (e) {
+      return d(e);
+    }
+  }
+  var _e = (se = (ie = Symbol.asyncIterator) !== null && ie !== undefined ? ie : (ae = Symbol.for) === null || ae === undefined ? undefined : ae.call(Symbol, "Symbol.asyncIterator")) !== null && se !== undefined ? se : "@@asyncIterator";
+  function me(e, r = "sync", o) {
+    if (o === undefined)
+      if (r === "async") {
+        if ((o = he(e, _e)) === undefined) {
+          return function(e) {
+            const r = { next() {
+              let t;
+              try {
+                t = pe(e);
+              } catch (e) {
+                return d(e);
+              }
+              return be(t);
+            }, return(r) {
+              let o;
+              try {
+                const t = he(e.iterator, "return");
+                if (t === undefined)
+                  return c({ done: true, value: r });
+                o = S(t, e.iterator, [r]);
+              } catch (e) {
+                return d(e);
+              }
+              return t(o) ? be(o) : d(new TypeError("The iterator.return() method must return an object"));
+            } };
+            return { iterator: r, nextMethod: r.next, done: false };
+          }(me(e, "sync", he(e, Symbol.iterator)));
+        }
+      } else
+        o = he(e, Symbol.iterator);
+    if (o === undefined)
+      throw new TypeError("The object is not iterable");
+    const n = S(o, e, []);
+    if (!t(n))
+      throw new TypeError("The iterator method must return an object");
+    return { iterator: n, nextMethod: n.next, done: false };
+  }
+  function pe(e) {
+    const r = S(e.nextMethod, e.iterator, []);
+    if (!t(r))
+      throw new TypeError("The iterator.next() method must return an object");
+    return r;
+  }
+
+  class ye {
+    constructor(e, t) {
+      this._ongoingPromise = undefined, this._isFinished = false, this._reader = e, this._preventCancel = t;
+    }
+    next() {
+      const e = () => this._nextSteps();
+      return this._ongoingPromise = this._ongoingPromise ? m(this._ongoingPromise, e, e) : e(), this._ongoingPromise;
+    }
+    return(e) {
+      const t = () => this._returnSteps(e);
+      return this._ongoingPromise = this._ongoingPromise ? m(this._ongoingPromise, t, t) : t(), this._ongoingPromise;
+    }
+    _nextSteps() {
+      if (this._isFinished)
+        return Promise.resolve({ value: undefined, done: true });
+      const e = this._reader, t = new Se(this);
+      return te(e, t), t._promise;
+    }
+    _returnSteps(e) {
+      if (this._isFinished)
+        return Promise.resolve({ value: e, done: true });
+      this._isFinished = true;
+      const t = this._reader;
+      if (!this._preventCancel) {
+        const r = W(t, e);
+        return O(t), m(r, () => ({ value: e, done: true }));
+      }
+      return O(t), c({ value: e, done: true });
+    }
+  }
+
+  class Se {
+    constructor(e) {
+      this._iterator = e, this._promise = u((e, t) => {
+        this._resolvePromise = e, this._rejectPromise = t;
+      });
+    }
+    _chunkSteps(e) {
+      this._iterator._ongoingPromise = undefined, y(() => this._resolvePromise({ value: e, done: false }));
+    }
+    _closeSteps() {
+      const e = this._iterator;
+      e._ongoingPromise = undefined, e._isFinished = true, O(e._reader), this._resolvePromise({ value: undefined, done: true });
+    }
+    _errorSteps(e) {
+      const t = this._iterator;
+      t._ongoingPromise = undefined, t._isFinished = true, O(t._reader), this._rejectPromise(e);
+    }
+  }
+  var ge = { next() {
+    return ve(this) ? this._asyncIteratorImpl.next() : d(we("next"));
+  }, return(e) {
+    return ve(this) ? this._asyncIteratorImpl.return(e) : d(we("return"));
+  }, [_e]() {
+    return this;
+  } };
+  function ve(e) {
+    if (!t(e))
+      return false;
+    if (!Object.prototype.hasOwnProperty.call(e, "_asyncIteratorImpl"))
+      return false;
+    try {
+      return e._asyncIteratorImpl instanceof ye;
+    } catch (e) {
+      return false;
+    }
+  }
+  function we(e) {
+    return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`);
+  }
+  Object.defineProperty(ge, _e, { enumerable: false });
+  var Re = Number.isNaN || function(e) {
+    return e != e;
+  };
+  function Te(e) {
+    const t = fe(e.buffer, e.byteOffset, e.byteOffset + e.byteLength);
+    return new Uint8Array(t);
+  }
+  function Pe(e) {
+    const t = e._queue.shift();
+    return e._queueTotalSize -= t.size, e._queueTotalSize < 0 && (e._queueTotalSize = 0), t.value;
+  }
+  function Ce(e, t, r) {
+    if (typeof (o = r) != "number" || Re(o) || o < 0 || r === 1 / 0)
+      throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
+    var o;
+    e._queue.push({ value: t, size: r }), e._queueTotalSize += r;
+  }
+  function qe(e) {
+    e._queue = new v, e._queueTotalSize = 0;
+  }
+  function Ee(e) {
+    return e === DataView;
+  }
+  function We(e) {
+    return Ee(e) ? 1 : e.BYTES_PER_ELEMENT;
+  }
+
+  class ReadableStreamBYOBRequest {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+    get view() {
+      if (!Be(this))
+        throw ot("view");
+      return this._view;
+    }
+    respond(e) {
+      if (!Be(this))
+        throw ot("respond");
+      if (M(e, 1, "respond"), e = N(e, "First parameter"), this._associatedReadableByteStreamController === undefined)
+        throw new TypeError("This BYOB request has been invalidated");
+      if (de(this._view.buffer))
+        throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
+      et(this._associatedReadableByteStreamController, e);
+    }
+    respondWithNewView(e) {
+      if (!Be(this))
+        throw ot("respondWithNewView");
+      if (M(e, 1, "respondWithNewView"), !ArrayBuffer.isView(e))
+        throw new TypeError("You can only respond with array buffer views");
+      if (this._associatedReadableByteStreamController === undefined)
+        throw new TypeError("This BYOB request has been invalidated");
+      if (de(e.buffer))
+        throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
+      tt(this._associatedReadableByteStreamController, e);
+    }
+  }
+  Object.defineProperties(ReadableStreamBYOBRequest.prototype, { respond: { enumerable: true }, respondWithNewView: { enumerable: true }, view: { enumerable: true } }), o(ReadableStreamBYOBRequest.prototype.respond, "respond"), o(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBRequest", configurable: true });
+
+  class ReadableByteStreamController {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+    get byobRequest() {
+      if (!Oe(this))
+        throw nt("byobRequest");
+      return Ke(this);
+    }
+    get desiredSize() {
+      if (!Oe(this))
+        throw nt("desiredSize");
+      return Ze(this);
+    }
+    close() {
+      if (!Oe(this))
+        throw nt("close");
+      if (this._closeRequested)
+        throw new TypeError("The stream has already been closed; do not close it again!");
+      const e = this._controlledReadableByteStream._state;
+      if (e !== "readable")
+        throw new TypeError(`The stream (in ${e} state) is not in the readable state and cannot be closed`);
+      Ue(this);
+    }
+    enqueue(e) {
+      if (!Oe(this))
+        throw nt("enqueue");
+      if (M(e, 1, "enqueue"), !ArrayBuffer.isView(e))
+        throw new TypeError("chunk must be an array buffer view");
+      if (e.byteLength === 0)
+        throw new TypeError("chunk must have non-zero byteLength");
+      if (e.buffer.byteLength === 0)
+        throw new TypeError("chunk's buffer must have non-zero byteLength");
+      if (this._closeRequested)
+        throw new TypeError("stream is closed or draining");
+      const t = this._controlledReadableByteStream._state;
+      if (t !== "readable")
+        throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be enqueued to`);
+      Ge(this, e);
+    }
+    error(e = undefined) {
+      if (!Oe(this))
+        throw nt("error");
+      Xe(this, e);
+    }
+    [T](e) {
+      ke(this), qe(this);
+      const t = this._cancelAlgorithm(e);
+      return Ve(this), t;
+    }
+    [P](e) {
+      const t = this._controlledReadableByteStream;
+      if (this._queueTotalSize > 0)
+        return void Je(this, e);
+      const r = this._autoAllocateChunkSize;
+      if (r !== undefined) {
+        let t;
+        try {
+          t = new ArrayBuffer(r);
+        } catch (t) {
+          return void e._errorSteps(t);
+        }
+        const o = { buffer: t, bufferByteLength: r, byteOffset: 0, byteLength: r, bytesFilled: 0, minimumFill: 1, elementSize: 1, viewConstructor: Uint8Array, readerType: "default" };
+        this._pendingPullIntos.push(o);
+      }
+      U(t, e), je(this);
+    }
+    [C]() {
+      return this._queueTotalSize > 0;
+    }
+    [q]() {
+      if (this._pendingPullIntos.length > 0) {
+        const e = this._pendingPullIntos.peek();
+        e.readerType = "none", this._pendingPullIntos = new v, this._pendingPullIntos.push(e);
+      }
+    }
+  }
+  function Oe(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_controlledReadableByteStream") && e instanceof ReadableByteStreamController);
+  }
+  function Be(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_associatedReadableByteStreamController") && e instanceof ReadableStreamBYOBRequest);
+  }
+  function je(e) {
+    const t = function(e) {
+      const t = e._controlledReadableByteStream;
+      if (t._state !== "readable")
+        return false;
+      if (e._closeRequested)
+        return false;
+      if (!e._started)
+        return false;
+      if (J(t) && X(t) > 0)
+        return true;
+      if (ut(t) && lt(t) > 0)
+        return true;
+      const r = Ze(e);
+      if (r > 0)
+        return true;
+      return false;
+    }(e);
+    if (!t)
+      return;
+    if (e._pulling)
+      return void (e._pullAgain = true);
+    e._pulling = true;
+    h(e._pullAlgorithm(), () => (e._pulling = false, e._pullAgain && (e._pullAgain = false, je(e)), null), (t) => (Xe(e, t), null));
+  }
+  function ke(e) {
+    xe(e), e._pendingPullIntos = new v;
+  }
+  function Ae(e, t) {
+    let r = false;
+    e._state === "closed" && (r = true);
+    const o = De(t);
+    t.readerType === "default" ? G(e, o, r) : function(e, t, r) {
+      const o = e._reader, n = o._readIntoRequests.shift();
+      r ? n._closeSteps(t) : n._chunkSteps(t);
+    }(e, o, r);
+  }
+  function ze(e, t) {
+    for (let r = 0;r < t.length; ++r)
+      Ae(e, t[r]);
+  }
+  function De(e) {
+    const { bytesFilled: t, elementSize: r } = e;
+    return new e.viewConstructor(e.buffer, e.byteOffset, t / r);
+  }
+  function Fe(e, t, r, o) {
+    e._queue.push({ buffer: t, byteOffset: r, byteLength: o }), e._queueTotalSize += o;
+  }
+  function Le(e, t, r, o) {
+    let n;
+    try {
+      n = fe(t, r, r + o);
+    } catch (t) {
+      throw Xe(e, t), t;
+    }
+    Fe(e, n, 0, o);
+  }
+  function Ie(e, t) {
+    t.bytesFilled > 0 && Le(e, t.buffer, t.byteOffset, t.bytesFilled), He(e);
+  }
+  function $e(e, t) {
+    const r = Math.min(e._queueTotalSize, t.byteLength - t.bytesFilled), o = t.bytesFilled + r;
+    let n = r, i = false;
+    const a = o - o % t.elementSize;
+    a >= t.minimumFill && (n = a - t.bytesFilled, i = true);
+    const s = e._queue;
+    for (;n > 0; ) {
+      const r = s.peek(), o = Math.min(n, r.byteLength), i = t.byteOffset + t.bytesFilled;
+      ue(t.buffer, i, r.buffer, r.byteOffset, o), r.byteLength === o ? s.shift() : (r.byteOffset += o, r.byteLength -= o), e._queueTotalSize -= o, Me(e, o, t), n -= o;
+    }
+    return i;
+  }
+  function Me(e, t, r) {
+    r.bytesFilled += t;
+  }
+  function Ye(e) {
+    e._queueTotalSize === 0 && e._closeRequested ? (Ve(e), Yr(e._controlledReadableByteStream)) : je(e);
+  }
+  function xe(e) {
+    e._byobRequest !== null && (e._byobRequest._associatedReadableByteStreamController = undefined, e._byobRequest._view = null, e._byobRequest = null);
+  }
+  function Qe(e) {
+    const t = [];
+    for (;e._pendingPullIntos.length > 0 && e._queueTotalSize !== 0; ) {
+      const r = e._pendingPullIntos.peek();
+      $e(e, r) && (He(e), t.push(r));
+    }
+    return t;
+  }
+  function Ne(e, t) {
+    const r = e._pendingPullIntos.peek();
+    xe(e);
+    e._controlledReadableByteStream._state === "closed" ? function(e, t) {
+      t.readerType === "none" && He(e);
+      const r = e._controlledReadableByteStream;
+      if (ut(r)) {
+        const t = [];
+        for (;t.length < lt(r); )
+          t.push(He(e));
+        ze(r, t);
+      }
+    }(e, r) : function(e, t, r) {
+      if (Me(0, t, r), r.readerType === "none") {
+        Ie(e, r);
+        const t = Qe(e);
+        return void ze(e._controlledReadableByteStream, t);
+      }
+      if (r.bytesFilled < r.minimumFill)
+        return;
+      He(e);
+      const o = r.bytesFilled % r.elementSize;
+      if (o > 0) {
+        const t = r.byteOffset + r.bytesFilled;
+        Le(e, r.buffer, t - o, o);
+      }
+      r.bytesFilled -= o;
+      const n = Qe(e);
+      Ae(e._controlledReadableByteStream, r), ze(e._controlledReadableByteStream, n);
+    }(e, t, r), je(e);
+  }
+  function He(e) {
+    return e._pendingPullIntos.shift();
+  }
+  function Ve(e) {
+    e._pullAlgorithm = undefined, e._cancelAlgorithm = undefined;
+  }
+  function Ue(e) {
+    const t = e._controlledReadableByteStream;
+    if (!e._closeRequested && t._state === "readable")
+      if (e._queueTotalSize > 0)
+        e._closeRequested = true;
+      else {
+        if (e._pendingPullIntos.length > 0) {
+          const t = e._pendingPullIntos.peek();
+          if (t.bytesFilled % t.elementSize !== 0) {
+            const t = new TypeError("Insufficient bytes to fill elements in the given buffer");
+            throw Xe(e, t), t;
+          }
+        }
+        Ve(e), Yr(t);
+      }
+  }
+  function Ge(e, t) {
+    const r = e._controlledReadableByteStream;
+    if (e._closeRequested || r._state !== "readable")
+      return;
+    const { buffer: o, byteOffset: n, byteLength: i } = t;
+    if (de(o))
+      throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
+    const a = ce(o);
+    if (e._pendingPullIntos.length > 0) {
+      const t = e._pendingPullIntos.peek();
+      if (de(t.buffer))
+        throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
+      xe(e), t.buffer = ce(t.buffer), t.readerType === "none" && Ie(e, t);
+    }
+    if (J(r))
+      if (function(e) {
+        const t = e._controlledReadableByteStream._reader;
+        for (;t._readRequests.length > 0; ) {
+          if (e._queueTotalSize === 0)
+            return;
+          Je(e, t._readRequests.shift());
+        }
+      }(e), X(r) === 0)
+        Fe(e, a, n, i);
+      else {
+        e._pendingPullIntos.length > 0 && He(e);
+        G(r, new Uint8Array(a, n, i), false);
+      }
+    else if (ut(r)) {
+      Fe(e, a, n, i);
+      ze(r, Qe(e));
+    } else
+      Fe(e, a, n, i);
+    je(e);
+  }
+  function Xe(e, t) {
+    const r = e._controlledReadableByteStream;
+    r._state === "readable" && (ke(e), qe(e), Ve(e), xr(r, t));
+  }
+  function Je(e, t) {
+    const r = e._queue.shift();
+    e._queueTotalSize -= r.byteLength, Ye(e);
+    const o = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+    t._chunkSteps(o);
+  }
+  function Ke(e) {
+    if (e._byobRequest === null && e._pendingPullIntos.length > 0) {
+      const t = e._pendingPullIntos.peek(), r = new Uint8Array(t.buffer, t.byteOffset + t.bytesFilled, t.byteLength - t.bytesFilled), o = Object.create(ReadableStreamBYOBRequest.prototype);
+      (function(e, t, r) {
+        e._associatedReadableByteStreamController = t, e._view = r;
+      })(o, e, r), e._byobRequest = o;
+    }
+    return e._byobRequest;
+  }
+  function Ze(e) {
+    const t = e._controlledReadableByteStream._state;
+    return t === "errored" ? null : t === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
+  }
+  function et(e, t) {
+    const r = e._pendingPullIntos.peek();
+    if (e._controlledReadableByteStream._state === "closed") {
+      if (t !== 0)
+        throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
+    } else {
+      if (t === 0)
+        throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
+      if (r.bytesFilled + t > r.byteLength)
+        throw new RangeError("bytesWritten out of range");
+    }
+    r.buffer = ce(r.buffer), Ne(e, t);
+  }
+  function tt(e, t) {
+    const r = e._pendingPullIntos.peek();
+    if (e._controlledReadableByteStream._state === "closed") {
+      if (t.byteLength !== 0)
+        throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
+    } else if (t.byteLength === 0)
+      throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
+    if (r.byteOffset + r.bytesFilled !== t.byteOffset)
+      throw new RangeError("The region specified by view does not match byobRequest");
+    if (r.bufferByteLength !== t.buffer.byteLength)
+      throw new RangeError("The buffer of view has different capacity than byobRequest");
+    if (r.bytesFilled + t.byteLength > r.byteLength)
+      throw new RangeError("The region specified by view is larger than byobRequest");
+    const o = t.byteLength;
+    r.buffer = ce(t.buffer), Ne(e, o);
+  }
+  function rt(e, t, r, o, n, i, a) {
+    t._controlledReadableByteStream = e, t._pullAgain = false, t._pulling = false, t._byobRequest = null, t._queue = t._queueTotalSize = undefined, qe(t), t._closeRequested = false, t._started = false, t._strategyHWM = i, t._pullAlgorithm = o, t._cancelAlgorithm = n, t._autoAllocateChunkSize = a, t._pendingPullIntos = new v, e._readableStreamController = t;
+    h(c(r()), () => (t._started = true, je(t), null), (e) => (Xe(t, e), null));
+  }
+  function ot(e) {
+    return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`);
+  }
+  function nt(e) {
+    return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`);
+  }
+  function it(e, t) {
+    if ((e = `${e}`) !== "byob")
+      throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);
+    return e;
+  }
+  function at(e) {
+    return new ReadableStreamBYOBReader(e);
+  }
+  function st(e, t) {
+    e._reader._readIntoRequests.push(t);
+  }
+  function lt(e) {
+    return e._reader._readIntoRequests.length;
+  }
+  function ut(e) {
+    const t = e._reader;
+    return t !== undefined && !!ft(t);
+  }
+  Object.defineProperties(ReadableByteStreamController.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, byobRequest: { enumerable: true }, desiredSize: { enumerable: true } }), o(ReadableByteStreamController.prototype.close, "close"), o(ReadableByteStreamController.prototype.enqueue, "enqueue"), o(ReadableByteStreamController.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, { value: "ReadableByteStreamController", configurable: true });
+
+  class ReadableStreamBYOBReader {
+    constructor(e) {
+      if (M(e, 1, "ReadableStreamBYOBReader"), H(e, "First parameter"), $r(e))
+        throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+      if (!Oe(e._readableStreamController))
+        throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
+      E(this, e), this._readIntoRequests = new v;
+    }
+    get closed() {
+      return ft(this) ? this._closedPromise : d(_t("closed"));
+    }
+    cancel(e = undefined) {
+      return ft(this) ? this._ownerReadableStream === undefined ? d(B("cancel")) : W(this, e) : d(_t("cancel"));
+    }
+    read(e, t = {}) {
+      if (!ft(this))
+        return d(_t("read"));
+      if (!ArrayBuffer.isView(e))
+        return d(new TypeError("view must be an array buffer view"));
+      if (e.byteLength === 0)
+        return d(new TypeError("view must have non-zero byteLength"));
+      if (e.buffer.byteLength === 0)
+        return d(new TypeError("view's buffer must have non-zero byteLength"));
+      if (de(e.buffer))
+        return d(new TypeError("view's buffer has been detached"));
+      let r;
+      try {
+        r = function(e, t) {
+          var r;
+          return L(e, t), { min: N((r = e == null ? undefined : e.min) !== null && r !== undefined ? r : 1, `${t} has member 'min' that`) };
+        }(t, "options");
+      } catch (e) {
+        return d(e);
+      }
+      const o = r.min;
+      if (o === 0)
+        return d(new TypeError("options.min must be greater than 0"));
+      if (function(e) {
+        return Ee(e.constructor);
+      }(e)) {
+        if (o > e.byteLength)
+          return d(new RangeError("options.min must be less than or equal to view's byteLength"));
+      } else if (o > e.length)
+        return d(new RangeError("options.min must be less than or equal to view's length"));
+      if (this._ownerReadableStream === undefined)
+        return d(B("read from"));
+      const n = function(e, t, r) {
+        const o = e._ownerReadableStream;
+        return o._state === "errored" || function(e, t, r) {
+          const o = e._controlledReadableByteStream, n = We(t.constructor), { byteLength: i } = t, a = r * n;
+          return !(e._pendingPullIntos.length > 0) && (o._state === "closed" || e._queueTotalSize >= a);
+        }(o._readableStreamController, t, r);
+      }(this, e, o) ? new dt : new ct;
+      return ht(this, e, o, n), n._promise;
+    }
+    releaseLock() {
+      if (!ft(this))
+        throw _t("releaseLock");
+      this._ownerReadableStream !== undefined && function(e) {
+        O(e);
+        const t = new TypeError("Reader was released");
+        bt(e, t);
+      }(this);
+    }
+  }
+  Object.defineProperties(ReadableStreamBYOBReader.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), o(ReadableStreamBYOBReader.prototype.cancel, "cancel"), o(ReadableStreamBYOBReader.prototype.read, "read"), o(ReadableStreamBYOBReader.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableStreamBYOBReader.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBReader", configurable: true });
+
+  class ct {
+    constructor() {
+      this._promise = u((e, t) => {
+        this._resolvePromise = e, this._rejectPromise = t;
+      });
+    }
+    _chunkSteps(e) {
+      this._resolvePromise({ value: e, done: false });
+    }
+    _closeSteps(e) {
+      this._resolvePromise({ value: e, done: true });
+    }
+    _errorSteps(e) {
+      this._rejectPromise(e);
+    }
+  }
+
+  class dt {
+    constructor() {
+      this._promise = undefined;
+    }
+    _chunkSteps(e) {
+      this._promise = l({ value: e, done: false });
+    }
+    _closeSteps(e) {
+      this._promise = l({ value: e, done: true });
+    }
+    _errorSteps(e) {
+      this._promise = d(e);
+    }
+  }
+  function ft(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_readIntoRequests") && e instanceof ReadableStreamBYOBReader);
+  }
+  function ht(e, t, r, o) {
+    const n = e._ownerReadableStream;
+    n._disturbed = true, n._state === "errored" ? o._errorSteps(n._storedError) : function(e, t, r, o) {
+      const n = e._controlledReadableByteStream, i = t.constructor, a = We(i), { byteOffset: s, byteLength: l } = t, u = r * a;
+      let c;
+      try {
+        c = ce(t.buffer);
+      } catch (e) {
+        return void o._errorSteps(e);
+      }
+      const d = { buffer: c, bufferByteLength: c.byteLength, byteOffset: s, byteLength: l, bytesFilled: 0, minimumFill: u, elementSize: a, viewConstructor: i, readerType: "byob" };
+      if (e._pendingPullIntos.length > 0)
+        return e._pendingPullIntos.push(d), void st(n, o);
+      if (n._state === "closed") {
+        const e = new i(d.buffer, d.byteOffset, 0);
+        return void o._closeSteps(e);
+      }
+      if (e._queueTotalSize > 0) {
+        if ($e(e, d)) {
+          const t = De(d);
+          return Ye(e), void o._chunkSteps(t);
+        }
+        if (e._closeRequested) {
+          const t = new TypeError("Insufficient bytes to fill elements in the given buffer");
+          return Xe(e, t), void o._errorSteps(t);
+        }
+      }
+      e._pendingPullIntos.push(d), st(n, o), je(e);
+    }(n._readableStreamController, t, r, o);
+  }
+  function bt(e, t) {
+    const r = e._readIntoRequests;
+    e._readIntoRequests = new v, r.forEach((e) => {
+      e._errorSteps(t);
+    });
+  }
+  function _t(e) {
+    return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`);
+  }
+  function mt(e, t) {
+    const { highWaterMark: r } = e;
+    if (r === undefined)
+      return t;
+    if (Re(r) || r < 0)
+      throw new RangeError("Invalid highWaterMark");
+    return r;
+  }
+  function pt(e) {
+    const { size: t } = e;
+    return t || (() => 1);
+  }
+  function yt(e, t) {
+    L(e, t);
+    const r = e == null ? undefined : e.highWaterMark, o = e == null ? undefined : e.size;
+    return { highWaterMark: r === undefined ? undefined : x(r), size: o === undefined ? undefined : St(o, `${t} has member 'size' that`) };
+  }
+  function St(e, t) {
+    return I(e, t), (t) => x(e(t));
+  }
+  function gt(e, t, r) {
+    return I(e, r), (r) => g(e, t, [r]);
+  }
+  function vt(e, t, r) {
+    return I(e, r), () => g(e, t, []);
+  }
+  function wt(e, t, r) {
+    return I(e, r), (r) => S(e, t, [r]);
+  }
+  function Rt(e, t, r) {
+    return I(e, r), (r, o) => g(e, t, [r, o]);
+  }
+  function Tt(e, t) {
+    if (!qt(e))
+      throw new TypeError(`${t} is not a WritableStream.`);
+  }
+
+  class WritableStream {
+    constructor(e = {}, t = {}) {
+      e === undefined ? e = null : $(e, "First parameter");
+      const r = yt(t, "Second parameter"), o = function(e, t) {
+        L(e, t);
+        const r = e == null ? undefined : e.abort, o = e == null ? undefined : e.close, n = e == null ? undefined : e.start, i = e == null ? undefined : e.type, a = e == null ? undefined : e.write;
+        return { abort: r === undefined ? undefined : gt(r, e, `${t} has member 'abort' that`), close: o === undefined ? undefined : vt(o, e, `${t} has member 'close' that`), start: n === undefined ? undefined : wt(n, e, `${t} has member 'start' that`), write: a === undefined ? undefined : Rt(a, e, `${t} has member 'write' that`), type: i };
+      }(e, "First parameter");
+      Ct(this);
+      if (o.type !== undefined)
+        throw new RangeError("Invalid type is specified");
+      const n = pt(r);
+      (function(e, t, r, o) {
+        const n = Object.create(WritableStreamDefaultController.prototype);
+        let i, a, s, l;
+        i = t.start !== undefined ? () => t.start(n) : () => {};
+        a = t.write !== undefined ? (e) => t.write(e, n) : () => c(undefined);
+        s = t.close !== undefined ? () => t.close() : () => c(undefined);
+        l = t.abort !== undefined ? (e) => t.abort(e) : () => c(undefined);
+        Nt(e, n, i, a, s, l, r, o);
+      })(this, o, mt(r, 1), n);
+    }
+    get locked() {
+      if (!qt(this))
+        throw Kt("locked");
+      return Et(this);
+    }
+    abort(e = undefined) {
+      return qt(this) ? Et(this) ? d(new TypeError("Cannot abort a stream that already has a writer")) : Wt(this, e) : d(Kt("abort"));
+    }
+    close() {
+      return qt(this) ? Et(this) ? d(new TypeError("Cannot close a stream that already has a writer")) : At(this) ? d(new TypeError("Cannot close an already-closing stream")) : Ot(this) : d(Kt("close"));
+    }
+    getWriter() {
+      if (!qt(this))
+        throw Kt("getWriter");
+      return Pt(this);
+    }
+  }
+  function Pt(e) {
+    return new WritableStreamDefaultWriter(e);
+  }
+  function Ct(e) {
+    e._state = "writable", e._storedError = undefined, e._writer = undefined, e._writableStreamController = undefined, e._writeRequests = new v, e._inFlightWriteRequest = undefined, e._closeRequest = undefined, e._inFlightCloseRequest = undefined, e._pendingAbortRequest = undefined, e._backpressure = false;
+  }
+  function qt(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_writableStreamController") && e instanceof WritableStream);
+  }
+  function Et(e) {
+    return e._writer !== undefined;
+  }
+  function Wt(e, t) {
+    var r;
+    if (e._state === "closed" || e._state === "errored")
+      return c(undefined);
+    e._writableStreamController._abortReason = t, (r = e._writableStreamController._abortController) === null || r === undefined || r.abort(t);
+    const o = e._state;
+    if (o === "closed" || o === "errored")
+      return c(undefined);
+    if (e._pendingAbortRequest !== undefined)
+      return e._pendingAbortRequest._promise;
+    let n = false;
+    o === "erroring" && (n = true, t = undefined);
+    const i = u((r, o) => {
+      e._pendingAbortRequest = { _promise: undefined, _resolve: r, _reject: o, _reason: t, _wasAlreadyErroring: n };
+    });
+    return e._pendingAbortRequest._promise = i, n || jt(e, t), i;
+  }
+  function Ot(e) {
+    const t = e._state;
+    if (t === "closed" || t === "errored")
+      return d(new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));
+    const r = u((t, r) => {
+      const o = { _resolve: t, _reject: r };
+      e._closeRequest = o;
+    }), o = e._writer;
+    var n;
+    return o !== undefined && e._backpressure && t === "writable" && cr(o), Ce(n = e._writableStreamController, xt, 0), Ut(n), r;
+  }
+  function Bt(e, t) {
+    e._state !== "writable" ? kt(e) : jt(e, t);
+  }
+  function jt(e, t) {
+    const r = e._writableStreamController;
+    e._state = "erroring", e._storedError = t;
+    const o = e._writer;
+    o !== undefined && $t(o, t), !function(e) {
+      if (e._inFlightWriteRequest === undefined && e._inFlightCloseRequest === undefined)
+        return false;
+      return true;
+    }(e) && r._started && kt(e);
+  }
+  function kt(e) {
+    e._state = "errored", e._writableStreamController[R]();
+    const t = e._storedError;
+    if (e._writeRequests.forEach((e) => {
+      e._reject(t);
+    }), e._writeRequests = new v, e._pendingAbortRequest === undefined)
+      return void zt(e);
+    const r = e._pendingAbortRequest;
+    if (e._pendingAbortRequest = undefined, r._wasAlreadyErroring)
+      return r._reject(t), void zt(e);
+    h(e._writableStreamController[w](r._reason), () => (r._resolve(), zt(e), null), (t) => (r._reject(t), zt(e), null));
+  }
+  function At(e) {
+    return e._closeRequest !== undefined || e._inFlightCloseRequest !== undefined;
+  }
+  function zt(e) {
+    e._closeRequest !== undefined && (e._closeRequest._reject(e._storedError), e._closeRequest = undefined);
+    const t = e._writer;
+    t !== undefined && nr(t, e._storedError);
+  }
+  function Dt(e, t) {
+    const r = e._writer;
+    r !== undefined && t !== e._backpressure && (t ? function(e) {
+      ar(e);
+    }(r) : cr(r)), e._backpressure = t;
+  }
+  Object.defineProperties(WritableStream.prototype, { abort: { enumerable: true }, close: { enumerable: true }, getWriter: { enumerable: true }, locked: { enumerable: true } }), o(WritableStream.prototype.abort, "abort"), o(WritableStream.prototype.close, "close"), o(WritableStream.prototype.getWriter, "getWriter"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(WritableStream.prototype, Symbol.toStringTag, { value: "WritableStream", configurable: true });
+
+  class WritableStreamDefaultWriter {
+    constructor(e) {
+      if (M(e, 1, "WritableStreamDefaultWriter"), Tt(e, "First parameter"), Et(e))
+        throw new TypeError("This stream has already been locked for exclusive writing by another writer");
+      this._ownerWritableStream = e, e._writer = this;
+      const t = e._state;
+      if (t === "writable")
+        !At(e) && e._backpressure ? ar(this) : lr(this), rr(this);
+      else if (t === "erroring")
+        sr(this, e._storedError), rr(this);
+      else if (t === "closed")
+        lr(this), rr(r = this), ir(r);
+      else {
+        const t = e._storedError;
+        sr(this, t), or(this, t);
+      }
+      var r;
+    }
+    get closed() {
+      return Ft(this) ? this._closedPromise : d(er("closed"));
+    }
+    get desiredSize() {
+      if (!Ft(this))
+        throw er("desiredSize");
+      if (this._ownerWritableStream === undefined)
+        throw tr("desiredSize");
+      return function(e) {
+        const t = e._ownerWritableStream, r = t._state;
+        if (r === "errored" || r === "erroring")
+          return null;
+        if (r === "closed")
+          return 0;
+        return Vt(t._writableStreamController);
+      }(this);
+    }
+    get ready() {
+      return Ft(this) ? this._readyPromise : d(er("ready"));
+    }
+    abort(e = undefined) {
+      return Ft(this) ? this._ownerWritableStream === undefined ? d(tr("abort")) : function(e, t) {
+        return Wt(e._ownerWritableStream, t);
+      }(this, e) : d(er("abort"));
+    }
+    close() {
+      if (!Ft(this))
+        return d(er("close"));
+      const e = this._ownerWritableStream;
+      return e === undefined ? d(tr("close")) : At(e) ? d(new TypeError("Cannot close an already-closing stream")) : Lt(this);
+    }
+    releaseLock() {
+      if (!Ft(this))
+        throw er("releaseLock");
+      this._ownerWritableStream !== undefined && Mt(this);
+    }
+    write(e = undefined) {
+      return Ft(this) ? this._ownerWritableStream === undefined ? d(tr("write to")) : Yt(this, e) : d(er("write"));
+    }
+  }
+  function Ft(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_ownerWritableStream") && e instanceof WritableStreamDefaultWriter);
+  }
+  function Lt(e) {
+    return Ot(e._ownerWritableStream);
+  }
+  function It(e, t) {
+    e._closedPromiseState === "pending" ? nr(e, t) : function(e, t) {
+      or(e, t);
+    }(e, t);
+  }
+  function $t(e, t) {
+    e._readyPromiseState === "pending" ? ur(e, t) : function(e, t) {
+      sr(e, t);
+    }(e, t);
+  }
+  function Mt(e) {
+    const t = e._ownerWritableStream, r = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
+    $t(e, r), It(e, r), t._writer = undefined, e._ownerWritableStream = undefined;
+  }
+  function Yt(e, t) {
+    const r = e._ownerWritableStream, o = r._writableStreamController, n = function(e, t) {
+      if (e._strategySizeAlgorithm === undefined)
+        return 1;
+      try {
+        return e._strategySizeAlgorithm(t);
+      } catch (t) {
+        return Gt(e, t), 1;
+      }
+    }(o, t);
+    if (r !== e._ownerWritableStream)
+      return d(tr("write to"));
+    const i = r._state;
+    if (i === "errored")
+      return d(r._storedError);
+    if (At(r) || i === "closed")
+      return d(new TypeError("The stream is closing or closed and cannot be written to"));
+    if (i === "erroring")
+      return d(r._storedError);
+    const a = function(e) {
+      return u((t, r) => {
+        const o = { _resolve: t, _reject: r };
+        e._writeRequests.push(o);
+      });
+    }(r);
+    return function(e, t, r) {
+      try {
+        Ce(e, t, r);
+      } catch (t) {
+        return void Gt(e, t);
+      }
+      const o = e._controlledWritableStream;
+      if (!At(o) && o._state === "writable") {
+        Dt(o, Xt(e));
+      }
+      Ut(e);
+    }(o, t, n), a;
+  }
+  Object.defineProperties(WritableStreamDefaultWriter.prototype, { abort: { enumerable: true }, close: { enumerable: true }, releaseLock: { enumerable: true }, write: { enumerable: true }, closed: { enumerable: true }, desiredSize: { enumerable: true }, ready: { enumerable: true } }), o(WritableStreamDefaultWriter.prototype.abort, "abort"), o(WritableStreamDefaultWriter.prototype.close, "close"), o(WritableStreamDefaultWriter.prototype.releaseLock, "releaseLock"), o(WritableStreamDefaultWriter.prototype.write, "write"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(WritableStreamDefaultWriter.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultWriter", configurable: true });
+  var xt = {};
+
+  class WritableStreamDefaultController {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+    get abortReason() {
+      if (!Qt(this))
+        throw Zt("abortReason");
+      return this._abortReason;
+    }
+    get signal() {
+      if (!Qt(this))
+        throw Zt("signal");
+      if (this._abortController === undefined)
+        throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
+      return this._abortController.signal;
+    }
+    error(e = undefined) {
+      if (!Qt(this))
+        throw Zt("error");
+      this._controlledWritableStream._state === "writable" && Jt(this, e);
+    }
+    [w](e) {
+      const t = this._abortAlgorithm(e);
+      return Ht(this), t;
+    }
+    [R]() {
+      qe(this);
+    }
+  }
+  function Qt(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_controlledWritableStream") && e instanceof WritableStreamDefaultController);
+  }
+  function Nt(e, t, r, o, n, i, a, s) {
+    t._controlledWritableStream = e, e._writableStreamController = t, t._queue = undefined, t._queueTotalSize = undefined, qe(t), t._abortReason = undefined, t._abortController = function() {
+      if (typeof AbortController == "function")
+        return new AbortController;
+    }(), t._started = false, t._strategySizeAlgorithm = s, t._strategyHWM = a, t._writeAlgorithm = o, t._closeAlgorithm = n, t._abortAlgorithm = i;
+    const l = Xt(t);
+    Dt(e, l);
+    h(c(r()), () => (t._started = true, Ut(t), null), (r) => (t._started = true, Bt(e, r), null));
+  }
+  function Ht(e) {
+    e._writeAlgorithm = undefined, e._closeAlgorithm = undefined, e._abortAlgorithm = undefined, e._strategySizeAlgorithm = undefined;
+  }
+  function Vt(e) {
+    return e._strategyHWM - e._queueTotalSize;
+  }
+  function Ut(e) {
+    const t = e._controlledWritableStream;
+    if (!e._started)
+      return;
+    if (t._inFlightWriteRequest !== undefined)
+      return;
+    if (t._state === "erroring")
+      return void kt(t);
+    if (e._queue.length === 0)
+      return;
+    const r = e._queue.peek().value;
+    r === xt ? function(e) {
+      const t = e._controlledWritableStream;
+      (function(e) {
+        e._inFlightCloseRequest = e._closeRequest, e._closeRequest = undefined;
+      })(t), Pe(e);
+      const r = e._closeAlgorithm();
+      Ht(e), h(r, () => (function(e) {
+        e._inFlightCloseRequest._resolve(undefined), e._inFlightCloseRequest = undefined, e._state === "erroring" && (e._storedError = undefined, e._pendingAbortRequest !== undefined && (e._pendingAbortRequest._resolve(), e._pendingAbortRequest = undefined)), e._state = "closed";
+        const t = e._writer;
+        t !== undefined && ir(t);
+      }(t), null), (e) => (function(e, t) {
+        e._inFlightCloseRequest._reject(t), e._inFlightCloseRequest = undefined, e._pendingAbortRequest !== undefined && (e._pendingAbortRequest._reject(t), e._pendingAbortRequest = undefined), Bt(e, t);
+      }(t, e), null));
+    }(e) : function(e, t) {
+      const r = e._controlledWritableStream;
+      (function(e) {
+        e._inFlightWriteRequest = e._writeRequests.shift();
+      })(r);
+      const o = e._writeAlgorithm(t);
+      h(o, () => {
+        (function(e) {
+          e._inFlightWriteRequest._resolve(undefined), e._inFlightWriteRequest = undefined;
+        })(r);
+        const t = r._state;
+        if (Pe(e), !At(r) && t === "writable") {
+          const t = Xt(e);
+          Dt(r, t);
+        }
+        return Ut(e), null;
+      }, (t) => (r._state === "writable" && Ht(e), function(e, t) {
+        e._inFlightWriteRequest._reject(t), e._inFlightWriteRequest = undefined, Bt(e, t);
+      }(r, t), null));
+    }(e, r);
+  }
+  function Gt(e, t) {
+    e._controlledWritableStream._state === "writable" && Jt(e, t);
+  }
+  function Xt(e) {
+    return Vt(e) <= 0;
+  }
+  function Jt(e, t) {
+    const r = e._controlledWritableStream;
+    Ht(e), jt(r, t);
+  }
+  function Kt(e) {
+    return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`);
+  }
+  function Zt(e) {
+    return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`);
+  }
+  function er(e) {
+    return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`);
+  }
+  function tr(e) {
+    return new TypeError("Cannot " + e + " a stream using a released writer");
+  }
+  function rr(e) {
+    e._closedPromise = u((t, r) => {
+      e._closedPromise_resolve = t, e._closedPromise_reject = r, e._closedPromiseState = "pending";
+    });
+  }
+  function or(e, t) {
+    rr(e), nr(e, t);
+  }
+  function nr(e, t) {
+    e._closedPromise_reject !== undefined && (p(e._closedPromise), e._closedPromise_reject(t), e._closedPromise_resolve = undefined, e._closedPromise_reject = undefined, e._closedPromiseState = "rejected");
+  }
+  function ir(e) {
+    e._closedPromise_resolve !== undefined && (e._closedPromise_resolve(undefined), e._closedPromise_resolve = undefined, e._closedPromise_reject = undefined, e._closedPromiseState = "resolved");
+  }
+  function ar(e) {
+    e._readyPromise = u((t, r) => {
+      e._readyPromise_resolve = t, e._readyPromise_reject = r;
+    }), e._readyPromiseState = "pending";
+  }
+  function sr(e, t) {
+    ar(e), ur(e, t);
+  }
+  function lr(e) {
+    ar(e), cr(e);
+  }
+  function ur(e, t) {
+    e._readyPromise_reject !== undefined && (p(e._readyPromise), e._readyPromise_reject(t), e._readyPromise_resolve = undefined, e._readyPromise_reject = undefined, e._readyPromiseState = "rejected");
+  }
+  function cr(e) {
+    e._readyPromise_resolve !== undefined && (e._readyPromise_resolve(undefined), e._readyPromise_resolve = undefined, e._readyPromise_reject = undefined, e._readyPromiseState = "fulfilled");
+  }
+  Object.defineProperties(WritableStreamDefaultController.prototype, { abortReason: { enumerable: true }, signal: { enumerable: true }, error: { enumerable: true } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(WritableStreamDefaultController.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultController", configurable: true });
+  var dr = typeof globalThis != "undefined" ? globalThis : typeof self != "undefined" ? self : typeof global != "undefined" ? global : undefined;
+  var fr = function() {
+    const e = dr == null ? undefined : dr.DOMException;
+    return function(e) {
+      if (typeof e != "function" && typeof e != "object")
+        return false;
+      if (e.name !== "DOMException")
+        return false;
+      try {
+        return new e, true;
+      } catch (e) {
+        return false;
+      }
+    }(e) ? e : undefined;
+  }() || function() {
+    const e = function(e, t) {
+      this.message = e || "", this.name = t || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+    };
+    return o(e, "DOMException"), e.prototype = Object.create(Error.prototype), Object.defineProperty(e.prototype, "constructor", { value: e, writable: true, configurable: true }), e;
+  }();
+  function hr(e, t, r, o, n, i) {
+    const a = V(e), s = Pt(t);
+    e._disturbed = true;
+    const l = new br(s), _ = new mr(l);
+    return u((m, y) => {
+      let S;
+      if (i !== undefined) {
+        if (S = () => {
+          const r = i.reason !== undefined ? i.reason : new fr("Aborted", "AbortError"), a = [];
+          o || a.push(() => t._state === "writable" ? Wt(t, r) : c(undefined)), n || a.push(() => e._state === "readable" ? Mr(e, r) : c(undefined)), T(() => Promise.all(a.map((e) => e())), true, r);
+        }, i.aborted)
+          return void S();
+        i.addEventListener("abort", S);
+      }
+      function g() {
+        for (;!l._shuttingDown && !t._backpressure && t._state === "writable" && !At(t) && e._state === "readable" && re(a); )
+          te(a, _);
+        if (l._shuttingDown)
+          return c(true);
+        if (t._backpressure)
+          return f(s._readyPromise, g);
+        const r = new _r(l);
+        return te(a, r), r._promise;
+      }
+      var v, w, R;
+      if (pr(e, a._closedPromise, (e) => (o ? P(true, e) : T(() => Wt(t, e), true, e), null)), pr(t, s._closedPromise, (t) => (n ? P(true, t) : T(() => Mr(e, t), true, t), null)), v = e, w = a._closedPromise, R = () => (r ? P() : T(() => function(e) {
+        const t = e._ownerWritableStream, r = t._state;
+        return At(t) || r === "closed" ? c(undefined) : r === "errored" ? d(t._storedError) : Lt(e);
+      }(s)), null), v._state === "closed" ? R() : b(w, R), At(t) || t._state === "closed") {
+        const t = new TypeError("the destination writable stream closed before all data could be piped to it");
+        n ? P(true, t) : T(() => Mr(e, t), true, t);
+      }
+      function T(e, r, o) {
+        function n() {
+          return h(e(), () => C(r, o), (e) => C(true, e)), null;
+        }
+        l._shuttingDown || (l._shuttingDown = true, t._state !== "writable" || At(t) ? n() : b(l._waitForWritesToFinish(), n));
+      }
+      function P(e, r) {
+        l._shuttingDown || (l._shuttingDown = true, t._state !== "writable" || At(t) ? C(e, r) : b(l._waitForWritesToFinish(), () => C(e, r)));
+      }
+      function C(e, t) {
+        return Mt(s), O(a), i !== undefined && i.removeEventListener("abort", S), e ? y(t) : m(undefined), null;
+      }
+      p(u((e, t) => {
+        (function r(o) {
+          o ? e() : f(g(), r, t);
+        })(false);
+      }));
+    });
+  }
+
+  class br {
+    constructor(e) {
+      this._writer = e, this._shuttingDown = false, this._currentWrite = c(undefined);
+    }
+    _waitForWritesToFinish() {
+      const e = this._currentWrite;
+      return f(this._currentWrite, () => e !== this._currentWrite ? this._waitForWritesToFinish() : undefined);
+    }
+  }
+
+  class _r {
+    constructor(e) {
+      this._state = e, this._promise = u((e, t) => {
+        this._resolvePromise = e, this._rejectPromise = t;
+      });
+    }
+    _chunkSteps(t) {
+      this._state._currentWrite = f(Yt(this._state._writer, t), undefined, e), this._resolvePromise(false);
+    }
+    _closeSteps() {
+      this._resolvePromise(true);
+    }
+    _errorSteps(e) {
+      this._rejectPromise(e);
+    }
+  }
+
+  class mr {
+    constructor(e) {
+      this._state = e;
+    }
+    _chunkSteps(t) {
+      this._state._currentWrite = f(Yt(this._state._writer, t), undefined, e);
+    }
+    _closeSteps() {}
+    _errorSteps(e) {}
+  }
+  function pr(e, t, r) {
+    e._state === "errored" ? r(e._storedError) : _(t, r);
+  }
+
+  class ReadableStreamDefaultController {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+    get desiredSize() {
+      if (!yr(this))
+        throw Er("desiredSize");
+      return Pr(this);
+    }
+    close() {
+      if (!yr(this))
+        throw Er("close");
+      if (!Cr(this))
+        throw new TypeError("The stream is not in a state that permits close");
+      wr(this);
+    }
+    enqueue(e = undefined) {
+      if (!yr(this))
+        throw Er("enqueue");
+      if (!Cr(this))
+        throw new TypeError("The stream is not in a state that permits enqueue");
+      return Rr(this, e);
+    }
+    error(e = undefined) {
+      if (!yr(this))
+        throw Er("error");
+      Tr(this, e);
+    }
+    [T](e) {
+      qe(this);
+      const t = this._cancelAlgorithm(e);
+      return vr(this), t;
+    }
+    [P](e) {
+      const t = this._controlledReadableStream;
+      if (this._queue.length > 0) {
+        const r = Pe(this);
+        this._closeRequested && this._queue.length === 0 ? (vr(this), Yr(t)) : Sr(this), e._chunkSteps(r);
+      } else
+        U(t, e), Sr(this);
+    }
+    [C]() {
+      return this._queue.length > 0;
+    }
+    [q]() {}
+  }
+  function yr(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_controlledReadableStream") && e instanceof ReadableStreamDefaultController);
+  }
+  function Sr(e) {
+    if (!gr(e))
+      return;
+    if (e._pulling)
+      return void (e._pullAgain = true);
+    e._pulling = true;
+    h(e._pullAlgorithm(), () => (e._pulling = false, e._pullAgain && (e._pullAgain = false, Sr(e)), null), (t) => (Tr(e, t), null));
+  }
+  function gr(e) {
+    const t = e._controlledReadableStream;
+    if (!Cr(e))
+      return false;
+    if (!e._started)
+      return false;
+    if ($r(t) && X(t) > 0)
+      return true;
+    return Pr(e) > 0;
+  }
+  function vr(e) {
+    e._pullAlgorithm = undefined, e._cancelAlgorithm = undefined, e._strategySizeAlgorithm = undefined;
+  }
+  function wr(e) {
+    if (!Cr(e))
+      return;
+    const t = e._controlledReadableStream;
+    e._closeRequested = true, e._queue.length === 0 && (vr(e), Yr(t));
+  }
+  function Rr(e, t) {
+    if (!Cr(e))
+      return;
+    const r = e._controlledReadableStream;
+    if ($r(r) && X(r) > 0)
+      G(r, t, false);
+    else {
+      let r;
+      try {
+        r = e._strategySizeAlgorithm(t);
+      } catch (t) {
+        throw Tr(e, t), t;
+      }
+      try {
+        Ce(e, t, r);
+      } catch (t) {
+        throw Tr(e, t), t;
+      }
+    }
+    Sr(e);
+  }
+  function Tr(e, t) {
+    const r = e._controlledReadableStream;
+    r._state === "readable" && (qe(e), vr(e), xr(r, t));
+  }
+  function Pr(e) {
+    const t = e._controlledReadableStream._state;
+    return t === "errored" ? null : t === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
+  }
+  function Cr(e) {
+    const t = e._controlledReadableStream._state;
+    return !e._closeRequested && t === "readable";
+  }
+  function qr(e, t, r, o, n, i, a) {
+    t._controlledReadableStream = e, t._queue = undefined, t._queueTotalSize = undefined, qe(t), t._started = false, t._closeRequested = false, t._pullAgain = false, t._pulling = false, t._strategySizeAlgorithm = a, t._strategyHWM = i, t._pullAlgorithm = o, t._cancelAlgorithm = n, e._readableStreamController = t;
+    h(c(r()), () => (t._started = true, Sr(t), null), (e) => (Tr(t, e), null));
+  }
+  function Er(e) {
+    return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`);
+  }
+  function Wr(e, t) {
+    return Oe(e._readableStreamController) ? function(e) {
+      let t, r, o, n, i, a = V(e), s = false, l = false, d = false, f = false, h = false;
+      const b = u((e) => {
+        i = e;
+      });
+      function m(e) {
+        _(e._closedPromise, (t) => (e !== a || (Xe(o._readableStreamController, t), Xe(n._readableStreamController, t), f && h || i(undefined)), null));
+      }
+      function p() {
+        ft(a) && (O(a), a = V(e), m(a));
+        te(a, { _chunkSteps: (t) => {
+          y(() => {
+            l = false, d = false;
+            const r = t;
+            let a = t;
+            if (!f && !h)
+              try {
+                a = Te(t);
+              } catch (t) {
+                return Xe(o._readableStreamController, t), Xe(n._readableStreamController, t), void i(Mr(e, t));
+              }
+            f || Ge(o._readableStreamController, r), h || Ge(n._readableStreamController, a), s = false, l ? g() : d && v();
+          });
+        }, _closeSteps: () => {
+          s = false, f || Ue(o._readableStreamController), h || Ue(n._readableStreamController), o._readableStreamController._pendingPullIntos.length > 0 && et(o._readableStreamController, 0), n._readableStreamController._pendingPullIntos.length > 0 && et(n._readableStreamController, 0), f && h || i(undefined);
+        }, _errorSteps: () => {
+          s = false;
+        } });
+      }
+      function S(t, r) {
+        ee(a) && (O(a), a = at(e), m(a));
+        const u = r ? n : o, c = r ? o : n;
+        ht(a, t, 1, { _chunkSteps: (t) => {
+          y(() => {
+            l = false, d = false;
+            const o = r ? h : f;
+            if (r ? f : h)
+              o || tt(u._readableStreamController, t);
+            else {
+              let r;
+              try {
+                r = Te(t);
+              } catch (t) {
+                return Xe(u._readableStreamController, t), Xe(c._readableStreamController, t), void i(Mr(e, t));
+              }
+              o || tt(u._readableStreamController, t), Ge(c._readableStreamController, r);
+            }
+            s = false, l ? g() : d && v();
+          });
+        }, _closeSteps: (e) => {
+          s = false;
+          const t = r ? h : f, o = r ? f : h;
+          t || Ue(u._readableStreamController), o || Ue(c._readableStreamController), e !== undefined && (t || tt(u._readableStreamController, e), !o && c._readableStreamController._pendingPullIntos.length > 0 && et(c._readableStreamController, 0)), t && o || i(undefined);
+        }, _errorSteps: () => {
+          s = false;
+        } });
+      }
+      function g() {
+        if (s)
+          return l = true, c(undefined);
+        s = true;
+        const e = Ke(o._readableStreamController);
+        return e === null ? p() : S(e._view, false), c(undefined);
+      }
+      function v() {
+        if (s)
+          return d = true, c(undefined);
+        s = true;
+        const e = Ke(n._readableStreamController);
+        return e === null ? p() : S(e._view, true), c(undefined);
+      }
+      function w(o) {
+        if (f = true, t = o, h) {
+          const o = le([t, r]), n = Mr(e, o);
+          i(n);
+        }
+        return b;
+      }
+      function R(o) {
+        if (h = true, r = o, f) {
+          const o = le([t, r]), n = Mr(e, o);
+          i(n);
+        }
+        return b;
+      }
+      function T() {}
+      return o = Fr(T, g, w), n = Fr(T, v, R), m(a), [o, n];
+    }(e) : function(e) {
+      const t = V(e);
+      let r, o, n, i, a, s = false, l = false, d = false, f = false;
+      const h = u((e) => {
+        a = e;
+      });
+      function b() {
+        if (s)
+          return l = true, c(undefined);
+        s = true;
+        return te(t, { _chunkSteps: (e) => {
+          y(() => {
+            l = false;
+            const t = e, r = e;
+            d || Rr(n._readableStreamController, t), f || Rr(i._readableStreamController, r), s = false, l && b();
+          });
+        }, _closeSteps: () => {
+          s = false, d || wr(n._readableStreamController), f || wr(i._readableStreamController), d && f || a(undefined);
+        }, _errorSteps: () => {
+          s = false;
+        } }), c(undefined);
+      }
+      function m(t) {
+        if (d = true, r = t, f) {
+          const t = le([r, o]), n = Mr(e, t);
+          a(n);
+        }
+        return h;
+      }
+      function p(t) {
+        if (f = true, o = t, d) {
+          const t = le([r, o]), n = Mr(e, t);
+          a(n);
+        }
+        return h;
+      }
+      function S() {}
+      return n = Dr(S, b, m), i = Dr(S, b, p), _(t._closedPromise, (e) => (Tr(n._readableStreamController, e), Tr(i._readableStreamController, e), d && f || a(undefined), null)), [n, i];
+    }(e);
+  }
+  function Or(r) {
+    return t(o = r) && o.getReader !== undefined ? function(r) {
+      let o;
+      function n() {
+        let e;
+        try {
+          e = r.read();
+        } catch (e) {
+          return d(e);
+        }
+        return m(e, (e) => {
+          if (!t(e))
+            throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
+          if (e.done)
+            wr(o._readableStreamController);
+          else {
+            const t = e.value;
+            Rr(o._readableStreamController, t);
+          }
+        });
+      }
+      function i(e) {
+        try {
+          return c(r.cancel(e));
+        } catch (e) {
+          return d(e);
+        }
+      }
+      return o = Dr(e, n, i, 0), o;
+    }(r.getReader()) : function(r) {
+      let o;
+      const n = me(r, "async");
+      function i() {
+        let e;
+        try {
+          e = pe(n);
+        } catch (e) {
+          return d(e);
+        }
+        return m(c(e), (e) => {
+          if (!t(e))
+            throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
+          if (e.done)
+            wr(o._readableStreamController);
+          else {
+            const t = e.value;
+            Rr(o._readableStreamController, t);
+          }
+        });
+      }
+      function a(e) {
+        const r = n.iterator;
+        let o;
+        try {
+          o = he(r, "return");
+        } catch (e) {
+          return d(e);
+        }
+        if (o === undefined)
+          return c(undefined);
+        return m(g(o, r, [e]), (e) => {
+          if (!t(e))
+            throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
+        });
+      }
+      return o = Dr(e, i, a, 0), o;
+    }(r);
+    var o;
+  }
+  function Br(e, t, r) {
+    return I(e, r), (r) => g(e, t, [r]);
+  }
+  function jr(e, t, r) {
+    return I(e, r), (r) => g(e, t, [r]);
+  }
+  function kr(e, t, r) {
+    return I(e, r), (r) => S(e, t, [r]);
+  }
+  function Ar(e, t) {
+    if ((e = `${e}`) !== "bytes")
+      throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);
+    return e;
+  }
+  function zr(e, t) {
+    L(e, t);
+    const r = e == null ? undefined : e.preventAbort, o = e == null ? undefined : e.preventCancel, n = e == null ? undefined : e.preventClose, i = e == null ? undefined : e.signal;
+    return i !== undefined && function(e, t) {
+      if (!function(e) {
+        if (typeof e != "object" || e === null)
+          return false;
+        try {
+          return typeof e.aborted == "boolean";
+        } catch (e) {
+          return false;
+        }
+      }(e))
+        throw new TypeError(`${t} is not an AbortSignal.`);
+    }(i, `${t} has member 'signal' that`), { preventAbort: Boolean(r), preventCancel: Boolean(o), preventClose: Boolean(n), signal: i };
+  }
+  Object.defineProperties(ReadableStreamDefaultController.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, desiredSize: { enumerable: true } }), o(ReadableStreamDefaultController.prototype.close, "close"), o(ReadableStreamDefaultController.prototype.enqueue, "enqueue"), o(ReadableStreamDefaultController.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableStreamDefaultController.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultController", configurable: true });
+
+  class ReadableStream {
+    constructor(e = {}, t = {}) {
+      e === undefined ? e = null : $(e, "First parameter");
+      const r = yt(t, "Second parameter"), o = function(e, t) {
+        L(e, t);
+        const r = e, o = r == null ? undefined : r.autoAllocateChunkSize, n = r == null ? undefined : r.cancel, i = r == null ? undefined : r.pull, a = r == null ? undefined : r.start, s = r == null ? undefined : r.type;
+        return { autoAllocateChunkSize: o === undefined ? undefined : N(o, `${t} has member 'autoAllocateChunkSize' that`), cancel: n === undefined ? undefined : Br(n, r, `${t} has member 'cancel' that`), pull: i === undefined ? undefined : jr(i, r, `${t} has member 'pull' that`), start: a === undefined ? undefined : kr(a, r, `${t} has member 'start' that`), type: s === undefined ? undefined : Ar(s, `${t} has member 'type' that`) };
+      }(e, "First parameter");
+      if (Lr(this), o.type === "bytes") {
+        if (r.size !== undefined)
+          throw new RangeError("The strategy for a byte stream cannot have a size function");
+        (function(e, t, r) {
+          const o = Object.create(ReadableByteStreamController.prototype);
+          let n, i, a;
+          n = t.start !== undefined ? () => t.start(o) : () => {}, i = t.pull !== undefined ? () => t.pull(o) : () => c(undefined), a = t.cancel !== undefined ? (e) => t.cancel(e) : () => c(undefined);
+          const s = t.autoAllocateChunkSize;
+          if (s === 0)
+            throw new TypeError("autoAllocateChunkSize must be greater than 0");
+          rt(e, o, n, i, a, r, s);
+        })(this, o, mt(r, 0));
+      } else {
+        const e = pt(r);
+        (function(e, t, r, o) {
+          const n = Object.create(ReadableStreamDefaultController.prototype);
+          let i, a, s;
+          i = t.start !== undefined ? () => t.start(n) : () => {}, a = t.pull !== undefined ? () => t.pull(n) : () => c(undefined), s = t.cancel !== undefined ? (e) => t.cancel(e) : () => c(undefined), qr(e, n, i, a, s, r, o);
+        })(this, o, mt(r, 1), e);
+      }
+    }
+    get locked() {
+      if (!Ir(this))
+        throw Qr("locked");
+      return $r(this);
+    }
+    cancel(e = undefined) {
+      return Ir(this) ? $r(this) ? d(new TypeError("Cannot cancel a stream that already has a reader")) : Mr(this, e) : d(Qr("cancel"));
+    }
+    getReader(e = undefined) {
+      if (!Ir(this))
+        throw Qr("getReader");
+      return function(e, t) {
+        L(e, t);
+        const r = e == null ? undefined : e.mode;
+        return { mode: r === undefined ? undefined : it(r, `${t} has member 'mode' that`) };
+      }(e, "First parameter").mode === undefined ? V(this) : at(this);
+    }
+    pipeThrough(e, t = {}) {
+      if (!Ir(this))
+        throw Qr("pipeThrough");
+      M(e, 1, "pipeThrough");
+      const r = function(e, t) {
+        L(e, t);
+        const r = e == null ? undefined : e.readable;
+        Y(r, "readable", "ReadableWritablePair"), H(r, `${t} has member 'readable' that`);
+        const o = e == null ? undefined : e.writable;
+        return Y(o, "writable", "ReadableWritablePair"), Tt(o, `${t} has member 'writable' that`), { readable: r, writable: o };
+      }(e, "First parameter"), o = zr(t, "Second parameter");
+      if ($r(this))
+        throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
+      if (Et(r.writable))
+        throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
+      return p(hr(this, r.writable, o.preventClose, o.preventAbort, o.preventCancel, o.signal)), r.readable;
+    }
+    pipeTo(e, t = {}) {
+      if (!Ir(this))
+        return d(Qr("pipeTo"));
+      if (e === undefined)
+        return d("Parameter 1 is required in 'pipeTo'.");
+      if (!qt(e))
+        return d(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
+      let r;
+      try {
+        r = zr(t, "Second parameter");
+      } catch (e) {
+        return d(e);
+      }
+      return $r(this) ? d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : Et(e) ? d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : hr(this, e, r.preventClose, r.preventAbort, r.preventCancel, r.signal);
+    }
+    tee() {
+      if (!Ir(this))
+        throw Qr("tee");
+      return le(Wr(this));
+    }
+    values(e = undefined) {
+      if (!Ir(this))
+        throw Qr("values");
+      return function(e, t) {
+        const r = V(e), o = new ye(r, t), n = Object.create(ge);
+        return n._asyncIteratorImpl = o, n;
+      }(this, function(e, t) {
+        L(e, t);
+        const r = e == null ? undefined : e.preventCancel;
+        return { preventCancel: Boolean(r) };
+      }(e, "First parameter").preventCancel);
+    }
+    [_e](e) {
+      return this.values(e);
+    }
+    static from(e) {
+      return Or(e);
+    }
+  }
+  function Dr(e, t, r, o = 1, n = () => 1) {
+    const i = Object.create(ReadableStream.prototype);
+    Lr(i);
+    return qr(i, Object.create(ReadableStreamDefaultController.prototype), e, t, r, o, n), i;
+  }
+  function Fr(e, t, r) {
+    const o = Object.create(ReadableStream.prototype);
+    Lr(o);
+    return rt(o, Object.create(ReadableByteStreamController.prototype), e, t, r, 0, undefined), o;
+  }
+  function Lr(e) {
+    e._state = "readable", e._reader = undefined, e._storedError = undefined, e._disturbed = false;
+  }
+  function Ir(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_readableStreamController") && e instanceof ReadableStream);
+  }
+  function $r(e) {
+    return e._reader !== undefined;
+  }
+  function Mr(t, r) {
+    if (t._disturbed = true, t._state === "closed")
+      return c(undefined);
+    if (t._state === "errored")
+      return d(t._storedError);
+    Yr(t);
+    const o = t._reader;
+    if (o !== undefined && ft(o)) {
+      const e = o._readIntoRequests;
+      o._readIntoRequests = new v, e.forEach((e) => {
+        e._closeSteps(undefined);
+      });
+    }
+    return m(t._readableStreamController[T](r), e);
+  }
+  function Yr(e) {
+    e._state = "closed";
+    const t = e._reader;
+    if (t !== undefined && (z(t), ee(t))) {
+      const e = t._readRequests;
+      t._readRequests = new v, e.forEach((e) => {
+        e._closeSteps();
+      });
+    }
+  }
+  function xr(e, t) {
+    e._state = "errored", e._storedError = t;
+    const r = e._reader;
+    r !== undefined && (A(r, t), ee(r) ? oe(r, t) : bt(r, t));
+  }
+  function Qr(e) {
+    return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`);
+  }
+  function Nr(e, t) {
+    L(e, t);
+    const r = e == null ? undefined : e.highWaterMark;
+    return Y(r, "highWaterMark", "QueuingStrategyInit"), { highWaterMark: x(r) };
+  }
+  Object.defineProperties(ReadableStream, { from: { enumerable: true } }), Object.defineProperties(ReadableStream.prototype, { cancel: { enumerable: true }, getReader: { enumerable: true }, pipeThrough: { enumerable: true }, pipeTo: { enumerable: true }, tee: { enumerable: true }, values: { enumerable: true }, locked: { enumerable: true } }), o(ReadableStream.from, "from"), o(ReadableStream.prototype.cancel, "cancel"), o(ReadableStream.prototype.getReader, "getReader"), o(ReadableStream.prototype.pipeThrough, "pipeThrough"), o(ReadableStream.prototype.pipeTo, "pipeTo"), o(ReadableStream.prototype.tee, "tee"), o(ReadableStream.prototype.values, "values"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableStream.prototype, Symbol.toStringTag, { value: "ReadableStream", configurable: true }), Object.defineProperty(ReadableStream.prototype, _e, { value: ReadableStream.prototype.values, writable: true, configurable: true });
+  var Hr = (e) => e.byteLength;
+  o(Hr, "size");
+
+  class ByteLengthQueuingStrategy {
+    constructor(e) {
+      M(e, 1, "ByteLengthQueuingStrategy"), e = Nr(e, "First parameter"), this._byteLengthQueuingStrategyHighWaterMark = e.highWaterMark;
+    }
+    get highWaterMark() {
+      if (!Ur(this))
+        throw Vr("highWaterMark");
+      return this._byteLengthQueuingStrategyHighWaterMark;
+    }
+    get size() {
+      if (!Ur(this))
+        throw Vr("size");
+      return Hr;
+    }
+  }
+  function Vr(e) {
+    return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`);
+  }
+  function Ur(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_byteLengthQueuingStrategyHighWaterMark") && e instanceof ByteLengthQueuingStrategy);
+  }
+  Object.defineProperties(ByteLengthQueuingStrategy.prototype, { highWaterMark: { enumerable: true }, size: { enumerable: true } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ByteLengthQueuingStrategy.prototype, Symbol.toStringTag, { value: "ByteLengthQueuingStrategy", configurable: true });
+  var Gr = () => 1;
+  o(Gr, "size");
+
+  class CountQueuingStrategy {
+    constructor(e) {
+      M(e, 1, "CountQueuingStrategy"), e = Nr(e, "First parameter"), this._countQueuingStrategyHighWaterMark = e.highWaterMark;
+    }
+    get highWaterMark() {
+      if (!Jr(this))
+        throw Xr("highWaterMark");
+      return this._countQueuingStrategyHighWaterMark;
+    }
+    get size() {
+      if (!Jr(this))
+        throw Xr("size");
+      return Gr;
+    }
+  }
+  function Xr(e) {
+    return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`);
+  }
+  function Jr(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_countQueuingStrategyHighWaterMark") && e instanceof CountQueuingStrategy);
+  }
+  function Kr(e, t, r) {
+    return I(e, r), (r) => g(e, t, [r]);
+  }
+  function Zr(e, t, r) {
+    return I(e, r), (r) => S(e, t, [r]);
+  }
+  function eo(e, t, r) {
+    return I(e, r), (r, o) => g(e, t, [r, o]);
+  }
+  function to(e, t, r) {
+    return I(e, r), (r) => g(e, t, [r]);
+  }
+  Object.defineProperties(CountQueuingStrategy.prototype, { highWaterMark: { enumerable: true }, size: { enumerable: true } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(CountQueuingStrategy.prototype, Symbol.toStringTag, { value: "CountQueuingStrategy", configurable: true });
+
+  class TransformStream {
+    constructor(e = {}, t = {}, r = {}) {
+      e === undefined && (e = null);
+      const o = yt(t, "Second parameter"), n = yt(r, "Third parameter"), i = function(e, t) {
+        L(e, t);
+        const r = e == null ? undefined : e.cancel, o = e == null ? undefined : e.flush, n = e == null ? undefined : e.readableType, i = e == null ? undefined : e.start, a = e == null ? undefined : e.transform, s = e == null ? undefined : e.writableType;
+        return { cancel: r === undefined ? undefined : to(r, e, `${t} has member 'cancel' that`), flush: o === undefined ? undefined : Kr(o, e, `${t} has member 'flush' that`), readableType: n, start: i === undefined ? undefined : Zr(i, e, `${t} has member 'start' that`), transform: a === undefined ? undefined : eo(a, e, `${t} has member 'transform' that`), writableType: s };
+      }(e, "First parameter");
+      if (i.readableType !== undefined)
+        throw new RangeError("Invalid readableType specified");
+      if (i.writableType !== undefined)
+        throw new RangeError("Invalid writableType specified");
+      const a = mt(n, 0), s = pt(n), l = mt(o, 1), f = pt(o);
+      let b;
+      (function(e, t, r, o, n, i) {
+        function a() {
+          return t;
+        }
+        function s(t) {
+          return function(e, t) {
+            const r = e._transformStreamController;
+            if (e._backpressure) {
+              return m(e._backpressureChangePromise, () => {
+                const o = e._writable;
+                if (o._state === "erroring")
+                  throw o._storedError;
+                return co(r, t);
+              });
+            }
+            return co(r, t);
+          }(e, t);
+        }
+        function l(t) {
+          return function(e, t) {
+            const r = e._transformStreamController;
+            if (r._finishPromise !== undefined)
+              return r._finishPromise;
+            const o = e._readable;
+            r._finishPromise = u((e, t) => {
+              r._finishPromise_resolve = e, r._finishPromise_reject = t;
+            });
+            const n = r._cancelAlgorithm(t);
+            return lo(r), h(n, () => (o._state === "errored" ? bo(r, o._storedError) : (Tr(o._readableStreamController, t), ho(r)), null), (e) => (Tr(o._readableStreamController, e), bo(r, e), null)), r._finishPromise;
+          }(e, t);
+        }
+        function c() {
+          return function(e) {
+            const t = e._transformStreamController;
+            if (t._finishPromise !== undefined)
+              return t._finishPromise;
+            const r = e._readable;
+            t._finishPromise = u((e, r) => {
+              t._finishPromise_resolve = e, t._finishPromise_reject = r;
+            });
+            const o = t._flushAlgorithm();
+            return lo(t), h(o, () => (r._state === "errored" ? bo(t, r._storedError) : (wr(r._readableStreamController), ho(t)), null), (e) => (Tr(r._readableStreamController, e), bo(t, e), null)), t._finishPromise;
+          }(e);
+        }
+        function d() {
+          return function(e) {
+            return ao(e, false), e._backpressureChangePromise;
+          }(e);
+        }
+        function f(t) {
+          return function(e, t) {
+            const r = e._transformStreamController;
+            if (r._finishPromise !== undefined)
+              return r._finishPromise;
+            const o = e._writable;
+            r._finishPromise = u((e, t) => {
+              r._finishPromise_resolve = e, r._finishPromise_reject = t;
+            });
+            const n = r._cancelAlgorithm(t);
+            return lo(r), h(n, () => (o._state === "errored" ? bo(r, o._storedError) : (Gt(o._writableStreamController, t), io(e), ho(r)), null), (t) => (Gt(o._writableStreamController, t), io(e), bo(r, t), null)), r._finishPromise;
+          }(e, t);
+        }
+        e._writable = function(e, t, r, o, n = 1, i = () => 1) {
+          const a = Object.create(WritableStream.prototype);
+          return Ct(a), Nt(a, Object.create(WritableStreamDefaultController.prototype), e, t, r, o, n, i), a;
+        }(a, s, c, l, r, o), e._readable = Dr(a, d, f, n, i), e._backpressure = undefined, e._backpressureChangePromise = undefined, e._backpressureChangePromise_resolve = undefined, ao(e, true), e._transformStreamController = undefined;
+      })(this, u((e) => {
+        b = e;
+      }), l, f, a, s), function(e, t) {
+        const r = Object.create(TransformStreamDefaultController.prototype);
+        let o, n, i;
+        o = t.transform !== undefined ? (e) => t.transform(e, r) : (e) => {
+          try {
+            return uo(r, e), c(undefined);
+          } catch (e) {
+            return d(e);
+          }
+        };
+        n = t.flush !== undefined ? () => t.flush(r) : () => c(undefined);
+        i = t.cancel !== undefined ? (e) => t.cancel(e) : () => c(undefined);
+        (function(e, t, r, o, n) {
+          t._controlledTransformStream = e, e._transformStreamController = t, t._transformAlgorithm = r, t._flushAlgorithm = o, t._cancelAlgorithm = n, t._finishPromise = undefined, t._finishPromise_resolve = undefined, t._finishPromise_reject = undefined;
+        })(e, r, o, n, i);
+      }(this, i), i.start !== undefined ? b(i.start(this._transformStreamController)) : b(undefined);
+    }
+    get readable() {
+      if (!ro(this))
+        throw _o("readable");
+      return this._readable;
+    }
+    get writable() {
+      if (!ro(this))
+        throw _o("writable");
+      return this._writable;
+    }
+  }
+  function ro(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_transformStreamController") && e instanceof TransformStream);
+  }
+  function oo(e, t) {
+    Tr(e._readable._readableStreamController, t), no(e, t);
+  }
+  function no(e, t) {
+    lo(e._transformStreamController), Gt(e._writable._writableStreamController, t), io(e);
+  }
+  function io(e) {
+    e._backpressure && ao(e, false);
+  }
+  function ao(e, t) {
+    e._backpressureChangePromise !== undefined && e._backpressureChangePromise_resolve(), e._backpressureChangePromise = u((t) => {
+      e._backpressureChangePromise_resolve = t;
+    }), e._backpressure = t;
+  }
+  Object.defineProperties(TransformStream.prototype, { readable: { enumerable: true }, writable: { enumerable: true } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(TransformStream.prototype, Symbol.toStringTag, { value: "TransformStream", configurable: true });
+
+  class TransformStreamDefaultController {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+    get desiredSize() {
+      if (!so(this))
+        throw fo("desiredSize");
+      return Pr(this._controlledTransformStream._readable._readableStreamController);
+    }
+    enqueue(e = undefined) {
+      if (!so(this))
+        throw fo("enqueue");
+      uo(this, e);
+    }
+    error(e = undefined) {
+      if (!so(this))
+        throw fo("error");
+      var t;
+      t = e, oo(this._controlledTransformStream, t);
+    }
+    terminate() {
+      if (!so(this))
+        throw fo("terminate");
+      (function(e) {
+        const t = e._controlledTransformStream;
+        wr(t._readable._readableStreamController);
+        const r = new TypeError("TransformStream terminated");
+        no(t, r);
+      })(this);
+    }
+  }
+  function so(e) {
+    return !!t(e) && (!!Object.prototype.hasOwnProperty.call(e, "_controlledTransformStream") && e instanceof TransformStreamDefaultController);
+  }
+  function lo(e) {
+    e._transformAlgorithm = undefined, e._flushAlgorithm = undefined, e._cancelAlgorithm = undefined;
+  }
+  function uo(e, t) {
+    const r = e._controlledTransformStream, o = r._readable._readableStreamController;
+    if (!Cr(o))
+      throw new TypeError("Readable side is not in a state that permits enqueue");
+    try {
+      Rr(o, t);
+    } catch (e) {
+      throw no(r, e), r._readable._storedError;
+    }
+    const n = function(e) {
+      return !gr(e);
+    }(o);
+    n !== r._backpressure && ao(r, true);
+  }
+  function co(e, t) {
+    return m(e._transformAlgorithm(t), undefined, (t) => {
+      throw oo(e._controlledTransformStream, t), t;
+    });
+  }
+  function fo(e) {
+    return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`);
+  }
+  function ho(e) {
+    e._finishPromise_resolve !== undefined && (e._finishPromise_resolve(), e._finishPromise_resolve = undefined, e._finishPromise_reject = undefined);
+  }
+  function bo(e, t) {
+    e._finishPromise_reject !== undefined && (p(e._finishPromise), e._finishPromise_reject(t), e._finishPromise_resolve = undefined, e._finishPromise_reject = undefined);
+  }
+  function _o(e) {
+    return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`);
+  }
+  Object.defineProperties(TransformStreamDefaultController.prototype, { enqueue: { enumerable: true }, error: { enumerable: true }, terminate: { enumerable: true }, desiredSize: { enumerable: true } }), o(TransformStreamDefaultController.prototype.enqueue, "enqueue"), o(TransformStreamDefaultController.prototype.error, "error"), o(TransformStreamDefaultController.prototype.terminate, "terminate"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(TransformStreamDefaultController.prototype, Symbol.toStringTag, { value: "TransformStreamDefaultController", configurable: true });
+// streams-entry.js
+  if (globalThis.ByteLengthQueuingStrategy == null)
+    globalThis.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
+  if (globalThis.CountQueuingStrategy == null)
+    globalThis.CountQueuingStrategy = CountQueuingStrategy;
+  if (globalThis.ReadableByteStreamController == null)
+    globalThis.ReadableByteStreamController = ReadableByteStreamController;
+  if (globalThis.ReadableStream == null)
+    globalThis.ReadableStream = ReadableStream;
+  if (globalThis.ReadableStreamBYOBReader == null)
+    globalThis.ReadableStreamBYOBReader = ReadableStreamBYOBReader;
+  if (globalThis.ReadableStreamBYOBRequest == null)
+    globalThis.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;
+  if (globalThis.ReadableStreamDefaultController == null)
+    globalThis.ReadableStreamDefaultController = ReadableStreamDefaultController;
+  if (globalThis.ReadableStreamDefaultReader == null)
+    globalThis.ReadableStreamDefaultReader = ReadableStreamDefaultReader;
+  if (globalThis.TransformStream == null)
+    globalThis.TransformStream = TransformStream;
+  if (globalThis.TransformStreamDefaultController == null)
+    globalThis.TransformStreamDefaultController = TransformStreamDefaultController;
+  if (globalThis.WritableStream == null)
+    globalThis.WritableStream = WritableStream;
+  if (globalThis.WritableStreamDefaultController == null)
+    globalThis.WritableStreamDefaultController = WritableStreamDefaultController;
+  if (globalThis.WritableStreamDefaultWriter == null)
+    globalThis.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
+
+/* oxlint-enable */
+// END WEB STREAMS
+
+// Porffor exposes native timers lexically. Libraries also access them through
+// globalThis, including noble hashes 2.4's host-task yields.
+if (globalThis.setTimeout == null) globalThis.setTimeout = setTimeout;
+if (globalThis.clearTimeout == null) globalThis.clearTimeout = clearTimeout;
+if (globalThis.setInterval == null) globalThis.setInterval = setInterval;
+if (globalThis.clearInterval == null) globalThis.clearInterval = clearInterval;
+
 // Prepended to every handler by tools/compile.ts, before Porffor's native-fetch
 // bundled handler. Porffor's runtime/fetch-globals.js (checked through alpha-10)
 // gives URL (href/origin/pathname/search only) and Response without static
@@ -111,8 +2425,38 @@ function __sbCollectionIterator(owner, kind, formData) {
 
 class __SproutboatURLSearchParams {
   constructor(init) {
+    this._url = null;
+    this._reset(init);
+  }
+  // A URL's searchParams writes back into it (_url), and is re-read when the URL's
+  // search is assigned (_reset).
+  _reset(init) {
     this._keys = [];
     this._vals = [];
+    // The URLSearchParams init forms: another URLSearchParams, a sequence of [name, value]
+    // pairs, a record of own string keys, or a query string. Only strings were read, so
+    // new URLSearchParams({ a: "1" }) serialized as "%5Bobject+Object%5D=" (W2).
+    if (init instanceof __SproutboatURLSearchParams) {
+      this._keys = init._keys.slice();
+      this._vals = init._vals.slice();
+      return;
+    }
+    if (init != null && Object(init) === init) {
+      if (__sbIsFn(init[Symbol.iterator])) {
+        for (const pair of init) {
+          const items = Array.from(pair);
+          if (items.length !== 2) throw new TypeError("URLSearchParams: each pair must have exactly two items");
+          this._keys.push(String(items[0]));
+          this._vals.push(String(items[1]));
+        }
+        return;
+      }
+      for (const key of Object.keys(init)) {
+        this._keys.push(key);
+        this._vals.push(String(init[key]));
+      }
+      return;
+    }
     let raw = init == null ? "" : String(init);
     if (raw.charCodeAt(0) === 63) raw = raw.slice(1); // strip a leading '?'
     if (raw.length === 0) return;
@@ -127,6 +2471,11 @@ class __SproutboatURLSearchParams {
       this._vals.push(decodeURIComponent(v.split("+").join(" ")));
     }
   }
+  _update() {
+    if (this._url == null) return;
+    const s = this.toString();
+    this._url._query = s === "" ? null : s;
+  }
   get(name) {
     for (let i = 0; i < this._keys.length; i++) if (this._keys[i] === name) return this._vals[i];
     return null;
@@ -143,12 +2492,10 @@ class __SproutboatURLSearchParams {
   forEach(cb) {
     for (let i = 0; i < this._keys.length; i++) cb(this._vals[i], this._keys[i], this);
   }
-  // Mutators: standalone `new URLSearchParams()` building works. They do NOT
-  // write back into a URL's `search` (Porffor's URL has no setter) — build the
-  // string with toString() and assign it yourself.
   append(name, value) {
     this._keys.push(String(name));
     this._vals.push(String(value));
+    this._update();
   }
   set(name, value) {
     let found = false;
@@ -163,7 +2510,11 @@ class __SproutboatURLSearchParams {
         found = true;
       }
     }
-    if (!found) this.append(name, value);
+    if (!found) {
+      this._keys.push(String(name));
+      this._vals.push(String(value));
+    }
+    this._update();
   }
   delete(name) {
     for (let i = 0; i < this._keys.length; i++)
@@ -172,13 +2523,15 @@ class __SproutboatURLSearchParams {
         this._vals.splice(i, 1);
         i--;
       }
+    this._update();
   }
   sort() {
     const idx = this._keys
       .map((_, i) => i)
-      .sort((a, b) => (this._keys[a] < this._keys[b] ? -1 : this._keys[a] > this._keys[b] ? 1 : 0));
+      .sort((a, b) => (this._keys[a] < this._keys[b] ? -1 : this._keys[a] > this._keys[b] ? 1 : a - b));
     this._keys = idx.map((i) => this._keys[i]);
     this._vals = idx.map((i) => this._vals[i]);
+    this._update();
   }
   keys() {
     return __sbCollectionIterator(this, 0, false);
@@ -193,15 +2546,34 @@ class __SproutboatURLSearchParams {
   get size() {
     return this._keys.length;
   }
+  // application/x-www-form-urlencoded: space is "+", and ! ' ( ) ~ are escaped too.
   toString() {
     let out = "";
     for (let i = 0; i < this._keys.length; i++) {
       if (i > 0) out += "&";
-      out += encodeURIComponent(this._keys[i]) + "=" + encodeURIComponent(this._vals[i]);
+      out += __sbFormEncode(this._keys[i]) + "=" + __sbFormEncode(this._vals[i]);
     }
     return out;
   }
 }
+// One pass over encodeURIComponent's output (chained split/join doubled compile time).
+function __sbFormEncode(s) {
+  const e = encodeURIComponent(s);
+  let out = "";
+  for (let i = 0; i < e.length; i++) {
+    const c = e.charCodeAt(i);
+    if (c === 33) out += "%21";
+    else if (c === 39) out += "%27";
+    else if (c === 40) out += "%28";
+    else if (c === 41) out += "%29";
+    else if (c === 126) out += "%7E";
+    else if (c === 37 && e.charCodeAt(i + 1) === 50 && e.charCodeAt(i + 2) === 48) {
+      out += "+";
+      i += 2;
+    } else out += e[i];
+  }
+  return out;
+}
 
 // URL and Response are always defined by Porffor's fetch-globals.js banner.
 if (globalThis.URLSearchParams == null) globalThis.URLSearchParams = __SproutboatURLSearchParams;
@@ -218,19 +2590,39 @@ if (!("searchParams" in URL.prototype)) {
 
 if (Response.json == null) {
   Response.json = function (data, init) {
-    const response = new Response(JSON.stringify(data), init);
-    if (!response.headers.has("content-type")) response.headers.set("content-type", "application/json;charset=utf-8");
-    return response;
+    // Typed before construction: a string body would otherwise default to text/plain.
+    const headers = new Headers(init?.headers);
+    if (!headers.has("content-type")) headers.set("content-type", "application/json");
+    return new Response(JSON.stringify(data), { status: init?.status ?? 200, statusText: init?.statusText, headers });
   };
 }
 
+// Error.stack: Porffor keeps no frames, so give V8's first line, "Name: message", rather
+// than undefined (code logs it or splits it on newlines).
+for (const E of [Error, TypeError, RangeError, ReferenceError, SyntaxError, EvalError, URIError]) {
+  if (!("stack" in E.prototype)) {
+    Object.defineProperty(E.prototype, "stack", {
+      configurable: true,
+      get() {
+        const message = String(this.message);
+        return message === "" ? String(this.name) : String(this.name) + ": " + message;
+      },
+    });
+  }
+}
+
+// Fetch: Headers iterates like entries(), so new Map(headers), [...headers] and
+// Object.fromEntries(headers) work. Porffor's Headers has entries() but no iterator.
+if (Headers.prototype[Symbol.iterator] == null) Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+
 // Porffor alpha-10 has no static Response.redirect().
 if (Response.redirect == null) {
   Response.redirect = function (url, status = 302) {
     if (status !== 301 && status !== 302 && status !== 303 && status !== 307 && status !== 308) {
       throw new RangeError("invalid redirect status");
     }
-    return new Response("", { status, headers: { location: String(url) } });
+    // Serialized like the URL parser does (a bare origin gains its "/"); invalid URLs throw.
+    return new Response(null, { status, headers: { location: new URL(String(url)).href } });
   };
 }
 
@@ -302,11 +2694,21 @@ if (globalThis.FormData == null) {
     constructor() {
       this._entries = [];
     }
+    // A Blob value is stored as a File named by filename ("blob" by default); anything
+    // else as a string, as the FormData spec's entry list does.
+    static _entryValue(value, filename) {
+      if (value instanceof Blob) {
+        if (filename === undefined && value instanceof File) return value;
+        return new File([value], filename === undefined ? "blob" : String(filename), { type: value.type });
+      }
+      return String(value);
+    }
     append(name, value, filename) {
-      this._entries.push([String(name), value, filename]);
+      this._entries.push([String(name), __SproutboatFormData._entryValue(value, filename), filename]);
     }
     set(name, value, filename) {
       name = String(name);
+      value = __SproutboatFormData._entryValue(value, filename);
       let replaced = false;
       this._entries = this._entries.filter((e) => {
         if (e[0] !== name) return true;
@@ -462,7 +2864,12 @@ if (globalThis.crypto.getRandomValues == null) {
   globalThis.crypto.getRandomValues = function (view) {
     const n = view.length >>> 0;
     // WebCrypto caps a single call at 65536 bytes.
-    if (n > 65536) throw new RangeError("crypto.getRandomValues: byte length exceeds 65536");
+    if (n > 65536) {
+      // WebCrypto's error for an oversized request (a DOMException named QuotaExceededError).
+      const e = new Error("crypto.getRandomValues: byte length exceeds 65536");
+      e.name = "QuotaExceededError";
+      throw e;
+    }
     if (n === 0) return view;
     // One CSPRNG byte per element. Correct for Uint8Array (and randomUUID); a
     // wider view gets its low byte filled, matching the previous polyfill's shape.
@@ -472,17 +2879,282 @@ if (globalThis.crypto.getRandomValues == null) {
     return view;
   };
 }
-// structuredClone: JSON round-trip. Lossy (no Map/Set/Date/typed arrays), but
-// covers the common "deep-copy a plain object" case Worker code relies on.
+// queueMicrotask, and atob/btoa input checks as the HTML spec has them: atob drops ASCII
+// whitespace and rejects anything that is not base64, btoa rejects characters above
+// U+00FF. Both threw nothing and returned garbage before (W2 conformance).
+{
+  const invalidCharacter = (message) => {
+    const e = new Error(message);
+    e.name = "InvalidCharacterError";
+    return e;
+  };
+  if (globalThis.queueMicrotask == null) {
+    globalThis.queueMicrotask = function (callback) {
+      if (!__sbIsFn(callback)) throw new TypeError("queueMicrotask needs a function");
+      Promise.resolve().then(() => callback());
+    };
+  }
+  const nativeAtob = globalThis.atob, nativeBtoa = globalThis.btoa;
+  globalThis.atob = function (data) {
+    let text = String(data).replace(/[\t\n\f\r ]/g, "");
+    if (text.length % 4 === 0) text = text.replace(/==?$/, "");
+    if (text.length % 4 === 1 || !/^[A-Za-z0-9+/]*$/.test(text)) throw invalidCharacter("atob: the string is not valid base64");
+    while (text.length % 4 !== 0) text += "=";
+    return nativeAtob(text);
+  };
+  globalThis.btoa = function (data) {
+    const text = String(data);
+    for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) > 0xff) throw invalidCharacter("btoa: the string has characters outside Latin-1");
+    return nativeBtoa(text);
+  };
+}
+
+/* oxlint-disable anti-slop/no-runtime-typeof -- these Web API polyfills branch on JavaScript types
+   exactly where their specs do (listener: function or { handleEvent }; structured clone: by value type). */
+// Event, CustomEvent, EventTarget, AbortSignal and AbortController, as workerd has
+// them (no DOM tree, so no bubbling or capture phases). Found missing by the W2
+// conformance suite; libraries use AbortController for fetch timeouts and EventTarget
+// for their own events.
+if (typeof globalThis.EventTarget !== "function") {
+  const namedError = (name, message) => {
+    const e = new Error(message);
+    e.name = name;
+    return e;
+  };
+  class Event {
+    constructor(type, init) {
+      if (arguments.length === 0) throw new TypeError("Event requires a type");
+      const options = init || {};
+      this.type = String(type);
+      this.bubbles = !!options.bubbles;
+      this.cancelable = !!options.cancelable;
+      this.composed = !!options.composed;
+      this.defaultPrevented = false;
+      this.target = null;
+      this.currentTarget = null;
+      this.eventPhase = 0;
+      this.isTrusted = false;
+      this.timeStamp = Date.now();
+      this.__sbStopped = false;
+    }
+    preventDefault() { if (this.cancelable) this.defaultPrevented = true; }
+    stopPropagation() {}
+    stopImmediatePropagation() { this.__sbStopped = true; }
+    composedPath() { return this.currentTarget ? [this.currentTarget] : []; }
+  }
+  class CustomEvent extends Event {
+    constructor(type, init) {
+      super(type, init);
+      this.detail = init && init.detail !== undefined ? init.detail : null;
+    }
+  }
+  class EventTarget {
+    constructor() { this.__sbListeners = {}; }
+    addEventListener(type, listener, options) {
+      if (listener == null) return;
+      const capture = typeof options === "boolean" ? options : !!(options && options.capture);
+      const once = !!(options && typeof options === "object" && options.once);
+      const signal = options && typeof options === "object" ? options.signal : undefined;
+      if (signal && signal.aborted) return;
+      const list = this.__sbListeners[type] || (this.__sbListeners[type] = []);
+      for (const entry of list) if (entry.listener === listener && entry.capture === capture) return;
+      const entry = { listener, capture, once, removed: false };
+      list.push(entry);
+      if (signal) signal.addEventListener("abort", () => this.removeEventListener(type, listener, capture));
+    }
+    removeEventListener(type, listener, options) {
+      const capture = typeof options === "boolean" ? options : !!(options && options.capture);
+      const list = this.__sbListeners[type];
+      if (!list) return;
+      for (let i = 0; i < list.length; i++) {
+        if (list[i].listener === listener && list[i].capture === capture) {
+          list[i].removed = true;
+          list.splice(i, 1);
+          return;
+        }
+      }
+    }
+    dispatchEvent(event) {
+      if (!(event instanceof Event)) throw new TypeError("dispatchEvent needs an Event");
+      event.target = this;
+      event.currentTarget = this;
+      event.eventPhase = 2;
+      const list = (this.__sbListeners[event.type] || []).slice();
+      for (const entry of list) {
+        if (entry.removed) continue;
+        if (entry.once) this.removeEventListener(event.type, entry.listener, entry.capture);
+        const fn = entry.listener;
+        if (typeof fn === "function") fn.call(this, event);
+        else if (fn && typeof fn.handleEvent === "function") fn.handleEvent(event);
+        if (event.__sbStopped) break;
+      }
+      event.currentTarget = null;
+      event.eventPhase = 0;
+      return !event.defaultPrevented;
+    }
+  }
+  class AbortSignal extends EventTarget {
+    constructor() {
+      super();
+      this.aborted = false;
+      this.reason = undefined;
+      this.onabort = null;
+    }
+    throwIfAborted() { if (this.aborted) throw this.reason; }
+    __sbAbort(reason) {
+      if (this.aborted) return;
+      this.aborted = true;
+      this.reason = reason === undefined ? namedError("AbortError", "This operation was aborted") : reason;
+      const event = new Event("abort");
+      if (typeof this.onabort === "function") this.onabort.call(this, event);
+      this.dispatchEvent(event);
+    }
+    static abort(reason) {
+      const signal = new AbortSignal();
+      signal.__sbAbort(reason);
+      return signal;
+    }
+    static timeout(ms) {
+      const signal = new AbortSignal();
+      setTimeout(() => signal.__sbAbort(namedError("TimeoutError", "The operation timed out")), ms);
+      return signal;
+    }
+    static any(signals) {
+      const signal = new AbortSignal();
+      for (const s of signals) {
+        if (s.aborted) {
+          signal.__sbAbort(s.reason);
+          return signal;
+        }
+      }
+      for (const s of signals) s.addEventListener("abort", () => signal.__sbAbort(s.reason));
+      return signal;
+    }
+  }
+  class AbortController {
+    constructor() { this.signal = new AbortSignal(); }
+    abort(reason) { this.signal.__sbAbort(reason); }
+  }
+  globalThis.Event = Event;
+  globalThis.CustomEvent = CustomEvent;
+  globalThis.EventTarget = EventTarget;
+  globalThis.AbortSignal = AbortSignal;
+  globalThis.AbortController = AbortController;
+}
+
+// TextEncoderStream and TextDecoderStream over the Web Streams ponyfill (W2 conformance).
+// The encoder holds back a lone high surrogate at the end of a chunk until the next one;
+// the decoder is TextDecoder in streaming mode, so a character split across chunks decodes.
+if (globalThis.TextEncoderStream == null) {
+  class TextEncoderStream {
+    constructor() {
+      const encoder = new TextEncoder();
+      let pending = "";
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          let text = pending + String(chunk);
+          pending = "";
+          const last = text.charCodeAt(text.length - 1);
+          if (last >= 0xd800 && last <= 0xdbff) {
+            pending = text.slice(-1);
+            text = text.slice(0, -1);
+          }
+          if (text.length > 0) controller.enqueue(encoder.encode(text));
+        },
+        flush(controller) {
+          if (pending.length > 0) controller.enqueue(encoder.encode(pending));
+        },
+      });
+      this.readable = transform.readable;
+      this.writable = transform.writable;
+    }
+    get encoding() {
+      return "utf-8";
+    }
+  }
+  class TextDecoderStream {
+    constructor(label = "utf-8", options = undefined) {
+      const decoder = new TextDecoder(label, options);
+      this.encoding = decoder.encoding;
+      this.fatal = decoder.fatal;
+      this.ignoreBOM = decoder.ignoreBOM;
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const text = decoder.decode(chunk, { stream: true });
+          if (text.length > 0) controller.enqueue(text);
+        },
+        flush(controller) {
+          const text = decoder.decode();
+          if (text.length > 0) controller.enqueue(text);
+        },
+      });
+      this.readable = transform.readable;
+      this.writable = transform.writable;
+    }
+  }
+  globalThis.TextEncoderStream = TextEncoderStream;
+  globalThis.TextDecoderStream = TextDecoderStream;
+}
+
+// structuredClone: the HTML structured-clone algorithm for the types Worker code
+// passes around. Keeps cycles and shared references (a memo per call), Date, RegExp,
+// Map, Set, ArrayBuffer, typed arrays, DataView, errors, arrays and plain objects;
+// functions and symbols throw DataCloneError. It replaced a JSON round-trip that lost
+// every non-JSON type and crashed on cycles (W2 conformance).
 if (globalThis.structuredClone == null) {
-  // The suggested fix (use structuredClone) is circular — this IS the polyfill,
-  // and Porffor exposes no other deep-clone primitive.
-  // react-doctor-disable-next-line react-doctor/no-json-parse-stringify-clone
+  const dataCloneError = (what) => {
+    const e = new Error(what + " could not be cloned");
+    e.name = "DataCloneError";
+    return e;
+  };
+  const errorTypes = { Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError };
+  const clone = (value, memo) => {
+    const type = typeof value;
+    if (type === "function") throw dataCloneError("function");
+    if (type === "symbol") throw dataCloneError("Symbol");
+    if (value === null || type !== "object") return value;
+    if (memo.has(value)) return memo.get(value);
+    let out;
+    if (value instanceof Date) out = new Date(value.getTime());
+    else if (value instanceof RegExp) out = new RegExp(value.source, value.flags);
+    else if (value instanceof ArrayBuffer) out = value.slice(0);
+    else if (ArrayBuffer.isView(value)) {
+      const buffer = clone(value.buffer, memo);
+      out = value instanceof DataView ? new DataView(buffer, value.byteOffset, value.byteLength) : new value.constructor(buffer, value.byteOffset, value.length);
+    } else if (value instanceof Map) {
+      out = new Map();
+      memo.set(value, out);
+      for (const [k, v] of value) out.set(clone(k, memo), clone(v, memo));
+      return out;
+    } else if (value instanceof Set) {
+      out = new Set();
+      memo.set(value, out);
+      for (const v of value) out.add(clone(v, memo));
+      return out;
+    } else if (value instanceof Error) {
+      const Ctor = errorTypes[value.name] || Error;
+      out = new Ctor(value.message);
+    } else if (Array.isArray(value)) {
+      out = new Array(value.length);
+      memo.set(value, out);
+      for (const k of Object.keys(value)) out[k] = clone(value[k], memo);
+      return out;
+    } else {
+      out = {};
+      memo.set(value, out);
+      for (const k of Object.keys(value)) out[k] = clone(value[k], memo);
+      return out;
+    }
+    memo.set(value, out);
+    return out;
+  };
   globalThis.structuredClone = function (value) {
-    return JSON.parse(JSON.stringify(value));
+    return clone(value, new Map());
   };
 }
 
+/* oxlint-enable anti-slop/no-runtime-typeof */
+
 if (globalThis.crypto.randomUUID == null) {
   globalThis.crypto.randomUUID = function () {
     const b = new Uint8Array(16);
@@ -503,6 +3175,8 @@ if (globalThis.crypto.randomUUID == null) {
 // dependency, so it works on the broker transport too.
 function __sbHashBits(algo) {
   const n = String((algo && algo.name) || algo || "").toUpperCase();
+  if (n === "SHA-1" || n === "SHA1") return "1";
+  if (n === "MD5") return "5";
   if (n === "SHA-256" || n === "SHA256") return "256";
   if (n === "SHA-384" || n === "SHA384") return "384";
   if (n === "SHA-512" || n === "SHA512") return "512";
@@ -729,42 +3403,77 @@ function __sbHexOrBytes(value) {
   return __sbToBytes(value);
 }
 
+// Errors as WebCrypto names them (DOMException names; plain Errors here).
+function __sbCryptoError(name, message) {
+  const e = new Error(message);
+  e.name = name;
+  return e;
+}
+// An HMAC key as importKey and generateKey return it. MD5 is digest-only, as in workerd.
+function __sbHmacKey(bytes, bits, extractable, usages) {
+  const hash = bits === "1" ? "SHA-1" : "SHA-" + bits;
+  return {
+    type: "secret",
+    extractable: !!extractable,
+    algorithm: { name: "HMAC", hash: { name: hash }, length: bytes.length * 8 },
+    usages: usages || [],
+    __sbKey: bytes,
+    __sbBits: bits,
+  };
+}
+function __sbHmacBits(algo) {
+  const bits = __sbHashBits((algo && algo.hash) || "SHA-256");
+  if (!bits || bits === "5") throw __sbCryptoError("NotSupportedError", "HMAC needs SHA-1, SHA-256, SHA-384 or SHA-512");
+  return bits;
+}
 if (globalThis.crypto.subtle == null) {
   globalThis.crypto.subtle = {
     async digest(algo, data) {
       const bits = __sbHashBits(algo);
-      if (!bits) throw new Error("crypto.subtle.digest: unsupported algorithm");
+      if (!bits) throw __sbCryptoError("NotSupportedError", "crypto.subtle.digest: unsupported algorithm");
       const out = __sbDigestRaw(bits, __sbToBytes(data));
       if (!out) throw new Error("crypto.subtle.digest failed");
       return __sbBufFrom(out);
     },
     async importKey(format, keyData, algo, extractable, usages) {
-      if (format !== "raw") throw new Error("crypto.subtle.importKey: only format 'raw' is supported");
+      if (format !== "raw") throw __sbCryptoError("NotSupportedError", "crypto.subtle.importKey: only format 'raw' is supported");
       const name = String((algo && algo.name) || algo || "").toUpperCase();
-      if (name !== "HMAC") throw new Error("crypto.subtle.importKey: only HMAC keys are supported");
-      const bits = __sbHashBits((algo && algo.hash) || "SHA-256");
-      if (!bits) throw new Error("crypto.subtle.importKey: unsupported hash");
-      return {
-        type: "secret",
-        extractable: !!extractable,
-        algorithm: { name: "HMAC", hash: { name: "SHA-" + bits } },
-        usages: usages || [],
-        __sbKey: __sbToBytes(keyData),
-        __sbBits: bits,
-      };
+      if (name !== "HMAC") throw __sbCryptoError("NotSupportedError", "crypto.subtle.importKey: only HMAC keys are supported");
+      return __sbHmacKey(__sbToBytes(keyData), __sbHmacBits(algo), extractable, usages);
+    },
+    async exportKey(format, key) {
+      if (!key || key.__sbKey == null) throw new TypeError("crypto.subtle.exportKey: not a key from this runtime");
+      if (format !== "raw") throw __sbCryptoError("NotSupportedError", "crypto.subtle.exportKey: only format 'raw' is supported");
+      if (!key.extractable) throw __sbCryptoError("InvalidAccessError", "crypto.subtle.exportKey: the key is not extractable");
+      return __sbBufFrom(key.__sbKey);
+    },
+    async generateKey(algo, extractable, usages) {
+      const name = String((algo && algo.name) || algo || "").toUpperCase();
+      if (name !== "HMAC") throw __sbCryptoError("NotSupportedError", "crypto.subtle.generateKey: only HMAC keys are supported");
+      const bits = __sbHmacBits(algo);
+      // The default length is the hash's block size: 512 bits, or 1024 for SHA-384/512.
+      const length = (algo && algo.length) || (bits === "384" || bits === "512" ? 1024 : 512);
+      const bytes = __sbRandomBytes(String(Math.ceil(length / 8)));
+      return __sbHmacKey(bytes, bits, extractable, usages);
     },
     async sign(algo, key, data) {
-      if (!key || key.__sbKey == null) throw new Error("crypto.subtle.sign: only HMAC keys from importKey are supported");
+      if (!key || key.__sbKey == null) throw __sbCryptoError("InvalidAccessError", "crypto.subtle.sign: only HMAC keys are supported");
       const out = __sbHmacRaw(key.__sbBits, key.__sbKey, __sbToBytes(data));
       if (!out) throw new Error("crypto.subtle.sign failed");
       return __sbBufFrom(out);
     },
     async verify(algo, key, signature, data) {
-      if (!key || key.__sbKey == null) throw new Error("crypto.subtle.verify: only HMAC keys are supported");
+      if (!key || key.__sbKey == null) throw __sbCryptoError("InvalidAccessError", "crypto.subtle.verify: only HMAC keys are supported");
       const mac = __sbHmacRaw(key.__sbBits, key.__sbKey, __sbToBytes(data));
       if (!mac) return false;
       return __sbEqCt(mac, __sbToBytes(signature));
     },
+    // workerd's extension: constant-time comparison of two equal-length buffers.
+    timingSafeEqual(a, b) {
+      const x = __sbToBytes(a), y = __sbToBytes(b);
+      if (x.length !== y.length) throw new TypeError("crypto.subtle.timingSafeEqual: the buffers differ in length");
+      return __sbEqCt(x, y);
+    },
   };
 }
 
@@ -967,9 +3676,82 @@ static void sb_sha512_final(sb_sha512_ctx* c, unsigned char* out, int is384) {
     for (int j = 0; j < 8; j++) out[i*8+j] = (unsigned char)(c->h[i] >> (56 - j*8));
 }
 
-// One-shot digest. algo: 256 | 384 | 512. out must hold 32/48/64 bytes.
+// SHA-1 and MD5 (W2: workerd's digest has both; HMAC also takes SHA-1). One-shot over a
+// padded copy: inputs are request-sized, not streams.
+static uint32_t sb_rol32(uint32_t x, int n) { return (x << n) | (x >> (32 - n)); }
+static unsigned char* sb_md_pad(const unsigned char* msg, size_t len, size_t* total, int big_endian) {
+  *total = ((len + 8) / 64 + 1) * 64;
+  unsigned char* m = (unsigned char*)calloc(*total, 1);
+  if (!m) return 0;
+  memcpy(m, msg, len); m[len] = 0x80;
+  uint64_t bits = (uint64_t)len * 8;
+  for (int i = 0; i < 8; i++) m[big_endian ? *total - 1 - i : *total - 8 + i] = (unsigned char)(bits >> (8 * i));
+  return m;
+}
+static size_t sb_sha1(const unsigned char* msg, size_t len, unsigned char out[20]) {
+  size_t total; unsigned char* m = sb_md_pad(msg, len, &total, 1);
+  if (!m) return 0;
+  uint32_t h[5] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
+  for (size_t off = 0; off < total; off += 64) {
+    uint32_t w[80];
+    for (int i = 0; i < 16; i++) w[i] = ((uint32_t)m[off + 4*i] << 24) | ((uint32_t)m[off + 4*i + 1] << 16) | ((uint32_t)m[off + 4*i + 2] << 8) | m[off + 4*i + 3];
+    for (int i = 16; i < 80; i++) w[i] = sb_rol32(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16], 1);
+    uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4];
+    for (int i = 0; i < 80; i++) {
+      uint32_t f, k;
+      if (i < 20) { f = (b & c) | (~b & d); k = 0x5A827999; }
+      else if (i < 40) { f = b ^ c ^ d; k = 0x6ED9EBA1; }
+      else if (i < 60) { f = (b & c) | (b & d) | (c & d); k = 0x8F1BBCDC; }
+      else { f = b ^ c ^ d; k = 0xCA62C1D6; }
+      uint32_t t = sb_rol32(a, 5) + f + e + k + w[i];
+      e = d; d = c; c = sb_rol32(b, 30); b = a; a = t;
+    }
+    h[0] += a; h[1] += b; h[2] += c; h[3] += d; h[4] += e;
+  }
+  free(m);
+  for (int i = 0; i < 5; i++) { out[4*i] = h[i] >> 24; out[4*i+1] = h[i] >> 16; out[4*i+2] = h[i] >> 8; out[4*i+3] = h[i]; }
+  return 20;
+}
+static size_t sb_md5(const unsigned char* msg, size_t len, unsigned char out[16]) {
+  static const uint32_t K[64] = {
+    0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+    0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
+    0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+    0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
+    0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+    0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
+    0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+    0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 };
+  static const int S[16] = { 7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21 };
+  size_t total; unsigned char* m = sb_md_pad(msg, len, &total, 0);
+  if (!m) return 0;
+  uint32_t h[4] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 };
+  for (size_t off = 0; off < total; off += 64) {
+    uint32_t w[16];
+    for (int i = 0; i < 16; i++) w[i] = (uint32_t)m[off + 4*i] | ((uint32_t)m[off + 4*i + 1] << 8) | ((uint32_t)m[off + 4*i + 2] << 16) | ((uint32_t)m[off + 4*i + 3] << 24);
+    uint32_t a = h[0], b = h[1], c = h[2], d = h[3];
+    for (int i = 0; i < 64; i++) {
+      uint32_t f; int g;
+      if (i < 16) { f = (b & c) | (~b & d); g = i; }
+      else if (i < 32) { f = (d & b) | (~d & c); g = (5*i + 1) % 16; }
+      else if (i < 48) { f = b ^ c ^ d; g = (3*i + 5) % 16; }
+      else { f = c ^ (b | ~d); g = (7*i) % 16; }
+      f = f + a + K[i] + w[g];
+      a = d; d = c; c = b;
+      b = b + sb_rol32(f, S[(i / 16) * 4 + i % 4]);
+    }
+    h[0] += a; h[1] += b; h[2] += c; h[3] += d;
+  }
+  free(m);
+  for (int i = 0; i < 4; i++) { out[4*i] = h[i]; out[4*i+1] = h[i] >> 8; out[4*i+2] = h[i] >> 16; out[4*i+3] = h[i] >> 24; }
+  return 16;
+}
+
+// One-shot digest. algo: 1 (SHA-1) | 5 (MD5) | 256 | 384 | 512. out must hold up to 64 bytes.
 // Returns the digest length, or 0 for an unknown algo.
 static size_t sb_digest(int algo, const unsigned char* msg, size_t mlen, unsigned char* out) {
+  if (algo == 1) return sb_sha1(msg, mlen, out);
+  if (algo == 5) return sb_md5(msg, mlen, out);
   if (algo == 256) { sb_sha256_ctx c; sb_sha256_init(&c); sb_sha256_update(&c, msg, mlen); sb_sha256_final(&c, out); return 32; }
   if (algo == 384) { sb_sha512_ctx c; sb_sha512_init(&c, 1); sb_sha512_update(&c, msg, mlen); sb_sha512_final(&c, out, 1); return 48; }
   if (algo == 512) { sb_sha512_ctx c; sb_sha512_init(&c, 0); sb_sha512_update(&c, msg, mlen); sb_sha512_final(&c, out, 0); return 64; }
@@ -979,6 +3761,20 @@ static size_t sb_digest(int algo, const unsigned char* msg, size_t mlen, unsigne
 // HMAC(algo) per RFC 2104. Block size is 64 for SHA-256, 128 for SHA-384/512.
 static size_t sb_hmac(int algo, const unsigned char* key, size_t klen,
                       const unsigned char* msg, size_t mlen, unsigned char* out) {
+  if (algo == 1) {
+    // HMAC-SHA-1: block 64, over padded copies like the one-shot digest.
+    unsigned char k1[64], inner1[20];
+    memset(k1, 0, sizeof(k1));
+    if (klen > 64) sb_sha1(key, klen, k1); else memcpy(k1, key, klen);
+    unsigned char* buf = (unsigned char*)malloc(64 + (mlen > 20 ? mlen : 20));
+    if (!buf) return 0;
+    for (int i = 0; i < 64; i++) buf[i] = k1[i] ^ 0x36;
+    memcpy(buf + 64, msg, mlen); sb_sha1(buf, 64 + mlen, inner1);
+    for (int i = 0; i < 64; i++) buf[i] = k1[i] ^ 0x5c;
+    memcpy(buf + 64, inner1, 20); sb_sha1(buf, 84, out);
+    free(buf);
+    return 20;
+  }
   size_t bs = algo == 256 ? 64 : 128;
   unsigned char k[128], ipad[128], opad[128], inner[64];
   memset(k, 0, sizeof(k));
@@ -1388,6 +4184,64 @@ function __sbR2Multipart(bucket, key, uploadId) {
   };
 }
 
+// Asset rules use the same parsed manifest in both transports. Matching mirrors
+// @sproutboat/assets; parity tests cover the portable native implementation.
+function __sbAssetRedirect(rule, path) {
+  const star = rule.from.indexOf("*");
+  if (star !== -1) {
+    const prefix = rule.from.slice(0, star);
+    if (!path.startsWith(prefix)) return null;
+    return rule.to.split(":splat").join(path.slice(prefix.length));
+  }
+  const from = rule.from.split("/").filter(Boolean);
+  const parts = path.split("/").filter(Boolean);
+  if (from.length !== parts.length) return null;
+  const params = {};
+  for (let i = 0; i < from.length; i++) {
+    if (from[i].startsWith(":")) params[from[i].slice(1)] = parts[i];
+    else if (from[i] !== parts[i]) return null;
+  }
+  let to = rule.to;
+  for (const name in params) to = to.split(":" + name).join(params[name]);
+  return to;
+}
+
+function __sbAssetHeaderMatches(pattern, path) {
+  const from = pattern.split("/").filter(Boolean);
+  const parts = path.split("/").filter(Boolean);
+  for (let i = 0; i < from.length; i++) {
+    if (from[i] === "*") return true;
+    if (from[i] !== parts[i]) return false;
+  }
+  return from.length === parts.length;
+}
+
+function __sbAssetResponse(path, r) {
+  if (r.location != null) return new Response(null, { status: r.status, headers: { location: r.location } });
+  const rules = r.rules || {};
+  const redirects = rules.redirects || [];
+  for (let i = 0; i < redirects.length; i++) {
+    const to = __sbAssetRedirect(redirects[i], path);
+    if (to !== null) return new Response(null, { status: redirects[i].status, headers: { location: to } });
+  }
+  const headers = new Headers();
+  if (r.type) headers.set("content-type", r.type);
+  if (r.found) headers.set("etag", '"' + r.hash + '"');
+  // A custom 404 page is also an asset; a generated Not Found is not.
+  if (r.type) {
+    const list = rules.headers || [];
+    for (let i = 0; i < list.length; i++) {
+      const rule = list[i];
+      if (!__sbAssetHeaderMatches(rule.pattern, path)) continue;
+      for (let j = 0; j < rule.unset.length; j++) headers.delete(rule.unset[j]);
+      for (let j = 0; j < rule.set.length; j++) headers.set(rule.set[j][0], rule.set[j][1]);
+    }
+  }
+  // Apply the internal byte marker after user rules so they cannot remove it.
+  if (r.body != null) headers.set("x-sb-raw-body", "1");
+  return __sbRawBodyResponse(r.body, { status: r.status || (r.found ? 200 : 404), headers });
+}
+
 // Installed only when the project declares bindings. `env` is the module-scoped
 // object from compile.ts (a `const`, but mutable); we add the binding accessors
 // to it in place. compile.ts emits `__sbInstallBindings(env, {...})` right after
@@ -1611,16 +4465,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
         } catch {
           /* use as-is */
         }
-        const r = globalThis.__sbAssetsGet(path);
-        const headers = {};
-        if (r.type) headers["content-type"] = r.type;
-        if (r.found) headers["etag"] = '"' + r.hash + '"';
-        // #176: these bytes came off disk already-finished (UTF-8 text or
-        // binary, doesn't matter which) -- the reserved x-sb-raw-body header
-        // tells the C write path to pass them through untouched instead of
-        // re-encoding as if this were a JS string a handler built.
-        if (r.body != null) headers["x-sb-raw-body"] = "1";
-        return __sbRawBodyResponse(r.body, { status: r.status || (r.found ? 200 : 404), headers });
+        return __sbAssetResponse(path, globalThis.__sbAssetsGet(path));
       },
     };
   }
@@ -1665,26 +4510,48 @@ globalThis.__sbInstallBindings = function (target, bindings) {
 // prelude must not replace fetch just by being evaluated.
 globalThis.__sbInstallFetch = function () {
   globalThis.fetch = function (input, init) {
-    const url = __sbIsStr(input) ? input : String(input.url);
+    // A Request's method, headers and body apply unless init overrides them; a URL
+    // object stands for its href.
+    const req = input != null && !__sbIsStr(input) && input.url != null ? input : null;
+    const url = req ? String(req.url) : input != null && input.href != null ? String(input.href) : String(input);
     const opts = init || {};
+    const source = opts.headers != null ? opts.headers : req ? req.headers : null;
     const headers = [];
-    if (opts.headers) {
-      if (__sbIsFn(opts.headers.forEach)) opts.headers.forEach((v, k) => headers.push([k, v]));
-      else for (const k in opts.headers) headers.push([k, opts.headers[k]]);
-    }
-    const r = globalThis.__sbFetchUpstream("fetch", {
-      url,
-      method: opts.method || "GET",
-      headers,
-      ...__sbRequestBody(opts.body),
+    if (source) {
+      if (__sbIsFn(source.forEach)) source.forEach((v, k) => headers.push([k, v]));
+      else for (const k in source) headers.push([k, source[k]]);
+    }
+    const body = opts.body !== undefined ? opts.body : req && req.body !== "" ? req.body : null;
+    const method = opts.method || (req && req.method) || "GET";
+    const msg = { url, method, headers, ...__sbRequestBody(body) };
+    const respond = (r) => {
+      const respHeaders = new Headers();
+      for (let j = 0; j < (r.headers || []).length; j++) respHeaders.set(r.headers[j][0], r.headers[j][1]);
+      // #176: bytes from an outbound HTTP response, not a string this handler
+      // built -- must not be re-encoded if the handler proxies it straight
+      // through (see the assets binding for the same reasoning).
+      if (r.body != null) respHeaders.set("x-sb-raw-body", "1");
+      return __sbRawBodyResponse(r.body, { status: r.status || 502, headers: respHeaders });
+    };
+    if (!__sbHttpAsyncEnabled()) return respond(globalThis.__sbFetchUpstream("fetch", msg));
+    // B18: the host runs the request off the event loop. Its reply fires a timer
+    // that never fires on its own; the timer table keeps the callback alive.
+    return new Promise((resolve, reject) => {
+      const id = setTimeout(() => {
+        try {
+          resolve(respond(__sbFetchReply(__sbHttpAsyncResult(id))));
+        } catch (e) {
+          reject(new Error("sproutboat fetch: " + ((e && e.message) || e)));
+        }
+      }, 2147483647);
+      try {
+        msg.asyncId = id;
+        globalThis.__sbFetchUpstream("fetch", msg);
+      } catch (e) {
+        clearTimeout(id);
+        reject(e);
+      }
     });
-    const respHeaders = new Headers();
-    for (let j = 0; j < (r.headers || []).length; j++) respHeaders.set(r.headers[j][0], r.headers[j][1]);
-    // #176: bytes from an outbound HTTP response, not a string this handler
-    // built -- must not be re-encoded if the handler proxies it straight
-    // through (see the assets binding for the same reasoning).
-    if (r.body != null) respHeaders.set("x-sb-raw-body", "1");
-    return __sbRawBodyResponse(r.body, { status: r.status || 502, headers: respHeaders });
   };
 };
 
@@ -1743,7 +4610,7 @@ function __sbMakeDONamespace(binding, className) {
           }
           const inst = __sbGetDOInstance(className, idStr);
           const res = inst.fetch(req);
-          if (inst.__sbTasks.length || (res && __sbIsFn(res.then))) return __sbFetchWithDrain(res, inst.__sbTasks);
+          if (inst.__sbTasks.length || (res && __sbIsFn(res.then)) || __sbHasStreamBody(res)) return __sbFetchWithDrain(res, inst.__sbTasks);
           return res;
         },
       };
@@ -2026,14 +4893,17 @@ function __sbTrustedProxyHeader(request, name) {
 // own.
 const __SB_WAITUNTIL_TIMEOUT_MS = 25000;
 
-function __sbTimeout(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 async function __sbDrainWaitUntil(tasks) {
   if (!tasks.length) return;
   const pending = tasks.splice(0, tasks.length);
-  await Promise.race([__sbDrainAll(pending), __sbTimeout(__SB_WAITUNTIL_TIMEOUT_MS)]);
+  // Clear the cap's timer once the tasks finish: a pending timer kept the process
+  // busy for the full 25 s (sproutd will not reap a worker with timers left, B22).
+  let timer;
+  const cap = new Promise((resolve) => {
+    timer = setTimeout(resolve, __SB_WAITUNTIL_TIMEOUT_MS);
+  });
+  await Promise.race([__sbDrainAll(pending), cap]);
+  clearTimeout(timer);
 }
 
 async function __sbDrainAll(pending) {
@@ -2049,15 +4919,130 @@ async function __sbDrainAll(pending) {
 // Tail-called from `__sbEntry`/DO dispatch so the promise this returns is the
 // one *this* async function creates, not a `.then()` derived from someone
 // else's — see the note below on why that distinction matters here.
+// B19 (first step): a ReadableStream response body is read to the end and sent buffered;
+// the native writer had sent "[object ReadableStream]". Chunks must be bytes, as in workerd
+// (a string chunk is a TypeError), and the whole body is capped like a fetched one.
+const __SB_STREAM_BODY_MAX = 32 * 1024 * 1024;
+async function __sbCollectBody(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;;) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    let bytes;
+    if (value instanceof Uint8Array) bytes = value;
+    else if (value instanceof ArrayBuffer) bytes = new Uint8Array(value);
+    else if (ArrayBuffer.isView(value)) bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    else throw new TypeError("This ReadableStream did not return bytes.");
+    size += bytes.length;
+    if (size > __SB_STREAM_BODY_MAX) throw new RangeError("Response body stream exceeds 32 MiB");
+    chunks.push(bytes);
+  }
+  const out = new Uint8Array(size);
+  let at = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, at);
+    at += chunk.length;
+  }
+  return out;
+}
+function __sbHasStreamBody(res) {
+  return res != null && res.body instanceof ReadableStream;
+}
+
+// B19: on a host that streams (a standalone sprout's native server defines sb_stream_*), a
+// stream body goes out as it is produced: the response is marked with the internal
+// x-sb-stream header, the native writer sends the status and headers and holds the
+// connection open, and each chunk is written as it arrives. Hosts that do not stream
+// (sproutd's workers, for now) link the weak fallbacks, report unsupported and keep buffering.
+// op: "s" supported, "o" open, "w" write data, "e" end. Returns a short string.
+// oxlint-disable-next-line no-unused-vars -- read inside the RawC block, not by JS.
+function __sbStreamOp(op, id, data) {
+  let out = "";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    extern int sb_stream_supported(void);
+    extern unsigned int sb_stream_open(void);
+    extern int sb_stream_write(unsigned int, const char*, size_t);
+    extern void sb_stream_end(unsigned int);
+    const char* __o; size_t __ol; char* __oo = 0;
+    porf_native_fetch_read_value(op, &__o, &__ol, &__oo);
+    char __op = __ol ? __o[0] : 0;
+    if (__oo) free(__oo);
+    const char* __i; size_t __il; char* __io = 0;
+    porf_native_fetch_read_value(id, &__i, &__il, &__io);
+    char __ib[16]; size_t __ik = __il < 15 ? __il : 15;
+    memcpy(__ib, __i, __ik); __ib[__ik] = 0;
+    if (__io) free(__io);
+    unsigned int __id = (unsigned int)strtoul(__ib, 0, 10);
+    char __r[24]; __r[0] = 0;
+    if (sb_stream_supported()) {
+      if (__op == 's') snprintf(__r, sizeof(__r), "1");
+      else if (__op == 'o') snprintf(__r, sizeof(__r), "%u", sb_stream_open());
+      else if (__op == 'w') {
+        const char* __d = 0; size_t __dl = 0;
+        int __w = -1;
+        if (porf_native_fetch_read_raw_bytes(data, &__d, &__dl) == 0) __w = sb_stream_write(__id, __d, __dl);
+        snprintf(__r, sizeof(__r), "%d", __w);
+      } else if (__op == 'e') { sb_stream_end(__id); snprintf(__r, sizeof(__r), "0"); }
+    }
+    out = porf_box((f64)porf_native_fetch_alloc_bytestring(__r, strlen(__r)), 195);
+  `;
+  return out;
+}
+let __sbStreaming = -1;
+function __sbStreamingSupported() {
+  if (__sbStreaming < 0) __sbStreaming = __sbStreamOp("s", "0", "") === "1" ? 1 : 0;
+  return __sbStreaming === 1;
+}
+function __sbStreamResponse(response) {
+  const stream = response.body;
+  const id = __sbStreamOp("o", "0", "");
+  response.headers.set("x-sb-stream", id);
+  response.body = "";
+  (async () => {
+    const reader = stream.getReader();
+    try {
+      for (;;) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        let bytes;
+        if (value instanceof Uint8Array) bytes = value;
+        else if (value instanceof ArrayBuffer) bytes = new Uint8Array(value);
+        else if (ArrayBuffer.isView(value)) bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+        else throw new TypeError("This ReadableStream did not return bytes.");
+        if (bytes.length > 0 && __sbStreamOp("w", id, __sbToBytes(bytes)) !== "0") {
+          // The client went away: stop the source.
+          reader.cancel();
+          break;
+        }
+      }
+    } catch (error) {
+      // The status line is already out; log and end what was sent.
+      __sbLogUncaught("fetch", error);
+    }
+    __sbStreamOp("e", id, "");
+  })();
+  return response;
+}
+
 async function __sbFetchWithDrain(res, tasks) {
   let r;
   try {
     r = res && __sbIsFn(res.then) ? await res : res;
+    if (__sbHasStreamBody(r)) {
+      if (__sbStreamingSupported()) __sbStreamResponse(r);
+      else r.body = await __sbCollectBody(r.body);
+    }
   } catch (error) {
     // #179 — a rejected handler promise must not take the process down with it.
     r = __sbErrorResponse(error);
   }
-  await __sbDrainWaitUntil(tasks);
+  // The response goes out now and ctx.waitUntil work keeps running after it, as in
+  // workerd; it was awaited first, so a 1.5 s background task delayed the response by
+  // 1.5 s. The 25 s cap still bounds it.
+  __sbDrainWaitUntil(tasks);
   return r;
 }
 
@@ -2067,7 +5052,10 @@ async function __sbFetchWithDrain(res, tasks) {
 // nothing on stderr, which hid #168 entirely.
 function __sbErrorResponse(error) {
   __sbLogUncaught("fetch", error);
-  return new Response("Internal Server Error", { status: 500 });
+  // Untyped, as workerd sends it: the text/plain default is for handlers' bodies.
+  const response = new Response("Internal Server Error", { status: 500 });
+  response.headers.delete("content-type");
+  return response;
 }
 
 function __sbLogUncaught(where, error) {
@@ -2165,7 +5153,7 @@ globalThis.__sbEntry = function (handlers, request) {
     }
     // Same promise-identity rule as above applies to `__sbFetchWithDrain`'s
     // own return, which is why it's tail-called rather than chained on here.
-    if (__sbTasks.length || (__res && __sbIsFn(__res.then))) return __sbFetchWithDrain(__res, __sbTasks);
+    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks);
     return __sbTagCpu(__res, __t0);
   }
   if (!__sbTriggerAuthed(request)) return new Response("forbidden", { status: 403 });