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

package/dist/transport/http/response.js

@@ -0,0 +1,77 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import { ResponseBodyTooLargeError } from '../../errors/index.js';
+/** Encode a bounded envelope with its binding content type and cache policy. */
+export function envelopeResponse(codec, input, cors, status = 200, negotiated = true, maximumResponseBytes) {
+    const encoded = codec.encode(input);
+    requireResponseBound(encoded, maximumResponseBytes);
+    const headers = bindingHeaders(cors, negotiated);
+    headers.set('content-type', codec.contentType);
+    return new Response(toBody(encoded), {
+        status,
+        headers,
+    });
+}
+function bindingHeaders(input, negotiated) {
+    const headers = new Headers(input);
+    headers.set('cache-control', 'no-store');
+    if (negotiated)
+        appendVary(headers, 'accept');
+    return headers;
+}
+/** Bound an error, falling back to a correlated limit refusal or an empty response. */
+export function errorEnvelopeResponse(codec, response, cors, status, negotiated, maximumResponseBytes) {
+    try {
+        return envelopeResponse(codec, response, cors, status, negotiated, maximumResponseBytes);
+    }
+    catch (error) {
+        if (!(error instanceof ResponseBodyTooLargeError))
+            throw error;
+        const fallback = {
+            requestId: response.requestId,
+            invocation: response.invocation,
+            error: {
+                code: errors.CODES.LIMIT_EXCEEDED,
+                message: 'Response body exceeds the configured limit.',
+            },
+        };
+        try {
+            return envelopeResponse(codec, fallback, cors, errors.httpStatusOf(fallback.error), negotiated, maximumResponseBytes);
+        }
+        catch (fallbackError) {
+            if (!(fallbackError instanceof ResponseBodyTooLargeError))
+                throw fallbackError;
+            return new Response(null, {
+                status: 500,
+                headers: bindingHeaders(cors, negotiated),
+            });
+        }
+    }
+}
+/** Enforce the configured byte budget before a buffered response is handed off. */
+export function requireResponseBound(input, maximumResponseBytes) {
+    if (maximumResponseBytes === undefined)
+        return;
+    const bytes = typeof input === 'string' ? new TextEncoder().encode(input).byteLength : input.byteLength;
+    if (bytes > maximumResponseBytes)
+        throw new ResponseBodyTooLargeError(maximumResponseBytes);
+}
+/** Retain existing Vary fields while declaring another response selector. */
+export function appendVary(headers, value) {
+    headers.set('vary', mergeVary(Object.fromEntries(headers), value));
+}
+/** Merge one case-insensitive selector into the response Vary field. */
+export function mergeVary(headers, value) {
+    const names = new Set((headers.vary ?? '')
+        .split(',')
+        .map((name) => name.trim().toLowerCase())
+        .filter(Boolean));
+    names.add(value.toLowerCase());
+    return [...names].join(', ');
+}
+/** Detach encoded bytes for Fetch while retaining encoded text as text. */
+export function toBody(input) {
+    if (typeof input === 'string')
+        return input;
+    const copy = new Uint8Array(input);
+    return copy.buffer;
+}

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

@@ -0,0 +1,5 @@
+import type { RenderContext } from './model.js';
+/** Frame ordered Invocation items and retain cleanup until the producer settles. */
+export declare function streamHttpResponse(stream: AsyncIterable<unknown> & {
+    cancel(reason?: string): Promise<void>;
+}, context: RenderContext): Response;

package/dist/transport/http/stream.js

