@loutrejs/loutre 0.9.2 → 0.10.1

package/dist/http/extension.js

@@ -1,3 +1,7 @@
+import { dependencyConsumerId } from '../core/identity.js';
+import { epochNow, expiresAt, epochMilliseconds, } from '../core/units.js';
+import { normalizeHttpMethod, requestPathname, httpProcedureName, } from './identity.js';
+import { syntheticExecutionId } from '../core/identity.js';
 import { collectInjectedDependencies, getSourceLocation, inheritSourceLocation, composeLayers, defineExecution, defineExecutionExtension, defineLayer, runInInjectionContext, runtimeCapability, SchemaValidationError, validateSchema, } from '../core/index.js';
 import { createCorsActualResponseHeaders, createCorsPreflightResponseHeaders, } from './cors-internal.js';
 import { assertValidHttpMethod, compareHttpPathSpecificity, createHttpDispatchKey, HttpPathDecodeError, matchHttpPath, parseHttpPath, } from './path.js';
@@ -6,8 +10,15 @@ import { IngressGate } from '../runtime/ingress-gate.js';
 import { AsyncIteratorCleanupDeadlineError, AsyncIteratorLifecycle, } from '../runtime/async-iterator-lifecycle.js';
 import { decodeBody, decodeQuery, HttpInputDecodeError, HttpInputValidationError, HttpUnsupportedMediaTypeError, validatedContentType, validateRequestHeaders, } from './runtime/request.js';
 import { applyFrameworkHeadersToResponse, applyFrameworkResponseHeaders, applyResponseHeaders, isResponseHeadersWithDefaults, isStandardSchema, mergeResponseHeaders, responseHeadersDefaults, responseHeadersSchema, validateResponseHeaders, } from './runtime/response.js';
+import { isWebSocketUpgrade } from './websocket-upgrade.js';
 import { match as patternMatch } from 'ts-pattern';
 export const HTTP_SERVER = runtimeCapability('http.server');
