@astrale-os/kernel-client 0.6.0-beta.6 → 0.6.0-beta.61

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

@@ -0,0 +1,86 @@
+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;
+    reader;
+    claimed = false;
+    terminal = false;
+    bytes = 0;
+    interruption;
+    constructor(body, maximumBytes, control) {
+        this.maximumBytes = maximumBytes;
+        this.control = control;
+        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) {
+                this.terminal = true;
+                this.control.close();
+                return { done: true, value: undefined };
+            }
+            this.bytes += next.value.byteLength;
+            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

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

package/dist/transport/http/transport.js

@@ -1,7 +1,9 @@
 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 { HttpByteStream } from './byte-stream.js';
 import { binaryHeaders, codecForResponse, decodeProtocol, normalizeMediaType, readBoundedBody, requireId, } from './response.js';
 import { HttpStream } from './stream.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -49,7 +51,7 @@ export class HttpTransport {
         try {
             requireLive(control);
             if (encodedByteLength(encoded) > this.maximumRequestBytes) {
-                throw new TransportError(`request exceeds maximumRequestBytes (${this.maximumRequestBytes}).`, { phase: 'send', delivery: 'not-sent' });
+                throw invocationFailure(`request exceeds maximumRequestBytes (${this.maximumRequestBytes}).`, 'send');
             }
             phase = 'send';
             delivery = 'unknown';
@@ -59,12 +61,17 @@ export class HttpTransport {
             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 +79,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'))}.`);
             }
@@ -132,9 +144,9 @@ export class HttpTransport {
         }
     }
     async fetchResponse(codec, encoded, trace, control) {
-        return this.fetchImpl(this.url, {
+        const init = {
             method: 'POST',
-            redirect: 'error',
+            redirect: 'manual',
             credentials: 'omit',
             cache: 'no-store',
             referrerPolicy: 'no-referrer',
@@ -146,12 +158,10 @@ export class HttpTransport {
             },
             body: 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}.`);
         }
@@ -159,17 +169,33 @@ export class HttpTransport {
         if (mediaType === undefined) {
             throw new ProtocolError('binary response has no media type.');
         }
-        const body = await readBoundedBody(response, this.maximumResponseBytes, control.signal);
-        requireLive(control);
         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.');
+            requireLive(control);
+            return {
+                kind: 'binary',
+                invocation,
+                value: {
+                    body: new HttpByteStream(response.body, this.maximumResponseBytes, control),
+                    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 +205,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 +292,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 +301,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 +330,6 @@ const RESERVED_REQUEST_HEADERS = new Set([
     'content-length',
     'content-type',
     'cookie',
-    'expect',
     'forwarded',
     'host',
     'keep-alive',
@@ -342,4 +366,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

package/dist/transport/websocket/transport.js

@@ -1,6 +1,7 @@
 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 { WebSocketConnection } from './connection.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -45,18 +46,12 @@ export class WebSocketTransport {
     }
     async dispatch(input, options = {}) {
         if (this.stopped) {
-            throw new TransportError('WebSocketTransport is closed.', {
-                phase: 'closed',
-                delivery: 'not-sent',
-            });
+            throw invocationFailure('WebSocketTransport is closed.', 'closed');
         }
         const timeoutMs = positiveInteger(options.timeoutMs ?? this.timeoutMs, 'timeoutMs');
         const codec = await this.codec();
         if (this.stopped) {
-            throw new TransportError('WebSocketTransport is closed.', {
-                phase: 'closed',
-                delivery: 'not-sent',
-            });
+            throw invocationFailure('WebSocketTransport is closed.', 'closed');
         }
         const request = protocol.decodeRequest({
             version: protocol.VERSION,
@@ -87,10 +82,7 @@ export class WebSocketTransport {
             return;
         this.stopped = true;
         this.connection = undefined;
-        const failure = new TransportError('WebSocketTransport is closed.', {
-            phase: 'closed',
-            delivery: 'not-sent',
-        });
+        const failure = invocationFailure('WebSocketTransport is closed.', 'closed');
         for (const connection of this.connections)
             connection.shutdown(failure);
     }
@@ -148,7 +140,7 @@ function admitCodecName(input) {
     throw new TypeError('codec must be "json" or "msgpack".');
 }
 function admitWebSocket(input) {
-    const implementation = input ?? globalThis.WebSocket;
+    const implementation = input ?? (typeof WebSocket === 'undefined' ? undefined : WebSocket);
     if (typeof implementation !== 'function') {
         throw new TypeError('WebSocketTransport requires a WebSocket implementation.');
     }
@@ -160,18 +152,13 @@ function transportFailure(input, control, parent, timeoutMs, url) {
     if (input instanceof TransportError)
         return input;
     if (control.timedOut) {
-        return new TransportError(`WebSocket invocation timed out after ${timeoutMs}ms.`, {
+        return invocationFailure(`WebSocket invocation timed out after ${timeoutMs}ms.`, 'timeout', {
             cause: asError(input),
-            phase: 'timeout',
-            delivery: 'not-sent',
         });
     }
     if (parent?.aborted)
         return asError(parent.reason ?? input);
-    return new TransportError(`Failed to communicate with the server at ${url}.`, {
+    return invocationFailure(`Failed to communicate with the server at ${url}.`, 'connect', {
         cause: asError(input),
-        phase: 'connect',
-        delivery: 'not-sent',
     });
 }
-//# sourceMappingURL=transport.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-client",
-  "version": "0.6.0-beta.6",
+  "version": "0.6.0-beta.61",
   "description": "Universal Client — protocol-first, transport-agnostic",
   "keywords": [
     "astrale",
@@ -65,31 +65,29 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": ">=0.9.0-beta.6 <1.0.0",
-    "@astrale-os/kernel-dsl": ">=0.2.0-beta.5 <1.0.0",
-    "@astrale-os/kernel-protocol": ">=0.5.0-beta.5 <1.0.0",
+    "@astrale-os/kernel-core": "0.9.0-beta.46",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.33",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.52",
     "@tanstack/pacer": "0.20.1",
-    "msgpackr": "^1.11.0"
+    "msgpackr": "^2.0.5"
   },
   "devDependencies": {
+    "@astrale-os/kernel-server": "0.5.0-beta.54",
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
     "@types/node": "^22.0.0",
-    "@typescript/native-preview": "latest",
-    "typescript": "~6.0.1-rc",
-    "vitest": "^3.1.4",
-    "@astrale-os/kernel-server": "^0.5.0-beta.6"
+    "typescript": "7.0.2",
+    "vitest": "^4.1.10"
   },
   "scripts": {
-    "build": "tsgo",
-    "dev": "tsgo --watch",
-    "typecheck": "tsgo --noEmit",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:boundary:protocol": "vitest run --config vitest.protocol-boundary.config.ts",
     "test:boundary:server": "vitest run --config vitest.server-boundary.config.ts",
     "test:file": "vitest run",
     "test:package": "node scripts/verify-packed-package.mjs",
     "test:watch": "vitest",
-    "clean": "rm -rf dist",
-    "preinstall": "node -e \"try{require('./.check-workspace.cjs')}catch{}\""
+    "clean": "rm -rf dist"
   }
 }

package/dist/auth/auth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../auth/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EAChB,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAE5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAO/C,MAAM,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,KAAK,CAAC,CAAA;AAEnG,MAAM,WAAW,OAAO;IACtB,SAAS,CAAC,KAAK,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IACtF,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IACnD,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;IAC5E,GAAG,CAAC,KAAK,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3E,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;IAC7E,QAAQ,CACN,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,eAAe,EACtB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAC7B;AAED,0FAA0F;AAC1F,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAQlD"}