@@ -0,0 +1,134 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { classifyError, ResponseBodyTooLargeError } from '../../errors/index.js';
+import { interruptedStreamError } from '../stream-error.js';
+import { mergeVary } from './response.js';
+/** Frame ordered Invocation items and retain cleanup until the producer settles. */
+export function streamHttpResponse(stream, context) {
+    const iterator = stream[Symbol.asyncIterator]();
+    const startFrame = encodeBoundedStreamFrame(context.codec, { kind: 'stream.start', requestId: context.requestId, invocation: context.invocation }, context.maximumResponseBytes);
+    let count = 0;
+    let terminal = false;
+    let controller;
+    let stopping;
+    const stop = (reason) => {
+        stopping ??= stopStream(reason);
+        return stopping;
+    };
+    async function stopStream(reason) {
+        if (terminal)
+            return;
+        terminal = true;
+        // End the wire response immediately. Producer cleanup remains part of the active operation,
+        // but an uncooperative producer must not leave the client waiting for a terminal frame.
+        if (controller !== undefined) {
+            try {
+                controller.enqueue(encodeBoundedStreamFrame(context.codec, cancellationFrame(context), context.maximumResponseBytes));
+            }
+            catch {
+                // The transport consumer may already have disconnected.
+            }
+            try {
+                controller.close();
+            }
+            catch {
+                // The stream may already be closed or cancelled by the consumer.
+            }
+        }
+        try {
+            await Promise.allSettled([
+                Promise.resolve().then(() => stream.cancel(reason)),
+                Promise.resolve().then(() => iterator.return?.()),
+            ]);
+        }
+        finally {
+            context.active.settle();
+        }
+    }
+    const body = new ReadableStream({
+        start(output) {
+            controller = output;
+            output.enqueue(startFrame);
+        },
+        async pull(output) {
+            if (terminal)
+                return;
+            try {
+                const next = await iterator.next();
+                if (terminal)
+                    return;
+                if (next.done) {
+                    terminal = true;
+                    output.enqueue(encodeBoundedStreamFrame(context.codec, {
+                        kind: 'stream.end',
+                        requestId: context.requestId,
+                        count,
+                    }, context.maximumResponseBytes));
+                    output.close();
+                    context.active.settle();
+                    return;
+                }
+                const frame = protocol.decodeStreamFrame({
+                    kind: 'stream.item',
+                    requestId: context.requestId,
+                    index: count,
+                    value: next.value,
+                });
+                output.enqueue(encodeBoundedStreamFrame(context.codec, frame, context.maximumResponseBytes));
+                count += 1;
+            }
+            catch (input) {
+                if (terminal)
+                    return;
+                terminal = true;
+                if (!context.active.signal.aborted) {
+                    try {
+                        output.enqueue(encodeBoundedStreamFrame(context.codec, {
+                            kind: 'stream.error',
+                            requestId: context.requestId,
+                            error: classifyError(input),
+                        }, context.maximumResponseBytes));
+                    }
+                    catch {
+                        // No valid terminal frame can be formed; closing is the only remaining signal.
+                    }
+                }
+                output.close();
+                await Promise.allSettled([
+                    Promise.resolve().then(() => stream.cancel('stream failed')),
+                    Promise.resolve().then(() => iterator.return?.()),
+                ]);
+                context.active.settle();
+            }
+        },
+        async cancel(reason) {
+            const message = typeof reason === 'string' ? reason : 'response consumer cancelled';
+            context.active.cancel(message);
+            await stop(message);
+        },
+    });
+    context.active.onCancel(stop);
+    return new Response(body, {
+        status: 200,
+        headers: {
+            ...context.cors([protocol.http.STREAM_FRAMING_FIELD]),
+            'cache-control': 'no-store',
+            'content-type': context.codec.contentType,
+            vary: mergeVary(context.cors(), 'accept'),
+            [protocol.http.STREAM_FRAMING_FIELD]: protocol.http.LENGTH_PREFIX_V1,
+        },
+    });
+}
+function encodeBoundedStreamFrame(codec, frame, maximumResponseBytes) {
+    const encoded = protocol.http.encodeStreamFrame(codec, frame);
+    if (encoded.byteLength - 4 > maximumResponseBytes) {
+        throw new ResponseBodyTooLargeError(maximumResponseBytes);
+    }
+    return encoded;
+}
+function cancellationFrame(context) {
+    return {
+        kind: 'stream.error',
+        requestId: context.requestId,
+        error: interruptedStreamError(context.active.timedOut),
+    };
+}

package/dist/transport/index.d.ts

@@ -1,10 +1,10 @@
+export { renderBinary, renderRedirect } from './result.js';
 export { byteLength, readBoundedBody } from './body.js';
 export { loadCodecs, type LoadedCodec } from './codecs.js';
 export { resolveCredential, type CredentialResult } from './credential.js';
 export { createHttpHandler, type HttpHandlerConfig } from './http/index.js';
-export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, type CorsHeaders, type ErrorRenderOptions, type RenderContext, } from './http/index.js';
+export { renderHttpError, renderHttpResult, renderHttpStale, type CorsHeaders, type ErrorRenderOptions, type RenderContext, } from './http/index.js';
 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

@@ -1,9 +1,9 @@
+export { renderBinary, renderRedirect } from './result.js';
 export { byteLength, readBoundedBody } from './body.js';
 export { loadCodecs } from './codecs.js';
 export { resolveCredential } from './credential.js';
 export { createHttpHandler } from './http/index.js';
