@astrale-os/kernel-client 0.6.0-beta.8 → 0.6.0-beta.80

package/dist/transport/failure.js

@@ -0,0 +1,9 @@
+import { TransportError } from '../errors/index.js';
+/** Create invocation transport evidence with the common not-sent default. */
+export function invocationFailure(message, phase, evidence = {}) {
+    return TransportError.invocation(message, {
+        ...evidence,
+        phase,
+        delivery: evidence.delivery ?? 'not-sent',
+    });
+}

package/dist/transport/http/byte-stream.d.ts

@@ -0,0 +1,18 @@
+import type { ControlledSignal } from '../index.js';
+/** Single-consumer HTTP byte stream preserving invocation lifetime and backpressure. */
+export declare class HttpByteStream implements AsyncIterable<Uint8Array> {
+    private readonly maximumBytes;
+    private readonly control;
+    private readonly expectedBytes?;
+    private readonly reader;
+    private claimed;
+    private terminal;
+    private bytes;
+    private interruption;
+    constructor(body: ReadableStream<Uint8Array>, maximumBytes: number, control: ControlledSignal, expectedBytes?: number | undefined);
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+    cancel(reason?: unknown): Promise<void>;
+    private next;
+    private interrupt;
+    private cancelReader;
+}

package/dist/transport/http/byte-stream.js

@@ -0,0 +1,94 @@
+import { ProtocolError } from '../../errors/index.js';
+import { asError } from '../index.js';
+/** Single-consumer HTTP byte stream preserving invocation lifetime and backpressure. */
+export class HttpByteStream {
+    maximumBytes;
+    control;
+    expectedBytes;
+    reader;
+    claimed = false;
+    terminal = false;
+    bytes = 0;
+    interruption;
+    constructor(body, maximumBytes, control, expectedBytes) {
+        this.maximumBytes = maximumBytes;
+        this.control = control;
+        this.expectedBytes = expectedBytes;
+        this.reader = body.getReader();
+        const abort = () => void this.interrupt(control.signal.reason);
+        if (control.signal.aborted)
+            abort();
+        else
+            control.signal.addEventListener('abort', abort, { once: true });
+    }
+    [Symbol.asyncIterator]() {
+        if (this.claimed)
+            throw new TypeError('streaming binary admits exactly one consumer.');
+        this.claimed = true;
+        return {
+            next: () => this.next(),
+            return: async () => {
+                await this.cancel('streaming binary consumer stopped');
+                return { done: true, value: undefined };
+            },
+            throw: async (error) => {
+                await this.cancel('streaming binary consumer failed');
+                throw error;
+            },
+        };
+    }
+    async cancel(reason = 'streaming binary cancelled') {
+        if (this.terminal)
+            return;
+        this.terminal = true;
+        this.control.cancel(reason);
+        await this.cancelReader(reason);
+        this.control.close();
+    }
+    async next() {
+        if (this.interruption !== undefined)
+            throw this.interruption;
+        if (this.terminal)
+            return { done: true, value: undefined };
+        try {
+            const next = await this.reader.read();
+            if (this.interruption !== undefined)
+                throw this.interruption;
+            if (next.done) {
+                if (this.expectedBytes !== undefined && this.bytes !== this.expectedBytes) {
+                    throw new ProtocolError(`streaming binary ended after ${this.bytes} bytes; expected ${this.expectedBytes}.`);
+                }
+                this.terminal = true;
+                this.control.close();
+                return { done: true, value: undefined };
+            }
+            this.bytes += next.value.byteLength;
+            if (this.expectedBytes !== undefined && this.bytes > this.expectedBytes) {
+                throw new ProtocolError(`streaming binary exceeded its declared length (${this.expectedBytes}).`);
+            }
+            if (this.bytes > this.maximumBytes) {
+                throw new ProtocolError(`streaming binary exceeds maximumResponseBytes (${this.maximumBytes}).`);
+            }
+            return { done: false, value: new Uint8Array(next.value) };
+        }
+        catch (error) {
+            await this.cancel(error);
+            throw error;
+        }
+    }
+    async interrupt(reason) {
+        if (this.terminal || this.interruption !== undefined)
+            return;
+        this.interruption = asError(reason ?? new Error('streaming binary was cancelled.'));
+        await this.cancelReader(this.interruption);
+        this.control.close();
+    }
+    async cancelReader(reason) {
+        try {
+            await this.reader.cancel(reason);
+        }
+        catch {
+            // Cancellation follows an already chosen terminal outcome.
+        }
+    }
+}

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

