@mcpwarp/ws-mixer 0.6.0 → 0.7.0

package/dist/index.js

@@ -66,7 +66,7 @@ var WsMixerError = class extends Error {
   /** The peer's observed WS close-frame reason, verbatim, under the same condition as `wsCode`. */
   closeReason;
   constructor(code, message, opts) {
-    super(message);
+    super(message, opts?.cause !== void 0 ? { cause: opts.cause } : void 0);
     this.code = code;
     this.fatal = opts?.fatal ?? false;
     this.streamId = opts?.streamId;
@@ -523,7 +523,7 @@ var MixerStream = class extends Duplex {
   /** Bytes queued via _write, waiting on credit; drives backpressure. */
   writeQueue = [];
   draining = false;
-  /** Write callbacks (_write's own terminal-error branch, or drainWriteQueue's catch) whose error must wait until the read side has finished delivering buffered data and emitted 'end' -- see terminateNoThrow's doc comment. Non-null exactly while that wait is pending; flushed (and reset to null) from _destroy(), or from the 'end' listener drainWriteQueue's catch installs. */
+  /** Write callbacks (_write's own terminal-error branch, or failWrite()) whose error must wait until the read side has finished delivering buffered data and emitted 'end' -- see terminateNoThrow's doc comment. Non-null exactly while that wait is pending; flushed (and reset to null) from _destroy(), or from the 'end' listener failWrite() installs. */
   heldWriteCallbacks = null;
   /** Set once this stream is RESET -- by the peer (handleReset), the SDK (abort()), or the app itself (reset()); undefined until then. Set even when no `'error'` listener is attached. */
   resetCode;
@@ -557,7 +557,7 @@ var MixerStream = class extends Duplex {
       return;
     }
     if (this.state !== "open" && this.state !== "half_closed_remote") {
-      callback(new StreamError(ErrorCode.STREAM_CLOSED, this.id, "write on a stream that is not open for sending"));
+      this.failWrite(callback, new StreamError(ErrorCode.STREAM_CLOSED, this.id, "write on a stream that is not open for sending"));
       return;
     }
     this.writeQueue.push({ chunk, callback });
@@ -595,6 +595,8 @@ var MixerStream = class extends Duplex {
       try {
         while (chunk.length > 0) {
           const n = await this.reserveSendCredit(chunk.length);
+          const { done, error } = this.sendDone();
+          if (done) throw error;
           const piece = chunk.subarray(0, n);
           chunk = chunk.subarray(n);
           await this.host.sendData(this.id, piece);
@@ -603,42 +605,66 @@ var MixerStream = class extends Duplex {
         callback();
       } catch (e) {
         this.writeQueue.shift();
-        if (this.heldWriteCallbacks) {
-          this.heldWriteCallbacks.push(callback);
-          continue;
-        }
-        if (this.state === "half_closed_remote") {
-          const failure = e;
-          if (!this.hasErrorListener()) {
-            this.on("error", NOOP_ERROR_LISTENER);
-          }
-          if (this.readableEnded) {
-            callback(failure);
-            continue;
-          }
-          this.heldWriteCallbacks = [(err) => callback(err ?? failure)];
-          this.once(
-            "end",
-            () => process.nextTick(() => {
-              if (this.destroyed || !this.heldWriteCallbacks) return;
-              if (this.state === "closed") {
-                this.destroy();
-                return;
-              }
-              const held = this.heldWriteCallbacks;
-              this.heldWriteCallbacks = null;
-              for (const cb of held) cb(this.terminalError ?? void 0);
-            })
-          );
-          continue;
-        }
-        if (!this.hasErrorListener()) {
-          this.on("error", NOOP_ERROR_LISTENER);
-        }
-        callback(e);
+        this.failWrite(callback, this.terminalError ?? e);
       }
     }
   }
+  /**
+   * Settles a failed write's callback with `failure` -- now, or held until
+   * the read side can no longer be hurt by it. Calling a write callback with
+   * an error marks the READABLE side errored too (Node's own Writable/Duplex
+   * machinery), which drops whatever is still buffered and blocks 'end'.
+   *
+   * - terminateNoThrow is already holding write errors for the read side
+   *   (`heldWriteCallbacks` non-null): join that hold -- see its doc comment.
+   * - The peer's CLOSE has arrived and 'end' hasn't fired yet, whatever this
+   *   side's own write state (`half_closed_remote`, or `closed` after
+   *   closeWrite()): the read side may still be delivering buffered data, so
+   *   hold the callback until 'end', without relying on teardown to flush it
+   *   -- there may be no teardown at all. A connection teardown that does
+   *   come (it also reaches a stream closeWrite() retired) flushes it once
+   *   nothing is left unread; so do destroy()/reset(). `failure` is the
+   *   fallback for a flush with no terminalError of its own (always, on a
+   *   stream CLOSE'd both ways -- see terminateNoThrow).
+   * - Otherwise (peer still sending, 'end' already fired or never will --
+   *   destroyed, or already errored): fail it now.
+   *
+   * Node's Writable machinery re-emits a write callback's error as 'error',
+   * so -- same rationale as terminateNoThrow() -- the internal no-op listener
+   * is attached first if nothing else is listening: a failure is also
+   * reachable before terminateNoThrow() has run at all (the connection's
+   * writer failed this chunk's socket write, and teardown follows from the
+   * socket's own 'close'), and a dying connection must not crash a consumer
+   * that never attached its own 'error'.
+   */
+  failWrite(callback, failure) {
+    if (this.heldWriteCallbacks) {
+      this.heldWriteCallbacks.push((err) => callback(err ?? failure));
+      return;
+    }
+    if (!this.hasErrorListener()) {
+      this.on("error", NOOP_ERROR_LISTENER);
+    }
+    if (!this.remoteClosed || this.readableEnded || this.destroyed || this.errored) {
+      callback(failure);
+      return;
+    }
+    this.heldWriteCallbacks = [(err) => callback(err ?? failure)];
+    this.host.pinRetired?.(this.id);
+    this.once(
+      "end",
+      () => process.nextTick(() => {
+        if (this.destroyed || !this.heldWriteCallbacks) return;
+        if (this.state === "closed") {
+          this.destroy();
+          return;
+        }
+        const held = this.heldWriteCallbacks;
+        this.heldWriteCallbacks = null;
+        for (const cb of held) cb(this.terminalError ?? void 0);
+      })
+    );
+  }
   /** Waits until send credit is available, then reserves and returns min(want, sendWindow, MAX_CHUNK). */
   reserveSendCredit(want) {
     return new Promise((resolve, reject) => {
@@ -751,12 +777,14 @@ var MixerStream = class extends Duplex {
    * @internal
    */
   handleClose() {
+    let closedNow = false;
     switch (this.state) {
       case "open":
         this.state = "half_closed_remote";
         break;
       case "half_closed_local":
         this.state = "closed";
+        closedNow = true;
         this.host.retireStream(this.id);
         break;
       case "half_closed_remote":
@@ -766,6 +794,42 @@ var MixerStream = class extends Duplex {
     }
     this.remoteClosed = true;
     this.maybeDeliverEOF();
+    if (closedNow) this.destroyWhenDone();
+  }
+  /**
+   * Both directions CLOSE'd cleanly (closeWrite() + the peer's CLOSE, in
+   * either order): the stream is retired, so only a connection teardown
+   * (which may never come) would otherwise reach it, and 'close' needs a
+   * destroy() on an `autoDestroy: false` Duplex. Mirrors
+   * what autoDestroy itself would do: destroy once the readable has emitted
+   * 'end' (a tick later, like failWrite()'s hold, so every 'end' listener
+   * runs first and 'end' always precedes 'close'), and, when the write side
+   * was closed by end(), once 'finish' has fired too -- destroying inside
+   * _final() would suppress 'finish' and turn finished()/pipeline() into a
+   * premature close. A readable that already errored never emits 'end', so
+   * that destroys right away. A consumer that never reads never sees 'end',
+   * and so never 'close' -- same as any other Readable.
+   */
+  destroyWhenDone() {
+    if (this.destroyed) return;
+    if (this.errored) {
+      this.destroy();
+      return;
+    }
+    if (this.writableEnded && !this.writableFinished) {
+      this.once("finish", () => this.destroyWhenDone());
+      return;
+    }
+    if (this.readableEnded) {
+      this.destroy();
+      return;
+    }
+    this.once(
+      "end",
+      () => process.nextTick(() => {
+        if (!this.destroyed) this.destroy();
+      })
+    );
   }
   // CLOSE preserves buffered data; EOF (push(null)) only follows once every
   // buffered byte has been delivered to the application (WIRE.md section
@@ -778,7 +842,7 @@ var MixerStream = class extends Duplex {
       this.push(null);
     }
   }
-  /** True once something is listening for `'error'`: gates attaching the internal no-op `'error'` listener (terminateNoThrow, drainWriteQueue). */
+  /** True once something is listening for `'error'`: gates attaching the internal no-op `'error'` listener (terminateNoThrow, failWrite). */
   hasErrorListener() {
     return this.listenerCount("error") > 0;
   }
@@ -865,8 +929,8 @@ var MixerStream = class extends Duplex {
    *   too, permanently blocking 'end' regardless of whether an 'error'
    *   listener is attached. So instead of calling those callbacks here,
    *   `heldWriteCallbacks` (non-null for exactly this stretch) collects them
-   *   -- pushed onto by `drainWriteQueue`'s catch and by `_write`'s
-   *   terminal-error branch -- and `_destroy()` flushes them with `err`
+   *   -- pushed onto by failWrite() and by `_write`'s terminal-error
+   *   branch -- and `_destroy()` flushes them with `err`
    *   right after `destroy()` actually runs (whether that's the 'end'-
    *   triggered `destroy()` below, or the read side never gets there because
    *   something else destroys the stream first): by then the readable side
@@ -893,9 +957,13 @@ var MixerStream = class extends Duplex {
    * loop, so no separate queue-flushing step is needed here.
    *
    * A stream already fully, cleanly closed (both directions CLOSE'd) has
-   * already called `retireStream()` and is no longer tracked by MixerConn,
-   * so `rejectOutstanding` never reaches it here at all -- only a stream
-   * still genuinely open, or half-closed one way, ever is.
+   * already called `retireStream()`, but MixerConn keeps it for
+   * `rejectOutstanding` until it is destroyed: it lands in the branch above
+   * (`remoteClosed`), so its read side still ends cleanly, and 'close' fires
+   * once nothing is left unread. Its exchange already completed, so `err`
+   * is not adopted (no `terminalError`, no `resetCode`): a write callback it
+   * holds keeps its own failure (STREAM_CLOSED, or its socket send's error).
+   * Without a teardown, destroyWhenDone() is what ends it.
    *
    * `resetCode` is set here too, but only when `err` is a `StreamError`
    * (mirrors handleReset()/applyReset(), which construct one for exactly
@@ -907,15 +975,18 @@ var MixerStream = class extends Duplex {
    * otherwise wrongly discard a response that had already completed on
    * every drain hand-over. From the stream's own perspective a `StreamError`
    * IS a fourth way it ends in RESET, on top of the three the class doc
-   * above lists, distinct from an ordinary `WsMixerError`/`ConnError`
-   * connection failure, which is not RESET-shaped and leaves `resetCode`
-   * unset.
+   * above lists, distinct from an ordinary connection failure (always a
+   * `ConnError` by the time rejectOutstanding() hands it here), which is not
+   * RESET-shaped and leaves `resetCode` unset.
    * @internal
    */
   terminateNoThrow(err, opts) {
+    const closedCleanly = this.state === "closed" && !this.terminalError;
     this.state = "closed";
-    this.terminalError = err;
-    if (err instanceof StreamError) this.resetCode = err.code;
+    if (!closedCleanly) {
+      this.terminalError = err;
+      if (err instanceof StreamError) this.resetCode = err.code;
+    }
     const deferWriteErrors = !opts?.discardBuffered && this.remoteClosed;
     if (deferWriteErrors) this.heldWriteCallbacks = this.heldWriteCallbacks ?? [];
     this.wakeSendWaiters();
@@ -948,8 +1019,21 @@ var MixerStream = class extends Duplex {
     }
     return { done: false };
   }
+  /**
+   * True while a write callback is held back for the read side (see failWrite()).
+   * @internal
+   */
+  hasHeldWriteCallbacks() {
+    return this.heldWriteCallbacks !== null && this.heldWriteCallbacks.length > 0;
+  }
   // --- public half-close / reset API -----------------------------------------
-  /** Sends CLOSE: "I will send no more DATA on this stream." end() is sugar for this via _final. */
+  /**
+   * Sends CLOSE: "I will send no more DATA on this stream." end() is sugar
+   * for this via _final. A write still waiting on send credit can never go
+   * out now, so it is woken to fail with STREAM_CLOSED (reserveSendCredit)
+   * instead of waiting on a WINDOW that, once this stream is retired, would
+   * never reach it.
+   */
   closeWrite() {
     switch (this.state) {
       case "open":
@@ -964,13 +1048,17 @@ var MixerStream = class extends Duplex {
     }
     const closedNow = this.state === "closed";
     this.host.sendControlFrame(encodeClose(this.id));
-    if (closedNow) this.host.retireStream(this.id);
+    this.wakeSendWaiters();
+    if (closedNow) {
+      this.host.retireStream(this.id);
+      this.destroyWhenDone();
+    }
   }
   /**
    * Sends CLOSE (if not already sent) and stops delivering further reads. If
    * the peer has not yet half-closed its own send side, a plain closeWrite()
    * would leave it writing into a window nobody drains, so close() also
-   * RESETs with CANCEL in that case (mirrors go/wsmixer/stream.go Close()).
+   * RESETs with CANCEL in that case (mirrors ws-mixer-go/wsmixer/stream.go Close()).
    */
   close() {
     if (!this.remoteClosed) {
@@ -1009,7 +1097,8 @@ var MixerStream = class extends Duplex {
    * MixerConn's dispatch loop). Identical effect to reset(), but also emits
    * `'reset'` the same way handleReset() does for a peer-sent RESET: in both
    * cases the stream's owner didn't choose this, so it needs to hear about
-   * it. No-ops (and does not emit) if the stream is already closed.
+   * it. Sends nothing and does not emit if the stream is already closed
+   * (applyReset then only finishes a pending local destroy()).
    * @internal
    */
   abort(code, message = "") {
@@ -1017,10 +1106,10 @@ var MixerStream = class extends Duplex {
       this.emit("reset", { code: this.resetCode, message: this.terminalError.message });
     }
   }
-  /** Shared implementation behind reset()/abort(); returns false (no-op) if the stream was already closed. */
+  /** Shared implementation behind reset()/abort(); returns false (nothing sent) if the stream was already closed. */
   applyReset(code, message) {
     if (this.state === "closed") {
-      if (this.heldWriteCallbacks && !this.destroyed) this.destroy();
+      if (!this.destroyed) this.destroy();
       return false;
     }
     const numericCode = typeof code === "string" ? parseErrorCode(code) : code;
@@ -1058,6 +1147,23 @@ var DELIVERY_QUEUE_MARGIN = 64;
 function wireCloseCode(wsCode) {
   return wsCode === 1e3 || wsCode >= 4e3 && wsCode <= 4999 ? wsCode : 4e3 + ErrorCode.INTERNAL_ERROR;
 }
+var MAX_RESET_MESSAGE = 256;
+function asConnError(err) {
+  if (err instanceof ConnError) return err;
+  if (err instanceof WsMixerError) {
+    return new ConnError(err.code, err.message, {
+      streamId: err.streamId,
+      fatal: err.fatal,
+      wsCode: err.wsCode,
+      closeReason: err.closeReason,
+      cause: err
+    });
+  }
+  return new ConnError(ErrorCode.INTERNAL_ERROR, err.message, { cause: err });
+}
+function retiredStreamError(streamId) {
+  return new StreamError(ErrorCode.STREAM_CLOSED, streamId, "DATA not sent: stream already closed");
+}
 var TokenBucket = class {
   constructor(capacity, ratePerSecond) {
     this.capacity = capacity;
@@ -1094,6 +1200,23 @@ var MixerConn = class extends EventEmitter {
   /** The `last_stream_id` from the most recently received `drain`; set only once draining. */
   lastStreamId;
   streams = /* @__PURE__ */ new Map();
+  /**
+   * Retired (out of `streams`: no frame or DATA is ever routed to them again)
+   * but not yet destroyed -- in practice a stream CLOSE'd both ways, waiting
+   * on its reader's 'end'. Tracked only so rejectOutstanding() still tears
+   * them down; each leaves on its own 'close', and teardown clears the rest.
+   * Weak by default: a stream never read never emits 'end', so never
+   * 'close', and a strong ref would pin every such stream the app abandoned
+   * for the connection's lifetime. Strong while the stream holds a write
+   * callback (retireStream(), or pinRetired() when one is held after
+   * retirement): the stream owns that callback, not the other way round, and
+   * the callback is what the app is waiting on -- collecting the stream
+   * would leave it unsettled forever. A retired stream's held callbacks are
+   * only ever flushed by destroy(), so a strong entry leaves on 'close' and
+   * is never unpinned.
+   * Dead weak refs are pruned whenever the map is touched.
+   */
+  retired = /* @__PURE__ */ new Map();
   highestOpened = 0;
   /**
    * Minimal "ignore and count" counters (item 11 of the review: full
@@ -1135,13 +1258,14 @@ var MixerConn = class extends EventEmitter {
   /**
    * The `StreamHost` a `MixerStream` actually talks to: a plain object of
    * bound closures, not `this` -- so `sendData`/`sendControlFrame`/
-   * `retireStream` stay private implementation details of MixerConn instead
-   * of leaking onto its public (and `.d.ts`) surface (item 8).
+   * `retireStream`/`pinRetired` stay private implementation details of
+   * MixerConn instead of leaking onto its public (and `.d.ts`) surface (item 8).
    */
   #streamHost = {
     sendData: (streamId, chunk) => this.sendData(streamId, chunk),
     sendControlFrame: (frame) => this.sendControlFrame(frame),
-    retireStream: (streamId) => this.retireStream(streamId)
+    retireStream: (streamId) => this.retireStream(streamId),
+    pinRetired: (streamId) => this.pinRetired(streamId)
   };
   // --- write scheduler state ---
   controlQueue = [];
@@ -1156,11 +1280,11 @@ var MixerConn = class extends EventEmitter {
   // order, off one queue, so a slow handler cannot stall frame parsing. ---
   deliveryQueue = [];
   deliveryRunning = false;
-  // --- stream-0 flood limit (item 4), mirrors go/wsmixer's Conn.stream0Bucket ---
+  // --- stream-0 flood limit (item 4), mirrors ws-mixer-go/wsmixer's Conn.stream0Bucket ---
   stream0Bucket = new TokenBucket(STREAM0_BURST, STREAM0_RATE_PER_SEC);
   // --- keepalive state ---
   nextPingId = 0;
-  /** Watermark: every id below this has been acked (or pruned as stale) at least once. Mirrors go/wsmixer's Conn.lowestUnacked. */
+  /** Watermark: every id below this has been acked (or pruned as stale) at least once. Mirrors ws-mixer-go/wsmixer's Conn.lowestUnacked. */
   lowestUnacked = 0;
   lastPongAt = 0;
   outstandingPings = /* @__PURE__ */ new Map();
@@ -1334,7 +1458,7 @@ var MixerConn = class extends EventEmitter {
         stream.handleClose();
         break;
       case FrameType.RESET:
-        stream.handleReset(resetCode(frame), resetMessage(frame));
+        stream.handleReset(resetCode(frame), truncateUtf8(resetMessage(frame), MAX_RESET_MESSAGE));
         break;
     }
   }
@@ -1387,7 +1511,7 @@ var MixerConn = class extends EventEmitter {
   // --- ordered async delivery (item 2) -------------------------------------
   /**
    * Queues one `'stream'`/`'app'`/`'drain'` event for in-order, async
-   * delivery, mirroring go/wsmixer's deliveryLoop: the read/dispatch path
+   * delivery, mirroring ws-mixer-go/wsmixer's deliveryLoop: the read/dispatch path
    * above never blocks on application code, but all three still fire in
    * wire order, off a single loop, one at a time. Handlers registered via
    * `on('stream'|'app'|'drain', ...)` must not block for long -- a handler
@@ -1459,9 +1583,13 @@ var MixerConn = class extends EventEmitter {
    * caught here, counted (stats().handlerErrors) and surfaced via a guarded
    * `'handlerError'` emit -- never an unhandled rejection, and never fatal
    * to delivery: the next queued stream/app/drain event still runs.
+   *
+   * Iterates rawListeners(), not listeners(): for a once() registration that
+   * is the self-removing wrapper, so it detaches on first delivery (it
+   * returns and throws exactly what the wrapped listener does).
    */
   async emitOrdered(event, arg) {
-    for (const listener of this.listeners(event)) {
+    for (const listener of this.rawListeners(event)) {
       try {
         const result = listener.call(this, arg);
         if (result instanceof Promise) await result;
@@ -1519,6 +1647,10 @@ var MixerConn = class extends EventEmitter {
         reject(new ConnError(ErrorCode.INTERNAL_ERROR, "connection closed"));
         return;
       }
+      if (!this.streams.has(streamId)) {
+        reject(retiredStreamError(streamId));
+        return;
+      }
       let q = this.outbox.get(streamId);
       if (!q) {
         q = [];
@@ -1528,12 +1660,47 @@ var MixerConn = class extends EventEmitter {
       this.markReady(streamId);
     });
   }
-  /** Backs `streamHost.retireStream`: retire a fully-closed stream's id. */
+  /**
+   * Backs `streamHost.retireStream`: retire a fully-closed stream's id. DATA
+   * still queued for it is rejected, never dropped (a dropped item's write
+   * callback would hang forever) -- with the stream's own sendDone() error
+   * (its RESET's, or STREAM_CLOSED after its CLOSE). A stream not yet
+   * destroyed moves to `retired` until its 'close' -- strongly if it holds
+   * a write callback, else weakly (see `retired`).
+   */
   retireStream(streamId) {
+    const stream = this.streams.get(streamId);
     this.streams.delete(streamId);
+    if (stream && !stream.destroyed) {
+      this.pruneRetired();
+      this.retired.set(streamId, stream.hasHeldWriteCallbacks() ? stream : new WeakRef(stream));
+      stream.once("close", () => {
+        this.retired.delete(streamId);
+        this.pruneRetired();
+      });
+    }
+    const q = this.outbox.get(streamId);
     this.outbox.delete(streamId);
+    if (q) {
+      const err = stream?.sendDone().error ?? retiredStreamError(streamId);
+      for (const item of q) item.reject(err);
+    }
     if (this.streams.size === 0) this.notifyIdle();
   }
+  /** Backs `streamHost.pinRetired`: a retired stream now holding a write callback is held strongly until its 'close'. */
+  pinRetired(streamId) {
+    const entry = this.retired.get(streamId);
+    if (entry instanceof WeakRef) {
+      const stream = entry.deref();
+      if (stream) this.retired.set(streamId, stream);
+    }
+  }
+  /** Drops weak `retired` entries whose stream has been garbage-collected. */
+  pruneRetired() {
+    for (const [id, entry] of this.retired) {
+      if (entry instanceof WeakRef && entry.deref() === void 0) this.retired.delete(id);
+    }
+  }
   /** Resolves every pending close()'s wait for the stream table to empty, instead of polling. */
   notifyIdle() {
     const waiters = this.idleWaiters;
@@ -1572,12 +1739,14 @@ var MixerConn = class extends EventEmitter {
       if (!q || q.length === 0) continue;
       const item = q.shift();
       const stream = this.streams.get(id);
-      if (stream) {
-        const { done, error } = stream.sendDone();
-        if (done) {
-          item.reject(error);
-          continue;
-        }
+      if (!stream) {
+        item.reject(retiredStreamError(id));
+        continue;
+      }
+      const { done, error } = stream.sendDone();
+      if (done) {
+        item.reject(error);
+        continue;
       }
       if (q.length > 0) this.markReady(id);
       return { streamId: id, item };
@@ -1627,20 +1796,20 @@ var MixerConn = class extends EventEmitter {
   writeRaw(frame) {
     return new Promise((resolve, reject) => {
       if (this.closed) {
-        reject(new Error("connection closed"));
+        reject(new ConnError(ErrorCode.INTERNAL_ERROR, "connection closed"));
         return;
       }
       try {
         this.ws.send(frame, (err) => {
           if (err) {
-            reject(err);
+            reject(asConnError(err));
             return;
           }
           this.counters.bytesOut += frame.length;
           resolve();
         });
       } catch (e) {
-        reject(e);
+        reject(asConnError(e instanceof Error ? e : new Error(String(e))));
       }
     });
   }
@@ -1668,7 +1837,7 @@ var MixerConn = class extends EventEmitter {
     });
   }
   /**
-   * Pong watermark scheme, mirroring go/wsmixer/dispatch.go's handlePong:
+   * Pong watermark scheme, mirroring ws-mixer-go/wsmixer/dispatch.go's handlePong:
    * every id below lowestUnacked has been acked (or pruned as stale) at
    * least once, and no id >= nextPingId has ever been sent.
    *  - id >= nextPingId: never sent -> PROTOCOL_ERROR, connection-fatal.
@@ -1774,7 +1943,7 @@ var MixerConn = class extends EventEmitter {
   /**
    * The peer sent `error{code,message}`: record it and close with
    * `4000 + code` immediately, without waiting for the peer to do anything
-   * else -- mirrors go/wsmixer/dispatch.go's handlePeerError. `error` is
+   * else -- mirrors ws-mixer-go/wsmixer/dispatch.go's handlePeerError. `error` is
    * always the last message on the wire (WIRE.md section 2.7), so
    * there is nothing left to negotiate.
    */
@@ -1889,19 +2058,26 @@ var MixerConn = class extends EventEmitter {
     this.jitterTimer = null;
   }
   rejectOutstanding(err, streamErrorFactory) {
-    for (const q of this.outbox.values()) {
-      for (const item of q) item.reject(err);
-    }
-    this.outbox.clear();
+    const connErr2 = asConnError(err);
     for (const item of this.controlQueue.splice(0, this.controlQueue.length)) {
-      item.reject(err);
+      item.reject(connErr2);
     }
-    this.wake();
-    for (const stream of this.streams.values()) {
-      stream.terminateNoThrow(
-        streamErrorFactory ? streamErrorFactory(stream.id) : err instanceof WsMixerError ? err : new ConnError(ErrorCode.INTERNAL_ERROR, err.message)
-      );
+    const retired = [];
+    for (const entry of this.retired.values()) {
+      const stream = entry instanceof WeakRef ? entry.deref() : entry;
+      if (stream) retired.push(stream);
     }
+    for (const stream of [...this.streams.values(), ...retired]) {
+      if (stream.destroyed) continue;
+      stream.terminateNoThrow(streamErrorFactory ? streamErrorFactory(stream.id) : connErr2);
+    }
+    this.retired.clear();
+    for (const [id, q] of this.outbox) {
+      const streamErr = this.streams.get(id)?.sendDone().error ?? connErr2;
+      for (const item of q) item.reject(streamErr);
+    }
+    this.outbox.clear();
+    this.wake();
   }
   isDraining() {
     return this.draining;
@@ -1913,7 +2089,7 @@ var MixerConn = class extends EventEmitter {
 
 // src/client.ts
 var SUBPROTOCOL = "ws-mixer.v1";
-var SDK_VERSION = "0.6.0";
+var SDK_VERSION = "0.7.0";
 async function resolveToken(token) {
   return typeof token === "function" ? await token() : token;
 }