@astrale-os/kernel-server 0.4.17 → 0.5.0-beta.10

package/dist/server.js

@@ -0,0 +1,266 @@
+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';
+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 } 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);
+}
+/** Validate all static transport configuration before a Host starts Runtime recovery/bootstrap. */
+export function prepareServer(options) {
+    const prepared = admitOptions(options);
+    return Object.freeze({
+        create: (handler) => createPreparedServer(handler, prepared),
+    });
+}
+function createPreparedServer(input, config) {
+    const handler = captureHandler(input);
+    const active = new ActiveOperations(config.limits.maximumConcurrentOperations);
+    const app = createServerRouter();
+    const hosts = new WeakMap();
+    const externalIssuer = config.issuer?.issuer;
+    const externalOrigin = externalIssuer === undefined ? undefined : new URL(externalIssuer).origin;
+    const handleHttp = createHttpHandler({
+        handler,
+        active,
+        invocation: config.invocation,
+        ...config.limits,
+        cors: config.cors,
+        websocket: config.websocket !== undefined,
+        ...(config.publication === undefined
+            ? {}
+            : {
+                currentPublication: (request) => currentPublicationSnapshot(config.publication, config.limits, {
+                    origin: externalOrigin ?? new URL(request.url).origin,
+                    ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
+                    reservations: config.routeReservations,
+                })?.snapshot,
+            }),
+    });
+    if (config.websocket !== undefined) {
+        app.get(config.path, (context) => handleWebSocketUpgrade({
+            request: context.req.raw,
+            adapter: config.websocket,
+            handler,
+            active,
+            invocation: config.invocation,
+            ...config.limits,
+            cors: config.cors,
+            ...(config.publication === undefined
+                ? {}
+                : {
+                    currentPublication: () => currentPublicationSnapshot(config.publication, config.limits, {
+                        origin: externalOrigin ?? new URL(context.req.raw.url).origin,
+                        ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
+                        reservations: config.routeReservations,
+                    })?.snapshot,
+                }),
+            host: hosts.get(context.req.raw),
+        }));
+    }
+    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();
+            return context.json({ status: ready ? 'ready' : 'not-ready' }, ready ? 200 : 503, {
+                ...config.cors.response(context.req.raw),
+                'cache-control': 'no-store',
+            });
+        });
+        if (config.cors.enabled) {
+            app.options(config.health.path, (context) => config.cors.preflight(context.req.raw, { methods: ['GET'] }));
+        }
+    }
+    if (config.issuer !== undefined) {
+        mountIssuer(app, config.issuer, config.cors, active, config.limits.invocationTimeoutMs, config.tokenExchange);
+    }
+    if (config.publication !== undefined) {
+        mountRoutes(app, config.publication, config.delivery, handler, active, config.invocation, config.limits, config.cors, (request) => hosts.get(request), config.routeReservations, externalIssuer);
+    }
+    app.onError((_error, context) => new Response('{"error":"Internal server error."}', {
+        status: 500,
+        headers: {
+            ...config.cors.response(context.req.raw),
+            'content-type': 'application/json',
+        },
+    }));
+    return Object.freeze({
+        app: Object.freeze({
+            async fetch(request, host) {
+                const admitted = host === undefined ? undefined : captureApplicationHost(host);
+                if (admitted !== undefined)
+                    hosts.set(request, admitted);
+                try {
+                    return await app.fetch(request);
+                }
+                finally {
+                    hosts.delete(request);
+                }
+            },
+        }),
+        drain() {
+            active.drain();
+        },
+        close(options) {
+            if (!Number.isFinite(options.deadline)) {
+                return Promise.reject(new TypeError('Server close deadline must be finite.'));
+            }
+            return active.close(options.deadline);
+        },
+    });
+}
+function captureApplicationHost(input) {
+    const waitUntil = captureMethod(input, 'waitUntil', 'Application host is invalid.');
+    const sleep = input.sleep === undefined
+        ? undefined
+        : captureMethod(input, 'sleep', 'Application host is invalid.');
+    return Object.freeze({
+        waitUntil,
+        ...(sleep === undefined ? {} : { sleep }),
+    });
+}
+function captureHandler(input) {
+    const dispatch = captureMethod(input, 'dispatch', 'Server handler is invalid.');
+    return Object.freeze({ dispatch });
+}
+function admitOptions(config) {
+    const invocation = captureInvocationSource(config.invocation);
+    const limits = admitLimits(config.limits);
+    const path = admitRoute(config.path ?? '/', 'invocation path');
+    const issuer = config.issuer === undefined ? undefined : admitIssuer(config.issuer);
+    const tokenExchange = config.tokenExchange === undefined ? undefined : captureExchangeProvider(config.tokenExchange);
+    if (tokenExchange !== undefined && issuer === undefined) {
+        throw new TypeError('Token exchange requires issuer configuration.');
+    }
+    const health = config.health === undefined || config.health === false
+        ? undefined
+        : Object.freeze({
+            path: admitRoute(config.health.path ?? '/health', 'Health path'),
+            probe: captureHealthProbe(config.health.probe),
+        });
+    const websocket = config.websocket === undefined ? undefined : captureWebSocket(config.websocket);
+    const publication = config.publication === undefined ? undefined : capturePublicationSource(config.publication);
+    const delivery = config.delivery === undefined ? undefined : captureDeliveryProvider(config.delivery);
+    if (delivery !== undefined && publication === undefined) {
+        throw new TypeError('Publication Delivery requires a Publication source.');
+    }
+    const publicationPath = publication === undefined
+        ? undefined
+        : issuer === undefined
+            ? protocolPublicationPath()
+            : protocolPublicationPath(issuer.issuer);
+    if (health?.path === path)
+        throw new TypeError('Health and invocation paths must be distinct.');
+    if (publicationPath === path) {
+        throw new TypeError('Publication and invocation paths must be distinct.');
+    }
+    if (health !== undefined && publicationPath === health.path) {
+        throw new TypeError('Health and Publication paths must be distinct.');
+    }
+    if (issuer !== undefined) {
+        const issuerReservations = issuerRouteReservations(issuer, tokenExchange !== undefined);
+        const issuerPaths = issuerReservations.map(({ path }) => path);
+        if (health !== undefined && issuerPaths.includes(health.path)) {
+            throw new TypeError('Health and issuer paths must be distinct.');
+        }
+        if (websocket !== undefined && issuerPaths.includes(path)) {
+            throw new TypeError('WebSocket invocation and issuer paths must be distinct.');
+        }
+        if (websocket === undefined &&
+            issuerReservations.some((reservation) => reservation.path === path && reservation.methods.includes('POST'))) {
+            throw new TypeError('Invocation and token-exchange paths must be distinct.');
+        }
+    }
+    return Object.freeze({
+        invocation,
+        limits,
+        path,
+        cors: prepareCors(config.cors),
+        ...(health === undefined ? {} : { health }),
+        ...(issuer === undefined ? {} : { issuer }),
+        ...(tokenExchange === undefined ? {} : { tokenExchange }),
+        ...(publication === undefined ? {} : { publication }),
+        ...(delivery === undefined ? {} : { delivery }),
+        routeReservations: routeReservations(path, health?.path, issuer, websocket !== undefined, tokenExchange !== undefined, publicationPath),
+        ...(websocket === undefined ? {} : { websocket }),
+    });
+}
+function routeReservations(invocationPath, healthPath, issuer, websocket, tokenExchange, publicationPath) {
+    const reservations = [
+        Object.freeze({
+            path: invocationPath,
+            methods: Object.freeze(websocket ? ['GET', 'POST'] : ['POST']),
+        }),
+    ];
+    if (healthPath !== undefined) {
+        reservations.push(Object.freeze({ path: healthPath, methods: Object.freeze(['GET']) }));
+    }
+    if (issuer !== undefined) {
+        reservations.push(...issuerRouteReservations(issuer, tokenExchange));
+    }
+    if (publicationPath !== undefined) {
+        reservations.push(Object.freeze({ path: publicationPath, methods: Object.freeze(['GET']) }));
+    }
+    return Object.freeze(reservations);
+}
+function protocolPublicationPath(issuer) {
+    if (issuer === undefined)
+        return PUBLICATION_PATH;
+    return new URL(publicationUrl(issuer)).pathname;
+}
+function captureHealthProbe(probe) {
+    const check = captureMethod(probe, 'check', 'Health probe is invalid.');
+    return Object.freeze({ check });
+}
+function captureWebSocket(adapter) {
+    const upgrade = captureMethod(adapter, 'upgrade', 'WebSocket adapter is invalid.');
+    return Object.freeze({ upgrade });
+}
+function capturePublicationSource(input) {
+    const current = captureMethod(input, 'current', 'Publication source is invalid.');
+    return Object.freeze({ current });
+}
+function captureDeliveryProvider(input) {
+    const create = captureMethod(input, 'create', 'Publication Delivery provider is invalid.');
+    return Object.freeze({ create });
+}
+function admitLimits(limits) {
+    if (!Number.isSafeInteger(limits.maximumRequestBytes) || limits.maximumRequestBytes <= 0) {
+        throw new TypeError('maximumRequestBytes must be a positive safe integer.');
+    }
+    if (!Number.isSafeInteger(limits.invocationTimeoutMs) || limits.invocationTimeoutMs <= 0) {
+        throw new TypeError('invocationTimeoutMs must be a positive safe integer.');
+    }
+    if (limits.invocationTimeoutMs > 2_147_483_647) {
+        throw new TypeError('invocationTimeoutMs exceeds the platform timer range.');
+    }
+    return Object.freeze({
+        maximumRequestBytes: limits.maximumRequestBytes,
+        maximumResponseBytes: admitOptionalLimit(limits.maximumResponseBytes, 16 * 1024 * 1024, 'maximumResponseBytes'),
+        maximumConcurrentOperations: admitOptionalLimit(limits.maximumConcurrentOperations, 1_024, 'maximumConcurrentOperations'),
+        maximumPublicationBytes: admitOptionalLimit(limits.maximumPublicationBytes, limits.maximumRequestBytes, 'maximumPublicationBytes'),
+        maximumBundleBytes: admitOptionalLimit(limits.maximumBundleBytes, 16 * 1024 * 1024, 'maximumBundleBytes'),
+        maximumDeliveryBytes: admitOptionalLimit(limits.maximumDeliveryBytes, limits.maximumRequestBytes, 'maximumDeliveryBytes'),
+        invocationTimeoutMs: limits.invocationTimeoutMs,
+    });
+}
+function admitOptionalLimit(input, fallback, label) {
+    const value = input ?? fallback;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError(`${label} must be a positive safe integer.`);
+    }
+    return value;
+}
+function admitRoute(path, label) {
+    if (!path.startsWith('/') || path.includes('?') || path.includes('#')) {
+        throw new TypeError(`${label} must be an absolute path without query or fragment.`);
+    }
+    return path;
+}

