@astrale-os/kernel-client 0.6.0-beta.1 → 0.6.0-beta.11

package/dist/transport/auto/fallback.js

@@ -1,4 +1,5 @@
 import { TransportError } from '../../errors/index.js';
+import { invocationFailure } from '../failure.js';
 import { positiveInteger } from '../index.js';
 const MAXIMUM_TIMEOUT_MS = 2_147_483_647;
 /** One invocation-owned total timeout budget shared by selection and fallback. */
@@ -33,10 +34,7 @@ export class InvocationBudget {
         let timer;
         let abort;
         const interrupted = new Promise((_resolve, reject) => {
-            timer = setTimeout(() => reject(new TransportError('Automatic transport decision exceeded its timeout.', {
-                phase: 'timeout',
-                delivery: 'not-sent',
-            })), remaining);
+            timer = setTimeout(() => reject(invocationFailure('Automatic transport decision exceeded its timeout.', 'timeout')), remaining);
             if (this.input?.signal) {
                 abort = () => reject(abortReason(this.input.signal));
                 this.input.signal.addEventListener('abort', abort, { once: true });
@@ -55,16 +53,17 @@ export class InvocationBudget {
     remaining() {
         const remaining = Math.min(MAXIMUM_TIMEOUT_MS, this.timeoutMs - (Date.now() - this.started));
         if (remaining < 1) {
-            throw new TransportError('Automatic transport invocation exceeded its timeout.', {
-                phase: 'timeout',
-                delivery: 'not-sent',
-            });
+            throw invocationFailure('Automatic transport invocation exceeded its timeout.', 'timeout');
         }
         return remaining;
     }
 }
 export function mayFallback(error) {
-    return error instanceof TransportError && error.phase !== 'closed' && error.phase !== 'timeout';
+    return (error instanceof TransportError &&
+        error.context.kind === 'invocation' &&
+        error.context.delivery === 'not-sent' &&
+        error.phase !== 'closed' &&
+        error.phase !== 'timeout');
 }
 export function warningTarget(input) {
     return input.call.target;
@@ -74,4 +73,3 @@ function abortReason(signal) {
         ? signal.reason
         : new Error(signal.reason === undefined ? 'request was cancelled' : String(signal.reason));
 }
-//# sourceMappingURL=fallback.js.map

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

@@ -1,3 +1,2 @@
 export { AutoTransport, type AutoTransportOptions } from './transport.js';
 export { formatClientWarning, type ClientWarning } from './warning.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/auto/index.js

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

package/dist/transport/auto/transport.d.ts

@@ -35,4 +35,3 @@ export declare class AutoTransport implements Transport {
     private tryWebsocket;
     private requireOpen;
 }
-//# sourceMappingURL=transport.d.ts.map

package/dist/transport/auto/transport.js

@@ -1,4 +1,5 @@
 import { TransportError } from '../../errors/index.js';
+import { invocationFailure } from '../failure.js';
 import { HttpTransport } from '../http/index.js';
 import { positiveInteger } from '../index.js';
 import { WebSocketTransport } from '../websocket/index.js';
@@ -104,7 +105,9 @@ export class AutoTransport {
                     this.decision.release();
                 throw error;
             }
-            if (error instanceof TransportError && error.delivery === 'unknown') {
+            if (error instanceof TransportError &&
+                error.context.kind === 'invocation' &&
+                error.context.delivery === 'unknown') {
                 this.decision.demote();
                 throw error;
             }
@@ -132,10 +135,6 @@ export class AutoTransport {
     requireOpen() {
         if (!this.closed)
             return;
-        throw new TransportError('AutoTransport is closed.', {
-            phase: 'closed',
-            delivery: 'not-sent',
-        });
+        throw invocationFailure('AutoTransport is closed.', 'closed');
     }
 }
-//# sourceMappingURL=transport.js.map

package/dist/transport/auto/warning.d.ts

@@ -11,4 +11,3 @@ export interface ClientWarning {
 }
 export declare function formatClientWarning(warning: ClientWarning): string;
 export declare function emitWarning(warning: ClientWarning, observer: ((warning: ClientWarning) => void) | undefined): void;
-//# sourceMappingURL=warning.d.ts.map

package/dist/transport/auto/warning.js

@@ -16,4 +16,3 @@ export function emitWarning(warning, observer) {
         // Warning observation cannot change invocation settlement.
     }
 }
-//# sourceMappingURL=warning.js.map

package/dist/transport/deadline.d.ts

@@ -9,4 +9,3 @@ export declare function controlledSignal(parent: AbortSignal | undefined, timeou
 export declare function positiveInteger(input: number, label: string): number;
 export declare function requireLive(control: ControlledSignal): void;
 export declare function asError(value: unknown): Error;
-//# sourceMappingURL=deadline.d.ts.map

package/dist/transport/deadline.js

@@ -37,4 +37,3 @@ export function requireLive(control) {
 export function asError(value) {
     return value instanceof Error ? value : new Error(String(value));
 }
-//# sourceMappingURL=deadline.js.map

package/dist/transport/failure.d.ts

@@ -0,0 +1,7 @@
+import { TransportError, type InvocationTransportErrorOptions } from '../errors/index.js';
+type InvocationFailureEvidence = Omit<InvocationTransportErrorOptions, 'delivery' | 'phase'> & {
+    readonly delivery?: InvocationTransportErrorOptions['delivery'];
+};
+/** Create invocation transport evidence with the common not-sent default. */
+export declare function invocationFailure(message: string, phase: InvocationTransportErrorOptions['phase'], evidence?: InvocationFailureEvidence): TransportError;
+export {};

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/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

@@ -1,8 +1,8 @@
-import { codecs, invocation as protocol } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
 export declare function codecForResponse(contentType: string | null): Promise<codecs.Codec | undefined>;
 export declare function readBoundedBody(response: Response, maximumBytes: number, signal: AbortSignal): Promise<Uint8Array>;
 export declare function requireId(expected: protocol.RequestId, received: protocol.RequestId): void;
 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

@@ -1,4 +1,5 @@
-import { codecs, invocation as protocol } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { ProtocolError, ResponseError } from '../../errors/index.js';
 import { asError } from '../index.js';
 export async function codecForResponse(contentType) {
@@ -76,4 +77,3 @@ export function binaryHeaders(input, names) {
     }
     return Object.freeze(output);
 }
-//# sourceMappingURL=response.js.map

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

@@ -1,18 +1,20 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
-import type { Stream } from '@astrale-os/kernel-ports/functions';
-import { invocation as protocol, type codecs } from '@astrale-os/kernel-protocol';
+import type * as codecs from '@astrale-os/kernel-protocol/codecs';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import type { Stream } from '../../client/index.js';
 import { type ControlledSignal } from '../index.js';
 export declare class HttpStream implements Stream {
     private readonly frames;
     private readonly codec;
-    private readonly id;
+    private readonly requestId;
     private readonly control;
+    invocation: protocol.InvocationId;
     private claimed;
     private terminal;
     private index;
     private interruption;
     private constructor();
-    static open(response: Response, codec: codecs.Codec, id: protocol.RequestId, maximumFrameBytes: number, control: ControlledSignal): Promise<HttpStream>;
+    static open(response: Response, codec: codecs.Codec, requestId: protocol.RequestId, maximumFrameBytes: number, control: ControlledSignal): Promise<HttpStream>;
     [Symbol.asyncIterator](): AsyncIterator<Value>;
     cancel(reason?: string): Promise<void>;
     private next;
@@ -22,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,20 +1,22 @@
-import { invocation as protocol } from '@astrale-os/kernel-protocol';
+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 {
     frames;
     codec;
-    id;
+    requestId;
     control;
+    invocation;
     claimed = false;
     terminal = false;
     index = 0;
     interruption;
-    constructor(frames, codec, id, control) {
+    constructor(frames, codec, requestId, control) {
         this.frames = frames;
         this.codec = codec;
-        this.id = id;
+        this.requestId = requestId;
         this.control = control;
         const abort = () => void this.interrupt(this.abortFailure(control.signal.reason));
         if (control.signal.aborted)
@@ -22,15 +24,16 @@ export class HttpStream {
         else
             control.signal.addEventListener('abort', abort, { once: true });
     }
-    static async open(response, codec, id, maximumFrameBytes, control) {
+    static async open(response, codec, requestId, maximumFrameBytes, control) {
         if (response.body === null)
             throw new ProtocolError('stream has no body.');
-        const stream = new HttpStream(new LengthPrefixedFrames(response.body.getReader(), maximumFrameBytes), codec, id, control);
+        const stream = new HttpStream(new LengthPrefixedFrames(response.body.getReader(), maximumFrameBytes), codec, requestId, control);
         const first = await stream.readFrame();
         if (first === null || first.kind !== 'stream.start') {
             await stream.stop('invalid stream start');
             throw new ProtocolError('stream did not begin with stream.start.');
         }
+        stream.invocation = first.invocation;
         return stream;
     }
     [Symbol.asyncIterator]() {
@@ -71,7 +74,7 @@ export class HttpStream {
             }
             if (frame.kind === 'stream.error') {
                 await this.finish();
-                throw new ResponseError(frame.error.code, frame.error.message, frame.error.data);
+                throw new ResponseError(frame.error.code, frame.error.message, this.invocation, frame.error.data);
             }
             if (frame.kind !== 'stream.end') {
                 throw new ProtocolError(`Unexpected ${frame.kind} frame inside stream.`);
@@ -83,7 +86,7 @@ export class HttpStream {
             return { done: true, value: undefined };
         }
         catch (error) {
-            const failure = this.interruption ?? error;
+            const failure = this.interruption ?? retainInvocationId(error, this.invocation);
             await this.stop(failure);
             throw failure;
         }
@@ -95,7 +98,7 @@ export class HttpStream {
         if (payload === null)
             return null;
         const frame = decodeProtocol('stream frame', () => protocol.decodeStreamFrame(this.codec.decode(payload)));
-        requireId(this.id, frame.id);
+        requireId(this.requestId, frame.requestId);
         return frame;
     }
     async finish() {
@@ -122,15 +125,30 @@ 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,
             });
         }
         return asError(reason ?? new Error('stream was cancelled.'));
     }
 }
+function retainInvocationId(input, invocation) {
+    if (input instanceof ProtocolError && input.invocation === undefined) {
+        return new ProtocolError(input.message, { cause: input, invocation });
+    }
+    if (input instanceof TransportError &&
+        input.context.kind === 'invocation' &&
+        input.context.invocation === undefined) {
+        return invocationFailure(input.message, input.phase, {
+            cause: input,
+            delivery: input.context.delivery,
+            invocation,
+        });
+    }
+    return input;
+}
 class LengthPrefixedFrames {
     reader;
     maximumFrameBytes;
@@ -194,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,5 +1,7 @@
-import { codecs, invocation as protocol } from '@astrale-os/kernel-protocol';
+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 { HttpStream } from './stream.js';
@@ -29,13 +31,15 @@ export class HttpTransport {
         this.maximumResponseBytes = positiveInteger(options.maximumResponseBytes ?? DEFAULT_MAXIMUM_RESPONSE_BYTES, 'maximumResponseBytes');
     }
     async dispatch(input, options = {}) {
-        const id = this.nextRequestId();
+        const requestId = this.nextRequestId();
         const timeoutMs = positiveInteger(options.timeoutMs ?? this.timeoutMs, 'timeoutMs');
         const codec = await this.requestCodec();
+        const { trace: traceInput, ...invocationInput } = input;
+        const trace = traceInput === undefined ? undefined : protocol.admitTrace(traceInput);
         const request = protocol.decodeRequest({
             version: protocol.VERSION,
-            id,
-            ...input,
+            requestId,
+            ...invocationInput,
             ...(options.idempotencyKey === undefined ? {} : { idempotencyKey: options.idempotencyKey }),
         });
         const encoded = codec.encode(request);
@@ -46,11 +50,11 @@ 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';
-            const response = await this.fetchResponse(codec, encoded, control);
+            const response = await this.fetchResponse(codec, encoded, trace, control);
             phase = 'receive';
             requireLive(control);
             if (response.status >= 300 && response.status < 400) {
@@ -69,7 +73,7 @@ export class HttpTransport {
                 if (binaryId === null || binaryManifest === null) {
                     throw new ProtocolError('server returned an incomplete binary response signal.');
                 }
-                return await this.decodeBinary(response, id, binaryId, control);
+                return await this.decodeBinary(response, requestId, binaryId, control);
             }
             const responseCodec = await codecForResponse(response.headers.get('content-type'));
             if (responseCodec === undefined) {
@@ -82,39 +86,43 @@ export class HttpTransport {
                 if (!response.ok) {
                     throw new ProtocolError('server returned a non-success stream response.');
                 }
-                const stream = await HttpStream.open(response, responseCodec, id, this.maximumResponseBytes, control);
+                const stream = await HttpStream.open(response, responseCodec, requestId, this.maximumResponseBytes, control);
                 requireLive(control);
                 handedOff = true;
-                return { kind: 'stream', stream };
+                return { kind: 'stream', stream, invocation: stream.invocation };
             }
             const body = await readBoundedBody(response, this.maximumResponseBytes, control.signal);
             requireLive(control);
             const decoded = decodeProtocol('response body', () => responseCodec.decode(body));
             const envelope = decodeProtocol('response envelope', () => protocol.decodeResponse(decoded));
-            if (envelope.id === null && 'error' in envelope) {
-                throw new ResponseError(envelope.error.code, envelope.error.message, envelope.error.data);
+            if (envelope.requestId === null && 'error' in envelope) {
+                throw new ResponseError(envelope.error.code, envelope.error.message, envelope.invocation, envelope.error.data);
             }
-            requireId(id, envelope.id);
+            requireId(requestId, envelope.requestId);
             if ('kind' in envelope && envelope.kind === 'stale') {
                 const stale = decodeProtocol('stale response', () => protocol.decodeStale(envelope));
                 requireLive(control);
-                return Object.freeze({ kind: 'stale', current: stale.current });
+                return Object.freeze({
+                    kind: 'stale',
+                    current: stale.current,
+                    invocation: stale.invocation,
+                });
             }
             if ('kind' in envelope && envelope.kind === 'miss') {
                 decodeProtocol('miss response', () => protocol.decodeMiss(envelope));
                 requireLive(control);
-                return Object.freeze({ kind: 'miss' });
+                return Object.freeze({ kind: 'miss', invocation: envelope.invocation });
             }
             if ('kind' in envelope && envelope.kind === 'redirect') {
-                const redirect = decodeProtocol('redirect response', () => protocol.decodeRedirect(envelope));
+                const response = decodeProtocol('redirect response', () => protocol.decodeRedirectResponse(envelope));
                 requireLive(control);
-                return redirectResult(redirect);
+                return redirectResult(response);
             }
             if ('error' in envelope) {
-                throw new ResponseError(envelope.error.code, envelope.error.message, envelope.error.data);
+                throw new ResponseError(envelope.error.code, envelope.error.message, envelope.invocation, envelope.error.data);
             }
             requireLive(control);
-            return { kind: 'value', value: envelope.result };
+            return { kind: 'value', value: envelope.result, invocation: envelope.invocation };
         }
         catch (error) {
             throw transportFailure(error, control, options.signal, timeoutMs, this.url, phase, delivery);
@@ -124,7 +132,7 @@ export class HttpTransport {
                 control.close();
         }
     }
-    async fetchResponse(codec, encoded, control) {
+    async fetchResponse(codec, encoded, trace, control) {
         return this.fetchImpl(this.url, {
             method: 'POST',
             redirect: 'error',
@@ -133,6 +141,7 @@ export class HttpTransport {
             referrerPolicy: 'no-referrer',
             headers: {
                 ...this.headers,
+                ...protocol.http.encodeTraceHeaders(trace),
                 'content-type': codec.contentType,
                 accept: codec.contentType,
             },
@@ -140,12 +149,12 @@ export class HttpTransport {
             signal: control.signal,
         });
     }
-    async decodeBinary(response, id, binaryId, control) {
+    async decodeBinary(response, requestId, binaryId, control) {
         if (!response.ok) {
             throw new ProtocolError('server returned binary data with an error status.');
         }
-        if (binaryId !== String(id)) {
-            throw new ProtocolError(`binary response id ${JSON.stringify(binaryId)} does not match request id ${id}.`);
+        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) {
@@ -155,9 +164,11 @@ export class HttpTransport {
         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)));
         const binary = decodeProtocol('binary response', () => protocol.decodeBinaryResponse({
             kind: 'binary',
-            id,
+            requestId,
+            invocation,
             body,
             mediaType,
             ...(Object.keys(headers).length === 0 ? {} : { headers }),
@@ -165,6 +176,7 @@ export class HttpTransport {
         requireLive(control);
         return {
             kind: 'binary',
+            invocation: binary.invocation,
             value: {
                 body: binary.body,
                 mediaType: binary.mediaType,
@@ -173,21 +185,19 @@ export class HttpTransport {
         };
     }
     nextRequestId() {
-        const id = this.nextId;
-        this.nextId = id === Number.MAX_SAFE_INTEGER ? 1 : id + 1;
-        return id;
+        const requestId = this.nextId;
+        this.nextId = requestId === Number.MAX_SAFE_INTEGER ? 1 : requestId + 1;
+        return requestId;
     }
     requestCodec() {
         return this.codecName === 'msgpack' ? codecs.loadMsgpack() : Promise.resolve(codecs.json);
     }
 }
-function redirectResult(redirect) {
+function redirectResult(response) {
     return Object.freeze({
         kind: 'redirect',
-        redirect: Object.freeze({
-            route: redirect.route,
-            ...(redirect.credential === undefined ? {} : { credential: redirect.credential }),
-        }),
+        invocation: response.invocation,
+        redirect: response.redirect,
     });
 }
 function normalizeUrl(input) {
@@ -256,9 +266,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,
         });
     }
@@ -266,9 +275,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,
         });
 }
@@ -308,6 +316,9 @@ const RESERVED_REQUEST_HEADERS = new Set([
     'referrer-policy',
     'set-cookie',
     'te',
+    protocol.http.TRACEPARENT_FIELD,
+    protocol.http.TRACESTATE_FIELD,
+    protocol.http.BAGGAGE_FIELD,
     'trailer',
     'transfer-encoding',
     'upgrade',
@@ -330,4 +341,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

@@ -1,5 +1,5 @@
-import type { Result } from '@astrale-os/kernel-ports/functions';
 import type { invocation as protocol } from '@astrale-os/kernel-protocol';
+import type { Result } from '../client/result.js';
 export interface RequestOptions {
     readonly signal?: AbortSignal;
     readonly timeoutMs?: number;
@@ -7,17 +7,23 @@ export interface RequestOptions {
 }
 export interface TransportRequest {
     readonly call: protocol.Call;
+    /** Internally supplied per-attempt correlation syntax; never a RequestOptions field. */
+    readonly trace?: protocol.Trace;
     readonly credential?: string;
     readonly delegate?: protocol.Delegate;
     readonly routing?: protocol.Routing;
+    /** Source-Kernel Schema Registration precondition; omitted after routing. */
+    readonly schema?: protocol.SchemaTarget;
 }
 /** Correlated reserved control decoded independently from application results and errors. */
 export interface StaleControl {
     readonly kind: 'stale';
     readonly current: protocol.Stale['current'];
+    readonly invocation: protocol.InvocationId;
 }
 export interface MissControl {
     readonly kind: 'miss';
+    readonly invocation: protocol.InvocationId;
 }
 export type TransportResult = Result | StaleControl | MissControl;
 export interface Transport {
@@ -26,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

@@ -1,4 +1,5 @@
-import { invocation as protocol, type codecs } from '@astrale-os/kernel-protocol';
+import type * as codecs from '@astrale-os/kernel-protocol/codecs';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { ControlledSignal } from '../index.js';
 import type { TransportResult } from '../index.js';
 import type { ExchangeOwner } from './exchange.js';
@@ -29,10 +30,9 @@ export declare class WebSocketConnection implements ExchangeOwner {
     connect(control: ControlledSignal): Promise<void>;
     dispatch(request: protocol.Request, control: ControlledSignal, maximumBufferedItems: number): Promise<TransportResult>;
     finish(exchange: WebSocketExchange, reusable: boolean, closeCode?: 1002 | 1008 | 1011): void;
-    cancel(exchange: WebSocketExchange, id: protocol.RequestId): void;
+    cancel(exchange: WebSocketExchange, requestId: protocol.RequestId): void;
     shutdown(reason?: Error, closeCode?: number, closeReason?: string): void;
     private onOpen;
     private onMessage;
     private onFailure;
 }
-//# sourceMappingURL=connection.d.ts.map