@astrale-os/kernel-server 0.5.0-beta.13 → 0.5.0-beta.15

package/dist/lifecycle/active.d.ts

@@ -26,6 +26,8 @@ export declare class ActiveOperations {
     private changed;
     constructor(maximumConcurrentOperations: number);
     get isAccepting(): boolean;
+    /** Whether a newly arriving operation can be admitted without semantic dispatch. */
+    get isAvailable(): boolean;
     begin(timeoutMs: number, externalSignal?: AbortSignal): ActiveOperation | undefined;
     attachSocket(socket: ActiveSocket): boolean;
     detachSocket(socket: ActiveSocket): void;

package/dist/lifecycle/active.js

@@ -13,10 +13,13 @@ export class ActiveOperations {
     get isAccepting() {
         return this.accepting;
     }
+    /** Whether a newly arriving operation can be admitted without semantic dispatch. */
+    get isAvailable() {
+        return this.accepting && this.operations.size < this.maximumConcurrentOperations;
+    }
     begin(timeoutMs, externalSignal) {
-        if (!this.accepting || this.operations.size >= this.maximumConcurrentOperations) {
+        if (!this.isAvailable)
             return undefined;
-        }
         const operation = new Operation(Date.now() + timeoutMs, () => {
             this.operations.delete(operation);
             this.changed?.();

package/dist/routes/routes.js

@@ -138,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,
@@ -197,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'] });

package/dist/server.js

@@ -68,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',

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

@@ -1,3 +1,4 @@
+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';
@@ -19,13 +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: 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 {};

package/dist/transport/http/render.js

@@ -19,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));
         }
@@ -41,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 }),
     });
 }
@@ -75,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 ?? {})) {
@@ -90,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]();

package/dist/transport/websocket/session.js

@@ -5,7 +5,7 @@ import { ResponseBodyTooLargeError } from '../../errors/index.js';
 import { invocationContext, publicationRouteDecision, } from '../../invocation/index.js';
 import { byteLength } from '../body.js';
 import { resolveCredential } from '../credential.js';
-import { renderBinary, renderRedirect } from '../http/render.js';
+import { isStreamingBinary, renderBinary, renderRedirect } from '../http/render.js';
 import { interruptedStreamError } from '../stream-error.js';
 const WS_OPEN = 1;
 /** Build one socket-pinned transport session. */
@@ -211,6 +211,17 @@ async function sendResult(socket, codec, requestId, assigned, result, operation,
             await send(socket, codec, protocol.miss(requestId, assigned), sendOutput);
             return;
         case 'binary': {
+            if (isStreamingBinary(result.value)) {
+                const streaming = result.value;
+                await Promise.allSettled([
+                    sendError(socket, codec, requestId, assigned, {
+                        code: errors.CODES.UNSUPPORTED,
+                        message: 'Streaming binary output requires the HTTP transport.',
+                    }, sendOutput),
+                    Promise.resolve().then(() => streaming.body[Symbol.asyncIterator]().return?.()),
+                ]);
+                return;
+            }
             const binary = renderBinary(requestId, assigned, result.value);
             if (socket.readyState === WS_OPEN) {
                 await sendOutput(socket, protocol.websocket.encodeBinary(binary));

package/dist/types.d.ts

@@ -6,7 +6,7 @@ import type { PublicationSource } from './publication/index.js';
 import type { Application, WebSocketAdapter } from './transport/index.js';
 export interface ServerLimits {
     readonly maximumRequestBytes: number;
-    /** Maximum bytes in one encoded envelope, finite-binary body, or stream frame. */
+    /** Maximum bytes in one encoded envelope, buffered binary body, or stream frame. */
     readonly maximumResponseBytes?: number;
     /** Maximum Server-owned active operations across all mounted protocol surfaces. */
     readonly maximumConcurrentOperations?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-server",
-  "version": "0.5.0-beta.13",
+  "version": "0.5.0-beta.15",
   "description": "Portable HTTP and WebSocket boundary for Astrale invocation, publication, installation, and issuer protocols",
   "license": "Apache-2.0",
   "repository": {
@@ -33,11 +33,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": ">=0.9.0-beta.10 <1.0.0",
-    "@astrale-os/kernel-dsl": ">=0.2.0-beta.8 <1.0.0",
-    "@astrale-os/kernel-protocol": ">=0.5.0-beta.10 <1.0.0",
     "hono": "^4.6.20",
-    "msgpackr": "^2.0.5"
+    "msgpackr": "^2.0.5",
+    "@astrale-os/kernel-core": "0.9.0-beta.14",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.11",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.14"
   },
   "devDependencies": {
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",