package/dist/transport/body.d.ts

@@ -0,0 +1,4 @@
+export { RequestBodyInvalidError, RequestBodyTooLargeError } from '../errors/index.js';
+/** 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;

package/dist/transport/body.js

@@ -0,0 +1,50 @@
+import { RequestBodyInvalidError, RequestBodyTooLargeError } from '../errors/index.js';
+export { RequestBodyInvalidError, RequestBodyTooLargeError } from '../errors/index.js';
+/** Read a request body while enforcing the limit before retaining excess bytes. */
+export async function readBoundedBody(request, maximumBytes, signal) {
+    const declared = request.headers.get('content-length');
+    if (declared !== null) {
+        const length = Number(declared);
+        if (!Number.isSafeInteger(length) || length < 0) {
+            throw new RequestBodyInvalidError('Content-Length is invalid.');
+        }
+        if (length > maximumBytes)
+            throw new RequestBodyTooLargeError(maximumBytes);
+    }
+    const reader = request.body?.getReader();
+    if (reader === undefined)
+        return new Uint8Array();
+    const chunks = [];
+    let total = 0;
+    const abort = () => void reader.cancel(signal.reason).catch(() => undefined);
+    signal.addEventListener('abort', abort, { once: true });
+    try {
+        while (true) {
+            if (signal.aborted)
+                throw signal.reason;
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maximumBytes) {
+                await reader.cancel('request body too large').catch(() => undefined);
+                throw new RequestBodyTooLargeError(maximumBytes);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+        reader.releaseLock();
+    }
+    const body = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return body;
+}
+export function byteLength(input) {
+    return typeof input === 'string' ? new TextEncoder().encode(input).byteLength : input.byteLength;
+}

package/dist/transport/codecs.d.ts

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

package/dist/transport/codecs.js

@@ -0,0 +1,5 @@
+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()]);
+}

