@astrale-os/kernel-server 0.5.0-beta.4 → 0.5.0-beta.40

package/dist/publication/index.d.ts

@@ -1,4 +1,3 @@
 export { preparePublicationSnapshot, readPreparedPublicationSnapshot, type PreparedPublicationSnapshot, } from './snapshot.js';
 export type { PublicationSnapshot, PublicationSnapshotInput, PublicationSource } from './types.js';
 export * as delivery from './delivery/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/publication/index.js

@@ -1,3 +1,2 @@
 export { preparePublicationSnapshot, readPreparedPublicationSnapshot, } from './snapshot.js';
 export * as delivery from './delivery/index.js';
-//# sourceMappingURL=index.js.map

package/dist/publication/snapshot.d.ts

@@ -1,14 +1,16 @@
-import { publication, routes } from '@astrale-os/kernel-protocol';
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type * as publication from '@astrale-os/kernel-protocol/publication';
+import type * as routes from '@astrale-os/kernel-protocol/routes';
 import type { PublicationSnapshot, PublicationSnapshotInput } from './types.js';
 export interface PreparedPublicationSnapshot {
     readonly snapshot: PublicationSnapshot;
     readonly publication: publication.Publication;
     readonly publicationBytes: Uint8Array;
     readonly bundle: Uint8Array;
-    readonly routes: readonly routes.CompiledRoute[];
+    readonly table: routes.Table;
+    readonly domain: Domain;
 }
 /** Admit and detach one revision-coherent serving snapshot before publication. */
 export declare function preparePublicationSnapshot(input: PublicationSnapshotInput): PublicationSnapshot;
 /** Internal proof that a PublicationSource returned a Server-prepared snapshot without cloning it. */
 export declare function readPreparedPublicationSnapshot(input: unknown): PreparedPublicationSnapshot | undefined;
-//# sourceMappingURL=snapshot.d.ts.map

package/dist/publication/snapshot.js

