@astrale-os/kernel-server 0.5.0-beta.73 → 0.5.0-beta.75

package/dist/transport/http/render.js

@@ -1,25 +1,26 @@
-import { json } 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 { deploymentRetiredBody, deploymentRetiredHeaders, HTTP_DEPLOYMENT_RETIRED, HTTP_DEPLOYMENT_RETIRED_STATUS, } from '@astrale-os/kernel-protocol/routes/deployment-retired';
-import { HTTP_ROUTE_MISS, HTTP_ROUTE_STALE } from '@astrale-os/kernel-protocol/routes/routing';
-import { classifyError, retryAfterHeaders } from '../../errors/index.js';
-import { ResponseBodyTooLargeError } from '../../errors/index.js';
-import { interruptedStreamError } from '../stream-error.js';
+import { isStreamingBinary, renderBinary, renderRedirect } from '../result.js';
+import { binaryHttpResponse } from './binary.js';
+import { streamingBinaryHttpResponse } from './byte-stream.js';
+import { envelopeResponse } from './response.js';
+import { streamHttpResponse } from './stream.js';
+/** Render one admitted Handler result and retain only live producers in the active operation. */
 export function renderHttpResult(result, context) {
+    let envelope;
     switch (result.kind) {
         case 'value':
-            return settled(context.active, envelopeResponse(context.codec, {
+            envelope = {
                 result: result.value,
                 requestId: context.requestId,
                 invocation: context.invocation,
-            }, context.cors(), 200, true, context.maximumResponseBytes));
-        case 'redirect': {
-            const response = renderRedirect(context.requestId, context.invocation, result.redirect);
-            return settled(context.active, envelopeResponse(context.codec, response, context.cors(), 200, true, context.maximumResponseBytes));
-        }
+            };
+            break;
+        case 'redirect':
+            envelope = renderRedirect(context.requestId, context.invocation, result.redirect);
+            break;
         case 'miss':
-            return settled(context.active, envelopeResponse(context.codec, protocol.miss(context.requestId, context.invocation), context.cors(), 200, true, context.maximumResponseBytes));
+            envelope = protocol.miss(context.requestId, context.invocation);
+            break;
         case 'binary': {
             if (isStreamingBinary(result.value))
                 return streamingBinaryHttpResponse(result.value, context);
@@ -29,406 +30,9 @@ export function renderHttpResult(result, context) {
         case 'stream':
             return streamHttpResponse(result.stream, context);
     }
-}
-export function renderBinary(requestId, invocation, binary) {
-    const reserved = Object.keys(binary.headers ?? {}).find((name) => {
-        const normalized = name.toLowerCase();
-        return (normalized === protocol.http.INVOCATION_FIELD ||
-            normalized === HTTP_ROUTE_STALE ||
-            normalized === HTTP_ROUTE_MISS);
-    });
-    if (reserved !== undefined)
-        throw new TypeError(`${reserved} is reserved by Protocol.`);
-    return protocol.decodeBinaryResponse({
-        kind: 'binary',
-        requestId,
-        invocation,
-        body: binary.body,
-        mediaType: binary.mediaType,
-        status: binary.status ?? 200,
-        ...(binary.headers === undefined ? {} : { headers: binary.headers }),
-    });
-}
-export function renderRedirect(requestId, invocation, redirect) {
-    return protocol.decodeRedirectResponse({
-        kind: 'redirect',
-        requestId,
-        invocation,
-        redirect,
-    });
-}
-export function renderHttpError(requestId, invocation, error, codec, cors, options = {}) {
-    const status = options.status ?? errors.httpStatusOf(error);
-    const retry = retryAfterHeaders(error);
-    const extra = status === 401 ? { 'www-authenticate': 'Bearer realm="astrale-invocation"' } : retry;
-    return errorEnvelopeResponse(codec, { error, requestId, invocation }, { ...cors(Object.keys(retry)), ...extra }, status, options.negotiated ?? true, options.maximumResponseBytes);
-}
-export function renderHttpStale(requestId, invocation, current, codec, cors, maximumResponseBytes) {
-    return envelopeResponse(codec, protocol.stale(requestId, invocation, current), cors(), 200, true, maximumResponseBytes);
-}
-/** Retirement controls always use JSON, regardless of the negotiated request codec. */
-export function renderDeploymentRetired(deployment, release, cors) {
-    return new Response(toBody(json.encode(deploymentRetiredBody(deployment, release))), {
-        status: HTTP_DEPLOYMENT_RETIRED_STATUS,
-        headers: { ...cors([HTTP_DEPLOYMENT_RETIRED]), ...deploymentRetiredHeaders() },
-    });
-}
-export function encodeEnvelope(codec, input) {
-    return codec.encode(input);
-}
-function envelopeResponse(codec, input, cors, status = 200, negotiated = true, maximumResponseBytes) {
-    const encoded = codec.encode(input);
-    requireResponseBound(encoded, maximumResponseBytes);
-    const headers = bindingHeaders(cors, negotiated);
-    headers.set('content-type', codec.contentType);
-    return new Response(toBody(encoded), {
-        status,
-        headers,
-    });
-}
-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) {
-    if (binary.length !== undefined && (!Number.isSafeInteger(binary.length) || binary.length < 0)) {
-        throw new TypeError('Streaming binary length must be a non-negative safe integer.');
-    }
-    const delivery = binary.delivery;
-    if (delivery !== undefined) {
-        if (!Number.isSafeInteger(delivery.maximumDurationMs) ||
-            delivery.maximumDurationMs <= 0 ||
-            delivery.maximumDurationMs > 2_147_483_647 ||
-            !Number.isSafeInteger(delivery.idleTimeoutMs) ||
-            delivery.idleTimeoutMs <= 0 ||
-            delivery.idleTimeoutMs > 2_147_483_647) {
-            throw new TypeError('Streaming binary delivery budget is invalid.');
-        }
-        context.active.extend(delivery.maximumDurationMs);
-    }
-    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);
-    if (binary.length !== undefined) {
-        headers.set('content-length', String(binary.length));
-        // Content-Length belongs to HTTP and an intermediary may rewrite it; the Client counts the
-        // delivered bytes against this protocol field instead.
-        headers.set(protocol.http.BINARY_LENGTH_FIELD, String(binary.length));
-    }
-    if (delivery !== undefined)
-        headers.set('cache-control', 'private, no-store');
-    let terminal = false;
-    let delivered = 0;
-    let controller;
-    let stopping;
-    let idleTimer;
-    const clearIdle = () => {
-        if (idleTimer !== undefined)
-            clearTimeout(idleTimer);
-    };
-    const resetIdle = () => {
-        if (delivery === undefined || terminal)
-            return;
-        clearIdle();
-        idleTimer = setTimeout(() => context.active.cancel('binary response idle timeout exceeded'), delivery.idleTimeoutMs);
-    };
-    const stop = (reason = 'Binary response was interrupted.') => {
-        if (terminal)
-            return stopping ?? Promise.resolve();
-        terminal = true;
-        clearIdle();
-        controller?.error(new Error(reason));
-        stopping = Promise.resolve().then(async () => {
-            try {
-                await iterator.return?.();
-            }
-            finally {
-                context.active.settle();
-            }
-        });
-        return stopping;
-    };
-    const fail = (cause) => {
-        if (terminal)
-            return;
-        terminal = true;
-        clearIdle();
-        controller?.error(cause);
-        stopping = Promise.resolve()
-            .then(() => iterator.return?.())
-            .catch(() => undefined)
-            .then(() => context.active.settle());
-    };
-    const body = new ReadableStream({
-        start(output) {
-            controller = output;
-            resetIdle();
-        },
-        async pull(controller) {
-            if (terminal)
-                return;
-            try {
-                const next = await iterator.next();
-                if (terminal)
-                    return;
-                if (next.done) {
-                    if (binary.length !== undefined && delivered !== binary.length) {
-                        fail(new Error('OUTCOME_UNKNOWN: streaming binary ended before its declared length.'));
-                        return;
-                    }
-                    terminal = true;
-                    clearIdle();
-                    controller.close();
-                    context.active.settle();
-                    return;
-                }
-                if (!(next.value instanceof Uint8Array)) {
-                    throw new TypeError('Streaming binary yielded a non-byte chunk.');
-                }
-                delivered += next.value.byteLength;
-                if (binary.length !== undefined && delivered > binary.length) {
-                    fail(new Error('OUTCOME_UNKNOWN: streaming binary exceeded its declared length.'));
-                    return;
-                }
-                controller.enqueue(next.value);
-                resetIdle();
-            }
-            catch (cause) {
-                fail(cause);
-            }
-        },
-        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, protocol.http.BINARY_LENGTH_FIELD]
-            : []),
-        ...applicationHeaders,
-    ]));
-    for (const [name, value] of Object.entries(binary.headers ?? {})) {
-        if (protocol.http.isApplicationBinaryHeader(name))
-            headers.set(name, value);
-    }
-    headers.set('content-type', binary.mediaType);
-    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 headers;
-}
-function streamHttpResponse(stream, context) {
-    const iterator = stream[Symbol.asyncIterator]();
-    const startFrame = encodeBoundedStreamFrame(context.codec, { kind: 'stream.start', requestId: context.requestId, invocation: context.invocation }, context.maximumResponseBytes);
-    let count = 0;
-    let terminal = false;
-    let controller;
-    let stopping;
-    const stop = (reason) => {
-        stopping ??= stopStream(reason);
-        return stopping;
-    };
-    async function stopStream(reason) {
-        if (terminal)
-            return;
-        terminal = true;
-        // End the wire response immediately. Producer cleanup remains part of the active operation,
-        // but an uncooperative producer must not leave the client waiting for a terminal frame.
-        if (controller !== undefined) {
-            try {
-                controller.enqueue(encodeBoundedStreamFrame(context.codec, cancellationFrame(context), context.maximumResponseBytes));
-            }
-            catch {
-                // The transport consumer may already have disconnected.
-            }
-            try {
-                controller.close();
-            }
-            catch {
-                // The stream may already be closed or cancelled by the consumer.
-            }
-        }
-        try {
-            await Promise.allSettled([
-                Promise.resolve().then(() => stream.cancel(reason)),
-                Promise.resolve().then(() => iterator.return?.()),
-            ]);
-        }
-        finally {
-            context.active.settle();
-        }
-    }
-    const body = new ReadableStream({
-        start(output) {
-            controller = output;
-            output.enqueue(startFrame);
-        },
-        async pull(output) {
-            if (terminal)
-                return;
-            try {
-                const next = await iterator.next();
-                if (terminal)
-                    return;
-                if (next.done) {
-                    terminal = true;
-                    output.enqueue(encodeBoundedStreamFrame(context.codec, {
-                        kind: 'stream.end',
-                        requestId: context.requestId,
-                        count,
-                    }, context.maximumResponseBytes));
-                    output.close();
-                    context.active.settle();
-                    return;
-                }
-                const frame = protocol.decodeStreamFrame({
-                    kind: 'stream.item',
-                    requestId: context.requestId,
-                    index: count,
-                    value: next.value,
-                });
-                output.enqueue(encodeBoundedStreamFrame(context.codec, frame, context.maximumResponseBytes));
-                count += 1;
-            }
-            catch (input) {
-                if (terminal)
-                    return;
-                terminal = true;
-                if (!context.active.signal.aborted) {
-                    try {
-                        output.enqueue(encodeBoundedStreamFrame(context.codec, {
-                            kind: 'stream.error',
-                            requestId: context.requestId,
-                            error: classifyError(input),
-                        }, context.maximumResponseBytes));
-                    }
-                    catch {
-                        // No valid terminal frame can be formed; closing is the only remaining signal.
-                    }
-                }
-                output.close();
-                await Promise.allSettled([
-                    Promise.resolve().then(() => stream.cancel('stream failed')),
-                    Promise.resolve().then(() => iterator.return?.()),
-                ]);
-                context.active.settle();
-            }
-        },
-        async cancel(reason) {
-            const message = typeof reason === 'string' ? reason : 'response consumer cancelled';
-            context.active.cancel(message);
-            await stop(message);
-        },
-    });
-    context.active.onCancel(stop);
-    return new Response(body, {
-        status: 200,
-        headers: {
-            ...context.cors([protocol.http.STREAM_FRAMING_FIELD]),
-            'cache-control': 'no-store',
-            'content-type': context.codec.contentType,
-            vary: mergeVary(context.cors(), 'accept'),
-            [protocol.http.STREAM_FRAMING_FIELD]: protocol.http.LENGTH_PREFIX_V1,
-        },
-    });
-}
-function bindingHeaders(input, negotiated) {
-    const headers = new Headers(input);
-    headers.set('cache-control', 'no-store');
-    if (negotiated)
-        appendVary(headers, 'accept');
-    return headers;
-}
-function errorEnvelopeResponse(codec, response, cors, status, negotiated, maximumResponseBytes) {
-    try {
-        return envelopeResponse(codec, response, cors, status, negotiated, maximumResponseBytes);
-    }
-    catch (error) {
-        if (!(error instanceof ResponseBodyTooLargeError))
-            throw error;
-        const fallback = {
-            requestId: response.requestId,
-            invocation: response.invocation,
-            error: {
-                code: errors.CODES.LIMIT_EXCEEDED,
-                message: 'Response body exceeds the configured limit.',
-            },
-        };
-        try {
-            return envelopeResponse(codec, fallback, cors, errors.httpStatusOf(fallback.error), negotiated, maximumResponseBytes);
-        }
-        catch (fallbackError) {
-            if (!(fallbackError instanceof ResponseBodyTooLargeError))
-                throw fallbackError;
-            return new Response(null, {
-                status: 500,
-                headers: bindingHeaders(cors, negotiated),
-            });
-        }
-    }
-}
-function encodeBoundedStreamFrame(codec, frame, maximumResponseBytes) {
-    const encoded = protocol.http.encodeStreamFrame(codec, frame);
-    if (encoded.byteLength - 4 > maximumResponseBytes) {
-        throw new ResponseBodyTooLargeError(maximumResponseBytes);
-    }
-    return encoded;
-}
-function requireResponseBound(input, maximumResponseBytes) {
-    if (maximumResponseBytes === undefined)
-        return;
-    const bytes = typeof input === 'string' ? new TextEncoder().encode(input).byteLength : input.byteLength;
-    if (bytes > maximumResponseBytes)
-        throw new ResponseBodyTooLargeError(maximumResponseBytes);
+    return settled(context.active, envelopeResponse(context.codec, envelope, context.cors(), 200, true, context.maximumResponseBytes));
 }
 function settled(operation, response) {
     operation.settle();
     return response;
 }
