@astrale-os/kernel-server 0.5.0-beta.7 → 0.5.0-beta.71

package/dist/transport/http/handler.js

@@ -1,12 +1,14 @@
 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 { admissionRefusal, classifyError, classifyRequestError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../../errors/index.js';
+import { admitVia, invocationContext, } from '../../invocation/index.js';
+import { pinned } from '../../release/served.js';
 import { readBoundedBody } from '../body.js';
 import { loadCodecs } from '../codecs.js';
 import { resolveCredential } from '../credential.js';
-import { renderHttpError, renderHttpResult } from './render.js';
+import { binaryRequestBody } from './binary-request.js';
+import { isStreamingBinary, renderDeploymentRetired, renderHttpError, renderHttpResult, } from './render.js';
 export function createHttpHandler(config) {
     return async (request, host) => {
         const cors = (exposedHeaders) => config.cors.response(request, exposedHeaders);
@@ -21,6 +23,8 @@ export function createHttpHandler(config) {
                 headers: [
                     'authorization',
                     'content-type',
+                    protocol.http.REQUEST_ENVELOPE_FIELD,
+                    protocol.http.BINARY_LENGTH_FIELD,
                     protocol.http.TRACEPARENT_FIELD,
                     protocol.http.TRACESTATE_FIELD,
                 ],
@@ -37,24 +41,34 @@ export function createHttpHandler(config) {
             ...options,
             maximumResponseBytes: config.maximumResponseBytes,
         });
-        const active = config.active.begin(config.invocationTimeoutMs, request.signal);
+        const binaryRequest = request.headers.get('content-type')?.trim().toLowerCase() ===
+            protocol.http.BINARY_REQUEST_CONTENT_TYPE;
+        const active = config.active.begin(binaryRequest ? config.binaryRequestTimeoutMs : config.invocationTimeoutMs, request.signal);
         if (active === undefined) {
-            return renderError(null, {
-                code: errors.CODES.BACKEND_UNAVAILABLE,
-                message: 'server is unavailable.',
-            }, codecs.json, { status: 503, negotiated: false });
+            if (binaryRequest && request.body !== null && !request.body.locked) {
+                void request.body.cancel('binary request rejected').catch(() => undefined);
+            }
+            return renderError(null, admissionRefusal(config.active.isAccepting), codecs.json, {
+                status: 503,
+                negotiated: false,
+            });
         }
         let handedOff = false;
+        let binary;
         try {
-            const supported = await loadCodecs();
+            const supported = loadCodecs();
             const contentType = request.headers.get('content-type');
-            const incoming = contentType === null || contentType.trim() === ''
+            // No default representation: a body without a declared Astrale type is never decoded, so a
+            // browser cannot send an admissible invocation from another origin without a CORS preflight.
+            const incoming = binaryRequest
                 ? codecs.json
                 : protocol.http.codecForContentType(contentType, supported);
             if (incoming === undefined) {
                 return renderError(null, {
                     code: errors.CODES.UNSUPPORTED,
-                    message: 'Unsupported request Content-Type.',
+                    message: contentType === null || contentType.trim() === ''
+                        ? 'Missing request Content-Type.'
+                        : 'Unsupported request Content-Type.',
                 }, codecs.json, { status: 415, negotiated: false });
             }
             const outgoing = protocol.http.negotiateResponseCodec(request.headers.get('accept'), incoming, supported);
@@ -66,7 +80,15 @@ export function createHttpHandler(config) {
             }
             let body;
             try {
-                body = await readBoundedBody(request, config.maximumRequestBytes, active.signal);
+                if (binaryRequest)
+                    binary = binaryRequestBody(request, config.maximumBinaryRequestBytes, active.signal, config.binaryRequestIdleTimeoutMs === undefined
+                        ? undefined
+                        : {
+                            timeoutMs: config.binaryRequestIdleTimeoutMs,
+                            cancel: () => active.cancel('binary request idle timeout exceeded'),
+                        });
+                else
+                    body = await readBoundedBody(request, config.maximumRequestBytes, active.signal);
             }
             catch (input) {
                 const payload = input instanceof RequestBodyTooLargeError
@@ -87,37 +109,54 @@ export function createHttpHandler(config) {
                     status: input instanceof RequestBodyTooLargeError ? 413 : errors.httpStatusOf(payload),
                 });
             }
-            let decoded;
-            try {
-                decoded = incoming.decode(body);
-            }
-            catch (input) {
-                if (!(input instanceof codecs.DecodeError))
-                    throw input;
-                return renderError(null, { code: errors.CODES.PARSE_ERROR, message: 'Request body is invalid.' }, outgoing);
-            }
             let envelope;
             try {
-                envelope = protocol.decodeRequest(decoded);
+                if (binaryRequest) {
+                    envelope = protocol.http.decodeBinaryRequestEnvelope(request.headers.get(protocol.http.REQUEST_ENVELOPE_FIELD));
+                    if (envelope.idempotencyKey !== undefined) {
+                        return renderError(envelope.requestId, {
+                            code: errors.CODES.INVALID_REQUEST,
+                            message: 'Binary requests forbid idempotencyKey.',
+                        }, outgoing);
+                    }
+                }
+                else {
+                    let decoded;
+                    try {
+                        decoded = incoming.decode(body);
+                    }
+                    catch (input) {
+                        if (!(input instanceof codecs.DecodeError))
+                            throw input;
+                        return renderError(null, { code: errors.CODES.PARSE_ERROR, message: 'Request body is invalid.' }, outgoing);
+                    }
+                    envelope = protocol.decodeRequest(decoded);
+                }
             }
             catch (input) {
                 return renderError(null, classifyError(input), outgoing);
             }
-            const publication = config.currentPublication?.(request);
-            if (config.currentPublication !== undefined && publication === undefined) {
+            if (!binaryRequest &&
+                config.binaryDownloadTarget !== undefined &&
+                protocol.targetPath(envelope.call.target) === config.binaryDownloadTarget) {
+                active.extend(config.binaryDownloadTimeoutMs);
+            }
+            if (active.signal.aborted) {
+                return renderError(envelope.requestId, classifyRequestError(active.signal.reason, active), outgoing);
+            }
+            const serving = config.serving?.(request);
+            const served = serving?.current();
+            if (serving !== undefined && served === undefined) {
                 return renderError(envelope.requestId, {
                     code: errors.CODES.BACKEND_UNAVAILABLE,
-                    message: 'Publication is unavailable.',
+                    message: `${serving.kind === 'release' ? 'Release' : 'Publication'} is unavailable.`,
                 }, outgoing, { status: 503 });
             }
             if (envelope.routing?.kind === 'via') {
-                if (publication === undefined) {
-                    return renderError(envelope.requestId, {
-                        code: errors.CODES.INVALID_REQUEST,
-                        message: 'Publication routing requires a Publication-backed destination.',
-                    }, outgoing);
+                const decision = admitVia(served, envelope.routing);
+                if (decision.kind === 'retired') {
+                    return renderDeploymentRetired(serving.deployment(), decision.release, cors);
                 }
-                const decision = publicationRouteDecision(publication.publication, envelope.routing.publication);
                 if (decision.kind === 'rejected') {
                     return renderError(envelope.requestId, decision.error, outgoing);
                 }
@@ -135,9 +174,20 @@ export function createHttpHandler(config) {
                     ...(envelope.delegate === undefined ? {} : { delegate: envelope.delegate }),
                     ...(envelope.routing?.kind === 'via' ? { via: envelope.routing } : {}),
                     ...(envelope.schema === undefined ? {} : { schema: envelope.schema }),
-                    ...(publication === undefined ? {} : { publication }),
-                    context: invocationContext(assigned, active, config.active, host, undefined, envelope.idempotencyKey),
+                    ...(served === undefined ? {} : pinned(served)),
+                    context: invocationContext(assigned, active, config.active, host, undefined, envelope.idempotencyKey, binary),
                 }));
+                if (binary !== undefined && result.kind !== 'redirect' && result.kind !== 'miss') {
+                    if (!binary.completed()) {
+                        if (result.kind === 'stream') {
+                            await result.stream.cancel('Binary request body was not fully consumed.');
+                        }
+                        else if (result.kind === 'binary' && isStreamingBinary(result.value)) {
+                            await result.value.body[Symbol.asyncIterator]().return?.();
+                        }
+                        throw new Error('Binary Function returned before consuming its request body.');
+                    }
+                }
                 const response = renderHttpResult(result, {
                     requestId: envelope.requestId,
                     codec: outgoing,
@@ -146,20 +196,12 @@ export function createHttpHandler(config) {
                     active,
                     maximumResponseBytes: config.maximumResponseBytes,
                 });
-                handedOff = result.kind === 'stream';
+                handedOff =
+                    result.kind === 'stream' || (result.kind === 'binary' && isStreamingBinary(result.value));
                 return response;
             }
             catch (input) {
-                if (active.timedOut) {
-                    return renderError(envelope.requestId, {
-                        code: errors.CODES.DEADLINE_EXCEEDED,
-                        message: 'Invocation deadline exceeded.',
-                    }, outgoing, { status: 504 });
-                }
-                if (active.signal.aborted) {
-                    return renderError(envelope.requestId, { code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }, outgoing, { status: 408 });
-                }
-                return renderError(envelope.requestId, classifyError(input), outgoing);
+                return renderError(envelope.requestId, classifyRequestError(input, active), outgoing);
             }
         }
         catch (input) {
@@ -168,6 +210,15 @@ export function createHttpHandler(config) {
             });
         }
         finally {
+            if (binary !== undefined) {
+                binary.cancel('binary invocation completed');
+            }
+            else if (binaryRequest &&
+                binary === undefined &&
+                request.body !== null &&
+                !request.body.locked) {
+                void request.body.cancel('binary request rejected').catch(() => undefined);
+            }
             if (!handedOff)
                 active.settle();
         }
@@ -178,4 +229,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,4 +1,7 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { BufferedBinaryResult, StreamingBinaryResult } from '@astrale-os/kernel-core/callable';
 import type { Codec } from '@astrale-os/kernel-protocol/codecs';
+import type { ReleaseDigest } from '@astrale-os/kernel-protocol/release';
 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';
@@ -19,14 +22,16 @@ export interface ErrorRenderOptions {
 }
 type HandlerResult = Awaited<ReturnType<Handler['dispatch']>>;
 export declare function renderHttpResult(result: HandlerResult, context: RenderContext): Response;
-export declare function renderBinary(requestId: protocol.RequestId, invocation: protocol.InvocationId, binary: Extract<HandlerResult, {
-    readonly kind: 'binary';
-}>['value']): protocol.BinaryResponse;
+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.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;
+/** Retirement controls always use JSON, regardless of the negotiated request codec. */
+export declare function renderDeploymentRetired(deployment: IssuerId, release: ReleaseDigest | undefined, cors: CorsHeaders): 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

package/dist/transport/http/render.js

@@ -1,7 +1,9 @@
+import { json } 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 { deploymentRetiredBody, deploymentRetiredHeaders, HTTP_DEPLOYMENT_RETIRED, HTTP_DEPLOYMENT_RETIRED_STATUS, } from '@astrale-os/kernel-protocol/routes/deployment-retired';
 import { HTTP_ROUTE_MISS, HTTP_ROUTE_STALE } from '@astrale-os/kernel-protocol/routes/routing';
-import { classifyError } from '../../errors/index.js';
+import { classifyError, retryAfterHeaders } from '../../errors/index.js';
 import { ResponseBodyTooLargeError } from '../../errors/index.js';
 import { interruptedStreamError } from '../stream-error.js';
 export function renderHttpResult(result, context) {
@@ -19,6 +21,8 @@ export function renderHttpResult(result, context) {
         case 'miss':
             return settled(context.active, envelopeResponse(context.codec, protocol.miss(context.requestId, context.invocation), context.cors(), 200, true, context.maximumResponseBytes));
         case 'binary': {
+            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));
         }
@@ -41,6 +45,7 @@ export function renderBinary(requestId, invocation, binary) {
         invocation,
         body: binary.body,
         mediaType: binary.mediaType,
+        status: binary.status ?? 200,
         ...(binary.headers === undefined ? {} : { headers: binary.headers }),
     });
 }
