@astrale-os/kernel-server 0.5.0-beta.73 → 0.5.0-beta.75

package/dist/routes/snapshot.js

@@ -0,0 +1,39 @@
+import * as routes from '@astrale-os/kernel-protocol/routes';
+import { readServed, servedDocument } from '../release/served.js';
+/**
+ * Read the one snapshot a request pins, withheld while it exceeds a serving limit, names another
+ * serving issuer, or claims a route this Server reserves.
+ */
+export function currentServed(source, limits, serving) {
+    const prepared = readServed(source);
+    if (prepared === undefined ||
+        prepared.releaseBytes.byteLength > limits.maximumReleaseBytes ||
+        prepared.bundle.byteLength > limits.maximumBundleBytes ||
+        (serving?.issuer !== undefined &&
+            servedDocument(prepared).identity.issuer !== serving.issuer) ||
+        (serving !== undefined && conflictsWithServingRoutes(prepared, serving))) {
+        return undefined;
+    }
+    return prepared;
+}
+/** Admit the one request snapshot against its trusted origin and reserved routes. */
+export function servingSnapshot(source, limits, request, reservations, externalIssuer, publicOrigin) {
+    return currentServed(source, limits, {
+        origin: publicOrigin ??
+            (externalIssuer === undefined ? new URL(request.url).origin : new URL(externalIssuer).origin),
+        ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
+        reservations,
+    });
+}
+function conflictsWithServingRoutes(snapshot, serving) {
+    for (const reservation of serving.reservations) {
+        const href = `${serving.origin}${reservation.path}`;
+        for (const entry of snapshot.table.entries) {
+            if (reservation.methods.some((method) => entry.method === '*' || entry.method === method) &&
+                routes.templatesOverlap(entry.href, href)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/routes/stream.d.ts

@@ -0,0 +1,6 @@
+import type { ActiveOperation } from '../lifecycle/index.js';
+import type { CorsHeaders } from './model.js';
+/** Render native item frames while retaining cancellation and producer cleanup. */
+export declare function streamResponse(stream: AsyncIterable<unknown> & {
+    cancel(reason?: string): Promise<void>;
+}, operation: ActiveOperation, cors: CorsHeaders): Promise<Response>;

package/dist/routes/stream.js

@@ -0,0 +1,122 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import * as routes from '@astrale-os/kernel-protocol/routes';
+import { classifyError, classifyRequestError } from '../errors/index.js';
+import { interruptedStreamError } from '../transport/stream-error.js';
+import { nativeError, response } from './response.js';
+/** Render native item frames while retaining cancellation and producer cleanup. */
+export async function streamResponse(stream, operation, cors) {
+    const iterator = stream[Symbol.asyncIterator]();
+    let rejectSetup;
+    const setupInterrupted = new Promise((_resolve, reject) => {
+        rejectSetup = reject;
+    });
+    let setupCleanup;
+    const cancelSetup = (reason) => {
+        rejectSetup(operation.signal.reason ?? new Error(reason));
+        setupCleanup ??= Promise.allSettled([
+            Promise.resolve().then(() => stream.cancel(reason)),
+            Promise.resolve().then(() => iterator.return?.()),
+        ]).then(() => operation.settle());
+        return setupCleanup;
+    };
+    const unregisterSetupCancellation = operation.onCancel(cancelSetup);
+    let first;
+    try {
+        first = await Promise.race([iterator.next(), setupInterrupted]);
+    }
+    catch (cause) {
+        unregisterSetupCancellation();
+        const cleanup = cancelSetup('native stream setup failed');
+        if (!operation.signal.aborted)
+            await cleanup;
+        const payload = classifyRequestError(cause, operation);
+        return nativeError(payload, errors.httpStatusOf(payload), cors);
+    }
+    unregisterSetupCancellation();
+    if (operation.signal.aborted) {
+        void cancelSetup('native stream setup cancelled');
+        const payload = classifyRequestError(operation.signal.reason, operation);
+        return response({ error: payload }, errors.httpStatusOf(payload), cors());
+    }
+    const encoder = new TextEncoder();
+    let pending = first;
+    let terminal = false;
+    let controller;
+    let stopping;
+    const encoded = (frame) => encoder.encode(routes.encodeStreamFrame(frame));
+    const stop = (reason, error) => {
+        stopping ??= (async () => {
+            if (terminal)
+                return;
+            terminal = true;
+            if (controller !== undefined) {
+                if (error !== undefined) {
+                    try {
+                        controller.enqueue(encoded({ kind: 'error', error }));
+                    }
+                    catch {
+                        // The transport consumer may already have disconnected.
+                    }
+                }
+                try {
+                    controller.close();
+                }
+                catch {
+                    // A cancelled response body is already terminal.
+                }
+            }
+            try {
+                await Promise.allSettled([
+                    Promise.resolve().then(() => stream.cancel(reason)),
+                    Promise.resolve().then(() => iterator.return?.()),
+                ]);
+            }
+            finally {
+                operation.settle();
+            }
+        })();
+        return stopping;
+    };
+    const body = new ReadableStream({
+        start(output) {
+            controller = output;
+        },
+        async pull(output) {
+            if (terminal)
+                return;
+            try {
+                const next = pending ?? (await iterator.next());
+                pending = undefined;
+                if (terminal)
+                    return;
+                if (next.done) {
+                    terminal = true;
+                    output.enqueue(encoded({ kind: 'end' }));
+                    output.close();
+                    operation.settle();
+                }
+                else {
+                    output.enqueue(encoded({ kind: 'item', value: next.value }));
+                }
+            }
+            catch (cause) {
+                await stop('native stream failed', operation.signal.aborted
+                    ? interruptedStreamError(operation.timedOut)
+                    : classifyError(cause));
+            }
+        },
+        async cancel(reason) {
+            const message = typeof reason === 'string' ? reason : 'native response cancelled';
+            operation.cancel(message);
+            await stop(message);
+        },
+    });
+    operation.onCancel((reason) => stop(reason, interruptedStreamError(operation.timedOut)));
+    return new Response(body, {
+        headers: {
+            ...cors(),
+            'content-type': routes.STREAM_MEDIA_TYPE,
+            'cache-control': 'no-cache',
+        },
+    });
+}

package/dist/server.js

@@ -1,7 +1,6 @@
 import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
 import { Path } from '@astrale-os/kernel-core/path';
 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';
@@ -150,20 +149,12 @@ function admitOptions(config) {
             probe: captureHealthProbe(config.health.probe),
         });
     const websocket = config.websocket === undefined ? undefined : captureWebSocket(config.websocket);
-    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 serving = config.release === undefined
+        ? undefined
+        : Object.freeze({ kind: 'release', source: captureReleaseSource(config.release) });
     const delivery = config.delivery === undefined ? undefined : captureDeliveryProvider(config.delivery);
     if (delivery !== undefined && serving === undefined) {
-        throw new TypeError('Delivery requires a release or Publication source.');
+        throw new TypeError('Delivery requires a release source.');
     }
     const documentPaths = serving === undefined ? [] : servedDocumentPaths(serving.kind, issuer?.issuer);
     if (health?.path === path)
@@ -223,18 +214,13 @@ function routeReservations(invocationPath, healthPath, issuer, websocket, tokenE
     }
     return Object.freeze(reservations);
 }
-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 servedDocumentPaths(_kind, issuer) {
+    return [
+        {
+            name: 'Release',
+            path: issuer === undefined ? RELEASE_PATH : new URL(releaseUrl(issuer)).pathname,
+        },
+    ];
 }
 function captureHealthProbe(probe) {
     const check = captureMethod(probe, 'check', 'Health probe is invalid.');
@@ -248,10 +234,6 @@ 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', 'Delivery provider is invalid.');
     return Object.freeze({ create });
@@ -281,7 +263,7 @@ function admitLimits(limits) {
         maximumBinaryRequestBytes: admitOptionalLimit(limits.maximumBinaryRequestBytes, limits.maximumRequestBytes, 'maximumBinaryRequestBytes'),
         maximumResponseBytes: admitOptionalLimit(limits.maximumResponseBytes, 16 * 1024 * 1024, 'maximumResponseBytes'),
         maximumConcurrentOperations: admitOptionalLimit(limits.maximumConcurrentOperations, 1_024, 'maximumConcurrentOperations'),
-        maximumPublicationBytes: admitOptionalLimit(limits.maximumPublicationBytes, limits.maximumRequestBytes, 'maximumPublicationBytes'),
+        maximumReleaseBytes: admitOptionalLimit(limits.maximumReleaseBytes, limits.maximumRequestBytes, 'maximumReleaseBytes'),
         maximumBundleBytes: admitOptionalLimit(limits.maximumBundleBytes, 16 * 1024 * 1024, 'maximumBundleBytes'),
         maximumDeliveryBytes: admitOptionalLimit(limits.maximumDeliveryBytes, limits.maximumRequestBytes, 'maximumDeliveryBytes'),
         invocationTimeoutMs: limits.invocationTimeoutMs,

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

@@ -0,0 +1,6 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import type { CorsHeaders } from './model.js';
+/** Present admitted buffered bytes under the response budget and binary manifest. */
+export declare function binaryHttpResponse(binary: protocol.BinaryResponse, cors: CorsHeaders, maximumResponseBytes: number): Response;
+/** Bind binary correlation and application headers to the HTTP response. */
+export declare function binaryHttpHeaders(binary: Pick<protocol.BinaryResponse, 'headers' | 'invocation' | 'mediaType' | 'requestId'>, cors: CorsHeaders, streaming: boolean): Headers;

package/dist/transport/http/binary.js

@@ -0,0 +1,35 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { appendVary, requireResponseBound, toBody } from './response.js';
+/** Present admitted buffered bytes under the response budget and binary manifest. */
+export 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 });
+}
+/** Bind binary correlation and application headers to the HTTP response. */
+export 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 ?? {})) {
+        if (protocol.http.isApplicationBinaryHeader(name))
+            headers.set(name, value);
+    }
+    headers.set('content-type', binary.mediaType);
+    headers.set(protocol.http.BINARY_HEADERS_FIELD, protocol.http.encodeBinaryHeaderNames(binary.headers));
+    headers.set(protocol.http.REQUEST_ID_FIELD, String(binary.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 headers;
+}

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

@@ -0,0 +1,4 @@
+import type { StreamingBinaryResult } from '@astrale-os/kernel-core/callable';
+import type { RenderContext } from './model.js';
+/** Deliver raw binary chunks with exact length, idle budget and producer cleanup. */
+export declare function streamingBinaryHttpResponse(binary: StreamingBinaryResult, context: RenderContext): Response;

package/dist/transport/http/byte-stream.js

@@ -0,0 +1,123 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { binaryHttpHeaders } from './binary.js';
+/** Deliver raw binary chunks with exact length, idle budget and producer cleanup. */
+export 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 });
+}

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