-function appendVary(headers, value) {
-    headers.set('vary', mergeVary(Object.fromEntries(headers), value));
-}
-function mergeVary(headers, value) {
-    const names = new Set((headers.vary ?? '')
-        .split(',')
-        .map((name) => name.trim().toLowerCase())
-        .filter(Boolean));
-    names.add(value.toLowerCase());
-    return [...names].join(', ');
-}
-function cancellationFrame(context) {
-    return {
-        kind: 'stream.error',
-        requestId: context.requestId,
-        error: interruptedStreamError(context.active.timedOut),
-    };
-}
-function toBody(input) {
-    if (typeof input === 'string')
-        return input;
-    const copy = new Uint8Array(input);
-    return copy.buffer;
-}

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

@@ -0,0 +1,14 @@
+import type { Codec } from '@astrale-os/kernel-protocol/codecs';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
+/** Encode a bounded envelope with its binding content type and cache policy. */
+export declare function envelopeResponse(codec: Codec, input: unknown, cors: Readonly<Record<string, string>>, status?: number, negotiated?: boolean, maximumResponseBytes?: number): Response;
+/** Bound an error, falling back to a correlated limit refusal or an empty response. */
+export declare function errorEnvelopeResponse(codec: Codec, response: protocol.ErrorResponse, cors: Readonly<Record<string, string>>, status: number, negotiated: boolean, maximumResponseBytes: number | undefined): Response;
+/** Enforce the configured byte budget before a buffered response is handed off. */
+export declare function requireResponseBound(input: string | Uint8Array, maximumResponseBytes: number | undefined): void;
+/** Retain existing Vary fields while declaring another response selector. */
+export declare function appendVary(headers: Headers, value: string): void;
+/** Merge one case-insensitive selector into the response Vary field. */
+export declare function mergeVary(headers: Readonly<Record<string, string>>, value: string): string;
+/** Detach encoded bytes for Fetch while retaining encoded text as text. */
+export declare function toBody(input: string | Uint8Array): BodyInit;

