@loutrejs/loutre 0.1.0 → 0.3.0

package/dist/graph/ir.d.ts

@@ -21,6 +21,7 @@ export interface DependencyNodeIR {
     readonly kind: 'class' | 'token' | 'factory' | 'conditional' | 'environment' | 'arguments' | 'implementation' | 'layer' | 'task' | 'framework';
     readonly scope?: 'application' | 'transient';
     readonly module?: string;
+    readonly visibility?: 'private' | 'exported';
 }
 export interface DependencyEdgeIR {
     readonly from: string;
@@ -57,18 +58,33 @@ export interface LayerIR {
         readonly response?: Readonly<Record<string, unknown>>;
     }[];
 }
+export type ContractId = `contract:${number}`;
+export type ImplementationId = `implementation:${number}`;
+export interface ContractProtocolIR {
+    readonly name: string;
+    readonly dispatchKey: string | null;
+    readonly interaction: string;
+}
+export interface ContractProcedureIR {
+    readonly name: string;
+    readonly protocols: readonly ContractProtocolIR[];
+}
+export interface ContractIR {
+    readonly id: ContractId;
+    readonly procedures: readonly ContractProcedureIR[];
+}
 export interface PipelineIR {
-    readonly contract: string;
+    readonly contract: ContractId;
     readonly procedure: string;
     readonly protocol: string;
     readonly layers: readonly LayerIR[];
 }
 export interface ImplementationIR {
-    readonly contract: string;
-    readonly procedure: string;
+    readonly id: ImplementationId;
+    readonly name: string;
+    readonly contract: ContractId;
     readonly protocol: string;
-    readonly implementation: string;
-    readonly method: string;
+    readonly procedures: readonly string[];
 }
 export interface CapabilityIR {
     readonly name: string;
@@ -79,9 +95,9 @@ export interface ProtocolExecutionRootIR {
     readonly id: `protocol:${string}`;
     readonly kind: 'protocol';
     readonly protocol: string;
-    readonly contract: string;
+    readonly contract: ContractId;
     readonly procedure: string;
-    readonly implementation: string;
+    readonly implementation: ImplementationId;
 }
 export interface ApplicationArgumentsIR {
     readonly name: string;
@@ -136,7 +152,7 @@ export interface ApplicationGraphIR {
     readonly providers: readonly ProviderIR[];
     readonly tokens: readonly TokenIR[];
     readonly contextKeys: readonly ContextKeyIR[];
-    readonly contracts: readonly string[];
+    readonly contracts: readonly ContractIR[];
     readonly pipelines: readonly PipelineIR[];
     readonly implementations: readonly ImplementationIR[];
     readonly tasks: readonly TaskIR[];

package/dist/http/application.js

@@ -301,7 +301,7 @@ async function finalizeResponse(definition, result, signal) {
     const responseHeaders = await validateResponseHeaders(response.headers, result.headers);
     if (response.stream === 'server') {
         if (!isAsyncIterable(result.body)) {
-            throw new Error('server-stream responseにはAsyncIterableが必要です');
+            throw new Error('Server-stream response requires an AsyncIterable');
         }
         const encoder = new TextEncoder();
         const iterator = result.body[Symbol.asyncIterator]();
@@ -315,7 +315,7 @@ async function finalizeResponse(definition, result, signal) {
                     finished = true;
                     signal.removeEventListener('abort', abort);
                     void iterator.return?.(signal.reason).finally(() => {
-                        controller.error(signal.reason ?? new Error('HTTP requestが中断されました'));
+                        controller.error(signal.reason ?? new Error('HTTP request was aborted'));
                     });
                 };
                 if (signal.aborted)
@@ -368,7 +368,7 @@ async function finalizeResponse(definition, result, signal) {
 async function validateResponseHeaders(schema, headers) {
     if (!schema) {
         if (headers !== undefined) {
-            throw new Error('未宣言のHTTP response headerが返されました');
+            throw new Error('Undeclared HTTP response header was returned');
         }
         return undefined;
     }
@@ -376,7 +376,7 @@ async function validateResponseHeaders(schema, headers) {
     if (validated === undefined)
         return undefined;
     if (!isHttpHeaders(validated)) {
-        throw new Error('HTTP response header schemaの出力が不正です');
+        throw new Error('HTTP response header schema produced an invalid value');
     }
     return validated;
 }
@@ -458,7 +458,7 @@ async function mapDeclaredError(definition, error) {
             if (typeof result !== 'object' ||
                 result === null ||
                 !('body' in result)) {
-                throw new Error('HTTP error mappingはbodyを返す必要があります');
+                throw new Error('HTTP error mapping must return a body');
             }
             return {
                 kind: 'http-result',

package/dist/http/basic-auth.js

@@ -40,7 +40,7 @@ function unauthorizedResult(unauthorized, challenge) {
 }
 function formatBasicChallenge(realm) {
     if (realm.length === 0 || /[\u0000-\u001f\u007f]/.test(realm)) {
-        throw new TypeError('Basic認証の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"`;

package/dist/http/client.d.ts

@@ -0,0 +1,72 @@
+import { type ContractDefinition, type ProcedureDefinition, type SchemaInput, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
+import type { HttpHeaders, HttpParamsSchemas, HttpProtocol, HttpProtocolDefinition, HttpRequestBodyDefinition, HttpResponseDefinition } from './definitions.js';
+import { type PathParamNames, type RawPathParams } from './path.js';
+export interface HttpClientTransportRequest {
+    readonly method: string;
+    readonly path: string;
+    readonly query?: unknown;
+    readonly headers?: unknown;
+    readonly body?: unknown;
+    readonly contentType?: string;
+}
+export interface HttpClientTransportResponse {
+    readonly status: number;
+    readonly body: unknown;
+    readonly headers?: HttpHeaders;
+}
+export type HttpClientTransport = (request: HttpClientTransportRequest) => Promise<HttpClientTransportResponse>;
+type HttpProtocolOf<TProcedure extends ProcedureDefinition> = TProcedure['protocols'] extends {
+    readonly http: infer TProtocol;
+} ? TProtocol extends HttpProtocol<infer TDefinition> ? HttpProtocol<TDefinition> : never : never;
+type HttpProcedureNames<TContract extends ContractDefinition> = {
+    [TProcedure in keyof TContract['procedures'] & string]: HttpProtocolOf<TContract['procedures'][TProcedure]> extends never ? never : TProcedure;
+}[keyof TContract['procedures'] & string];
+type HttpDefinitionOf<TContract extends ContractDefinition, TProcedure extends HttpProcedureNames<TContract>> = HttpProtocolOf<TContract['procedures'][TProcedure]>['definition'];
+type RequestBodySchema<TBody> = TBody extends HttpRequestBodyDefinition<infer TSchema> ? TSchema : never;
+type PathParamsInput<TDefinition extends HttpProtocolDefinition> = PathParamNames<TDefinition['path']> extends never ? never : TDefinition['request'] extends {
+    readonly params: infer TSchemas extends HttpParamsSchemas;
+} ? Readonly<{
+    [TName in keyof TSchemas]: SchemaInput<TSchemas[TName]>;
+}> : RawPathParams<TDefinition['path']>;
+type RequestPartInput<TDefinition extends HttpProtocolDefinition, TPart extends 'query' | 'headers'> = TDefinition['request'] extends infer TRequest ? TRequest extends Record<TPart, infer TSchema extends StandardSchemaV1> ? SchemaInput<TSchema> : never : never;
+type RequestBodyInput<TDefinition extends HttpProtocolDefinition> = TDefinition['request'] extends {
+    readonly body: infer TBody extends HttpRequestBodyDefinition;
+} ? SchemaInput<RequestBodySchema<TBody>> : never;
+type RequestField<TName extends string, TValue> = [TValue] extends [never] ? object : undefined extends TValue ? {
+    readonly [TKey in TName]?: Exclude<TValue, undefined>;
+} : {
+    readonly [TKey in TName]: TValue;
+};
+export type HttpClientRequest<TDefinition extends HttpProtocolDefinition> = RequestField<'params', PathParamsInput<TDefinition>> & RequestField<'query', RequestPartInput<TDefinition, 'query'>> & RequestField<'headers', RequestPartInput<TDefinition, 'headers'>> & RequestField<'body', RequestBodyInput<TDefinition>>;
+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> : HttpHeaders;
+export type HttpClientResponse<TDefinition extends HttpProtocolDefinition> = {
+    [TVariant in keyof TDefinition['responses'] & string]: NonNullable<TDefinition['responses'][TVariant]> extends infer TResponse extends HttpResponseDefinition ? {
+        readonly status: TResponse['status'];
+        readonly body: ResponseBodyOutput<TResponse>;
+        readonly headers: ResponseHeadersOutput<TResponse>;
+    } : never;
+}[keyof TDefinition['responses'] & string];
+type HttpClientMethod<TDefinition extends HttpProtocolDefinition> = keyof HttpClientRequest<TDefinition> extends never ? () => Promise<HttpClientResponse<TDefinition>> : (request: HttpClientRequest<TDefinition>) => Promise<HttpClientResponse<TDefinition>>;
+export type HttpClient<TContract extends ContractDefinition> = {
+    readonly [TProcedure in HttpProcedureNames<TContract>]: HttpClientMethod<HttpDefinitionOf<TContract, TProcedure>>;
+};
+export declare class HttpClientResponseError extends Error {
+    readonly status: number;
+    readonly method: string;
+    readonly path: string;
+    readonly procedure: string;
+    constructor(status: number, method: string, path: string, procedure: string, message: string, options?: ErrorOptions);
+}
+export declare function createHttpClient<const TContract extends ContractDefinition>(contract: TContract, transport: HttpClientTransport): HttpClient<TContract>;
+export interface FetchHttpTransportOptions {
+    readonly baseUrl: string | URL;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly headers?: HeadersInit;
+}
+export declare function fetchHttpTransport(options: FetchHttpTransportOptions): HttpClientTransport;
+export {};

package/dist/http/client.js

@@ -0,0 +1,258 @@
+import { SchemaValidationError, validateSchema, } from '../core/index.js';
+import { parseHttpPath, } from './path.js';
+export class HttpClientResponseError extends Error {
+    status;
+    method;
+    path;
+    procedure;
+    constructor(status, method, path, procedure, message, options) {
+        super(message, options);
+        this.status = status;
+        this.method = method;
+        this.path = path;
+        this.procedure = procedure;
+        this.name = 'HttpClientResponseError';
+    }
+}
+export function createHttpClient(contract, transport) {
+    const client = {};
+    for (const [procedureName, procedure] of Object.entries(contract.procedures)) {
+        const definition = httpDefinitionOf(procedure);
+        if (!definition)
+            continue;
+        client[procedureName] = async (request = {}) => {
+            const response = await transport({
+                method: definition.method,
+                path: interpolatePath(definition.path, request.params),
+                ...(request.query === undefined ? {} : { query: request.query }),
+                ...(request.headers === undefined ? {} : { headers: request.headers }),
+                ...(request.body === undefined ? {} : { body: request.body }),
+                ...(definition.request?.body === undefined
+                    ? {}
+                    : { contentType: definition.request.body.contentType }),
+            });
+            return decodeResponse(procedureName, definition, response);
+        };
+    }
+    return Object.freeze(client);
+}
+function httpDefinitionOf(procedure) {
+    const protocol = procedure.protocols.http;
+    if (!protocol ||
+        protocol.protocol !== 'http' ||
+        !('definition' in protocol)) {
+        return undefined;
+    }
+    return protocol.definition;
+}
+function interpolatePath(path, params) {
+    const segments = parseHttpPath(path);
+    if (segments.length === 0)
+        return '/';
+    return `/${segments
+        .map((segment) => {
+        if (segment.kind === 'static')
+            return segment.value;
+        const value = params?.[segment.name];
+        if (value === undefined) {
+            throw new Error(`Missing HTTP path parameter: ${segment.name}`);
+        }
+        return encodeURIComponent(String(value));
+    })
+        .join('/')}`;
+}
+async function decodeResponse(procedure, definition, response) {
+    const target = describeHttpTarget(definition, procedure);
+    const candidates = Object.values(definition.responses).filter((candidate) => candidate.status === response.status);
+    if (candidates.length === 0) {
+        throw new HttpClientResponseError(response.status, definition.method, definition.path, procedure, `${target} returned undeclared HTTP status ${response.status}`);
+    }
+    let lastValidationError;
+    for (const candidate of candidates) {
+        try {
+            const body = candidate.stream
+                ? validatedResponseStream(candidate.body, response.body, procedure, definition, response.status)
+                : await validateSchema(candidate.body, response.body);
+            const headers = candidate.headers
+                ? await validateSchema(candidate.headers, response.headers ?? {})
+                : (response.headers ?? {});
+            return Object.freeze({ status: response.status, body, headers });
+        }
+        catch (error) {
+            if (!(error instanceof SchemaValidationError))
+                throw error;
+            lastValidationError = error;
+        }
+    }
+    throw new HttpClientResponseError(response.status, definition.method, definition.path, procedure, `${target} returned a response that does not match its Contract`, lastValidationError ? { cause: lastValidationError } : undefined);
+}
+function validatedResponseStream(schema, value, procedure, definition, status) {
+    const target = describeHttpTarget(definition, procedure);
+    if (!isAsyncIterable(value)) {
+        throw new HttpClientResponseError(status, definition.method, definition.path, procedure, `${target} returned a non-stream body for a server-stream response`);
+    }
+    return {
+        async *[Symbol.asyncIterator]() {
+            try {
+                for await (const item of value)
+                    yield await validateSchema(schema, item);
+            }
+            catch (error) {
+                throw new HttpClientResponseError(status, definition.method, definition.path, procedure, `${target} returned an invalid server-stream item`, { cause: error });
+            }
+        },
+    };
+}
+function describeHttpTarget(definition, procedure) {
+    return `${definition.method.toUpperCase()} ${definition.path} (${procedure})`;
+}
+function isAsyncIterable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}
+export function fetchHttpTransport(options) {
+    const fetchImplementation = options.fetch ?? globalThis.fetch;
+    return async (request) => {
+        const url = new URL(request.path, options.baseUrl);
+        appendQuery(url.searchParams, request.query);
+        const headers = new Headers(options.headers);
+        appendHeaders(headers, request.headers);
+        if (request.contentType && !headers.has('content-type')) {
+            headers.set('content-type', request.contentType);
+        }
+        const response = await fetchImplementation(url, {
+            method: request.method,
+            headers,
+            ...(request.body === undefined
+                ? {}
+                : { body: encodeBody(request.body, request.contentType) }),
+        });
+        return {
+            status: response.status,
+            body: await decodeFetchBody(response),
+            headers: Object.fromEntries(response.headers.entries()),
+        };
+    };
+}
+function appendQuery(searchParams, query) {
+    if (query === undefined || query === null)
+        return;
+    if (query instanceof URLSearchParams) {
+        for (const [key, value] of query)
+            searchParams.append(key, value);
+        return;
+    }
+    if (typeof query !== 'object') {
+        throw new TypeError('HTTP client query must be an object or URLSearchParams');
+    }
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                searchParams.append(key, String(item));
+        }
+        else {
+            searchParams.append(key, String(value));
+        }
+    }
+}
+function appendHeaders(headers, value) {
+    if (value === undefined || value === null)
+        return;
+    if (value instanceof Headers) {
+        for (const [name, header] of value)
+            headers.set(name, header);
+        return;
+    }
+    if (typeof value !== 'object') {
+        throw new TypeError('HTTP client headers must be an object or Headers');
+    }
+    for (const [name, header] of Object.entries(value)) {
+        if (header === undefined)
+            continue;
+        if (Array.isArray(header)) {
+            headers.set(name, header.map(String).join(', '));
+        }
+        else {
+            headers.set(name, String(header));
+        }
+    }
+}
+function encodeBody(body, contentType) {
+    const mediaType = normalizeMediaType(contentType);
+    if (mediaType === 'application/json' || mediaType?.endsWith('+json')) {
+        return JSON.stringify(body);
+    }
+    return body;
+}
+async function decodeFetchBody(response) {
+    if (response.status === 204 || response.status === 205)
+        return undefined;
+    const mediaType = normalizeMediaType(response.headers.get('content-type'));
+    if (mediaType === 'text/event-stream') {
+        if (!response.body) {
+            throw new Error('Server-stream HTTP response has no body');
+        }
+        return decodeServerSentEvents(response.body);
+    }
+    if (mediaType === 'application/json' || mediaType?.endsWith('+json')) {
+        return response.json();
+    }
+    return response.text();
+}
+function normalizeMediaType(value) {
+    const mediaType = value?.split(';', 1)[0]?.trim().toLowerCase();
+    return mediaType || undefined;
+}
+async function* decodeServerSentEvents(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let completed = false;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                completed = true;
+                buffer += decoder.decode();
+                break;
+            }
+            buffer += decoder.decode(next.value, { stream: true });
+            buffer = normalizeEventStreamNewlines(buffer);
+            let boundary = buffer.indexOf('\n\n');
+            while (boundary >= 0) {
+                const event = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const data = event
+                    .split('\n')
+                    .filter((line) => line.startsWith('data:'))
+                    .map((line) => line.slice('data:'.length).trimStart())
+                    .join('\n');
+                if (data.length > 0)
+                    yield JSON.parse(data);
+                boundary = buffer.indexOf('\n\n');
+            }
+        }
+        buffer = normalizeEventStreamNewlines(buffer).trim();
+        if (buffer.length > 0) {
+            const data = buffer
+                .split('\n')
+                .filter((line) => line.startsWith('data:'))
+                .map((line) => line.slice('data:'.length).trimStart())
+                .join('\n');
+            if (data.length > 0)
+                yield JSON.parse(data);
+        }
+    }
+    finally {
+        if (!completed)
+            await reader.cancel();
+        reader.releaseLock();
+    }
+}
+function normalizeEventStreamNewlines(value) {
+    return value.replaceAll('\r\n', '\n').replaceAll('\r', '\n');
+}

package/dist/http/cors.js

@@ -123,12 +123,12 @@ function normalizeOrigin(origin, credentials) {
     }
     for (const value of origins) {
         if (value.length === 0 || /[\u0000-\u001f\u007f]/.test(value)) {
-            throw new TypeError('CORS originには空文字列または制御文字を使用できません');
+            throw new TypeError('CORS origin cannot be empty or contain control characters');
         }
     }
     if (origins.includes('*')) {
         if (credentials) {
-            throw new TypeError('credentialsを有効にする場合、CORS originにワイルドカードは使用できません');
+            throw new TypeError('CORS origin cannot be a wildcard when credentials are enabled');
         }
         return Object.freeze({ kind: 'wildcard' });
     }
@@ -141,7 +141,7 @@ 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が含まれています`);
+            throw new TypeError(`CORS ${option} contains an invalid HTTP token`);
         }
         return uppercase ? token.toUpperCase() : token;
     }));
@@ -150,7 +150,7 @@ function normalizeMaxAge(maxAge) {
     if (maxAge === undefined)
         return undefined;
     if (!Number.isSafeInteger(maxAge) || maxAge < 0) {
-        throw new TypeError('CORS maxAgeには0以上の安全な整数を指定してください');
+        throw new TypeError('CORS maxAge must be a non-negative safe integer');
     }
     return maxAge;
 }

package/dist/http/definitions.d.ts

@@ -1,4 +1,4 @@
-import type { ContractDefinition, ContextProvidedBeforeTerminal, HasValidationBeforeTerminal, IsValidProtocolPipeline, PipelineItem, ProtocolDescriptor, SchemaInput, SchemaOutput, ShortCircuitDeclarationsOf, ShortCircuitResultOf, StandardSchemaV1, TerminalLayerDescriptor, ValidationLayerDescriptor } from '../core/index.js';
+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>>;
@@ -133,11 +133,19 @@ type AreErrorMappingsCompatible<TResponses extends HttpProtocolDefinition['respo
     [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;
+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";

package/dist/http/definitions.js

@@ -1,4 +1,4 @@
-import { childPipelineOf } from '../core/index.js';
+import { childPipelineOf, protocolGroup } from '../core/index.js';
 import { createHttpDispatchKey, parseHttpPath, } from './path.js';
 const controller = Object.freeze({
     kind: 'terminal',
@@ -37,8 +37,12 @@ function hasParamsValidation(pipeline) {
         (item.kind === 'layer' &&
             hasParamsValidation(childPipelineOf(item) ?? [])));
 }
-export const http = Object.assign(defineHttp, {
+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,
 });

package/dist/http/index.d.ts

@@ -1,5 +1,6 @@
 export * from './application.js';
 export * from './basic-auth.js';
+export * from './client.js';
 export type { CorsLayerDescriptor, CorsOptions, CorsOrigin } from './cors.js';
 export * from './definitions.js';
 export { http } from './hosted-protocol.js';

package/dist/http/index.js

@@ -1,5 +1,6 @@
 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';

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

@@ -1,4 +1,4 @@
-import { type ContextProvidedBeforeTerminal, type IsValidProtocolPipeline, type ContractDefinition, type PipelineItem, type ProtocolDescriptor, type SchemaOutput, type StandardSchemaV1, type TerminalLayerDescriptor } from '../core/index.js';
+import { type ContextProvidedBeforeTerminal, type IsValidProtocolPipeline, type ContractDefinition, type PipelineItem, type ProtocolDescriptor, type ProtocolFactory, type ProtocolGroup, type SchemaOutput, type StandardSchemaV1, type TerminalLayerDescriptor } from '../core/index.js';
 import type { ApplicationGraphIR } from '../graph/index.js';
 import { ApplicationRuntime, Logger } from '../runtime/index.js';
 export interface MessagePortResponseDefinition {
@@ -17,10 +17,18 @@ declare function defineMessagePort<const TDefinition extends MessagePortProtocol
 type MessagePortPipelineConstraint<TDefinition extends MessagePortProtocolDefinition> = IsValidProtocolPipeline<TDefinition['pipeline'], 'messagePort'> extends true ? unknown : {
     readonly pipeline: never;
 };
-export declare const messagePort: typeof defineMessagePort & {
-    protocol: 'messagePort';
-    handler: TerminalLayerDescriptor<"messagePort">;
+type MessagePortProtocolGroup<TDefinitions extends Record<string, MessagePortProtocolDefinition>> = ProtocolGroup<'messagePort', {
+    [K in keyof TDefinitions]: MessagePortProtocol<TDefinitions[K]>;
+}>;
+type MessagePortDefinitionsConstraint<TDefinitions extends Record<string, MessagePortProtocolDefinition>> = {
+    [K in keyof TDefinitions]: TDefinitions[K] & MessagePortPipelineConstraint<TDefinitions[K]>;
 };
+export interface MessagePortProtocolFactory extends ProtocolFactory<'messagePort'> {
+    <const TDefinitions extends Record<string, MessagePortProtocolDefinition>>(definitions: TDefinitions & MessagePortDefinitionsConstraint<TDefinitions>): MessagePortProtocolGroup<TDefinitions>;
+    readonly route: typeof defineMessagePort;
+    readonly handler: TerminalLayerDescriptor<'messagePort'>;
+}
+export declare const messagePort: MessagePortProtocolFactory;
 export interface LogicalMessagePortResult<TVariant extends string = string, TValue = unknown> {
     readonly kind: 'message-port-result';
     readonly variant: TVariant;

package/dist/message-port/index.js

@@ -1,4 +1,4 @@
-import { validateSchema, } from '../core/index.js';
+import { validateSchema, protocolGroup, } from '../core/index.js';
 import { executePipeline, Logger, normalizeUnknownError, } from '../runtime/index.js';
 const handler = Object.freeze({
     kind: 'terminal',
@@ -15,8 +15,15 @@ function defineMessagePort(definition) {
         definition,
     };
 }
-export const messagePort = Object.assign(defineMessagePort, {
+function defineMessagePortGroup(definitions) {
+    return protocolGroup('messagePort', Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+        name,
+        defineMessagePort(definition),
+    ])));
+}
+export const messagePort = Object.assign(defineMessagePortGroup, {
     protocol: 'messagePort',
+    route: defineMessagePort,
     handler,
 });
 export function createMessagePortExecution(options) {
@@ -41,7 +48,7 @@ export function createMessagePortExecution(options) {
                 return await runtime.execute(async () => {
                     const route = routes.find((candidate) => candidate.procedure === procedure);
                     if (!route)
-                        throw new Error(`MessagePort procedureがありません: ${procedure}`);
+                        throw new Error(`MessagePort procedure not found: ${procedure}`);
                     invocationLogger = invocationLogger.child({
                         source: `${route.implementation.name}.${route.procedure}`,
                     });
@@ -66,7 +73,7 @@ export function createMessagePortExecution(options) {
                             const target = runtime.container.implementationRuntime(route.implementation);
                             const method = target[route.procedure];
                             if (typeof method !== 'function')
-                                throw new Error('Handler methodがありません');
+                                throw new Error('Handler method is missing');
                             return Reflect.apply(method, target, [
                                 terminalContext,
                             ]);
@@ -106,10 +113,10 @@ export function createMessagePortExecution(options) {
 async function finalize(definition, result) {
     const response = definition.responses[result.variant];
     if (!response)
-        throw new Error(`未宣言variantです: ${result.variant}`);
+        throw new Error(`Undeclared variant: ${result.variant}`);
     if (response.stream === 'server') {
         if (!isAsyncIterable(result.value)) {
-            throw new Error('server-stream resultにはAsyncIterableが必要です');
+            throw new Error('Server-stream result requires an AsyncIterable');
         }
         const source = result.value;
         return {