+const httpContractRawRouteBrand = Symbol.for('loutre.http-contract-raw-route');
+export function isHttpRawContractRoute(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[httpContractRawRouteBrand] === true);
+}
 const httpContractBrand = Symbol.for('loutre.http-contract');
 export function isHttpContract(value) {
     if (typeof value !== 'object' || value === null)
@@ -29,18 +40,22 @@ export const httpExecutionExtension = defineExecutionExtension({
         const raw = 'route' in definition;
         const routes = raw
             ? [compileRawRoute(definition.route)]
-            : Object.entries(definition.contract.routes).map(([name, route]) => compileHttpRoute(name, route, getSourceLocation(definition.contract)));
+            : Object.entries(definition.contract.routes).flatMap(([name, route]) => route.raw === true
+                ? []
+                : [
+                    compileHttpRoute(name, route, getSourceLocation(definition.contract)),
+                ]);
         const id = definition.name || `${context.moduleId}.http.${context.definitionIndex}`;
         const dependencies = new Set(collectInjectedDependencies({
             kind: 'execution',
-            id: `http:${id}`,
+            id: dependencyConsumerId(`http:${id}`),
             name: id,
         }, () => definition.factory()));
         routes.forEach((route) => {
             route.middlewares.forEach((middleware, index) => {
                 for (const dependency of collectInjectedDependencies({
                     kind: 'layer',
-                    id: `http:${id}:${route.name}:${index}`,
+                    id: dependencyConsumerId(`http:${id}:${route.name}:${index}`),
                     name: middleware.name,
                 }, () => middleware.factory())) {
                     dependencies.add(dependency);
@@ -123,7 +138,9 @@ export function defineHttpContract(routes) {
     const resolvedRoutes = resolveHttpContractRoutes(routes);
     const canonicalRoutes = Object.fromEntries(Object.entries(resolvedRoutes).map(([name, route]) => [
         name,
-        compileHttpRoute(name, route).definition,
+        route.raw === true
+            ? snapshotHttpContractRawRoute(route)
+            : compileHttpRoute(name, route).definition,
     ]));
     return Object.freeze({
         kind: 'http-contract',
@@ -142,7 +159,28 @@ function resolveHttpContractRoutes(tree) {
                 if (resolved[name]) {
                     throw new TypeError(`Duplicate nested HTTP route name: ${name}`);
                 }
-                assertNoInheritedResponseCollision(name, inheritedResponses, node.responses);
+                if (node.raw === true) {
+                    if (node.responses !== undefined ||
+                        node.request !== undefined ||
+                        Object.keys(inheritedResponses).length > 0)
+                        throw new TypeError('Raw routes cannot declare or inherit HTTP request schemas or responses.');
+                    resolved[name] = inheritSourceLocation({
+                        ...node,
+                        path: joinHttpPath(pathPrefix, node.path),
+                        ...(inheritedMiddlewares.length === 0 && !node.middlewares
+                            ? {}
+                            : {
+                                middlewares: [
+                                    ...inheritedMiddlewares,
+                                    ...(node.middlewares ?? []),
+                                ],
+                            }),
+                    }, node);
+                    continue;
+                }
+                else {
+                    assertNoInheritedResponseCollision(name, inheritedResponses, node.responses);
+                }
                 resolved[name] = inheritSourceLocation({
                     ...node,
                     path: joinHttpPath(pathPrefix, node.path),
@@ -208,6 +246,7 @@ export const validate = Object.freeze({
     body: bodyValidation,
 });
 export const executionHttp = Object.freeze({
+    isWebSocketUpgrade,
     raw: defineHttpRaw,
     contract: defineHttpContract,
     implementation: defineHttpImplementation,
@@ -226,40 +265,55 @@ export function withHttpFrameworkHeaders(result, headers) {
         [httpFrameworkHeaders]: { ...current, ...headers },
     };
 }
+function snapshotHttpContractRawRoute(route) {
+    if (route.method !== '*')
+        assertValidHttpMethod(route.method);
+    parseHttpPath(route.path);
+    return inheritSourceLocation(Object.freeze({
+        ...route,
+        method: route.method.toUpperCase(),
+        [httpContractRawRouteBrand]: true,
+        ...(route.middlewares === undefined
+            ? {}
+            : { middlewares: Object.freeze([...route.middlewares]) }),
+    }), route);
+}
 function compileRawRoute(route) {
     if (route.method !== '*')
         assertValidHttpMethod(route.method);
     const segments = parseHttpPath(route.path);
+    const source = getSourceLocation(route);
     return Object.freeze({
-        name: 'raw',
-        method: route.method.toUpperCase(),
+        name: httpProcedureName('raw'),
+        method: route.method === '*' ? '*' : normalizeHttpMethod(route.method),
         path: route.path,
         segments,
-        dispatch: createHttpDispatchKey(route.method, segments),
+        dispatch: createHttpDispatchKey(normalizeHttpMethod(route.method), segments),
         definition: Object.freeze({
             method: route.method,
             path: route.path,
             responses: Object.freeze({}),
         }),
         middlewares: Object.freeze([...(route.middlewares ?? [])]),
+        ...(source === undefined ? {} : { source }),
         raw: true,
         ...(route.protocol === undefined ? {} : { protocol: route.protocol }),
     });
 }
 function compileHttpRoute(name, route, routeSourceFallback) {
     if (route.method === '*')
-        throw new TypeError('method: *はhttp.raw()でのみ利用できます。');
+        throw new TypeError('The wildcard method (*) is only supported by http.raw().');
     assertValidHttpMethod(route.method);
     const segments = parseHttpPath(route.path);
     assertValidHttpRouteDefinition(route, segments);
     const definition = snapshotHttpRouteDefinition(route);
     const routeSource = getSourceLocation(route) ?? routeSourceFallback;
     return Object.freeze({
-        name,
-        method: route.method.toUpperCase(),
+        name: httpProcedureName(name),
+        method: route.method === '*' ? '*' : normalizeHttpMethod(route.method),
         path: route.path,
         segments,
-        dispatch: createHttpDispatchKey(route.method, segments),
+        dispatch: createHttpDispatchKey(normalizeHttpMethod(route.method), segments),
         definition,
         middlewares: compileHttpMiddlewares(definition),
         ...(routeSource === undefined ? {} : { source: routeSource }),
@@ -278,6 +332,7 @@ function snapshotHttpRouteDefinition(route) {
         name,
         Object.freeze({
             ...response,
+            status: response.status,
             ...(response.headers === undefined
                 ? {}
                 : { headers: snapshotHttpResponseHeaders(response.headers) }),
@@ -411,7 +466,7 @@ function createHttpExtensionRuntime(bindings, applicationRuntime) {
         handlers.set(execution.id, runInInjectionContext({
             consumer: {
                 kind: 'execution',
-                id: `http:${execution.id}`,
+                id: dependencyConsumerId(`http:${execution.id}`),
                 name: execution.id,
             },
             resolve: (token, consumer) => resolve(token, { consumer }),
@@ -427,7 +482,7 @@ function createHttpExtensionRuntime(bindings, applicationRuntime) {
     return {
         async drain({ timeoutMs }) {
             ingress.stopAccepting();
-            const deadline = Date.now() + timeoutMs;
+            const deadline = expiresAt(epochNow(), timeoutMs);
             await ingress.waitForIdle();
             const reason = new Error('LUTRE_HTTP_SERVER_STREAM_DRAIN: Application is shutting down.');
             const results = await Promise.allSettled([...activeResponseStreams].map((stream) => stream.abort(reason, deadline)));
@@ -440,6 +495,13 @@ function createHttpExtensionRuntime(bindings, applicationRuntime) {
             if (!ingress.isAccepting) {
                 return Response.json({ error: 'Service Unavailable' }, { status: 503 });
             }
+            if (request.headers.has('upgrade') ||
+                request.headers
+                    .get('connection')
+                    ?.split(',')
+                    .some((value) => value.trim().toLowerCase() === 'upgrade')) {
+                return new Response('Upgrade requests must use the WebSocket entry point.', { status: 400 });
+            }
             const url = new URL(request.url);
             const method = request.method.toUpperCase();
             if (isCorsPreflightRequest(request)) {
@@ -504,7 +566,7 @@ function createHttpExtensionRuntime(bindings, applicationRuntime) {
                 let lease;
                 try {
                     lease = applicationRuntime.beginExecution({
-                        executionId: 'http.not-found',
+                        executionId: syntheticExecutionId('http.not-found'),
                         executionKind: 'http.request',
                         name: `${method} ${url.pathname}`,
                     });
@@ -674,7 +736,7 @@ function createHttpExtensionRuntime(bindings, applicationRuntime) {
                     return complete(result);
                 }
                 if (match.route.raw)
-                    throw new TypeError('Raw handlerとmiddlewareはResponseを返す必要があります。');
+                    throw new TypeError('Raw handlers and middleware must return a Response.');
                 const finalized = await finalizeHttpResult(match.route.definition, result, lease.signal, finishExecution);
                 if (finalized.streamControl)
                     adoptResponseStream(finalized.streamControl);
@@ -715,7 +777,7 @@ function findRuntimeHttpRoute(routes, method, pathname) {
     for (const candidate of routes) {
         if (candidate.route.method !== method && candidate.route.method !== '*')
             continue;
-        const params = matchHttpPath(candidate.route.segments, pathname);
+        const params = matchHttpPath(candidate.route.segments, requestPathname(pathname));
         if (!params)
             continue;
         return { ...candidate, params };
@@ -770,10 +832,14 @@ function createHttpResponseHelpers(responses) {
         }),
     ]));
 }
+function isHttpInputRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 async function replayHttpHandler(applicationRuntime, handler, match, input, state) {
-    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+    if (!isHttpInputRecord(input) || !isHttpInputRecord(input.params)) {
         throw new TypeError('LUTRE_DEVTOOLS_HTTP_HANDLER_INPUT_REQUIRED');
     }
+    const params = input.params;
     const lease = applicationRuntime.beginExecution({
         executionId: match.executionId,
         executionKind: 'http.handler',
@@ -781,7 +847,12 @@ async function replayHttpHandler(applicationRuntime, handler, match, input, stat
         name: `${match.executionId}.${match.route.name}`,
     });
     const invoke = () => handler({
-        input,
+        input: {
+            params,
+            query: input.query,
+            headers: input.headers,
+            body: input.body,
+        },
         response: createHttpResponseHelpers(match.route.definition.responses),
         signal: lease.signal,
         state,
@@ -1016,7 +1087,7 @@ function createServerSentEventStream(source, schema, signal, completeExecution)
     const stop = (reason, errorStream, deadline) => {
         if (cleanupAttempt) {
             if (deadline !== undefined) {
-                cleanupDeadline = Math.min(cleanupDeadline ?? deadline, deadline);
+                cleanupDeadline = epochMilliseconds(Math.min(cleanupDeadline ?? deadline, deadline));
             }
             return cleanupAttempt;
         }

package/dist/http/identity.d.ts

@@ -0,0 +1,20 @@
+import type { Brand } from '../internal/brand.js';
+export type HttpPathTemplate = Brand<string, 'http.path-template'>;
+export type HttpNormalizedPath = Brand<string, 'http.normalized-path'>;
+export type RequestPathname = Brand<string, 'http.request-pathname'>;
+export type HttpMethod = Brand<string, 'http.method'>;
+export type HttpDispatchKey = Brand<string, 'http.dispatch-key'>;
+export type HttpProcedureName = Brand<string, 'http.procedure'>;
+export type HttpHeaderName = Brand<string, 'http.header-name'>;
+export type CorsOriginValue = Brand<string, 'http.cors-origin'>;
+export type ContentTypeValue = Brand<string, 'http.content-type'>;
+export type NormalizedMediaType = Brand<string, 'http.media-type'>;
+export type HttpResponseStatus = Brand<number, 'http.response-status'>;
+export type HttpBaseUrl = Brand<string, 'http.base-url'>;
+export declare const normalizeHttpMethod: (value: string) => HttpMethod;
+export declare const requestPathname: (value: string) => RequestPathname;
+export declare const httpProcedureName: (value: string) => HttpProcedureName;
+export declare const httpHeaderName: (value: string) => HttpHeaderName;
+export declare const corsOriginValue: (value: string) => CorsOriginValue;
+export declare const httpBaseUrl: (value: string | URL) => HttpBaseUrl;
+export declare function normalizeMediaType(value: string | null | undefined): NormalizedMediaType | undefined;

package/dist/http/identity.js

@@ -0,0 +1,10 @@
+export const normalizeHttpMethod = (value) => value.toUpperCase();
+export const requestPathname = (value) => value;
+export const httpProcedureName = (value) => value;
+export const httpHeaderName = (value) => value;
+export const corsOriginValue = (value) => value;
+export const httpBaseUrl = (value) => String(value);
+export function normalizeMediaType(value) {
+    const normalized = value?.split(';', 1)[0]?.trim().toLowerCase();
+    return normalized ? normalized : undefined;
+}

package/dist/http/index.d.ts

@@ -1,11 +1,15 @@
 export { createHttpClient, fetchHttpTransport, HttpClientResponseError, } from './client.js';
 export type { FetchHttpTransportOptions, HttpClient, HttpClientRequest, HttpClientResponse, HttpClientTransport, HttpClientTransportRequest, HttpClientTransportResponse, } from './client.js';
 export { cors } from './cors.js';
+export { isWebSocketUpgrade } from './websocket-upgrade.js';
 export type { CorsLayerDescriptor, CorsOptions, CorsOrigin } from './cors.js';
 export { basicAuth, bearerAuth } from './auth.js';
 export type { BasicAuthContext, BasicAuthCredentials, BasicAuthDefinition, BasicAuthUnauthorized, BasicAuthRuntime, BearerAuthContext, BearerAuthDefinition, BearerAuthRuntime, BearerAuthUnauthorized, HttpAuthenticationFailure, } from './auth.js';
-export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, defineHttpRaw, httpError, executionHttp as http, httpExecutionExtension, isHttpContract, HTTP_SERVER, validate, } from './extension.js';
-export type { HttpRawDefinition, HttpRawRouteDefinition, HttpRawExecutionContext, HttpRawExecutionDefinition, HttpContract, HttpContractBranchDefinition, HttpContractNodeDefinition, HttpContractRouteTree, HttpExecutionContext, HttpExecutionDefinition, HttpExecutionRequestDefinition, HttpExecutionResponseDefinition, HttpExecutionResult, HttpExecutionRouteDefinition, HttpErrorMapping, HttpErrorMatcher, HttpExtensionRuntime, HttpHandlers, HttpHeaderValue, HttpHeaders, HttpHostApi, HttpImplementationDefinition, HttpMiddleware, HttpMiddlewareContext, HttpResponseHeadersDefinition, HttpResponseResult, HttpResponseHeadersWithDefaults, HttpServerDriver, HttpValidationMiddleware, HttpValidationPart, ResolvedHttpContractRoutes, } from './extension.js';
+export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, defineHttpRaw, httpError, executionHttp as http, httpExecutionExtension, isHttpContract, isHttpRawContractRoute, HTTP_SERVER, validate, } from './extension.js';
+export type { HttpRawDefinition, HttpRawRouteDefinition, HttpRawExecutionContext, HttpRawExecutionDefinition, HttpContract, HttpContractBranchDefinition, HttpContractNodeDefinition, HttpContractRouteTree, HttpContractRouteDefinition, HttpContractRawRouteDefinition, HttpContractRawRoute, HttpExecutionContext, HttpExecutionDefinition, HttpExecutionRequestDefinition, HttpExecutionResponseDefinition, HttpExecutionResult, HttpExecutionRouteDefinition, HttpErrorMapping, HttpErrorMatcher, HttpExtensionRuntime, HttpHandlers, HttpHeaderValue, HttpHeaders, HttpHostApi, HttpImplementationDefinition, HttpMiddleware, HttpMiddlewareContext, HttpResponseHeadersDefinition, HttpResponseResult, HttpResponseHeadersWithDefaults, HttpServerDriver, HttpValidationMiddleware, HttpValidationPart, ResolvedHttpContractRoutes, } from './extension.js';
 export { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, normalizeHttpPath, parseHttpPath, } from './path.js';
 export type { HttpPathSegment, PathParamNames } from './path.js';
 export type { HttpRequestHeadDefinition } from './request-head.js';
+export * from './identity.js';
+export type { ParsedHttpPath } from './path.js';
+export type { BearerCredential } from './auth.js';

package/dist/http/index.js

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

package/dist/http/openapi-identity.d.ts

@@ -0,0 +1,9 @@
+import type { Brand } from '../internal/brand.js';
+export type OpenApiOperationId = Brand<string, 'openapi.operation-id'>;
+export type OpenApiSchemaName = Brand<string, 'openapi.schema-name'>;
+export type JsonSchemaReference = Brand<string, 'openapi.schema-reference'>;
+export type SchemaComparisonKey = Brand<string, 'openapi.schema-comparison-key'>;
+export declare const openApiOperationId: (value: string) => OpenApiOperationId;
+export declare const openApiSchemaName: (value: string) => OpenApiSchemaName;
+export declare const jsonSchemaReference: (value: string) => JsonSchemaReference;
+export declare const schemaComparisonKey: (value: unknown) => SchemaComparisonKey;

package/dist/http/openapi-identity.js

@@ -0,0 +1,4 @@
+export const openApiOperationId = (value) => value;
+export const openApiSchemaName = (value) => value;
+export const jsonSchemaReference = (value) => value;
+export const schemaComparisonKey = (value) => JSON.stringify(value);

package/dist/http/openapi.d.ts

@@ -1,3 +1,4 @@
+export type { OpenApiOperationId, OpenApiSchemaName, JsonSchemaReference, } from './openapi-identity.js';
 import { type ApplicationModel } from '../core/index.js';
 import { type HttpContract, type HttpExecutionResponseDefinition, type HttpExecutionRouteDefinition } from './extension.js';
 export interface OpenApiInfo {
@@ -39,4 +40,3 @@ export interface HttpOperationTarget {
 }
 export type OpenApiSource = ApplicationModel | HttpContract;
 export declare function generateOpenApi(source: OpenApiSource, options: GenerateOpenApiOptions): OpenApiDocument;
-export {};

package/dist/http/openapi.js

@@ -1,3 +1,4 @@
+import { openApiOperationId, openApiSchemaName, jsonSchemaReference, schemaComparisonKey, } from './openapi-identity.js';
 import { supportsJsonSchema, assertValidApplicationModel, } from '../core/index.js';
 import { httpExecutionExtension, isHttpContract, } from './extension.js';
 import { findHttpRouteConflicts } from './route-validation.js';
@@ -34,7 +35,7 @@ function httpOperationTargets(source) {
         if (!isHttpContract(source)) {
             throw openApiError('LUTRE_OPENAPI_SOURCE_001', 'HttpContract source must be created by http.contract().');
         }
-        const routes = Object.entries(source.routes).map(([procedure, definition]) => ({ procedure, definition }));
+        const routes = Object.entries(source.routes).flatMap(([procedure, definition]) => definition.raw === true ? [] : [{ procedure, definition }]);
         const [conflict] = findHttpRouteConflicts(routes.map(({ definition }) => definition));
         if (conflict) {
             throw openApiError('LUTRE_OPENAPI_OPERATION_001', `Duplicate OpenAPI operation: ${conflict.route.method.toUpperCase()} ${conflict.route.path} conflicts with ${conflict.existing.method.toUpperCase()} ${conflict.existing.path}`);
@@ -71,10 +72,10 @@ function createOperation(target, registry, operationIds, resolveOperationId) {
         if (operationId.length === 0) {
             throw openApiError('LUTRE_OPENAPI_OPERATION_ID_002', `operationId must not be empty for ${describeTarget(target)}`);
         }
-        if (operationIds.has(operationId)) {
+        if (operationIds.has(openApiOperationId(operationId))) {
             throw openApiError('LUTRE_OPENAPI_OPERATION_ID_001', `Duplicate operationId: ${operationId}`);
         }
-        operationIds.add(operationId);
+        operationIds.add(openApiOperationId(operationId));
     }
     const parameters = [];
     const request = definition.request;
@@ -387,7 +388,9 @@ class SchemaRegistry {
         const materialized = {
             name,
             schema: rebased,
-            reference: { $ref: `#/components/schemas/${escapeJsonPointer(name)}` },
+            reference: {
+                $ref: jsonSchemaReference(`#/components/schemas/${escapeJsonPointer(name)}`),
+            },
         };
         const directions = this.bySchema.get(schema) ?? {};
         directions[direction] = materialized;
@@ -407,11 +410,11 @@ function sanitizeComponentName(value) {
 }
 function uniqueComponentName(preferred, schemas) {
     if (!(preferred in schemas))
-        return preferred;
+        return openApiSchemaName(preferred);
     let index = 2;
     while (`${preferred}_${index}` in schemas)
         index += 1;
-    return `${preferred}_${index}`;
+    return openApiSchemaName(`${preferred}_${index}`);
 }
 function escapeJsonPointer(value) {
     return value.replace(/~/g, '~0').replace(/\//g, '~1');
@@ -423,7 +426,7 @@ function dedupeJsonSchemas(schemas) {
     const seen = new Set();
     const result = [];
     for (const schema of schemas) {
-        const serialized = JSON.stringify(schema);
+        const serialized = schemaComparisonKey(schema);
         if (seen.has(serialized))
             continue;
         seen.add(serialized);

package/dist/http/path.d.ts

@@ -1,3 +1,5 @@
+import type { Brand } from '../internal/brand.js';
+import type { HttpNormalizedPath, HttpDispatchKey, HttpMethod, RequestPathname } from './identity.js';
 export type HttpPathSegment = {
     readonly kind: 'static';
     readonly value: string;
@@ -6,12 +8,13 @@ export type HttpPathSegment = {
     readonly name: string;
 };
 export type PathParamNames<TPath extends string> = TPath extends `${string}{${infer TName}}${infer TRest}` ? TName | PathParamNames<TRest> : never;
+export type ParsedHttpPath = Brand<readonly HttpPathSegment[], 'http.parsed-path'>;
 export declare function assertValidHttpMethod(method: string): void;
-export declare function parseHttpPath(path: string): readonly HttpPathSegment[];
-export declare function normalizeHttpPath(segments: readonly HttpPathSegment[]): string;
-export declare function createHttpDispatchKey(method: string, segments: readonly HttpPathSegment[]): string;
-export declare function matchHttpPath(segments: readonly HttpPathSegment[], pathname: string): Record<string, string> | undefined;
-export declare function compareHttpPathSpecificity(left: readonly HttpPathSegment[], right: readonly HttpPathSegment[]): number;
+export declare function parseHttpPath(path: string): ParsedHttpPath;
+export declare function normalizeHttpPath(segments: ParsedHttpPath): HttpNormalizedPath;
+export declare function createHttpDispatchKey(method: HttpMethod | '*', segments: ParsedHttpPath): HttpDispatchKey;
+export declare function matchHttpPath(segments: ParsedHttpPath, pathname: RequestPathname): Record<string, string> | undefined;
+export declare function compareHttpPathSpecificity(left: ParsedHttpPath, right: ParsedHttpPath): number;
 export declare class HttpPathDecodeError extends Error {
     readonly cause: unknown;
     constructor(cause: unknown);

package/dist/http/route-validation.js

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

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

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

package/dist/http/runtime/request.js

@@ -1,3 +1,4 @@
+import { normalizeMediaType } from '../identity.js';
 import { SchemaValidationError, validateSchema, } from '../../core/index.js';
 export function decodeQuery(searchParams) {
     const query = {};
@@ -79,10 +80,6 @@ function hasContentTypeIssue(error) {
         return key === 'content-type';
     });
 }
-function normalizeMediaType(value) {
-    const normalized = value?.split(';', 1)[0]?.trim().toLowerCase();
-    return normalized ? normalized : undefined;
-}
 export class HttpInputDecodeError extends Error {
     cause;
     constructor(cause) {

package/dist/http/websocket-upgrade.d.ts

@@ -0,0 +1,2 @@
+/** WebSocketへのUpgrade要求かを判定する。handshake全体の検証は行わない。 */
+export declare function isWebSocketUpgrade(request: Request): boolean;

package/dist/http/websocket-upgrade.js

@@ -0,0 +1,4 @@
+/** WebSocketへのUpgrade要求かを判定する。handshake全体の検証は行わない。 */
+export function isWebSocketUpgrade(request) {
+    return request.headers.get('upgrade')?.toLowerCase() === 'websocket';
+}

package/dist/internal/brand.d.ts

@@ -0,0 +1,8 @@
+export type Brand<T, Tag extends string> = T & {
+    readonly '~loutre.brand': {
+        readonly [Key in Tag]: true;
+    };
+};
+export interface Descriptor<Tag extends string> {
+    readonly '~loutre.descriptor': Tag;
+}

package/dist/internal/brand.js

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

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

@@ -1,3 +1,5 @@
+import { type MessagePortProcedureName } from './identity.js';
+import type { Descriptor } from '../internal/brand.js';
 import { type ExecutionDefinition, type ExecutionExtension, type ExecutionExtensionDrainContext, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
 export interface MessagePortServerStreamResponseDefinition {
     readonly body: StandardSchemaV1;
@@ -8,7 +10,7 @@ export interface MessagePortRouteDefinition {
     readonly input?: StandardSchemaV1;
     readonly responses: Readonly<Record<string, MessagePortResponseDefinition>>;
 }
-export interface MessagePortContract<TRoutes extends Readonly<Record<string, MessagePortRouteDefinition>> = Readonly<Record<string, MessagePortRouteDefinition>>> {
+export interface MessagePortContract<TRoutes extends Readonly<Record<string, MessagePortRouteDefinition>> = Readonly<Record<string, MessagePortRouteDefinition>>> extends Descriptor<'message-port-contract'> {
     readonly kind: 'message-port-contract';
     readonly routes: TRoutes;
 }
@@ -39,7 +41,7 @@ interface CompiledMessagePortExecution {
     readonly factory: () => Readonly<Record<string, (context: MessagePortContext) => MessagePortResult | Promise<MessagePortResult>>>;
 }
 export interface MessagePortExtensionRuntime {
-    invoke(method: string, input?: unknown): Promise<MessagePortResult>;
+    invoke(method: MessagePortProcedureName, input?: unknown): Promise<MessagePortResult>;
     drain(context: ExecutionExtensionDrainContext): Promise<void>;
 }
 export interface MessagePortHostApi {

package/dist/message-port/extension.js

@@ -1,3 +1,6 @@
+import { dependencyConsumerId } from '../core/identity.js';
+import { epochNow, expiresAt, epochMilliseconds, } from '../core/units.js';
+import { messagePortProcedureName, } from './identity.js';
 import { collectInjectedDependencies, defineExecution, defineExecutionExtension, runInInjectionContext, validateSchema, } from '../core/index.js';
 import { IngressGate } from '../runtime/ingress-gate.js';
 import { AsyncIteratorCleanupDeadlineError, AsyncIteratorLifecycle, } from '../runtime/async-iterator-lifecycle.js';
@@ -13,7 +16,7 @@ export const messagePortExtension = defineExecutionExtension({
             executionKind: 'message-port.invocation',
             dependencies: collectInjectedDependencies({
                 kind: 'execution',
-                id: `message-port:${definition.name || `${context.moduleId}.message-port.${context.definitionIndex}`}`,
+                id: dependencyConsumerId(`message-port:${definition.name || `${context.moduleId}.message-port.${context.definitionIndex}`}`),
                 name: definition.name ||
                     `${context.moduleId}.message-port.${context.definitionIndex}`,
             }, () => definition.factory()),
@@ -26,7 +29,8 @@ export const messagePortExtension = defineExecutionExtension({
     },
     validate({ executions }) {
         const methods = new Set();
-        return executions.flatMap((execution) => Object.keys(execution.compiled.routes).flatMap((method) => {
+        return executions.flatMap((execution) => Object.keys(execution.compiled.routes).flatMap((name) => {
+            const method = messagePortProcedureName(name);
             if (!methods.has(method)) {
                 methods.add(method);
                 return [];
@@ -49,12 +53,15 @@ export const messagePortExtension = defineExecutionExtension({
     host: {
         namespace: 'messagePort',
         create: ({ runtime }) => ({
-            invoke: (method, input) => runtime.invoke(method, input),
+            invoke: (method, input) => runtime.invoke(messagePortProcedureName(method), input),
         }),
     },
 });
 export function defineMessagePortContract(routes) {
-    return Object.freeze({ kind: 'message-port-contract', routes });
+    return Object.freeze({
+        kind: 'message-port-contract',
+        routes,
+    });
 }
 export function defineMessagePortImplementation(definition) {
     return defineExecution(messagePortExtension, {
@@ -90,7 +97,7 @@ function createMessagePortRuntime(bindings, applicationRuntime) {
         const handlers = runInInjectionContext({
             consumer: {
                 kind: 'execution',
-                id: `message-port:${execution.id}`,
+                id: dependencyConsumerId(`message-port:${execution.id}`),
                 name: execution.id,
             },
             resolve: (token, consumer) => resolve(token, { consumer }),
@@ -98,7 +105,7 @@ function createMessagePortRuntime(bindings, applicationRuntime) {
         for (const [method, definition] of Object.entries(execution.compiled.routes)) {
             const handler = handlers[method];
             if (handler) {
-                routes.set(method, {
+                routes.set(messagePortProcedureName(method), {
                     executionId: execution.id,
                     route: definition,
                     handler,
@@ -178,7 +185,7 @@ function createMessagePortRuntime(bindings, applicationRuntime) {
         },
         async drain({ timeoutMs }) {
             ingress.stopAccepting();
-            const deadline = Date.now() + timeoutMs;
+            const deadline = expiresAt(epochNow(), timeoutMs);
             await ingress.waitForIdle();
             const reason = new Error('LUTRE_MESSAGE_PORT_DRAINING');
             const results = await Promise.allSettled([...activeStreams].map((stream) => stream.abort(reason, deadline)));
@@ -230,7 +237,7 @@ function createLeasedMessagePortStream(schema, source, lease, activeStreams) {
     const startIteratorCleanup = (reason, deadline) => {
         if (iteratorCleanup) {
             if (deadline !== undefined) {
-                iteratorCleanupDeadline = Math.min(iteratorCleanupDeadline ?? deadline, deadline);
+                iteratorCleanupDeadline = epochMilliseconds(Math.min(iteratorCleanupDeadline ?? deadline, deadline));
             }
             return iteratorCleanup;
         }

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

@@ -0,0 +1,9 @@
+import type { Brand } from '../internal/brand.js';
+export type MessagePortRequestId = Brand<string, 'message-port.request-id'>;
+export type MessagePortProcedureName = Brand<string, 'message-port.procedure'>;
+export declare const messagePortProcedureName: (value: string) => MessagePortProcedureName;
+export declare function decodeMessagePortRequest(value: unknown): {
+    readonly id: MessagePortRequestId;
+    readonly procedure: MessagePortProcedureName;
+    readonly input?: unknown;
+} | undefined;

package/dist/message-port/identity.js

@@ -0,0 +1,16 @@
+export const messagePortProcedureName = (value) => value;
+export function decodeMessagePortRequest(value) {
+    if (typeof value !== 'object' ||
+        value === null ||
+        Array.isArray(value) ||
+        !('id' in value) ||
+        !('procedure' in value) ||
+        typeof value.id !== 'string' ||
+        typeof value.procedure !== 'string')
+        return undefined;
+    return {
+        id: value.id,
+        procedure: messagePortProcedureName(value.procedure),
+        ...('input' in value ? { input: value.input } : {}),
+    };
+}