@loutrejs/loutre 0.6.0 → 0.8.0

package/dist/http/extension.js

@@ -1,18 +1,35 @@
 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 { findHttpRouteConflicts } from './route-validation.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';
+import { match as patternMatch } from 'ts-pattern';
 export const HTTP_SERVER = runtimeCapability('http.server');
+const httpContractBrand = Symbol.for('loutre.http-contract');
+export function isHttpContract(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return (candidate.kind === 'http-contract' &&
+        candidate[httpContractBrand] === true &&
+        typeof candidate.routes === 'object' &&
+        candidate.routes !== null);
+}
+export function defineHttpRaw(definition) {
+    return defineExecution(httpExecutionExtension, { ...definition, raw: true });
+}
 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 raw = 'route' in definition;
+        const routes = raw
+            ? [compileRawRoute(definition.route)]
+            : Object.entries(definition.contract.routes).map(([name, route]) => compileHttpRoute(name, route, getSourceLocation(definition.contract)));
         const id = definition.name || `${context.moduleId}.http.${context.definitionIndex}`;
         const dependencies = new Set(collectInjectedDependencies({
             kind: 'execution',
@@ -43,25 +60,22 @@ export const httpExecutionExtension = defineExecutionExtension({
             ],
             compiled: Object.freeze({
                 routes: Object.freeze(routes),
-                factory: definition.factory,
+                factory: (raw
+                    ? () => ({ raw: definition.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 [];
+        const routes = executions.flatMap((execution) => execution.compiled.routes.map((route) => ({
+            method: route.method,
+            path: route.path,
+            owner: execution.id,
+        })));
+        return findHttpRouteConflicts(routes).map(({ existing, route }) => ({
+            code: 'LUTRE_HTTP_DUPLICATE_ROUTE',
+            message: `${route.method} ${route.path} conflicts with ${existing.owner}.`,
+            path: route.owner,
         }));
     },
     createRuntime(context) {
@@ -81,10 +95,16 @@ export const httpExecutionExtension = defineExecutionExtension({
                     ? {}
                     : { source: getSourceLocation(middleware) }),
             })),
-            responses: Object.fromEntries(Object.entries(route.definition.responses).map(([name, response]) => [
-                name,
-                { status: response.status },
-            ])),
+            ...(route.raw
+                ? {
+                    raw: true,
+                    ...(route.protocol === undefined
+                        ? {}
+                        : { protocol: route.protocol }),
+                }
+                : {
+                    responses: Object.fromEntries(Object.entries(route.definition.responses).map(([name, response]) => [name, { status: response.status }])),
+                }),
         })),
     }),
     host: {
@@ -101,12 +121,14 @@ export function httpError(definition, map) {
 }
 export function defineHttpContract(routes) {
     const resolvedRoutes = resolveHttpContractRoutes(routes);
-    for (const [name, route] of Object.entries(resolvedRoutes)) {
-        compileHttpRoute(name, route);
-    }
+    const canonicalRoutes = Object.fromEntries(Object.entries(resolvedRoutes).map(([name, route]) => [
+        name,
+        compileHttpRoute(name, route).definition,
+    ]));
     return Object.freeze({
         kind: 'http-contract',
-        routes: Object.freeze(resolvedRoutes),
+        [httpContractBrand]: true,
+        routes: Object.freeze(canonicalRoutes),
     });
 }
 function resolveHttpContractRoutes(tree) {
@@ -186,6 +208,7 @@ export const validate = Object.freeze({
     body: bodyValidation,
 });
 export const executionHttp = Object.freeze({
+    raw: defineHttpRaw,
     contract: defineHttpContract,
     implementation: defineHttpImplementation,
     middleware: defineHttpMiddleware,
@@ -203,7 +226,29 @@ export function withHttpFrameworkHeaders(result, headers) {
         [httpFrameworkHeaders]: { ...current, ...headers },
     };
 }
+function compileRawRoute(route) {
+    if (route.method !== '*')
+        assertValidHttpMethod(route.method);
+    const segments = parseHttpPath(route.path);
+    return Object.freeze({
+        name: 'raw',
+        method: route.method.toUpperCase(),
+        path: route.path,
+        segments,
+        dispatch: createHttpDispatchKey(route.method, segments),
+        definition: Object.freeze({
+            method: route.method,
+            path: route.path,
+            responses: Object.freeze({}),
+        }),
+        middlewares: Object.freeze([...(route.middlewares ?? [])]),
+        raw: true,
+        ...(route.protocol === undefined ? {} : { protocol: route.protocol }),
+    });
+}
 function compileHttpRoute(name, route, routeSourceFallback) {
+    if (route.method === '*')
+        throw new TypeError('method: *はhttp.raw()でのみ利用できます。');
     assertValidHttpMethod(route.method);
     const segments = parseHttpPath(route.path);
     assertValidHttpRouteDefinition(route, segments);
@@ -281,15 +326,15 @@ function compileHttpMiddlewares(route) {
     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);
+    return patternMatch(middleware)
+        .with({ part: '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);
+    })
+        .exhaustive();
 }
 function createBodyValidationMiddleware(schema) {
     return defineLayer({
@@ -409,7 +454,12 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                         }
                         let lease;
                         try {
-                            lease = applicationRuntime.beginExecution();
+                            lease = applicationRuntime.beginExecution({
+                                executionId: match.executionId,
+                                executionKind: 'http.request',
+                                graphNodeId: match.executionId,
+                                name: `OPTIONS ${match.route.path}`,
+                            });
                         }
                         catch (error) {
                             completePendingIngress();
@@ -418,6 +468,7 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                         try {
                             const headers = await createCorsPreflightResponseHeaders(match.route.middlewares, request, match.route.method);
                             if (headers) {
+                                lease.annotate?.({ 'http.status_code': 204 });
                                 return new Response(null, { status: 204, headers });
                             }
                         }
@@ -445,7 +496,30 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                 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({
+                        executionId: 'http.not-found',
+                        executionKind: 'http.request',
+                        name: `${method} ${url.pathname}`,
+                    });
+                }
+                catch (error) {
+                    completePendingIngress();
+                    throw error;
+                }
+                try {
+                    lease.annotate?.({ 'http.status_code': 404 });
+                    return Response.json({ error: 'Not Found' }, { status: 404 });
+                }
+                finally {
+                    lease.complete();
+                    completePendingIngress();
+                }
             }
             const completePendingIngress = ingress.enter();
             if (!completePendingIngress) {
@@ -453,7 +527,12 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
             }
             let lease;
             try {
-                lease = applicationRuntime.beginExecution();
+                lease = applicationRuntime.beginExecution({
+                    executionId: match.executionId,
+                    executionKind: 'http.request',
+                    graphNodeId: match.executionId,
+                    name: `${match.route.method} ${match.route.path}`,
+                });
             }
             catch (error) {
                 completePendingIngress();
@@ -462,12 +541,17 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
             const abortRequest = () => lease.abort(request.signal.reason);
             let executionOwnedByStream = false;
             let executionFinished = false;
+            let executionResult;
+            let hasExecutionResult = false;
             const finishExecution = () => {
                 if (executionFinished)
                     return;
                 executionFinished = true;
                 request.signal.removeEventListener('abort', abortRequest);
-                lease.complete();
+                if (hasExecutionResult)
+                    lease.complete(executionResult);
+                else
+                    lease.complete();
             };
             const adoptResponseStream = (stream) => {
                 executionOwnedByStream = true;
@@ -486,9 +570,13 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
             request.signal.addEventListener('abort', abortRequest, { once: true });
             if (request.signal.aborted)
                 abortRequest();
+            const annotateResponse = (response) => {
+                lease.annotate?.({ 'http.status_code': response.status });
+                return response;
+            };
             try {
                 const corsHeaders = await createCorsActualResponseHeaders(match.route.middlewares, request);
-                const complete = (response) => applyFrameworkHeadersToResponse(response, corsHeaders);
+                const complete = (response) => annotateResponse(applyFrameworkHeadersToResponse(response, corsHeaders));
                 let context;
                 try {
                     context = await createHttpContext(request, url, match.params, match.route, lease.signal);
@@ -509,17 +597,83 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                 if (!handler) {
                     throw new Error(`LUTRE_HTTP_HANDLER_MISSING: ${match.executionId}.${match.route.name}`);
                 }
-                const result = await composeLayers({
+                const dispatch = () => 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,
-                    }),
+                    terminal: async (middlewareContext) => {
+                        const handlerName = `${match.executionId}.${match.route.name}`;
+                        const handlerOperation = applicationRuntime.beginOperation?.({
+                            kind: 'http.handler',
+                            name: handlerName,
+                            graphNodeId: match.executionId,
+                        }, match.route.raw
+                            ? undefined
+                            : {
+                                input: middlewareContext.input,
+                                invoke: (input) => replayHttpHandler(applicationRuntime, handler, match, input, middlewareContext.state),
+                            });
+                        const invoke = () => handler({
+                            ...(match.route.raw
+                                ? {
+                                    request,
+                                    execution: {
+                                        signal: lease.signal,
+                                        annotate: (attributes) => lease.annotate?.(attributes),
+                                        beginOperation: (metadata) => {
+                                            const begin = () => applicationRuntime.beginOperation?.(metadata) ?? {
+                                                complete() { },
+                                            };
+                                            return lease.run ? lease.run(begin) : begin();
+                                        },
+                                    },
+                                }
+                                : {}),
+                            input: middlewareContext.input,
+                            response: middlewareContext.response,
+                            signal: match.route.raw
+                                ? request.signal
+                                : middlewareContext.signal,
+                            state: middlewareContext.state,
+                        });
+                        let result;
+                        let hasResult = false;
+                        try {
+                            result = await (handlerOperation?.run
+                                ? handlerOperation.run(invoke)
+                                : invoke());
+                            hasResult = true;
+                            return result;
+                        }
+                        catch (error) {
+                            handlerOperation?.fail?.(error);
+                            throw error;
+                        }
+                        finally {
+                            if (hasResult)
+                                handlerOperation?.complete(result);
+                            else
+                                handlerOperation?.complete();
+                        }
+                    },
                 });
+                const result = await (lease.run ? lease.run(dispatch) : dispatch());
+                executionResult = result;
+                hasExecutionResult = true;
+                if (result instanceof Response) {
+                    if (result.body) {
+                        const stream = createLeasedReadableStream(result.body, lease.signal, finishExecution);
+                        adoptResponseStream(stream);
+                        return complete(new Response(stream.stream, {
+                            status: result.status,
+                            statusText: result.statusText,
+                            headers: result.headers,
+                        }));
+                    }
+                    return complete(result);
+                }
+                if (match.route.raw)
+                    throw new TypeError('Raw handlerとmiddlewareはResponseを返す必要があります。');
                 const finalized = await finalizeHttpResult(match.route.definition, result, lease.signal, finishExecution);
                 if (finalized.streamControl)
                     adoptResponseStream(finalized.streamControl);
@@ -527,11 +681,12 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
             }
             catch (error) {
                 if (error instanceof HttpInputDecodeError) {
-                    return applyFrameworkHeadersToResponse(Response.json({ error: 'Invalid request' }, { status: 400 }), await safeCorsHeaders(match.route.middlewares, request));
+                    return annotateResponse(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));
+                    return annotateResponse(applyFrameworkHeadersToResponse(Response.json({ error: 'Validation failed' }, { status: 400 }), await safeCorsHeaders(match.route.middlewares, request)));
                 }
+                lease.fail?.(error);
                 try {
                     const mapped = await mapDeclaredError(match.route.definition, error);
                     if (mapped) {
@@ -539,13 +694,13 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                         if (finalized.streamControl) {
                             adoptResponseStream(finalized.streamControl);
                         }
-                        return applyFrameworkHeadersToResponse(finalized.response, await safeCorsHeaders(match.route.middlewares, request));
+                        return annotateResponse(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));
+                return annotateResponse(applyFrameworkHeadersToResponse(Response.json({ error: 'Internal Server Error' }, { status: 500 }), await safeCorsHeaders(match.route.middlewares, request)));
             }
             finally {
                 if (!executionOwnedByStream)
@@ -557,7 +712,7 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
 }
 function findRuntimeHttpRoute(routes, method, pathname) {
     for (const candidate of routes) {
-        if (candidate.route.method !== method)
+        if (candidate.route.method !== method && candidate.route.method !== '*')
             continue;
         const params = matchHttpPath(candidate.route.segments, pathname);
         if (!params)
@@ -595,7 +750,16 @@ async function createHttpContext(request, url, rawParams, route, signal) {
         ? 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) => [
+    const response = createHttpResponseHelpers(route.definition.responses);
+    return {
+        request,
+        input: { params, query, headers, body },
+        response,
+        signal,
+    };
+}
+function createHttpResponseHelpers(responses) {
+    return Object.fromEntries(Object.keys(responses).map((name) => [
         name,
         (value = {}) => ({
             kind: 'http-result',
@@ -604,12 +768,40 @@ async function createHttpContext(request, url, rawParams, route, signal) {
             ...(value.headers === undefined ? {} : { headers: value.headers }),
         }),
     ]));
-    return {
-        request,
-        input: { params, query, headers, body },
-        response,
-        signal,
-    };
+}
+async function replayHttpHandler(applicationRuntime, handler, match, input, state) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new TypeError('LUTRE_DEVTOOLS_HTTP_HANDLER_INPUT_REQUIRED');
+    }
+    const lease = applicationRuntime.beginExecution({
+        executionId: match.executionId,
+        executionKind: 'http.handler',
+        graphNodeId: match.executionId,
+        name: `${match.executionId}.${match.route.name}`,
+    });
+    const invoke = () => handler({
+        input,
+        response: createHttpResponseHelpers(match.route.definition.responses),
+        signal: lease.signal,
+        state,
+    });
+    let result;
+    let hasResult = false;
+    try {
+        result = await (lease.run ? lease.run(invoke) : invoke());
+        hasResult = true;
+        return result;
+    }
+    catch (error) {
+        lease.fail?.(error);
+        throw error;
+    }
+    finally {
+        if (hasResult)
+            lease.complete(result);
+        else
+            lease.complete();
+    }
 }
 async function finalizeHttpResult(route, result, signal, completeExecution) {
     const response = route.responses[result.response];

package/dist/http/index.d.ts

@@ -4,7 +4,8 @@ export { cors } from './cors.js';
 export type { CorsLayerDescriptor, CorsOptions, CorsOrigin } from './cors.js';
 export { basicAuth, bearerAuth } from './auth.js';
 export type { BasicAuthContext, BasicAuthCredentials, BasicAuthDefinition, BasicAuthUnauthorized, BasicAuthRuntime, BearerAuthContext, BearerAuthDefinition, BearerAuthRuntime, BearerAuthUnauthorized, HttpAuthenticationFailure, } from './auth.js';
-export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, httpError, executionHttp as http, httpExecutionExtension, HTTP_SERVER, validate, } from './extension.js';
-export type { HttpContract, HttpContractBranchDefinition, HttpContractNodeDefinition, HttpContractRouteTree, HttpExecutionContext, HttpExecutionDefinition, HttpExecutionRequestDefinition, HttpExecutionResponseDefinition, HttpExecutionResult, HttpExecutionRouteDefinition, HttpErrorMapping, HttpErrorMatcher, HttpExtensionRuntime, HttpHandlers, HttpHeaderValue, HttpHeaders, HttpHostApi, HttpImplementationDefinition, HttpMiddleware, HttpMiddlewareContext, HttpResponseHeadersDefinition, HttpResponseResult, HttpResponseHeadersWithDefaults, HttpServerDriver, HttpValidationMiddleware, HttpValidationPart, ResolvedHttpContractRoutes, } from './extension.js';
+export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, defineHttpRaw, httpError, executionHttp as http, httpExecutionExtension, isHttpContract, HTTP_SERVER, validate, } from './extension.js';
+export type { HttpRawDefinition, HttpRawRouteDefinition, HttpRawExecutionContext, HttpRawExecutionDefinition, HttpContract, HttpContractBranchDefinition, HttpContractNodeDefinition, HttpContractRouteTree, HttpExecutionContext, HttpExecutionDefinition, HttpExecutionRequestDefinition, HttpExecutionResponseDefinition, HttpExecutionResult, HttpExecutionRouteDefinition, HttpErrorMapping, HttpErrorMatcher, HttpExtensionRuntime, HttpHandlers, HttpHeaderValue, HttpHeaders, HttpHostApi, HttpImplementationDefinition, HttpMiddleware, HttpMiddlewareContext, HttpResponseHeadersDefinition, HttpResponseResult, HttpResponseHeadersWithDefaults, HttpServerDriver, HttpValidationMiddleware, HttpValidationPart, ResolvedHttpContractRoutes, } from './extension.js';
 export { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, normalizeHttpPath, parseHttpPath, } from './path.js';
 export type { HttpPathSegment, PathParamNames } from './path.js';
+export type { HttpRequestHeadDefinition } from './request-head.js';

package/dist/http/index.js

@@ -1,5 +1,5 @@
 export { createHttpClient, fetchHttpTransport, HttpClientResponseError, } from './client.js';
 export { cors } from './cors.js';
 export { basicAuth, bearerAuth } from './auth.js';
-export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, httpError, executionHttp as http, httpExecutionExtension, HTTP_SERVER, validate, } from './extension.js';
+export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, defineHttpRaw, httpError, executionHttp as http, httpExecutionExtension, isHttpContract, HTTP_SERVER, validate, } from './extension.js';
 export { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, normalizeHttpPath, parseHttpPath, } from './path.js';

package/dist/http/openapi.d.ts

@@ -1,5 +1,5 @@
 import { type ApplicationModel } from '../core/index.js';
-import { type HttpExecutionResponseDefinition, type HttpExecutionRouteDefinition } from './extension.js';
+import { type HttpContract, type HttpExecutionResponseDefinition, type HttpExecutionRouteDefinition } from './extension.js';
 export interface OpenApiInfo {
     readonly title: string;
     readonly version: string;
@@ -37,7 +37,6 @@ export interface HttpOperationTarget {
     };
     readonly procedure: string;
 }
-export declare function generateOpenApi(source: ApplicationModel | {
-    readonly model: ApplicationModel;
-}, options: GenerateOpenApiOptions): OpenApiDocument;
+export type OpenApiSource = ApplicationModel | HttpContract;
+export declare function generateOpenApi(source: OpenApiSource, options: GenerateOpenApiOptions): OpenApiDocument;
 export {};

package/dist/http/openapi.js

@@ -1,5 +1,7 @@
 import { supportsJsonSchema, assertValidApplicationModel, } from '../core/index.js';
-import { httpExecutionExtension, } from './extension.js';
+import { httpExecutionExtension, isHttpContract, } from './extension.js';
+import { findHttpRouteConflicts } from './route-validation.js';
+import { match } from 'ts-pattern';
 const FIXED_METHODS = new Set([
     'get',
     'put',
@@ -12,24 +14,11 @@ const FIXED_METHODS = new Set([
     'query',
 ]);
 export function generateOpenApi(source, options) {
-    const model = 'model' in source ? source.model : source;
-    assertValidApplicationModel(model);
     const registry = new SchemaRegistry();
     const paths = {};
     const operationIds = new Set();
-    const http = model.extensions.get(httpExecutionExtension);
-    for (const execution of http?.executions ?? []) {
-        for (const route of execution.compiled.routes) {
-            const target = {
-                procedure: route.name,
-                definition: {
-                    ...route.definition,
-                    method: route.method,
-                    path: route.path,
-                },
-            };
-            attachOperation(paths, target.definition, createOperation(target, registry, operationIds, options.operationId));
-        }
+    for (const target of httpOperationTargets(source)) {
+        attachOperation(paths, target.definition, createOperation(target, registry, operationIds, options.operationId));
     }
     const schemas = registry.components();
     return {
@@ -40,6 +29,37 @@ export function generateOpenApi(source, options) {
         ...(Object.keys(schemas).length === 0 ? {} : { components: { schemas } }),
     };
 }
+function httpOperationTargets(source) {
+    if (source.kind === 'http-contract') {
+        if (!isHttpContract(source)) {
+            throw openApiError('LUTRE_OPENAPI_SOURCE_001', 'HttpContract source must be created by http.contract().');
+        }
+        const routes = Object.entries(source.routes).map(([procedure, definition]) => ({ procedure, definition }));
+        const [conflict] = findHttpRouteConflicts(routes.map(({ definition }) => definition));
+        if (conflict) {
+            throw openApiError('LUTRE_OPENAPI_OPERATION_001', `Duplicate OpenAPI operation: ${conflict.route.method.toUpperCase()} ${conflict.route.path} conflicts with ${conflict.existing.method.toUpperCase()} ${conflict.existing.path}`);
+        }
+        return routes.map(({ procedure, definition }) => ({
+            procedure,
+            definition: {
+                ...definition,
+                method: definition.method.toUpperCase(),
+            },
+        }));
+    }
+    assertValidApplicationModel(source);
+    const http = source.extensions.get(httpExecutionExtension);
+    return (http?.executions ?? []).flatMap((execution) => execution.compiled.routes
+        .filter((route) => !route.raw)
+        .map((route) => ({
+        procedure: route.name,
+        definition: {
+            ...route.definition,
+            method: route.method,
+            path: route.path,
+        },
+    })));
+}
 function createOperation(target, registry, operationIds, resolveOperationId) {
     const definition = target.definition;
     const operationId = resolveOperationId?.({
@@ -244,18 +264,17 @@ function mergeResponseHeaders(entries, registry, target) {
     ]));
 }
 function responseHeadersSchema(headers) {
-    if (isStandardSchema(headers))
-        return headers;
-    if (isResponseHeadersWithDefaults(headers))
-        return headers.schema;
-    return undefined;
+    return match(headers)
+        .when(isStandardSchema, (schema) => schema)
+        .when(isResponseHeadersWithDefaults, (definition) => definition.schema)
+        .otherwise(() => undefined);
 }
 function responseHeadersDefaults(headers) {
-    if (headers === undefined || isStandardSchema(headers))
-        return undefined;
-    if (isResponseHeadersWithDefaults(headers))
-        return headers.defaults;
-    return headers;
+    return match(headers)
+        .with(undefined, () => undefined)
+        .when(isStandardSchema, () => undefined)
+        .when(isResponseHeadersWithDefaults, (definition) => definition.defaults)
+        .otherwise((definition) => definition);
 }
 function isStandardSchema(value) {
     return typeof value === 'object' && value !== null && '~standard' in value;

package/dist/http/request-head.d.ts

@@ -0,0 +1,6 @@
+import type { StandardSchemaV1 } from '../core/index.js';
+export interface HttpRequestHeadDefinition {
+    readonly params?: Readonly<Record<string, StandardSchemaV1>>;
+    readonly query?: StandardSchemaV1;
+    readonly headers?: StandardSchemaV1;
+}

package/dist/http/request-head.js

@@ -0,0 +1 @@
+export {};

package/dist/http/route-validation.d.ts

@@ -0,0 +1,9 @@
+export interface HttpRouteDescriptor {
+    readonly method: string;
+    readonly path: string;
+}
+export interface HttpRouteConflict<TRoute extends HttpRouteDescriptor> {
+    readonly existing: TRoute;
+    readonly route: TRoute;
+}
+export declare function findHttpRouteConflicts<TRoute extends HttpRouteDescriptor>(routes: readonly TRoute[]): readonly HttpRouteConflict<TRoute>[];

package/dist/http/route-validation.js

@@ -0,0 +1,18 @@
+import { createHttpDispatchKey, parseHttpPath } from './path.js';
+export function findHttpRouteConflicts(routes) {
+    const dispatches = new Map();
+    const conflicts = [];
+    for (const route of routes) {
+        const dispatch = createHttpDispatchKey(route.method, parseHttpPath(route.path));
+        const existing = dispatches.get(dispatch) ??
+            [...dispatches.values()].find((candidate) => (route.method === '*' || candidate.method === '*') &&
+                createHttpDispatchKey('*', parseHttpPath(candidate.path)) ===
+                    createHttpDispatchKey('*', parseHttpPath(route.path)));
+        if (existing) {
+            conflicts.push({ existing, route });
+            continue;
+        }
+        dispatches.set(dispatch, route);
+    }
+    return conflicts;
+}