@loutrejs/loutre 0.4.1 → 0.6.0

package/dist/http/index.d.ts

@@ -1,8 +1,10 @@
-export * from './application.js';
-export * from './basic-auth.js';
-export * from './client.js';
+export { createHttpClient, fetchHttpTransport, HttpClientResponseError, } from './client.js';
+export type { FetchHttpTransportOptions, HttpClient, HttpClientRequest, HttpClientResponse, HttpClientTransport, HttpClientTransportRequest, HttpClientTransportResponse, } from './client.js';
+export { cors } from './cors.js';
 export type { CorsLayerDescriptor, CorsOptions, CorsOrigin } from './cors.js';
-export * from './definitions.js';
-export { http } from './hosted-protocol.js';
-export * from './request-body.js';
-export { validate } from './validate.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 { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, normalizeHttpPath, parseHttpPath, } from './path.js';
+export type { HttpPathSegment, PathParamNames } from './path.js';

package/dist/http/index.js

@@ -1,7 +1,5 @@
-export * from './application.js';
-export * from './basic-auth.js';
-export * from './client.js';
-export * from './definitions.js';
-export { http } from './hosted-protocol.js';
-export * from './request-body.js';
-export { validate } from './validate.js';
+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 { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, normalizeHttpPath, parseHttpPath, } from './path.js';

package/dist/{application → http}/openapi.d.ts