package/dist/transport/credential.d.ts

@@ -0,0 +1,10 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+export type CredentialResult = {
+    readonly ok: true;
+    readonly credential: string | undefined;
+} | {
+    readonly ok: false;
+    readonly error: errors.ErrorPayload;
+};
+/** Resolve exactly zero or one untrusted credential channel without authenticating it. */
+export declare function resolveCredential(envelope: string | undefined, authorization: string | null): CredentialResult;

package/dist/transport/credential.js

@@ -0,0 +1,28 @@
+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) {
+        return failure('Credential must be supplied in either the envelope or Authorization, not both.');
+    }
+    if (envelope !== undefined)
+        return { ok: true, credential: envelope };
+    if (authorization === null)
+        return { ok: true, credential: undefined };
+    const match = /^Bearer[ \t]+([^\s]+)$/i.exec(authorization.trim());
+    if (match === null) {
+        return {
+            ok: false,
+            error: {
+                code: errors.CODES.AUTH_INVALID,
+                message: 'Authorization must use one Bearer credential.',
+            },
+        };
+    }
+    return { ok: true, credential: match[1] };
+}
+function failure(message) {
+    return {
+        ok: false,
+        error: { code: errors.CODES.INVALID_REQUEST, message },
+    };
+}

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

@@ -0,0 +1,17 @@
+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 ApplicationHost, type Handler } from '../../invocation/index.js';
+export interface HttpHandlerConfig {
+    readonly handler: Handler;
+    readonly active: ActiveOperations;
+    readonly invocation: NextInvocationId;
+    readonly maximumRequestBytes: number;
+    readonly maximumResponseBytes: number;
+    readonly invocationTimeoutMs: number;
+    readonly cors: CorsPolicy;
+    readonly websocket: boolean;
+    readonly currentPublication?: (request: Request) => PublicationSnapshot | undefined;
+}
+export declare function createHttpHandler(config: HttpHandlerConfig): (request: Request, host?: ApplicationHost) => Promise<Response>;

