@loutrejs/loutre 0.4.0 → 0.5.0

package/dist/graph/graph.js

@@ -1,4 +1,5 @@
 import { argumentsProvider, asModuleInstance, childPipelineOf, contextKeyName, defineModule, isArgsClass, isEnvClass, layerDefinitionOf, normalizeProvider, queueRuntimeToken, tokenName, } from '../core/index.js';
+import { contractOfBinding, contractRootOf, resolveContractProcedureIdentity, } from '../core/contract-internal.js';
 import { Container, Logger } from '../runtime/index.js';
 export class StaticValidationError extends Error {
     diagnostics;
@@ -38,6 +39,7 @@ export function compileApplication(input) {
     validateNamedDescriptors(queues, 'LUTRE_QUEUE_DUPLICATE', diagnostics);
     validateCronTriggers(triggers, diagnostics);
     diagnostics.push(...validateQueueDrivers(input.modules, queueTriggers));
+    const applicationContract = input.contract === undefined ? undefined : contractOfBinding(input.contract);
     const contractIds = new Map();
     const idContract = (contract) => {
         const current = contractIds.get(contract);
@@ -56,29 +58,36 @@ export function compileApplication(input) {
         implementationIds.set(implementation, id);
         return id;
     };
+    if (applicationContract)
+        idContract(applicationContract);
     const descriptors = modules.flatMap((module) => module.definition.implementations ?? []);
     for (const implementation of new Set(descriptors)) {
-        idContract(implementation.contract);
+        const firstProcedure = implementation.procedures[0];
+        const identity = firstProcedure === undefined
+            ? { contract: contractRootOf(implementation.contract) }
+            : resolveContractProcedureIdentity(implementation.contract, firstProcedure, applicationContract);
+        idContract(identity.contract);
         idImplementation(implementation);
     }
     const targets = [];
     for (const implementation of descriptors) {
         for (const procedureName of implementation.procedures) {
+            const identity = resolveContractProcedureIdentity(implementation.contract, procedureName, applicationContract);
             const procedure = implementation.contract.procedures[procedureName];
             const protocol = procedure?.protocols[implementation.protocol];
             if (!procedure || !protocol) {
                 diagnostics.push({
                     code: 'LUTRE_IMPL_003',
                     message: `${procedureName} is not declared for protocol ${implementation.protocol}`,
-                    path: `${idContract(implementation.contract)}.${procedureName}.${implementation.protocol}`,
+                    path: `${idContract(identity.contract)}.${identity.procedure}.${implementation.protocol}`,
                 });
                 continue;
             }
             targets.push({
                 implementation,
-                contractId: idContract(implementation.contract),
+                contractId: idContract(identity.contract),
                 implementationId: idImplementation(implementation),
-                procedure: procedureName,
+                procedure: identity.procedure,
                 protocol: implementation.protocol,
                 dispatchKey: protocol.dispatchKey,
                 pipeline: protocol.pipeline ?? protocol.definition?.pipeline ?? [],
@@ -90,7 +99,7 @@ export function compileApplication(input) {
         }
     }
     validateDispatchKeys(targets, diagnostics);
-    validateCoverage(descriptors, contractIds, diagnostics);
+    validateCoverage(descriptors, targets, contractIds, diagnostics, applicationContract);
     validateDuplicateProviders(modules, diagnostics);
     const tokensById = collectCustomTokens(providers, targets, diagnostics);
     const contextKeysByName = collectContextKeys(targets, diagnostics);
@@ -104,13 +113,17 @@ export function compileApplication(input) {
             layers: target.pipeline.map(toLayerIR),
         });
     }
-    const implementations = [...new Set(descriptors)].map((implementation) => ({
-        id: idImplementation(implementation),
-        name: implementation.name,
-        contract: idContract(implementation.contract),
-        protocol: implementation.protocol,
-        procedures: implementation.procedures,
-    }));
+    const implementations = [...new Set(descriptors)].map((implementation) => {
+        const implementationTargets = targets.filter((target) => target.implementation === implementation);
+        return {
+            id: idImplementation(implementation),
+            name: implementation.name,
+            contract: implementationTargets[0]?.contractId ??
+                idContract(contractRootOf(implementation.contract)),
+            protocol: implementation.protocol,
+            procedures: implementationTargets.map((target) => target.procedure),
+        };
+    });
     const dependencyGraph = buildDependencyGraph(modules, descriptors, targets, tasks, diagnostics);
     const probedTokenIds = dependencyGraph.nodes
         .filter((node) => node.kind === 'token')
@@ -272,7 +285,7 @@ function validateDispatchKeys(targets, diagnostics) {
         const path = `${target.contractId}.${target.procedure}.${target.protocol}`;
         const existing = targetsByKey.get(target.dispatchKey);
         if (existing) {
-            if (existing.implementation.contract === target.implementation.contract &&
+            if (existing.contractId === target.contractId &&
                 existing.procedure === target.procedure &&
                 existing.protocol === target.protocol) {
                 continue;
@@ -914,18 +927,20 @@ function collectModules(roots) {
         visit(root);
     return modules;
 }
-function validateCoverage(implementations, contractIds, diagnostics) {
-    const contracts = new Set(implementations.map((implementation) => implementation.contract));
+function validateCoverage(implementations, targets, contractIds, diagnostics, applicationContract) {
+    const contracts = applicationContract
+        ? [applicationContract]
+        : [
+            ...new Set(implementations.map((implementation) => contractRootOf(implementation.contract))),
+        ];
     for (const contract of contracts) {
-        const protocols = new Set(Object.values(contract.procedures).flatMap((procedure) => Object.keys(procedure.protocols)));
-        for (const protocol of protocols) {
-            for (const [procedureName, procedure] of Object.entries(contract.procedures)) {
-                if (!(protocol in procedure.protocols))
-                    continue;
-                const covering = implementations.filter((implementation) => implementation.contract === contract &&
-                    implementation.protocol === protocol &&
-                    implementation.procedures.includes(procedureName));
-                const path = `${contractIds.get(contract) ?? 'contract:unknown'}.${procedureName}.${protocol}`;
+        const contractId = contractIds.get(contract) ?? 'contract:unknown';
+        for (const [procedureName, procedure] of Object.entries(contract.procedures)) {
+            for (const protocol of Object.keys(procedure.protocols)) {
+                const covering = targets.filter((target) => target.contractId === contractId &&
+                    target.protocol === protocol &&
+                    target.procedure === procedureName);
+                const path = `${contractId}.${procedureName}.${protocol}`;
                 if (covering.length === 0) {
                     diagnostics.push({
                         code: 'LUTRE_IMPL_001',

package/dist/http/application.js

@@ -363,7 +363,16 @@ async function finalizeResponse(definition, result, signal) {
         });
     }
     const body = await validateSchema(response.body, result.body);
-    return jsonResponse(response.status, body, mergeResponseHeaders(response.staticHeaders, responseHeaders));
+    const headers = mergeResponseHeaders(response.staticHeaders, responseHeaders);
+    if (response.status === 204 ||
+        response.status === 205 ||
+        response.status === 304) {
+        if (body !== undefined) {
+            throw new Error(`HTTP ${response.status} response body must be undefined`);
+        }
+        return new Response(undefined, { status: response.status, headers });
+    }
+    return jsonResponse(response.status, body, headers);
 }
 async function validateResponseHeaders(schema, headers) {
     if (!schema) {

package/dist/http/client.d.ts

@@ -1,4 +1,4 @@
-import { type ContractDefinition, type ProcedureDefinition, type SchemaInput, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
+import { type ContractBinding, type ContractDefinition, type ContractOfBinding, 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 {
@@ -52,8 +52,8 @@ export type HttpClientResponse<TDefinition extends HttpProtocolDefinition> = {
     } : 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 type HttpClient<TBinding extends ContractBinding> = {
+    readonly [TProcedure in HttpProcedureNames<ContractOfBinding<TBinding>>]: HttpClientMethod<HttpDefinitionOf<ContractOfBinding<TBinding>, TProcedure>>;
 };
 export declare class HttpClientResponseError extends Error {
     readonly status: number;
@@ -62,7 +62,7 @@ export declare class HttpClientResponseError extends Error {
     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 declare function createHttpClient<const TBinding extends ContractBinding>(binding: TBinding, transport: HttpClientTransport): HttpClient<TBinding>;
 export interface FetchHttpTransportOptions {
     readonly baseUrl: string | URL;
     readonly fetch?: typeof globalThis.fetch;

package/dist/http/client.js

@@ -1,4 +1,5 @@
 import { SchemaValidationError, validateSchema, } from '../core/index.js';
+import { contractOfBinding } from '../core/contract-internal.js';
 import { parseHttpPath, } from './path.js';
 export class HttpClientResponseError extends Error {
     status;
@@ -14,7 +15,8 @@ export class HttpClientResponseError extends Error {
         this.name = 'HttpClientResponseError';
     }
 }
-export function createHttpClient(contract, transport) {
+export function createHttpClient(binding, transport) {
+    const contract = contractOfBinding(binding);
     const client = {};
     for (const [procedureName, procedure] of Object.entries(contract.procedures)) {
         const definition = httpDefinitionOf(procedure);
@@ -189,8 +191,11 @@ function encodeBody(body, contentType) {
     return body;
 }
 async function decodeFetchBody(response) {
-    if (response.status === 204 || response.status === 205)
+    if (response.status === 204 ||
+        response.status === 205 ||
+        response.status === 304) {
         return undefined;
+    }
     const mediaType = normalizeMediaType(response.headers.get('content-type'));
     if (mediaType === 'text/event-stream') {
         if (!response.body) {

package/dist/http/definitions.d.ts

@@ -1,6 +1,8 @@
-import type { ContractDefinition, ContextProvidedBeforeTerminal, HasValidationBeforeTerminal, IsValidProtocolPipeline, PipelineItem, ProtocolDescriptor, ProtocolFactory, ProtocolGroup, SchemaInput, SchemaOutput, ShortCircuitDeclarationsOf, ShortCircuitResultOf, StandardSchemaV1, TerminalLayerDescriptor, ValidationLayerDescriptor } from '../core/index.js';
+import type { ContractBinding, ContractDefinition, ContractOfBinding, ResolvedContractNode, ContextProvidedBeforeTerminal, HasValidationBeforeTerminal, IsValidProtocolPipeline, PipelineItem, ProcedureDefinition, ProtocolDescriptor, ProtocolFactory, ProtocolGroup, SchemaInput, SchemaOutput, ShortCircuitDeclarationsOf, ShortCircuitResultOf, StandardSchemaV1, TerminalLayerDescriptor, ValidationLayerDescriptor } from '../core/index.js';
+import { protocolNamespaceType } from '../core/contract-internal.js';
+import { httpNodeMetadata } from './internal.js';
 import type { Logger } from '../runtime/index.js';
-import { type HttpDispatchKey, type IsValidHttpPath, type PathParamNames, type RawPathParams } from './path.js';
+import { type HttpDispatchKey, type IsValidHttpMethod, 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;
@@ -49,8 +51,110 @@ export interface HttpProtocolDefinition {
     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']>> {
+export interface HttpBranchDefinition {
+    readonly path?: string;
+    readonly pipeline?: readonly PipelineItem[];
+    readonly responses?: Readonly<Record<string, HttpResponseDefinition>>;
+    readonly routes: HttpRouteTree;
+}
+export type HttpRouteTree = Readonly<Record<string, HttpProtocolDefinition | HttpBranchDefinition | HttpResolvedNode>>;
+interface HttpResolvedNodeMetadata<TSource extends HttpProtocolDefinition | HttpBranchDefinition = HttpProtocolDefinition | HttpBranchDefinition, THandlerName extends string | never = string | never> {
+    readonly kind: 'leaf' | 'branch';
+    readonly source: TSource;
+    readonly handlerName: THandlerName;
+}
+export type HttpResolvedLeaf<THandlerName extends string = string, TSource extends HttpProtocolDefinition = HttpProtocolDefinition, TEffective extends HttpProtocolDefinition = HttpProtocolDefinition> = ResolvedContractNode<ContractDefinition<{
+    readonly [K in THandlerName]: {
+        readonly kind: 'procedure';
+        readonly protocols: {
+            readonly http: HttpProtocol<TEffective>;
+        };
+    };
+}>, 'leaf'> & {
+    readonly [httpNodeMetadata]: HttpResolvedNodeMetadata<TSource, THandlerName> & {
+        readonly kind: 'leaf';
+    };
+};
+type ResolvedContractOf<TNode> = TNode extends ResolvedContractNode<infer TContract> ? TContract : never;
+type HttpProtocolOfResolvedLeaf<TNode> = ResolvedContractOf<TNode> extends ContractDefinition<infer TProcedures> ? TProcedures[keyof TProcedures & string]['protocols'] extends {
+    readonly http: infer TProtocol extends ProtocolDescriptor<'http'>;
+} ? TProtocol : never : never;
+type FlatResolvedHttpProcedures<TChildren extends Readonly<Record<string, unknown>>, TPrefix extends string = ''> = UnionToIntersection<{
+    [K in keyof TChildren & string]: TChildren[K] extends HttpResolvedLeaf<any, any, any> ? {
+        readonly [P in JoinProcedurePath<TPrefix, K>]: ProcedureDefinition<{
+            readonly http: HttpProtocolOfResolvedLeaf<TChildren[K]>;
+        }>;
+    } : TChildren[K] extends HttpResolvedBranch<any, infer TGrandchildren> ? FlatResolvedHttpProcedures<TGrandchildren, JoinProcedurePath<TPrefix, K>> : never;
+}[keyof TChildren & string]> extends infer TProcedures extends Record<string, ProcedureDefinition> ? TProcedures : never;
+export type HttpResolvedBranch<TSource extends HttpBranchDefinition = HttpBranchDefinition, TChildren extends Readonly<Record<string, HttpResolvedNode>> = Readonly<Record<string, HttpResolvedNode>>> = ResolvedContractNode<ContractDefinition<FlatResolvedHttpProcedures<TChildren>>, 'branch'> & TChildren & {
+    readonly [httpNodeMetadata]: HttpResolvedNodeMetadata<TSource, never> & {
+        readonly kind: 'branch';
+    };
+};
+export type HttpResolvedNode = ResolvedContractNode<ContractDefinition, 'leaf' | 'branch'> & {
+    readonly [httpNodeMetadata]: HttpResolvedNodeMetadata;
+};
+type SourceOfHttpNode<TNode> = TNode extends {
+    readonly [httpNodeMetadata]: HttpResolvedNodeMetadata<infer TSource, any>;
+} ? TSource : TNode;
+type HandlerNameOfHttpNode<TName extends string, TNode> = TNode extends {
+    readonly [httpNodeMetadata]: HttpResolvedNodeMetadata<any, infer THandlerName>;
+} ? [THandlerName] extends [never] ? TName : THandlerName & string : TName;
+type BranchPathOf<TBranch extends HttpBranchDefinition> = TBranch extends {
+    readonly path: infer TPath extends string;
+} ? TPath : '';
+type BranchPipelineOf<TBranch extends HttpBranchDefinition> = TBranch extends {
+    readonly pipeline: infer TPipeline extends readonly PipelineItem[];
+} ? TPipeline : readonly [];
+type BranchResponsesOf<TBranch extends HttpBranchDefinition> = TBranch extends {
+    readonly responses: infer TResponses extends Readonly<Record<string, HttpResponseDefinition>>;
+} ? TResponses : {};
+type JoinHttpPath<TParent extends string, TChild extends string> = TParent extends '' ? TChild : TChild extends '/' ? TParent : `${TParent}${TChild}`;
+type MergeHttpResponses<TParent extends Readonly<Record<string, HttpResponseDefinition>>, TLocal extends Readonly<Record<string, HttpResponseDefinition>>> = Extract<keyof TParent, keyof TLocal> extends never ? TParent & TLocal : never;
+type EffectiveHttpDefinition<TDefinition extends HttpProtocolDefinition, TParentPath extends string, TParentPipeline extends readonly PipelineItem[], TParentResponses extends Readonly<Record<string, HttpResponseDefinition>>> = {
+    readonly method: TDefinition['method'];
+    readonly path: JoinHttpPath<TParentPath, TDefinition['path']>;
+    readonly responses: MergeHttpResponses<TParentResponses, TDefinition['responses']>;
+    readonly pipeline: readonly [...TParentPipeline, ...TDefinition['pipeline']];
+} & (TDefinition extends {
+    readonly summary: infer TValue extends string;
+} ? {
+    readonly summary: TValue;
+} : {}) & (TDefinition extends {
+    readonly description: infer TValue extends string;
+} ? {
+    readonly description: TValue;
+} : {}) & (TDefinition extends {
+    readonly tags: infer TValue extends readonly string[];
+} ? {
+    readonly tags: TValue;
+} : {}) & (TDefinition extends {
+    readonly deprecated: infer TValue extends boolean;
+} ? {
+    readonly deprecated: TValue;
+} : {}) & (TDefinition extends {
+    readonly request: infer TValue extends HttpRequestDefinition;
+} ? {
+    readonly request: TValue;
+} : {}) & (TDefinition extends {
+    readonly interaction: infer TValue extends 'unary' | 'server-stream';
+} ? {
+    readonly interaction: TValue;
+} : {});
+type ResolvedHttpTree<TTree extends Readonly<Record<string, unknown>>, TParentPath extends string = '', TParentPipeline extends readonly PipelineItem[] = readonly [], TParentResponses extends Readonly<Record<string, HttpResponseDefinition>> = {}> = {
+    readonly [K in keyof TTree]: ResolveHttpNode<K & string, TTree[K], TParentPath, TParentPipeline, TParentResponses>;
+};
+type ResolveHttpNode<TName extends string, TNode, TParentPath extends string, TParentPipeline extends readonly PipelineItem[], TParentResponses extends Readonly<Record<string, HttpResponseDefinition>>> = SourceOfHttpNode<TNode> extends infer TSource ? TSource extends HttpProtocolDefinition ? HttpResolvedLeaf<HandlerNameOfHttpNode<TName, TNode>, TSource, EffectiveHttpDefinition<TSource, TParentPath, TParentPipeline, TParentResponses>> : TSource extends HttpBranchDefinition ? HttpResolvedBranch<TSource, ResolvedHttpTree<TSource['routes'], JoinHttpPath<TParentPath, BranchPathOf<TSource>>, readonly [...TParentPipeline, ...BranchPipelineOf<TSource>], MergeHttpResponses<TParentResponses, BranchResponsesOf<TSource>>>> : never : never;
+type JoinProcedurePath<TPrefix extends string, TName extends string> = TPrefix extends '' ? TName : `${TPrefix}.${TName}`;
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type FlatHttpProtocols<TTree extends Readonly<Record<string, unknown>>, TParentPath extends string = '', TParentPipeline extends readonly PipelineItem[] = readonly [], TParentResponses extends Readonly<Record<string, HttpResponseDefinition>> = {}, TProcedurePrefix extends string = '', TRootTree extends Readonly<Record<string, unknown>> = TTree> = UnionToIntersection<{
+    [K in keyof TTree & string]: SourceOfHttpNode<TTree[K]> extends infer TSource ? TSource extends HttpProtocolDefinition ? {
+        readonly [P in JoinProcedurePath<TProcedurePrefix, K>]: HttpProtocol<EffectiveHttpDefinition<TSource, TParentPath, TParentPipeline, TParentResponses>, ResolvedHttpTree<TRootTree>>;
+    } : TSource extends HttpBranchDefinition ? FlatHttpProtocols<TSource['routes'], JoinHttpPath<TParentPath, BranchPathOf<TSource>>, readonly [...TParentPipeline, ...BranchPipelineOf<TSource>], MergeHttpResponses<TParentResponses, BranchResponsesOf<TSource>>, JoinProcedurePath<TProcedurePrefix, K>, TRootTree> : never : never;
+}[keyof TTree & string]>;
+export interface HttpProtocol<TDefinition extends HttpProtocolDefinition = HttpProtocolDefinition, TNamespace = unknown> extends ProtocolDescriptor<'http', HttpControllerContextDefinition<TDefinition>, DeclaredHttpResults<TDefinition['responses']>, HttpDispatchKey<TDefinition['method'], TDefinition['path']>> {
     readonly definition: TDefinition;
+    readonly [protocolNamespaceType]: TNamespace;
     readonly interaction: TDefinition extends {
         readonly interaction: infer TInteraction;
     } ? TInteraction & ('unary' | 'server-stream') : 'unary';
@@ -88,6 +192,14 @@ type HttpPipelineConstraint<TDefinition extends HttpProtocolDefinition> = IsVali
 } : {
     readonly pipeline: never;
 };
+type HttpStatusDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type HttpStatusHundreds = '2' | '3' | '4' | '5';
+type IsValidHttpResponseStatus<TStatus extends number> = number extends TStatus ? false : `${TStatus}` extends `${HttpStatusHundreds}${HttpStatusDigit}${HttpStatusDigit}` ? true : false;
+type IsBodylessHttpStatus<TStatus extends number> = TStatus extends 204 | 205 | 304 ? true : false;
+type IsResponseStatusCompatible<TResponse> = TResponse extends HttpResponseDefinition ? IsValidHttpResponseStatus<TResponse['status']> extends true ? IsBodylessHttpStatus<TResponse['status']> extends true ? [SchemaOutput<TResponse['body']>] extends [undefined] ? true : false : true : false : false;
+type AreResponseStatusesCompatible<TResponses extends HttpProtocolDefinition['responses']> = false extends {
+    [TVariant in keyof TResponses]: IsResponseStatusCompatible<TResponses[TVariant]>;
+}[keyof TResponses] ? false : true;
 type IsResponseHeadersSchemaCompatible<TResponse> = TResponse extends HttpResponseDefinition ? TResponse extends {
     readonly headers: infer THeaders extends StandardSchemaV1;
 } ? SchemaOutput<THeaders> extends HttpHeaders | undefined ? true : false : true : false;
@@ -96,7 +208,9 @@ type AreResponseHeadersSchemasCompatible<TResponses extends HttpProtocolDefiniti
 }[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 : {
+} : AreResponseStatusesCompatible<TDefinition['responses']> extends true ? AreResponseHeadersSchemasCompatible<TDefinition['responses']> extends true ? AreErrorMappingsCompatible<TDefinition['responses']> extends true ? unknown : {
+    readonly responses: never;
+} : {
     readonly responses: never;
 } : {
     readonly responses: never;
@@ -110,6 +224,8 @@ type IsUnion<TValue, TCandidate = TValue> = TValue extends unknown ? [TCandidate
 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;
+} : IsValidHttpMethod<TDefinition['method']> extends false ? {
+    readonly method: never;
 } : IsSingleStringLiteral<TDefinition['path']> extends false ? {
     readonly path: never;
 } : IsValidHttpPath<TDefinition['path']> extends true ? TDefinition['request'] extends {
@@ -132,15 +248,39 @@ type IsErrorMappingCompatible<TResponse> = TResponse extends HttpResponseDefinit
 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]>;
+type IsConstraintSatisfied<TConstraint> = keyof TConstraint extends never ? true : false;
+type IsValidHttpRouteName<TName extends string> = TName extends '' ? false : TName extends '__proto__' ? false : TName extends `${string}.${string}` ? false : TName extends `${number}` ? false : true;
+type HasOnlyHttpNodeProperties<TNode, TAllowed extends PropertyKey> = Exclude<keyof TNode, TAllowed> extends never ? true : false;
+type IsExactHttpLeaf<TNode> = HasOnlyHttpNodeProperties<TNode, keyof HttpProtocolDefinition>;
+type IsExactHttpBranch<TNode> = HasOnlyHttpNodeProperties<TNode, keyof HttpBranchDefinition>;
+type IsBranchPipelineTerminalFree<TPipeline extends readonly PipelineItem[]> = number extends TPipeline['length'] ? false : TPipeline extends readonly [infer THead, ...infer TTail] ? THead extends TerminalLayerDescriptor ? false : THead extends {
+    readonly kind: 'layer';
+    readonly pipeline: infer TChild extends readonly PipelineItem[];
+} ? IsBranchPipelineTerminalFree<TChild> extends true ? IsBranchPipelineTerminalFree<Extract<TTail, readonly PipelineItem[]>> : false : IsBranchPipelineTerminalFree<Extract<TTail, readonly PipelineItem[]>> : true;
+type IsHttpBranchPathValid<TBranch extends HttpBranchDefinition> = TBranch extends {
+    readonly path: infer TPath extends string;
+} ? string extends TPath ? false : TPath extends '/' ? true : IsValidHttpPath<TPath> : true;
+type IsHttpBranchPipelineValid<TBranch extends HttpBranchDefinition> = TBranch extends {
+    readonly pipeline: infer TPipeline extends readonly PipelineItem[];
+} ? IsBranchPipelineTerminalFree<TPipeline> : true;
+type IsHttpBranchResponsesValid<TBranch extends HttpBranchDefinition> = TBranch extends {
+    readonly responses: infer TResponses extends Readonly<Record<string, HttpResponseDefinition>>;
+} ? string extends keyof TResponses ? false : AreResponseHeadersSchemasCompatible<TResponses> extends true ? AreErrorMappingsCompatible<TResponses> : false : true;
+type HasHttpResponseCollision<TParent extends Readonly<Record<string, HttpResponseDefinition>>, TLocal extends Readonly<Record<string, HttpResponseDefinition>>> = Extract<keyof TParent, keyof TLocal> extends never ? false : true;
+type IsHttpResolvedLeafValid<TDefinition extends HttpProtocolDefinition, TParentPath extends string, TParentPipeline extends readonly PipelineItem[], TParentResponses extends Readonly<Record<string, HttpResponseDefinition>>, TEffective extends HttpProtocolDefinition = EffectiveHttpDefinition<TDefinition, TParentPath, TParentPipeline, TParentResponses>> = IsConstraintSatisfied<HttpPipelineConstraint<TEffective> & HttpResponseConstraint<TEffective> & HttpPathConstraint<TEffective>>;
+type IsHttpTreeValid<TTree extends Readonly<Record<string, unknown>>, TParentPath extends string = '', TParentPipeline extends readonly PipelineItem[] = readonly [], TParentResponses extends Readonly<Record<string, HttpResponseDefinition>> = {}> = Extract<keyof TTree, number> extends never ? false extends {
+    [K in keyof TTree & string]: IsValidHttpRouteName<K> extends true ? SourceOfHttpNode<TTree[K]> extends infer TSource ? TSource extends HttpProtocolDefinition ? IsExactHttpLeaf<TSource> extends true ? IsHttpResolvedLeafValid<TSource, TParentPath, TParentPipeline, TParentResponses> : false : TSource extends HttpBranchDefinition ? IsExactHttpBranch<TSource> extends true ? IsHttpBranchPathValid<TSource> extends true ? IsHttpBranchPipelineValid<TSource> extends true ? IsHttpBranchResponsesValid<TSource> extends true ? HasHttpResponseCollision<TParentResponses, BranchResponsesOf<TSource>> extends false ? IsHttpTreeValid<TSource['routes'], JoinHttpPath<TParentPath, BranchPathOf<TSource>>, readonly [
+        ...TParentPipeline,
+        ...BranchPipelineOf<TSource>
+    ], MergeHttpResponses<TParentResponses, BranchResponsesOf<TSource>>> : false : false : false : false : false : false : false : false;
+}[keyof TTree & string] ? false : true : false;
+type HttpTreeConstraint<TDefinitions extends HttpRouteTree> = IsHttpTreeValid<TDefinitions> extends true ? unknown : {
+    readonly __invalidHttpRouteTree__: never;
 };
+declare function defineHttp<const TDefinition extends HttpProtocolDefinition>(definition: TDefinition & HttpPipelineConstraint<TDefinition> & HttpResponseConstraint<TDefinition> & HttpPathConstraint<TDefinition>): HttpProtocol<TDefinition>;
+type HttpProtocolGroup<TDefinitions extends HttpRouteTree> = ProtocolGroup<'http', FlatHttpProtocols<TDefinitions> extends infer TProtocols extends Record<string, ProtocolDescriptor<'http'>> ? TProtocols : never>;
 export interface HttpProtocolFactory extends ProtocolFactory<'http'> {
-    <const TDefinitions extends Record<string, HttpProtocolDefinition>>(definitions: TDefinitions & HttpDefinitionsConstraint<TDefinitions>): HttpProtocolGroup<TDefinitions>;
+    <const TDefinitions extends HttpRouteTree>(definitions: TDefinitions & HttpTreeConstraint<TDefinitions>): HttpProtocolGroup<TDefinitions>;
     readonly route: typeof defineHttp;
     readonly controller: TerminalLayerDescriptor<'http'>;
     readonly error: typeof httpError;
@@ -164,12 +304,10 @@ export declare const validate: Readonly<{
         readonly name: "validate.body";
     };
 }>;
-type ProceduresForHttp<TContract extends ContractDefinition> = {
+type ProceduresForHttp<TBinding extends ContractBinding, TContract extends ContractDefinition = ContractOfBinding<TBinding>> = {
     [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 HttpProtocolAt<TBinding extends ContractBinding, TProcedure extends keyof ContractOfBinding<TBinding>['procedures'], TContract extends ContractDefinition = ContractOfBinding<TBinding>> = TContract['procedures'][TProcedure]['protocols']['http' & keyof TContract['procedures'][TProcedure]['protocols']] extends infer TProtocol ? TProtocol extends HttpProtocol<any, any> ? TProtocol : 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;
@@ -218,8 +356,8 @@ type HttpControllerContextDefinition<TDefinition extends HttpProtocolDefinition>
     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']>>;
+export type ControllerOf<TBinding extends ContractBinding, TProtocol extends 'http', TProcedures extends ProceduresForHttp<TBinding> = ProceduresForHttp<TBinding>> = TProtocol extends 'http' ? {
+    [K in TProcedures]: (context: HttpControllerContext<HttpProtocolAt<TBinding, K>>) => DeclaredHttpResults<HttpProtocolAt<TBinding, K>['definition']['responses']> | Promise<DeclaredHttpResults<HttpProtocolAt<TBinding, K>['definition']['responses']>>;
 } : never;
 export type ContextOf<TController, TProcedure extends keyof TController> = TController[TProcedure] extends (context: infer TContext, ...args: any[]) => any ? TContext : never;
 export {};