-export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, } from './http/index.js';
+export { renderHttpError, renderHttpResult, renderHttpStale, } from './http/index.js';
 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/result.d.ts

@@ -0,0 +1,13 @@
+import type { BufferedBinaryResult, StreamingBinaryResult } from '@astrale-os/kernel-core/callable';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import type { HandlerResult } from '../invocation/index.js';
+/** Admit one buffered binary result into the shared Invocation envelope. */
+export declare function renderBinary(requestId: protocol.RequestId, invocation: protocol.InvocationId, binary: BufferedBinaryResult): protocol.BinaryResponse;
+/** Admit a semantic redirect without selecting an HTTP or WebSocket binding. */
+export declare function renderRedirect(requestId: protocol.RequestId, invocation: protocol.InvocationId, redirect: Extract<HandlerResult, {
+    readonly kind: 'redirect';
+}>['redirect']): protocol.RedirectResponse;
+/** Identify a binary producer whose lifetime stays with its transport. */
+export declare function isStreamingBinary(input: Extract<HandlerResult, {
+    readonly kind: 'binary';
+}>['value']): input is StreamingBinaryResult;

package/dist/transport/result.js

@@ -0,0 +1,35 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { HTTP_ROUTE_MISS, HTTP_ROUTE_STALE } from '@astrale-os/kernel-protocol/routes';
+/** Admit one buffered binary result into the shared Invocation envelope. */
+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',
+        requestId,
+        invocation,
+        body: binary.body,
+        mediaType: binary.mediaType,
+        status: binary.status ?? 200,
+        ...(binary.headers === undefined ? {} : { headers: binary.headers }),
+    });
+}
+/** Admit a semantic redirect without selecting an HTTP or WebSocket binding. */
+export function renderRedirect(requestId, invocation, redirect) {
+    return protocol.decodeRedirectResponse({
+        kind: 'redirect',
+        requestId,
+        invocation,
+        redirect,
+    });
+}
+/** Identify a binary producer whose lifetime stays with its transport. */
+export function isStreamingBinary(input) {
+    return !(input.body instanceof Uint8Array);
+}

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

package/dist/transport/websocket/session.js

@@ -1,11 +1,13 @@
 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 { deploymentRetiredBody } from '@astrale-os/kernel-protocol/routes';
+import { admissionRefusal, classifyError, classifyRequestError } from '../../errors/index.js';
 import { ResponseBodyTooLargeError } from '../../errors/index.js';
-import { invocationContext, publicationRouteDecision, } from '../../invocation/index.js';
+import { admitVia, invocationContext, } from '../../invocation/index.js';
+import { pinned } from '../../release/served.js';
 import { byteLength } from '../body.js';
 import { resolveCredential } from '../credential.js';
-import { renderBinary, renderRedirect } from '../http/render.js';
+import { isStreamingBinary, renderBinary, renderRedirect } from '../result.js';
 import { interruptedStreamError } from '../stream-error.js';
 const WS_OPEN = 1;
 /** Build one socket-pinned transport session. */
@@ -100,25 +102,23 @@ export function createWebSocketSession(config) {
                 }, sendOutput);
                 return;
             }
-            const publication = config.currentPublication?.();
-            if (config.currentPublication !== undefined && publication === undefined) {
+            const serving = config.serving;
+            const served = serving?.current();
+            if (serving !== undefined && served === undefined) {
                 await sendError(socket, admittedCodec, envelope.requestId, assigned, {
                     code: errors.CODES.BACKEND_UNAVAILABLE,
-                    message: 'Publication is unavailable.',
+                    message: 'Release is unavailable.',
                 }, sendOutput);
                 return;
             }
             if (envelope.routing?.kind === 'via') {
-                if (publication === undefined) {
-                    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, envelope.routing.publication);
-                if (decision.kind === 'rejected') {
-                    await sendError(socket, admittedCodec, envelope.requestId, assigned, decision.error, sendOutput);
+                const decision = admitVia(served, envelope.routing);
+                if (decision.kind !== 'admitted') {
+                    // A socket has no HTTP status: a retired deployment answers this request with the
+                    // DEPLOYMENT_RETIRED error payload of the reserved control, correlated to its request.
+                    await sendError(socket, admittedCodec, envelope.requestId, assigned, decision.kind === 'retired'
+                        ? deploymentRetiredBody(serving.deployment(), decision.release).error
+                        : decision.error, sendOutput);
                     return;
                 }
             }
@@ -129,10 +129,7 @@ export function createWebSocketSession(config) {
             }
             const operation = config.active.begin(config.invocationTimeoutMs);
             if (operation === undefined) {
-                await sendError(socket, admittedCodec, envelope.requestId, assigned, {
-                    code: errors.CODES.BACKEND_UNAVAILABLE,
-                    message: 'server is unavailable.',
-                }, sendOutput);
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, admissionRefusal(config.active.isAccepting), sendOutput);
                 return;
             }
             operations.set(key, operation);
@@ -145,7 +142,7 @@ export function createWebSocketSession(config) {
                     ...(envelope.delegate === undefined ? {} : { delegate: envelope.delegate }),
                     ...(envelope.routing?.kind === 'via' ? { via: envelope.routing } : {}),
                     ...(envelope.schema === undefined ? {} : { schema: envelope.schema }),
-                    ...(publication === undefined ? {} : { publication }),
+                    ...(served === undefined ? {} : pinned(served)),
                     context: invocationContext(assigned, operation, config.active, config.host, undefined, envelope.idempotencyKey),
                 }));
                 await sendResult(socket, admittedCodec, envelope.requestId, assigned, result, operation, sendOutput);