@@ -1,2 +1 @@
 export { HttpTransport, type Fetch, type HttpTransportOptions } from './transport.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/http/index.js

@@ -1,2 +1 @@
 export { HttpTransport } from './transport.js';
-//# sourceMappingURL=index.js.map

package/dist/transport/http/response.d.ts

@@ -6,4 +6,3 @@ export declare function requireId(expected: protocol.RequestId, received: protoc
 export declare function decodeProtocol<T>(label: string, decode: () => T): T;
 export declare function normalizeMediaType(input: string | null): string | undefined;
 export declare function binaryHeaders(input: Headers, names: readonly string[]): Readonly<Record<string, string>>;
-//# sourceMappingURL=response.d.ts.map

package/dist/transport/http/response.js

@@ -77,4 +77,3 @@ export function binaryHeaders(input, names) {
     }
     return Object.freeze(output);
 }
-//# sourceMappingURL=response.js.map

package/dist/transport/http/stream.d.ts

@@ -24,4 +24,3 @@ export declare class HttpStream implements Stream {
     private stop;
     private abortFailure;
 }
-//# sourceMappingURL=stream.d.ts.map

package/dist/transport/http/stream.js

@@ -1,5 +1,6 @@
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { ProtocolError, ResponseError, TransportError } from '../../errors/index.js';
+import { invocationFailure } from '../failure.js';
 import { asError } from '../index.js';
 import { decodeProtocol, requireId } from './response.js';
 export class HttpStream {
@@ -124,9 +125,8 @@ export class HttpStream {
     }
     abortFailure(reason) {
         if (this.control.timedOut) {
-            return new TransportError('stream exceeded its invocation timeout.', {
+            return invocationFailure('stream exceeded its invocation timeout.', 'timeout', {
                 cause: asError(reason),
-                phase: 'timeout',
                 delivery: 'unknown',
                 invocation: this.invocation,
             });
@@ -138,11 +138,12 @@ function retainInvocationId(input, invocation) {
     if (input instanceof ProtocolError && input.invocation === undefined) {
         return new ProtocolError(input.message, { cause: input, invocation });
     }
-    if (input instanceof TransportError && input.invocation === undefined) {
-        return new TransportError(input.message, {
+    if (input instanceof TransportError &&
+        input.context.kind === 'invocation' &&
+        input.context.invocation === undefined) {
+        return invocationFailure(input.message, input.phase, {
             cause: input,
-            phase: input.phase,
-            delivery: input.delivery,
+            delivery: input.context.delivery,
             invocation,
         });
     }
@@ -211,4 +212,3 @@ class LengthPrefixedFrames {
         return output;
     }
 }
-//# sourceMappingURL=stream.js.map

package/dist/transport/http/transport.d.ts

@@ -25,9 +25,11 @@ export declare class HttpTransport implements Transport {
     private nextId;
     constructor(options: HttpTransportOptions);
     dispatch(input: TransportRequest, options?: RequestOptions): Promise<TransportResult>;
+    /** HTTP-only binary invocation; each call may replay a re-readable Blob. */
+    dispatchBinary(input: TransportRequest, body: Blob, options?: RequestOptions): Promise<TransportResult>;
+    private dispatchWith;
     private fetchResponse;
     private decodeBinary;
     private nextRequestId;
     private requestCodec;
 }
-//# sourceMappingURL=transport.d.ts.map

package/dist/transport/http/transport.js

@@ -1,8 +1,11 @@
+import { canonicalMediaType } from '@astrale-os/kernel-protocol/artifact';
 import * as codecs from '@astrale-os/kernel-protocol/codecs';
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { ProtocolError, ResponseError, TransportError } from '../../errors/index.js';
+import { invocationFailure } from '../failure.js';
 import { asError, controlledSignal, positiveInteger, requireLive, } from '../index.js';
-import { binaryHeaders, codecForResponse, decodeProtocol, normalizeMediaType, readBoundedBody, requireId, } from './response.js';
+import { HttpByteStream } from './byte-stream.js';
+import { binaryHeaders, codecForResponse, decodeProtocol, readBoundedBody, requireId, } from './response.js';
 import { HttpStream } from './stream.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAXIMUM_REQUEST_BYTES = 16 * 1024 * 1024;
@@ -30,6 +33,18 @@ export class HttpTransport {
         this.maximumResponseBytes = positiveInteger(options.maximumResponseBytes ?? DEFAULT_MAXIMUM_RESPONSE_BYTES, 'maximumResponseBytes');
     }
     async dispatch(input, options = {}) {
+        return this.dispatchWith(input, options);
+    }
+    /** HTTP-only binary invocation; each call may replay a re-readable Blob. */
+    async dispatchBinary(input, body, options = {}) {
+        if (!(body instanceof Blob))
+            throw new TypeError('Binary request body must be a Blob.');
+        if (options.idempotencyKey !== undefined) {
+            throw new TypeError('Binary requests cannot carry an idempotency key.');
+        }
+        return this.dispatchWith(input, options, body);
+    }
+    async dispatchWith(input, options, binaryBody) {
         const requestId = this.nextRequestId();
         const timeoutMs = positiveInteger(options.timeoutMs ?? this.timeoutMs, 'timeoutMs');
         const codec = await this.requestCodec();
@@ -41,30 +56,37 @@ export class HttpTransport {
             ...invocationInput,
             ...(options.idempotencyKey === undefined ? {} : { idempotencyKey: options.idempotencyKey }),
         });
-        const encoded = codec.encode(request);
+        const encoded = binaryBody === undefined
+            ? codec.encode(request)
+            : protocol.http.encodeBinaryRequestEnvelope(request);
         const control = controlledSignal(options.signal, timeoutMs);
         let handedOff = false;
         let phase = 'connect';
         let delivery = 'not-sent';
         try {
             requireLive(control);
-            if (encodedByteLength(encoded) > this.maximumRequestBytes) {
-                throw new TransportError(`request exceeds maximumRequestBytes (${this.maximumRequestBytes}).`, { phase: 'send', delivery: 'not-sent' });
+            if (binaryBody === undefined && encodedByteLength(encoded) > this.maximumRequestBytes) {
+                throw invocationFailure(`request exceeds maximumRequestBytes (${this.maximumRequestBytes}).`, 'send');
             }
             phase = 'send';
             delivery = 'unknown';
-            const response = await this.fetchResponse(codec, encoded, trace, control);
+            const response = await this.fetchResponse(codec, encoded, trace, control, binaryBody);
             phase = 'receive';
             requireLive(control);
             if (response.status >= 300 && response.status < 400) {
                 throw new ProtocolError('server returned a network redirect.');
             }
-            requireNoStore(response);
             const streamFraming = response.headers.get(protocol.http.STREAM_FRAMING_FIELD);
             const binaryId = response.headers.get(protocol.http.REQUEST_ID_FIELD);
             const binaryManifest = response.headers.get(protocol.http.BINARY_HEADERS_FIELD);
+            const binaryDelivery = response.headers.get(protocol.http.BINARY_DELIVERY_FIELD);
             const hasStreamSignal = streamFraming !== null;
-            const hasBinarySignal = binaryId !== null || binaryManifest !== null;
+            const hasBinarySignal = binaryId !== null || binaryManifest !== null || binaryDelivery !== null;
+            const responseCodec = await codecForResponse(response.headers.get('content-type'));
+            if (!response.ok && responseCodec === undefined && !hasStreamSignal && !hasBinarySignal) {
+                throw invocationFailure(`server returned HTTP ${response.status} without an invocation response.`, 'receive', { delivery: 'unknown' });
+            }
+            requireNoStore(response);
             if (hasStreamSignal && hasBinarySignal) {
                 throw new ProtocolError('server returned conflicting stream and binary response signals.');
             }
@@ -72,9 +94,14 @@ export class HttpTransport {
                 if (binaryId === null || binaryManifest === null) {
                     throw new ProtocolError('server returned an incomplete binary response signal.');
                 }
-                return await this.decodeBinary(response, requestId, binaryId, control);
+                if (binaryDelivery !== null && binaryDelivery !== protocol.http.STREAMING_BINARY_DELIVERY) {
+                    throw new ProtocolError('server returned an unsupported binary delivery signal.');
+                }
+                const binary = await this.decodeBinary(response, requestId, binaryId, binaryDelivery !== null, control);
+                if (!(binary.value.body instanceof Uint8Array))
+                    handedOff = true;
+                return binary;
             }
-            const responseCodec = await codecForResponse(response.headers.get('content-type'));
             if (responseCodec === undefined) {
                 throw new ProtocolError(`server returned unsupported Content-Type ${JSON.stringify(response.headers.get('content-type'))}.`);
             }
@@ -131,45 +158,78 @@ export class HttpTransport {
                 control.close();
         }
     }
-    async fetchResponse(codec, encoded, trace, control) {
-        return this.fetchImpl(this.url, {
+    async fetchResponse(codec, encoded, trace, control, binaryBody) {
+        const init = {
             method: 'POST',
-            redirect: 'error',
+            redirect: 'manual',
             credentials: 'omit',
-            cache: 'no-store',
             referrerPolicy: 'no-referrer',
+            // Fetch owns Content-Length; the protocol carries Blob.size across Fetch runtimes.
             headers: {
                 ...this.headers,
                 ...protocol.http.encodeTraceHeaders(trace),
-                'content-type': codec.contentType,
+                'content-type': binaryBody === undefined ? codec.contentType : protocol.http.BINARY_REQUEST_CONTENT_TYPE,
                 accept: codec.contentType,
+                ...(binaryBody === undefined
+                    ? {}
+                    : {
+                        [protocol.http.REQUEST_ENVELOPE_FIELD]: encoded,
+                        [protocol.http.BINARY_LENGTH_FIELD]: String(binaryBody.size),
+                    }),
             },
-            body: toBody(encoded),
+            body: binaryBody ?? toBody(encoded),
             signal: control.signal,
-        });
+        };
+        return this.fetchImpl(this.url, init);
     }
-    async decodeBinary(response, requestId, binaryId, control) {
-        if (!response.ok) {
-            throw new ProtocolError('server returned binary data with an error status.');
-        }
+    async decodeBinary(response, requestId, binaryId, streaming, control) {
         if (binaryId !== String(requestId)) {
             throw new ProtocolError(`binary response requestId ${JSON.stringify(binaryId)} does not match request requestId ${requestId}.`);
         }
-        const mediaType = normalizeMediaType(response.headers.get('content-type'));
-        if (mediaType === undefined) {
+        const contentType = response.headers.get('content-type');
+        if (contentType === null) {
             throw new ProtocolError('binary response has no media type.');
         }
-        const body = await readBoundedBody(response, this.maximumResponseBytes, control.signal);
-        requireLive(control);
+        const mediaType = decodeProtocol('binary media type', () => canonicalMediaType(contentType));
         const headerNames = decodeProtocol('binary application-header manifest', () => protocol.http.decodeBinaryHeaderNames(response.headers.get(protocol.http.BINARY_HEADERS_FIELD)));
         const headers = binaryHeaders(response.headers, headerNames);
         const invocation = decodeProtocol('binary InvocationId field', () => protocol.http.decodeInvocationId(response.headers.get(protocol.http.INVOCATION_FIELD)));
+        if (streaming) {
+            if (response.body === null)
+                throw new ProtocolError('streaming binary has no body.');
+            // An intermediary may rewrite Content-Length (for example when it compresses the body), so the
+            // protocol length wins; Content-Length only counts for a Server that predates the field.
+            const declared = response.headers.get(protocol.http.BINARY_LENGTH_FIELD);
+            const length = declared ?? response.headers.get('content-length');
+            const expectedBytes = length === null ? undefined : Number(length);
+            if (length !== null &&
+                (!/^(?:0|[1-9][0-9]*)$/u.test(length) || !Number.isSafeInteger(expectedBytes))) {
+                throw new ProtocolError(`streaming binary has an invalid ${declared === null ? 'Content-Length' : protocol.http.BINARY_LENGTH_FIELD}.`);
+            }
+            if (expectedBytes !== undefined && expectedBytes > this.maximumResponseBytes) {
+                throw new ProtocolError(`streaming binary exceeds maximumResponseBytes (${this.maximumResponseBytes}).`);
+            }
+            requireLive(control);
+            return {
+                kind: 'binary',
+                invocation,
+                value: {
+                    body: new HttpByteStream(response.body, this.maximumResponseBytes, control, expectedBytes),
+                    mediaType,
+                    ...(response.status === 200 ? {} : { status: response.status }),
+                    ...(Object.keys(headers).length === 0 ? {} : { headers }),
+                },
+            };
+        }
+        const body = await readBoundedBody(response, this.maximumResponseBytes, control.signal);
+        requireLive(control);
         const binary = decodeProtocol('binary response', () => protocol.decodeBinaryResponse({
             kind: 'binary',
             requestId,
             invocation,
             body,
             mediaType,
+            status: response.status,
             ...(Object.keys(headers).length === 0 ? {} : { headers }),
         }));
         requireLive(control);
@@ -179,6 +239,7 @@ export class HttpTransport {
             value: {
                 body: binary.body,
                 mediaType: binary.mediaType,
+                ...(binary.status === 200 ? {} : { status: binary.status }),
                 ...(binary.headers === undefined ? {} : { headers: binary.headers }),
             },
         };
@@ -265,9 +326,8 @@ function transportFailure(input, control, parent, timeoutMs, url, phase, deliver
     if (input instanceof ResponseError || input instanceof ProtocolError)
         return input;
     if (control.timedOut) {
-        return new TransportError(`request timed out after ${timeoutMs}ms.`, {
+        return invocationFailure(`request timed out after ${timeoutMs}ms.`, 'timeout', {
             cause: asError(input),
-            phase: 'timeout',
             delivery,
         });
     }
@@ -275,9 +335,8 @@ function transportFailure(input, control, parent, timeoutMs, url, phase, deliver
         return asError(parent.reason ?? input);
     return input instanceof TransportError
         ? input
-        : new TransportError(`Failed to communicate with the server at ${url}.`, {
+        : invocationFailure(`Failed to communicate with the server at ${url}.`, phase, {
             cause: asError(input),
-            phase,
             delivery,
         });
 }
@@ -305,7 +364,6 @@ const RESERVED_REQUEST_HEADERS = new Set([
     'content-length',
     'content-type',
     'cookie',
-    'expect',
     'forwarded',
     'host',
     'keep-alive',
@@ -342,4 +400,3 @@ function hasControlCharacter(input) {
     }
     return false;
 }
-//# sourceMappingURL=transport.js.map

package/dist/transport/index.d.ts

@@ -1,3 +1,2 @@
 export type { RequestOptions, MissControl, StaleControl, Transport, TransportRequest, TransportResult, } from './transport.js';
 export { asError, controlledSignal, positiveInteger, requireLive, type ControlledSignal, } from './deadline.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/index.js

@@ -1,2 +1 @@
 export { asError, controlledSignal, positiveInteger, requireLive, } from './deadline.js';
-//# sourceMappingURL=index.js.map

package/dist/transport/transport.d.ts

@@ -32,4 +32,3 @@ export interface Transport {
     /** Optional owned-resource shutdown used by Client.close(). */
     readonly close?: () => void;
 }
-//# sourceMappingURL=transport.d.ts.map

package/dist/transport/transport.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=transport.js.map

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

@@ -36,4 +36,3 @@ export declare class WebSocketConnection implements ExchangeOwner {
     private onMessage;
     private onFailure;
 }
-//# sourceMappingURL=connection.d.ts.map

package/dist/transport/websocket/connection.js

@@ -1,5 +1,6 @@
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
-import { ProtocolError, TransportError } from '../../errors/index.js';
+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;
@@ -63,10 +64,7 @@ export class WebSocketConnection {
     dispatch(request, control, maximumBufferedItems) {
         if (!this.isOpen) {
             control.close();
-            return Promise.reject(new TransportError('WebSocket connection is not available.', {
-                phase: 'connect',
-                delivery: 'not-sent',
-            }));
+            return Promise.reject(invocationFailure('WebSocket connection is not available.', 'connect'));
         }
         const key = requestKey(request.requestId);
         if (this.active.has(key) || this.cancelled.has(key)) {
@@ -75,17 +73,17 @@ export class WebSocketConnection {
         }
         if (this.active.size + this.cancelled.size >= this.maximumActiveInvocations) {
             control.close();
-            return Promise.reject(new TransportError(`WebSocket connection exceeds maximumActiveInvocations (${this.maximumActiveInvocations}).`, { phase: 'send', delivery: 'not-sent' }));
+            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(new TransportError(`WebSocket request exceeds maximumRequestBytes (${this.maximumRequestBytes}).`, { phase: 'send', delivery: 'not-sent' }));
+            return Promise.reject(invocationFailure(`WebSocket request exceeds maximumRequestBytes (${this.maximumRequestBytes}).`, 'send'));
         }
-        if (this.socket.bufferedAmount + encodedBytes > this.maximumBufferedBytes) {
+        if (socketBufferedAmount(this.socket) + encodedBytes > this.maximumBufferedBytes) {
             control.close();
-            return Promise.reject(new TransportError(`WebSocket connection exceeds maximumBufferedBytes (${this.maximumBufferedBytes}).`, { phase: 'send', delivery: 'not-sent' }));
+            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);
@@ -94,10 +92,7 @@ export class WebSocketConnection {
     finish(exchange, reusable, closeCode = 1002) {
         removeExchange(this.active, exchange);
         if (!reusable) {
-            this.shutdown(new TransportError('WebSocket connection was closed after a binding failure.', {
-                phase: 'receive',
-                delivery: 'not-sent',
-            }), closeCode, closeReason(closeCode));
+            this.shutdown(invocationFailure('WebSocket connection was closed after a binding failure.', 'receive'), closeCode, closeReason(closeCode));
         }
     }
     cancel(exchange, requestId) {
@@ -110,23 +105,19 @@ export class WebSocketConnection {
             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) {
+                socketBufferedAmount(this.socket) + 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(new TransportError('Failed to send WebSocket cancellation.', {
+            this.shutdown(invocationFailure('Failed to send WebSocket cancellation.', 'send', {
                 cause: asError(error),
-                phase: 'send',
                 delivery: 'unknown',
             }), error instanceof WebSocketBindingFailure ? error.closeCode : 1011, error instanceof WebSocketBindingFailure ? error.closeReason : 'Client send failed');
         }
     }
-    shutdown(reason = new TransportError('WebSocket connection was closed.', {
-        phase: 'closed',
-        delivery: 'not-sent',
-    }), closeCode = 1000, closeReason = 'Client closed') {
+    shutdown(reason = invocationFailure('WebSocket connection was closed.', 'closed'), closeCode = 1000, closeReason = 'Client closed') {
         if (this.closedState)
             return;
         this.closedState = true;
@@ -151,7 +142,7 @@ export class WebSocketConnection {
             return;
         const expected = protocol.websocket.subprotocolFor(this.codec);
         if (this.socket.protocol !== expected) {
-            this.shutdown(new TransportError(`server selected WebSocket subprotocol ${JSON.stringify(this.socket.protocol)}; expected ${JSON.stringify(expected)}.`, { phase: 'connect', delivery: 'not-sent' }), 1002, 'Subprotocol mismatch');
+            this.shutdown(invocationFailure(`server selected WebSocket subprotocol ${JSON.stringify(this.socket.protocol)}; expected ${JSON.stringify(expected)}.`, 'connect'), 1002, 'Subprotocol mismatch');
             return;
         }
         this.opened = true;
@@ -186,12 +177,12 @@ export class WebSocketConnection {
     onFailure(message) {
         if (this.closedState)
             return;
-        this.shutdown(new TransportError(message, {
-            phase: this.opened ? 'receive' : 'connect',
-            delivery: 'not-sent',
-        }));
+        this.shutdown(invocationFailure(message, this.opened ? 'receive' : 'connect'));
     }
 }
+function socketBufferedAmount(socket) {
+    return socket.bufferedAmount ?? 0;
+}
 async function normalizeFrame(input) {
     if (typeof input === 'string')
         return input;
@@ -294,4 +285,3 @@ function removeExchange(exchanges, exchange) {
         return;
     }
 }
-//# sourceMappingURL=connection.js.map

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

@@ -44,4 +44,3 @@ export declare class WebSocketExchange implements Stream {
     private flushTerminal;
     private abortFailure;
 }
-//# sourceMappingURL=exchange.d.ts.map

package/dist/transport/websocket/exchange.js

@@ -1,5 +1,6 @@
 import * as errors from '@astrale-os/kernel-protocol/errors';
-import { ProtocolError, ResponseError, TransportError } from '../../errors/index.js';
+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 {
@@ -44,10 +45,8 @@ export class WebSocketExchange {
             this.sent = true;
         }
         catch (error) {
-            this.fail(new TransportError('Failed to send the WebSocket invocation.', {
+            this.fail(invocationFailure('Failed to send the WebSocket invocation.', 'send', {
                 cause: asError(error),
-                phase: 'send',
-                delivery: 'not-sent',
             }), 1011);
         }
         return this.result;
@@ -70,9 +69,8 @@ export class WebSocketExchange {
     }
     connectionFailed(error) {
         this.fail(this.sent
-            ? new TransportError(error.message, {
+            ? invocationFailure(error.message, 'receive', {
                 cause: error,
-                phase: 'receive',
                 delivery: 'unknown',
                 ...(this.invocation === undefined ? {} : { invocation: this.invocation }),
             })
@@ -257,9 +255,8 @@ export class WebSocketExchange {
     }
     abortFailure() {
         if (this.control.timedOut) {
-            return new TransportError('WebSocket invocation exceeded its timeout.', {
+            return invocationFailure('WebSocket invocation exceeded its timeout.', 'timeout', {
                 cause: asError(this.control.signal.reason),
-                phase: 'timeout',
                 delivery: this.sent ? 'unknown' : 'not-sent',
                 ...(this.invocation === undefined ? {} : { invocation: this.invocation }),
             });
@@ -301,4 +298,3 @@ function isKind(input, kind) {
         !Array.isArray(input) &&
         input.kind === kind);
 }
-//# sourceMappingURL=exchange.js.map

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

@@ -1,2 +1 @@
 export { WebSocketTransport, type WebSocketConstructor, type WebSocketTransportOptions, } from './transport.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/websocket/index.js

@@ -1,2 +1 @@
 export { WebSocketTransport, } from './transport.js';
-//# sourceMappingURL=index.js.map

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

@@ -44,4 +44,3 @@ export declare class WebSocketTransport implements Transport {
     private nextRequestId;
     private codec;
 }
-//# sourceMappingURL=transport.d.ts.map