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

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

@@ -1,18 +1,23 @@
 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;
     readonly active: ActiveOperations;
     readonly invocation: NextInvocationId;
     readonly maximumRequestBytes: number;
+    readonly maximumBinaryRequestBytes: number;
     readonly maximumResponseBytes: number;
     readonly invocationTimeoutMs: number;
+    readonly binaryRequestTimeoutMs: number;
+    readonly binaryRequestIdleTimeoutMs?: number;
+    readonly binaryDownloadTarget?: string;
+    readonly binaryDownloadTimeoutMs?: number;
     readonly cors: CorsPolicy;
     readonly websocket: boolean;
-    readonly currentPublication?: (request: Request) => PublicationSnapshot | undefined;
+    /** 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>;
-//# sourceMappingURL=handler.d.ts.map

package/dist/transport/http/handler.js

@@ -1,12 +1,16 @@
 import * as codecs from '@astrale-os/kernel-protocol/codecs';
 import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
-import { classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../../errors/index.js';
-import { invocationContext, publicationRouteDecision, } from '../../invocation/index.js';
+import { admissionRefusal, classifyError, classifyRequestError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../../errors/index.js';
+import { admitVia, invocationContext, } from '../../invocation/index.js';
+import { pinned } from '../../release/served.js';
 import { readBoundedBody } from '../body.js';
 import { loadCodecs } from '../codecs.js';
 import { resolveCredential } from '../credential.js';
-import { renderHttpError, renderHttpResult } from './render.js';
+import { isStreamingBinary } from '../result.js';
+import { binaryRequestBody } from './binary-request.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);
@@ -21,6 +25,8 @@ export function createHttpHandler(config) {
                 headers: [
                     'authorization',
                     'content-type',
+                    protocol.http.REQUEST_ENVELOPE_FIELD,
+                    protocol.http.BINARY_LENGTH_FIELD,
                     protocol.http.TRACEPARENT_FIELD,
                     protocol.http.TRACESTATE_FIELD,
                 ],
@@ -37,24 +43,34 @@ export function createHttpHandler(config) {
             ...options,
             maximumResponseBytes: config.maximumResponseBytes,
         });
-        const active = config.active.begin(config.invocationTimeoutMs, request.signal);
+        const binaryRequest = request.headers.get('content-type')?.trim().toLowerCase() ===
+            protocol.http.BINARY_REQUEST_CONTENT_TYPE;
+        const active = config.active.begin(binaryRequest ? config.binaryRequestTimeoutMs : config.invocationTimeoutMs, request.signal);
         if (active === undefined) {
-            return renderError(null, {
-                code: errors.CODES.BACKEND_UNAVAILABLE,
-                message: 'server is unavailable.',
-            }, codecs.json, { status: 503, negotiated: false });
+            if (binaryRequest && request.body !== null && !request.body.locked) {
+                void request.body.cancel('binary request rejected').catch(() => undefined);
+            }
+            return renderError(null, admissionRefusal(config.active.isAccepting), codecs.json, {
+                status: 503,
+                negotiated: false,
+            });
         }
         let handedOff = false;
+        let binary;
         try {
-            const supported = await loadCodecs();
+            const supported = loadCodecs();
             const contentType = request.headers.get('content-type');
-            const incoming = contentType === null || contentType.trim() === ''
+            // No default representation: a body without a declared Astrale type is never decoded, so a
+            // browser cannot send an admissible invocation from another origin without a CORS preflight.
+            const incoming = binaryRequest
                 ? codecs.json
                 : protocol.http.codecForContentType(contentType, supported);
             if (incoming === undefined) {
                 return renderError(null, {
                     code: errors.CODES.UNSUPPORTED,
-                    message: 'Unsupported request Content-Type.',
+                    message: contentType === null || contentType.trim() === ''
+                        ? 'Missing request Content-Type.'
+                        : 'Unsupported request Content-Type.',
                 }, codecs.json, { status: 415, negotiated: false });
             }
             const outgoing = protocol.http.negotiateResponseCodec(request.headers.get('accept'), incoming, supported);
@@ -66,7 +82,15 @@ export function createHttpHandler(config) {
             }
             let body;
             try {
-                body = await readBoundedBody(request, config.maximumRequestBytes, active.signal);
+                if (binaryRequest)
+                    binary = binaryRequestBody(request, config.maximumBinaryRequestBytes, active.signal, config.binaryRequestIdleTimeoutMs === undefined
+                        ? undefined
+                        : {
+                            timeoutMs: config.binaryRequestIdleTimeoutMs,
+                            cancel: () => active.cancel('binary request idle timeout exceeded'),
+                        });
+                else
+                    body = await readBoundedBody(request, config.maximumRequestBytes, active.signal);
             }
             catch (input) {
                 const payload = input instanceof RequestBodyTooLargeError
@@ -87,37 +111,54 @@ export function createHttpHandler(config) {
                     status: input instanceof RequestBodyTooLargeError ? 413 : errors.httpStatusOf(payload),
                 });
             }
-            let decoded;
-            try {
-                decoded = incoming.decode(body);
-            }
-            catch (input) {
-                if (!(input instanceof codecs.DecodeError))
-                    throw input;
-                return renderError(null, { code: errors.CODES.PARSE_ERROR, message: 'Request body is invalid.' }, outgoing);
-            }
             let envelope;
             try {
-                envelope = protocol.decodeRequest(decoded);
+                if (binaryRequest) {
+                    envelope = protocol.http.decodeBinaryRequestEnvelope(request.headers.get(protocol.http.REQUEST_ENVELOPE_FIELD));
+                    if (envelope.idempotencyKey !== undefined) {
+                        return renderError(envelope.requestId, {
+                            code: errors.CODES.INVALID_REQUEST,
+                            message: 'Binary requests forbid idempotencyKey.',
+                        }, outgoing);
+                    }
+                }
+                else {
+                    let decoded;
+                    try {
+                        decoded = incoming.decode(body);
+                    }
+                    catch (input) {
+                        if (!(input instanceof codecs.DecodeError))
+                            throw input;
+                        return renderError(null, { code: errors.CODES.PARSE_ERROR, message: 'Request body is invalid.' }, outgoing);
+                    }
+                    envelope = protocol.decodeRequest(decoded);
+                }
             }
             catch (input) {
                 return renderError(null, classifyError(input), outgoing);
             }
-            const publication = config.currentPublication?.(request);
-            if (config.currentPublication !== undefined && publication === undefined) {
+            if (!binaryRequest &&
+                config.binaryDownloadTarget !== undefined &&
+                protocol.targetPath(envelope.call.target) === config.binaryDownloadTarget) {
+                active.extend(config.binaryDownloadTimeoutMs);
+            }
+            if (active.signal.aborted) {
+                return renderError(envelope.requestId, classifyRequestError(active.signal.reason, active), outgoing);
+            }
+            const serving = config.serving?.(request);
+            const served = serving?.current();
+            if (serving !== undefined && served === undefined) {
                 return renderError(envelope.requestId, {
                     code: errors.CODES.BACKEND_UNAVAILABLE,
-                    message: 'Publication is unavailable.',
+                    message: 'Release is unavailable.',
                 }, outgoing, { status: 503 });
             }
             if (envelope.routing?.kind === 'via') {
-                if (publication === undefined) {
-                    return renderError(envelope.requestId, {
-                        code: errors.CODES.INVALID_REQUEST,
-                        message: 'Publication routing requires a Publication-backed destination.',
-                    }, outgoing);
+                const decision = admitVia(served, envelope.routing);
+                if (decision.kind === 'retired') {
+                    return renderDeploymentRetired(serving.deployment(), decision.release, cors);
                 }
-                const decision = publicationRouteDecision(publication.publication, envelope.routing.publication);
                 if (decision.kind === 'rejected') {
                     return renderError(envelope.requestId, decision.error, outgoing);
                 }
@@ -135,9 +176,20 @@ export function createHttpHandler(config) {
                     ...(envelope.delegate === undefined ? {} : { delegate: envelope.delegate }),
                     ...(envelope.routing?.kind === 'via' ? { via: envelope.routing } : {}),
                     ...(envelope.schema === undefined ? {} : { schema: envelope.schema }),
-                    ...(publication === undefined ? {} : { publication }),
-                    context: invocationContext(assigned, active, config.active, host, undefined, envelope.idempotencyKey),
+                    ...(served === undefined ? {} : pinned(served)),
+                    context: invocationContext(assigned, active, config.active, host, undefined, envelope.idempotencyKey, binary),
                 }));
+                if (binary !== undefined && result.kind !== 'redirect' && result.kind !== 'miss') {
+                    if (!binary.completed()) {
+                        if (result.kind === 'stream') {
+                            await result.stream.cancel('Binary request body was not fully consumed.');
+                        }
+                        else if (result.kind === 'binary' && isStreamingBinary(result.value)) {
+                            await result.value.body[Symbol.asyncIterator]().return?.();
+                        }
+                        throw new Error('Binary Function returned before consuming its request body.');
+                    }
+                }
                 const response = renderHttpResult(result, {
                     requestId: envelope.requestId,
                     codec: outgoing,
@@ -146,20 +198,12 @@ export function createHttpHandler(config) {
                     active,
                     maximumResponseBytes: config.maximumResponseBytes,
                 });
-                handedOff = result.kind === 'stream';
+                handedOff =
+                    result.kind === 'stream' || (result.kind === 'binary' && isStreamingBinary(result.value));
                 return response;
             }
             catch (input) {
-                if (active.timedOut) {
-                    return renderError(envelope.requestId, {
-                        code: errors.CODES.DEADLINE_EXCEEDED,
-                        message: 'Invocation deadline exceeded.',
-                    }, outgoing, { status: 504 });
-                }
-                if (active.signal.aborted) {
-                    return renderError(envelope.requestId, { code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }, outgoing, { status: 408 });
-                }
-                return renderError(envelope.requestId, classifyError(input), outgoing);
+                return renderError(envelope.requestId, classifyRequestError(input, active), outgoing);
             }
         }
         catch (input) {
@@ -168,6 +212,15 @@ export function createHttpHandler(config) {
             });
         }
         finally {
+            if (binary !== undefined) {
+                binary.cancel('binary invocation completed');
+            }
+            else if (binaryRequest &&
+                binary === undefined &&
+                request.body !== null &&
+                !request.body.locked) {
+                void request.body.cancel('binary request rejected').catch(() => undefined);
+            }
             if (!handedOff)
                 active.settle();
         }
@@ -178,4 +231,3 @@ function noStore(response) {
     headers.set('cache-control', 'no-store');
     return new Response(response.body, { status: response.status, headers });
 }
-//# sourceMappingURL=handler.js.map

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

@@ -1,3 +1,4 @@
 export { createHttpHandler, type HttpHandlerConfig } from './handler.js';
-export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, type CorsHeaders, type ErrorRenderOptions, type RenderContext, } from './render.js';
-//# sourceMappingURL=index.d.ts.map
+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,3 +1,3 @@
 export { createHttpHandler } from './handler.js';
-export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, } from './render.js';
-//# sourceMappingURL=index.js.map
+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,32 +1,4 @@
-import type { Codec } from '@astrale-os/kernel-protocol/codecs';
-import * as errors from '@astrale-os/kernel-protocol/errors';
-import * as protocol from '@astrale-os/kernel-protocol/invocation';
-import type { Handler } from '../../invocation/index.js';
-import type { ActiveOperation } from '../../lifecycle/index.js';
-export interface RenderContext {
-    readonly 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: Extract<HandlerResult, {
-    readonly kind: 'binary';
-}>['value']): 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;
-export declare function encodeEnvelope(codec: Codec, input: unknown): string | Uint8Array;
-export {};
-//# sourceMappingURL=render.d.ts.map

package/dist/transport/http/render.js

@@ -1,289 +1,38 @@
-import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
-import { HTTP_ROUTE_MISS, HTTP_ROUTE_STALE } from '@astrale-os/kernel-protocol/routes/routing';
-import { classifyError } from '../../errors/index.js';
-import { ResponseBodyTooLargeError } from '../../errors/index.js';
-import { interruptedStreamError } from '../stream-error.js';
+import { isStreamingBinary, renderBinary, renderRedirect } from '../result.js';
+import { binaryHttpResponse } from './binary.js';
+import { streamingBinaryHttpResponse } from './byte-stream.js';
+import { envelopeResponse } from './response.js';
+import { streamHttpResponse } from './stream.js';
+/** Render one admitted Handler result and retain only live producers in the active operation. */
 export function renderHttpResult(result, context) {
+    let envelope;
     switch (result.kind) {
         case 'value':
-            return settled(context.active, envelopeResponse(context.codec, {
+            envelope = {
                 result: result.value,
                 requestId: context.requestId,
                 invocation: context.invocation,
-            }, context.cors(), 200, true, context.maximumResponseBytes));
-        case 'redirect': {
-            const response = renderRedirect(context.requestId, context.invocation, result.redirect);
-            return settled(context.active, envelopeResponse(context.codec, response, context.cors(), 200, true, context.maximumResponseBytes));
-        }
+            };
+            break;
+        case 'redirect':
+            envelope = renderRedirect(context.requestId, context.invocation, result.redirect);
+            break;
         case 'miss':
-            return settled(context.active, envelopeResponse(context.codec, protocol.miss(context.requestId, context.invocation), context.cors(), 200, true, context.maximumResponseBytes));
+            envelope = protocol.miss(context.requestId, context.invocation);
+            break;
         case 'binary': {
+            if (isStreamingBinary(result.value))
+                return streamingBinaryHttpResponse(result.value, context);
             const binary = renderBinary(context.requestId, context.invocation, result.value);
             return settled(context.active, binaryHttpResponse(binary, context.cors, context.maximumResponseBytes));
         }
         case 'stream':
             return streamHttpResponse(result.stream, context);
     }
-}
-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,
-        ...(binary.headers === undefined ? {} : { headers: binary.headers }),
-    });
-}
-export function renderRedirect(requestId, invocation, redirect) {
-    return protocol.decodeRedirectResponse({
-        kind: 'redirect',
-        requestId,
-        invocation,
-        redirect,
-    });
-}
-export function renderHttpError(requestId, invocation, error, codec, cors, options = {}) {
-    const status = options.status ?? errors.httpStatusOf(error);
-    const extra = status === 401 ? { 'www-authenticate': 'Bearer realm="astrale-invocation"' } : {};
-    return errorEnvelopeResponse(codec, { error, requestId, invocation }, { ...cors(), ...extra }, status, options.negotiated ?? true, options.maximumResponseBytes);
-}
-export function renderHttpStale(requestId, invocation, current, codec, cors, maximumResponseBytes) {
-    return envelopeResponse(codec, protocol.stale(requestId, invocation, current), cors(), 200, true, maximumResponseBytes);
-}
-export function encodeEnvelope(codec, input) {
-    return codec.encode(input);
-}
-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 binaryHttpResponse(binary, cors, maximumResponseBytes) {
-    requireResponseBound(binary.body, maximumResponseBytes);
-    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,
-        ...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));
-    headers.set('cache-control', 'no-store');
-    appendVary(headers, 'accept');
-    return new Response(toBody(binary.body), { status: 200, headers });
-}
-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 bindingHeaders(input, negotiated) {
-    const headers = new Headers(input);
-    headers.set('cache-control', 'no-store');
-    if (negotiated)
-        appendVary(headers, 'accept');
-    return headers;
-}
-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),
-            });
-        }
-    }
-}
-function encodeBoundedStreamFrame(codec, frame, maximumResponseBytes) {
-    const encoded = protocol.http.encodeStreamFrame(codec, frame);
-    if (encoded.byteLength - 4 > maximumResponseBytes) {
-        throw new ResponseBodyTooLargeError(maximumResponseBytes);
-    }
-    return encoded;
-}
-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);
+    return settled(context.active, envelopeResponse(context.codec, envelope, context.cors(), 200, true, context.maximumResponseBytes));
 }
 function settled(operation, response) {
     operation.settle();
     return response;
 }
