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

package/dist/routes/routes.js

@@ -1,13 +1,20 @@
-import { codecs, errors, invocation as protocol, publication, routes, } 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 { MEDIA_TYPE as PUBLICATION_MEDIA_TYPE, PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
+import { reference as publicationReference } from '@astrale-os/kernel-protocol/publication/reference';
+import * as routes from '@astrale-os/kernel-protocol/routes';
 import { classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../errors/index.js';
 import { invocationContext } from '../invocation/index.js';
 import { handleDelivery } from '../publication/delivery/index.js';
 import { readPreparedPublicationSnapshot, } from '../publication/index.js';
-import { interruptedStreamError, readBoundedBody } from '../transport/index.js';
-export function mountRoutes(app, source, deliveryProvider, handler, active, limits, cors, hostFor, reservations, externalIssuer) {
+import { readBoundedBody } from '../transport/body.js';
+import {} from '../transport/router.js';
+import { interruptedStreamError } from '../transport/stream-error.js';
+export function mountRoutes(app, source, deliveryProvider, handler, active, nextInvocation, limits, cors, hostFor, reservations, externalIssuer) {
     const publicationPath = externalIssuer === undefined
-        ? publication.PATH
-        : new URL(publication.url(externalIssuer)).pathname;
+        ? PUBLICATION_PATH
+        : new URL(publicationUrl(externalIssuer)).pathname;
     const externalOrigin = externalIssuer === undefined ? undefined : new URL(externalIssuer).origin;
     if (cors.enabled) {
         app.options(publicationPath, (context) => cors.preflight(context.req.raw, {
@@ -37,7 +44,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, limi
             status: 200,
             headers: {
                 ...responseCors,
-                'content-type': 'application/json',
+                'content-type': PUBLICATION_MEDIA_TYPE,
                 etag: quoteEtag(snapshot.publication.etag),
                 'cache-control': 'public, max-age=0, must-revalidate, no-transform',
             },
@@ -89,7 +96,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, limi
                     },
                 });
             }
-            routing = routes.decodeRouting(request, publication.reference(snapshot.publication));
+            routing = routes.decodeRouting(request, publicationReference(snapshot.publication));
         }
         catch (cause) {
             if (cause instanceof routes.RouteError) {
@@ -97,9 +104,10 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, limi
             }
             throw cause;
         }
-        const route = routes.match(snapshot.routes, request);
+        const route = routes.match(snapshot.table, request);
         if (route === undefined)
             return context.notFound();
+        const assigned = nextInvocation();
         const operation = active.begin(limits.invocationTimeoutMs, request.signal);
         if (operation === undefined)
             return nativeError({
@@ -109,12 +117,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, limi
         let handedOff = false;
         try {
             const body = await readBoundedBody(request, limits.maximumRequestBytes, operation.signal);
-            const invocation = routes.decode(route, {
-                url: request.url,
-                method: request.method,
-                headers: request.headers,
-                body,
-            });
+            const invocation = routes.decode(route, { url: request.url, method: request.method, headers: request.headers, body }, snapshot.domain, snapshot.table.publication);
             const idempotencyHeader = request.headers.get(protocol.HTTP_IDEMPOTENCY_KEY);
             const idempotencyKey = idempotencyHeader === null
                 ? undefined
@@ -124,7 +127,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, limi
                 ...(invocation.credential === undefined ? {} : { credential: invocation.credential }),
                 ...(routing === undefined ? {} : { via: routing }),
                 publication: snapshot.snapshot,
-                context: invocationContext(operation, active, hostFor(request), body, idempotencyKey),
+                context: invocationContext(assigned, operation, active, hostFor(request), body, idempotencyKey),
             }));
             if (result.kind === 'value') {
                 return new Response(encodedBody(codecs.json.encode(result.value)), {
@@ -135,8 +138,13 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, limi
                 });
             }
             if (result.kind === 'binary') {
+                if (isStreamingBinary(result.value)) {
+                    handedOff = true;
+                    return streamingBinaryResponse(result.value, operation, cors, request);
+                }
                 const applicationHeaders = applicationBinaryHeaders(result.value.headers);
                 return new Response(toBody(result.value.body), {
+                    status: result.value.status ?? 200,
                     headers: {
                         ...cors.response(request, [
                             protocol.http.BINARY_HEADERS_FIELD,
@@ -194,6 +202,66 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, limi
         }
     });
 }
+function streamingBinaryResponse(binary, operation, cors, request) {
+    const iterator = binary.body[Symbol.asyncIterator]();
+    const applicationHeaders = applicationBinaryHeaders(binary.headers);
+    let terminal = false;
+    let stopping;
+    const stop = () => {
+        stopping ??= Promise.resolve().then(async () => {
+            if (terminal)
+                return;
+            terminal = true;
+            try {
+                await iterator.return?.();
+            }
+            finally {
+                operation.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();
+                    operation.settle();
+                    return;
+                }
+                controller.enqueue(next.value);
+            }
+            catch (cause) {
+                terminal = true;
+                controller.error(cause);
+                operation.settle();
+            }
+        },
+        async cancel(reason) {
+            const message = typeof reason === 'string' ? reason : 'native binary response cancelled';
+            operation.cancel(message);
+            await stop();
+        },
+    });
+    operation.onCancel(stop);
+    return new Response(body, {
+        status: binary.status ?? 200,
+        headers: {
+            ...cors.response(request, Object.keys(applicationHeaders)),
+            ...applicationHeaders,
+            'content-type': binary.mediaType,
+        },
+    });
+}
+function isStreamingBinary(input) {
+    return !(input.body instanceof Uint8Array);
+}
 function publicationPreflight(cors, request, snapshot, externalOrigin) {
     if (sameRoute(request.url, snapshot.publication.schema.bundle.href, externalOrigin)) {
         return cors.preflight(request, { methods: ['GET'], headers: ['if-none-match'] });
@@ -208,7 +276,7 @@ function publicationPreflight(cors, request, snapshot, externalOrigin) {
     const requestedMethod = request.headers.get('access-control-request-method');
     const route = requestedMethod === null
         ? undefined
-        : routes.match(snapshot.routes, { url: request.url, method: requestedMethod });
+        : routes.match(snapshot.table, { url: request.url, method: requestedMethod });
     return cors.preflight(request, route === undefined ? undefined : nativeCorsRoute(route, requestedMethod));
 }
 function nativeCorsRoute(entry, requestedMethod) {
@@ -218,16 +286,16 @@ function nativeCorsRoute(entry, requestedMethod) {
         routes.HTTP_ROUTE_ISSUER,
         protocol.HTTP_IDEMPOTENCY_KEY,
     ]);
-    if (entry.route.body !== undefined)
+    if (entry.body !== undefined)
         headers.add('content-type');
     let allowAnyHeaders = false;
-    for (const pick of Object.values(entry.route.headers ?? {})) {
+    for (const pick of Object.values(entry.headers ?? {})) {
         if (pick === '*')
             allowAnyHeaders = true;
         else
             headers.add(pick.toLowerCase());
     }
-    const credential = entry.route.credential;
+    const credential = entry.credential;
     const sources = credential === undefined
         ? [{ in: 'header' }]
         : Array.isArray(credential)
@@ -238,9 +306,7 @@ function nativeCorsRoute(entry, requestedMethod) {
             headers.add((source.name ?? 'authorization').toLowerCase());
     }
     return Object.freeze({
-        methods: Object.freeze([
-            entry.route.method === '*' ? requestedMethod.toUpperCase() : entry.route.method,
-        ]),
+        methods: Object.freeze([entry.method === '*' ? requestedMethod.toUpperCase() : entry.method]),
         headers: Object.freeze([...headers]),
         ...(allowAnyHeaders ? { allowAnyHeaders: true } : {}),
     });
@@ -269,9 +335,9 @@ function servingSnapshot(source, limits, request, reservations, externalIssuer)
 function conflictsWithServingRoutes(snapshot, serving) {
     for (const reservation of serving.reservations) {
         const href = `${serving.origin}${reservation.path}`;
-        for (const entry of snapshot.routes) {
-            if (reservation.methods.some((method) => entry.route.method === '*' || entry.route.method === method) &&
-                routes.templatesOverlap(entry.route.href, href)) {
+        for (const entry of snapshot.table.entries) {
+            if (reservation.methods.some((method) => entry.method === '*' || entry.method === method) &&
+                routes.templatesOverlap(entry.href, href)) {
                 return true;
             }
         }
@@ -445,4 +511,3 @@ function encodedBody(input) {
 function toBody(input) {
     return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
 }
-//# sourceMappingURL=routes.js.map

package/dist/server.d.ts

@@ -2,4 +2,3 @@ import type { Server, ServerConfig, ServerOptions, PreparedServer } from './type
 export declare function createServer(config: ServerConfig): Server;
 /** Validate all static transport configuration before a Host starts Runtime recovery/bootstrap. */
 export declare function prepareServer(options: ServerOptions): PreparedServer;
-//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -1,11 +1,14 @@
-import { publication as protocolPublication } from '@astrale-os/kernel-protocol';
+import { PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
 import { captureMethod } from './capture.js';
 import { prepareCors } from './cors/index.js';
+import { captureInvocationSource } from './invocation/index.js';
 import { capture as captureExchangeProvider } from './issuer/exchange.js';
 import { admitIssuer, issuerRouteReservations, mountIssuer } from './issuer/index.js';
 import { ActiveOperations } from './lifecycle/index.js';
 import { currentPublicationSnapshot, mountRoutes } from './routes/index.js';
-import { createHttpHandler, createServerRouter, handleWebSocketUpgrade } from './transport/index.js';
+import { createHttpHandler } from './transport/http/handler.js';
+import { createServerRouter } from './transport/router.js';
+import { handleWebSocketUpgrade } from './transport/websocket/upgrade.js';
 export function createServer(config) {
     const { handler, ...options } = config;
     return prepareServer(options).create(handler);
@@ -27,6 +30,7 @@ function createPreparedServer(input, config) {
     const handleHttp = createHttpHandler({
         handler,
         active,
+        invocation: config.invocation,
         ...config.limits,
         cors: config.cors,
         websocket: config.websocket !== undefined,
@@ -46,6 +50,7 @@ function createPreparedServer(input, config) {
             adapter: config.websocket,
             handler,
             active,
+            invocation: config.invocation,
             ...config.limits,
             cors: config.cors,
             ...(config.publication === undefined
@@ -63,7 +68,7 @@ function createPreparedServer(input, config) {
     app.all(config.path, (context) => handleHttp(context.req.raw, hosts.get(context.req.raw)));
     if (config.health !== undefined) {
         app.get(config.health.path, (context) => {
-            const ready = active.isAccepting && config.health.probe.check();
+            const ready = active.isAvailable && config.health.probe.check();
             return context.json({ status: ready ? 'ready' : 'not-ready' }, ready ? 200 : 503, {
                 ...config.cors.response(context.req.raw),
                 'cache-control': 'no-store',
@@ -77,7 +82,7 @@ function createPreparedServer(input, config) {
         mountIssuer(app, config.issuer, config.cors, active, config.limits.invocationTimeoutMs, config.tokenExchange);
     }
     if (config.publication !== undefined) {
-        mountRoutes(app, config.publication, config.delivery, handler, active, config.limits, config.cors, (request) => hosts.get(request), config.routeReservations, externalIssuer);
+        mountRoutes(app, config.publication, config.delivery, handler, active, config.invocation, config.limits, config.cors, (request) => hosts.get(request), config.routeReservations, externalIssuer);
     }
     app.onError((_error, context) => new Response('{"error":"Internal server error."}', {
         status: 500,
@@ -126,6 +131,7 @@ function captureHandler(input) {
     return Object.freeze({ dispatch });
 }
 function admitOptions(config) {
+    const invocation = captureInvocationSource(config.invocation);
     const limits = admitLimits(config.limits);
     const path = admitRoute(config.path ?? '/', 'invocation path');
     const issuer = config.issuer === undefined ? undefined : admitIssuer(config.issuer);
@@ -173,6 +179,7 @@ function admitOptions(config) {
         }
     }
     return Object.freeze({
+        invocation,
         limits,
         path,
         cors: prepareCors(config.cors),
@@ -205,8 +212,8 @@ function routeReservations(invocationPath, healthPath, issuer, websocket, tokenE
 }
 function protocolPublicationPath(issuer) {
     if (issuer === undefined)
-        return protocolPublication.PATH;
-    return new URL(protocolPublication.url(issuer)).pathname;
+        return PUBLICATION_PATH;
+    return new URL(publicationUrl(issuer)).pathname;
 }
 function captureHealthProbe(probe) {
     const check = captureMethod(probe, 'check', 'Health probe is invalid.');
@@ -257,4 +264,3 @@ function admitRoute(path, label) {
     }
     return path;
 }
-//# sourceMappingURL=server.js.map

package/dist/transport/body.d.ts

@@ -2,4 +2,3 @@ export { RequestBodyInvalidError, RequestBodyTooLargeError } from '../errors/ind
 /** Read a request body while enforcing the limit before retaining excess bytes. */
 export declare function readBoundedBody(request: Request, maximumBytes: number, signal: AbortSignal): Promise<Uint8Array>;
 export declare function byteLength(input: string | Uint8Array): number;
-//# sourceMappingURL=body.d.ts.map

package/dist/transport/body.js

@@ -48,4 +48,3 @@ export async function readBoundedBody(request, maximumBytes, signal) {
 export function byteLength(input) {
     return typeof input === 'string' ? new TextEncoder().encode(input).byteLength : input.byteLength;
 }
-//# sourceMappingURL=body.js.map

package/dist/transport/codecs.d.ts

@@ -1,5 +1,4 @@
-import { codecs } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
 export type LoadedCodec = codecs.Codec;
 /** Load the built-in Server representation set before pure Protocol binding selection. */
 export declare function loadCodecs(): Promise<readonly [codecs.Codec, codecs.Codec]>;
-//# sourceMappingURL=codecs.d.ts.map

package/dist/transport/codecs.js

@@ -1,6 +1,5 @@
-import { codecs } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
 /** Load the built-in Server representation set before pure Protocol binding selection. */
 export async function loadCodecs() {
     return Object.freeze([codecs.json, await codecs.loadMsgpack()]);
 }
-//# sourceMappingURL=codecs.js.map

package/dist/transport/credential.d.ts

@@ -1,4 +1,4 @@
-import { errors } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
 export type CredentialResult = {
     readonly ok: true;
     readonly credential: string | undefined;
@@ -8,4 +8,3 @@ export type CredentialResult = {
 };
 /** Resolve exactly zero or one untrusted credential channel without authenticating it. */
 export declare function resolveCredential(envelope: string | undefined, authorization: string | null): CredentialResult;
-//# sourceMappingURL=credential.d.ts.map

package/dist/transport/credential.js

@@ -1,4 +1,4 @@
-import { errors } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
 /** Resolve exactly zero or one untrusted credential channel without authenticating it. */
 export function resolveCredential(envelope, authorization) {
     if (envelope !== undefined && authorization !== null) {
@@ -26,4 +26,3 @@ function failure(message) {
         error: { code: errors.CODES.INVALID_REQUEST, message },
     };
 }
-//# sourceMappingURL=credential.js.map

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

@@ -1,10 +1,12 @@
 import type { CorsPolicy } from '../../cors/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 ApplicationHost, type Handler } from '../../invocation/index.js';
 export interface HttpHandlerConfig {
     readonly handler: Handler;
     readonly active: ActiveOperations;
+    readonly invocation: NextInvocationId;
     readonly maximumRequestBytes: number;
     readonly maximumResponseBytes: number;
     readonly invocationTimeoutMs: number;
@@ -13,4 +15,3 @@ export interface HttpHandlerConfig {
     readonly currentPublication?: (request: Request) => PublicationSnapshot | undefined;
 }
 export declare function createHttpHandler(config: HttpHandlerConfig): (request: Request, host?: ApplicationHost) => Promise<Response>;
-//# sourceMappingURL=handler.d.ts.map

package/dist/transport/http/handler.js

@@ -1,4 +1,6 @@
-import { codecs, errors, invocation as protocol } 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, publicationRouteDecision, } from '../../invocation/index.js';
 import { readBoundedBody } from '../body.js';
@@ -8,10 +10,6 @@ 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',
@@ -34,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.',
@@ -63,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)
@@ -93,69 +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);
                 }
-                const decision = publicationRouteDecision(publication.publication, invocation.routing.publication);
+                const decision = publicationRouteDecision(publication.publication, envelope.routing.publication);
                 if (decision.kind === 'rejected') {
-                    return renderError(invocation.id, decision.error, outgoing);
+                    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 } : {}),
-                    ...(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, host, undefined, invocation.idempotencyKey),
+                    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) {
@@ -165,7 +169,7 @@ export function createHttpHandler(config) {
         }
         finally {
             if (!handedOff)
-                operation.settle();
+                active.settle();
         }
     };
 }
@@ -174,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,15 @@
-import { errors, invocation as protocol, type codecs } from '@astrale-os/kernel-protocol';
+import type { BufferedBinaryResult, StreamingBinaryResult } from '@astrale-os/kernel-core/callable';
+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 +20,14 @@ 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, {
-    readonly kind: 'binary';
-}>['value']): protocol.BinaryResponse;
-export declare function renderRedirect(id: protocol.RequestId, redirect: Extract<HandlerResult, {
+export declare function renderBinary(requestId: protocol.RequestId, invocation: protocol.InvocationId, binary: BufferedBinaryResult): protocol.BinaryResponse;
+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 declare function isStreamingBinary(input: Extract<HandlerResult, {
+    readonly kind: 'binary';
+}>['value']): input is StreamingBinaryResult;
 export {};
-//# sourceMappingURL=render.d.ts.map