@@ -155,14 +152,7 @@ export function createWebSocketSession(config) {
                     return;
                 }
                 if (socket.readyState === WS_OPEN) {
-                    const error = operation.timedOut
-                        ? {
-                            code: errors.CODES.DEADLINE_EXCEEDED,
-                            message: 'Invocation deadline exceeded.',
-                        }
-                        : operation.signal.aborted
-                            ? { code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }
-                            : classifyError(input);
+                    const error = classifyRequestError(input, operation);
                     if (error.code === errors.CODES.INTERNAL_ERROR) {
                         socket.close(1011, 'Internal error');
                         return;
@@ -211,6 +201,17 @@ async function sendResult(socket, codec, requestId, assigned, result, operation,
             await send(socket, codec, protocol.miss(requestId, assigned), sendOutput);
             return;
         case 'binary': {
+            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));
@@ -333,4 +334,3 @@ function isCancelRequest(input) {
         !Array.isArray(input) &&
         input.kind === 'cancel');
 }
-//# sourceMappingURL=session.js.map

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

@@ -2,7 +2,7 @@ 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 { RequestServing } from '../../release/served.js';
 import type { WebSocketAdapter } from '../types.js';
 export interface WebSocketHandlerConfig {
     readonly request: Request;
@@ -14,8 +14,7 @@ export interface WebSocketHandlerConfig {
     readonly maximumResponseBytes: number;
     readonly invocationTimeoutMs: number;
     readonly cors: CorsPolicy;
-    readonly currentPublication?: () => PublicationSnapshot | undefined;
+    readonly serving?: RequestServing;
     readonly host?: ApplicationHost;
 }
 export declare function handleWebSocketUpgrade(config: WebSocketHandlerConfig): Promise<Response>;
-//# sourceMappingURL=upgrade.d.ts.map

package/dist/transport/websocket/upgrade.js

@@ -1,14 +1,17 @@
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { admissionRefusal, retryAfterHeaders } from '../../errors/index.js';
 import { loadCodecs } from '../codecs.js';
 import { createWebSocketSession } from './session.js';
 export async function handleWebSocketUpgrade(config) {
     if (!config.cors.allowsBrowserOrigin(config.request))
         return failure(403);
     const operation = config.active.begin(config.invocationTimeoutMs, config.request.signal);
-    if (operation === undefined)
-        return failure(503, config.cors.response(config.request));
+    if (operation === undefined) {
+        const retry = retryAfterHeaders(admissionRefusal(config.active.isAccepting));
+        return failure(503, { ...config.cors.response(config.request, Object.keys(retry)), ...retry });
+    }
     try {
-        const supported = await loadCodecs();
+        const supported = loadCodecs();
         const selection = protocol.websocket.selectSubprotocol(config.request.headers.get('sec-websocket-protocol'), supported);
         if (selection === undefined)
             return failure(400, config.cors.response(config.request));
@@ -23,9 +26,7 @@ export async function handleWebSocketUpgrade(config) {
                 maximumRequestBytes: config.maximumRequestBytes,
                 maximumResponseBytes: config.maximumResponseBytes,
                 invocationTimeoutMs: config.invocationTimeoutMs,
-                ...(config.currentPublication === undefined
-                    ? {}
-                    : { currentPublication: config.currentPublication }),
+                ...(config.serving === undefined ? {} : { serving: config.serving }),
                 ...(config.host === undefined ? {} : { host: config.host }),
             }),
             signal: operation.signal,
@@ -44,4 +45,3 @@ function failure(status, input = {}) {
         headers: { ...input, 'cache-control': 'no-store' },
     });
 }
-//# sourceMappingURL=upgrade.js.map

package/dist/types.d.ts

@@ -1,20 +1,32 @@
 import type { CorsConfig } from './cors/index.js';
 import type { Handler, InvocationSource } from './invocation/index.js';
-import type { exchange, Issuer } from './issuer/index.js';
-import type { Provider as DeliveryProvider } from './publication/delivery/index.js';
-import type { PublicationSource } from './publication/index.js';
+import type { Context as ExchangeContext, Provider as ExchangeProvider } from './issuer/exchange.js';
+import type { Issuer } from './issuer/index.js';
+import type { Provider as DeliveryProvider } from './release/delivery/index.js';
+import type { ReleaseSource } from './release/index.js';
 import type { Application, WebSocketAdapter } from './transport/index.js';
 export interface ServerLimits {
     readonly maximumRequestBytes: number;
-    /** Maximum bytes in one encoded envelope, finite-binary body, or stream frame. */
+    /** Deployment cap for a streamed binary HTTP request; defaults to maximumRequestBytes. */
+    readonly maximumBinaryRequestBytes?: number;
+    /** Maximum bytes in one encoded envelope, buffered binary body, or stream frame. */
     readonly maximumResponseBytes?: number;
     /** Maximum Server-owned active operations across all mounted protocol surfaces. */
     readonly maximumConcurrentOperations?: number;
-    readonly maximumPublicationBytes?: number;
+    /** Maximum bytes of each served discovery document (`release.json`). */
+    readonly maximumReleaseBytes?: number;
     readonly maximumBundleBytes?: number;
     readonly maximumDeliveryBytes?: number;
     /** Maximum lifetime of one invocation, including a returned stream. */
     readonly invocationTimeoutMs: number;
+    /** Binary request lifetime; defaults to invocationTimeoutMs. */
+    readonly binaryRequestTimeoutMs?: number;
+    /** Maximum wait for the next binary body chunk while a consumer is reading. */
+    readonly binaryRequestIdleTimeoutMs?: number;
+    /** Exact Host-selected callable Path whose ordinary JSON invocation may stream a large result. */
+    readonly binaryDownloadTarget?: string;
+    /** Required with binaryDownloadTarget; selected before semantic dispatch. */
+    readonly binaryDownloadTimeoutMs?: number;
 }
 export interface ServerCloseOptions {
     /** Absolute Unix time in milliseconds after which active work is cancelled. */
@@ -37,10 +49,16 @@ export interface ServerOptions {
         readonly probe: HealthProbe;
     } | false;
     readonly issuer?: Issuer;
+    /** Public HTTP origin for transport placement, independent of the stable issuer. */
+    readonly publicOrigin?: string;
     /** Present only for the configured self issuer; owns verification and signing. */
     readonly tokenExchange?: exchange.Provider;
-    readonly publication?: PublicationSource;
-    /** Required exactly when the current Publication advertises delivery. */
+    /**
+     * Exact release, bundle, Delivery v2 and native routes served by this deployment. With no
+     * source the Server serves no document and admits no routed call.
+     */
+    readonly release?: ReleaseSource;
+    /** Required exactly when the current release advertises Delivery. */
     readonly delivery?: DeliveryProvider;
     readonly websocket?: WebSocketAdapter;
 }
@@ -60,7 +78,12 @@ export interface Server {
 export type { CorsConfig } from './cors/index.js';
 export type { InvocationSource } from './invocation/index.js';
 export type { ApplicationHost, ExecutionControl, Handler, HandlerRequest, HandlerResult, HandlerStream, InvocationContext, RequestBackground, RequestEvidence, RequestSleep, } from './invocation/index.js';
-export type { exchange, Issuer } from './issuer/index.js';
-export type { PublicationSnapshot, PublicationSnapshotInput, PublicationSource, } from './publication/index.js';
+/** Public token-exchange provider contract; transport capture and mounting stay private. */
+export declare namespace exchange {
+    type Context = ExchangeContext;
+    type Provider = ExchangeProvider;
+}
+export type { Issuer } from './issuer/index.js';
+export type { Provider as DeliveryProvider } from './release/delivery/index.js';
+export type { ReleaseSnapshot, ReleaseSnapshotInput, ReleaseSource } from './release/index.js';
 export type { Application, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './transport/index.js';
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

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