-function appendVary(headers, value) {
-    headers.set('vary', mergeVary(Object.fromEntries(headers), value));
-}
-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(', ');
-}
-function cancellationFrame(context) {
-    return {
-        kind: 'stream.error',
-        requestId: context.requestId,
-        error: interruptedStreamError(context.active.timedOut),
-    };
-}
-function toBody(input) {
-    if (typeof input === 'string')
-        return input;
-    const copy = new Uint8Array(input);
-    return copy.buffer;
-}
-//# sourceMappingURL=render.js.map

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

@@ -0,0 +1,14 @@
+import type { Codec } from '@astrale-os/kernel-protocol/codecs';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
+/** Encode a bounded envelope with its binding content type and cache policy. */
+export declare function envelopeResponse(codec: Codec, input: unknown, cors: Readonly<Record<string, string>>, status?: number, negotiated?: boolean, maximumResponseBytes?: number): Response;
+/** Bound an error, falling back to a correlated limit refusal or an empty response. */
+export declare function errorEnvelopeResponse(codec: Codec, response: protocol.ErrorResponse, cors: Readonly<Record<string, string>>, status: number, negotiated: boolean, maximumResponseBytes: number | undefined): Response;
+/** Enforce the configured byte budget before a buffered response is handed off. */
+export declare function requireResponseBound(input: string | Uint8Array, maximumResponseBytes: number | undefined): void;
+/** Retain existing Vary fields while declaring another response selector. */
+export declare function appendVary(headers: Headers, value: string): void;
+/** Merge one case-insensitive selector into the response Vary field. */
+export declare function mergeVary(headers: Readonly<Record<string, string>>, value: string): string;
+/** Detach encoded bytes for Fetch while retaining encoded text as text. */
+export declare function toBody(input: string | Uint8Array): BodyInit;