package/dist/transport/http/handler.js

@@ -0,0 +1,180 @@
+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';
+import { loadCodecs } from '../codecs.js';
+import { resolveCredential } from '../credential.js';
+import { renderHttpError, renderHttpResult } from './render.js';
+export function createHttpHandler(config) {
+    return async (request, host) => {
+        const cors = (exposedHeaders) => config.cors.response(request, exposedHeaders);
+        const allow = [
+            ...(config.websocket ? ['GET'] : []),
+            'POST',
+            ...(config.cors.enabled ? ['OPTIONS'] : []),
+        ];
+        if (request.method === 'OPTIONS' && config.cors.enabled) {
+            return noStore(config.cors.preflight(request, {
+                methods: ['POST'],
+                headers: [
+                    'authorization',
+                    'content-type',
+                    protocol.http.TRACEPARENT_FIELD,
+                    protocol.http.TRACESTATE_FIELD,
+                ],
+            }));
+        }
+        if (request.method !== 'POST') {
+            return new Response(null, {
+                status: 405,
+                headers: { ...cors(), allow: allow.join(', '), 'cache-control': 'no-store' },
+            });
+        }
+        const assigned = config.invocation();
+        const renderError = (requestId, error, codec, options = {}) => renderHttpError(requestId, assigned, error, codec, cors, {
+            ...options,
+            maximumResponseBytes: config.maximumResponseBytes,
+        });
+        const active = config.active.begin(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 });
+        }
+        let handedOff = false;
+        try {
+            const supported = await loadCodecs();
+            const contentType = request.headers.get('content-type');
+            const incoming = contentType === null || contentType.trim() === ''
+                ? codecs.json
+                : protocol.http.codecForContentType(contentType, supported);
+            if (incoming === undefined) {
+                return renderError(null, {
+                    code: errors.CODES.UNSUPPORTED,
+                    message: 'Unsupported request Content-Type.',
+                }, codecs.json, { status: 415, negotiated: false });
+            }
+            const outgoing = protocol.http.negotiateResponseCodec(request.headers.get('accept'), incoming, supported);
+            if (outgoing === undefined) {
+                return renderError(null, {
+                    code: errors.CODES.UNSUPPORTED,
+                    message: 'No acceptable response codec is available.',
+                }, incoming, { status: 406 });
+            }
+            let body;
+            try {
+                body = await readBoundedBody(request, config.maximumRequestBytes, active.signal);
+            }
+            catch (input) {
+                const payload = input instanceof RequestBodyTooLargeError
+                    ? classifyError(input)
+                    : input instanceof RequestBodyInvalidError
+                        ? { code: errors.CODES.PARSE_ERROR, message: 'Request body is invalid.' }
+                        : active.timedOut
+                            ? {
+                                code: errors.CODES.DEADLINE_EXCEEDED,
+                                message: 'Invocation deadline exceeded.',
+                            }
+                            : active.signal.aborted
+                                ? { code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }
+                                : undefined;
+                if (payload === undefined)
+                    throw input;
+                return renderError(null, payload, outgoing, {
+                    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);
+            }
+            catch (input) {
+                return renderError(null, classifyError(input), outgoing);
+            }
+            const publication = config.currentPublication?.(request);
+            if (config.currentPublication !== undefined && publication === undefined) {
+                return renderError(envelope.requestId, {
+                    code: errors.CODES.BACKEND_UNAVAILABLE,
+                    message: 'Publication is unavailable.',
+                }, outgoing, { status: 503 });
+            }
+            if (envelope.routing?.kind === 'via') {
+                if (publication === undefined) {
+                    return renderError(envelope.requestId, {
+                        code: errors.CODES.INVALID_REQUEST,
+                        message: 'Publication routing requires a Publication-backed destination.',
+                    }, outgoing);
+                }
+                const decision = publicationRouteDecision(publication.publication, envelope.routing.publication);
+                if (decision.kind === 'rejected') {
+                    return renderError(envelope.requestId, decision.error, outgoing);
+                }
+            }
+            const credential = resolveCredential(envelope.credential, request.headers.get('authorization'));
+            if (!credential.ok) {
+                return renderError(envelope.requestId, credential.error, outgoing);
+            }
+            const trace = protocol.http.decodeTraceHeaders(request.headers.get(protocol.http.TRACEPARENT_FIELD), request.headers.get(protocol.http.TRACESTATE_FIELD));
+            try {
+                const result = await config.handler.dispatch(Object.freeze({
+                    call: envelope.call,
+                    ...(trace === undefined ? {} : { trace }),
+                    ...(credential.credential === undefined ? {} : { credential: credential.credential }),
+                    ...(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),
+                }));
+                const response = renderHttpResult(result, {
+                    requestId: envelope.requestId,
+                    codec: outgoing,
+                    cors,
+                    invocation: assigned,
+                    active,
+                    maximumResponseBytes: config.maximumResponseBytes,
+                });
+                handedOff = result.kind === 'stream';
+                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);
+            }
+        }
+        catch (input) {
+            return renderError(null, classifyError(input), codecs.json, {
+                negotiated: false,
+            });
+        }
+        finally {
+            if (!handedOff)
+                active.settle();
+        }
+    };
+}
+function noStore(response) {
+    const headers = new Headers(response.headers);
+    headers.set('cache-control', 'no-store');
+    return new Response(response.body, { status: response.status, headers });
+}

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

@@ -0,0 +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';

package/dist/transport/http/index.js

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

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

@@ -0,0 +1,31 @@
+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']>>;
+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 {};