@loutrejs/loutre 0.5.0 → 0.6.0

package/dist/http/extension.js

@@ -0,0 +1,947 @@
+import { collectInjectedDependencies, getSourceLocation, inheritSourceLocation, composeLayers, defineExecution, defineExecutionExtension, defineLayer, runInInjectionContext, runtimeCapability, SchemaValidationError, validateSchema, } from '../core/index.js';
+import { createCorsActualResponseHeaders, createCorsPreflightResponseHeaders, } from './cors-internal.js';
+import { assertValidHttpMethod, compareHttpPathSpecificity, createHttpDispatchKey, HttpPathDecodeError, matchHttpPath, parseHttpPath, } from './path.js';
+import { IngressGate } from '../runtime/ingress-gate.js';
+import { AsyncIteratorCleanupDeadlineError, AsyncIteratorLifecycle, } from '../runtime/async-iterator-lifecycle.js';
+import { decodeBody, decodeQuery, HttpInputDecodeError, HttpInputValidationError, HttpUnsupportedMediaTypeError, validatedContentType, validateRequestHeaders, } from './runtime/request.js';
+import { applyFrameworkHeadersToResponse, applyFrameworkResponseHeaders, applyResponseHeaders, isResponseHeadersWithDefaults, isStandardSchema, mergeResponseHeaders, responseHeadersDefaults, responseHeadersSchema, validateResponseHeaders, } from './runtime/response.js';
+export const HTTP_SERVER = runtimeCapability('http.server');
+export const httpExecutionExtension = defineExecutionExtension({
+    kind: 'execution-extension',
+    abiVersion: '1',
+    name: 'loutre:http',
+    compile(definition, context) {
+        const contractSource = getSourceLocation(definition.contract);
+        const routes = Object.entries(definition.contract.routes).map(([name, route]) => compileHttpRoute(name, route, contractSource));
+        const id = definition.name || `${context.moduleId}.http.${context.definitionIndex}`;
+        const dependencies = new Set(collectInjectedDependencies({
+            kind: 'execution',
+            id: `http:${id}`,
+            name: id,
+        }, () => definition.factory()));
+        routes.forEach((route) => {
+            route.middlewares.forEach((middleware, index) => {
+                for (const dependency of collectInjectedDependencies({
+                    kind: 'layer',
+                    id: `http:${id}:${route.name}:${index}`,
+                    name: middleware.name,
+                }, () => middleware.factory())) {
+                    dependencies.add(dependency);
+                }
+            });
+        });
+        return {
+            kind: 'execution',
+            id,
+            executionKind: 'http.request',
+            dependencies: [...dependencies],
+            capabilities: [
+                ...new Set([
+                    HTTP_SERVER,
+                    ...routes.flatMap((route) => route.middlewares.flatMap((middleware) => middleware.capabilities)),
+                ]),
+            ],
+            compiled: Object.freeze({
+                routes: Object.freeze(routes),
+                factory: definition.factory,
+            }),
+        };
+    },
+    validate({ executions }) {
+        const dispatches = new Map();
+        return executions.flatMap((execution) => execution.compiled.routes.flatMap((route) => {
+            const owner = dispatches.get(route.dispatch);
+            if (owner) {
+                return [
+                    {
+                        code: 'LUTRE_HTTP_DUPLICATE_ROUTE',
+                        message: `${route.method} ${route.path} conflicts with ${owner}.`,
+                        path: execution.id,
+                    },
+                ];
+            }
+            dispatches.set(route.dispatch, execution.id);
+            return [];
+        }));
+    },
+    createRuntime(context) {
+        context.capabilities.get(HTTP_SERVER);
+        return createHttpExtensionRuntime(context.executions, context.applicationRuntime);
+    },
+    projectGraph: ({ execution }) => ({
+        routes: execution.compiled.routes.map((route) => ({
+            name: route.name,
+            method: route.method,
+            path: route.path,
+            ...(route.source === undefined ? {} : { source: route.source }),
+            middlewares: route.middlewares.map((middleware) => ({
+                name: middleware.name,
+                capabilities: middleware.capabilities.map((capability) => capability.id),
+                ...(getSourceLocation(middleware) === undefined
+                    ? {}
+                    : { source: getSourceLocation(middleware) }),
+            })),
+            responses: Object.fromEntries(Object.entries(route.definition.responses).map(([name, response]) => [
+                name,
+                { status: response.status },
+            ])),
+        })),
+    }),
+    host: {
+        namespace: 'http',
+        create: ({ runtime }) => ({ fetch: (request) => runtime.fetch(request) }),
+    },
+});
+export function httpError(definition, map) {
+    return Object.freeze({
+        kind: 'http-error-mapping',
+        definition,
+        map: map ?? ((error) => ({ body: error.data })),
+    });
+}
+export function defineHttpContract(routes) {
+    const resolvedRoutes = resolveHttpContractRoutes(routes);
+    for (const [name, route] of Object.entries(resolvedRoutes)) {
+        compileHttpRoute(name, route);
+    }
+    return Object.freeze({
+        kind: 'http-contract',
+        routes: Object.freeze(resolvedRoutes),
+    });
+}
+function resolveHttpContractRoutes(tree) {
+    const resolved = {};
+    const visit = (current, pathPrefix, inheritedResponses, inheritedMiddlewares) => {
+        for (const [name, node] of Object.entries(current)) {
+            if ('method' in node) {
+                if ('routes' in node) {
+                    throw new TypeError(`HTTP Contract node ${name} must be either a branch or a leaf route.`);
+                }
+                if (resolved[name]) {
+                    throw new TypeError(`Duplicate nested HTTP route name: ${name}`);
+                }
+                assertNoInheritedResponseCollision(name, inheritedResponses, node.responses);
+                resolved[name] = inheritSourceLocation({
+                    ...node,
+                    path: joinHttpPath(pathPrefix, node.path),
+                    responses: { ...inheritedResponses, ...node.responses },
+                    ...(inheritedMiddlewares.length === 0 && !node.middlewares
+                        ? {}
+                        : {
+                            middlewares: [
+                                ...inheritedMiddlewares,
+                                ...(node.middlewares ?? []),
+                            ],
+                        }),
+                }, node);
+                continue;
+            }
+            if (!('routes' in node)) {
+                throw new TypeError(`HTTP Contract node ${name} must declare method or routes.`);
+            }
+            const branchPath = node.path ?? '';
+            if (branchPath !== '')
+                parseHttpPath(branchPath);
+            assertNoInheritedResponseCollision(name, inheritedResponses, node.responses ?? {});
+            visit(node.routes, joinHttpPath(pathPrefix, branchPath), { ...inheritedResponses, ...node.responses }, [...inheritedMiddlewares, ...(node.middlewares ?? [])]);
+        }
+    };
+    visit(tree, '', {}, []);
+    return resolved;
+}
+function joinHttpPath(prefix, path) {
+    if (prefix === '')
+        return path;
+    if (prefix === '/')
+        return path;
+    if (path === '/')
+        return prefix;
+    return `${prefix}${path}`;
+}
+function assertNoInheritedResponseCollision(nodeName, inherited, declared) {
+    for (const name of Object.keys(declared)) {
+        if (name in inherited) {
+            throw new TypeError(`Duplicate inherited HTTP response ${name} at ${nodeName}.`);
+        }
+    }
+}
+export function defineHttpImplementation(definition) {
+    return defineExecution(httpExecutionExtension, {
+        name: definition.name ?? '',
+        contract: definition.contract,
+        factory: definition.factory,
+    });
+}
+export function bindHttpServer(driver) {
+    return { capability: HTTP_SERVER, value: driver };
+}
+export function defineHttpMiddleware(definition) {
+    return defineLayer(definition);
+}
+const bodyValidation = Object.freeze({
+    kind: 'http-validation',
+    part: 'body',
+});
+export const validate = Object.freeze({
+    body: bodyValidation,
+});
+export const executionHttp = Object.freeze({
+    contract: defineHttpContract,
+    implementation: defineHttpImplementation,
+    middleware: defineHttpMiddleware,
+    validate,
+    error: httpError,
+    extension: httpExecutionExtension,
+    serverCapability: HTTP_SERVER,
+    bindServer: bindHttpServer,
+});
+const httpFrameworkHeaders = Symbol('loutre.http.framework-headers');
+export function withHttpFrameworkHeaders(result, headers) {
+    const current = result[httpFrameworkHeaders];
+    return {
+        ...result,
+        [httpFrameworkHeaders]: { ...current, ...headers },
+    };
+}
+function compileHttpRoute(name, route, routeSourceFallback) {
+    assertValidHttpMethod(route.method);
+    const segments = parseHttpPath(route.path);
+    assertValidHttpRouteDefinition(route, segments);
+    const definition = snapshotHttpRouteDefinition(route);
+    const routeSource = getSourceLocation(route) ?? routeSourceFallback;
+    return Object.freeze({
+        name,
+        method: route.method.toUpperCase(),
+        path: route.path,
+        segments,
+        dispatch: createHttpDispatchKey(route.method, segments),
+        definition,
+        middlewares: compileHttpMiddlewares(definition),
+        ...(routeSource === undefined ? {} : { source: routeSource }),
+    });
+}
+function snapshotHttpRouteDefinition(route) {
+    const request = route.request
+        ? Object.freeze({
+            ...route.request,
+            ...(route.request.params === undefined
+                ? {}
+                : { params: Object.freeze({ ...route.request.params }) }),
+        })
+        : undefined;
+    const responses = Object.freeze(Object.fromEntries(Object.entries(route.responses).map(([name, response]) => [
+        name,
+        Object.freeze({
+            ...response,
+            ...(response.headers === undefined
+                ? {}
+                : { headers: snapshotHttpResponseHeaders(response.headers) }),
+            ...(response.error === undefined
+                ? {}
+                : { error: Object.freeze({ ...response.error }) }),
+        }),
+    ])));
+    return inheritSourceLocation(Object.freeze({
+        ...route,
+        ...(route.tags === undefined
+            ? {}
+            : { tags: Object.freeze([...route.tags]) }),
+        ...(request === undefined ? {} : { request }),
+        responses,
+        ...(route.middlewares === undefined
+            ? {}
+            : { middlewares: Object.freeze([...route.middlewares]) }),
+    }), route);
+}
+function snapshotHttpResponseHeaders(headers) {
+    if (isStandardSchema(headers))
+        return headers;
+    if (isResponseHeadersWithDefaults(headers)) {
+        return Object.freeze({
+            schema: headers.schema,
+            defaults: snapshotHttpHeaders(headers.defaults),
+        });
+    }
+    return snapshotHttpHeaders(headers);
+}
+function snapshotHttpHeaders(headers) {
+    return Object.freeze(Object.fromEntries(Object.entries(headers).map(([name, value]) => [
+        name,
+        Array.isArray(value) ? Object.freeze([...value]) : value,
+    ])));
+}
+function compileHttpMiddlewares(route) {
+    const declared = route.middlewares ?? [];
+    const compiled = declared.map((middleware) => isHttpValidationMiddleware(middleware)
+        ? compileHttpValidationMiddleware(middleware, route)
+        : middleware);
+    if (route.request?.body && !hasBodyValidation(declared)) {
+        compiled.push(createBodyValidationMiddleware(route.request.body));
+    }
+    return Object.freeze(compiled);
+}
+function compileHttpValidationMiddleware(middleware, route) {
+    switch (middleware.part) {
+        case 'body': {
+            const schema = route.request?.body;
+            if (!schema) {
+                throw new TypeError(`HTTP ${route.method} ${route.path} uses validate.body but declares no request body.`);
+            }
+            return createBodyValidationMiddleware(schema);
+        }
+    }
+}
+function createBodyValidationMiddleware(schema) {
+    return defineLayer({
+        name: 'validate.body',
+        factory: () => async (context, next) => {
+            const rawBody = await decodeBody(context.request, validatedContentType(context.input.headers));
+            try {
+                const body = await validateSchema(schema, rawBody);
+                context.input.body = body;
+            }
+            catch (error) {
+                if (error instanceof SchemaValidationError) {
+                    throw new HttpInputValidationError(error);
+                }
+                throw error;
+            }
+            await next();
+        },
+    });
+}
+function isHttpValidationMiddleware(middleware) {
+    return middleware.kind === 'http-validation';
+}
+function hasBodyValidation(middlewares) {
+    return middlewares.some((middleware) => isHttpValidationMiddleware(middleware) && middleware.part === 'body');
+}
+function countBodyValidations(middlewares) {
+    return middlewares.filter((middleware) => isHttpValidationMiddleware(middleware) && middleware.part === 'body').length;
+}
+function assertValidHttpRouteDefinition(route, segments) {
+    if (route.request?.body && !route.request.headers) {
+        throw new TypeError(`HTTP ${route.method} ${route.path} declares a body but no request headers schema.`);
+    }
+    const bodyValidationCount = countBodyValidations(route.middlewares ?? []);
+    if (!route.request?.body && bodyValidationCount > 0) {
+        throw new TypeError(`HTTP ${route.method} ${route.path} uses validate.body but declares no request body.`);
+    }
+    if (bodyValidationCount > 1) {
+        throw new TypeError(`HTTP ${route.method} ${route.path} declares validate.body more than once.`);
+    }
+    if (route.request?.params) {
+        const pathParams = segments
+            .filter((segment) => segment.kind === 'param')
+            .map((segment) => segment.name)
+            .toSorted();
+        const schemaParams = Object.keys(route.request.params).toSorted();
+        if (pathParams.length !== schemaParams.length ||
+            pathParams.some((name, index) => name !== schemaParams[index])) {
+            throw new TypeError(`HTTP ${route.method} ${route.path} request params must exactly match path parameters.`);
+        }
+    }
+    for (const [name, response] of Object.entries(route.responses)) {
+        if (!Number.isInteger(response.status) ||
+            response.status < 200 ||
+            response.status > 599) {
+            throw new TypeError(`HTTP response ${name} has invalid status ${response.status}.`);
+        }
+        if ((response.status === 204 ||
+            response.status === 205 ||
+            response.status === 304) &&
+            (response.body || response.stream === 'server')) {
+            throw new TypeError(`HTTP response ${name} with status ${response.status} cannot declare a body or stream.`);
+        }
+        if (response.stream === 'server' && !response.body) {
+            throw new TypeError(`HTTP server-stream response ${name} must declare a body schema.`);
+        }
+    }
+}
+function createHttpExtensionRuntime(executions, applicationRuntime) {
+    const ingress = new IngressGate();
+    const activeResponseStreams = new Set();
+    const handlers = new Map();
+    for (const execution of executions) {
+        handlers.set(execution.id, runInInjectionContext({
+            consumer: {
+                kind: 'execution',
+                id: `http:${execution.id}`,
+                name: execution.id,
+            },
+            resolve: (token) => applicationRuntime.resolve(token, execution.id),
+        }, () => execution.compiled.factory()));
+    }
+    const routes = executions
+        .flatMap((execution) => execution.compiled.routes.map((route) => ({
+        executionId: execution.id,
+        route,
+    })))
+        .toSorted((left, right) => compareHttpPathSpecificity(left.route.segments, right.route.segments));
+    return {
+        async drain({ timeoutMs }) {
+            ingress.stopAccepting();
+            const deadline = Date.now() + timeoutMs;
+            await ingress.waitForIdle();
+            const reason = new Error('LUTRE_HTTP_SERVER_STREAM_DRAIN: Application is shutting down.');
+            const results = await Promise.allSettled([...activeResponseStreams].map((stream) => stream.abort(reason, deadline)));
+            const errors = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
+            if (errors.length > 0) {
+                throw new AggregateError(errors, 'HTTP response stream drain failed.');
+            }
+        },
+        async fetch(request) {
+            if (!ingress.isAccepting) {
+                return Response.json({ error: 'Service Unavailable' }, { status: 503 });
+            }
+            const url = new URL(request.url);
+            const method = request.method.toUpperCase();
+            if (isCorsPreflightRequest(request)) {
+                try {
+                    const requestedMethod = request.headers
+                        .get('access-control-request-method')
+                        .toUpperCase();
+                    const match = findRuntimeHttpRoute(routes, requestedMethod, url.pathname);
+                    if (match) {
+                        const completePendingIngress = ingress.enter();
+                        if (!completePendingIngress) {
+                            return Response.json({ error: 'Service Unavailable' }, { status: 503 });
+                        }
+                        let lease;
+                        try {
+                            lease = applicationRuntime.beginExecution();
+                        }
+                        catch (error) {
+                            completePendingIngress();
+                            throw error;
+                        }
+                        try {
+                            const headers = await createCorsPreflightResponseHeaders(match.route.middlewares, request, match.route.method);
+                            if (headers) {
+                                return new Response(null, { status: 204, headers });
+                            }
+                        }
+                        finally {
+                            lease.complete();
+                            completePendingIngress();
+                        }
+                    }
+                }
+                catch (error) {
+                    if (error instanceof HttpPathDecodeError) {
+                        return Response.json({ error: 'Invalid request' }, { status: 400 });
+                    }
+                    return Response.json({ error: 'Internal Server Error' }, { status: 500 });
+                }
+            }
+            let match;
+            try {
+                match = findRuntimeHttpRoute(routes, method, url.pathname);
+            }
+            catch (error) {
+                if (error instanceof HttpPathDecodeError) {
+                    return Response.json({ error: 'Invalid request' }, { status: 400 });
+                }
+                return Response.json({ error: 'Internal Server Error' }, { status: 500 });
+            }
+            if (!match) {
+                return Response.json({ error: 'Not Found' }, { status: 404 });
+            }
+            const completePendingIngress = ingress.enter();
+            if (!completePendingIngress) {
+                return Response.json({ error: 'Service Unavailable' }, { status: 503 });
+            }
+            let lease;
+            try {
+                lease = applicationRuntime.beginExecution();
+            }
+            catch (error) {
+                completePendingIngress();
+                throw error;
+            }
+            const abortRequest = () => lease.abort(request.signal.reason);
+            let executionOwnedByStream = false;
+            let executionFinished = false;
+            const finishExecution = () => {
+                if (executionFinished)
+                    return;
+                executionFinished = true;
+                request.signal.removeEventListener('abort', abortRequest);
+                lease.complete();
+            };
+            const adoptResponseStream = (stream) => {
+                executionOwnedByStream = true;
+                const activeStream = {
+                    async abort(reason, deadline) {
+                        stream.setDrainDeadline?.(deadline);
+                        lease.abort(reason);
+                        await stream.abort(reason, deadline);
+                    },
+                };
+                activeResponseStreams.add(activeStream);
+                void stream.finished.then(() => {
+                    activeResponseStreams.delete(activeStream);
+                });
+            };
+            request.signal.addEventListener('abort', abortRequest, { once: true });
+            if (request.signal.aborted)
+                abortRequest();
+            try {
+                const corsHeaders = await createCorsActualResponseHeaders(match.route.middlewares, request);
+                const complete = (response) => applyFrameworkHeadersToResponse(response, corsHeaders);
+                let context;
+                try {
+                    context = await createHttpContext(request, url, match.params, match.route, lease.signal);
+                }
+                catch (error) {
+                    if (error instanceof HttpUnsupportedMediaTypeError) {
+                        return complete(Response.json({ error: 'Unsupported Media Type' }, { status: 415 }));
+                    }
+                    if (error instanceof HttpInputDecodeError) {
+                        return complete(Response.json({ error: 'Invalid request' }, { status: 400 }));
+                    }
+                    if (error instanceof SchemaValidationError) {
+                        return complete(Response.json({ error: 'Validation failed' }, { status: 400 }));
+                    }
+                    throw error;
+                }
+                const handler = handlers.get(match.executionId)?.[match.route.name];
+                if (!handler) {
+                    throw new Error(`LUTRE_HTTP_HANDLER_MISSING: ${match.executionId}.${match.route.name}`);
+                }
+                const result = await composeLayers({
+                    context,
+                    layers: match.route.middlewares,
+                    resolve: (token, source) => applicationRuntime.resolve(token, source),
+                    terminal: async (middlewareContext) => handler({
+                        input: middlewareContext.input,
+                        response: middlewareContext.response,
+                        signal: middlewareContext.signal,
+                        state: middlewareContext.state,
+                    }),
+                });
+                const finalized = await finalizeHttpResult(match.route.definition, result, lease.signal, finishExecution);
+                if (finalized.streamControl)
+                    adoptResponseStream(finalized.streamControl);
+                return complete(finalized.response);
+            }
+            catch (error) {
+                if (error instanceof HttpInputDecodeError) {
+                    return applyFrameworkHeadersToResponse(Response.json({ error: 'Invalid request' }, { status: 400 }), await safeCorsHeaders(match.route.middlewares, request));
+                }
+                if (error instanceof HttpInputValidationError) {
+                    return applyFrameworkHeadersToResponse(Response.json({ error: 'Validation failed' }, { status: 400 }), await safeCorsHeaders(match.route.middlewares, request));
+                }
+                try {
+                    const mapped = await mapDeclaredError(match.route.definition, error);
+                    if (mapped) {
+                        const finalized = await finalizeHttpResult(match.route.definition, mapped, lease.signal, finishExecution);
+                        if (finalized.streamControl) {
+                            adoptResponseStream(finalized.streamControl);
+                        }
+                        return applyFrameworkHeadersToResponse(finalized.response, await safeCorsHeaders(match.route.middlewares, request));
+                    }
+                }
+                catch {
+                    // 内部のmapping/finalization errorをclientへ公開しない。
+                }
+                return applyFrameworkHeadersToResponse(Response.json({ error: 'Internal Server Error' }, { status: 500 }), await safeCorsHeaders(match.route.middlewares, request));
+            }
+            finally {
+                if (!executionOwnedByStream)
+                    finishExecution();
+                completePendingIngress();
+            }
+        },
+    };
+}
+function findRuntimeHttpRoute(routes, method, pathname) {
+    for (const candidate of routes) {
+        if (candidate.route.method !== method)
+            continue;
+        const params = matchHttpPath(candidate.route.segments, pathname);
+        if (!params)
+            continue;
+        return { ...candidate, params };
+    }
+    return undefined;
+}
+async function safeCorsHeaders(middlewares, request) {
+    try {
+        return await createCorsActualResponseHeaders(middlewares, request);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCorsPreflightRequest(request) {
+    return (request.method.toUpperCase() === 'OPTIONS' &&
+        request.headers.has('origin') &&
+        request.headers.has('access-control-request-method'));
+}
+async function createHttpContext(request, url, rawParams, route, signal) {
+    const definition = route.definition.request;
+    const params = definition?.params
+        ? Object.fromEntries(await Promise.all(Object.entries(definition.params).map(async ([name, schema]) => [
+            name,
+            await validateSchema(schema, rawParams[name]),
+        ])))
+        : rawParams;
+    const rawQuery = decodeQuery(url.searchParams);
+    const query = definition?.query
+        ? await validateSchema(definition.query, rawQuery)
+        : rawQuery;
+    const headers = definition?.headers
+        ? await validateRequestHeaders(definition.headers, definition.body !== undefined, request.headers)
+        : Object.fromEntries(request.headers.entries());
+    const body = definition?.body ? request.body : undefined;
+    const response = Object.fromEntries(Object.keys(route.definition.responses).map((name) => [
+        name,
+        (value = {}) => ({
+            kind: 'http-result',
+            response: name,
+            body: value.body,
+            ...(value.headers === undefined ? {} : { headers: value.headers }),
+        }),
+    ]));
+    return {
+        request,
+        input: { params, query, headers, body },
+        response,
+        signal,
+    };
+}
+async function finalizeHttpResult(route, result, signal, completeExecution) {
+    const response = route.responses[result.response];
+    if (!response) {
+        throw new Error(`LUTRE_HTTP_RESPONSE_UNDECLARED: ${result.response}`);
+    }
+    const responseHeaders = await validateResponseHeaders(responseHeadersSchema(response.headers), result.headers);
+    const headers = mergeResponseHeaders(responseHeadersDefaults(response.headers), responseHeaders);
+    applyFrameworkResponseHeaders(headers, result[httpFrameworkHeaders]);
+    if (response.stream === 'server') {
+        if (!response.body || !isAsyncIterable(result.body)) {
+            throw new Error('Server-stream response requires an AsyncIterable body');
+        }
+        applyResponseHeaders(headers, {
+            'content-type': 'text/event-stream; charset=utf-8',
+            'cache-control': 'no-cache',
+        });
+        const serverStream = createServerSentEventStream(result.body, response.body, signal, completeExecution);
+        return {
+            response: new Response(serverStream.stream, {
+                status: response.status,
+                headers,
+            }),
+            streamControl: serverStream,
+        };
+    }
+    const body = response.body
+        ? await validateSchema(response.body, result.body)
+        : undefined;
+    if (body === undefined) {
+        return {
+            response: new Response(null, { status: response.status, headers }),
+        };
+    }
+    if (body instanceof ReadableStream) {
+        const responseStream = createLeasedReadableStream(body, signal, completeExecution);
+        return {
+            response: new Response(responseStream.stream, {
+                status: response.status,
+                headers,
+            }),
+            streamControl: responseStream,
+        };
+    }
+    if (typeof body === 'string' ||
+        body instanceof ArrayBuffer ||
+        ArrayBuffer.isView(body) ||
+        body instanceof Blob ||
+        body instanceof FormData ||
+        body instanceof URLSearchParams) {
+        return {
+            response: new Response(body, {
+                status: response.status,
+                headers,
+            }),
+        };
+    }
+    if (!headers.has('content-type')) {
+        headers.set('content-type', 'application/json; charset=utf-8');
+    }
+    return {
+        response: new Response(JSON.stringify(body), {
+            status: response.status,
+            headers,
+        }),
+    };
+}
+function createLeasedReadableStream(source, signal, completeExecution) {
+    const reader = source.getReader();
+    let finished = false;
+    let completed = false;
+    let inFlightOperations = 0;
+    let cleanupSettled = true;
+    let controller;
+    let cleanup;
+    let resolveFinished;
+    const finishedPromise = new Promise((resolve) => {
+        resolveFinished = resolve;
+    });
+    const markFinished = () => {
+        if (finished)
+            return false;
+        finished = true;
+        signal.removeEventListener('abort', abort);
+        return true;
+    };
+    const completeIfSafe = () => {
+        if (completed || !finished || !cleanupSettled || inFlightOperations > 0) {
+            return;
+        }
+        completed = true;
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // pending中のreader操作がsettleするまではlockを解放できない。
+        }
+        try {
+            completeExecution();
+        }
+        finally {
+            resolveFinished();
+        }
+    };
+    const stop = (reason, errorStream) => {
+        if (cleanup)
+            return cleanup;
+        if (!markFinished())
+            return finishedPromise;
+        cleanupSettled = false;
+        cleanup = (async () => {
+            let cleanupError;
+            try {
+                await reader.cancel(reason);
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+            finally {
+                cleanupSettled = true;
+                if (errorStream) {
+                    controller?.error(cleanupError ?? reason ?? new Error('HTTP request was aborted'));
+                }
+                completeIfSafe();
+            }
+            await finishedPromise;
+            if (cleanupError !== undefined)
+                throw cleanupError;
+        })();
+        return cleanup;
+    };
+    const abort = () => {
+        void stop(signal.reason, true).catch(() => undefined);
+    };
+    const stream = new ReadableStream({
+        start(value) {
+            controller = value;
+            if (signal.aborted)
+                abort();
+            else
+                signal.addEventListener('abort', abort, { once: true });
+        },
+        async pull(value) {
+            if (finished)
+                return;
+            inFlightOperations += 1;
+            try {
+                const next = await reader.read();
+                if (finished)
+                    return;
+                if (next.done) {
+                    if (markFinished())
+                        value.close();
+                    return;
+                }
+                value.enqueue(next.value);
+            }
+            catch (error) {
+                if (markFinished())
+                    value.error(error);
+            }
+            finally {
+                inFlightOperations -= 1;
+                completeIfSafe();
+            }
+        },
+        cancel(reason) {
+            return stop(reason, false);
+        },
+    });
+    return {
+        stream,
+        finished: finishedPromise,
+        abort: (reason) => stop(reason, true),
+    };
+}
+function createServerSentEventStream(source, schema, signal, completeExecution) {
+    const encoder = new TextEncoder();
+    const iterator = new AsyncIteratorLifecycle(source[Symbol.asyncIterator]());
+    let finished = false;
+    let completed = false;
+    let inFlightOperations = 0;
+    let cleanupComplete = false;
+    let cleanupSettled = true;
+    let controller;
+    let cleanupAttempt;
+    let cleanupDeadline;
+    let resolveFinished;
+    const finishedPromise = new Promise((resolve) => {
+        resolveFinished = resolve;
+    });
+    const markFinished = () => {
+        if (finished)
+            return false;
+        finished = true;
+        signal.removeEventListener('abort', abort);
+        return true;
+    };
+    const completeIfSafe = () => {
+        if (completed || !finished || !cleanupSettled || inFlightOperations > 0) {
+            return;
+        }
+        completed = true;
+        try {
+            completeExecution();
+        }
+        finally {
+            resolveFinished();
+        }
+    };
+    const stop = (reason, errorStream, deadline) => {
+        if (cleanupAttempt) {
+            if (deadline !== undefined) {
+                cleanupDeadline = Math.min(cleanupDeadline ?? deadline, deadline);
+            }
+            return cleanupAttempt;
+        }
+        if (deadline !== undefined)
+            cleanupDeadline = deadline;
+        markFinished();
+        if (cleanupComplete)
+            return finishedPromise;
+        cleanupSettled = false;
+        const operation = (async () => {
+            let cleanupError;
+            try {
+                await iterator.drain(reason, () => cleanupDeadline, 'HTTP iterator cleanup exceeded the drain deadline.');
+            }
+            catch (error) {
+                if (error instanceof AsyncIteratorCleanupDeadlineError)
+                    throw error;
+                cleanupError = error;
+            }
+            finally {
+                if (iterator.done || cleanupError !== undefined) {
+                    cleanupComplete = true;
+                    cleanupSettled = true;
+                    if (errorStream) {
+                        controller?.error(cleanupError ?? reason ?? new Error('HTTP request was aborted'));
+                    }
+                    completeIfSafe();
+                }
+            }
+            await finishedPromise;
+            if (cleanupError !== undefined)
+                throw cleanupError;
+        })();
+        cleanupAttempt = operation;
+        void operation.then(() => {
+            if (cleanupAttempt === operation)
+                cleanupAttempt = undefined;
+        }, () => {
+            if (cleanupAttempt === operation)
+                cleanupAttempt = undefined;
+        });
+        return operation;
+    };
+    const abort = () => {
+        void stop(signal.reason, true).catch(() => undefined);
+    };
+    const stream = new ReadableStream({
+        start(value) {
+            controller = value;
+            if (signal.aborted)
+                abort();
+            else
+                signal.addEventListener('abort', abort, { once: true });
+        },
+        async pull(value) {
+            if (finished)
+                return;
+            inFlightOperations += 1;
+            let stopPromise;
+            try {
+                const next = await iterator.next();
+                if (finished)
+                    return;
+                if (next.done) {
+                    if (markFinished())
+                        value.close();
+                    return;
+                }
+                const item = await validateSchema(schema, next.value);
+                if (finished)
+                    return;
+                value.enqueue(encoder.encode(`data:${JSON.stringify(item)}\n\n`));
+            }
+            catch (error) {
+                stopPromise = stop(error, true);
+            }
+            finally {
+                inFlightOperations -= 1;
+                completeIfSafe();
+            }
+            await stopPromise;
+        },
+        cancel(reason) {
+            return stop(reason, false);
+        },
+    });
+    return {
+        stream,
+        finished: finishedPromise,
+        setDrainDeadline(deadline) {
+            cleanupDeadline = deadline;
+        },
+        abort: (reason, deadline) => stop(reason, true, deadline),
+    };
+}
+async function mapDeclaredError(route, error) {
+    for (const [responseName, response] of Object.entries(route.responses)) {
+        const mapping = response.error;
+        if (!mapping?.definition.is(error))
+            continue;
+        const mapped = await mapping.map(error);
+        if (typeof mapped !== 'object' || mapped === null || !('body' in mapped)) {
+            throw new Error('HTTP error mapping must return a body');
+        }
+        return {
+            kind: 'http-result',
+            response: responseName,
+            body: mapped.body,
+            ...('headers' in mapped
+                ? { headers: mapped.headers }
+                : {}),
+        };
+    }
+    return undefined;
+}
+function isAsyncIterable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}