@astrale-os/kernel-client 0.5.1 → 0.6.0-beta.10

package/dist/transport/websocket/connection.js

@@ -0,0 +1,284 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { ProtocolError } from '../../errors/index.js';
+import { invocationFailure } from '../failure.js';
+import { asError } from '../index.js';
+import { WebSocketExchange } from './exchange.js';
+const WS_CONNECTING = 0;
+const WS_OPEN = 1;
+export class WebSocketConnection {
+    owner;
+    codec;
+    maximumRequestBytes;
+    maximumResponseBytes;
+    maximumBufferedBytes;
+    maximumActiveInvocations;
+    socket;
+    ready;
+    resolveReady;
+    rejectReady;
+    opened = false;
+    closedState = false;
+    active = new Map();
+    cancelled = new Set();
+    incoming = Promise.resolve();
+    constructor(owner, WebSocketConstructor, url, codec, maximumRequestBytes, maximumResponseBytes, maximumBufferedBytes, maximumActiveInvocations) {
+        this.owner = owner;
+        this.codec = codec;
+        this.maximumRequestBytes = maximumRequestBytes;
+        this.maximumResponseBytes = maximumResponseBytes;
+        this.maximumBufferedBytes = maximumBufferedBytes;
+        this.maximumActiveInvocations = maximumActiveInvocations;
+        this.ready = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = reject;
+        });
+        this.socket = new WebSocketConstructor(url, protocol.websocket.subprotocolFor(codec));
+        this.socket.binaryType = 'arraybuffer';
+        this.socket.addEventListener('open', () => this.onOpen(), { once: true });
+        this.socket.addEventListener('message', (event) => this.onMessage(event));
+        this.socket.addEventListener('error', () => this.onFailure('WebSocket connection failed.'));
+        this.socket.addEventListener('close', () => this.onFailure('WebSocket connection closed.'));
+    }
+    get isOpen() {
+        return !this.closedState && this.opened && this.socket.readyState === WS_OPEN;
+    }
+    get isAvailable() {
+        return !this.closedState;
+    }
+    async connect(control) {
+        if (control.signal.aborted) {
+            throw asError(control.signal.reason);
+        }
+        let abort;
+        const cancelled = new Promise((_resolve, reject) => {
+            abort = () => reject(asError(control.signal.reason));
+            control.signal.addEventListener('abort', abort, { once: true });
+        });
+        try {
+            await Promise.race([this.ready, cancelled]);
+        }
+        finally {
+            control.signal.removeEventListener('abort', abort);
+        }
+    }
+    dispatch(request, control, maximumBufferedItems) {
+        if (!this.isOpen) {
+            control.close();
+            return Promise.reject(invocationFailure('WebSocket connection is not available.', 'connect'));
+        }
+        const key = requestKey(request.requestId);
+        if (this.active.has(key) || this.cancelled.has(key)) {
+            control.close();
+            return Promise.reject(new ProtocolError('WebSocket request ID is already in use.'));
+        }
+        if (this.active.size + this.cancelled.size >= this.maximumActiveInvocations) {
+            control.close();
+            return Promise.reject(invocationFailure(`WebSocket connection exceeds maximumActiveInvocations (${this.maximumActiveInvocations}).`, 'send'));
+        }
+        const encoded = this.codec.encode(request);
+        const encodedBytes = frameSize(encoded);
+        if (encodedBytes > this.maximumRequestBytes) {
+            control.close();
+            return Promise.reject(invocationFailure(`WebSocket request exceeds maximumRequestBytes (${this.maximumRequestBytes}).`, 'send'));
+        }
+        if (this.socket.bufferedAmount + encodedBytes > this.maximumBufferedBytes) {
+            control.close();
+            return Promise.reject(invocationFailure(`WebSocket connection exceeds maximumBufferedBytes (${this.maximumBufferedBytes}).`, 'send'));
+        }
+        const exchange = new WebSocketExchange(this, request.requestId, control, maximumBufferedItems);
+        this.active.set(key, exchange);
+        return exchange.start((data) => this.socket.send(socketData(data)), encoded);
+    }
+    finish(exchange, reusable, closeCode = 1002) {
+        removeExchange(this.active, exchange);
+        if (!reusable) {
+            this.shutdown(invocationFailure('WebSocket connection was closed after a binding failure.', 'receive'), closeCode, closeReason(closeCode));
+        }
+    }
+    cancel(exchange, requestId) {
+        const key = requestKey(requestId);
+        if (this.active.get(key) !== exchange)
+            return;
+        this.active.delete(key);
+        this.cancelled.add(key);
+        try {
+            const encoded = this.codec.encode(protocol.decodeCancelRequest({ version: protocol.VERSION, kind: 'cancel', requestId }));
+            const bytes = frameSize(encoded);
+            if (bytes > this.maximumRequestBytes ||
+                this.socket.bufferedAmount + bytes > this.maximumBufferedBytes) {
+                throw new WebSocketBindingFailure('WebSocket cancellation exceeds the connection send policy.', 1008, 'Client send policy exceeded');
+            }
+            this.socket.send(socketData(encoded));
+        }
+        catch (error) {
+            this.shutdown(invocationFailure('Failed to send WebSocket cancellation.', 'send', {
+                cause: asError(error),
+                delivery: 'unknown',
+            }), error instanceof WebSocketBindingFailure ? error.closeCode : 1011, error instanceof WebSocketBindingFailure ? error.closeReason : 'Client send failed');
+        }
+    }
+    shutdown(reason = invocationFailure('WebSocket connection was closed.', 'closed'), closeCode = 1000, closeReason = 'Client closed') {
+        if (this.closedState)
+            return;
+        this.closedState = true;
+        this.rejectReady(reason);
+        const active = [...this.active.values()];
+        this.active.clear();
+        this.cancelled.clear();
+        for (const exchange of active)
+            exchange.connectionFailed(reason);
+        try {
+            if (this.socket.readyState === WS_CONNECTING || this.socket.readyState === WS_OPEN) {
+                this.socket.close(closeCode, closeReason);
+            }
+        }
+        catch {
+            // The platform already owns a broken socket.
+        }
+        this.owner.closed(this);
+    }
+    onOpen() {
+        if (this.closedState)
+            return;
+        const expected = protocol.websocket.subprotocolFor(this.codec);
+        if (this.socket.protocol !== expected) {
+            this.shutdown(invocationFailure(`server selected WebSocket subprotocol ${JSON.stringify(this.socket.protocol)}; expected ${JSON.stringify(expected)}.`, 'connect'), 1002, 'Subprotocol mismatch');
+            return;
+        }
+        this.opened = true;
+        this.resolveReady();
+    }
+    onMessage(event) {
+        this.incoming = this.incoming
+            .then(async () => {
+            const frame = await normalizeFrame(event.data);
+            if (frameSize(frame) > this.maximumResponseBytes) {
+                throw new WebSocketBindingFailure(`WebSocket frame exceeds maximumResponseBytes (${this.maximumResponseBytes}).`, 1009, 'Message too big');
+            }
+            const admitted = decodeFrame(this.codec, frame);
+            const key = requestKey(admitted.requestId);
+            const exchange = this.active.get(key);
+            if (exchange !== undefined) {
+                exchange.receive(admitted);
+                return;
+            }
+            if (this.cancelled.has(key)) {
+                if (isTerminal(admitted))
+                    this.cancelled.delete(key);
+                return;
+            }
+            throw new ProtocolError('server sent an unsolicited WebSocket frame.');
+        })
+            .catch((error) => {
+            const failure = bindingFailure(error);
+            this.shutdown(failure, failure.closeCode, failure.closeReason);
+        });
+    }
+    onFailure(message) {
+        if (this.closedState)
+            return;
+        this.shutdown(invocationFailure(message, this.opened ? 'receive' : 'connect'));
+    }
+}
+async function normalizeFrame(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input instanceof ArrayBuffer)
+        return new Uint8Array(input.slice(0));
+    if (ArrayBuffer.isView(input)) {
+        return new Uint8Array(input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength));
+    }
+    if (typeof Blob !== 'undefined' && input instanceof Blob) {
+        return new Uint8Array(await input.arrayBuffer());
+    }
+    throw new ProtocolError('server returned an unsupported WebSocket frame type.');
+}
+function frameSize(input) {
+    return typeof input === 'string' ? new TextEncoder().encode(input).byteLength : input.byteLength;
+}
+function socketData(input) {
+    if (typeof input === 'string')
+        return input;
+    const copy = new Uint8Array(input);
+    return copy.buffer;
+}
+function decodeFrame(codec, input) {
+    try {
+        const binary = typeof input === 'string' ? undefined : protocol.websocket.decodeBinary(input);
+        if (binary !== undefined)
+            return binary;
+        if ((codec.binary && typeof input === 'string') ||
+            (!codec.binary && typeof input !== 'string')) {
+            throw new WebSocketBindingFailure('server returned a message type incompatible with the selected subprotocol.', 1003, 'Unsupported message type');
+        }
+        const decoded = codec.decode(input);
+        if (isKind(decoded, 'redirect'))
+            return protocol.decodeRedirectResponse(decoded);
+        if (isKind(decoded, 'stale'))
+            return protocol.decodeStale(decoded);
+        if (isKind(decoded, 'miss'))
+            return protocol.decodeMiss(decoded);
+        if (isStreamFrame(decoded))
+            return protocol.decodeStreamFrame(decoded);
+        return protocol.decodeResponse(decoded);
+    }
+    catch (error) {
+        if (error instanceof WebSocketBindingFailure)
+            throw error;
+        throw new ProtocolError('server returned an invalid WebSocket frame.', {
+            cause: asError(error),
+        });
+    }
+}
+class WebSocketBindingFailure extends ProtocolError {
+    closeCode;
+    closeReason;
+    constructor(message, closeCode, closeReason) {
+        super(message);
+        this.closeCode = closeCode;
+        this.closeReason = closeReason;
+    }
+}
+function bindingFailure(input) {
+    if (input instanceof WebSocketBindingFailure)
+        return input;
+    const error = input instanceof ProtocolError
+        ? input
+        : new ProtocolError('server returned an invalid WebSocket frame.', {
+            cause: asError(input),
+        });
+    return new WebSocketBindingFailure(error.message, 1002, 'Protocol error');
+}
+function closeReason(code) {
+    if (code === 1008)
+        return 'Client policy exceeded';
+    if (code === 1011)
+        return 'Client send failed';
+    return 'Protocol error';
+}
+function isTerminal(input) {
+    return !isKind(input, 'stream.start') && !isKind(input, 'stream.item');
+}
+function isStreamFrame(input) {
+    const kind = typeof input === 'object' && input !== null && !Array.isArray(input)
+        ? input.kind
+        : undefined;
+    return typeof kind === 'string' && kind.startsWith('stream.');
+}
+function isKind(input, kind) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        !Array.isArray(input) &&
+        input.kind === kind);
+}
+function requestKey(requestId) {
+    return requestId === null ? 'null:' : `${typeof requestId}:${String(requestId)}`;
+}
+function removeExchange(exchanges, exchange) {
+    for (const [key, active] of exchanges) {
+        if (active !== exchange)
+            continue;
+        exchanges.delete(key);
+        return;
+    }
+}