@@ -1,22 +1,30 @@
-import { publication, routes } from '@astrale-os/kernel-protocol';
+import { verifyBundleBytes } from '@astrale-os/kernel-protocol/publication/bundle-evidence';
+import { accept as acceptPublication, encode as encodePublication, } from '@astrale-os/kernel-protocol/publication/publication';
+import { admitTable } from './table.js';
 const snapshots = new WeakMap();
 /** Admit and detach one revision-coherent serving snapshot before publication. */
 export function preparePublicationSnapshot(input) {
     if (input === null || typeof input !== 'object' || !(input.bundle instanceof Uint8Array)) {
         throw new TypeError('Publication snapshot input is invalid.');
     }
-    const admittedPublication = publication.accept(input.publication);
+    const admittedPublication = acceptPublication(input.publication);
     const bundleBytes = new Uint8Array(input.bundle);
-    const artifact = publication.decodeBundle(admittedPublication, bundleBytes);
-    const compiledRoutes = routes.compile(admittedPublication, artifact);
-    const publicationBytes = publication.encode(admittedPublication);
+    verifyBundleBytes(admittedPublication, bundleBytes);
+    const domain = input.domain;
+    if (domain.origin !== admittedPublication.origin ||
+        domain.revision !== admittedPublication.schema.revision) {
+        throw new TypeError('Publication snapshot Domain identity differs from its Publication.');
+    }
+    const table = admitTable(admittedPublication, input.table, domain);
+    const publicationBytes = encodePublication(admittedPublication);
     const snapshot = Object.freeze({ publication: admittedPublication });
     const prepared = Object.freeze({
         snapshot,
         publication: admittedPublication,
         publicationBytes,
         bundle: bundleBytes,
-        routes: compiledRoutes,
+        table,
+        domain,
     });
     snapshots.set(snapshot, prepared);
     return snapshot;
@@ -27,4 +35,3 @@ export function readPreparedPublicationSnapshot(input) {
         return undefined;
     return snapshots.get(input);
 }
-//# sourceMappingURL=snapshot.js.map

package/dist/publication/table.d.ts

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

package/dist/publication/table.js

@@ -0,0 +1,16 @@
+import { reference } from '@astrale-os/kernel-protocol/publication/reference';
+import { acceptTable } from '@astrale-os/kernel-protocol/routes/admission';
+import { verifyTable } from '@astrale-os/kernel-protocol/routes/evidence';
+export function admitTable(deployed, input, domain) {
+    if (input === undefined) {
+        if (deployed.routes.length !== 0) {
+            throw new TypeError('A Publication with native routes requires a Route Table.');
+        }
+        return verifyTable(Object.freeze({
+            publication: reference(deployed),
+            entries: Object.freeze([]),
+        }), deployed, domain);
+    }
+    const table = acceptTable(input);
+    return verifyTable(table, deployed, domain);
+}

package/dist/publication/types.d.ts

@@ -1,9 +1,13 @@
-import type { publication } from '@astrale-os/kernel-protocol';
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type * as publication from '@astrale-os/kernel-protocol/publication';
+import type * as routes from '@astrale-os/kernel-protocol/routes';
 declare const PUBLICATION_SNAPSHOT: unique symbol;
 export interface PublicationSnapshotInput {
     readonly publication: publication.Publication;
     /** Exact artifact served at Publication.schema.bundle.href. */
     readonly bundle: Uint8Array;
+    readonly table?: routes.Table;
+    readonly domain: Domain;
 }
 /** Immutable admitted serving identity; bundle and compiled routes remain Server-private. */
 export interface PublicationSnapshot {
@@ -16,4 +20,3 @@ export interface PublicationSource {
     current(): PublicationSnapshot | undefined;
 }
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/publication/types.js

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

package/dist/routes/index.d.ts

@@ -1,2 +1 @@
 export { currentPublicationSnapshot, mountRoutes, type RouteLimits, type RouteReservation, } from './routes.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/routes/index.js

@@ -1,2 +1 @@
 export { currentPublicationSnapshot, mountRoutes, } from './routes.js';
-//# sourceMappingURL=index.js.map

package/dist/routes/routes.d.ts

@@ -5,7 +5,7 @@ import type { Provider as DeliveryProvider } from '../publication/delivery/index
 import type { PublicationSource } from '../publication/index.js';
 import { type ApplicationHost, type Handler } from '../invocation/index.js';
 import { type PreparedPublicationSnapshot } from '../publication/index.js';
-import { type ServerRouter } from '../transport/index.js';
+import { type ServerRouter } from '../transport/router.js';
 export interface RouteLimits {
     readonly maximumRequestBytes: number;
     readonly maximumPublicationBytes: number;
@@ -23,4 +23,3 @@ export declare function currentPublicationSnapshot(source: PublicationSource, li
     readonly issuer?: string;
     readonly reservations: readonly RouteReservation[];
 }): PreparedPublicationSnapshot | undefined;
-//# sourceMappingURL=routes.d.ts.map

package/dist/routes/routes.js

@@ -1,13 +1,20 @@
-import { codecs, errors, invocation as protocol, publication, routes, } from '@astrale-os/kernel-protocol';
+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 { MEDIA_TYPE as PUBLICATION_MEDIA_TYPE, PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
+import { reference as publicationReference } from '@astrale-os/kernel-protocol/publication/reference';
+import * as routes from '@astrale-os/kernel-protocol/routes';
 import { classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../errors/index.js';
 import { invocationContext } from '../invocation/index.js';
 import { handleDelivery } from '../publication/delivery/index.js';
 import { readPreparedPublicationSnapshot, } from '../publication/index.js';
-import { interruptedStreamError, readBoundedBody } from '../transport/index.js';
+import { readBoundedBody } from '../transport/body.js';
+import {} from '../transport/router.js';
+import { interruptedStreamError } from '../transport/stream-error.js';
 export function mountRoutes(app, source, deliveryProvider, handler, active, nextInvocation, limits, cors, hostFor, reservations, externalIssuer) {
     const publicationPath = externalIssuer === undefined
-        ? publication.PATH
-        : new URL(publication.url(externalIssuer)).pathname;
+        ? PUBLICATION_PATH
+        : new URL(publicationUrl(externalIssuer)).pathname;
     const externalOrigin = externalIssuer === undefined ? undefined : new URL(externalIssuer).origin;
     if (cors.enabled) {
         app.options(publicationPath, (context) => cors.preflight(context.req.raw, {
@@ -37,7 +44,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
             status: 200,
             headers: {
                 ...responseCors,
-                'content-type': 'application/json',
+                'content-type': PUBLICATION_MEDIA_TYPE,
                 etag: quoteEtag(snapshot.publication.etag),
                 'cache-control': 'public, max-age=0, must-revalidate, no-transform',
             },
@@ -89,7 +96,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
                     },
                 });
             }
-            routing = routes.decodeRouting(request, publication.reference(snapshot.publication));
+            routing = routes.decodeRouting(request, publicationReference(snapshot.publication));
         }
         catch (cause) {
             if (cause instanceof routes.RouteError) {
@@ -97,7 +104,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
             }
             throw cause;
         }
-        const route = routes.match(snapshot.routes, request);
+        const route = routes.match(snapshot.table, request);
         if (route === undefined)
             return context.notFound();
         const assigned = nextInvocation();
@@ -110,12 +117,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
         let handedOff = false;
         try {
             const body = await readBoundedBody(request, limits.maximumRequestBytes, operation.signal);
-            const invocation = routes.decode(route, {
-                url: request.url,
-                method: request.method,
-                headers: request.headers,
-                body,
-            });
+            const invocation = routes.decode(route, { url: request.url, method: request.method, headers: request.headers, body }, snapshot.domain, snapshot.table.publication);
             const idempotencyHeader = request.headers.get(protocol.HTTP_IDEMPOTENCY_KEY);
             const idempotencyKey = idempotencyHeader === null
                 ? undefined
@@ -136,8 +138,13 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
                 });
             }
             if (result.kind === 'binary') {
+                if (isStreamingBinary(result.value)) {
+                    handedOff = true;
+                    return streamingBinaryResponse(result.value, operation, cors, request);
+                }
                 const applicationHeaders = applicationBinaryHeaders(result.value.headers);
                 return new Response(toBody(result.value.body), {
+                    status: result.value.status ?? 200,
                     headers: {
                         ...cors.response(request, [
                             protocol.http.BINARY_HEADERS_FIELD,
@@ -195,6 +202,66 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
         }
     });
 }
+function streamingBinaryResponse(binary, operation, cors, request) {
+    const iterator = binary.body[Symbol.asyncIterator]();
+    const applicationHeaders = applicationBinaryHeaders(binary.headers);
+    let terminal = false;
+    let stopping;
+    const stop = () => {
+        stopping ??= Promise.resolve().then(async () => {
+            if (terminal)
+                return;
+            terminal = true;
+            try {
+                await iterator.return?.();
+            }
+            finally {
+                operation.settle();
+            }
+        });
+        return stopping;
+    };
+    const body = new ReadableStream({
+        async pull(controller) {
+            if (terminal)
+                return;
+            try {
+                const next = await iterator.next();
+                if (terminal)
+                    return;
+                if (next.done) {
+                    terminal = true;
+                    controller.close();
+                    operation.settle();
+                    return;
+                }
+                controller.enqueue(next.value);
+            }
+            catch (cause) {
+                terminal = true;
+                controller.error(cause);
+                operation.settle();
+            }
+        },
+        async cancel(reason) {
+            const message = typeof reason === 'string' ? reason : 'native binary response cancelled';
+            operation.cancel(message);
+            await stop();
+        },
+    });
+    operation.onCancel(stop);
+    return new Response(body, {
+        status: binary.status ?? 200,
+        headers: {
+            ...cors.response(request, Object.keys(applicationHeaders)),
+            ...applicationHeaders,
+            'content-type': binary.mediaType,
+        },
+    });
+}
+function isStreamingBinary(input) {
+    return !(input.body instanceof Uint8Array);
+}
 function publicationPreflight(cors, request, snapshot, externalOrigin) {
     if (sameRoute(request.url, snapshot.publication.schema.bundle.href, externalOrigin)) {
         return cors.preflight(request, { methods: ['GET'], headers: ['if-none-match'] });
@@ -209,7 +276,7 @@ function publicationPreflight(cors, request, snapshot, externalOrigin) {
     const requestedMethod = request.headers.get('access-control-request-method');
     const route = requestedMethod === null
         ? undefined
-        : routes.match(snapshot.routes, { url: request.url, method: requestedMethod });
+        : routes.match(snapshot.table, { url: request.url, method: requestedMethod });
     return cors.preflight(request, route === undefined ? undefined : nativeCorsRoute(route, requestedMethod));
 }
 function nativeCorsRoute(entry, requestedMethod) {
@@ -219,16 +286,16 @@ function nativeCorsRoute(entry, requestedMethod) {
         routes.HTTP_ROUTE_ISSUER,
         protocol.HTTP_IDEMPOTENCY_KEY,
     ]);
-    if (entry.route.body !== undefined)
+    if (entry.body !== undefined)
         headers.add('content-type');
     let allowAnyHeaders = false;
-    for (const pick of Object.values(entry.route.headers ?? {})) {
+    for (const pick of Object.values(entry.headers ?? {})) {
         if (pick === '*')
             allowAnyHeaders = true;
         else
             headers.add(pick.toLowerCase());
     }
-    const credential = entry.route.credential;
+    const credential = entry.credential;
     const sources = credential === undefined
         ? [{ in: 'header' }]
         : Array.isArray(credential)
@@ -239,9 +306,7 @@ function nativeCorsRoute(entry, requestedMethod) {
             headers.add((source.name ?? 'authorization').toLowerCase());
     }
     return Object.freeze({
-        methods: Object.freeze([
-            entry.route.method === '*' ? requestedMethod.toUpperCase() : entry.route.method,
-        ]),
+        methods: Object.freeze([entry.method === '*' ? requestedMethod.toUpperCase() : entry.method]),
         headers: Object.freeze([...headers]),
         ...(allowAnyHeaders ? { allowAnyHeaders: true } : {}),
     });
@@ -270,9 +335,9 @@ function servingSnapshot(source, limits, request, reservations, externalIssuer)
 function conflictsWithServingRoutes(snapshot, serving) {
     for (const reservation of serving.reservations) {
         const href = `${serving.origin}${reservation.path}`;
-        for (const entry of snapshot.routes) {
-            if (reservation.methods.some((method) => entry.route.method === '*' || entry.route.method === method) &&
-                routes.templatesOverlap(entry.route.href, href)) {
+        for (const entry of snapshot.table.entries) {
+            if (reservation.methods.some((method) => entry.method === '*' || entry.method === method) &&
+                routes.templatesOverlap(entry.href, href)) {
                 return true;
             }
         }
@@ -446,4 +511,3 @@ function encodedBody(input) {
 function toBody(input) {
     return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
 }
-//# sourceMappingURL=routes.js.map

package/dist/server.d.ts

@@ -2,4 +2,3 @@ import type { Server, ServerConfig, ServerOptions, PreparedServer } from './type
 export declare function createServer(config: ServerConfig): Server;
 /** Validate all static transport configuration before a Host starts Runtime recovery/bootstrap. */
 export declare function prepareServer(options: ServerOptions): PreparedServer;
-//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -1,4 +1,4 @@
-import { publication as protocolPublication } from '@astrale-os/kernel-protocol';
+import { PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
 import { captureMethod } from './capture.js';
 import { prepareCors } from './cors/index.js';
 import { captureInvocationSource } from './invocation/index.js';
@@ -6,7 +6,9 @@ import { capture as captureExchangeProvider } from './issuer/exchange.js';
 import { admitIssuer, issuerRouteReservations, mountIssuer } from './issuer/index.js';
 import { ActiveOperations } from './lifecycle/index.js';
 import { currentPublicationSnapshot, mountRoutes } from './routes/index.js';
-import { createHttpHandler, createServerRouter, handleWebSocketUpgrade } from './transport/index.js';
+import { createHttpHandler } from './transport/http/handler.js';
+import { createServerRouter } from './transport/router.js';
+import { handleWebSocketUpgrade } from './transport/websocket/upgrade.js';
 export function createServer(config) {
     const { handler, ...options } = config;
     return prepareServer(options).create(handler);
@@ -66,7 +68,7 @@ function createPreparedServer(input, config) {
     app.all(config.path, (context) => handleHttp(context.req.raw, hosts.get(context.req.raw)));
     if (config.health !== undefined) {
         app.get(config.health.path, (context) => {
-            const ready = active.isAccepting && config.health.probe.check();
+            const ready = active.isAvailable && config.health.probe.check();
             return context.json({ status: ready ? 'ready' : 'not-ready' }, ready ? 200 : 503, {
                 ...config.cors.response(context.req.raw),
                 'cache-control': 'no-store',
@@ -210,8 +212,8 @@ function routeReservations(invocationPath, healthPath, issuer, websocket, tokenE
 }
 function protocolPublicationPath(issuer) {
     if (issuer === undefined)
-        return protocolPublication.PATH;
-    return new URL(protocolPublication.url(issuer)).pathname;
+        return PUBLICATION_PATH;
+    return new URL(publicationUrl(issuer)).pathname;
 }
 function captureHealthProbe(probe) {
     const check = captureMethod(probe, 'check', 'Health probe is invalid.');
@@ -262,4 +264,3 @@ function admitRoute(path, label) {
     }
     return path;
 }
-//# sourceMappingURL=server.js.map

package/dist/transport/body.d.ts

@@ -2,4 +2,3 @@ export { RequestBodyInvalidError, RequestBodyTooLargeError } from '../errors/ind
 /** Read a request body while enforcing the limit before retaining excess bytes. */
 export declare function readBoundedBody(request: Request, maximumBytes: number, signal: AbortSignal): Promise<Uint8Array>;
 export declare function byteLength(input: string | Uint8Array): number;
-//# sourceMappingURL=body.d.ts.map

package/dist/transport/body.js

@@ -48,4 +48,3 @@ export async function readBoundedBody(request, maximumBytes, signal) {
 export function byteLength(input) {
     return typeof input === 'string' ? new TextEncoder().encode(input).byteLength : input.byteLength;
 }
-//# sourceMappingURL=body.js.map

package/dist/transport/codecs.d.ts

@@ -1,5 +1,4 @@
-import { codecs } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
 export type LoadedCodec = codecs.Codec;
 /** Load the built-in Server representation set before pure Protocol binding selection. */
 export declare function loadCodecs(): Promise<readonly [codecs.Codec, codecs.Codec]>;
-//# sourceMappingURL=codecs.d.ts.map

package/dist/transport/codecs.js

@@ -1,6 +1,5 @@
-import { codecs } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
 /** Load the built-in Server representation set before pure Protocol binding selection. */
 export async function loadCodecs() {
     return Object.freeze([codecs.json, await codecs.loadMsgpack()]);
 }
-//# sourceMappingURL=codecs.js.map

package/dist/transport/credential.d.ts

@@ -1,4 +1,4 @@
-import { errors } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
 export type CredentialResult = {
     readonly ok: true;
     readonly credential: string | undefined;
@@ -8,4 +8,3 @@ export type CredentialResult = {
 };
 /** Resolve exactly zero or one untrusted credential channel without authenticating it. */
 export declare function resolveCredential(envelope: string | undefined, authorization: string | null): CredentialResult;
-//# sourceMappingURL=credential.d.ts.map

package/dist/transport/credential.js

@@ -1,4 +1,4 @@
-import { errors } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
 /** Resolve exactly zero or one untrusted credential channel without authenticating it. */
 export function resolveCredential(envelope, authorization) {
     if (envelope !== undefined && authorization !== null) {
@@ -26,4 +26,3 @@ function failure(message) {
         error: { code: errors.CODES.INVALID_REQUEST, message },
     };
 }
-//# sourceMappingURL=credential.js.map

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

@@ -15,4 +15,3 @@ export interface HttpHandlerConfig {
     readonly currentPublication?: (request: Request) => PublicationSnapshot | undefined;
 }
 export declare function createHttpHandler(config: HttpHandlerConfig): (request: Request, host?: ApplicationHost) => Promise<Response>;
-//# sourceMappingURL=handler.d.ts.map

package/dist/transport/http/handler.js

@@ -1,4 +1,6 @@
-import { codecs, errors, invocation as protocol } from '@astrale-os/kernel-protocol';
+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 { readBoundedBody } from '../body.js';
@@ -176,4 +178,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,2 @@
 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

package/dist/transport/http/index.js

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

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

@@ -1,9 +1,12 @@
-import { errors, invocation as protocol, type codecs } from '@astrale-os/kernel-protocol';
+import type { BufferedBinaryResult, StreamingBinaryResult } from '@astrale-os/kernel-core/callable';
+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: codecs.Codec;
+    readonly codec: Codec;
     readonly cors: CorsHeaders;
     readonly invocation: protocol.InvocationId;
     readonly active: ActiveOperation;
@@ -17,14 +20,14 @@ export interface ErrorRenderOptions {
 }
 type HandlerResult = Awaited<ReturnType<Handler['dispatch']>>;
 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 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: codecs.Codec, cors: CorsHeaders, options?: ErrorRenderOptions): Response;
-export declare function renderHttpStale(requestId: protocol.RequestId, invocation: protocol.InvocationId, current: protocol.Stale['current'], codec: codecs.Codec, cors: CorsHeaders, maximumResponseBytes?: number): Response;
-export declare function encodeEnvelope(codec: codecs.Codec, input: unknown): string | Uint8Array;
+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 declare function isStreamingBinary(input: Extract<HandlerResult, {
+    readonly kind: 'binary';
+}>['value']): input is StreamingBinaryResult;
 export {};
-//# sourceMappingURL=render.d.ts.map

package/dist/transport/http/render.js

@@ -1,4 +1,6 @@
-import { errors, invocation as protocol, routes } from '@astrale-os/kernel-protocol';
+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';
@@ -17,6 +19,8 @@ export function renderHttpResult(result, context) {
         case 'miss':
             return settled(context.active, envelopeResponse(context.codec, protocol.miss(context.requestId, context.invocation), context.cors(), 200, true, context.maximumResponseBytes));
         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));
         }
@@ -28,8 +32,8 @@ 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 === routes.HTTP_ROUTE_STALE ||
-            normalized === routes.HTTP_ROUTE_MISS);
+            normalized === HTTP_ROUTE_STALE ||
+            normalized === HTTP_ROUTE_MISS);
     });
     if (reserved !== undefined)
         throw new TypeError(`${reserved} is reserved by Protocol.`);
@@ -39,6 +43,7 @@ export function renderBinary(requestId, invocation, binary) {
         invocation,
         body: binary.body,
         mediaType: binary.mediaType,
+        status: binary.status ?? 200,
         ...(binary.headers === undefined ? {} : { headers: binary.headers }),
     });
 }
@@ -73,11 +78,74 @@ function envelopeResponse(codec, input, cors, status = 200, negotiated = true, m
 }
 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 });
+}
+function streamingBinaryHttpResponse(binary, context) {
+    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);
+    let terminal = false;
+    let stopping;
+    const stop = () => {
+        stopping ??= Promise.resolve().then(async () => {
+            if (terminal)
+                return;
+            terminal = true;
+            try {
+                await iterator.return?.();
+            }
+            finally {
+                context.active.settle();
+            }
+        });
+        return stopping;
+    };
+    const body = new ReadableStream({
+        async pull(controller) {
+            if (terminal)
+                return;
+            try {
+                const next = await iterator.next();
+                if (terminal)
+                    return;
+                if (next.done) {
+                    terminal = true;
+                    controller.close();
+                    context.active.settle();
+                    return;
+                }
+                controller.enqueue(next.value);
+            }
+            catch (cause) {
+                terminal = true;
+                controller.error(cause);
+                context.active.settle();
+            }
+        },
+        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 });
+}
+export function isStreamingBinary(input) {
+    return !(input.body instanceof Uint8Array);
+}
+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] : []),
         ...applicationHeaders,
     ]));
     for (const [name, value] of Object.entries(binary.headers ?? {})) {
@@ -88,9 +156,12 @@ function binaryHttpResponse(binary, cors, maximumResponseBytes) {
     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 new Response(toBody(binary.body), { status: 200, headers });
+    return headers;
 }
 function streamHttpResponse(stream, context) {
     const iterator = stream[Symbol.asyncIterator]();
@@ -284,4 +355,3 @@ function toBody(input) {
     const copy = new Uint8Array(input);
     return copy.buffer;
 }
-//# sourceMappingURL=render.js.map