@loutrejs/loutre 0.1.0

package/dist/http/basic-auth.d.ts

@@ -0,0 +1,37 @@
+import { type ContextKey, type ContextKeyValue, type LayerDescriptor } from '../core/index.js';
+import type { LogicalHttpResult } from './definitions.js';
+export interface BasicAuthCredentials {
+    readonly username: string;
+    readonly password: string;
+}
+export interface BasicAuthUnauthorized<TVariant extends string, TBody> {
+    readonly variant: TVariant;
+    readonly body: TBody;
+}
+export interface BasicAuthOptions<TPrincipal extends ContextKey, TVariant extends string, TUnauthorizedBody> {
+    readonly realm: string;
+    readonly principal: TPrincipal;
+    readonly authenticate: (credentials: BasicAuthCredentials) => ContextKeyValue<TPrincipal> | null | undefined | Promise<ContextKeyValue<TPrincipal> | null | undefined>;
+    readonly unauthorized: BasicAuthUnauthorized<TVariant, TUnauthorizedBody>;
+    readonly name?: string;
+}
+type BasicAuthShortCircuits<TVariant extends string> = readonly [
+    {
+        readonly protocol: 'http';
+        readonly variant: TVariant;
+        readonly response: {
+            readonly status: 401;
+        };
+    }
+];
+type BasicAuthResponseHeaders = {
+    readonly 'www-authenticate': string;
+};
+export interface BasicAuthLayerDescriptor<TPrincipal extends ContextKey, TVariant extends string, TUnauthorizedBody> extends LayerDescriptor<readonly [], readonly [TPrincipal], string extends TVariant ? unknown : LogicalHttpResult<TVariant, TUnauthorizedBody, BasicAuthResponseHeaders>, BasicAuthShortCircuits<TVariant>, string, 'authentication', readonly [], BasicAuthContext> {
+    readonly role: 'authentication';
+}
+export interface BasicAuthContext {
+    readonly headers: Readonly<Record<string, string | undefined>>;
+}
+export declare function basicAuth<TPrincipal extends ContextKey, const TVariant extends string, TUnauthorizedBody>(options: BasicAuthOptions<TPrincipal, TVariant, TUnauthorizedBody>): BasicAuthLayerDescriptor<TPrincipal, TVariant, TUnauthorizedBody>;
+export {};

package/dist/http/basic-auth.js

