@orkestrel/mcp 0.0.23 → 0.0.24

package/dist/src/server/index.cjs

@@ -371,6 +371,14 @@ function extractLines(buffer, chunk) {
 * The completion callback is the writable channel's backpressure boundary. A callback error and
 * a synchronous `write` throw reject the returned promise with the original value.
 *
+* That callback is the ONLY thing that settles the promise: this helper holds no timer and no
+* abort, so an output that neither confirms nor fails the write parks the promise for as long as
+* the caller-owned stream holds the callback. A caller wanting a bound races this promise against
+* one it owns — {@link import('./transports/StdioServerTransport.js').StdioServerTransport}
+* registers such a bound per send and rejects it on `close()`, so closing the transport settles
+* the CALLER's `send` while the abandoned write stays with the stream that still holds its
+* callback, reachable from nothing the transport retains.
+*
 * @param output - The writable stream that receives the line
 * @param line - The complete line to write
 * @returns Resolves when the stream confirms the write; rejects when the write fails
@@ -1240,7 +1248,11 @@ var WebSocketServerTransport = class {
 *   event (the reply the {@link import('@orkestrel/mcp').MCPClientInterface} correlates by `id`); a
 *   non-JSON / non-message frame surfaces on `error` and is dropped. The socket's `close`
 *   / `error` bridge to this transport's events.
-* - **Outbound (`send`).** `send(message)` writes one masked text frame.
+* - **Outbound (`send`).** `send(message)` writes one masked text frame. A socket write is not
+*   confirmed, so this transport answers a closed channel from its OWN state: a `send` with no
+*   bound socket — before `start()`, after `close()`, or after the peer ended the socket —
+*   REJECTS with `WebSocket transport is not connected`. It neither drops the message (the
+*   browser face's posture) nor queues it for a connection this transport is not holding.
 * - **`close()`** unsubscribes from the socket, closes it, and fires `close` (idempotent). An
 *   upgrade still on the wire is DESTROYED, so a `close()` during the handshake ends the
 *   transport at once instead of waiting for a peer that may never answer — the suspended