@@ -0,0 +1,12 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+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 { CorsHeaders, ErrorRenderOptions } from './model.js';
+/** Render a correlated error with its status, authentication challenge and retry delay. */
+export declare function renderHttpError(requestId: protocol.RequestId, invocation: protocol.InvocationId, error: errors.ErrorPayload, codec: Codec, cors: CorsHeaders, options?: ErrorRenderOptions): Response;
+/** Present stale routing as a bounded status-200 Invocation envelope. */
+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;

package/dist/transport/http/control.js

@@ -0,0 +1,24 @@
+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';
+import { retryAfterHeaders } from '../../errors/index.js';
+import { envelopeResponse, errorEnvelopeResponse, toBody } from './response.js';
+/** Render a correlated error with its status, authentication challenge and retry delay. */
+export function renderHttpError(requestId, invocation, error, codec, cors, options = {}) {
+    const status = options.status ?? errors.httpStatusOf(error);
+    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);
+}
+/** Present stale routing as a bounded status-200 Invocation envelope. */
+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() },
+    });
+}

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

@@ -17,7 +17,7 @@ export interface HttpHandlerConfig {
     readonly binaryDownloadTimeoutMs?: number;
     readonly cors: CorsPolicy;
     readonly websocket: boolean;
-    /** Present exactly when the Server serves a release or a Publication. */
+    /** Present exactly when the Server serves a Release. */
     readonly serving?: (request: Request) => RequestServing;
 }
 export declare function createHttpHandler(config: HttpHandlerConfig): (request: Request, host?: ApplicationHost) => Promise<Response>;

