@loutrejs/loutre 0.2.0 → 0.3.0

package/dist/application/openapi.d.ts

@@ -8,9 +8,15 @@ export interface OpenApiServer {
     readonly url: string;
     readonly description?: string;
 }
+export interface OpenApiOperationIdContext {
+    readonly procedure: string;
+    readonly method: string;
+    readonly path: string;
+}
 export interface GenerateOpenApiOptions {
     readonly info: OpenApiInfo;
     readonly servers?: readonly OpenApiServer[];
+    readonly operationId?: (context: OpenApiOperationIdContext) => string | undefined;
 }
 export interface OpenApiDocument {
     readonly openapi: '3.2.0';

package/dist/application/openapi.js

@@ -13,7 +13,7 @@ const FIXED_METHODS = new Set([
     'query',
 ]);
 export function generateOpenApi(application, options) {
-    const graph = assertValidCompilation(compileApplication({
+    assertValidCompilation(compileApplication({
         modules: application.modules,
         ...(application.arguments === undefined
             ? {}
@@ -21,11 +21,6 @@ export function generateOpenApi(application, options) {
         tasks: application.tasks,
         triggers: application.triggers,
     }));
-    const executable = new Set(graph.executions
-        .filter((execution) => execution.kind === 'protocol' && execution.protocol === 'http')
-        .map((execution) => execution.kind === 'protocol'
-        ? `${execution.implementation}\u0000${execution.procedure}`
-        : ''));
     const registry = new SchemaRegistry();
     const paths = {};
     const operationIds = new Set();
@@ -34,20 +29,15 @@ export function generateOpenApi(application, options) {
             if (implementation.protocol !== 'http')
                 continue;
             for (const procedure of implementation.procedures) {
-                if (!executable.has(`${implementation.name}\u0000${procedure}`))
-                    continue;
                 const protocol = implementation.contract.procedures[procedure]?.protocols.http;
                 if (!protocol || protocol.protocol !== 'http')
                     continue;
                 const typed = protocol;
                 const target = {
                     definition: typed.definition,
-                    ...(implementation.contract.name === undefined
-                        ? {}
-                        : { contractName: implementation.contract.name }),
                     procedure,
                 };
-                const operation = createOperation(target, registry, operationIds);
+                const operation = createOperation(target, registry, operationIds, options.operationId);
                 attachOperation(paths, typed.definition, operation);
             }
         }
@@ -62,12 +52,17 @@ export function generateOpenApi(application, options) {
         ...(Object.keys(schemas).length === 0 ? {} : { components: { schemas } }),
     };
 }
-function createOperation(target, registry, operationIds) {
+function createOperation(target, registry, operationIds, resolveOperationId) {
     const definition = target.definition;
-    const operationId = target.contractName
-        ? `${target.contractName}.${target.procedure}`
-        : undefined;
-    if (operationId) {
+    const operationId = resolveOperationId?.({
+        procedure: target.procedure,
+        method: definition.method,
+        path: definition.path,
+    });
+    if (operationId !== undefined) {
+        if (operationId.length === 0) {
+            throw openApiError('LUTRE_OPENAPI_OPERATION_ID_002', `operationId must not be empty for ${describeTarget(target)}`);
+        }
         if (operationIds.has(operationId)) {
             throw openApiError('LUTRE_OPENAPI_OPERATION_ID_001', `Duplicate operationId: ${operationId}`);
         }
@@ -322,7 +317,7 @@ function rebaseLocalDefinitions(schema, schemaComponentName) {
     return visit(schema);
 }
 function componentName(target, suffix) {
-    return sanitizeComponentName(`${target.contractName ?? 'AnonymousContract'}_${target.procedure}_${suffix}`);
+    return sanitizeComponentName(`${target.definition.method} ${target.definition.path} ${target.procedure} ${suffix}`);
 }
 function sanitizeComponentName(value) {
     const sanitized = value.replace(/[^A-Za-z0-9_.-]+/g, '_');
@@ -340,7 +335,7 @@ function escapeJsonPointer(value) {
     return value.replace(/~/g, '~0').replace(/\//g, '~1');
 }
 function describeTarget(target) {
-    return `${target.contractName ?? 'AnonymousContract'}.${target.procedure}`;
+    return `${target.definition.method.toUpperCase()} ${target.definition.path} (${target.procedure})`;
 }
 function dedupeJsonSchemas(schemas) {
     const seen = new Set();

package/dist/core/contract.d.ts

@@ -12,17 +12,57 @@ export interface ProcedureDefinition<TProtocols extends Record<string, ProtocolD
     readonly kind: 'procedure';
     readonly protocols: TProtocols;
 }
-export declare function procedure<const TProtocols extends Record<string, ProtocolDescriptor>>(definition: {
-    readonly protocols: TProtocols;
-}): ProcedureDefinition<TProtocols>;
+export interface ProtocolGroup<TName extends string = string, TProcedures extends Record<string, ProtocolDescriptor<TName>> = Record<string, ProtocolDescriptor<TName>>> {
+    readonly kind: 'protocol-group';
+    readonly protocol: TName;
+    readonly procedures: TProcedures;
+}
+export declare function protocolGroup<const TName extends string, const TProcedures extends Record<string, ProtocolDescriptor<TName>>>(protocol: TName, procedures: TProcedures): ProtocolGroup<TName, TProcedures>;
 export interface ContractDefinition<TProcedures extends Record<string, ProcedureDefinition> = Record<string, ProcedureDefinition>> {
     readonly kind: 'contract';
-    readonly name?: string;
     readonly procedures: TProcedures;
 }
-export declare function contract<const TProcedures extends Record<string, ProcedureDefinition>>(procedures: TProcedures & DispatchKeyUniquenessConstraint<TProcedures>, options?: {
-    readonly name?: string;
-}): ContractDefinition<TProcedures>;
+type ProcedureNamesOfGroup<TGroup> = TGroup extends ProtocolGroup<string, infer TProcedures> ? keyof TProcedures & string : never;
+type ProcedureNamesOfGroups<TGroups extends readonly ProtocolGroup[]> = ProcedureNamesOfGroup<TGroups[number]>;
+type ProtocolOfGroupProcedure<TGroup, TProcedure extends string> = TGroup extends ProtocolGroup<infer TProtocol, infer TProcedures> ? TProcedure extends keyof TProcedures ? {
+    readonly [K in TProtocol]: TProcedures[TProcedure];
+} : never : never;
+type ProceduresFromGroups<TGroups extends readonly ProtocolGroup[]> = {
+    [TProcedure in ProcedureNamesOfGroups<TGroups>]: ProcedureDefinition<UnionToIntersection<ProtocolOfGroupProcedure<TGroups[number], TProcedure>> extends infer TProtocols extends Record<string, ProtocolDescriptor> ? TProtocols : never>;
+};
+type NonEmptyArrayConstraint<TValues extends readonly unknown[]> = TValues extends readonly [] ? {
+    readonly __requiresAtLeastOneEntry__: never;
+} : unknown;
+type ProcedureProtocolKeysOfGroup<TGroup> = TGroup extends ProtocolGroup<infer TProtocol, infer TProcedures> ? `${keyof TProcedures & string}.${TProtocol}` : never;
+type DuplicateGroupProcedureProtocolKeys<TGroups extends readonly ProtocolGroup[], TSeen extends string = never> = number extends TGroups['length'] ? never : TGroups extends readonly [
+    infer THead extends ProtocolGroup,
+    ...infer TTail extends readonly ProtocolGroup[]
+] ? Extract<ProcedureProtocolKeysOfGroup<THead>, TSeen> | DuplicateGroupProcedureProtocolKeys<TTail, TSeen | ProcedureProtocolKeysOfGroup<THead>> : never;
+type GroupProcedureProtocolUniquenessConstraint<TGroups extends readonly ProtocolGroup[]> = [DuplicateGroupProcedureProtocolKeys<TGroups>] extends [never] ? unknown : {
+    readonly __duplicateProcedureProtocol__: DuplicateGroupProcedureProtocolKeys<TGroups>;
+};
+declare function defineContract<const TGroups extends readonly ProtocolGroup[]>(groups: TGroups & NonEmptyArrayConstraint<TGroups> & GroupProcedureProtocolUniquenessConstraint<TGroups> & DispatchKeyUniquenessConstraint<ProceduresFromGroups<TGroups>>): ContractDefinition<ProceduresFromGroups<TGroups>>;
+type ProcedureNamesOfContract<TContract> = TContract extends ContractDefinition<infer TProcedures> ? keyof TProcedures & string : never;
+type ProcedureNamesOfContracts<TContracts extends readonly ContractDefinition[]> = ProcedureNamesOfContract<TContracts[number]>;
+type ProtocolsOfContractProcedure<TContract, TProcedure extends string> = TContract extends ContractDefinition<infer TProcedures> ? TProcedure extends keyof TProcedures ? TProcedures[TProcedure]['protocols'] : never : never;
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type MergedProcedures<TContracts extends readonly ContractDefinition[]> = {
+    [TProcedure in ProcedureNamesOfContracts<TContracts>]: ProcedureDefinition<UnionToIntersection<ProtocolsOfContractProcedure<TContracts[number], TProcedure>> extends infer TProtocols extends Record<string, ProtocolDescriptor> ? TProtocols : never>;
+};
+type ProcedureProtocolKeysOfContract<TContract> = TContract extends ContractDefinition<infer TProcedures> ? {
+    [TProcedure in keyof TProcedures & string]: `${TProcedure}.${keyof TProcedures[TProcedure]['protocols'] & string}`;
+}[keyof TProcedures & string] : never;
+type DuplicateContractProcedureProtocolKeys<TContracts extends readonly ContractDefinition[], TSeen extends string = never> = number extends TContracts['length'] ? never : TContracts extends readonly [
+    infer THead extends ContractDefinition,
+    ...infer TTail extends readonly ContractDefinition[]
+] ? Extract<ProcedureProtocolKeysOfContract<THead>, TSeen> | DuplicateContractProcedureProtocolKeys<TTail, TSeen | ProcedureProtocolKeysOfContract<THead>> : never;
+type ContractProcedureProtocolUniquenessConstraint<TContracts extends readonly ContractDefinition[]> = [DuplicateContractProcedureProtocolKeys<TContracts>] extends [never] ? unknown : {
+    readonly __duplicateProcedureProtocol__: DuplicateContractProcedureProtocolKeys<TContracts>;
+};
+declare function mergeContracts<const TContracts extends readonly ContractDefinition[]>(contracts: TContracts & NonEmptyArrayConstraint<TContracts> & ContractProcedureProtocolUniquenessConstraint<TContracts> & DispatchKeyUniquenessConstraint<MergedProcedures<TContracts>>): ContractDefinition<MergedProcedures<TContracts>>;
+export declare const contract: typeof defineContract & {
+    merge: typeof mergeContracts;
+};
 type ProtocolDispatchEntries<TProcedures extends Record<string, ProcedureDefinition>> = {
     [TProcedure in keyof TProcedures & string]: {
         [TProtocol in keyof TProcedures[TProcedure]['protocols'] & string]: TProcedures[TProcedure]['protocols'][TProtocol] extends {

package/dist/core/contract.js

@@ -1,15 +1,64 @@
-export function procedure(definition) {
-    return { kind: 'procedure', protocols: definition.protocols };
+export function protocolGroup(protocol, procedures) {
+    return Object.freeze({
+        kind: 'protocol-group',
+        protocol,
+        procedures: Object.freeze({ ...procedures }),
+    });
 }
-export function contract(procedures, options = {}) {
-    assertUniqueDispatchKeys(procedures, options.name);
-    return {
+function defineContract(groups) {
+    if (groups.length === 0) {
+        throw new Error('contract([]) requires at least one protocol group');
+    }
+    const procedures = {};
+    for (const group of groups) {
+        for (const [procedureName, descriptor] of Object.entries(group.procedures)) {
+            const current = procedures[procedureName];
+            if (Object.hasOwn(current?.protocols ?? {}, group.protocol)) {
+                throw new Error(`Duplicate contract procedure protocol: ${procedureName}.${group.protocol}`);
+            }
+            procedures[procedureName] = {
+                kind: 'procedure',
+                protocols: {
+                    ...current?.protocols,
+                    [group.protocol]: descriptor,
+                },
+            };
+        }
+    }
+    assertUniqueDispatchKeys(procedures);
+    return Object.freeze({
+        kind: 'contract',
+        procedures: Object.freeze(procedures),
+    });
+}
+function mergeContracts(contracts) {
+    if (contracts.length === 0) {
+        throw new Error('contract.merge([]) requires at least one Contract');
+    }
+    const procedures = {};
+    for (const source of contracts) {
+        for (const [procedureName, procedureDefinition] of Object.entries(source.procedures)) {
+            const current = procedures[procedureName];
+            const protocols = { ...current?.protocols };
+            for (const [protocolName, descriptor] of Object.entries(procedureDefinition.protocols)) {
+                if (Object.hasOwn(protocols, protocolName)) {
+                    throw new Error(`Duplicate contract procedure protocol: ${procedureName}.${protocolName}`);
+                }
+                protocols[protocolName] = descriptor;
+            }
+            procedures[procedureName] = { kind: 'procedure', protocols };
+        }
+    }
+    assertUniqueDispatchKeys(procedures);
+    return Object.freeze({
         kind: 'contract',
-        ...(options.name === undefined ? {} : { name: options.name }),
-        procedures,
-    };
+        procedures: Object.freeze(procedures),
+    });
 }
-function assertUniqueDispatchKeys(procedures, contractName) {
+export const contract = Object.assign(defineContract, {
+    merge: mergeContracts,
+});
+function assertUniqueDispatchKeys(procedures) {
     const paths = new Map();
     for (const [procedureName, procedureDefinition] of Object.entries(procedures)) {
         for (const [protocolName, protocol] of Object.entries(procedureDefinition.protocols)) {
@@ -19,7 +68,7 @@ function assertUniqueDispatchKeys(procedures, contractName) {
             if (typeof dispatchKey !== 'string') {
                 throw new Error(`Protocol dispatchKey must be a string or null: ${procedureName}.${protocolName}`);
             }
-            const path = `${contractName ?? 'Contract'}.${procedureName}.${protocolName}`;
+            const path = `${procedureName}.${protocolName}`;
             const existing = paths.get(dispatchKey);
             if (existing) {
                 throw new Error(`Duplicate protocol dispatch key "${dispatchKey}" between ${existing} and ${path}`);

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const LOUTRE_VERSION = "0.2.0";
+export declare const LOUTRE_VERSION = "0.3.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // package manifestとのずれを避けるため、scripts/generate-version.mjsがbuild前に更新する。
-export const LOUTRE_VERSION = '0.2.0';
+export const LOUTRE_VERSION = '0.3.0';

package/dist/graph/compiler.d.ts

@@ -0,0 +1,4 @@
+import { type ApplicationCompilationInput } from './graph.js';
+import type { CompilationResult } from './ir.js';
+export declare function compileApplication(input: ApplicationCompilationInput): CompilationResult;
+export declare const buildApplicationGraph: typeof compileApplication;

package/dist/graph/compiler.js

@@ -0,0 +1,228 @@
+import { asModuleInstance, normalizeProvider, tokenName, } from '../core/index.js';
+import { compileApplication as compileBaseApplication, } from './graph.js';
+export function compileApplication(input) {
+    const base = compileBaseApplication(input);
+    const modules = collectModules(input.modules);
+    const moduleIds = new Map(modules.map((module, index) => [module, `module:${index + 1}`]));
+    const implementationModules = collectImplementationModules(modules, moduleIds);
+    const implementationNames = new Map(base.graph.implementations.map((implementation) => [
+        implementation.id,
+        implementation.name,
+    ]));
+    const graphModules = new Map(base.graph.modules.map((module) => [module.id, module]));
+    const executionModules = new Map();
+    for (const execution of base.graph.executions) {
+        if (execution.kind !== 'protocol')
+            continue;
+        const implementationName = implementationNames.get(execution.implementation);
+        const module = implementationName
+            ? implementationModules.get(implementationName)
+            : undefined;
+        if (!module)
+            continue;
+        executionModules.set(`${execution.contract}:${execution.procedure}:${execution.protocol}`, module);
+    }
+    const providerModules = collectProviderModules(modules, moduleIds);
+    const nodes = base.graph.nodes.map((node) => {
+        const module = node.module ??
+            providerModules.get(node.label) ??
+            moduleForImplementation(node, implementationModules) ??
+            moduleForLifecycle(node) ??
+            moduleForLayer(node, executionModules);
+        if (!module)
+            return node;
+        const owner = graphModules.get(module);
+        if (!owner)
+            return node;
+        return {
+            ...node,
+            module,
+            visibility: owner.exports.includes(node.label) ? 'exported' : 'private',
+        };
+    });
+    const diagnostics = [
+        ...base.diagnostics,
+        ...validateModuleExports(base.graph.modules),
+        ...validateModuleVisibility(base.graph, nodes),
+    ];
+    const graph = {
+        ...base.graph,
+        nodes,
+        diagnostics,
+    };
+    return { graph, diagnostics };
+}
+export const buildApplicationGraph = compileApplication;
+function collectModules(roots) {
+    const modules = [];
+    const seen = new Set();
+    const visit = (candidate) => {
+        const module = asModuleInstance(candidate);
+        if (seen.has(module))
+            return;
+        seen.add(module);
+        for (const imported of module.definition.imports ?? [])
+            visit(imported);
+        modules.push(module);
+    };
+    for (const root of roots)
+        visit(root);
+    return modules;
+}
+function collectProviderModules(modules, moduleIds) {
+    const result = new Map();
+    const ambiguous = new Set();
+    for (const module of modules) {
+        const moduleId = moduleIds.get(module);
+        if (!moduleId)
+            continue;
+        for (const declaration of module.definition.providers ?? []) {
+            const provider = normalizeProvider(declaration);
+            const labels = [
+                tokenName(provider.provide),
+                ...(provider.kind === 'class' ? [provider.useClass.name] : []),
+                ...(provider.kind === 'conditional'
+                    ? Reflect.ownKeys(provider.mapping).flatMap((key) => {
+                        const candidate = provider.mapping[key];
+                        return candidate ? [candidate.name] : [];
+                    })
+                    : []),
+            ];
+            for (const label of labels) {
+                const current = result.get(label);
+                if (current && current !== moduleId)
+                    ambiguous.add(label);
+                else
+                    result.set(label, moduleId);
+            }
+        }
+    }
+    for (const label of ambiguous)
+        result.delete(label);
+    return result;
+}
+function collectImplementationModules(modules, moduleIds) {
+    const result = new Map();
+    const ambiguous = new Set();
+    for (const module of modules) {
+        const moduleId = moduleIds.get(module);
+        if (!moduleId)
+            continue;
+        for (const implementation of module.definition.implementations ?? []) {
+            const current = result.get(implementation.name);
+            if (current && current !== moduleId)
+                ambiguous.add(implementation.name);
+            else
+                result.set(implementation.name, moduleId);
+        }
+    }
+    for (const name of ambiguous)
+        result.delete(name);
+    return result;
+}
+function moduleForImplementation(node, modules) {
+    return node.kind === 'implementation' ? modules.get(node.label) : undefined;
+}
+function moduleForLifecycle(node) {
+    if (node.kind !== 'framework' || !node.id.startsWith('lifecycle:module:')) {
+        return undefined;
+    }
+    const match = /^lifecycle:(module:\d+):/.exec(node.id);
+    return match?.[1];
+}
+function moduleForLayer(node, executionModules) {
+    if (node.kind !== 'layer')
+        return undefined;
+    const match = /^layer:(contract:\d+)\/([^/]+)\/([^/]+)\//.exec(node.id);
+    if (!match)
+        return undefined;
+    const [, contract, procedure, protocol] = match;
+    return executionModules.get(`${contract}:${procedure}:${protocol}`);
+}
+function validateModuleExports(modules) {
+    const byId = new Map(modules.map((module) => [module.id, module]));
+    return modules.flatMap((module) => module.exports.flatMap((token) => declaresToken(module, token) ||
+        canResolveExport(module, token, byId, new Set())
+        ? []
+        : [
+            {
+                code: 'LUTRE_MODULE_EXPORT_UNRESOLVED',
+                message: `${describeModule(module)} exports ${token}, but the token is neither declared nor re-exported from an imported Module.`,
+                path: `${module.id}.exports.${token}`,
+            },
+        ]));
+}
+function declaresToken(module, token) {
+    return module.providers.includes(token) || module.environment.includes(token);
+}
+function canResolveExport(source, token, modules, visited) {
+    if (visited.has(source.id))
+        return false;
+    visited.add(source.id);
+    for (const importedId of source.imports) {
+        const imported = modules.get(importedId);
+        if (!imported || !imported.exports.includes(token))
+            continue;
+        if (declaresToken(imported, token))
+            return true;
+        if (canResolveExport(imported, token, modules, new Set(visited)))
+            return true;
+    }
+    return false;
+}
+function validateModuleVisibility(graph, nodes) {
+    const modules = new Map(graph.modules.map((module) => [module.id, module]));
+    const nodesById = new Map(nodes.map((node) => [node.id, node]));
+    const seen = new Set();
+    const diagnostics = [];
+    for (const edge of graph.edges) {
+        const consumer = nodesById.get(edge.from);
+        const dependency = nodesById.get(edge.to);
+        if (!consumer?.module ||
+            !dependency?.module ||
+            consumer.module === dependency.module ||
+            !modules.has(consumer.module) ||
+            !modules.has(dependency.module)) {
+            continue;
+        }
+        const key = `${consumer.id}->${dependency.id}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        if (isTokenVisibleFrom(consumer.module, dependency.module, dependency.label, modules)) {
+            continue;
+        }
+        diagnostics.push({
+            code: 'LUTRE_MODULE_VISIBILITY',
+            message: `${consumer.label} in ${describeModuleId(consumer.module, modules)} depends on private ${dependency.label} from ${describeModuleId(dependency.module, modules)}. Export the dependency and import its Module explicitly.`,
+            path: consumer.id,
+        });
+    }
+    return diagnostics;
+}
+function isTokenVisibleFrom(sourceId, targetId, token, modules, visited = new Set()) {
+    if (visited.has(sourceId))
+        return false;
+    visited.add(sourceId);
+    const source = modules.get(sourceId);
+    if (!source)
+        return false;
+    for (const importedId of source.imports) {
+        const imported = modules.get(importedId);
+        if (!imported || !imported.exports.includes(token))
+            continue;
+        if (importedId === targetId)
+            return true;
+        if (isTokenVisibleFrom(importedId, targetId, token, modules, new Set(visited))) {
+            return true;
+        }
+    }
+    return false;
+}
+function describeModule(module) {
+    return module.name ?? module.description ?? module.id;
+}
+function describeModuleId(id, modules) {
+    const module = modules.get(id);
+    return module ? describeModule(module) : id;
+}

package/dist/graph/graph.js

@@ -38,17 +38,29 @@ export function compileApplication(input) {
     validateNamedDescriptors(queues, 'LUTRE_QUEUE_DUPLICATE', diagnostics);
     validateCronTriggers(triggers, diagnostics);
     diagnostics.push(...validateQueueDrivers(input.modules, queueTriggers));
-    const contractNames = new Map();
-    let contractSequence = 0;
-    const nameContract = (contract) => {
-        const current = contractNames.get(contract);
+    const contractIds = new Map();
+    const idContract = (contract) => {
+        const current = contractIds.get(contract);
         if (current)
             return current;
-        const name = contract.name ?? `Contract${++contractSequence}`;
-        contractNames.set(contract, name);
-        return name;
+        const id = `contract:${contractIds.size + 1}`;
+        contractIds.set(contract, id);
+        return id;
+    };
+    const implementationIds = new Map();
+    const idImplementation = (implementation) => {
+        const current = implementationIds.get(implementation);
+        if (current)
+            return current;
+        const id = `implementation:${implementationIds.size + 1}`;
+        implementationIds.set(implementation, id);
+        return id;
     };
     const descriptors = modules.flatMap((module) => module.definition.implementations ?? []);
+    for (const implementation of new Set(descriptors)) {
+        idContract(implementation.contract);
+        idImplementation(implementation);
+    }
     const targets = [];
     for (const implementation of descriptors) {
         for (const procedureName of implementation.procedures) {
@@ -58,13 +70,14 @@ export function compileApplication(input) {
                 diagnostics.push({
                     code: 'LUTRE_IMPL_003',
                     message: `${procedureName} is not declared for protocol ${implementation.protocol}`,
-                    path: `${nameContract(implementation.contract)}.${procedureName}.${implementation.protocol}`,
+                    path: `${idContract(implementation.contract)}.${procedureName}.${implementation.protocol}`,
                 });
                 continue;
             }
             targets.push({
                 implementation,
-                contractName: nameContract(implementation.contract),
+                contractId: idContract(implementation.contract),
+                implementationId: idImplementation(implementation),
                 procedure: procedureName,
                 protocol: implementation.protocol,
                 dispatchKey: protocol.dispatchKey,
@@ -77,28 +90,27 @@ export function compileApplication(input) {
         }
     }
     validateDispatchKeys(targets, diagnostics);
-    validateCoverage(descriptors, contractNames, diagnostics);
+    validateCoverage(descriptors, contractIds, diagnostics);
     validateDuplicateProviders(modules, diagnostics);
     const tokensById = collectCustomTokens(providers, targets, diagnostics);
     const contextKeysByName = collectContextKeys(targets, diagnostics);
     const pipelines = [];
-    const implementations = [];
     for (const target of targets) {
         validatePipeline(target, diagnostics);
         pipelines.push({
-            contract: target.contractName,
+            contract: target.contractId,
             procedure: target.procedure,
             protocol: target.protocol,
             layers: target.pipeline.map(toLayerIR),
         });
-        implementations.push({
-            contract: target.contractName,
-            procedure: target.procedure,
-            protocol: target.protocol,
-            implementation: target.implementation.name,
-            method: target.procedure,
-        });
     }
+    const implementations = [...new Set(descriptors)].map((implementation) => ({
+        id: idImplementation(implementation),
+        name: implementation.name,
+        contract: idContract(implementation.contract),
+        protocol: implementation.protocol,
+        procedures: implementation.procedures,
+    }));
     const dependencyGraph = buildDependencyGraph(modules, descriptors, targets, tasks, diagnostics);
     const probedTokenIds = dependencyGraph.nodes
         .filter((node) => node.kind === 'token')
@@ -150,7 +162,7 @@ export function compileApplication(input) {
         })),
         tokens: [...new Set([...tokensById.keys(), ...probedTokenIds])].map((id) => ({ id })),
         contextKeys: [...contextKeysByName.keys()].map((name) => ({ name })),
-        contracts: [...contractNames.values()],
+        contracts: [...contractIds.entries()].map(([contract, id]) => toContractIR(contract, id)),
         pipelines,
         implementations,
         tasks: tasks.map((task) => ({
@@ -161,12 +173,12 @@ export function compileApplication(input) {
         queues: queues.map(toQueueIR),
         executions: [
             ...targets.map((target) => ({
-                id: `protocol:${target.protocol}:${target.contractName}.${target.procedure}`,
+                id: `protocol:${target.contractId}:${target.procedure}:${target.protocol}`,
                 kind: 'protocol',
                 protocol: target.protocol,
-                contract: target.contractName,
+                contract: target.contractId,
                 procedure: target.procedure,
-                implementation: target.implementation.name,
+                implementation: target.implementationId,
             })),
             ...publicTasks.map((task) => ({
                 id: `task:${task.name}`,
@@ -177,7 +189,7 @@ export function compileApplication(input) {
         ],
         capabilities: [
             ...targets.flatMap((target) => {
-                const requiredBy = `${target.contractName}.${target.procedure}`;
+                const requiredBy = `${target.contractId}.${target.procedure}`;
                 return [
                     { name: 'crypto.random', scope: 'execution', requiredBy },
                     ...(target.protocol === 'http'
@@ -257,7 +269,7 @@ function validateDispatchKeys(targets, diagnostics) {
     for (const target of targets) {
         if (target.dispatchKey === null)
             continue;
-        const path = `${target.contractName}.${target.procedure}.${target.protocol}`;
+        const path = `${target.contractId}.${target.procedure}.${target.protocol}`;
         const existing = targetsByKey.get(target.dispatchKey);
         if (existing) {
             if (existing.implementation.contract === target.implementation.contract &&
@@ -265,7 +277,7 @@ function validateDispatchKeys(targets, diagnostics) {
                 existing.protocol === target.protocol) {
                 continue;
             }
-            const existingPath = `${existing.contractName}.${existing.procedure}.${existing.protocol}`;
+            const existingPath = `${existing.contractId}.${existing.procedure}.${existing.protocol}`;
             diagnostics.push({
                 code: 'LUTRE_PROTOCOL_001',
                 message: `Duplicate protocol dispatch key "${target.dispatchKey}": ${existingPath}, ${path}`,
@@ -736,7 +748,7 @@ function buildDependencyGraph(modules, descriptors, targets, tasks, diagnostics)
             const definition = layerDefinitionOf(item);
             const consumer = {
                 kind: 'layer-consumer',
-                id: `layer:${target.contractName}:${target.procedure}:${target.protocol}:${indexPath.join('.')}`,
+                id: `layer:${target.contractId}/${target.procedure}/${target.protocol}/${indexPath.join('.')}`,
                 name: definition.name,
             };
             if (!nodes.some(({ id }) => id === consumer.id)) {
@@ -847,7 +859,7 @@ function collectCustomTokens(providers, targets, diagnostics) {
 function collectContextKeys(targets, diagnostics) {
     const keys = new Map();
     for (const target of targets) {
-        const path = `${target.contractName}.${target.procedure}.${target.protocol}`;
+        const path = `${target.contractId}.${target.procedure}.${target.protocol}`;
         visitPipelineItems(target.pipeline, (item) => {
             if (item.kind !== 'layer')
                 return;
@@ -867,6 +879,19 @@ function collectContextKeys(targets, diagnostics) {
     }
     return keys;
 }
+function toContractIR(contract, id) {
+    return {
+        id,
+        procedures: Object.entries(contract.procedures).map(([procedureName, procedure]) => ({
+            name: procedureName,
+            protocols: Object.entries(procedure.protocols).map(([protocolName, protocol]) => ({
+                name: protocolName,
+                dispatchKey: protocol.dispatchKey,
+                interaction: protocol.interaction ?? 'unary',
+            })),
+        })),
+    };
+}
 export function assertValidCompilation(result) {
     if (result.diagnostics.length > 0) {
         throw new StaticValidationError(result.diagnostics, result.graph);
@@ -889,7 +914,7 @@ function collectModules(roots) {
         visit(root);
     return modules;
 }
-function validateCoverage(implementations, contractNames, diagnostics) {
+function validateCoverage(implementations, contractIds, diagnostics) {
     const contracts = new Set(implementations.map((implementation) => implementation.contract));
     for (const contract of contracts) {
         const protocols = new Set(Object.values(contract.procedures).flatMap((procedure) => Object.keys(procedure.protocols)));
@@ -900,7 +925,7 @@ function validateCoverage(implementations, contractNames, diagnostics) {
                 const covering = implementations.filter((implementation) => implementation.contract === contract &&
                     implementation.protocol === protocol &&
                     implementation.procedures.includes(procedureName));
-                const path = `${contractNames.get(contract) ?? 'Contract'}.${procedureName}.${protocol}`;
+                const path = `${contractIds.get(contract) ?? 'contract:unknown'}.${procedureName}.${protocol}`;
                 if (covering.length === 0) {
                     diagnostics.push({
                         code: 'LUTRE_IMPL_001',
@@ -920,7 +945,7 @@ function validateCoverage(implementations, contractNames, diagnostics) {
     }
 }
 function validatePipeline(target, diagnostics) {
-    const path = `${target.contractName}.${target.procedure}.${target.protocol}`;
+    const path = `${target.contractId}.${target.procedure}.${target.protocol}`;
     const flattened = [];
     visitPipelineItems(target.pipeline, (item, indexPath) => {
         flattened.push({ item, indexPath });

package/dist/graph/index.d.ts

@@ -1,2 +1,3 @@
 export * from './ir.js';
-export * from './graph.js';
+export { StaticValidationError, assertValidCompilation, validateGraph, type ApplicationCompilationInput, } from './graph.js';
+export { buildApplicationGraph, compileApplication } from './compiler.js';

package/dist/graph/index.js

@@ -1,2 +1,3 @@
 export * from './ir.js';
-export * from './graph.js';
+export { StaticValidationError, assertValidCompilation, validateGraph, } from './graph.js';
+export { buildApplicationGraph, compileApplication } from './compiler.js';

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/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/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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loutrejs/loutre",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "MIT",
   "type": "module",
   "files": [