package/dist/transport/http/response.js

@@ -0,0 +1,77 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import { ResponseBodyTooLargeError } from '../../errors/index.js';
+/** Encode a bounded envelope with its binding content type and cache policy. */
+export function envelopeResponse(codec, input, cors, status = 200, negotiated = true, maximumResponseBytes) {
+    const encoded = codec.encode(input);
+    requireResponseBound(encoded, maximumResponseBytes);
+    const headers = bindingHeaders(cors, negotiated);
+    headers.set('content-type', codec.contentType);
+    return new Response(toBody(encoded), {
+        status,
+        headers,
+    });
+}
+function bindingHeaders(input, negotiated) {
+    const headers = new Headers(input);
+    headers.set('cache-control', 'no-store');
+    if (negotiated)
+        appendVary(headers, 'accept');
+    return headers;
+}
+/** Bound an error, falling back to a correlated limit refusal or an empty response. */
+export function errorEnvelopeResponse(codec, response, cors, status, negotiated, maximumResponseBytes) {
+    try {
+        return envelopeResponse(codec, response, cors, status, negotiated, maximumResponseBytes);
+    }
+    catch (error) {
+        if (!(error instanceof ResponseBodyTooLargeError))
+            throw error;
+        const fallback = {
+            requestId: response.requestId,
+            invocation: response.invocation,
+            error: {
+                code: errors.CODES.LIMIT_EXCEEDED,
+                message: 'Response body exceeds the configured limit.',
+            },
+        };
+        try {
+            return envelopeResponse(codec, fallback, cors, errors.httpStatusOf(fallback.error), negotiated, maximumResponseBytes);
+        }
+        catch (fallbackError) {
+            if (!(fallbackError instanceof ResponseBodyTooLargeError))
+                throw fallbackError;
+            return new Response(null, {
+                status: 500,
+                headers: bindingHeaders(cors, negotiated),
+            });
+        }
+    }
+}
+/** Enforce the configured byte budget before a buffered response is handed off. */
+export function requireResponseBound(input, maximumResponseBytes) {
+    if (maximumResponseBytes === undefined)
+        return;
+    const bytes = typeof input === 'string' ? new TextEncoder().encode(input).byteLength : input.byteLength;
+    if (bytes > maximumResponseBytes)
+        throw new ResponseBodyTooLargeError(maximumResponseBytes);
+}
+/** Retain existing Vary fields while declaring another response selector. */
+export function appendVary(headers, value) {
+    headers.set('vary', mergeVary(Object.fromEntries(headers), value));
+}
+/** Merge one case-insensitive selector into the response Vary field. */
+export function mergeVary(headers, value) {
+    const names = new Set((headers.vary ?? '')
+        .split(',')
+        .map((name) => name.trim().toLowerCase())
+        .filter(Boolean));
+    names.add(value.toLowerCase());
+    return [...names].join(', ');
+}
+/** Detach encoded bytes for Fetch while retaining encoded text as text. */
+export function toBody(input) {
+    if (typeof input === 'string')
+        return input;
+    const copy = new Uint8Array(input);
+    return copy.buffer;
+}

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

