@astrale-os/kernel-server 0.5.0-beta.69 → 0.5.0-beta.70

package/dist/server.js

@@ -1,12 +1,14 @@
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
 import { Path } from '@astrale-os/kernel-core/path';
-import { PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
+import { PATH as RELEASE_PATH, url as releaseUrl } from '@astrale-os/kernel-protocol/release';
+import { PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/release/legacy';
 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 { currentServed, mountRoutes } from './routes/index.js';
 import { createHttpHandler } from './transport/http/handler.js';
 import { createServerRouter } from './transport/router.js';
 import { handleWebSocketUpgrade } from './transport/websocket/upgrade.js';
@@ -29,6 +31,21 @@ function createPreparedServer(input, config) {
     const externalIssuer = config.issuer?.issuer;
     const externalOrigin = config.publicOrigin ??
         (externalIssuer === undefined ? undefined : new URL(externalIssuer).origin);
+    const source = config.serving;
+    const serving = source === undefined
+        ? undefined
+        : (request) => {
+            const origin = externalOrigin ?? new URL(request.url).origin;
+            return Object.freeze({
+                kind: source.kind,
+                current: () => currentServed(source, config.limits, {
+                    origin,
+                    ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
+                    reservations: config.routeReservations,
+                }),
+                deployment: () => acceptIssuer(origin),
+            });
+        };
     const handleHttp = createHttpHandler({
         handler,
         active,
@@ -36,15 +53,7 @@ function createPreparedServer(input, config) {
         ...config.limits,
         cors: config.cors,
         websocket: config.websocket !== undefined,
-        ...(config.publication === undefined
-            ? {}
-            : {
-                currentPublication: (request) => currentPublicationSnapshot(config.publication, config.limits, {
-                    origin: externalOrigin ?? new URL(request.url).origin,
-                    ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
-                    reservations: config.routeReservations,
-                })?.snapshot,
-            }),
+        ...(serving === undefined ? {} : { serving }),
     });
     if (config.websocket !== undefined) {
         app.get(config.path, (context) => handleWebSocketUpgrade({
@@ -55,15 +64,7 @@ function createPreparedServer(input, config) {
             invocation: config.invocation,
             ...config.limits,
             cors: config.cors,
-            ...(config.publication === undefined
-                ? {}
-                : {
-                    currentPublication: () => currentPublicationSnapshot(config.publication, config.limits, {
-                        origin: externalOrigin ?? new URL(context.req.raw.url).origin,
-                        ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
-                        reservations: config.routeReservations,
-                    })?.snapshot,
-                }),
+            ...(serving === undefined ? {} : { serving: serving(context.req.raw) }),
             host: hosts.get(context.req.raw),
         }));
     }
@@ -83,8 +84,8 @@ function createPreparedServer(input, config) {
     if (config.issuer !== undefined) {
         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.invocation, config.limits, config.cors, (request) => hosts.get(request), config.routeReservations, externalIssuer, externalOrigin);
+    if (config.serving !== undefined) {
+        mountRoutes(app, config.serving, config.delivery, handler, active, config.invocation, config.limits, config.cors, (request) => hosts.get(request), config.routeReservations, externalIssuer, externalOrigin);
     }
     app.onError((_error, context) => new Response('{"error":"Internal server error."}', {
         status: 500,
@@ -149,23 +150,31 @@ function admitOptions(config) {
             probe: captureHealthProbe(config.health.probe),
         });
     const websocket = config.websocket === undefined ? undefined : captureWebSocket(config.websocket);
-    const publication = config.publication === undefined ? undefined : capturePublicationSource(config.publication);
+    if (config.release !== undefined && config.publication !== undefined) {
+        throw new TypeError('Server options take at most one of release and publication.');
+    }
+    const serving = config.release !== undefined
+        ? Object.freeze({ kind: 'release', source: captureReleaseSource(config.release) })
+        : config.publication !== undefined
+            ? Object.freeze({
+                kind: 'publication',
+                source: capturePublicationSource(config.publication),
+            })
+            : undefined;
     const delivery = config.delivery === undefined ? undefined : captureDeliveryProvider(config.delivery);
-    if (delivery !== undefined && publication === undefined) {
-        throw new TypeError('Publication Delivery requires a Publication source.');
+    if (delivery !== undefined && serving === undefined) {
+        throw new TypeError('Delivery requires a release or Publication source.');
     }
-    const publicationPath = publication === undefined
-        ? undefined
-        : issuer === undefined
-            ? protocolPublicationPath()
-            : protocolPublicationPath(issuer.issuer);
+    const documentPaths = serving === undefined ? [] : servedDocumentPaths(serving.kind, issuer?.issuer);
     if (health?.path === path)
         throw new TypeError('Health and invocation paths must be distinct.');
-    if (publicationPath === path) {
-        throw new TypeError('Publication and invocation paths must be distinct.');
-    }
-    if (health !== undefined && publicationPath === health.path) {
-        throw new TypeError('Health and Publication paths must be distinct.');
+    for (const { name, path: documentPath } of documentPaths) {
+        if (documentPath === path) {
+            throw new TypeError(`${name} and invocation paths must be distinct.`);
+        }
+        if (health !== undefined && documentPath === health.path) {
+            throw new TypeError(`Health and ${name} paths must be distinct.`);
+        }
     }
     if (issuer !== undefined) {
         const issuerReservations = issuerRouteReservations(issuer, tokenExchange !== undefined);
@@ -190,13 +199,13 @@ function admitOptions(config) {
         ...(health === undefined ? {} : { health }),
         ...(issuer === undefined ? {} : { issuer }),
         ...(tokenExchange === undefined ? {} : { tokenExchange }),
-        ...(publication === undefined ? {} : { publication }),
+        ...(serving === undefined ? {} : { serving }),
         ...(delivery === undefined ? {} : { delivery }),
-        routeReservations: routeReservations(path, health?.path, issuer, websocket !== undefined, tokenExchange !== undefined, publicationPath),
+        routeReservations: routeReservations(path, health?.path, issuer, websocket !== undefined, tokenExchange !== undefined, documentPaths.map(({ path: documentPath }) => documentPath)),
         ...(websocket === undefined ? {} : { websocket }),
     });
 }
-function routeReservations(invocationPath, healthPath, issuer, websocket, tokenExchange, publicationPath) {
+function routeReservations(invocationPath, healthPath, issuer, websocket, tokenExchange, documentPaths) {
     const reservations = [
         Object.freeze({
             path: invocationPath,
@@ -209,15 +218,23 @@ function routeReservations(invocationPath, healthPath, issuer, websocket, tokenE
     if (issuer !== undefined) {
         reservations.push(...issuerRouteReservations(issuer, tokenExchange));
     }
-    if (publicationPath !== undefined) {
-        reservations.push(Object.freeze({ path: publicationPath, methods: Object.freeze(['GET']) }));
+    for (const documentPath of documentPaths) {
+        reservations.push(Object.freeze({ path: documentPath, methods: Object.freeze(['GET']) }));
     }
     return Object.freeze(reservations);
 }
-function protocolPublicationPath(issuer) {
-    if (issuer === undefined)
-        return PUBLICATION_PATH;
-    return new URL(publicationUrl(issuer)).pathname;
+function servedDocumentPaths(kind, issuer) {
+    const publication = {
+        name: 'Publication',
+        path: issuer === undefined ? PUBLICATION_PATH : new URL(publicationUrl(issuer)).pathname,
+    };
+    if (kind === 'publication')
+        return [publication];
+    const release = {
+        name: 'Release',
+        path: issuer === undefined ? RELEASE_PATH : new URL(releaseUrl(issuer)).pathname,
+    };
+    return [release, publication];
 }
 function captureHealthProbe(probe) {
     const check = captureMethod(probe, 'check', 'Health probe is invalid.');
@@ -227,12 +244,16 @@ function captureWebSocket(adapter) {
     const upgrade = captureMethod(adapter, 'upgrade', 'WebSocket adapter is invalid.');
     return Object.freeze({ upgrade });
 }
+function captureReleaseSource(input) {
+    const current = captureMethod(input, 'current', 'Release source is invalid.');
+    return Object.freeze({ current });
+}
 function capturePublicationSource(input) {
     const current = captureMethod(input, 'current', 'Publication source is invalid.');
     return Object.freeze({ current });
 }
 function captureDeliveryProvider(input) {
-    const create = captureMethod(input, 'create', 'Publication Delivery provider is invalid.');
+    const create = captureMethod(input, 'create', 'Delivery provider is invalid.');
     return Object.freeze({ create });
 }
 function admitLimits(limits) {

package/dist/transport/codecs.d.ts

@@ -1,4 +1,4 @@
 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]>;
+/** The built-in Server representation set before pure Protocol binding selection. */
+export declare function loadCodecs(): readonly [codecs.Codec];

package/dist/transport/codecs.js

@@ -1,5 +1,6 @@
 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()]);
+const SUPPORTED = Object.freeze([codecs.json]);
+/** The built-in Server representation set before pure Protocol binding selection. */
+export function loadCodecs() {
+    return SUPPORTED;
 }

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

@@ -1,7 +1,7 @@
 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 { RequestServing } from '../../release/served.js';
 import { type ApplicationHost, type Handler } from '../../invocation/index.js';
 export interface HttpHandlerConfig {
     readonly handler: Handler;
@@ -17,6 +17,7 @@ export interface HttpHandlerConfig {
     readonly binaryDownloadTimeoutMs?: number;
     readonly cors: CorsPolicy;
     readonly websocket: boolean;
-    readonly currentPublication?: (request: Request) => PublicationSnapshot | undefined;
+    /** Present exactly when the Server serves a release or a Publication. */
+    readonly serving?: (request: Request) => RequestServing;
 }
 export declare function createHttpHandler(config: HttpHandlerConfig): (request: Request, host?: ApplicationHost) => Promise<Response>;

package/dist/transport/http/handler.js

@@ -2,12 +2,13 @@ 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 { admissionRefusal, classifyError, classifyRequestError, RequestBodyInvalidError, RequestBodyTooLargeError, } 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 { readBoundedBody } from '../body.js';
 import { loadCodecs } from '../codecs.js';
 import { resolveCredential } from '../credential.js';
 import { binaryRequestBody } from './binary-request.js';
-import { isStreamingBinary, renderHttpError, renderHttpResult, } from './render.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);
@@ -55,15 +56,19 @@ export function createHttpHandler(config) {
         let handedOff = false;
         let binary;
         try {
-            const supported = await loadCodecs();
+            const supported = loadCodecs();
             const contentType = request.headers.get('content-type');
-            const incoming = binaryRequest || 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);
@@ -139,21 +144,19 @@ export function createHttpHandler(config) {
             if (active.signal.aborted) {
                 return renderError(envelope.requestId, classifyRequestError(active.signal.reason, active), outgoing);
             }
-            const publication = config.currentPublication?.(request);
-            if (config.currentPublication !== undefined && publication === undefined) {
+            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);
                 }
@@ -171,7 +174,7 @@ 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 }),
+                    ...(served === undefined ? {} : pinned(served)),
                     context: invocationContext(assigned, active, config.active, host, undefined, envelope.idempotencyKey, binary),
                 }));
                 if (binary !== undefined && result.kind !== 'redirect' && result.kind !== 'miss') {

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

@@ -1,5 +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';
@@ -26,6 +28,8 @@ export declare function renderRedirect(requestId: protocol.RequestId, invocation
 }>['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';

package/dist/transport/http/render.js

@@ -1,5 +1,7 @@
+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, retryAfterHeaders } from '../../errors/index.js';
 import { ResponseBodyTooLargeError } from '../../errors/index.js';
@@ -64,6 +66,13 @@ export function renderHttpError(requestId, invocation, error, codec, cors, optio
 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);
 }
@@ -111,9 +120,8 @@ function streamingBinaryHttpResponse(binary, context) {
         // delivered bytes against this protocol field instead.
         headers.set(protocol.http.BINARY_LENGTH_FIELD, String(binary.length));
     }
-    // Clients that predate the protocol length count against Content-Length, which an intermediary
-    // that re-encodes the stream would rewrite, so a compressible media type would fail delivery.
-    headers.set('cache-control', delivery === undefined ? 'no-store, no-transform' : 'private, no-store, no-transform');
+    if (delivery !== undefined)
+        headers.set('cache-control', 'private, no-store');
     let terminal = false;
     let delivered = 0;
     let controller;

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,7 +13,8 @@ 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. */

package/dist/transport/websocket/session.js

@@ -1,8 +1,10 @@
 import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { deploymentRetiredBody } from '@astrale-os/kernel-protocol/routes/deployment-retired';
 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 { isStreamingBinary, renderBinary, renderRedirect } from '../http/render.js';
@@ -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: `${serving.kind === 'release' ? 'Release' : 'Publication'} 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;
                 }
             }
@@ -142,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);

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

package/dist/transport/websocket/upgrade.js

@@ -11,7 +11,7 @@ export async function handleWebSocketUpgrade(config) {
         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));
@@ -26,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,

package/dist/types.d.ts

@@ -1,8 +1,9 @@
 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 { Provider as DeliveryProvider } from './release/delivery/index.js';
+import type { ReleaseSource } from './release/index.js';
+import type { PublicationSource } from './release/legacy/index.js';
 import type { Application, WebSocketAdapter } from './transport/index.js';
 export interface ServerLimits {
     readonly maximumRequestBytes: number;
@@ -12,6 +13,7 @@ export interface ServerLimits {
     readonly maximumResponseBytes?: number;
     /** Maximum Server-owned active operations across all mounted protocol surfaces. */
     readonly maximumConcurrentOperations?: number;
+    /** Maximum bytes of each served discovery document (`release.json` and `domain.json`). */
     readonly maximumPublicationBytes?: number;
     readonly maximumBundleBytes?: number;
     readonly maximumDeliveryBytes?: number;
@@ -51,8 +53,19 @@ export interface ServerOptions {
     readonly publicOrigin?: string;
     /** Present only for the configured self issuer; owns verification and signing. */
     readonly tokenExchange?: exchange.Provider;
+    /**
+     * The release this deployment serves: `release.json`, its frozen v3 projection at `domain.json`,
+     * its bundle, Delivery v1 and v2, and its native routes; routed calls are admitted only for this
+     * exact release. At most one of `release` and `publication`; with neither, the Server serves no
+     * document and admits no routed call.
+     */
+    readonly release?: ReleaseSource;
+    /** @deprecated Use `release`. Publication sources allow ETag and Schema drift when routing. */
     readonly publication?: PublicationSource;
-    /** Required exactly when the current Publication advertises delivery. */
+    /**
+     * Required exactly when the current release or Publication advertises delivery. With `release`
+     * it must answer Delivery v2 and v1; a v1-only provider fits only `publication`.
+     */
     readonly delivery?: DeliveryProvider;
     readonly websocket?: WebSocketAdapter;
 }
@@ -73,5 +86,7 @@ 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';
+export type { Provider as DeliveryProvider } from './release/delivery/index.js';
+export type { ReleaseSnapshot, ReleaseSnapshotInput, ReleaseSource } from './release/index.js';
+export type { PublicationSnapshot, PublicationSnapshotInput, PublicationSource, } from './release/legacy/index.js';
 export type { Application, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './transport/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-server",
-  "version": "0.5.0-beta.69",
+  "version": "0.5.0-beta.70",
   "description": "Portable HTTP and WebSocket boundary for Astrale invocation, publication, installation, and issuer protocols",
   "license": "Apache-2.0",
   "repository": {
@@ -20,8 +20,8 @@
       "import": "./dist/index.js"
     },
     "./publication/snapshot": {
-      "types": "./dist/publication/snapshot.d.ts",
-      "import": "./dist/publication/snapshot.js"
+      "types": "./dist/release/legacy/snapshot.d.ts",
+      "import": "./dist/release/legacy/snapshot.js"
     },
     "./server": {
       "types": "./dist/server.d.ts",
@@ -33,11 +33,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "0.9.0-beta.61",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.43",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.67",
-    "hono": "^4.6.20",
-    "msgpackr": "^2.0.5"
+    "@astrale-os/kernel-core": "0.9.0-beta.62",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.44",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.68",
+    "hono": "^4.6.20"
   },
   "devDependencies": {
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",

package/dist/publication/delivery/handler.d.ts

@@ -1,9 +0,0 @@
-import type { ActiveOperations } from '../../lifecycle/index.js';
-import type { PreparedPublicationSnapshot } from '../snapshot.js';
-import type { Provider } from './types.js';
-export interface Limits {
-    readonly maximumDeliveryBytes: number;
-    readonly invocationTimeoutMs: number;
-}
-/** Serve one delivery request against the exact Publication snapshot that selected its URL. */
-export declare function handleDelivery(request: Request, snapshot: PreparedPublicationSnapshot, provider: Provider | undefined, active: ActiveOperations, limits: Limits, corsFor: (exposedHeaders?: readonly string[]) => Readonly<Record<string, string>>): Promise<Response>;

package/dist/publication/delivery/types.d.ts

@@ -1,11 +0,0 @@
-import type * as publication from '@astrale-os/kernel-protocol/publication';
-export interface Context {
-    /** Omitted for a public endpoint; otherwise the exact admitted retrieval credential. */
-    readonly token?: publication.delivery.Token;
-    readonly signal: AbortSignal;
-}
-/** Provider-owned retrieval, construction, and attestation signing. */
-export interface Provider {
-    /** Throw DeliveryUnavailableError only for an expected dependency outage. */
-    create(request: publication.delivery.Request, context: Context): Promise<publication.delivery.Delivery>;
-}

package/dist/publication/index.d.ts

@@ -1,3 +0,0 @@
-export { preparePublicationSnapshot, readPreparedPublicationSnapshot, type PreparedPublicationSnapshot, } from './snapshot.js';
-export type { PublicationSnapshot, PublicationSnapshotInput, PublicationSource } from './types.js';
-export * as delivery from './delivery/index.js';

package/dist/publication/index.js

@@ -1,2 +0,0 @@
-export { preparePublicationSnapshot, readPreparedPublicationSnapshot, } from './snapshot.js';
-export * as delivery from './delivery/index.js';

package/dist/publication/table.d.ts

@@ -1,4 +0,0 @@
-import type { Domain } from '@astrale-os/kernel-dsl/v1';
-import type * as publication from '@astrale-os/kernel-protocol/publication';
-import type * as routes from '@astrale-os/kernel-protocol/routes';
-export declare function admitTable(deployed: publication.Publication, input: routes.Table | undefined, domain: Domain): routes.Table;