@harapter/transport-jsonrpc-stdio 0.1.1

package/dist/index.js

@@ -0,0 +1,829 @@
+import { setImmediate as scheduleImmediate } from 'node:timers';
+import { inspect } from 'node:util';
+const defaultMaxMessageBytes = 1024 * 1024;
+const defaultMaxBufferedMessages = 128;
+const defaultMaxPendingRequests = 128;
+const defaultMaxPendingInboundRequests = 128;
+const defaultMaxPendingWrites = 128;
+const defaultRequestTimeoutMs = 30_000;
+const maximumTimerMilliseconds = 2_147_483_647;
+/** Safe transport failure that never includes a frame or stream error body. */
+export class JsonRpcTransportError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'JsonRpcTransportError';
+        this.code = code;
+    }
+}
+/** Safe remote failure with raw fields behind an explicit extraction method. */
+export class JsonRpcRemoteError extends Error {
+    #remoteError;
+    constructor(error) {
+        super('Remote JSON-RPC request failed.');
+        Object.defineProperty(this, 'name', { value: 'JsonRpcRemoteError' });
+        this.#remoteError = Object.prototype.hasOwnProperty.call(error, 'data')
+            ? { code: error.code, data: error.data, message: error.message }
+            : { code: error.code, message: error.message };
+    }
+    /** Explicitly extract untrusted fields for Provider validation and redaction. */
+    getRemoteError() {
+        return this.#remoteError;
+    }
+    /** Keep generic JSON error logging bounded and content-free. */
+    toJSON() {
+        return { message: this.message, name: this.name };
+    }
+    /** Keep Node inspection bounded and content-free. */
+    [inspect.custom]() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+class InboundQueue {
+    capacity;
+    values = [];
+    waiter;
+    closed = false;
+    failure;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    push(value) {
+        if (this.closed)
+            return false;
+        if (this.waiter) {
+            const waiter = this.waiter;
+            this.waiter = undefined;
+            waiter.resolve({ done: false, value });
+            return true;
+        }
+        if (this.values.length >= this.capacity)
+            return false;
+        this.values.push(value);
+        return true;
+    }
+    next() {
+        const value = this.values.shift();
+        if (value)
+            return Promise.resolve({ done: false, value });
+        if (this.failure)
+            return Promise.reject(this.failure);
+        if (this.closed)
+            return Promise.resolve({ done: true, value: undefined });
+        if (this.waiter) {
+            return Promise.reject(transportError('consumer_conflict', 'Only one inbound read may be pending at a time.'));
+        }
+        return new Promise((resolve, reject) => {
+            this.waiter = { resolve, reject };
+        });
+    }
+    close(failure) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.failure = failure;
+        this.values.length = 0;
+        if (!this.waiter)
+            return;
+        const waiter = this.waiter;
+        this.waiter = undefined;
+        if (failure)
+            waiter.reject(failure);
+        else
+            waiter.resolve({ done: true, value: undefined });
+    }
+}
+/**
+ * Bounded bidirectional JSONL RPC transport over caller-owned Node streams.
+ * It correlates responses but leaves Provider methods and lifecycle semantics
+ * to the consuming Adapter.
+ */
+export class JsonRpcStdioTransport {
+    readable;
+    writable;
+    cleanup;
+    emitJsonRpcVersion;
+    requireJsonRpcVersion;
+    requireIntegerNumericIds;
+    maxMessageBytes;
+    maxPendingRequests;
+    maxPendingInboundRequests;
+    maxPendingWrites;
+    requestTimeoutMs;
+    onDiagnostic;
+    inboundQueue;
+    pendingRequests = new Map();
+    pendingInboundRequestIds = new Set();
+    respondingInboundRequestIds = new Set();
+    abandoningInboundRequestIds = new Set();
+    terminalGuardStreams = new Set();
+    activeWriteRejectors = new Set();
+    lineChunks = [];
+    lineBytes = 0;
+    nextRequestId = 1;
+    pendingWrites = 0;
+    incomingClaimed = false;
+    inboundAcknowledgedSequence = 0;
+    inboundSequence = 0;
+    inboundBarrierWaiters = new Set();
+    open = true;
+    terminalError;
+    cleanupFailure;
+    cleanupPromise;
+    writeTail = Promise.resolve();
+    writableCallbackFailed = false;
+    handleReadableData = (chunk) => {
+        if (!this.open)
+            return;
+        if (typeof chunk !== 'string' &&
+            !Buffer.isBuffer(chunk) &&
+            !(chunk instanceof Uint8Array)) {
+            this.fail(transportError('stream_failed', 'The readable stream emitted an unsupported chunk.'));
+            return;
+        }
+        this.consumeChunk(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    };
+    handleReadableEnd = () => {
+        if (!this.open)
+            return;
+        this.fail(this.lineBytes > 0
+            ? transportError('truncated_message', 'The readable stream ended with an incomplete JSONL frame.')
+            : transportError('stream_ended', 'The readable stream ended before the transport was closed.'));
+    };
+    handleStreamError = (_error) => {
+        this.fail(transportError('stream_failed', 'A transport stream reported a failure.'));
+    };
+    handleWritableError = (_error) => {
+        this.fail(this.writableCallbackFailed
+            ? transportError('write_failed', 'The transport could not write a JSON-RPC frame.')
+            : transportError('stream_failed', 'A transport stream reported a failure.'));
+    };
+    handleStreamClose = () => {
+        if (!this.open)
+            return;
+        this.fail(transportError('stream_ended', 'A transport stream closed before the transport was closed.'));
+    };
+    constructor(options) {
+        this.maxMessageBytes = positiveInteger(options.maxMessageBytes ?? defaultMaxMessageBytes);
+        const maxBufferedMessages = positiveInteger(options.maxBufferedMessages ?? defaultMaxBufferedMessages);
+        this.maxPendingRequests = positiveInteger(options.maxPendingRequests ?? defaultMaxPendingRequests);
+        this.maxPendingInboundRequests = positiveInteger(options.maxPendingInboundRequests ?? defaultMaxPendingInboundRequests);
+        this.maxPendingWrites = positiveInteger(options.maxPendingWrites ?? defaultMaxPendingWrites);
+        this.requestTimeoutMs = timerMilliseconds(options.requestTimeoutMs ?? defaultRequestTimeoutMs);
+        this.readable = options.readable;
+        this.writable = options.writable;
+        this.cleanup = options.cleanup;
+        this.emitJsonRpcVersion = options.emitJsonRpcVersion ?? false;
+        this.requireJsonRpcVersion = options.requireJsonRpcVersion ?? false;
+        this.requireIntegerNumericIds = options.requireIntegerNumericIds ?? false;
+        this.onDiagnostic = options.onDiagnostic;
+        this.inboundQueue = new InboundQueue(maxBufferedMessages);
+        this.readable.on('data', this.handleReadableData);
+        this.readable.once('end', this.handleReadableEnd);
+        this.readable.once('error', this.handleStreamError);
+        this.readable.once('close', this.handleStreamClose);
+        this.writable.once('error', this.handleWritableError);
+        this.writable.once('close', this.handleStreamClose);
+    }
+    /** Send a request and resolve it exactly once from its correlated response. */
+    request(method, params, options = {}) {
+        return this.requestInternal(method, params, options, false);
+    }
+    /** Resolve a request only after earlier inbound messages were consumed. */
+    requestAfterInbound(method, params, options = {}) {
+        return this.requestInternal(method, params, options, true);
+    }
+    requestInternal(method, params, options, waitForInbound) {
+        try {
+            this.assertOpen();
+            assertMethod(method);
+            if (options.signal?.aborted) {
+                throw transportError('request_aborted', 'The local request wait was aborted before the request was sent.');
+            }
+            if (this.pendingRequests.size >= this.maxPendingRequests) {
+                throw transportError('capacity_exceeded', 'The pending outbound request limit was reached.');
+            }
+            const timeoutMs = timerMilliseconds(options.timeoutMs ?? this.requestTimeoutMs);
+            const id = this.allocateRequestId();
+            const envelope = this.outboundEnvelope({ id, method, params });
+            const frame = this.encode(envelope);
+            this.assertOpen();
+            const response = new Promise((resolve, reject) => {
+                const abortListener = options.signal
+                    ? () => {
+                        this.settlePending(id, (pending) => {
+                            pending.reject(transportError('request_aborted', 'The local request wait was aborted.'));
+                        });
+                    }
+                    : undefined;
+                const timer = setTimeout(() => {
+                    this.settlePending(id, (pending) => {
+                        pending.reject(transportError('request_timeout', 'The JSON-RPC request timed out.'));
+                    });
+                }, timeoutMs);
+                timer.unref();
+                this.pendingRequests.set(id, {
+                    resolve,
+                    reject,
+                    timer,
+                    signal: options.signal,
+                    abortListener,
+                    waitForInbound,
+                    responseReceived: false,
+                    writeStarted: false,
+                });
+                if (abortListener) {
+                    options.signal?.addEventListener('abort', abortListener, {
+                        once: true,
+                    });
+                    if (options.signal?.aborted)
+                        abortListener();
+                }
+            });
+            void this.enqueueWrite(frame, () => this.startPendingWrite(id)).catch((error) => {
+                this.settlePending(id, (pending) => {
+                    pending.reject(asTransportError(error));
+                });
+            });
+            return response;
+        }
+        catch (error) {
+            return Promise.reject(asTransportError(error));
+        }
+    }
+    /** Send a notification and wait until its complete frame is flushed. */
+    notify(method, params) {
+        try {
+            this.assertOpen();
+            assertMethod(method);
+            return this.enqueueWrite(this.encode(this.outboundEnvelope({ method, params })));
+        }
+        catch (error) {
+            return Promise.reject(asTransportError(error));
+        }
+    }
+    /** Iterate remote requests and notifications in wire order. */
+    incoming() {
+        if (this.incomingClaimed) {
+            throw transportError('consumer_conflict', 'The inbound message stream already has a consumer.');
+        }
+        this.incomingClaimed = true;
+        const source = this.iterateIncoming();
+        return {
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            next: () => source.next(),
+            return: async () => {
+                await this.close();
+                return source.return(undefined);
+            },
+            throw: async (error) => {
+                await this.close();
+                return source.throw(error);
+            },
+        };
+    }
+    /** Respond successfully to one outstanding remote request. */
+    respond(id, result) {
+        if (result === undefined) {
+            return Promise.reject(transportError('invalid_outbound_message', 'A JSON-RPC response result cannot be undefined.'));
+        }
+        return this.respondWithEnvelope(id, { id, result });
+    }
+    /** Respond with a JSON-RPC error to one outstanding remote request. */
+    respondError(id, error) {
+        return this.respondWithEnvelope(id, { error, id }, 'error');
+    }
+    /**
+     * Release a remote request that the Provider authoritatively resolved without
+     * a client response. No wire message is emitted.
+     */
+    abandonInboundRequest(id) {
+        if (!isJsonRpcId(id, this.requireIntegerNumericIds))
+            return false;
+        const key = requestIdKey(id);
+        if (!this.pendingInboundRequestIds.has(key))
+            return false;
+        if (this.respondingInboundRequestIds.has(key)) {
+            this.abandoningInboundRequestIds.add(key);
+            return true;
+        }
+        this.pendingInboundRequestIds.delete(key);
+        return true;
+    }
+    /** Whether the logical transport can still accept operations. */
+    isOpen() {
+        return this.open;
+    }
+    /** Close the logical transport and run caller-provided cleanup once. */
+    async close() {
+        if (this.open) {
+            this.terminate(undefined, transportError('transport_closed', 'The transport was closed.'));
+        }
+        await this.cleanupPromise;
+        if (this.cleanupFailure)
+            throw this.cleanupFailure;
+    }
+    async *iterateIncoming() {
+        try {
+            for (;;) {
+                const next = await this.inboundQueue.next();
+                if (next.done)
+                    return;
+                yield next.value.message;
+                this.acknowledgeInbound(next.value.sequence);
+            }
+        }
+        finally {
+            if (this.open)
+                await this.close();
+        }
+    }
+    respondWithEnvelope(id, envelope, responseKind = 'result') {
+        let reservedKey;
+        try {
+            this.assertOpen();
+            if (!isJsonRpcId(id, this.requireIntegerNumericIds)) {
+                throw transportError('invalid_outbound_message', 'A JSON-RPC response identifier is invalid.');
+            }
+            const key = requestIdKey(id);
+            if (!this.pendingInboundRequestIds.has(key) ||
+                this.respondingInboundRequestIds.has(key)) {
+                throw transportError('response_not_pending', 'No inbound request is awaiting that response.');
+            }
+            this.respondingInboundRequestIds.add(key);
+            reservedKey = key;
+            const frame = this.encode(this.outboundEnvelope(envelope));
+            assertSerializedResponse(frame, key, responseKind, this.requireIntegerNumericIds);
+            return this.enqueueWrite(frame).then(() => {
+                this.respondingInboundRequestIds.delete(key);
+                this.abandoningInboundRequestIds.delete(key);
+                this.pendingInboundRequestIds.delete(key);
+            }, (error) => {
+                this.respondingInboundRequestIds.delete(key);
+                if (this.abandoningInboundRequestIds.delete(key)) {
+                    this.pendingInboundRequestIds.delete(key);
+                }
+                throw asTransportError(error);
+            });
+        }
+        catch (error) {
+            if (reservedKey) {
+                this.respondingInboundRequestIds.delete(reservedKey);
+                if (this.abandoningInboundRequestIds.delete(reservedKey)) {
+                    this.pendingInboundRequestIds.delete(reservedKey);
+                }
+            }
+            return Promise.reject(asTransportError(error));
+        }
+    }
+    outboundEnvelope(envelope) {
+        const output = this.emitJsonRpcVersion
+            ? { jsonrpc: '2.0', ...envelope }
+            : { ...envelope };
+        if (output['params'] === undefined)
+            delete output['params'];
+        return output;
+    }
+    encode(envelope) {
+        let encoded;
+        try {
+            encoded = JSON.stringify(envelope);
+        }
+        catch {
+            throw transportError('invalid_outbound_message', 'The outbound JSON-RPC message is not JSON serializable.');
+        }
+        if (!encoded) {
+            throw transportError('invalid_outbound_message', 'The outbound JSON-RPC message is invalid.');
+        }
+        if (Buffer.byteLength(encoded) > this.maxMessageBytes) {
+            throw transportError('message_too_large', 'The outbound JSON-RPC message exceeds the configured limit.');
+        }
+        return `${encoded}\n`;
+    }
+    enqueueWrite(frame, shouldWrite) {
+        if (this.pendingWrites >= this.maxPendingWrites) {
+            return Promise.reject(transportError('capacity_exceeded', 'The pending transport write limit was reached.'));
+        }
+        this.pendingWrites += 1;
+        const operation = this.writeTail.then(async () => {
+            this.assertOpen();
+            if (shouldWrite && !shouldWrite())
+                return;
+            await this.writeFrame(frame);
+        });
+        const tracked = operation.finally(() => {
+            this.pendingWrites -= 1;
+        });
+        this.writeTail = tracked.catch(() => undefined);
+        return tracked;
+    }
+    writeFrame(frame) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const rejectWrite = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.activeWriteRejectors.delete(rejectWrite);
+                reject(error);
+            };
+            const resolveWrite = () => {
+                if (settled)
+                    return;
+                settled = true;
+                this.activeWriteRejectors.delete(rejectWrite);
+                resolve();
+            };
+            this.activeWriteRejectors.add(rejectWrite);
+            try {
+                this.writable.write(frame, (error) => {
+                    if (error) {
+                        // Node emits the matching `error` event after this callback. Let
+                        // that listener terminate the transport so the event cannot become
+                        // unhandled when termination detaches stream listeners.
+                        this.writableCallbackFailed = true;
+                    }
+                    else {
+                        resolveWrite();
+                    }
+                });
+            }
+            catch {
+                this.fail(transportError('write_failed', 'The transport could not write a JSON-RPC frame.'));
+            }
+        });
+    }
+    consumeChunk(chunk) {
+        let segmentStart = 0;
+        for (let index = 0; index < chunk.length && this.open; index += 1) {
+            if (chunk[index] !== 0x0a)
+                continue;
+            if (!this.appendLineSegment(chunk.subarray(segmentStart, index)))
+                return;
+            this.consumeLine();
+            segmentStart = index + 1;
+        }
+        if (this.open && segmentStart < chunk.length) {
+            this.appendLineSegment(chunk.subarray(segmentStart));
+        }
+    }
+    appendLineSegment(segment) {
+        if (segment.length === 0)
+            return true;
+        if (this.lineBytes + segment.length > this.maxMessageBytes) {
+            this.fail(transportError('message_too_large', 'An inbound JSONL frame exceeds the configured limit.'));
+            return false;
+        }
+        this.lineChunks.push(Buffer.from(segment));
+        this.lineBytes += segment.length;
+        return true;
+    }
+    consumeLine() {
+        let line = Buffer.concat(this.lineChunks, this.lineBytes);
+        this.lineChunks = [];
+        this.lineBytes = 0;
+        if (line.at(-1) === 0x0d)
+            line = line.subarray(0, -1);
+        let decoded;
+        try {
+            decoded = new TextDecoder('utf-8', { fatal: true }).decode(line);
+        }
+        catch {
+            this.fail(transportError('malformed_message', 'An inbound frame is not UTF-8.'));
+            return;
+        }
+        let value;
+        try {
+            value = JSON.parse(decoded);
+        }
+        catch {
+            this.fail(transportError('malformed_message', 'An inbound frame is not valid JSON.'));
+            return;
+        }
+        this.consumeEnvelope(value);
+    }
+    consumeEnvelope(value) {
+        if (!isRecord(value) ||
+            !validJsonRpcVersion(value, this.requireJsonRpcVersion)) {
+            this.fail(malformedEnvelope());
+            return;
+        }
+        if (hasOwn(value, 'method')) {
+            this.consumeMethodEnvelope(value);
+            return;
+        }
+        this.consumeResponseEnvelope(value);
+    }
+    consumeMethodEnvelope(envelope) {
+        if (typeof envelope['method'] !== 'string' ||
+            envelope['method'].length === 0 ||
+            hasOwn(envelope, 'result') ||
+            hasOwn(envelope, 'error')) {
+            this.fail(malformedEnvelope());
+            return;
+        }
+        const params = hasOwn(envelope, 'params')
+            ? { params: envelope['params'] }
+            : {};
+        if (!hasOwn(envelope, 'id')) {
+            this.enqueueInbound({
+                kind: 'notification',
+                method: envelope['method'],
+                ...params,
+            });
+            return;
+        }
+        const id = envelope['id'];
+        if (!isJsonRpcId(id, this.requireIntegerNumericIds)) {
+            this.fail(malformedEnvelope());
+            return;
+        }
+        const key = requestIdKey(id);
+        if (this.pendingInboundRequestIds.has(key) ||
+            this.pendingInboundRequestIds.size >= this.maxPendingInboundRequests) {
+            this.fail(this.pendingInboundRequestIds.has(key)
+                ? malformedEnvelope()
+                : transportError('capacity_exceeded', 'The pending inbound request limit was reached.'));
+            return;
+        }
+        this.pendingInboundRequestIds.add(key);
+        this.enqueueInbound({
+            id,
+            kind: 'request',
+            method: envelope['method'],
+            ...params,
+        });
+    }
+    consumeResponseEnvelope(envelope) {
+        if (!hasOwn(envelope, 'id')) {
+            this.fail(malformedEnvelope());
+            return;
+        }
+        const hasResult = hasOwn(envelope, 'result');
+        const hasError = hasOwn(envelope, 'error');
+        if (hasResult === hasError) {
+            this.fail(malformedEnvelope());
+            return;
+        }
+        if (hasError && !isJsonRpcErrorObject(envelope['error'])) {
+            this.fail(malformedEnvelope());
+            return;
+        }
+        const id = envelope['id'];
+        if (id === null) {
+            this.emitDiagnostic({ code: 'unmatched_response' });
+            return;
+        }
+        if (!isJsonRpcId(id, this.requireIntegerNumericIds)) {
+            this.fail(malformedEnvelope());
+            return;
+        }
+        const pending = this.pendingRequests.get(id);
+        if (!pending?.writeStarted || pending.responseReceived) {
+            this.emitDiagnostic({ code: 'unmatched_response' });
+            return;
+        }
+        pending.responseReceived = true;
+        const inboundTarget = this.inboundSequence;
+        const settleResponse = () => {
+            this.settlePending(id, (pending) => {
+                if (hasError) {
+                    pending.reject(new JsonRpcRemoteError(envelope['error']));
+                }
+                else {
+                    pending.resolve(envelope['result']);
+                }
+            });
+        };
+        if (!pending.waitForInbound) {
+            settleResponse();
+            return;
+        }
+        void this.waitForInbound(inboundTarget, pending).then(settleResponse, (error) => {
+            this.settlePending(id, (pending) => {
+                pending.reject(asTransportError(error));
+            });
+        });
+    }
+    enqueueInbound(message) {
+        const sequence = ++this.inboundSequence;
+        if (this.inboundQueue.push({ message, sequence }))
+            return;
+        this.fail(transportError('capacity_exceeded', 'The buffered inbound message limit was reached.'));
+    }
+    acknowledgeInbound(sequence) {
+        this.inboundAcknowledgedSequence = sequence;
+        for (const waiter of [...this.inboundBarrierWaiters]) {
+            if (waiter.target > sequence)
+                continue;
+            this.inboundBarrierWaiters.delete(waiter);
+            waiter.resolve();
+        }
+    }
+    waitForInbound(target, pending) {
+        if (target <= this.inboundAcknowledgedSequence)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const waiter = { target, resolve, reject };
+            pending.inboundWaiter = waiter;
+            this.inboundBarrierWaiters.add(waiter);
+        });
+    }
+    settlePending(id, settle) {
+        const pending = this.pendingRequests.get(id);
+        if (!pending)
+            return false;
+        this.pendingRequests.delete(id);
+        if (pending.inboundWaiter) {
+            this.inboundBarrierWaiters.delete(pending.inboundWaiter);
+            pending.inboundWaiter.resolve();
+            delete pending.inboundWaiter;
+        }
+        clearTimeout(pending.timer);
+        if (pending.abortListener) {
+            pending.signal?.removeEventListener('abort', pending.abortListener);
+        }
+        settle(pending);
+        return true;
+    }
+    startPendingWrite(id) {
+        const pending = this.pendingRequests.get(id);
+        if (!pending)
+            return false;
+        pending.writeStarted = true;
+        return true;
+    }
+    allocateRequestId() {
+        const start = this.nextRequestId;
+        do {
+            const candidate = this.nextRequestId;
+            this.nextRequestId =
+                candidate === Number.MAX_SAFE_INTEGER ? 1 : candidate + 1;
+            if (!this.pendingRequests.has(candidate))
+                return candidate;
+        } while (this.nextRequestId !== start);
+        throw transportError('capacity_exceeded', 'No JSON-RPC request identifier is available.');
+    }
+    emitDiagnostic(diagnostic) {
+        try {
+            this.onDiagnostic?.(diagnostic);
+        }
+        catch {
+            // Diagnostic callbacks cannot affect transport lifecycle.
+        }
+    }
+    assertOpen() {
+        if (!this.open) {
+            throw (this.terminalError ??
+                transportError('transport_closed', 'The transport is closed.'));
+        }
+    }
+    fail(error) {
+        if (!this.open)
+            return;
+        this.terminate(error, error);
+    }
+    terminate(inboundFailure, operationFailure) {
+        if (!this.open)
+            return;
+        this.open = false;
+        this.terminalError = operationFailure;
+        this.armTerminalErrorGuards();
+        this.detachStreams();
+        this.lineChunks = [];
+        this.lineBytes = 0;
+        this.pendingInboundRequestIds.clear();
+        this.respondingInboundRequestIds.clear();
+        this.abandoningInboundRequestIds.clear();
+        for (const waiter of this.inboundBarrierWaiters) {
+            waiter.reject(operationFailure);
+        }
+        this.inboundBarrierWaiters.clear();
+        for (const id of [...this.pendingRequests.keys()]) {
+            this.settlePending(id, (pending) => {
+                pending.reject(operationFailure);
+            });
+        }
+        for (const rejectWrite of [...this.activeWriteRejectors]) {
+            rejectWrite(operationFailure);
+        }
+        this.inboundQueue.close(inboundFailure);
+        this.startCleanup();
+    }
+    detachStreams() {
+        this.readable.off('data', this.handleReadableData);
+        this.readable.off('end', this.handleReadableEnd);
+        this.readable.off('error', this.handleStreamError);
+        this.readable.off('close', this.handleStreamClose);
+        this.writable.off('error', this.handleWritableError);
+        this.writable.off('close', this.handleStreamClose);
+    }
+    startCleanup() {
+        this.cleanupPromise ??= Promise.resolve()
+            .then(() => this.cleanup?.())
+            .then(() => undefined)
+            .catch(() => {
+            this.cleanupFailure = transportError('cleanup_failed', 'Transport cleanup failed.');
+        })
+            .then(() => new Promise((resolve) => {
+            scheduleImmediate(resolve);
+        }))
+            .then(() => {
+            this.releaseTerminalErrorGuards();
+        });
+    }
+    armTerminalErrorGuards() {
+        this.terminalGuardStreams.add(this.readable);
+        this.terminalGuardStreams.add(this.writable);
+        for (const stream of this.terminalGuardStreams) {
+            stream.on('error', ignoreTerminalStreamError);
+        }
+    }
+    releaseTerminalErrorGuards() {
+        for (const stream of this.terminalGuardStreams) {
+            stream.off('error', ignoreTerminalStreamError);
+        }
+        this.terminalGuardStreams.clear();
+    }
+}
+function transportError(code, message) {
+    return new JsonRpcTransportError(code, message);
+}
+function asTransportError(error) {
+    return error instanceof JsonRpcTransportError
+        ? error
+        : transportError('invalid_outbound_message', 'The outbound JSON-RPC operation is invalid.');
+}
+function positiveInteger(value) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw transportError('invalid_configuration', 'Transport limits and timeouts must be positive safe integers.');
+    }
+    return value;
+}
+function timerMilliseconds(value) {
+    const timeout = positiveInteger(value);
+    if (timeout > maximumTimerMilliseconds) {
+        throw transportError('invalid_configuration', `Transport timeouts cannot exceed ${String(maximumTimerMilliseconds)} milliseconds.`);
+    }
+    return timeout;
+}
+function assertMethod(method) {
+    if (typeof method !== 'string' || method.length === 0) {
+        throw transportError('invalid_outbound_message', 'A JSON-RPC method must be a non-empty string.');
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function validJsonRpcVersion(value, requireJsonRpcVersion) {
+    return requireJsonRpcVersion
+        ? value['jsonrpc'] === '2.0'
+        : !hasOwn(value, 'jsonrpc') || value['jsonrpc'] === '2.0';
+}
+function isJsonRpcId(value, requireIntegerNumericIds = false) {
+    return (value === null ||
+        typeof value === 'string' ||
+        (typeof value === 'number' &&
+            Number.isFinite(value) &&
+            (!requireIntegerNumericIds || Number.isInteger(value))));
+}
+function requestIdKey(id) {
+    return `${typeof id}:${String(id)}`;
+}
+function isJsonRpcErrorObject(value) {
+    return (isRecord(value) &&
+        typeof value['code'] === 'number' &&
+        Number.isSafeInteger(value['code']) &&
+        typeof value['message'] === 'string');
+}
+function malformedEnvelope() {
+    return transportError('malformed_message', 'An inbound JSON-RPC envelope is malformed.');
+}
+function assertSerializedResponse(frame, expectedIdKey, responseKind, requireIntegerNumericIds) {
+    const value = JSON.parse(frame);
+    if (!isRecord(value) || !isJsonRpcId(value['id'], requireIntegerNumericIds)) {
+        throw invalidSerializedResponse();
+    }
+    const hasError = hasOwn(value, 'error');
+    const hasResult = hasOwn(value, 'result');
+    if (requestIdKey(value['id']) !== expectedIdKey ||
+        hasOwn(value, 'method') ||
+        (responseKind === 'result'
+            ? !hasResult || hasError
+            : hasResult || !hasError || !isJsonRpcErrorObject(value['error']))) {
+        throw invalidSerializedResponse();
+    }
+}
+function invalidSerializedResponse() {
+    return transportError('invalid_outbound_message', 'The serialized JSON-RPC response is invalid.');
+}
+function ignoreTerminalStreamError(_error) {
+    // The first terminal error is already recorded; suppress only errors that
+    // race with that terminal path or its awaited cleanup operation.
+}
+//# sourceMappingURL=index.js.map