@@ -0,0 +1,5 @@
+import type { RenderContext } from './model.js';
+/** Frame ordered Invocation items and retain cleanup until the producer settles. */
+export declare function streamHttpResponse(stream: AsyncIterable<unknown> & {
+    cancel(reason?: string): Promise<void>;
+}, context: RenderContext): Response;

package/dist/transport/http/stream.js

@@ -0,0 +1,134 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { classifyError, ResponseBodyTooLargeError } from '../../errors/index.js';
+import { interruptedStreamError } from '../stream-error.js';
+import { mergeVary } from './response.js';
+/** Frame ordered Invocation items and retain cleanup until the producer settles. */
+export function streamHttpResponse(stream, context) {
+    const iterator = stream[Symbol.asyncIterator]();
+    const startFrame = encodeBoundedStreamFrame(context.codec, { kind: 'stream.start', requestId: context.requestId, invocation: context.invocation }, context.maximumResponseBytes);
+    let count = 0;
+    let terminal = false;
+    let controller;
+    let stopping;
+    const stop = (reason) => {
+        stopping ??= stopStream(reason);
+        return stopping;
+    };
+    async function stopStream(reason) {
+        if (terminal)
+            return;
+        terminal = true;
+        // End the wire response immediately. Producer cleanup remains part of the active operation,
+        // but an uncooperative producer must not leave the client waiting for a terminal frame.
+        if (controller !== undefined) {
+            try {
+                controller.enqueue(encodeBoundedStreamFrame(context.codec, cancellationFrame(context), context.maximumResponseBytes));
+            }
+            catch {
+                // The transport consumer may already have disconnected.
+            }
+            try {
+                controller.close();
+            }
+            catch {
+                // The stream may already be closed or cancelled by the consumer.
+            }
+        }
+        try {
+            await Promise.allSettled([
+                Promise.resolve().then(() => stream.cancel(reason)),
+                Promise.resolve().then(() => iterator.return?.()),
+            ]);
+        }
+        finally {
+            context.active.settle();
+        }
+    }
+    const body = new ReadableStream({
+        start(output) {
+            controller = output;
+            output.enqueue(startFrame);
+        },
+        async pull(output) {
+            if (terminal)
+                return;
+            try {
+                const next = await iterator.next();
+                if (terminal)
+                    return;
+                if (next.done) {
+                    terminal = true;
+                    output.enqueue(encodeBoundedStreamFrame(context.codec, {
+                        kind: 'stream.end',
+                        requestId: context.requestId,
+                        count,
+                    }, context.maximumResponseBytes));
+                    output.close();
+                    context.active.settle();
+                    return;
+                }
+                const frame = protocol.decodeStreamFrame({
+                    kind: 'stream.item',
+                    requestId: context.requestId,
+                    index: count,
+                    value: next.value,
+                });
+                output.enqueue(encodeBoundedStreamFrame(context.codec, frame, context.maximumResponseBytes));
+                count += 1;
+            }
+            catch (input) {
+                if (terminal)
+                    return;
+                terminal = true;
+                if (!context.active.signal.aborted) {
+                    try {
+                        output.enqueue(encodeBoundedStreamFrame(context.codec, {
+                            kind: 'stream.error',
+                            requestId: context.requestId,
+                            error: classifyError(input),
+                        }, context.maximumResponseBytes));
+                    }
+                    catch {
+                        // No valid terminal frame can be formed; closing is the only remaining signal.
+                    }
+                }
+                output.close();
+                await Promise.allSettled([
+                    Promise.resolve().then(() => stream.cancel('stream failed')),
+                    Promise.resolve().then(() => iterator.return?.()),
+                ]);
+                context.active.settle();
+            }
+        },
+        async cancel(reason) {
+            const message = typeof reason === 'string' ? reason : 'response consumer cancelled';
+            context.active.cancel(message);
+            await stop(message);
+        },
+    });
+    context.active.onCancel(stop);
+    return new Response(body, {
+        status: 200,
+        headers: {
+            ...context.cors([protocol.http.STREAM_FRAMING_FIELD]),
+            'cache-control': 'no-store',
+            'content-type': context.codec.contentType,
+            vary: mergeVary(context.cors(), 'accept'),
+            [protocol.http.STREAM_FRAMING_FIELD]: protocol.http.LENGTH_PREFIX_V1,
+        },
+    });
+}
+function encodeBoundedStreamFrame(codec, frame, maximumResponseBytes) {
+    const encoded = protocol.http.encodeStreamFrame(codec, frame);
+    if (encoded.byteLength - 4 > maximumResponseBytes) {
+        throw new ResponseBodyTooLargeError(maximumResponseBytes);
+    }
+    return encoded;
+}
+function cancellationFrame(context) {
+    return {
+        kind: 'stream.error',
+        requestId: context.requestId,
+        error: interruptedStreamError(context.active.timedOut),
+    };
+}