@astrale-os/kernel-server 0.5.0-beta.7 → 0.5.0-beta.71

package/dist/server.js

@@ -1,11 +1,14 @@
-import { PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
+import { Path } from '@astrale-os/kernel-core/path';
+import { PATH as RELEASE_PATH, url as releaseUrl } from '@astrale-os/kernel-protocol/release';
+import { PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/release/legacy';
 import { captureMethod } from './capture.js';
 import { prepareCors } from './cors/index.js';
 import { captureInvocationSource } from './invocation/index.js';
 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 { currentServed, 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';
@@ -26,7 +29,23 @@ function createPreparedServer(input, config) {
     const app = createServerRouter();
     const hosts = new WeakMap();
     const externalIssuer = config.issuer?.issuer;
-    const externalOrigin = externalIssuer === undefined ? undefined : new URL(externalIssuer).origin;
+    const externalOrigin = config.publicOrigin ??
+        (externalIssuer === undefined ? undefined : new URL(externalIssuer).origin);
+    const source = config.serving;
+    const serving = source === undefined
+        ? undefined
+        : (request) => {
+            const origin = externalOrigin ?? new URL(request.url).origin;
+            return Object.freeze({
+                kind: source.kind,
+                current: () => currentServed(source, config.limits, {
+                    origin,
+                    ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
+                    reservations: config.routeReservations,
+                }),
+                deployment: () => acceptIssuer(origin),
+            });
+        };
     const handleHttp = createHttpHandler({
         handler,
         active,
@@ -34,15 +53,7 @@ function createPreparedServer(input, config) {
         ...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,
-            }),
+        ...(serving === undefined ? {} : { serving }),
     });
     if (config.websocket !== undefined) {
         app.get(config.path, (context) => handleWebSocketUpgrade({
@@ -53,22 +64,14 @@ function createPreparedServer(input, config) {
             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,
-                }),
+            ...(serving === undefined ? {} : { serving: serving(context.req.raw) }),
             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();
+            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',
@@ -81,8 +84,8 @@ function createPreparedServer(input, config) {
     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);
+    if (config.serving !== undefined) {
+        mountRoutes(app, config.serving, config.delivery, handler, active, config.invocation, config.limits, config.cors, (request) => hosts.get(request), config.routeReservations, externalIssuer, externalOrigin);
     }
     app.onError((_error, context) => new Response('{"error":"Internal server error."}', {
         status: 500,
@@ -131,6 +134,7 @@ function captureHandler(input) {
     return Object.freeze({ dispatch });
 }
 function admitOptions(config) {
+    const publicOrigin = config.publicOrigin === undefined ? undefined : admitPublicOrigin(config.publicOrigin);
     const invocation = captureInvocationSource(config.invocation);
     const limits = admitLimits(config.limits);
     const path = admitRoute(config.path ?? '/', 'invocation path');
@@ -146,23 +150,31 @@ function admitOptions(config) {
             probe: captureHealthProbe(config.health.probe),
         });
     const websocket = config.websocket === undefined ? undefined : captureWebSocket(config.websocket);
-    const publication = config.publication === undefined ? undefined : capturePublicationSource(config.publication);
+    if (config.release !== undefined && config.publication !== undefined) {
+        throw new TypeError('Server options take at most one of release and publication.');
+    }
+    const serving = config.release !== undefined
+        ? Object.freeze({ kind: 'release', source: captureReleaseSource(config.release) })
+        : config.publication !== undefined
+            ? Object.freeze({
+                kind: 'publication',
+                source: capturePublicationSource(config.publication),
+            })
+            : undefined;
     const delivery = config.delivery === undefined ? undefined : captureDeliveryProvider(config.delivery);
-    if (delivery !== undefined && publication === undefined) {
-        throw new TypeError('Publication Delivery requires a Publication source.');
+    if (delivery !== undefined && serving === undefined) {
+        throw new TypeError('Delivery requires a release or Publication source.');
     }
-    const publicationPath = publication === undefined
-        ? undefined
-        : issuer === undefined
-            ? protocolPublicationPath()
-            : protocolPublicationPath(issuer.issuer);
+    const documentPaths = serving === undefined ? [] : servedDocumentPaths(serving.kind, 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.');
+    for (const { name, path: documentPath } of documentPaths) {
+        if (documentPath === path) {
+            throw new TypeError(`${name} and invocation paths must be distinct.`);
+        }
+        if (health !== undefined && documentPath === health.path) {
+            throw new TypeError(`Health and ${name} paths must be distinct.`);
+        }
     }
     if (issuer !== undefined) {
         const issuerReservations = issuerRouteReservations(issuer, tokenExchange !== undefined);
@@ -180,19 +192,20 @@ function admitOptions(config) {
     }
     return Object.freeze({
         invocation,
+        ...(publicOrigin === undefined ? {} : { publicOrigin }),
         limits,
         path,
         cors: prepareCors(config.cors),
         ...(health === undefined ? {} : { health }),
         ...(issuer === undefined ? {} : { issuer }),
         ...(tokenExchange === undefined ? {} : { tokenExchange }),
-        ...(publication === undefined ? {} : { publication }),
+        ...(serving === undefined ? {} : { serving }),
         ...(delivery === undefined ? {} : { delivery }),
-        routeReservations: routeReservations(path, health?.path, issuer, websocket !== undefined, tokenExchange !== undefined, publicationPath),
+        routeReservations: routeReservations(path, health?.path, issuer, websocket !== undefined, tokenExchange !== undefined, documentPaths.map(({ path: documentPath }) => documentPath)),
         ...(websocket === undefined ? {} : { websocket }),
     });
 }
-function routeReservations(invocationPath, healthPath, issuer, websocket, tokenExchange, publicationPath) {
+function routeReservations(invocationPath, healthPath, issuer, websocket, tokenExchange, documentPaths) {
     const reservations = [
         Object.freeze({
             path: invocationPath,
@@ -205,15 +218,23 @@ function routeReservations(invocationPath, healthPath, issuer, websocket, tokenE
     if (issuer !== undefined) {
         reservations.push(...issuerRouteReservations(issuer, tokenExchange));
     }
-    if (publicationPath !== undefined) {
-        reservations.push(Object.freeze({ path: publicationPath, methods: Object.freeze(['GET']) }));
+    for (const documentPath of documentPaths) {
+        reservations.push(Object.freeze({ path: documentPath, methods: Object.freeze(['GET']) }));
     }
     return Object.freeze(reservations);
 }
-function protocolPublicationPath(issuer) {
-    if (issuer === undefined)
-        return PUBLICATION_PATH;
-    return new URL(publicationUrl(issuer)).pathname;
+function servedDocumentPaths(kind, issuer) {
+    const publication = {
+        name: 'Publication',
+        path: issuer === undefined ? PUBLICATION_PATH : new URL(publicationUrl(issuer)).pathname,
+    };
+    if (kind === 'publication')
+        return [publication];
+    const release = {
+        name: 'Release',
+        path: issuer === undefined ? RELEASE_PATH : new URL(releaseUrl(issuer)).pathname,
+    };
+    return [release, publication];
 }
 function captureHealthProbe(probe) {
     const check = captureMethod(probe, 'check', 'Health probe is invalid.');
@@ -223,12 +244,16 @@ function captureWebSocket(adapter) {
     const upgrade = captureMethod(adapter, 'upgrade', 'WebSocket adapter is invalid.');
     return Object.freeze({ upgrade });
 }
+function captureReleaseSource(input) {
+    const current = captureMethod(input, 'current', 'Release source is invalid.');
+    return Object.freeze({ current });
+}
 function capturePublicationSource(input) {
     const current = captureMethod(input, 'current', 'Publication source is invalid.');
     return Object.freeze({ current });
 }
 function captureDeliveryProvider(input) {
-    const create = captureMethod(input, 'create', 'Publication Delivery provider is invalid.');
+    const create = captureMethod(input, 'create', 'Delivery provider is invalid.');
     return Object.freeze({ create });
 }
 function admitLimits(limits) {
@@ -241,16 +266,42 @@ function admitLimits(limits) {
     if (limits.invocationTimeoutMs > 2_147_483_647) {
         throw new TypeError('invocationTimeoutMs exceeds the platform timer range.');
     }
+    if ((limits.binaryDownloadTarget === undefined) !==
+        (limits.binaryDownloadTimeoutMs === undefined)) {
+        throw new TypeError('binaryDownloadTarget and binaryDownloadTimeoutMs must be configured together.');
+    }
+    const binaryDownloadTarget = limits.binaryDownloadTarget === undefined
+        ? undefined
+        : Path.parse(limits.binaryDownloadTarget).raw;
+    const binaryDownloadTimeoutMs = limits.binaryDownloadTimeoutMs === undefined
+        ? undefined
+        : admitTimerLimit(limits.binaryDownloadTimeoutMs, 'binaryDownloadTimeoutMs');
     return Object.freeze({
         maximumRequestBytes: limits.maximumRequestBytes,
+        maximumBinaryRequestBytes: admitOptionalLimit(limits.maximumBinaryRequestBytes, limits.maximumRequestBytes, 'maximumBinaryRequestBytes'),
         maximumResponseBytes: admitOptionalLimit(limits.maximumResponseBytes, 16 * 1024 * 1024, 'maximumResponseBytes'),
         maximumConcurrentOperations: admitOptionalLimit(limits.maximumConcurrentOperations, 1_024, 'maximumConcurrentOperations'),
         maximumPublicationBytes: admitOptionalLimit(limits.maximumPublicationBytes, limits.maximumRequestBytes, 'maximumPublicationBytes'),
         maximumBundleBytes: admitOptionalLimit(limits.maximumBundleBytes, 16 * 1024 * 1024, 'maximumBundleBytes'),
         maximumDeliveryBytes: admitOptionalLimit(limits.maximumDeliveryBytes, limits.maximumRequestBytes, 'maximumDeliveryBytes'),
         invocationTimeoutMs: limits.invocationTimeoutMs,
+        binaryRequestTimeoutMs: admitTimerLimit(limits.binaryRequestTimeoutMs ?? limits.invocationTimeoutMs, 'binaryRequestTimeoutMs'),
+        ...(limits.binaryRequestIdleTimeoutMs === undefined
+            ? {}
+            : {
+                binaryRequestIdleTimeoutMs: admitTimerLimit(limits.binaryRequestIdleTimeoutMs, 'binaryRequestIdleTimeoutMs'),
+            }),
+        ...(binaryDownloadTarget === undefined
+            ? {}
+            : { binaryDownloadTarget, binaryDownloadTimeoutMs }),
     });
 }
+function admitTimerLimit(input, label) {
+    if (!Number.isSafeInteger(input) || input <= 0 || input > 2_147_483_647) {
+        throw new TypeError(`${label} must be a positive platform timer duration.`);
+    }
+    return input;
+}
 function admitOptionalLimit(input, fallback, label) {
     const value = input ?? fallback;
     if (!Number.isSafeInteger(value) || value <= 0) {
@@ -264,4 +315,15 @@ function admitRoute(path, label) {
     }
     return path;
 }
-//# sourceMappingURL=server.js.map
+function admitPublicOrigin(input) {
+    const url = new URL(input);
+    if (!['http:', 'https:'].includes(url.protocol) ||
+        url.username !== '' ||
+        url.password !== '' ||
+        url.pathname !== '/' ||
+        url.search !== '' ||
+        url.hash !== '') {
+        throw new TypeError('Server publicOrigin must be an HTTP(S) origin.');
+    }
+    return url.origin;
+}

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 * 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
+/** The built-in Server representation set before pure Protocol binding selection. */
+export declare function loadCodecs(): readonly [codecs.Codec];

package/dist/transport/codecs.js

@@ -1,6 +1,6 @@
 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()]);
+const SUPPORTED = Object.freeze([codecs.json]);
+/** The built-in Server representation set before pure Protocol binding selection. */
+export function loadCodecs() {
+    return SUPPORTED;
 }
-//# sourceMappingURL=codecs.js.map

package/dist/transport/credential.d.ts

@@ -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

@@ -26,4 +26,3 @@ function failure(message) {
         error: { code: errors.CODES.INVALID_REQUEST, message },
     };
 }
-//# sourceMappingURL=credential.js.map

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

@@ -0,0 +1,11 @@
+import { type BinaryRequestBody } from '@astrale-os/kernel-core/callable';
+interface IdleBudget {
+    readonly timeoutMs: number;
+    readonly cancel: () => void;
+}
+/** Admit a declared length before dispatch and expose one counted, non-buffering body. */
+export declare function binaryRequestBody(request: Request, maximumBytes: number, signal: AbortSignal, idle?: IdleBudget): BinaryRequestBody & {
+    readonly completed: () => boolean;
+    readonly cancel: (reason: unknown) => void;
+};
+export {};

package/dist/transport/http/binary-request.js

@@ -0,0 +1,102 @@
+import { BinaryBodyLengthError } from '@astrale-os/kernel-core/callable';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { RequestBodyInvalidError, RequestBodyTooLargeError } from '../../errors/index.js';
+/** Admit a declared length before dispatch and expose one counted, non-buffering body. */
+export function binaryRequestBody(request, maximumBytes, signal, idle) {
+    const declared = request.headers.get(protocol.http.BINARY_LENGTH_FIELD);
+    if (declared === null || !/^(?:0|[1-9][0-9]*)$/u.test(declared)) {
+        throw new RequestBodyInvalidError('Binary request length is required and must be exact.');
+    }
+    const length = Number(declared);
+    if (!Number.isSafeInteger(length)) {
+        throw new RequestBodyInvalidError('Binary request length is invalid.');
+    }
+    const contentLength = request.headers.get('content-length');
+    if (contentLength !== null && contentLength !== declared) {
+        throw new RequestBodyInvalidError('Binary request length differs from Content-Length.');
+    }
+    if (length > maximumBytes)
+        throw new RequestBodyTooLargeError(maximumBytes);
+    if (request.body === null) {
+        if (length !== 0)
+            throw new RequestBodyInvalidError('Binary request body is missing.');
+        return Object.freeze({
+            body: new ReadableStream({ start: (controller) => controller.close() }),
+            length,
+            completed: () => true,
+            cancel: () => undefined,
+        });
+    }
+    const reader = request.body.getReader();
+    let size = 0;
+    let finished = false;
+    let completed = false;
+    let idleTimer;
+    const clearIdle = () => {
+        if (idleTimer !== undefined)
+            clearTimeout(idleTimer);
+        idleTimer = undefined;
+    };
+    const release = () => {
+        if (finished)
+            return;
+        finished = true;
+        clearIdle();
+        signal.removeEventListener('abort', abort);
+        reader.releaseLock();
+    };
+    const cancelSource = (reason) => {
+        if (finished)
+            return;
+        clearIdle();
+        void reader.cancel(reason).then(release, release);
+    };
+    const abort = () => cancelSource(signal.reason);
+    signal.addEventListener('abort', abort, { once: true });
+    if (signal.aborted)
+        abort();
+    const startIdle = () => {
+        if (idle !== undefined && idleTimer === undefined) {
+            idleTimer = setTimeout(idle.cancel, idle.timeoutMs);
+        }
+    };
+    const body = new ReadableStream({
+        async pull(controller) {
+            try {
+                if (signal.aborted)
+                    throw signal.reason;
+                startIdle();
+                const next = await reader.read();
+                if (signal.aborted)
+                    throw signal.reason;
+                if (next.done) {
+                    if (size !== length)
+                        throw new BinaryBodyLengthError();
+                    completed = true;
+                    release();
+                    controller.close();
+                    return;
+                }
+                if (!(next.value instanceof Uint8Array)) {
+                    throw new RequestBodyInvalidError('Binary request yielded a non-byte chunk.');
+                }
+                size += next.value.byteLength;
+                if (size > length)
+                    throw new BinaryBodyLengthError();
+                if (next.value.byteLength > 0)
+                    clearIdle();
+                controller.enqueue(next.value);
+            }
+            catch (cause) {
+                cancelSource(cause);
+                release();
+                controller.error(cause);
+            }
+        },
+        cancel(reason) {
+            cancelSource(reason);
+            release();
+        },
+    }, { highWaterMark: 0 });
+    return Object.freeze({ body, length, completed: () => completed, cancel: cancelSource });
+}

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

@@ -1,18 +1,23 @@
 import type { CorsPolicy } from '../../cors/index.js';
 import type { NextInvocationId } from '../../invocation/index.js';
 import type { ActiveOperations } from '../../lifecycle/index.js';
-import type { PublicationSnapshot } from '../../publication/index.js';
+import type { RequestServing } from '../../release/served.js';
 import { type ApplicationHost, type Handler } from '../../invocation/index.js';
 export interface HttpHandlerConfig {
     readonly handler: Handler;
     readonly active: ActiveOperations;
     readonly invocation: NextInvocationId;
     readonly maximumRequestBytes: number;
+    readonly maximumBinaryRequestBytes: number;
     readonly maximumResponseBytes: number;
     readonly invocationTimeoutMs: number;
+    readonly binaryRequestTimeoutMs: number;
+    readonly binaryRequestIdleTimeoutMs?: number;
+    readonly binaryDownloadTarget?: string;
+    readonly binaryDownloadTimeoutMs?: number;
     readonly cors: CorsPolicy;
     readonly websocket: boolean;
-    readonly currentPublication?: (request: Request) => PublicationSnapshot | undefined;
+    /** Present exactly when the Server serves a release or a Publication. */
+    readonly serving?: (request: Request) => RequestServing;
 }
 export declare function createHttpHandler(config: HttpHandlerConfig): (request: Request, host?: ApplicationHost) => Promise<Response>;
-//# sourceMappingURL=handler.d.ts.map