package/dist/transport/http/handler.js

@@ -7,8 +7,10 @@ import { pinned } from '../../release/served.js';
 import { readBoundedBody } from '../body.js';
 import { loadCodecs } from '../codecs.js';
 import { resolveCredential } from '../credential.js';
+import { isStreamingBinary } from '../result.js';
 import { binaryRequestBody } from './binary-request.js';
-import { isStreamingBinary, renderDeploymentRetired, renderHttpError, renderHttpResult, } from './render.js';
+import { renderDeploymentRetired, renderHttpError } from './control.js';
+import { renderHttpResult } from './render.js';
 export function createHttpHandler(config) {
     return async (request, host) => {
         const cors = (exposedHeaders) => config.cors.response(request, exposedHeaders);
@@ -149,7 +151,7 @@ export function createHttpHandler(config) {
             if (serving !== undefined && served === undefined) {
                 return renderError(envelope.requestId, {
                     code: errors.CODES.BACKEND_UNAVAILABLE,
-                    message: `${serving.kind === 'release' ? 'Release' : 'Publication'} is unavailable.`,
+                    message: 'Release is unavailable.',
                 }, outgoing, { status: 503 });
             }
             if (envelope.routing?.kind === 'via') {

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

@@ -1,2 +1,4 @@
 export { createHttpHandler, type HttpHandlerConfig } from './handler.js';
-export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, type CorsHeaders, type ErrorRenderOptions, type RenderContext, } from './render.js';
+export { renderHttpResult } from './render.js';
+export { renderHttpError, renderHttpStale } from './control.js';
+export type { CorsHeaders, ErrorRenderOptions, RenderContext } from './model.js';

package/dist/transport/http/index.js

@@ -1,2 +1,3 @@
 export { createHttpHandler } from './handler.js';
-export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, } from './render.js';
+export { renderHttpResult } from './render.js';
+export { renderHttpError, renderHttpStale } from './control.js';

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

@@ -0,0 +1,20 @@
+import type { Codec } from '@astrale-os/kernel-protocol/codecs';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
+import type { ActiveOperation } from '../../lifecycle/index.js';
+/** Correlation, binding and active lifetime retained while presenting one result. */
+export interface RenderContext {
+    readonly requestId: protocol.RequestId;
+    readonly codec: Codec;
+    readonly cors: CorsHeaders;
+    readonly invocation: protocol.InvocationId;
+    readonly active: ActiveOperation;
+    readonly maximumResponseBytes: number;
+}
+/** Derive response headers with the transport fields exposed to the browser. */
+export type CorsHeaders = (exposedHeaders?: readonly string[]) => Readonly<Record<string, string>>;
+/** Bound and negotiate an error using the admitted request presentation. */
+export interface ErrorRenderOptions {
+    readonly status?: number;
+    readonly negotiated?: boolean;
+    readonly maximumResponseBytes?: number;
+}

package/dist/transport/http/model.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,37 +1,4 @@
-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';
-import type { ActiveOperation } from '../../lifecycle/index.js';
-export interface RenderContext {
-    readonly requestId: protocol.RequestId;
-    readonly codec: Codec;
-    readonly cors: CorsHeaders;
-    readonly invocation: protocol.InvocationId;
-    readonly active: ActiveOperation;
-    readonly maximumResponseBytes: number;
-}
-export type CorsHeaders = (exposedHeaders?: readonly string[]) => Readonly<Record<string, string>>;
-export interface ErrorRenderOptions {
-    readonly status?: number;
-    readonly negotiated?: boolean;
-    readonly maximumResponseBytes?: number;
-}
-type HandlerResult = Awaited<ReturnType<Handler['dispatch']>>;
+import type { HandlerResult } from '../../invocation/index.js';
+import type { RenderContext } from './model.js';
+/** Render one admitted Handler result and retain only live producers in the active operation. */
 export declare function renderHttpResult(result: HandlerResult, context: RenderContext): Response;
-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 {};