@loutrejs/loutre 0.4.1 → 0.6.0

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

@@ -1,37 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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 authentication realm cannot be empty or contain control characters');
-    }
-    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/definitions.d.ts

@@ -1,225 +0,0 @@
-import type { ContractDefinition, ContextProvidedBeforeTerminal, HasValidationBeforeTerminal, IsValidProtocolPipeline, PipelineItem, ProtocolDescriptor, ProtocolFactory, ProtocolGroup, 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>;
-type HttpProtocolGroup<TDefinitions extends Record<string, HttpProtocolDefinition>> = ProtocolGroup<'http', {
-    [K in keyof TDefinitions]: HttpProtocol<TDefinitions[K]>;
-}>;
-type HttpDefinitionsConstraint<TDefinitions extends Record<string, HttpProtocolDefinition>> = {
-    [K in keyof TDefinitions]: TDefinitions[K] & HttpPipelineConstraint<TDefinitions[K]> & HttpResponseConstraint<TDefinitions[K]> & HttpPathConstraint<TDefinitions[K]>;
-};
-export interface HttpProtocolFactory extends ProtocolFactory<'http'> {
-    <const TDefinitions extends Record<string, HttpProtocolDefinition>>(definitions: TDefinitions & HttpDefinitionsConstraint<TDefinitions>): HttpProtocolGroup<TDefinitions>;
-    readonly route: typeof defineHttp;
-    readonly controller: TerminalLayerDescriptor<'http'>;
-    readonly error: typeof httpError;
-}
-export declare const http: HttpProtocolFactory;
-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

@@ -1,69 +0,0 @@
-import { childPipelineOf, protocolGroup } 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) ?? [])));
-}
-function defineHttpGroup(definitions) {
-    return protocolGroup('http', Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, defineHttp(definition)])));
-}
-export const http = Object.assign(defineHttpGroup, {
-    protocol: 'http',
-    route: defineHttp,
-    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

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

package/dist/http/hosted-protocol.js

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

package/dist/http/params.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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;
-}

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

@@ -1,4 +0,0 @@
-import type { StandardSchemaV1 } from '../core/index.js';
-import type { HttpRequestBodyDefinition } from './definitions.js';
-export declare function httpRequestBodySchema(body: HttpRequestBodyDefinition): StandardSchemaV1;
-export declare function httpRequestBodyContentType(body: HttpRequestBodyDefinition): string;

package/dist/http/request-body.js

@@ -1,6 +0,0 @@
-export function httpRequestBodySchema(body) {
-    return body.schema;
-}
-export function httpRequestBodyContentType(body) {
-    return body.contentType;
-}

package/dist/http/validate.d.ts

@@ -1,20 +0,0 @@
-import { cors } from './cors.js';
-export declare const validate: Readonly<{
-    params: import("../index.js").ValidationLayerDescriptor & {
-        readonly part: "params";
-        readonly name: "validate.params";
-    };
-    query: import("../index.js").ValidationLayerDescriptor & {
-        readonly part: "query";
-        readonly name: "validate.query";
-    };
-    headers: import("../index.js").ValidationLayerDescriptor & {
-        readonly part: "headers";
-        readonly name: "validate.headers";
-    };
-    body: import("../index.js").ValidationLayerDescriptor & {
-        readonly part: "body";
-        readonly name: "validate.body";
-    };
-    cors: typeof cors;
-}>;

package/dist/http/validate.js

@@ -1,6 +0,0 @@
-import { cors } from './cors.js';
-import { validate as inputValidation } from './definitions.js';
-export const validate = Object.freeze({
-    ...inputValidation,
-    cors,
-});

package/dist/message-port/environment.d.ts

@@ -1,2 +0,0 @@
-import type { MessagePortProtocolExecution } from './index.js';
-export declare function initializeMessagePortExecution(application: MessagePortProtocolExecution, environmentSource: unknown): Promise<void>;

package/dist/message-port/environment.js

@@ -1,4 +0,0 @@
-import { initializeWithEnvironment } from '../runtime/index.js';
-export function initializeMessagePortExecution(application, environmentSource) {
-    return initializeWithEnvironment(application, environmentSource);
-}

package/dist/runtime/application.d.ts

@@ -1,38 +0,0 @@
-import { type ArgsClass, type EnvClass, type ModuleInstance, type ModuleTemplate, type TaskArguments, type TaskDescriptor, type TaskOutput, type TokenLike } from '../core/index.js';
-import { Container, type RuntimeModuleGraph } from './di.js';
-import { Logger } from './logger.js';
-export interface ApplicationRuntimeOptions {
-    readonly logger?: Logger;
-    readonly environmentSource?: unknown;
-    readonly arguments?: ArgsClass;
-    readonly argumentsSource?: unknown;
-    readonly tasks?: readonly TaskDescriptor<any, any>[];
-    readonly publicTasks?: readonly TaskDescriptor<any, any>[];
-}
-export interface InitializableApplication {
-    initialize(): Promise<void>;
-}
-export declare function initializeWithEnvironment(application: InitializableApplication, environmentSource: unknown): Promise<void>;
-export declare class EnvironmentBindingError extends Error {
-    readonly code = "LUTRE_ENV_003";
-    constructor(environment: EnvClass, cause: unknown);
-}
-export declare class ArgumentsBindingError extends Error {
-    readonly code = "LUTRE_ARGS_003";
-    constructor(argumentsContract: ArgsClass, cause: unknown);
-}
-export declare class ApplicationRuntime {
-    #private;
-    readonly graph: RuntimeModuleGraph;
-    readonly container: Container;
-    constructor(roots: readonly (ModuleInstance | ModuleTemplate<void>)[], options?: ApplicationRuntimeOptions);
-    initialize(): Promise<void>;
-    get<T>(token: TokenLike<T>): T;
-    run<TTask extends TaskDescriptor<any, any>>(task: TTask, ...args: TaskArguments<TTask>): Promise<TaskOutput<TTask>>;
-    /** public run()ではTrigger専用Taskを拒否するため、Trigger Host専用経路を分ける。 */
-    runTask<TTask extends TaskDescriptor<any, any>>(task: TTask, ...args: TaskArguments<TTask>): Promise<TaskOutput<TTask>>;
-    execute<T>(execution: () => T | Promise<T>): Promise<T>;
-    stopAcceptingExecutions(): void;
-    shutdown(signal?: string): Promise<void>;
-}
-export declare function createApplicationRuntime(roots: readonly (ModuleInstance | ModuleTemplate<void>)[], options?: ApplicationRuntimeOptions): ApplicationRuntime;