@@ -1,4 +1,5 @@
-import type { ApplicationDefinition } from './index.js';
+import { type ApplicationModel } from '../core/index.js';
+import { type HttpExecutionResponseDefinition, type HttpExecutionRouteDefinition } from './extension.js';
 export interface OpenApiInfo {
     readonly title: string;
     readonly version: string;
@@ -20,7 +21,6 @@ export interface GenerateOpenApiOptions {
 }
 export interface OpenApiDocument {
     readonly openapi: '3.2.0';
-    readonly jsonSchemaDialect: 'https://json-schema.org/draft/2020-12/schema';
     readonly info: OpenApiInfo;
     readonly servers?: readonly OpenApiServer[];
     readonly paths: Readonly<Record<string, OpenApiPathItem>>;
@@ -30,5 +30,14 @@ export interface OpenApiDocument {
 }
 type JsonSchema = Record<string, unknown>;
 type OpenApiPathItem = Record<string, unknown>;
-export declare function generateOpenApi(application: ApplicationDefinition, options: GenerateOpenApiOptions): OpenApiDocument;
+type OpenApiResponseDefinition = HttpExecutionResponseDefinition;
+export interface HttpOperationTarget {
+    readonly definition: Omit<HttpExecutionRouteDefinition, 'responses'> & {
+        readonly responses: Readonly<Record<string, OpenApiResponseDefinition>>;
+    };
+    readonly procedure: string;
+}
+export declare function generateOpenApi(source: ApplicationModel | {
+    readonly model: ApplicationModel;
+}, options: GenerateOpenApiOptions): OpenApiDocument;
 export {};

package/dist/{application → http}/openapi.js

@@ -1,6 +1,5 @@
-import { supportsJsonSchema, } from '../core/index.js';
-import { assertValidCompilation, compileApplication } from '../graph/index.js';
-import { httpRequestBodyContentType, httpRequestBodySchema, } from '../http/index.js';
+import { supportsJsonSchema, assertValidApplicationModel, } from '../core/index.js';
+import { httpExecutionExtension, } from './extension.js';
 const FIXED_METHODS = new Set([
     'get',
     'put',
@@ -12,40 +11,29 @@ const FIXED_METHODS = new Set([
     'trace',
     'query',
 ]);
-export function generateOpenApi(application, options) {
-    assertValidCompilation(compileApplication({
-        modules: application.modules,
-        ...(application.arguments === undefined
-            ? {}
-            : { arguments: application.arguments }),
-        tasks: application.tasks,
-        triggers: application.triggers,
-    }));
+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();
-    for (const module of collectModules(application.modules)) {
-        for (const implementation of module.definition.implementations ?? []) {
-            if (implementation.protocol !== 'http')
-                continue;
-            for (const procedure of implementation.procedures) {
-                const protocol = implementation.contract.procedures[procedure]?.protocols.http;
-                if (!protocol || protocol.protocol !== 'http')
-                    continue;
-                const typed = protocol;
-                const target = {
-                    definition: typed.definition,
-                    procedure,
-                };
-                const operation = createOperation(target, registry, operationIds, options.operationId);
-                attachOperation(paths, typed.definition, operation);
-            }
+    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));
         }
     }
     const schemas = registry.components();
     return {
         openapi: '3.2.0',
-        jsonSchemaDialect: 'https://json-schema.org/draft/2020-12/schema',
         info: options.info,
         ...(options.servers === undefined ? {} : { servers: options.servers }),
         paths,
@@ -82,6 +70,7 @@ function createOperation(target, registry, operationIds, resolveOperationId) {
     }
     if (request?.query) {
         parameters.push({
+            name: 'query',
             in: 'querystring',
             content: {
                 'application/x-www-form-urlencoded': {
@@ -94,7 +83,7 @@ function createOperation(target, registry, operationIds, resolveOperationId) {
         parameters.push(...headerParameters(request.headers, registry, target, 'RequestHeaders_Input'));
     }
     const requestBody = request?.body
-        ? createRequestBody(request.body, registry, target)
+        ? createRequestBody(request.body, request.headers, registry, target)
         : undefined;
     return {
         ...(definition.tags === undefined ? {} : { tags: definition.tags }),
@@ -113,21 +102,62 @@ function createOperation(target, registry, operationIds, resolveOperationId) {
             : { deprecated: definition.deprecated }),
     };
 }
-function createRequestBody(body, registry, target) {
-    const contentType = httpRequestBodyContentType(body);
+function createRequestBody(body, headers, registry, target) {
+    const mediaTypes = requestBodyMediaTypes(headers, registry, target);
+    const schema = registry.reference(body, 'input', componentName(target, 'RequestBody_Input'));
     return {
-        content: {
-            [contentType]: {
-                schema: registry.reference(httpRequestBodySchema(body), 'input', componentName(target, 'RequestBody_Input')),
-            },
-        },
+        content: Object.fromEntries(mediaTypes.map((mediaType) => [mediaType, { schema }])),
     };
 }
+function requestBodyMediaTypes(headers, registry, target) {
+    if (!headers) {
+        throw openApiError('LUTRE_OPENAPI_CONTENT_TYPE_001', `${describeTarget(target)} request body requires a request headers schema with content-type.`);
+    }
+    const materialized = registry.materialize(headers, 'input', componentName(target, 'RequestHeaders_Input'));
+    const properties = objectProperties(materialized.schema, 'LUTRE_OPENAPI_HEADER_SCHEMA_001', `${describeTarget(target)} request headers`);
+    const contentType = properties['content-type'];
+    if (!contentType) {
+        throw openApiError('LUTRE_OPENAPI_CONTENT_TYPE_001', `${describeTarget(target)} request headers must declare content-type.`);
+    }
+    const values = finiteStringValues(contentType);
+    if (!values || values.length === 0) {
+        throw openApiError('LUTRE_OPENAPI_CONTENT_TYPE_002', `${describeTarget(target)} request content-type must resolve to a finite set of string literals.`);
+    }
+    return [...new Set(values)];
+}
+function finiteStringValues(schema) {
+    if (typeof schema.const === 'string')
+        return [schema.const];
+    if (Array.isArray(schema.enum)) {
+        return schema.enum.every((value) => typeof value === 'string')
+            ? schema.enum
+            : undefined;
+    }
+    for (const keyword of ['anyOf', 'oneOf']) {
+        const alternatives = schema[keyword];
+        if (!Array.isArray(alternatives))
+            continue;
+        const values = [];
+        for (const alternative of alternatives) {
+            if (typeof alternative !== 'object' ||
+                alternative === null ||
+                Array.isArray(alternative)) {
+                return undefined;
+            }
+            const nested = finiteStringValues(alternative);
+            if (!nested)
+                return undefined;
+            values.push(...nested);
+        }
+        return values;
+    }
+    return undefined;
+}
 function createResponses(target, registry) {
     const grouped = new Map();
-    for (const [variant, response] of Object.entries(target.definition.responses)) {
+    for (const [name, response] of Object.entries(target.definition.responses)) {
         const current = grouped.get(response.status) ?? [];
-        current.push({ variant, response });
+        current.push({ name, response });
         grouped.set(response.status, current);
     }
     return Object.fromEntries([...grouped.entries()]
@@ -142,50 +172,64 @@ function createResponse(target, entries, registry) {
     if (streamKinds.size > 1) {
         throw openApiError('LUTRE_OPENAPI_RESPONSE_STREAM_001', `${describeTarget(target)} declares streaming and non-streaming responses with the same status.`);
     }
-    const schemas = entries.map(({ variant, response }) => registry.reference(response.body, 'output', componentName(target, `Response_${variant}_Output`)));
+    const schemas = entries
+        .filter(({ response }) => response.body !== undefined)
+        .map(({ name, response }) => registry.reference(response.body, 'output', componentName(target, `Response_${name}_Output`)));
     const payloadSchema = schemas.length === 1 ? schemas[0] : { oneOf: schemas };
     const streaming = entries[0]?.response.stream === 'server';
     const headers = mergeResponseHeaders(entries, registry, target);
     const descriptions = [
-        ...new Set(entries.map(({ variant, response }) => response.description ?? variant)),
+        ...new Set(entries.map(({ name, response }) => response.description ?? name)),
     ];
     return {
         description: descriptions.join(' / '),
         ...(headers === undefined ? {} : { headers }),
-        content: streaming
-            ? {
-                'text/event-stream': {
-                    itemSchema: {
-                        type: 'object',
-                        required: ['data'],
-                        properties: {
-                            data: {
-                                type: 'string',
-                                contentMediaType: 'application/json',
-                                contentSchema: payloadSchema,
+        ...(schemas.length === 0
+            ? {}
+            : {
+                content: streaming
+                    ? {
+                        'text/event-stream': {
+                            itemSchema: {
+                                type: 'object',
+                                required: ['data'],
+                                properties: {
+                                    data: {
+                                        type: 'string',
+                                        contentMediaType: 'application/json',
+                                        contentSchema: payloadSchema,
+                                    },
+                                },
                             },
                         },
+                    }
+                    : {
+                        'application/json': {
+                            schema: payloadSchema,
+                        },
                     },
-                },
-            }
-            : {
-                'application/json': {
-                    schema: payloadSchema,
-                },
-            },
+            }),
     };
 }
 function mergeResponseHeaders(entries, registry, target) {
     const result = new Map();
-    for (const { variant, response } of entries) {
-        if (!response.headers)
+    for (const { name, response } of entries) {
+        for (const [headerName, value] of Object.entries(responseHeadersDefaults(response.headers) ?? {})) {
+            if (value === undefined)
+                continue;
+            const current = result.get(headerName) ?? [];
+            current.push(responseHeaderDefaultSchema(value));
+            result.set(headerName, current);
+        }
+        const headerSchema = responseHeadersSchema(response.headers);
+        if (!headerSchema)
             continue;
-        const materialized = registry.materialize(response.headers, 'output', componentName(target, `Response_${variant}_Headers_Output`));
+        const materialized = registry.materialize(headerSchema, 'output', componentName(target, `Response_${name}_Headers_Output`));
         const properties = objectProperties(materialized.schema, 'LUTRE_OPENAPI_HEADER_SCHEMA_001', `${describeTarget(target)} response headers`);
-        for (const [name, schema] of Object.entries(properties)) {
-            const current = result.get(name) ?? [];
+        for (const [headerName, schema] of Object.entries(properties)) {
+            const current = result.get(headerName) ?? [];
             current.push(schema);
-            result.set(name, current);
+            result.set(headerName, current);
         }
     }
     if (result.size === 0)
@@ -199,13 +243,47 @@ function mergeResponseHeaders(entries, registry, target) {
         },
     ]));
 }
+function responseHeadersSchema(headers) {
+    if (isStandardSchema(headers))
+        return headers;
+    if (isResponseHeadersWithDefaults(headers))
+        return headers.schema;
+    return undefined;
+}
+function responseHeadersDefaults(headers) {
+    if (headers === undefined || isStandardSchema(headers))
+        return undefined;
+    if (isResponseHeadersWithDefaults(headers))
+        return headers.defaults;
+    return headers;
+}
+function isStandardSchema(value) {
+    return typeof value === 'object' && value !== null && '~standard' in value;
+}
+function isResponseHeadersWithDefaults(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'schema' in value &&
+        isStandardSchema(value.schema));
+}
+function responseHeaderDefaultSchema(value) {
+    if (typeof value === 'string')
+        return { type: 'string', const: value };
+    return {
+        type: 'array',
+        items: { type: 'string' },
+        const: [...value],
+    };
+}
 function headerParameters(schema, registry, target, suffix) {
     const materialized = registry.materialize(schema, 'input', componentName(target, suffix));
     const properties = objectProperties(materialized.schema, 'LUTRE_OPENAPI_HEADER_SCHEMA_001', `${describeTarget(target)} request headers`);
     const required = new Set(Array.isArray(materialized.schema.required)
         ? materialized.schema.required.filter((value) => typeof value === 'string')
         : []);
-    return Object.entries(properties).map(([name, propertySchema]) => ({
+    return Object.entries(properties)
+        .filter(([name]) => name.toLowerCase() !== 'content-type')
+        .map(([name, propertySchema]) => ({
         name,
         in: 'header',
         required: required.has(name),
@@ -240,20 +318,27 @@ function attachOperation(paths, definition, operation) {
     }
     additional[methodName] = operation;
 }
-function collectModules(roots) {
-    const result = [];
-    const seen = new Set();
-    const visit = (module) => {
-        if (seen.has(module))
-            return;
-        seen.add(module);
-        for (const imported of module.definition.imports ?? [])
-            visit(imported);
-        result.push(module);
+function rebaseLocalDefinitions(schema, schemaComponentName) {
+    const visit = (value) => {
+        if (Array.isArray(value))
+            return value.map(visit);
+        if (typeof value !== 'object' || value === null)
+            return value;
+        const result = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (key === '$ref' &&
+                typeof child === 'string' &&
+                child.startsWith('#/$defs/')) {
+                result[key] =
+                    `#/components/schemas/${escapeJsonPointer(schemaComponentName)}/$defs/${child.slice('#/$defs/'.length)}`;
+            }
+            else {
+                result[key] = visit(child);
+            }
+        }
+        return result;
     };
-    for (const root of roots)
-        visit(root);
-    return result;
+    return visit(schema);
 }
 class SchemaRegistry {
     bySchema = new Map();
@@ -294,28 +379,6 @@ class SchemaRegistry {
         return this.schemas;
     }
 }
-function rebaseLocalDefinitions(schema, schemaComponentName) {
-    const visit = (value) => {
-        if (Array.isArray(value))
-            return value.map(visit);
-        if (typeof value !== 'object' || value === null)
-            return value;
-        const result = {};
-        for (const [key, child] of Object.entries(value)) {
-            if (key === '$ref' &&
-                typeof child === 'string' &&
-                child.startsWith('#/$defs/')) {
-                result[key] =
-                    `#/components/schemas/${escapeJsonPointer(schemaComponentName)}/$defs/${child.slice('#/$defs/'.length)}`;
-            }
-            else {
-                result[key] = visit(child);
-            }
-        }
-        return result;
-    };
-    return visit(schema);
-}
 function componentName(target, suffix) {
     return sanitizeComponentName(`${target.definition.method} ${target.definition.path} ${target.procedure} ${suffix}`);
 }

package/dist/http/path.d.ts

@@ -1,41 +1,3 @@
-type AsciiLowercase = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
-type AsciiLetter = AsciiLowercase | Uppercase<AsciiLowercase>;
-type AsciiDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
-type ParamNameStart = AsciiLetter | '_';
-type ParamNameContinuation = ParamNameStart | AsciiDigit;
-type IsParamNameRest<TName extends string> = TName extends '' ? true : TName extends `${ParamNameContinuation}${infer TRest}` ? IsParamNameRest<TRest> : false;
-type IsParamName<TName extends string> = TName extends `${ParamNameStart}${infer TRest}` ? IsParamNameRest<TRest> : false;
-type IsStaticSegment<TSegment extends string> = TSegment extends '' ? false : TSegment extends `${string}{${string}` | `${string}}${string}` ? false : TSegment extends `${string}?${string}` | `${string}#${string}` ? false : true;
-type ValidatePathSegments<TSegments extends string, TSeen extends string = never> = TSegments extends `${infer THead}/${infer TTail}` ? ValidatePathSegment<THead, TSeen> extends infer TResult ? TResult extends {
-    readonly valid: true;
-    readonly seen: infer TNext extends string;
-} ? ValidatePathSegments<TTail, TNext> : false : false : ValidatePathSegment<TSegments, TSeen> extends {
-    readonly valid: true;
-} ? true : false;
-type ValidatePathSegment<TSegment extends string, TSeen extends string> = TSegment extends `{${infer TName}}` ? IsParamName<TName> extends true ? TName extends TSeen ? {
-    readonly valid: false;
-} : {
-    readonly valid: true;
-    readonly seen: TSeen | TName;
-} : {
-    readonly valid: false;
-} : IsStaticSegment<TSegment> extends true ? {
-    readonly valid: true;
-    readonly seen: TSeen;
-} : {
-    readonly valid: false;
-};
-export type IsValidHttpPath<TPath extends string> = string extends TPath ? false : TPath extends '/' ? true : TPath extends `/${infer TSegments}` ? ValidatePathSegments<TSegments> : false;
-type PathParamNamesFromSegments<TSegments extends string> = TSegments extends `${infer THead}/${infer TTail}` ? PathParamName<THead> | PathParamNamesFromSegments<TTail> : PathParamName<TSegments>;
-type PathParamName<TSegment extends string> = TSegment extends `{${infer TName}}` ? TName : never;
-export type PathParamNames<TPath extends string> = TPath extends `/${infer TSegments}` ? PathParamNamesFromSegments<TSegments> : never;
-export type RawPathParams<TPath extends string> = Readonly<{
-    [TName in PathParamNames<TPath>]: string;
-}>;
-type NormalizeHttpPathSegments<TSegments extends string> = TSegments extends `${infer THead}/${infer TTail}` ? `${NormalizeHttpPathSegment<THead>}/${NormalizeHttpPathSegments<TTail>}` : NormalizeHttpPathSegment<TSegments>;
-type NormalizeHttpPathSegment<TSegment extends string> = TSegment extends `{${string}}` ? '{}' : TSegment;
-export type NormalizeHttpPath<TPath extends string> = TPath extends '/' ? '/' : string extends TPath ? string : TPath extends `/${infer TSegments}` ? `/${NormalizeHttpPathSegments<TSegments>}` : never;
-export type HttpDispatchKey<TMethod extends string, TPath extends string> = `http:${Uppercase<TMethod>}:${NormalizeHttpPath<TPath>}`;
 export type HttpPathSegment = {
     readonly kind: 'static';
     readonly value: string;
@@ -43,6 +5,8 @@ export type HttpPathSegment = {
     readonly kind: 'param';
     readonly name: string;
 };
+export type PathParamNames<TPath extends string> = TPath extends `${string}{${infer TName}}${infer TRest}` ? TName | PathParamNames<TRest> : never;
+export declare function assertValidHttpMethod(method: string): void;
 export declare function parseHttpPath(path: string): readonly HttpPathSegment[];
 export declare function normalizeHttpPath(segments: readonly HttpPathSegment[]): string;
 export declare function createHttpDispatchKey(method: string, segments: readonly HttpPathSegment[]): string;
@@ -52,4 +16,3 @@ export declare class HttpPathDecodeError extends Error {
     readonly cause: unknown;
     constructor(cause: unknown);
 }
-export {};

package/dist/http/path.js

@@ -1,4 +1,10 @@
 const PARAM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const HTTP_METHOD_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+export function assertValidHttpMethod(method) {
+    if (!HTTP_METHOD_PATTERN.test(method)) {
+        throw new Error(`Invalid HTTP method: ${JSON.stringify(method)}`);
+    }
+}
 export function parseHttpPath(path) {
     if (path === '/')
         return Object.freeze([]);
@@ -50,8 +56,7 @@ export function matchHttpPath(segments, pathname) {
     if (requestSegments.length !== segments.length)
         return undefined;
     const params = {};
-    for (let index = 0; index < segments.length; index += 1) {
-        const routeSegment = segments[index];
+    for (const [index, routeSegment] of segments.entries()) {
         const requestSegment = requestSegments[index];
         if (routeSegment.kind === 'static') {
             if (routeSegment.value !== requestSegment)

package/dist/http/runtime/request.d.ts

@@ -0,0 +1,17 @@
+import { type StandardSchemaV1 } from '../../core/index.js';
+export declare function decodeQuery(searchParams: URLSearchParams): Readonly<Record<string, string | string[]>>;
+export declare function validateRequestHeaders(schema: StandardSchemaV1, bodyDeclared: boolean, headers: Headers): Promise<unknown>;
+export declare function validatedContentType(headers: unknown): string;
+export declare function decodeBody(request: Request, contentType: string): Promise<unknown>;
+export declare class HttpInputDecodeError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+export declare class HttpInputValidationError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+export declare class HttpUnsupportedMediaTypeError extends Error {
+    readonly mediaType: string | undefined;
+    constructor(mediaType: string | undefined);
+}

package/dist/http/runtime/request.js

@@ -0,0 +1,109 @@
+import { SchemaValidationError, validateSchema, } from '../../core/index.js';
+export function decodeQuery(searchParams) {
+    const query = {};
+    for (const [key, value] of searchParams) {
+        const current = query[key];
+        query[key] =
+            current === undefined
+                ? value
+                : Array.isArray(current)
+                    ? [...current, value]
+                    : [current, value];
+    }
+    return query;
+}
+export async function validateRequestHeaders(schema, bodyDeclared, headers) {
+    try {
+        return await validateSchema(schema, requestHeadersForValidation(headers));
+    }
+    catch (error) {
+        if (bodyDeclared &&
+            error instanceof SchemaValidationError &&
+            hasContentTypeIssue(error)) {
+            throw new HttpUnsupportedMediaTypeError(normalizeMediaType(headers.get('content-type')));
+        }
+        throw error;
+    }
+}
+export function validatedContentType(headers) {
+    if (typeof headers !== 'object' || headers === null) {
+        throw new TypeError('HTTP body requires validated request headers');
+    }
+    const contentType = headers['content-type'];
+    if (typeof contentType !== 'string' || contentType.length === 0) {
+        throw new TypeError('HTTP body requires request.headers content-type to resolve to a string');
+    }
+    return contentType;
+}
+export async function decodeBody(request, contentType) {
+    const mediaType = normalizeMediaType(contentType);
+    if (mediaType === 'application/json' || mediaType.endsWith('+json')) {
+        try {
+            return await request.json();
+        }
+        catch (error) {
+            throw new HttpInputDecodeError(error);
+        }
+    }
+    if (mediaType === 'multipart/form-data') {
+        try {
+            return await request.formData();
+        }
+        catch (error) {
+            throw new HttpInputDecodeError(error);
+        }
+    }
+    if (mediaType.startsWith('text/')) {
+        try {
+            return await request.text();
+        }
+        catch (error) {
+            throw new HttpInputDecodeError(error);
+        }
+    }
+    return request.body;
+}
+function requestHeadersForValidation(headers) {
+    const decoded = Object.fromEntries(headers.entries());
+    const contentType = normalizeMediaType(headers.get('content-type'));
+    if (contentType)
+        decoded['content-type'] = contentType;
+    return decoded;
+}
+function hasContentTypeIssue(error) {
+    return error.issues.some((issue) => {
+        const first = issue.path?.[0];
+        const key = typeof first === 'object' && first !== null && 'key' in first
+            ? first.key
+            : first;
+        return key === 'content-type';
+    });
+}
+function normalizeMediaType(value) {
+    const normalized = value?.split(';', 1)[0]?.trim().toLowerCase();
+    return normalized ? normalized : undefined;
+}
+export class HttpInputDecodeError extends Error {
+    cause;
+    constructor(cause) {
+        super('HTTP request body decode failed', { cause });
+        this.cause = cause;
+        this.name = 'HttpInputDecodeError';
+    }
+}
+export class HttpInputValidationError extends Error {
+    cause;
+    constructor(cause) {
+        super('HTTP request body validation failed', { cause });
+        this.cause = cause;
+        this.name = 'HttpInputValidationError';
+    }
+}
+export class HttpUnsupportedMediaTypeError extends Error {
+    mediaType;
+    constructor(mediaType) {
+        super('HTTP request content type is unsupported by the Contract');
+        this.mediaType = mediaType;
+        this.name = 'HttpUnsupportedMediaTypeError';
+    }
+}

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

@@ -0,0 +1,18 @@
+import { type StandardSchemaV1 } from '../../core/index.js';
+type HttpHeaderValue = string | readonly string[];
+type HttpHeaders = Readonly<Record<string, HttpHeaderValue | undefined>>;
+interface HttpResponseHeadersWithDefaults {
+    readonly schema: StandardSchemaV1;
+    readonly defaults: HttpHeaders;
+}
+type HttpResponseHeadersDefinition = StandardSchemaV1 | HttpHeaders | HttpResponseHeadersWithDefaults;
+export declare function validateResponseHeaders(schema: StandardSchemaV1 | undefined, headers: HttpHeaders | undefined): Promise<HttpHeaders | undefined>;
+export declare function responseHeadersSchema(headers: HttpResponseHeadersDefinition | undefined): StandardSchemaV1 | undefined;
+export declare function responseHeadersDefaults(headers: HttpResponseHeadersDefinition | undefined): HttpHeaders | undefined;
+export declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+export declare function isResponseHeadersWithDefaults(value: unknown): value is HttpResponseHeadersWithDefaults;
+export declare function mergeResponseHeaders(defaults: HttpHeaders | undefined, dynamic: HttpHeaders | undefined): Headers;
+export declare function applyResponseHeaders(headers: Headers, source: HttpHeaders | undefined): void;
+export declare function applyFrameworkHeadersToResponse(response: Response, source: Headers | undefined): Response;
+export declare function applyFrameworkResponseHeaders(headers: Headers, source: HttpHeaders | undefined): void;
+export {};