package/dist/transport/websocket/exchange.d.ts

@@ -0,0 +1,46 @@
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
+import type { Stream } from '../../client/index.js';
+import type { ControlledSignal } from '../index.js';
+import type { TransportResult } from '../index.js';
+export interface ExchangeOwner {
+    finish(exchange: WebSocketExchange, reusable: boolean, closeCode?: 1002 | 1008 | 1011): void;
+    cancel(exchange: WebSocketExchange, requestId: protocol.RequestId): void;
+}
+export type WebSocketInbound = protocol.BinaryResponse | protocol.RedirectResponse | protocol.Stale | protocol.Miss | protocol.Response | protocol.StreamFrame;
+/** One correlated invocation within a multiplexed WebSocket connection. */
+export declare class WebSocketExchange implements Stream {
+    private readonly owner;
+    private readonly requestId;
+    private readonly control;
+    private readonly maximumBufferedItems;
+    private readonly result;
+    private resolveResult;
+    private rejectResult;
+    private readonly abort;
+    private state;
+    private claimed;
+    private index;
+    private readonly values;
+    private readonly waiters;
+    private terminal;
+    private sent;
+    private invocation?;
+    constructor(owner: ExchangeOwner, requestId: protocol.RequestId, control: ControlledSignal, maximumBufferedItems: number);
+    start(send: (data: string | Uint8Array) => void, encoded: string | Uint8Array): Promise<TransportResult>;
+    receive(input: WebSocketInbound): void;
+    connectionFailed(error: Error): void;
+    [Symbol.asyncIterator](): AsyncIterator<Value>;
+    cancel(_reason?: string): Promise<void>;
+    private receiveResponse;
+    private receiveStreamFrame;
+    private next;
+    private complete;
+    private reject;
+    private fail;
+    private cancelLocally;
+    private finish;
+    private finishCancelled;
+    private flushTerminal;
+    private abortFailure;
+}

