@astrale-os/kernel-server 0.5.0-beta.9 → 0.5.0

package/dist/transport/http/render.js

@@ -1,289 +1,45 @@
-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 'execution':
+            envelope = {
+                execution: result.execution,
+                requestId: context.requestId,
+                invocation: context.invocation,
+            };
+            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;

package/dist/transport/http/response.js

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

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

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

package/dist/transport/http/stream.js

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

package/dist/transport/index.d.ts

@@ -1,10 +1,10 @@
+export { renderBinary, renderRedirect } from './result.js';
 export { byteLength, readBoundedBody } from './body.js';
 export { loadCodecs, type LoadedCodec } from './codecs.js';
 export { resolveCredential, type CredentialResult } from './credential.js';
 export { createHttpHandler, type HttpHandlerConfig } from './http/index.js';
-export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, type CorsHeaders, type ErrorRenderOptions, type RenderContext, } from './http/index.js';
+export { renderHttpError, renderHttpResult, renderHttpStale, type CorsHeaders, type ErrorRenderOptions, type RenderContext, } from './http/index.js';
 export { interruptedStreamError } from './stream-error.js';
 export { createServerRouter, type ServerRouter } from './router.js';
 export { createWebSocketSession, handleWebSocketUpgrade, type WebSocketHandlerConfig, type WebSocketSessionConfig, } from './websocket/index.js';
 export type { Application, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/index.js

@@ -1,9 +1,9 @@
+export { renderBinary, renderRedirect } from './result.js';
 export { byteLength, readBoundedBody } from './body.js';
 export { loadCodecs } from './codecs.js';
 export { resolveCredential } from './credential.js';
 export { createHttpHandler } from './http/index.js';
-export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, renderHttpStale, renderRedirect, } from './http/index.js';
+export { renderHttpError, renderHttpResult, renderHttpStale, } from './http/index.js';
 export { interruptedStreamError } from './stream-error.js';
 export { createServerRouter } from './router.js';
 export { createWebSocketSession, handleWebSocketUpgrade, } from './websocket/index.js';
-//# sourceMappingURL=index.js.map

package/dist/transport/result.d.ts

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

package/dist/transport/result.js

@@ -0,0 +1,35 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { HTTP_ROUTE_MISS, HTTP_ROUTE_STALE } from '@astrale-os/kernel-protocol/routes';
+/** Admit one buffered binary result into the shared Invocation envelope. */
+export function renderBinary(requestId, invocation, binary) {
+    const reserved = Object.keys(binary.headers ?? {}).find((name) => {
+        const normalized = name.toLowerCase();
+        return (normalized === protocol.http.INVOCATION_FIELD ||
+            normalized === HTTP_ROUTE_STALE ||
+            normalized === HTTP_ROUTE_MISS);
+    });
+    if (reserved !== undefined)
+        throw new TypeError(`${reserved} is reserved by Protocol.`);
+    return protocol.decodeBinaryResponse({
+        kind: 'binary',
+        requestId,
+        invocation,
+        body: binary.body,
+        mediaType: binary.mediaType,
+        status: binary.status ?? 200,
+        ...(binary.headers === undefined ? {} : { headers: binary.headers }),
+    });
+}
+/** Admit a semantic redirect without selecting an HTTP or WebSocket binding. */
+export function renderRedirect(requestId, invocation, redirect) {
+    return protocol.decodeRedirectResponse({
+        kind: 'redirect',
+        requestId,
+        invocation,
+        redirect,
+    });
+}
+/** Identify a binary producer whose lifetime stays with its transport. */
+export function isStreamingBinary(input) {
+    return !(input.body instanceof Uint8Array);
+}

package/dist/transport/router.d.ts

@@ -2,4 +2,3 @@ import { type Hono as HonoType } from 'hono';
 /** Private Web-standard router capability shared by Server route-owning children. */
 export type ServerRouter = HonoType;
 export declare function createServerRouter(): ServerRouter;
-//# sourceMappingURL=router.d.ts.map

package/dist/transport/router.js

@@ -2,4 +2,3 @@ import { Hono } from 'hono';
 export function createServerRouter() {
     return new Hono();
 }
-//# sourceMappingURL=router.js.map

package/dist/transport/stream-error.d.ts

@@ -1,4 +1,3 @@
 import type { ErrorPayload } from '@astrale-os/kernel-protocol/errors';
 /** A transport cancellation after stream.start necessarily follows the Function effect boundary. */
 export declare function interruptedStreamError(timedOut: boolean): ErrorPayload;
-//# sourceMappingURL=stream-error.d.ts.map

package/dist/transport/stream-error.js

@@ -11,4 +11,3 @@ export function interruptedStreamError(timedOut) {
             message: 'Function stream was cancelled after execution began; outcome is unknown.',
         };
 }
-//# sourceMappingURL=stream-error.js.map

package/dist/transport/types.d.ts

@@ -26,4 +26,3 @@ export interface WebSocketUpgradeOptions {
 export interface WebSocketAdapter {
     upgrade(request: Request, options: WebSocketUpgradeOptions): Response | Promise<Response>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/transport/types.js

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

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

@@ -1,3 +1,2 @@
 export { createWebSocketSession, type WebSocketSessionConfig } from './session.js';
 export { handleWebSocketUpgrade, type WebSocketHandlerConfig } from './upgrade.js';
-//# sourceMappingURL=index.d.ts.map