@@ -54,12 +59,20 @@ export function renderRedirect(requestId, invocation, redirect) {
 }
 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, requestId, invocation }, { ...cors(), ...extra }, status, options.negotiated ?? true, options.maximumResponseBytes);
+    const retry = retryAfterHeaders(error);
+    const extra = status === 401 ? { 'www-authenticate': 'Bearer realm="astrale-invocation"' } : retry;
+    return errorEnvelopeResponse(codec, { error, requestId, invocation }, { ...cors(Object.keys(retry)), ...extra }, status, options.negotiated ?? true, options.maximumResponseBytes);
 }
 export function renderHttpStale(requestId, invocation, current, codec, cors, maximumResponseBytes) {
     return envelopeResponse(codec, protocol.stale(requestId, invocation, current), cors(), 200, true, maximumResponseBytes);
 }
+/** Retirement controls always use JSON, regardless of the negotiated request codec. */
+export function renderDeploymentRetired(deployment, release, cors) {
+    return new Response(toBody(json.encode(deploymentRetiredBody(deployment, release))), {
+        status: HTTP_DEPLOYMENT_RETIRED_STATUS,
+        headers: { ...cors([HTTP_DEPLOYMENT_RETIRED]), ...deploymentRetiredHeaders() },
+    });
+}
 export function encodeEnvelope(codec, input) {
     return codec.encode(input);
 }
