@astrale-os/kernel-server 0.5.0-beta.2 → 0.5.0-beta.20

package/dist/transport/http/render.js

@@ -1,56 +1,67 @@
-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));
+            if (isStreamingBinary(result.value))
+                return streamingBinaryHttpResponse(result.value, context);
+            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,
+        status: binary.status ?? 200,
         ...(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 }),
-        ...(redirect.trace === undefined ? {} : { trace: redirect.trace }),
+        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);
@@ -67,10 +78,74 @@ function envelopeResponse(codec, input, cors, status = 200, negotiated = true, m
 }
 function binaryHttpResponse(binary, cors, maximumResponseBytes) {
     requireResponseBound(binary.body, maximumResponseBytes);
+    const headers = binaryHttpHeaders(binary, cors, false);
+    return new Response(toBody(binary.body), { status: binary.status, headers });
+}
+function streamingBinaryHttpResponse(binary, context) {
+    const iterator = binary.body[Symbol.asyncIterator]();
+    const headers = binaryHttpHeaders(Object.freeze({
+        requestId: context.requestId,
+        invocation: context.invocation,
+        mediaType: binary.mediaType,
+        headers: binary.headers,
+    }), context.cors, true);
+    let terminal = false;
+    let stopping;
+    const stop = () => {
+        stopping ??= Promise.resolve().then(async () => {
+            if (terminal)
+                return;
+            terminal = true;
+            try {
+                await iterator.return?.();
+            }
+            finally {
+                context.active.settle();
+            }
+        });
+        return stopping;
+    };
+    const body = new ReadableStream({
+        async pull(controller) {
+            if (terminal)
+                return;
+            try {
+                const next = await iterator.next();
+                if (terminal)
+                    return;
+                if (next.done) {
+                    terminal = true;
+                    controller.close();
+                    context.active.settle();
+                    return;
+                }
+                controller.enqueue(next.value);
+            }
+            catch (cause) {
+                terminal = true;
+                controller.error(cause);
+                context.active.settle();
+            }
+        },
+        async cancel(reason) {
+            const message = typeof reason === 'string' ? reason : 'binary response consumer cancelled';
+            context.active.cancel(message);
+            await stop();
+        },
+    });
+    context.active.onCancel(stop);
+    return new Response(body, { status: binary.status ?? 200, headers });
+}
+export function isStreamingBinary(input) {
+    return !(input.body instanceof Uint8Array);
+}
+function binaryHttpHeaders(binary, cors, streaming) {
     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,
+        ...(streaming ? [protocol.http.BINARY_DELIVERY_FIELD] : []),
         ...applicationHeaders,
     ]));
     for (const [name, value] of Object.entries(binary.headers ?? {})) {
@@ -79,14 +154,18 @@ 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));
+    if (streaming) {
+        headers.set(protocol.http.BINARY_DELIVERY_FIELD, protocol.http.STREAMING_BINARY_DELIVERY);
+    }
     headers.set('cache-control', 'no-store');
     appendVary(headers, 'accept');
-    return new Response(toBody(binary.body), { status: 200, headers });
+    return 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;
@@ -122,7 +201,7 @@ function streamHttpResponse(stream, context) {
             ]);
         }
         finally {
-            context.operation.settle();
+            context.active.settle();
         }
     }
     const body = new ReadableStream({
@@ -141,16 +220,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,
                 });
@@ -161,11 +240,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));
                     }
