@astrale-os/kernel-server 0.5.0-beta.6 → 0.5.0-beta.61

package/dist/routes/routes.js

@@ -1,7 +1,8 @@
 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 { PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
+import { bundleUrl } from '@astrale-os/kernel-protocol/publication';
+import { mediaType as publicationMediaType, 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';
@@ -11,11 +12,11 @@ import { readPreparedPublicationSnapshot, } from '../publication/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) {
+export function mountRoutes(app, source, deliveryProvider, handler, active, nextInvocation, limits, cors, hostFor, reservations, externalIssuer, publicOrigin) {
     const publicationPath = externalIssuer === undefined
         ? PUBLICATION_PATH
         : new URL(publicationUrl(externalIssuer)).pathname;
-    const externalOrigin = externalIssuer === undefined ? undefined : new URL(externalIssuer).origin;
+    const externalOrigin = publicOrigin ?? (externalIssuer === undefined ? undefined : new URL(externalIssuer).origin);
     if (cors.enabled) {
         app.options(publicationPath, (context) => cors.preflight(context.req.raw, {
             methods: ['GET'],
@@ -26,7 +27,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
         const responseCors = cors.response(context.req.raw, ['etag']);
         if (!active.isAccepting)
             return response({ error: 'Publication is unavailable while draining.' }, 503, responseCors);
-        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer);
+        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer, externalOrigin);
         if (snapshot === undefined)
             return response({ error: 'Publication is not ready.' }, 503, responseCors);
         const body = snapshot.publicationBytes;
@@ -44,14 +45,14 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
             status: 200,
             headers: {
                 ...responseCors,
-                'content-type': 'application/json',
+                'content-type': publicationMediaType(snapshot.publication),
                 etag: quoteEtag(snapshot.publication.etag),
                 'cache-control': 'public, max-age=0, must-revalidate, no-transform',
             },
         });
     });
     app.all('*', async (context) => {
-        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer);
+        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer, externalOrigin);
         if (snapshot === undefined)
             return context.notFound();
         const request = context.req.raw;
@@ -59,6 +60,9 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
             return publicationPreflight(cors, request, snapshot, externalOrigin);
         }
         const responseCors = cors.response(request);