package/dist/transport/websocket/exchange.js

@@ -0,0 +1,300 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import { ProtocolError, ResponseError } from '../../errors/index.js';
+import { invocationFailure } from '../failure.js';
+import { asError } from '../index.js';
+/** One correlated invocation within a multiplexed WebSocket connection. */
+export class WebSocketExchange {
+    owner;
+    requestId;
+    control;
+    maximumBufferedItems;
+    result;
+    resolveResult;
+    rejectResult;
+    abort;
+    state = 'response';
+    claimed = false;
+    index = 0;
+    values = [];
+    waiters = [];
+    terminal;
+    sent = false;
+    invocation;
+    constructor(owner, requestId, control, maximumBufferedItems) {
+        this.owner = owner;
+        this.requestId = requestId;
+        this.control = control;
+        this.maximumBufferedItems = maximumBufferedItems;
+        this.result = new Promise((resolve, reject) => {
+            this.resolveResult = resolve;
+            this.rejectResult = reject;
+        });
+        this.abort = () => this.cancelLocally(this.abortFailure());
+        if (!control.signal.aborted)
+            control.signal.addEventListener('abort', this.abort, { once: true });
+    }
+    start(send, encoded) {
+        if (this.state === 'finished')
+            return this.result;
+        if (this.control.signal.aborted) {
+            this.abort();
+            return this.result;
+        }
+        try {
+            send(encoded);
+            this.sent = true;
+        }
+        catch (error) {
+            this.fail(invocationFailure('Failed to send the WebSocket invocation.', 'send', {
+                cause: asError(error),
+            }), 1011);
+        }
+        return this.result;
+    }
+    receive(input) {
+        try {
+            if (this.state === 'response') {
+                this.receiveResponse(input);
+                return;
+            }
+            if (this.state !== 'stream' || isKind(input, 'binary')) {
+                throw new ProtocolError('server sent an unexpected WebSocket response.');
+            }
+            this.receiveStreamFrame(input);
+        }
+        catch (error) {
+            const failure = protocolFailure(error, this.invocation);
+            this.fail(failure, failure instanceof WebSocketPolicyError ? 1008 : 1002);
+        }
+    }
+    connectionFailed(error) {
+        this.fail(this.sent
+            ? invocationFailure(error.message, 'receive', {
+                cause: error,
+                delivery: 'unknown',
+                ...(this.invocation === undefined ? {} : { invocation: this.invocation }),
+            })
+            : error);
+    }
+    [Symbol.asyncIterator]() {
+        if (this.claimed)
+            throw new TypeError('streams admit exactly one consumer.');
+        this.claimed = true;
+        return {
+            next: () => this.next(),
+            return: async () => {
+                await this.cancel('stream consumer stopped');
+                return { done: true, value: undefined };
+            },
+            throw: async (error) => {
+                await this.cancel('stream consumer failed');
+                throw error;
+            },
+        };
+    }
+    async cancel(_reason = 'stream cancelled') {
+        if (this.state === 'finished')
+            return;
+        this.values.length = 0;
+        this.terminal = true;
+        this.finishCancelled();
+        this.flushTerminal();
+    }
+    receiveResponse(input) {
+        if (isKind(input, 'binary')) {
+            const binary = input;
+            requireId(this.requestId, binary.requestId);
+            this.complete({
+                kind: 'binary',
+                invocation: binary.invocation,
+                value: {
+                    body: binary.body,
+                    mediaType: binary.mediaType,
+                    ...(binary.headers === undefined ? {} : { headers: binary.headers }),
+                },
+            });
+            return;
+        }
+        if (isKind(input, 'stream.start')) {
+            const start = input;
+            requireId(this.requestId, start.requestId);
+            if (start.kind !== 'stream.start')
+                throw new ProtocolError('stream did not begin with stream.start.');
+            this.state = 'stream';
+            this.invocation = start.invocation;
+            this.resolveResult({ kind: 'stream', stream: this, invocation: start.invocation });
+            return;
+        }
+        if (isKind(input, 'redirect')) {
+            const response = input;
+            requireId(this.requestId, response.requestId);
+            this.complete({
+                kind: 'redirect',
+                invocation: response.invocation,
+                redirect: response.redirect,
+            });
+            return;
+        }
+        if (isKind(input, 'stale')) {
+            const stale = input;
+            requireId(this.requestId, stale.requestId);
+            this.complete(Object.freeze({ kind: 'stale', current: stale.current, invocation: stale.invocation }));
+            return;
+        }
+        if (isKind(input, 'miss')) {
+            const miss = input;
+            requireId(this.requestId, miss.requestId);
+            this.complete(Object.freeze({ kind: 'miss', invocation: miss.invocation }));
+            return;
+        }
+        const response = input;
+        requireId(this.requestId, response.requestId);
+        if ('error' in response) {
+            this.reject(new ResponseError(response.error.code, response.error.message, response.invocation, response.error.data));
+            return;
+        }
+        this.complete({ kind: 'value', value: response.result, invocation: response.invocation });
+    }
+    receiveStreamFrame(frame) {
+        requireId(this.requestId, frame.requestId);
+        if (frame.kind === 'stream.start') {
+            throw new ProtocolError('server sent a duplicate stream.start frame.');
+        }
+        if (frame.kind === 'stream.item') {
+            if (frame.index !== this.index) {
+                throw new ProtocolError(`stream item ${frame.index} does not match expected index ${this.index}.`);
+            }
+            this.index += 1;
+            const waiter = this.waiters.shift();
+            if (waiter !== undefined)
+                waiter.resolve({ done: false, value: frame.value });
+            else {
+                if (this.values.length >= this.maximumBufferedItems) {
+                    throw new WebSocketPolicyError(`stream exceeds maximumBufferedStreamItems (${this.maximumBufferedItems}).`);
+                }
+                this.values.push(frame.value);
+            }
+            return;
+        }
+        if (frame.kind === 'stream.end' && frame.count !== this.index) {
+            throw new ProtocolError(`stream ended with count ${frame.count}; ${this.index} items were received.`);
+        }
+        this.terminal =
+            frame.kind === 'stream.error'
+                ? new ResponseError(frame.error.code, frame.error.message, this.invocation, frame.error.data)
+                : true;
+        this.finish(true);
+        this.flushTerminal();
+    }
+    next() {
+        const value = this.values.shift();
+        if (value !== undefined)
+            return Promise.resolve({ done: false, value });
+        if (this.terminal === true)
+            return Promise.resolve({ done: true, value: undefined });
+        if (this.terminal instanceof Error)
+            return Promise.reject(this.terminal);
+        return new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+    }
+    complete(result) {
+        this.finish(true);
+        this.resolveResult(result);
+    }
+    reject(error) {
+        this.finish(true);
+        this.rejectResult(error);
+    }
+    fail(error, closeCode = 1002) {
+        if (this.state === 'finished')
+            return;
+        if (this.state === 'response')
+            this.rejectResult(error);
+        else {
+            this.terminal = error;
+            this.flushTerminal();
+        }
+        this.finish(false, closeCode);
+    }
+    cancelLocally(error) {
+        if (this.state === 'finished')
+            return;
+        if (this.state === 'response')
+            this.rejectResult(error);
+        else {
+            this.values.length = 0;
+            this.terminal = error;
+            this.flushTerminal();
+        }
+        this.finishCancelled();
+    }
+    finish(reusable, closeCode) {
+        if (this.state === 'finished')
+            return;
+        this.state = 'finished';
+        this.control.signal.removeEventListener('abort', this.abort);
+        this.control.close();
+        this.owner.finish(this, reusable, closeCode);
+    }
+    finishCancelled() {
+        if (this.state === 'finished')
+            return;
+        this.state = 'finished';
+        this.control.signal.removeEventListener('abort', this.abort);
+        this.control.close();
+        this.owner.cancel(this, this.requestId);
+    }
+    flushTerminal() {
+        if (this.terminal === undefined)
+            return;
+        for (const waiter of this.waiters.splice(0)) {
+            if (this.terminal === true)
+                waiter.resolve({ done: true, value: undefined });
+            else
+                waiter.reject(this.terminal);
+        }
+    }
+    abortFailure() {
+        if (this.control.timedOut) {
+            return invocationFailure('WebSocket invocation exceeded its timeout.', 'timeout', {
+                cause: asError(this.control.signal.reason),
+                delivery: this.sent ? 'unknown' : 'not-sent',
+                ...(this.invocation === undefined ? {} : { invocation: this.invocation }),
+            });
+        }
+        return asError(this.control.signal.reason ?? new Error('WebSocket invocation was cancelled.'));
+    }
+}
+class WebSocketPolicyError extends ProtocolError {
+}
+function protocolFailure(input, invocation) {
+    if (input instanceof ResponseError)
+        return input;
+    if (input instanceof WebSocketPolicyError) {
+        return input.invocation !== undefined || invocation === undefined
+            ? input
+            : new WebSocketPolicyError(input.message, { cause: input, invocation });
+    }
+    if (input instanceof ProtocolError) {
+        return input.invocation !== undefined || invocation === undefined
+            ? input
+            : new ProtocolError(input.message, { cause: input, invocation });
+    }
+    if (input instanceof errors.ProtocolError) {
+        return new ProtocolError(input.message, { cause: input, invocation });
+    }
+    return new ProtocolError('server returned an invalid WebSocket frame.', {
+        cause: asError(input),
+        invocation,
+    });
+}
+function requireId(expected, received) {
+    if (received !== expected) {
+        throw new ProtocolError(`response requestId ${JSON.stringify(received)} does not match request requestId ${JSON.stringify(expected)}.`);
+    }
+}
+function isKind(input, kind) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        !Array.isArray(input) &&
+        input.kind === kind);
+}