@@ -178,16 +257,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: {
@@ -214,7 +293,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.',
@@ -265,8 +345,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) {
@@ -275,4 +355,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

package/dist/transport/websocket/session.js

@@ -1,10 +1,11 @@
-import { errors, invocation as protocol } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { classifyError } from '../../errors/index.js';
 import { ResponseBodyTooLargeError } from '../../errors/index.js';
 import { invocationContext, publicationRouteDecision, } from '../../invocation/index.js';
 import { byteLength } from '../body.js';
 import { resolveCredential } from '../credential.js';
-import { renderBinary, renderRedirect } from '../http/render.js';
+import { isStreamingBinary, renderBinary, renderRedirect } from '../http/render.js';
 import { interruptedStreamError } from '../stream-error.js';
 const WS_OPEN = 1;
 /** Build one socket-pinned transport session. */
@@ -71,9 +72,9 @@ export function createWebSocketSession(config) {
                     socket.close(1002, 'Invalid cancellation message');
                     return;
                 }
-                const operation = operations.get(requestKey(cancellation.id));
+                const operation = operations.get(requestKey(cancellation.requestId));
                 if (operation === undefined) {
-                    await sendError(socket, admittedCodec, cancellation.id, {
+                    await sendError(socket, admittedCodec, cancellation.requestId, config.invocation(), {
                         code: errors.CODES.INVALID_REQUEST,
                         message: 'Request ID is not active on this connection.',
                     }, sendOutput);
@@ -82,17 +83,18 @@ export function createWebSocketSession(config) {
                 operation.cancel('client cancelled invocation');
                 return;
             }
-            let invocation;
+            let envelope;
             try {
-                invocation = protocol.decodeRequest(decoded);
+                envelope = protocol.decodeRequest(decoded);
             }
             catch {
                 socket.close(1002, 'Invalid Invocation request');
                 return;
             }
-            const key = requestKey(invocation.id);
+            const assigned = config.invocation();
+            const key = requestKey(envelope.requestId);
             if (operations.has(key)) {
-                await sendError(socket, admittedCodec, invocation.id, {
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, {
                     code: errors.CODES.INVALID_REQUEST,
                     message: 'Request ID is already active on this connection.',
                 }, sendOutput);
@@ -100,34 +102,34 @@ export function createWebSocketSession(config) {
             }
             const publication = config.currentPublication?.();
             if (config.currentPublication !== undefined && publication === undefined) {
-                await sendError(socket, admittedCodec, invocation.id, {
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, {
                     code: errors.CODES.BACKEND_UNAVAILABLE,
                     message: 'Publication is unavailable.',
                 }, sendOutput);
                 return;
             }
-            if (invocation.routing?.kind === 'via') {
+            if (envelope.routing?.kind === 'via') {
                 if (publication === undefined) {
-                    await sendError(socket, admittedCodec, invocation.id, {
+                    await sendError(socket, admittedCodec, envelope.requestId, assigned, {
                         code: errors.CODES.INVALID_REQUEST,
                         message: 'Publication routing requires a Publication-backed destination.',
                     }, sendOutput);
                     return;
                 }
-                const decision = publicationRouteDecision(publication.publication, invocation.routing.publication);
+                const decision = publicationRouteDecision(publication.publication, envelope.routing.publication);
                 if (decision.kind === 'rejected') {
-                    await sendError(socket, admittedCodec, invocation.id, decision.error, sendOutput);
+                    await sendError(socket, admittedCodec, envelope.requestId, assigned, decision.error, sendOutput);
                     return;
                 }
             }
-            const credential = resolveCredential(invocation.credential, config.authorization);
+            const credential = resolveCredential(envelope.credential, config.authorization);
             if (!credential.ok) {
-                await sendError(socket, admittedCodec, invocation.id, credential.error, sendOutput);
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, credential.error, sendOutput);
                 return;
             }
             const operation = config.active.begin(config.invocationTimeoutMs);
             if (operation === undefined) {
-                await sendError(socket, admittedCodec, invocation.id, {
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, {
                     code: errors.CODES.BACKEND_UNAVAILABLE,
                     message: 'server is unavailable.',
                 }, sendOutput);
@@ -137,16 +139,16 @@ export function createWebSocketSession(config) {
             scopes.add(operation);
             try {
                 const result = await config.handler.dispatch(Object.freeze({
-                    call: invocation.call,
-                    ...(invocation.trace === undefined ? {} : { trace: invocation.trace }),
+                    call: envelope.call,
+                    ...(envelope.trace === undefined ? {} : { trace: envelope.trace }),
                     ...(credential.credential === undefined ? {} : { credential: credential.credential }),
-                    ...(invocation.delegate === undefined ? {} : { delegate: invocation.delegate }),
-                    ...(invocation.routing?.kind === 'via' ? { via: invocation.routing } : {}),
-                    ...(invocation.schema === undefined ? {} : { schema: invocation.schema }),
+                    ...(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, config.host, undefined, invocation.idempotencyKey),
+                    context: invocationContext(assigned, operation, config.active, config.host, undefined, envelope.idempotencyKey),
                 }));
-                await sendResult(socket, admittedCodec, invocation.id, result, operation, sendOutput);
+                await sendResult(socket, admittedCodec, envelope.requestId, assigned, result, operation, sendOutput);
             }
             catch (input) {
                 if (input instanceof ResponseBodyTooLargeError || input instanceof WebSocketOutputError) {
@@ -165,7 +167,7 @@ export function createWebSocketSession(config) {
                         socket.close(1011, 'Internal error');
                         return;
                     }
-                    await sendError(socket, admittedCodec, invocation.id, error, sendOutput);
+                    await sendError(socket, admittedCodec, envelope.requestId, assigned, error, sendOutput);
                 }
             }
             finally {
@@ -193,22 +195,34 @@ export function createWebSocketSession(config) {
     };
     return handlers;
 }
-async function sendResult(socket, codec, id, result, operation, sendOutput) {
+async function sendResult(socket, codec, requestId, assigned, result, operation, sendOutput) {
     switch (result.kind) {
         case 'value':
             await send(socket, codec, {
                 result: result.value,
-                id,
+                requestId,
+                invocation: assigned,
             }, sendOutput);
             return;
         case 'redirect':
-            await send(socket, codec, renderRedirect(id, result.redirect), sendOutput);
+            await send(socket, codec, renderRedirect(requestId, assigned, result.redirect), sendOutput);
             return;
         case 'miss':
-            await send(socket, codec, protocol.miss(id), sendOutput);
+            await send(socket, codec, protocol.miss(requestId, assigned), sendOutput);
             return;
         case 'binary': {
-            const binary = renderBinary(id, result.value);
+            if (isStreamingBinary(result.value)) {
+                const streaming = result.value;
+                await Promise.allSettled([
+                    sendError(socket, codec, requestId, assigned, {
+                        code: errors.CODES.UNSUPPORTED,
+                        message: 'Streaming binary output requires the HTTP transport.',
+                    }, sendOutput),
+                    Promise.resolve().then(() => streaming.body[Symbol.asyncIterator]().return?.()),
+                ]);
+                return;
+            }
+            const binary = renderBinary(requestId, assigned, result.value);
             if (socket.readyState === WS_OPEN) {
                 await sendOutput(socket, protocol.websocket.encodeBinary(binary));
             }
@@ -234,7 +248,7 @@ async function sendResult(socket, codec, id, result, operation, sendOutput) {
                 terminal = true;
                 const terminalOutput = emit({
                     kind: 'stream.error',
-                    id,
+                    requestId,
                     error: interruptedStreamError(operation.timedOut),
                 });
                 await Promise.allSettled([
@@ -243,7 +257,11 @@ async function sendResult(socket, codec, id, result, operation, sendOutput) {
                     Promise.resolve().then(() => iterator.return?.()),
                 ]);
             };
-            const started = emit({ kind: 'stream.start', id });
+            const started = emit({
+                kind: 'stream.start',
+                requestId,
+                invocation: assigned,
+            });
             operation.onCancel(cancel);
             let count = 0;
             try {
@@ -254,12 +272,12 @@ async function sendResult(socket, codec, id, result, operation, sendOutput) {
                         break;
                     if (next.done) {
                         terminal = true;
-                        await emit({ kind: 'stream.end', id, count });
+                        await emit({ kind: 'stream.end', requestId, count });
                         break;
                     }
                     await emit(protocol.decodeStreamFrame({
                         kind: 'stream.item',
-                        id,
+                        requestId,
                         index: count,
                         value: next.value,
                     }));
@@ -295,7 +313,7 @@ async function sendResult(socket, codec, id, result, operation, sendOutput) {
                 await Promise.allSettled([
                     emit({
                         kind: 'stream.error',
-                        id,
+                        requestId,
                         error,
                     }),
                     Promise.resolve().then(() => result.stream.cancel('stream failed')),
@@ -305,8 +323,8 @@ async function sendResult(socket, codec, id, result, operation, sendOutput) {
         }
     }
 }
-function sendError(socket, codec, id, error, output) {
-    return send(socket, codec, { error, id }, output);
+function sendError(socket, codec, requestId, invocation, error, output) {
+    return send(socket, codec, { error, requestId, invocation }, output);
 }
 function send(socket, codec, value, output) {
     return output(socket, codec.encode(value));
@@ -317,8 +335,8 @@ class WebSocketOutputError extends Error {
         this.name = 'WebSocketOutputError';
     }
 }
-function requestKey(id) {
-    return id === null ? 'null:' : `${typeof id}:${String(id)}`;
+function requestKey(requestId) {
+    return requestId === null ? 'null:' : `${typeof requestId}:${String(requestId)}`;
 }
 function isCancelRequest(input) {
     return (typeof input === 'object' &&
@@ -326,4 +344,3 @@ function isCancelRequest(input) {
         !Array.isArray(input) &&
         input.kind === 'cancel');
 }
-//# sourceMappingURL=session.js.map

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

@@ -1,5 +1,6 @@
 import type { CorsPolicy } from '../../cors/index.js';
 import type { ApplicationHost, Handler } from '../../invocation/index.js';
+import type { NextInvocationId } from '../../invocation/index.js';
 import type { ActiveOperations } from '../../lifecycle/index.js';
 import type { PublicationSnapshot } from '../../publication/index.js';
 import type { WebSocketAdapter } from '../types.js';
@@ -8,6 +9,7 @@ export interface WebSocketHandlerConfig {
     readonly adapter: WebSocketAdapter;
     readonly handler: Handler;
     readonly active: ActiveOperations;
+    readonly invocation: NextInvocationId;
     readonly maximumRequestBytes: number;
     readonly maximumResponseBytes: number;
     readonly invocationTimeoutMs: number;
@@ -16,4 +18,3 @@ export interface WebSocketHandlerConfig {
     readonly host?: ApplicationHost;
 }
 export declare function handleWebSocketUpgrade(config: WebSocketHandlerConfig): Promise<Response>;
-//# sourceMappingURL=upgrade.d.ts.map

package/dist/transport/websocket/upgrade.js

@@ -1,4 +1,4 @@
-import { invocation as protocol } from '@astrale-os/kernel-protocol';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { loadCodecs } from '../codecs.js';
 import { createWebSocketSession } from './session.js';
 export async function handleWebSocketUpgrade(config) {
@@ -19,6 +19,7 @@ export async function handleWebSocketUpgrade(config) {
                 authorization: config.request.headers.get('authorization'),
                 handler: config.handler,
                 active: config.active,
+                invocation: config.invocation,
                 maximumRequestBytes: config.maximumRequestBytes,
                 maximumResponseBytes: config.maximumResponseBytes,
                 invocationTimeoutMs: config.invocationTimeoutMs,
@@ -43,4 +44,3 @@ function failure(status, input = {}) {
         headers: { ...input, 'cache-control': 'no-store' },
     });
 }
-//# sourceMappingURL=upgrade.js.map