+        const descriptor = snapshot.publication.schema.bundle;
+        const addressed = bundleUrl(snapshot.publication.identity.issuer, descriptor.ref);
+        const immutable = descriptor.href === addressed;
         if (sameRoute(request.url, snapshot.publication.schema.bundle.href, externalOrigin)) {
             if (!active.isAccepting)
                 return response({ error: 'Publication artifact is unavailable while draining.' }, 503, responseCors);
@@ -68,16 +72,32 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
             if (body.byteLength !== snapshot.publication.schema.bundle.ref.size) {
                 return response({ error: 'Bundle differs from its Publication.' }, 500, responseCors);
             }
-            return new Response(toBody(body), {
-                status: 200,
+            const etag = quoteEtag(descriptor.ref.digest);
+            const unchanged = request.headers.get('if-none-match') === etag;
+            return new Response(unchanged ? null : toBody(body), {
+                status: unchanged ? 304 : 200,
                 headers: {
                     ...responseCors,
                     'content-type': snapshot.publication.schema.bundle.ref.mediaType,
-                    etag: quoteEtag(snapshot.publication.schema.bundle.ref.digest),
-                    'cache-control': 'public, max-age=31536000, immutable, no-transform',
+                    etag,
+                    'cache-control': immutable
+                        ? 'public, max-age=31536000, immutable, no-transform'
+                        : 'public, max-age=0, must-revalidate, no-transform',
                 },
             });
         }
+        if (request.method === 'GET' && immutable) {
+            const pathname = new URL(addressed).pathname;
+            const directory = pathname.slice(0, pathname.lastIndexOf('/') + 1);
+            const requested = new URL(request.url);
+            if (requested.pathname.startsWith(directory) &&
+                /^[0-9a-f]{64}\.json$/u.test(requested.pathname.slice(directory.length))) {
+                return new Response(null, {
+                    status: 404,
+                    headers: { ...responseCors, 'cache-control': 'no-store' },
+                });
+            }
+        }
         const deliveryUrl = snapshot.publication.delivery?.href;
         if (deliveryUrl !== undefined && sameRoute(request.url, deliveryUrl, externalOrigin)) {
             return handleDelivery(request, snapshot, deliveryProvider, active, limits, cors.response(request));
@@ -117,7 +137,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 }, snapshot.validator, snapshot.table.publication);
+            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
@@ -138,8 +158,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 +222,73 @@ 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 controller;
+    let stopping;
+    const stop = (reason = 'Binary response was interrupted.') => {
+        if (terminal)
+            return stopping ?? Promise.resolve();
+        terminal = true;
+        controller?.error(new Error(reason));
+        stopping = Promise.resolve().then(async () => {
+            try {
+                await iterator.return?.();
+            }
+            finally {
+                operation.settle();
+            }
+        });
+        return stopping;
+    };
+    const body = new ReadableStream({
+        start(output) {
+            controller = output;
+        },
+        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) {
+                if (terminal)
+                    return;
+                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'] });
@@ -260,9 +352,10 @@ export function currentPublicationSnapshot(source, limits, serving) {
     }
     return prepared;
 }
-function servingSnapshot(source, limits, request, reservations, externalIssuer) {
+function servingSnapshot(source, limits, request, reservations, externalIssuer, publicOrigin) {
     return currentPublicationSnapshot(source, limits, {
-        origin: externalIssuer === undefined ? new URL(request.url).origin : new URL(externalIssuer).origin,
+        origin: publicOrigin ??
+            (externalIssuer === undefined ? new URL(request.url).origin : new URL(externalIssuer).origin),
         ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
         reservations,
     });
@@ -446,4 +539,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

@@ -26,7 +26,8 @@ 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 handleHttp = createHttpHandler({
         handler,
         active,
@@ -68,7 +69,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',
@@ -82,7 +83,7 @@ function createPreparedServer(input, config) {
         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);
+        mountRoutes(app, config.publication, 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 +132,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');
@@ -180,6 +182,7 @@ function admitOptions(config) {
     }
     return Object.freeze({
         invocation,
+        ...(publicOrigin === undefined ? {} : { publicOrigin }),
         limits,
         path,
         cors: prepareCors(config.cors),
@@ -264,4 +267,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

@@ -2,4 +2,3 @@ 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

@@ -3,4 +3,3 @@ import * as codecs from '@astrale-os/kernel-protocol/codecs';
 export async function loadCodecs() {
     return Object.freeze([codecs.json, await codecs.loadMsgpack()]);
 }
-//# 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/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

@@ -6,7 +6,7 @@ import { invocationContext, publicationRouteDecision, } from '../../invocation/i
 import { readBoundedBody } from '../body.js';
 import { loadCodecs } from '../codecs.js';
 import { resolveCredential } from '../credential.js';
-import { renderHttpError, renderHttpResult } from './render.js';
+import { isStreamingBinary, renderHttpError, renderHttpResult, } from './render.js';
 export function createHttpHandler(config) {
     return async (request, host) => {
         const cors = (exposedHeaders) => config.cors.response(request, exposedHeaders);
@@ -146,7 +146,8 @@ export function createHttpHandler(config) {
                     active,
                     maximumResponseBytes: config.maximumResponseBytes,
                 });
-                handedOff = result.kind === 'stream';
+                handedOff =
+                    result.kind === 'stream' || (result.kind === 'binary' && isStreamingBinary(result.value));
                 return response;
             }
             catch (input) {
@@ -178,4 +179,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,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,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: 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

@@ -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,81 @@ 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 controller;
+    let stopping;
+    const stop = (reason = 'Binary response was interrupted.') => {
+        if (terminal)
+            return stopping ?? Promise.resolve();
+        terminal = true;
+        controller?.error(new Error(reason));
+        stopping = Promise.resolve().then(async () => {
+            try {
+                await iterator.return?.();
+            }
+            finally {
+                context.active.settle();
+            }
+        });
+        return stopping;
+    };
+    const body = new ReadableStream({
+        start(output) {
+            controller = output;
+        },
+        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) {
+                if (terminal)
+                    return;
+                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 +163,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]();
@@ -286,4 +362,3 @@ function toBody(input) {
     const copy = new Uint8Array(input);
     return copy.buffer;
 }
-//# sourceMappingURL=render.js.map

package/dist/transport/index.d.ts

@@ -7,4 +7,3 @@ export { interruptedStreamError } from './stream-error.js';
 export { createServerRouter, type ServerRouter } from './router.js';
 export { createWebSocketSession, handleWebSocketUpgrade, type WebSocketHandlerConfig, type WebSocketSessionConfig, } from './websocket/index.js';
 export type { Application, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/index.js

@@ -6,4 +6,3 @@ export { encodeEnvelope, renderBinary, renderHttpError, renderHttpResult, render
 export { interruptedStreamError } from './stream-error.js';
 export { createServerRouter } from './router.js';
 export { createWebSocketSession, handleWebSocketUpgrade, } from './websocket/index.js';
-//# sourceMappingURL=index.js.map

package/dist/transport/router.d.ts

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

package/dist/transport/router.js

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

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

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

package/dist/transport/stream-error.js

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

package/dist/transport/types.d.ts

@@ -1,4 +1,4 @@
-import type { invocation as protocol } from '@astrale-os/kernel-protocol';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { ApplicationHost } from '../invocation/index.js';
 /** Portable Fetch application; framework and listener APIs are adapter-owned. */
 export interface Application {
@@ -26,4 +26,3 @@ export interface WebSocketUpgradeOptions {
 export interface WebSocketAdapter {
     upgrade(request: Request, options: WebSocketUpgradeOptions): Response | Promise<Response>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/transport/types.js

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

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

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

package/dist/transport/websocket/index.js

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

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

@@ -18,4 +18,3 @@ export interface WebSocketSessionConfig {
 }
 /** Build one socket-pinned transport session. */
 export declare function createWebSocketSession(config: WebSocketSessionConfig): WebSocketHandlers;
-//# sourceMappingURL=session.d.ts.map

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));
@@ -333,4 +344,3 @@ function isCancelRequest(input) {
         !Array.isArray(input) &&
         input.kind === 'cancel');
 }
-//# sourceMappingURL=session.js.map

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

@@ -18,4 +18,3 @@ export interface WebSocketHandlerConfig {
     readonly host?: ApplicationHost;
 }
 export declare function handleWebSocketUpgrade(config: WebSocketHandlerConfig): Promise<Response>;
-//# sourceMappingURL=upgrade.d.ts.map

package/dist/transport/websocket/upgrade.js

@@ -44,4 +44,3 @@ function failure(status, input = {}) {
         headers: { ...input, 'cache-control': 'no-store' },
     });
 }
-//# sourceMappingURL=upgrade.js.map

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;
@@ -37,6 +37,8 @@ export interface ServerOptions {
         readonly probe: HealthProbe;
     } | false;
     readonly issuer?: Issuer;
+    /** Public HTTP origin for transport placement, independent of the stable issuer. */
+    readonly publicOrigin?: string;
     /** Present only for the configured self issuer; owns verification and signing. */
     readonly tokenExchange?: exchange.Provider;
     readonly publication?: PublicationSource;
@@ -63,4 +65,3 @@ export type { ApplicationHost, ExecutionControl, Handler, HandlerRequest, Handle
 export type { exchange, Issuer } from './issuer/index.js';
 export type { PublicationSnapshot, PublicationSnapshotInput, PublicationSource, } from './publication/index.js';
 export type { Application, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './transport/index.js';
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

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