@astrale-os/kernel-server 0.5.0-beta.1 → 0.5.0-beta.11

package/dist/transport/http/handler.js

@@ -1,17 +1,15 @@
-import { codecs, errors, invocation as protocol, publication as publicationProtocol, } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../../errors/index.js';
-import { invocationContext } from '../../invocation/index.js';
+import { invocationContext, publicationRouteDecision, } from '../../invocation/index.js';
 import { readBoundedBody } from '../body.js';
 import { loadCodecs } from '../codecs.js';
 import { resolveCredential } from '../credential.js';
-import { renderHttpError, renderHttpResult, renderHttpStale, } from './render.js';
+import { renderHttpError, renderHttpResult } from './render.js';
 export function createHttpHandler(config) {
     return async (request, host) => {
         const cors = (exposedHeaders) => config.cors.response(request, exposedHeaders);
-        const renderError = (id, error, codec, options = {}) => renderHttpError(id, error, codec, cors, {
-            ...options,
-            maximumResponseBytes: config.maximumResponseBytes,
-        });
         const allow = [
             ...(config.websocket ? ['GET'] : []),
             'POST',
@@ -20,7 +18,12 @@ export function createHttpHandler(config) {
         if (request.method === 'OPTIONS' && config.cors.enabled) {
             return noStore(config.cors.preflight(request, {
                 methods: ['POST'],
-                headers: ['authorization', 'content-type'],
+                headers: [
+                    'authorization',
+                    'content-type',
+                    protocol.http.TRACEPARENT_FIELD,
+                    protocol.http.TRACESTATE_FIELD,
+                ],
             }));
         }
         if (request.method !== 'POST') {
@@ -29,8 +32,13 @@ export function createHttpHandler(config) {
                 headers: { ...cors(), allow: allow.join(', '), 'cache-control': 'no-store' },
             });
         }
-        const operation = config.active.begin(config.invocationTimeoutMs, request.signal);
-        if (operation === undefined) {
+        const assigned = config.invocation();
+        const renderError = (requestId, error, codec, options = {}) => renderHttpError(requestId, assigned, error, codec, cors, {
+            ...options,
+            maximumResponseBytes: config.maximumResponseBytes,
+        });
+        const active = config.active.begin(config.invocationTimeoutMs, request.signal);
+        if (active === undefined) {
             return renderError(null, {
                 code: errors.CODES.BACKEND_UNAVAILABLE,
                 message: 'server is unavailable.',
@@ -58,19 +66,19 @@ export function createHttpHandler(config) {
             }
             let body;
             try {
-                body = await readBoundedBody(request, config.maximumRequestBytes, operation.signal);
+                body = await readBoundedBody(request, config.maximumRequestBytes, active.signal);
             }
             catch (input) {
                 const payload = input instanceof RequestBodyTooLargeError
                     ? classifyError(input)
                     : input instanceof RequestBodyInvalidError
                         ? { code: errors.CODES.PARSE_ERROR, message: 'Request body is invalid.' }
-                        : operation.timedOut
+                        : active.timedOut
                             ? {
                                 code: errors.CODES.DEADLINE_EXCEEDED,
                                 message: 'Invocation deadline exceeded.',
                             }
-                            : operation.signal.aborted
+                            : active.signal.aborted
                                 ? { code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }
                                 : undefined;
                 if (payload === undefined)
@@ -88,67 +96,70 @@ export function createHttpHandler(config) {
                     throw input;
                 return renderError(null, { code: errors.CODES.PARSE_ERROR, message: 'Request body is invalid.' }, outgoing);
             }
-            let invocation;
+            let envelope;
             try {
-                invocation = protocol.decodeRequest(decoded);
+                envelope = protocol.decodeRequest(decoded);
             }
             catch (input) {
                 return renderError(null, classifyError(input), outgoing);
             }
             const publication = config.currentPublication?.(request);
             if (config.currentPublication !== undefined && publication === undefined) {
-                return renderError(invocation.id, {
+                return renderError(envelope.requestId, {
                     code: errors.CODES.BACKEND_UNAVAILABLE,
                     message: 'Publication is unavailable.',
                 }, outgoing, { status: 503 });
             }
-            if (invocation.routing?.kind === 'via') {
+            if (envelope.routing?.kind === 'via') {
                 if (publication === undefined) {
-                    return renderError(invocation.id, {
+                    return renderError(envelope.requestId, {
                         code: errors.CODES.INVALID_REQUEST,
                         message: 'Publication routing requires a Publication-backed destination.',
                     }, outgoing);
                 }
-                if (!publicationProtocol.matchesReference(publication.publication, invocation.routing.publication)) {
-                    return renderHttpStale(invocation.id, publication.publication.etag, outgoing, cors, config.maximumResponseBytes);
+                const decision = publicationRouteDecision(publication.publication, envelope.routing.publication);
+                if (decision.kind === 'rejected') {
+                    return renderError(envelope.requestId, decision.error, outgoing);
                 }
             }
-            const credential = resolveCredential(invocation.credential, request.headers.get('authorization'));
+            const credential = resolveCredential(envelope.credential, request.headers.get('authorization'));
             if (!credential.ok) {
-                return renderError(invocation.id, credential.error, outgoing);
+                return renderError(envelope.requestId, credential.error, outgoing);
             }
+            const trace = protocol.http.decodeTraceHeaders(request.headers.get(protocol.http.TRACEPARENT_FIELD), request.headers.get(protocol.http.TRACESTATE_FIELD));
             try {
                 const result = await config.handler.dispatch(Object.freeze({
-                    call: invocation.call,
+                    call: envelope.call,
+                    ...(trace === undefined ? {} : { trace }),
                     ...(credential.credential === undefined ? {} : { credential: credential.credential }),
-                    ...(invocation.delegate === undefined ? {} : { delegate: invocation.delegate }),
-                    ...(invocation.routing?.kind === 'via' ? { via: invocation.routing } : {}),
+                    ...(envelope.delegate === undefined ? {} : { delegate: envelope.delegate }),
+                    ...(envelope.routing?.kind === 'via' ? { via: envelope.routing } : {}),
+                    ...(envelope.schema === undefined ? {} : { schema: envelope.schema }),
                     ...(publication === undefined ? {} : { publication }),
-                    context: invocationContext(operation, config.active, host, undefined, invocation.idempotencyKey, invocation.routing?.kind === 'refresh'
-                        ? { staleEtag: invocation.routing.stale }
-                        : undefined),
+                    context: invocationContext(assigned, active, config.active, host, undefined, envelope.idempotencyKey),
                 }));
                 const response = renderHttpResult(result, {
-                    id: invocation.id,
+                    requestId: envelope.requestId,
                     codec: outgoing,
                     cors,
-                    operation,
+                    invocation: assigned,
+                    active,
                     maximumResponseBytes: config.maximumResponseBytes,
                 });
                 handedOff = result.kind === 'stream';
                 return response;
             }
             catch (input) {
-                if (operation.timedOut) {
-                    return renderError(invocation.id, {
+                if (active.timedOut) {
+                    return renderError(envelope.requestId, {
                         code: errors.CODES.DEADLINE_EXCEEDED,
                         message: 'Invocation deadline exceeded.',
                     }, outgoing, { status: 504 });
                 }
-                if (operation.signal.aborted) {
-                    return renderError(invocation.id, { code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }, outgoing, { status: 408 });
+                if (active.signal.aborted) {
+                    return renderError(envelope.requestId, { code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }, outgoing, { status: 408 });
                 }
-                return renderError(invocation.id, classifyError(input), outgoing);
+                return renderError(envelope.requestId, classifyError(input), outgoing);
             }
         }
         catch (input) {
@@ -158,7 +169,7 @@ export function createHttpHandler(config) {
         }
         finally {
             if (!handedOff)
-                operation.settle();
+                active.settle();
         }
     };
 }
@@ -167,4 +178,3 @@ function noStore(response) {
     headers.set('cache-control', 'no-store');
     return new Response(response.body, { status: response.status, headers });
 }
-//# sourceMappingURL=handler.js.map

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

@@ -1,3 +1,2 @@
 export { createHttpHandler, type HttpHandlerConfig } from './handler.js';
 export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, type CorsHeaders, type ErrorRenderOptions, type RenderContext, } from './render.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/http/index.js

@@ -1,3 +1,2 @@
 export { createHttpHandler } from './handler.js';
 export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, } from './render.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,11 +1,14 @@
-import { errors, invocation as protocol, type codecs } from '@astrale-os/kernel-protocol';
+import type { Codec } from '@astrale-os/kernel-protocol/codecs';
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { Handler } from '../../invocation/index.js';
 import type { ActiveOperation } from '../../lifecycle/index.js';
 export interface RenderContext {
-    readonly id: protocol.RequestId;
-    readonly codec: codecs.Codec;
+    readonly requestId: protocol.RequestId;
+    readonly codec: Codec;
     readonly cors: CorsHeaders;
-    readonly operation: ActiveOperation;
+    readonly invocation: protocol.InvocationId;
+    readonly active: ActiveOperation;
     readonly maximumResponseBytes: number;
 }
 export type CorsHeaders = (exposedHeaders?: readonly string[]) => Readonly<Record<string, string>>;
@@ -16,14 +19,13 @@ export interface ErrorRenderOptions {
 }
 type HandlerResult = Awaited<ReturnType<Handler['dispatch']>>;
 export declare function renderHttpResult(result: HandlerResult, context: RenderContext): Response;
-export declare function renderBinary(id: protocol.RequestId, binary: Extract<HandlerResult, {
+export declare function renderBinary(requestId: protocol.RequestId, invocation: protocol.InvocationId, binary: Extract<HandlerResult, {
     readonly kind: 'binary';
 }>['value']): protocol.BinaryResponse;
-export declare function renderRedirect(id: protocol.RequestId, redirect: Extract<HandlerResult, {
+export declare function renderRedirect(requestId: protocol.RequestId, invocation: protocol.InvocationId, redirect: Extract<HandlerResult, {
     readonly kind: 'redirect';
-}>['redirect']): protocol.Redirect;
-export declare function renderHttpError(id: protocol.RequestId, error: errors.ErrorPayload, codec: codecs.Codec, cors: CorsHeaders, options?: ErrorRenderOptions): Response;
-export declare function renderHttpStale(id: protocol.RequestId, current: protocol.Stale['current'], codec: codecs.Codec, cors: CorsHeaders, maximumResponseBytes?: number): Response;
-export declare function encodeEnvelope(codec: codecs.Codec, input: unknown): string | Uint8Array;
+}>['redirect']): protocol.RedirectResponse;
+export declare function renderHttpError(requestId: protocol.RequestId, invocation: protocol.InvocationId, error: errors.ErrorPayload, codec: Codec, cors: CorsHeaders, options?: ErrorRenderOptions): Response;
+export declare function renderHttpStale(requestId: protocol.RequestId, invocation: protocol.InvocationId, current: protocol.Stale['current'], codec: Codec, cors: CorsHeaders, maximumResponseBytes?: number): Response;
+export declare function encodeEnvelope(codec: Codec, input: unknown): string | Uint8Array;
 export {};
-//# sourceMappingURL=render.d.ts.map

package/dist/transport/http/render.js

@@ -1,55 +1,64 @@
-import { errors, invocation as protocol, routes } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { HTTP_ROUTE_MISS, HTTP_ROUTE_STALE } from '@astrale-os/kernel-protocol/routes/routing';
 import { classifyError } from '../../errors/index.js';
 import { ResponseBodyTooLargeError } from '../../errors/index.js';
 import { interruptedStreamError } from '../stream-error.js';
 export function renderHttpResult(result, context) {
     switch (result.kind) {
         case 'value':
-            return settled(context.operation, envelopeResponse(context.codec, { result: result.value, id: context.id }, context.cors(), 200, true, context.maximumResponseBytes));
+            return settled(context.active, envelopeResponse(context.codec, {
+                result: result.value,
+                requestId: context.requestId,
+                invocation: context.invocation,
+            }, context.cors(), 200, true, context.maximumResponseBytes));
         case 'redirect': {
-            const response = renderRedirect(context.id, result.redirect);
-            return settled(context.operation, envelopeResponse(context.codec, response, context.cors(), 200, true, context.maximumResponseBytes));
+            const response = renderRedirect(context.requestId, context.invocation, result.redirect);
+            return settled(context.active, envelopeResponse(context.codec, response, context.cors(), 200, true, context.maximumResponseBytes));
         }
         case 'miss':
-            return settled(context.operation, envelopeResponse(context.codec, protocol.miss(context.id), context.cors(), 200, true, context.maximumResponseBytes));
+            return settled(context.active, envelopeResponse(context.codec, protocol.miss(context.requestId, context.invocation), context.cors(), 200, true, context.maximumResponseBytes));
         case 'binary': {
-            const binary = renderBinary(context.id, result.value);
-            return settled(context.operation, binaryHttpResponse(binary, context.cors, context.maximumResponseBytes));
+            const binary = renderBinary(context.requestId, context.invocation, result.value);
+            return settled(context.active, binaryHttpResponse(binary, context.cors, context.maximumResponseBytes));
         }
         case 'stream':
             return streamHttpResponse(result.stream, context);
     }
 }
-export function renderBinary(id, binary) {
-    if (Object.keys(binary.headers ?? {}).some((name) => {
-        const lower = name.toLowerCase();
-        return lower === routes.HTTP_ROUTE_STALE || lower === routes.HTTP_ROUTE_MISS;
-    })) {
-        throw new TypeError(`${routes.HTTP_ROUTE_STALE} is reserved for stale-route control.`);
-    }
+export function renderBinary(requestId, invocation, binary) {
+    const reserved = Object.keys(binary.headers ?? {}).find((name) => {
+        const normalized = name.toLowerCase();
+        return (normalized === protocol.http.INVOCATION_FIELD ||
+            normalized === HTTP_ROUTE_STALE ||
+            normalized === HTTP_ROUTE_MISS);
+    });
+    if (reserved !== undefined)
+        throw new TypeError(`${reserved} is reserved by Protocol.`);
     return protocol.decodeBinaryResponse({
         kind: 'binary',
-        id,
+        requestId,
+        invocation,
         body: binary.body,
         mediaType: binary.mediaType,
         ...(binary.headers === undefined ? {} : { headers: binary.headers }),
     });
 }
-export function renderRedirect(id, redirect) {
-    return protocol.decodeRedirect({
+export function renderRedirect(requestId, invocation, redirect) {
+    return protocol.decodeRedirectResponse({
         kind: 'redirect',
-        id,
-        route: redirect.route,
-        ...(redirect.credential === undefined ? {} : { credential: redirect.credential }),
+        requestId,
+        invocation,
+        redirect,
     });
 }
-export function renderHttpError(id, error, codec, cors, options = {}) {
+export function renderHttpError(requestId, invocation, error, codec, cors, options = {}) {
     const status = options.status ?? errors.httpStatusOf(error);
     const extra = status === 401 ? { 'www-authenticate': 'Bearer realm="astrale-invocation"' } : {};
-    return errorEnvelopeResponse(codec, { error, id }, { ...cors(), ...extra }, status, options.negotiated ?? true, options.maximumResponseBytes);
+    return errorEnvelopeResponse(codec, { error, requestId, invocation }, { ...cors(), ...extra }, status, options.negotiated ?? true, options.maximumResponseBytes);
 }
-export function renderHttpStale(id, current, codec, cors, maximumResponseBytes) {
-    return envelopeResponse(codec, protocol.stale(id, current), cors(), 200, true, maximumResponseBytes);
+export function renderHttpStale(requestId, invocation, current, codec, cors, maximumResponseBytes) {
+    return envelopeResponse(codec, protocol.stale(requestId, invocation, current), cors(), 200, true, maximumResponseBytes);
 }
 export function encodeEnvelope(codec, input) {
     return codec.encode(input);
@@ -69,6 +78,7 @@ function binaryHttpResponse(binary, cors, maximumResponseBytes) {
     const applicationHeaders = Object.keys(binary.headers ?? {}).filter((name) => protocol.http.isApplicationBinaryHeader(name));
     const headers = new Headers(cors([
         protocol.http.REQUEST_ID_FIELD,
+        protocol.http.INVOCATION_FIELD,
         protocol.http.BINARY_HEADERS_FIELD,
         ...applicationHeaders,
     ]));
@@ -78,14 +88,15 @@ function binaryHttpResponse(binary, cors, maximumResponseBytes) {
     }
     headers.set('content-type', binary.mediaType);
     headers.set(protocol.http.BINARY_HEADERS_FIELD, protocol.http.encodeBinaryHeaderNames(binary.headers));
-    headers.set(protocol.http.REQUEST_ID_FIELD, String(binary.id));
+    headers.set(protocol.http.REQUEST_ID_FIELD, String(binary.requestId));
+    headers.set(protocol.http.INVOCATION_FIELD, protocol.http.encodeInvocationId(binary.invocation));
     headers.set('cache-control', 'no-store');
     appendVary(headers, 'accept');
     return new Response(toBody(binary.body), { status: 200, headers });
 }
 function streamHttpResponse(stream, context) {
     const iterator = stream[Symbol.asyncIterator]();
-    const startFrame = encodeBoundedStreamFrame(context.codec, { kind: 'stream.start', id: context.id }, context.maximumResponseBytes);
+    const startFrame = encodeBoundedStreamFrame(context.codec, { kind: 'stream.start', requestId: context.requestId, invocation: context.invocation }, context.maximumResponseBytes);
     let count = 0;
     let terminal = false;
     let controller;
@@ -121,7 +132,7 @@ function streamHttpResponse(stream, context) {
             ]);
         }
         finally {
-            context.operation.settle();
+            context.active.settle();
         }
     }
     const body = new ReadableStream({
@@ -140,16 +151,16 @@ function streamHttpResponse(stream, context) {
                     terminal = true;
                     output.enqueue(encodeBoundedStreamFrame(context.codec, {
                         kind: 'stream.end',
-                        id: context.id,
+                        requestId: context.requestId,
                         count,
                     }, context.maximumResponseBytes));
                     output.close();
-                    context.operation.settle();
+                    context.active.settle();
                     return;
                 }
                 const frame = protocol.decodeStreamFrame({
                     kind: 'stream.item',
-                    id: context.id,
+                    requestId: context.requestId,
                     index: count,
                     value: next.value,
                 });
@@ -160,11 +171,11 @@ function streamHttpResponse(stream, context) {
                 if (terminal)
                     return;
                 terminal = true;
-                if (!context.operation.signal.aborted) {
+                if (!context.active.signal.aborted) {
                     try {
                         output.enqueue(encodeBoundedStreamFrame(context.codec, {
                             kind: 'stream.error',
-                            id: context.id,
+                            requestId: context.requestId,
                             error: classifyError(input),
                         }, context.maximumResponseBytes));
                     }
@@ -177,16 +188,16 @@ function streamHttpResponse(stream, context) {
                     Promise.resolve().then(() => stream.cancel('stream failed')),
                     Promise.resolve().then(() => iterator.return?.()),
                 ]);
-                context.operation.settle();
+                context.active.settle();
             }
         },
         async cancel(reason) {
             const message = typeof reason === 'string' ? reason : 'response consumer cancelled';
-            context.operation.cancel(message);
+            context.active.cancel(message);
             await stop(message);
         },
     });
-    context.operation.onCancel(stop);
+    context.active.onCancel(stop);
     return new Response(body, {
         status: 200,
         headers: {
@@ -213,7 +224,8 @@ function errorEnvelopeResponse(codec, response, cors, status, negotiated, maximu
         if (!(error instanceof ResponseBodyTooLargeError))
             throw error;
         const fallback = {
-            id: response.id,
+            requestId: response.requestId,
+            invocation: response.invocation,
             error: {
                 code: errors.CODES.LIMIT_EXCEEDED,
                 message: 'Response body exceeds the configured limit.',
@@ -264,8 +276,8 @@ function mergeVary(headers, value) {
 function cancellationFrame(context) {
     return {
         kind: 'stream.error',
-        id: context.id,
-        error: interruptedStreamError(context.operation.timedOut),
+        requestId: context.requestId,
+        error: interruptedStreamError(context.active.timedOut),
     };
 }
 function toBody(input) {
@@ -274,4 +286,3 @@ function toBody(input) {
     const copy = new Uint8Array(input);
     return copy.buffer;
 }
-//# sourceMappingURL=render.js.map

package/dist/transport/index.d.ts

@@ -7,4 +7,3 @@ export { interruptedStreamError } from './stream-error.js';
 export { createServerRouter, type ServerRouter } from './router.js';
 export { createWebSocketSession, handleWebSocketUpgrade, type WebSocketHandlerConfig, type WebSocketSessionConfig, } from './websocket/index.js';
 export type { Application, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/index.js

@@ -6,4 +6,3 @@ export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, render
 export { interruptedStreamError } from './stream-error.js';
 export { createServerRouter } from './router.js';
 export { createWebSocketSession, handleWebSocketUpgrade, } from './websocket/index.js';
-//# sourceMappingURL=index.js.map

package/dist/transport/router.d.ts

@@ -2,4 +2,3 @@ import { type Hono as HonoType } from 'hono';
 /** Private Web-standard router capability shared by Server route-owning children. */
 export type ServerRouter = HonoType;
 export declare function createServerRouter(): ServerRouter;
-//# sourceMappingURL=router.d.ts.map

package/dist/transport/router.js

@@ -2,4 +2,3 @@ import { Hono } from 'hono';
 export function createServerRouter() {
     return new Hono();
 }
-//# sourceMappingURL=router.js.map

package/dist/transport/stream-error.d.ts

@@ -1,4 +1,3 @@
-import { type errors } from '@astrale-os/kernel-protocol';
+import type { ErrorPayload } from '@astrale-os/kernel-protocol/errors';
 /** A transport cancellation after stream.start necessarily follows the Function effect boundary. */
-export declare function interruptedStreamError(timedOut: boolean): errors.ErrorPayload;
-//# sourceMappingURL=stream-error.d.ts.map
+export declare function interruptedStreamError(timedOut: boolean): ErrorPayload;

package/dist/transport/stream-error.js

@@ -1,14 +1,13 @@
-import { errors as protocolErrors } from '@astrale-os/kernel-protocol';
+import { CODES } from '@astrale-os/kernel-protocol/errors';
 /** A transport cancellation after stream.start necessarily follows the Function effect boundary. */
 export function interruptedStreamError(timedOut) {
     return timedOut
         ? {
-            code: protocolErrors.CODES.OUTCOME_UNKNOWN,
+            code: CODES.OUTCOME_UNKNOWN,
             message: 'Invocation deadline elapsed after the Function stream began; outcome is unknown.',
         }
         : {
-            code: protocolErrors.CODES.OUTCOME_UNKNOWN,
+            code: CODES.OUTCOME_UNKNOWN,
             message: 'Function stream was cancelled after execution began; outcome is unknown.',
         };
 }
-//# sourceMappingURL=stream-error.js.map

package/dist/transport/types.d.ts

@@ -1,4 +1,4 @@
-import type { invocation as protocol } from '@astrale-os/kernel-protocol';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { ApplicationHost } from '../invocation/index.js';
 /** Portable Fetch application; framework and listener APIs are adapter-owned. */
 export interface Application {
@@ -26,4 +26,3 @@ export interface WebSocketUpgradeOptions {
 export interface WebSocketAdapter {
     upgrade(request: Request, options: WebSocketUpgradeOptions): Response | Promise<Response>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/transport/types.js

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

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

@@ -1,3 +1,2 @@
 export { createWebSocketSession, type WebSocketSessionConfig } from './session.js';
 export { handleWebSocketUpgrade, type WebSocketHandlerConfig } from './upgrade.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/websocket/index.js

@@ -1,3 +1,2 @@
 export { createWebSocketSession } from './session.js';
 export { handleWebSocketUpgrade } from './upgrade.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,13 +1,15 @@
-import { type codecs } from '@astrale-os/kernel-protocol';
+import type { Codec } from '@astrale-os/kernel-protocol/codecs';
+import type { NextInvocationId } from '../../invocation/index.js';
 import type { ActiveOperations } from '../../lifecycle/index.js';
 import type { PublicationSnapshot } from '../../publication/index.js';
 import type { WebSocketHandlers } from '../types.js';
 import { type ApplicationHost, type Handler } from '../../invocation/index.js';
 export interface WebSocketSessionConfig {
-    readonly codec: codecs.Codec;
+    readonly codec: Codec;
     readonly authorization: string | null;
     readonly handler: Handler;
     readonly active: ActiveOperations;
+    readonly invocation: NextInvocationId;
     readonly maximumRequestBytes: number;
     readonly maximumResponseBytes: number;
     readonly invocationTimeoutMs: number;
@@ -16,4 +18,3 @@ export interface WebSocketSessionConfig {
 }
 /** Build one socket-pinned transport session. */
 export declare function createWebSocketSession(config: WebSocketSessionConfig): WebSocketHandlers;
-//# sourceMappingURL=session.d.ts.map