package/dist/transport/websocket/index.d.ts

@@ -0,0 +1 @@
+export { WebSocketTransport, type WebSocketConstructor, type WebSocketTransportOptions, } from './transport.js';

package/dist/transport/websocket/index.js

@@ -0,0 +1 @@
+export { WebSocketTransport, } from './transport.js';

package/dist/transport/websocket/transport.d.ts

@@ -0,0 +1,46 @@
+import type { RequestOptions, Transport, TransportRequest, TransportResult } from '../index.js';
+/** Web-compatible WebSocket constructor used by the built-in WebSocket transport. */
+export type WebSocketConstructor = new (url: string | URL, protocols?: string | string[]) => WebSocket;
+export interface WebSocketTransportOptions {
+    readonly url: string;
+    readonly codec?: 'json' | 'msgpack';
+    /** Inject this capability when the host does not provide a global WebSocket. */
+    readonly websocket?: WebSocketConstructor;
+    readonly timeoutMs?: number;
+    /** Maximum bytes in one encoded request or cancellation before send. */
+    readonly maximumRequestBytes?: number;
+    /** Maximum unary, binary, or individual stream-frame body size. */
+    readonly maximumResponseBytes?: number;
+    /** Maximum socket bufferedAmount plus the next encoded message. */
+    readonly maximumBufferedBytes?: number;
+    /** Maximum active correlated invocations on one connection. */
+    readonly maximumActiveInvocations?: number;
+    /** Maximum decoded items retained while a stream consumer is slower than the socket. */
+    readonly maximumBufferedStreamItems?: number;
+}
+/** WebSocket implementation of the universal invocation protocol. */
+export declare class WebSocketTransport implements Transport {
+    readonly url: string;
+    private readonly connectionUrl;
+    private readonly codecName;
+    private readonly WebSocketConstructor;
+    private readonly timeoutMs;
+    private readonly maximumRequestBytes;
+    private readonly maximumResponseBytes;
+    private readonly maximumBufferedBytes;
+    private readonly maximumActiveInvocations;
+    private readonly maximumBufferedStreamItems;
+    private readonly connections;
+    private readonly connectionOwner;
+    private connection;
+    private stopped;
+    private nextId;
+    constructor(options: WebSocketTransportOptions);
+    dispatch(input: TransportRequest, options?: RequestOptions): Promise<TransportResult>;
+    /** Close the multiplexed connection, reject active exchanges, and reject future dispatches. */
+    close(): void;
+    private connectionClosed;
+    private acquire;
+    private nextRequestId;
+    private codec;
+}