@@ -0,0 +1,67 @@
+import { layer, shortCircuit, } from '../core/index.js';
+export function basicAuth(options) {
+    const challenge = formatBasicChallenge(options.realm);
+    const descriptor = layer({
+        name: options.name ?? 'basicAuth',
+        role: 'authentication',
+        provides: [options.principal],
+        shortCircuits: [
+            {
+                protocol: 'http',
+                variant: options.unauthorized.variant,
+                response: { status: 401 },
+            },
+        ],
+        factory: () => async (ctx, next) => {
+            const credentials = decodeBasicCredentials(ctx.headers.authorization);
+            if (!credentials) {
+                return unauthorizedResult(options.unauthorized, challenge);
+            }
+            const principal = await options.authenticate(credentials);
+            if (principal == null) {
+                return unauthorizedResult(options.unauthorized, challenge);
+            }
+            await next({
+                [options.principal.name]: principal,
+            });
+        },
+    });
+    return Object.freeze(descriptor);
+}
+function unauthorizedResult(unauthorized, challenge) {
+    return shortCircuit({
+        kind: 'http-result',
+        variant: unauthorized.variant,
+        body: unauthorized.body,
+        headers: {
+            'www-authenticate': challenge,
+        },
+    });
+}
+function formatBasicChallenge(realm) {
+    if (realm.length === 0 || /[\u0000-\u001f\u007f]/.test(realm)) {
+        throw new TypeError('Basic認証のrealmには空文字列または制御文字を使用できません');
+    }
+    const escaped = realm.replace(/[\\"]/g, '\\$&');
+    return `Basic realm="${escaped}", charset="UTF-8"`;
+}
+function decodeBasicCredentials(authorization) {
+    const match = /^Basic +([A-Za-z0-9+/]+={0,2})$/i.exec(authorization ?? '');
+    if (!match?.[1])
+        return undefined;
+    try {
+        const binary = atob(match[1]);
+        const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+        const decoded = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        const separator = decoded.indexOf(':');
+        if (separator < 0)
+            return undefined;
+        return {
+            username: decoded.slice(0, separator),
+            password: decoded.slice(separator + 1),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/http/cors.d.ts

@@ -0,0 +1,17 @@
+import { type LayerDescriptor, type PipelineItem } from '../core/index.js';
+export type CorsOrigin = string | readonly string[] | ((origin: string) => boolean | Promise<boolean>);
+export interface CorsOptions {
+    readonly origin?: CorsOrigin;
+    readonly allowMethods?: readonly string[];
+    readonly allowHeaders?: readonly string[];
+    readonly exposeHeaders?: readonly string[];
+    readonly credentials?: boolean;
+    readonly maxAge?: number;
+    readonly name?: string;
+}
+export interface CorsLayerDescriptor extends LayerDescriptor<readonly [], readonly [], never, readonly [], string, 'framework', readonly [], object> {
+    readonly role: 'framework';
+}
+export declare function cors(options?: CorsOptions): CorsLayerDescriptor;
+export declare function createCorsActualResponseHeaders(pipeline: readonly PipelineItem[], request: Request): Promise<Headers | undefined>;
+export declare function createCorsPreflightResponseHeaders(pipeline: readonly PipelineItem[], request: Request, targetMethod: string): Promise<Headers | undefined>;

package/dist/http/cors.js

@@ -0,0 +1,171 @@
+import { childPipelineOf, layer, layerDefinitionOf, } from '../core/index.js';
+const policies = new WeakMap();
+const httpToken = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+export function cors(options = {}) {
+    const policy = normalizeCorsOptions(options);
+    const descriptor = layer({
+        name: options.name ?? 'cors',
+        role: 'framework',
+        factory: () => async (_ctx, next) => {
+            await next();
+        },
+    });
+    policies.set(descriptor, policy);
+    return descriptor;
+}
+export async function createCorsActualResponseHeaders(pipeline, request) {
+    const policy = corsPolicyOfPipeline(pipeline);
+    if (!policy)
+        return undefined;
+    const origin = request.headers.get('origin');
+    const headers = new Headers();
+    if (policy.origin.kind !== 'wildcard')
+        appendVary(headers, 'Origin');
+    if (origin === null)
+        return headers;
+    await applyOrigin(headers, policy, origin);
+    if (!headers.has('access-control-allow-origin'))
+        return headers;
+    if (policy.credentials) {
+        headers.set('access-control-allow-credentials', 'true');
+    }
+    if (policy.exposeHeaders.length > 0) {
+        headers.set('access-control-expose-headers', policy.exposeHeaders.join(', '));
+    }
+    return headers;
+}
+export async function createCorsPreflightResponseHeaders(pipeline, request, targetMethod) {
+    const policy = corsPolicyOfPipeline(pipeline);
+    if (!policy)
+        return undefined;
+    const headers = new Headers();
+    appendVary(headers, 'Access-Control-Request-Method');
+    const origin = request.headers.get('origin');
+    if (origin === null)
+        return headers;
+    await applyOrigin(headers, policy, origin);
+    if (!headers.has('access-control-allow-origin'))
+        return headers;
+    if (policy.credentials) {
+        headers.set('access-control-allow-credentials', 'true');
+    }
+    const methods = policy.allowMethods ?? [targetMethod.toUpperCase()];
+    if (methods.length > 0) {
+        headers.set('access-control-allow-methods', methods.join(', '));
+    }
+    if (policy.allowHeaders === undefined) {
+        const requested = request.headers.get('access-control-request-headers');
+        if (requested !== null && requested.trim().length > 0) {
+            headers.set('access-control-allow-headers', requested);
+            appendVary(headers, 'Access-Control-Request-Headers');
+        }
+    }
+    else if (policy.allowHeaders.length > 0) {
+        headers.set('access-control-allow-headers', policy.allowHeaders.join(', '));
+    }
+    if (policy.maxAge !== undefined) {
+        headers.set('access-control-max-age', String(policy.maxAge));
+    }
+    return headers;
+}
+function corsPolicyOfPipeline(pipeline) {
+    let found;
+    const visit = (items) => {
+        for (const item of items) {
+            if (item.kind !== 'layer')
+                continue;
+            const definition = layerDefinitionOf(item);
+            const policy = policies.get(definition);
+            if (policy)
+                found = policy;
+            const child = childPipelineOf(item);
+            if (child)
+                visit(child);
+        }
+    };
+    visit(pipeline);
+    return found;
+}
+async function applyOrigin(headers, policy, origin) {
+    if (policy.origin.kind === 'wildcard') {
+        headers.set('access-control-allow-origin', '*');
+        return;
+    }
+    appendVary(headers, 'Origin');
+    const allowed = policy.origin.kind === 'exact'
+        ? policy.origin.origins.has(origin)
+        : await policy.origin.predicate(origin);
+    if (allowed)
+        headers.set('access-control-allow-origin', origin);
+}
+function normalizeCorsOptions(options) {
+    const origin = normalizeOrigin(options.origin ?? '*', options.credentials ?? false);
+    return Object.freeze({
+        origin,
+        allowMethods: options.allowMethods === undefined
+            ? undefined
+            : normalizeTokens(options.allowMethods, 'allowMethods', true),
+        allowHeaders: options.allowHeaders === undefined
+            ? undefined
+            : normalizeTokens(options.allowHeaders, 'allowHeaders', false),
+        exposeHeaders: normalizeTokens(options.exposeHeaders ?? [], 'exposeHeaders', false),
+        credentials: options.credentials ?? false,
+        maxAge: normalizeMaxAge(options.maxAge),
+    });
+}
+function normalizeOrigin(origin, credentials) {
+    if (typeof origin === 'function') {
+        return Object.freeze({ kind: 'predicate', predicate: origin });
+    }
+    const origins = typeof origin === 'string' ? [origin] : [...origin];
+    if (origins.length === 0) {
+        return Object.freeze({ kind: 'exact', origins: new Set() });
+    }
+    for (const value of origins) {
+        if (value.length === 0 || /[\u0000-\u001f\u007f]/.test(value)) {
+            throw new TypeError('CORS originには空文字列または制御文字を使用できません');
+        }
+    }
+    if (origins.includes('*')) {
+        if (credentials) {
+            throw new TypeError('credentialsを有効にする場合、CORS originにワイルドカードは使用できません');
+        }
+        return Object.freeze({ kind: 'wildcard' });
+    }
+    return Object.freeze({
+        kind: 'exact',
+        origins: new Set(origins),
+    });
+}
+function normalizeTokens(values, option, uppercase) {
+    return Object.freeze(values.map((value) => {
+        const token = value.trim();
+        if (!httpToken.test(token)) {
+            throw new TypeError(`CORS ${option}に不正なHTTP tokenが含まれています`);
+        }
+        return uppercase ? token.toUpperCase() : token;
+    }));
+}
+function normalizeMaxAge(maxAge) {
+    if (maxAge === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(maxAge) || maxAge < 0) {
+        throw new TypeError('CORS maxAgeには0以上の安全な整数を指定してください');
+    }
+    return maxAge;
+}
+function appendVary(headers, value) {
+    const current = headers.get('vary');
+    if (current === null) {
+        headers.set('vary', value);
+        return;
+    }
+    const values = current
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (!values.some((item) => item.toLowerCase() === value.toLowerCase())) {
+        values.push(value);
+    }
+    headers.set('vary', values.join(', '));
+}

package/dist/http/definitions.d.ts

@@ -0,0 +1,217 @@
+import type { ContractDefinition, ContextProvidedBeforeTerminal, HasValidationBeforeTerminal, IsValidProtocolPipeline, PipelineItem, ProtocolDescriptor, SchemaInput, SchemaOutput, ShortCircuitDeclarationsOf, ShortCircuitResultOf, StandardSchemaV1, TerminalLayerDescriptor, ValidationLayerDescriptor } from '../core/index.js';
+import type { Logger } from '../runtime/index.js';
+import { type HttpDispatchKey, type IsValidHttpPath, type PathParamNames, type RawPathParams } from './path.js';
+export type HttpParamsSchemas = Readonly<Record<string, StandardSchemaV1>>;
+export interface HttpRequestBodyDefinition<TSchema extends StandardSchemaV1 = StandardSchemaV1> {
+    readonly contentType: string;
+    readonly schema: TSchema;
+}
+export interface HttpRequestDefinition {
+    readonly params?: HttpParamsSchemas;
+    readonly query?: StandardSchemaV1;
+    readonly headers?: StandardSchemaV1;
+    readonly body?: HttpRequestBodyDefinition;
+}
+export type HttpHeaderValue = string | readonly string[];
+export type HttpHeaders = Readonly<Record<string, HttpHeaderValue | undefined>>;
+export interface HttpErrorMatcher<TError extends {
+    readonly data: unknown;
+}> {
+    is(error: unknown): error is TError;
+}
+export interface HttpErrorMapping<TError extends {
+    readonly data: unknown;
+} = {
+    readonly data: unknown;
+}, TResult = unknown> {
+    readonly kind: 'http-error-mapping';
+    readonly definition: HttpErrorMatcher<TError>;
+    readonly map: (error: TError) => TResult | Promise<TResult>;
+}
+export interface HttpResponseDefinition {
+    readonly status: number;
+    readonly description?: string;
+    readonly body: StandardSchemaV1;
+    readonly headers?: StandardSchemaV1;
+    readonly staticHeaders?: HttpHeaders;
+    readonly error?: HttpErrorMapping<any, any>;
+    readonly stream?: 'server';
+}
+export interface HttpProtocolDefinition {
+    readonly method: string;
+    readonly path: string;
+    readonly summary?: string;
+    readonly description?: string;
+    readonly tags?: readonly string[];
+    readonly deprecated?: boolean;
+    readonly request?: HttpRequestDefinition;
+    readonly responses: Readonly<Record<string, HttpResponseDefinition>>;
+    readonly pipeline: readonly PipelineItem[];
+    readonly interaction?: 'unary' | 'server-stream';
+}
+export interface HttpProtocol<TDefinition extends HttpProtocolDefinition = HttpProtocolDefinition> extends ProtocolDescriptor<'http', HttpControllerContextDefinition<TDefinition>, DeclaredHttpResults<TDefinition['responses']>, HttpDispatchKey<TDefinition['method'], TDefinition['path']>> {
+    readonly definition: TDefinition;
+    readonly interaction: TDefinition extends {
+        readonly interaction: infer TInteraction;
+    } ? TInteraction & ('unary' | 'server-stream') : 'unary';
+}
+type IsHttpPipelineCompatible<TPipeline extends readonly PipelineItem[], TResponses extends HttpProtocolDefinition['responses']> = number extends TPipeline['length'] ? false : TPipeline extends readonly [infer THead, ...infer TTail] ? IsLayerShortCircuitCompatible<ShortCircuitResultOf<THead>, TResponses> extends true ? IsShortCircuitDeclarationsCompatible<ShortCircuitDeclarationsOf<THead>, TResponses> extends true ? IsHttpPipelineCompatible<Extract<TTail, readonly PipelineItem[]>, TResponses> : false : false : true;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type IsUnknown<T> = unknown extends T ? [keyof T] extends [never] ? true : false : false;
+type ResponseBodyOutput<TResponse extends HttpResponseDefinition> = TResponse extends {
+    readonly stream: 'server';
+} ? AsyncIterable<SchemaOutput<TResponse['body']>> : SchemaOutput<TResponse['body']>;
+type ResponseHeadersOutput<TResponse extends HttpResponseDefinition> = TResponse extends {
+    readonly headers: infer THeaders extends StandardSchemaV1;
+} ? SchemaOutput<THeaders> : never;
+type DeclaredHttpResults<TResponses extends HttpProtocolDefinition['responses']> = string extends keyof TResponses ? LogicalHttpResult : {
+    [TVariant in keyof TResponses & string]: NonNullable<TResponses[TVariant]> extends infer TResponse extends HttpResponseDefinition ? LogicalHttpResult<TVariant, ResponseBodyOutput<TResponse>, ResponseHeadersOutput<TResponse>> : never;
+}[keyof TResponses & string];
+type IsResultHeadersCompatible<TResult, TResponses extends HttpProtocolDefinition['responses']> = string extends keyof TResponses ? true : TResult extends {
+    readonly variant: infer TVariant extends keyof TResponses;
+} ? TResult extends {
+    readonly headers: infer TResultHeaders;
+} ? NonNullable<TResponses[TVariant]> extends infer TResponse extends HttpResponseDefinition ? [ResponseHeadersOutput<TResponse>] extends [never] ? false : Exclude<keyof TResultHeaders, keyof NonNullable<ResponseHeadersOutput<TResponse>>> extends never ? true : false : false : true : false;
+type AreResultHeadersCompatible<TResult, TResponses extends HttpProtocolDefinition['responses']> = false extends (TResult extends unknown ? IsResultHeadersCompatible<TResult, TResponses> : never) ? false : true;
+type IsLayerShortCircuitCompatible<TResult, TResponses extends HttpProtocolDefinition['responses']> = IsAny<TResult> extends true ? true : IsUnknown<TResult> extends true ? true : [TResult] extends [never] ? true : [TResult] extends [DeclaredHttpResults<TResponses>] ? AreResultHeadersCompatible<TResult, TResponses> : false;
+type IsShortCircuitDeclarationsCompatible<TDeclarations, TResponses extends HttpProtocolDefinition['responses']> = IsAny<TDeclarations> extends true ? true : IsUnknown<TDeclarations> extends true ? true : TDeclarations extends readonly unknown[] ? number extends TDeclarations['length'] ? true : TDeclarations extends readonly [infer THead, ...infer TTail] ? IsHttpShortCircuitDeclarationCompatible<THead, TResponses> extends true ? IsShortCircuitDeclarationsCompatible<TTail, TResponses> : false : true : true;
+type IsHttpShortCircuitDeclarationCompatible<TDeclaration, TResponses extends HttpProtocolDefinition['responses']> = TDeclaration extends {
+    readonly protocol: 'http';
+    readonly variant: infer TVariant extends string;
+} ? string extends TVariant ? true : TVariant extends keyof TResponses ? NonNullable<TResponses[TVariant]> extends HttpResponseDefinition ? TDeclaration extends {
+    readonly response: {
+        readonly status: infer TStatus extends number;
+    };
+} ? NonNullable<TResponses[TVariant]>['status'] extends TStatus ? true : number extends NonNullable<TResponses[TVariant]>['status'] ? true : false : true : false : false : true;
+type HttpPipelineConstraint<TDefinition extends HttpProtocolDefinition> = IsValidProtocolPipeline<TDefinition['pipeline'], 'http'> extends true ? IsHttpPipelineCompatible<TDefinition['pipeline'], TDefinition['responses']> extends true ? unknown : {
+    readonly pipeline: never;
+} : {
+    readonly pipeline: never;
+};
+type IsResponseHeadersSchemaCompatible<TResponse> = TResponse extends HttpResponseDefinition ? TResponse extends {
+    readonly headers: infer THeaders extends StandardSchemaV1;
+} ? SchemaOutput<THeaders> extends HttpHeaders | undefined ? true : false : true : false;
+type AreResponseHeadersSchemasCompatible<TResponses extends HttpProtocolDefinition['responses']> = false extends {
+    [TVariant in keyof TResponses]: IsResponseHeadersSchemaCompatible<TResponses[TVariant]>;
+}[keyof TResponses] ? false : true;
+type HttpResponseConstraint<TDefinition extends HttpProtocolDefinition> = string extends keyof TDefinition['responses'] ? {
+    readonly responses: never;
+} : AreResponseHeadersSchemasCompatible<TDefinition['responses']> extends true ? AreErrorMappingsCompatible<TDefinition['responses']> extends true ? unknown : {
+    readonly responses: never;
+} : {
+    readonly responses: never;
+};
+type IsExactParamsSchemaMap<TPath extends string, TSchemas extends HttpParamsSchemas> = Exclude<keyof TSchemas, PathParamNames<TPath>> extends never ? Exclude<PathParamNames<TPath>, keyof TSchemas> extends never ? true : false : false;
+type DoParamsSchemasAcceptStrings<TSchemas extends HttpParamsSchemas> = false extends {
+    [TName in keyof TSchemas]: IsRawStringCompatible<SchemaInput<TSchemas[TName]>>;
+}[keyof TSchemas] ? false : true;
+type IsRawStringCompatible<TInput> = string extends TInput ? true : [Extract<TInput, string>] extends [never] ? false : true;
+type IsUnion<TValue, TCandidate = TValue> = TValue extends unknown ? [TCandidate] extends [TValue] ? false : true : never;
+type IsSingleStringLiteral<TValue extends string> = string extends TValue ? false : true extends IsUnion<TValue> ? false : true;
+type HttpPathConstraint<TDefinition extends HttpProtocolDefinition> = IsSingleStringLiteral<TDefinition['method']> extends false ? {
+    readonly method: never;
+} : IsSingleStringLiteral<TDefinition['path']> extends false ? {
+    readonly path: never;
+} : IsValidHttpPath<TDefinition['path']> extends true ? TDefinition['request'] extends {
+    readonly params: infer TSchemas extends HttpParamsSchemas;
+} ? IsExactParamsSchemaMap<TDefinition['path'], TSchemas> extends true ? DoParamsSchemasAcceptStrings<TSchemas> extends true ? unknown : {
+    readonly request: never;
+} : {
+    readonly request: never;
+} : HasValidationBeforeTerminal<TDefinition['pipeline'], 'params'> extends true ? {
+    readonly pipeline: never;
+} : unknown : {
+    readonly path: never;
+};
+type ErrorMappingResult<TResponse> = TResponse extends {
+    readonly error: infer TMapping extends HttpErrorMapping<any, any>;
+} ? Awaited<ReturnType<TMapping['map']>> : never;
+type IsErrorMappingCompatible<TResponse> = TResponse extends HttpResponseDefinition ? TResponse extends {
+    readonly error: HttpErrorMapping<any, any>;
+} ? ErrorMappingResult<TResponse> extends HttpResponseResult<ResponseBodyOutput<TResponse>, ResponseHeadersOutput<TResponse>> ? true : false : true : false;
+type AreErrorMappingsCompatible<TResponses extends HttpProtocolDefinition['responses']> = false extends {
+    [TVariant in keyof TResponses]: IsErrorMappingCompatible<TResponses[TVariant]>;
+}[keyof TResponses] ? false : true;
+declare function defineHttp<const TDefinition extends HttpProtocolDefinition>(definition: TDefinition & HttpPipelineConstraint<TDefinition> & HttpResponseConstraint<TDefinition> & HttpPathConstraint<TDefinition>): HttpProtocol<TDefinition>;
+export declare const http: typeof defineHttp & {
+    protocol: 'http';
+    controller: TerminalLayerDescriptor<"http">;
+    error: typeof httpError;
+};
+export declare const validate: Readonly<{
+    params: ValidationLayerDescriptor & {
+        readonly part: "params";
+        readonly name: "validate.params";
+    };
+    query: ValidationLayerDescriptor & {
+        readonly part: "query";
+        readonly name: "validate.query";
+    };
+    headers: ValidationLayerDescriptor & {
+        readonly part: "headers";
+        readonly name: "validate.headers";
+    };
+    body: ValidationLayerDescriptor & {
+        readonly part: "body";
+        readonly name: "validate.body";
+    };
+}>;
+type ProceduresForHttp<TContract extends ContractDefinition> = {
+    [K in keyof TContract['procedures']]: 'http' extends keyof TContract['procedures'][K]['protocols'] ? K : never;
+}[keyof TContract['procedures']] & string;
+type HttpProtocolAt<TContract extends ContractDefinition, TProcedure extends keyof TContract['procedures']> = TContract['procedures'][TProcedure]['protocols']['http' & keyof TContract['procedures'][TProcedure]['protocols']] extends infer TProtocol ? TProtocol extends {
+    readonly definition: infer TDefinition;
+} ? TDefinition extends HttpProtocolDefinition ? HttpProtocol<TDefinition> : never : never : never;
+type RequestBodySchema<TBody> = TBody extends HttpRequestBodyDefinition<infer TSchema> ? TSchema : never;
+type PartOutput<TDefinition extends HttpProtocolDefinition, TPart extends keyof HttpRequestDefinition> = TPart extends 'params' ? HasValidationBeforeTerminal<TDefinition['pipeline'], 'params'> extends true ? TDefinition['request'] extends {
+    readonly params: infer TSchemas extends HttpParamsSchemas;
+} ? ValidatedPathParams<TSchemas> : never : RawPathParams<TDefinition['path']> : HasValidationBeforeTerminal<TDefinition['pipeline'], TPart> extends false ? unknown : TDefinition['request'] extends HttpRequestDefinition ? TPart extends keyof TDefinition['request'] ? TPart extends 'body' ? SchemaOutput<RequestBodySchema<NonNullable<TDefinition['request'][TPart]>>> : NonNullable<TDefinition['request'][TPart]> extends StandardSchemaV1 ? SchemaOutput<NonNullable<TDefinition['request'][TPart]>> : unknown : unknown : unknown;
+type ValidatedPathParams<TSchemas extends HttpParamsSchemas> = Readonly<{
+    [TName in keyof TSchemas]: SchemaOutput<TSchemas[TName]>;
+}>;
+type HttpResultHeaders<THeaders> = IsAny<THeaders> extends true ? {
+    readonly headers?: HttpHeaders;
+} : IsUnknown<THeaders> extends true ? {
+    readonly headers?: HttpHeaders;
+} : [THeaders] extends [never] ? {
+    readonly headers?: never;
+} : undefined extends THeaders ? {
+    readonly headers?: Exclude<THeaders, undefined>;
+} : {
+    readonly headers: THeaders;
+};
+export type HttpResponseResult<TBody, THeaders = unknown> = {
+    readonly body: TBody;
+} & HttpResultHeaders<THeaders>;
+type ErrorOf<TDefinition> = TDefinition extends HttpErrorMatcher<infer TError> ? TError : never;
+export declare function httpError<TDefinition extends HttpErrorMatcher<{
+    readonly data: unknown;
+}>>(definition: TDefinition): HttpErrorMapping<ErrorOf<TDefinition>, {
+    readonly body: ErrorOf<TDefinition>['data'];
+}>;
+export declare function httpError<TDefinition extends HttpErrorMatcher<{
+    readonly data: unknown;
+}>, const TResult>(definition: TDefinition, map: (error: ErrorOf<TDefinition>) => TResult | Promise<TResult>): HttpErrorMapping<ErrorOf<TDefinition>, TResult>;
+export type LogicalHttpResult<TVariant extends string = string, TBody = unknown, THeaders = unknown> = {
+    readonly kind: 'http-result';
+    readonly variant: TVariant;
+    readonly body: TBody;
+} & HttpResultHeaders<THeaders>;
+type ResponseHelpers<TDefinition extends HttpProtocolDefinition> = {
+    [TVariant in keyof TDefinition['responses'] & string]: (result: HttpResponseResult<ResponseBodyOutput<TDefinition['responses'][TVariant]>, ResponseHeadersOutput<TDefinition['responses'][TVariant]>>) => LogicalHttpResult<TVariant, ResponseBodyOutput<TDefinition['responses'][TVariant]>, ResponseHeadersOutput<TDefinition['responses'][TVariant]>>;
+};
+type HttpControllerContextDefinition<TDefinition extends HttpProtocolDefinition> = {
+    readonly params: PartOutput<TDefinition, 'params'>;
+    readonly query: PartOutput<TDefinition, 'query'>;
+    readonly headers: PartOutput<TDefinition, 'headers'>;
+    readonly body: PartOutput<TDefinition, 'body'>;
+    readonly response: ResponseHelpers<TDefinition>;
+    readonly logger: Logger;
+    readonly signal: AbortSignal;
+} & ContextProvidedBeforeTerminal<TDefinition['pipeline']>;
+export type HttpControllerContext<TProtocol extends HttpProtocol<any>> = HttpControllerContextDefinition<TProtocol['definition']>;
+export type ControllerOf<TContract extends ContractDefinition, TProtocol extends 'http', TProcedures extends ProceduresForHttp<TContract> = ProceduresForHttp<TContract>> = TProtocol extends 'http' ? {
+    [K in TProcedures]: (context: HttpControllerContext<HttpProtocolAt<TContract, K>>) => DeclaredHttpResults<HttpProtocolAt<TContract, K>['definition']['responses']> | Promise<DeclaredHttpResults<HttpProtocolAt<TContract, K>['definition']['responses']>>;
+} : never;
+export type ContextOf<TController, TProcedure extends keyof TController> = TController[TProcedure] extends (context: infer TContext, ...args: any[]) => any ? TContext : never;
+export {};

package/dist/http/definitions.js

@@ -0,0 +1,65 @@
+import { childPipelineOf } from '../core/index.js';
+import { createHttpDispatchKey, parseHttpPath, } from './path.js';
+const controller = Object.freeze({
+    kind: 'terminal',
+    name: 'http.controller',
+    role: 'terminal',
+    protocol: 'http',
+});
+function defineHttp(definition) {
+    const segments = parseHttpPath(definition.path);
+    const paramsSchemas = definition.request?.params;
+    if (paramsSchemas) {
+        const pathNames = segments.flatMap((segment) => segment.kind === 'param' ? [segment.name] : []);
+        const schemaNames = Object.keys(paramsSchemas);
+        if (pathNames.length !== schemaNames.length ||
+            pathNames.some((name) => !Object.hasOwn(paramsSchemas, name))) {
+            throw new Error('HTTP path parameter names and request.params keys must match');
+        }
+    }
+    else if (hasParamsValidation(definition.pipeline)) {
+        throw new Error('validate.params requires request.params');
+    }
+    const body = definition.request?.body;
+    if (body && body.contentType.trim().length === 0) {
+        throw new Error('HTTP request body contentType must not be empty');
+    }
+    return {
+        kind: 'protocol',
+        protocol: 'http',
+        interaction: definition.interaction ?? 'unary',
+        dispatchKey: createHttpDispatchKey(definition.method, segments),
+        definition,
+    };
+}
+function hasParamsValidation(pipeline) {
+    return pipeline.some((item) => (item.kind === 'validation' && item.part === 'params') ||
+        (item.kind === 'layer' &&
+            hasParamsValidation(childPipelineOf(item) ?? [])));
+}
+export const http = Object.assign(defineHttp, {
+    protocol: 'http',
+    controller,
+    error: httpError,
+});
+function validationLayer(part) {
+    return Object.freeze({
+        kind: 'validation',
+        name: `validate.${part}`,
+        role: 'validation',
+        part,
+    });
+}
+export const validate = Object.freeze({
+    params: validationLayer('params'),
+    query: validationLayer('query'),
+    headers: validationLayer('headers'),
+    body: validationLayer('body'),
+});
+export function httpError(definition, map) {
+    return Object.freeze({
+        kind: 'http-error-mapping',
+        definition,
+        map: map ?? ((error) => ({ body: error.data })),
+    });
+}

package/dist/http/hosted-protocol.d.ts

@@ -0,0 +1,4 @@
+import { http as baseHttp } from './definitions.js';
+export declare const http: typeof baseHttp & {
+    readonly capabilities: readonly ['http'];
+};

package/dist/http/hosted-protocol.js

@@ -0,0 +1,4 @@
+import { http as baseHttp } from './definitions.js';
+export const http = Object.assign(baseHttp, {
+    capabilities: ['http'],
+});

package/dist/http/index.d.ts

@@ -0,0 +1,7 @@
+export * from './application.js';
+export * from './basic-auth.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';

package/dist/http/index.js

@@ -0,0 +1,6 @@
+export * from './application.js';
+export * from './basic-auth.js';
+export * from './definitions.js';
+export { http } from './hosted-protocol.js';
+export * from './request-body.js';
+export { validate } from './validate.js';

package/dist/http/params.d.ts

@@ -0,0 +1,2 @@
+import type { HttpParamsSchemas } from './definitions.js';
+export declare function validateHttpParamsSchemas(schemas: HttpParamsSchemas, value: Readonly<Record<string, string>>): Promise<Record<string, unknown>>;

package/dist/http/params.js

@@ -0,0 +1,19 @@
+import { SchemaValidationError, validateSchema } from '../core/index.js';
+export async function validateHttpParamsSchemas(schemas, value) {
+    const output = {};
+    for (const [name, schema] of Object.entries(schemas)) {
+        try {
+            output[name] = await validateSchema(schema, value[name]);
+        }
+        catch (error) {
+            if (error instanceof SchemaValidationError) {
+                throw new SchemaValidationError(error.issues.map((issue) => ({
+                    ...issue,
+                    path: [name, ...(issue.path ?? [])],
+                })));
+            }
+            throw error;
+        }
+    }
+    return output;
+}