@@ -75,11 +88,141 @@ 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) {
+    if (binary.length !== undefined && (!Number.isSafeInteger(binary.length) || binary.length < 0)) {
+        throw new TypeError('Streaming binary length must be a non-negative safe integer.');
+    }
+    const delivery = binary.delivery;
+    if (delivery !== undefined) {
+        if (!Number.isSafeInteger(delivery.maximumDurationMs) ||
+            delivery.maximumDurationMs <= 0 ||
+            delivery.maximumDurationMs > 2_147_483_647 ||
+            !Number.isSafeInteger(delivery.idleTimeoutMs) ||
+            delivery.idleTimeoutMs <= 0 ||
+            delivery.idleTimeoutMs > 2_147_483_647) {
+            throw new TypeError('Streaming binary delivery budget is invalid.');
+        }
+        context.active.extend(delivery.maximumDurationMs);
+    }
+    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);
+    if (binary.length !== undefined) {
+        headers.set('content-length', String(binary.length));
+        // Content-Length belongs to HTTP and an intermediary may rewrite it; the Client counts the
+        // delivered bytes against this protocol field instead.
+        headers.set(protocol.http.BINARY_LENGTH_FIELD, String(binary.length));
+    }
+    if (delivery !== undefined)
+        headers.set('cache-control', 'private, no-store');
+    let terminal = false;
+    let delivered = 0;
+    let controller;
+    let stopping;
+    let idleTimer;
+    const clearIdle = () => {
+        if (idleTimer !== undefined)
+            clearTimeout(idleTimer);
+    };
+    const resetIdle = () => {
+        if (delivery === undefined || terminal)
+            return;
+        clearIdle();
+        idleTimer = setTimeout(() => context.active.cancel('binary response idle timeout exceeded'), delivery.idleTimeoutMs);
+    };
+    const stop = (reason = 'Binary response was interrupted.') => {
+        if (terminal)
+            return stopping ?? Promise.resolve();
+        terminal = true;
+        clearIdle();
+        controller?.error(new Error(reason));
+        stopping = Promise.resolve().then(async () => {
+            try {
+                await iterator.return?.();
+            }
+            finally {
+                context.active.settle();
+            }
+        });
+        return stopping;
+    };
+    const fail = (cause) => {
+        if (terminal)
+            return;
+        terminal = true;
+        clearIdle();
+        controller?.error(cause);
+        stopping = Promise.resolve()
+            .then(() => iterator.return?.())
+            .catch(() => undefined)
+            .then(() => context.active.settle());
+    };
+    const body = new ReadableStream({
+        start(output) {
+            controller = output;
+            resetIdle();
+        },
+        async pull(controller) {
+            if (terminal)
+                return;
+            try {
+                const next = await iterator.next();
+                if (terminal)
+                    return;
+                if (next.done) {
+                    if (binary.length !== undefined && delivered !== binary.length) {
+                        fail(new Error('OUTCOME_UNKNOWN: streaming binary ended before its declared length.'));
+                        return;
+                    }
+                    terminal = true;
+                    clearIdle();
+                    controller.close();
+                    context.active.settle();
+                    return;
+                }
+                if (!(next.value instanceof Uint8Array)) {
+                    throw new TypeError('Streaming binary yielded a non-byte chunk.');
+                }
+                delivered += next.value.byteLength;
+                if (binary.length !== undefined && delivered > binary.length) {
+                    fail(new Error('OUTCOME_UNKNOWN: streaming binary exceeded its declared length.'));
+                    return;
+                }
+                controller.enqueue(next.value);
+                resetIdle();
+            }
+            catch (cause) {
+                fail(cause);
+            }
+        },
+        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, protocol.http.BINARY_LENGTH_FIELD]
+            : []),
         ...applicationHeaders,
     ]));
     for (const [name, value] of Object.entries(binary.headers ?? {})) {
@@ -90,9 +233,12 @@ function binaryHttpResponse(binary, cors, maximumResponseBytes) {
     headers.set(protocol.http.BINARY_HEADERS_FIELD, protocol.http.encodeBinaryHeaderNames(binary.headers));
     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]();
@@ -286,4 +432,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 { 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): ErrorPayload;
-//# sourceMappingURL=stream-error.d.ts.map

package/dist/transport/stream-error.js

@@ -11,4 +11,3 @@ export function interruptedStreamError(timedOut) {
             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,7 +1,7 @@
 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 { RequestServing } from '../../release/served.js';
 import type { WebSocketHandlers } from '../types.js';
 import { type ApplicationHost, type Handler } from '../../invocation/index.js';
 export interface WebSocketSessionConfig {
@@ -13,9 +13,9 @@ export interface WebSocketSessionConfig {
     readonly maximumRequestBytes: number;
     readonly maximumResponseBytes: number;
     readonly invocationTimeoutMs: number;
-    readonly currentPublication?: () => PublicationSnapshot | undefined;
+    /** Present exactly when the Server serves a release or a Publication; bound to the upgrade. */
+    readonly serving?: RequestServing;
     readonly host?: ApplicationHost;
 }
 /** Build one socket-pinned transport session. */
 export declare function createWebSocketSession(config: WebSocketSessionConfig): WebSocketHandlers;
-//# sourceMappingURL=session.d.ts.map