@loutrejs/loutre 0.4.1 → 0.5.0

package/dist/application/openapi.js

@@ -1,4 +1,5 @@
 import { supportsJsonSchema, } from '../core/index.js';
+import { resolveContractProcedureIdentity } from '../core/contract-internal.js';
 import { assertValidCompilation, compileApplication } from '../graph/index.js';
 import { httpRequestBodyContentType, httpRequestBodySchema, } from '../http/index.js';
 const FIXED_METHODS = new Set([
@@ -35,7 +36,7 @@ export function generateOpenApi(application, options) {
                 const typed = protocol;
                 const target = {
                     definition: typed.definition,
-                    procedure,
+                    procedure: resolveContractProcedureIdentity(implementation.contract, procedure).procedure,
                 };
                 const operation = createOperation(target, registry, operationIds, options.operationId);
                 attachOperation(paths, typed.definition, operation);

package/dist/core/context-key.d.ts

@@ -8,7 +8,9 @@ export type ContextKeyValue<TKey> = TKey extends ContextKey<string, infer TValue
 export type ContextProperties<TKeys extends readonly ContextKey[]> = {
     readonly [TKey in TKeys[number] as TKey['name']]: ContextKeyValue<TKey>;
 };
-export declare function contextKey<const TName extends string>(name: TName): {
+type ContextKeyNameConstraint<TName extends string> = TName extends '' | '__proto__' ? never : unknown;
+export declare function contextKey<const TName extends string>(name: TName & ContextKeyNameConstraint<TName>): {
     of<TValue>(): ContextKey<TName, TValue>;
 };
 export declare function contextKeyName(key: ContextKey): string;
+export {};

package/dist/core/context-key.js

@@ -1,4 +1,7 @@
 export function contextKey(name) {
+    if (name.length === 0 || name === '__proto__') {
+        throw new Error(`Invalid Context Key name: ${JSON.stringify(name)}`);
+    }
     return {
         of() {
             return Object.freeze({

package/dist/core/contract-internal.d.ts

@@ -0,0 +1,22 @@
+import type { ContractDefinition } from './contract.js';
+export declare const protocolNamespaceBuilder: unique symbol;
+export declare const protocolNamespaceType: unique symbol;
+export declare const contractNodeBinding: unique symbol;
+export declare const contractNodeKindType: unique symbol;
+export declare const contractNodeMetadata: unique symbol;
+export interface ContractNodeMetadata {
+    readonly kind: 'leaf' | 'branch';
+    readonly root: ContractDefinition;
+    readonly path: readonly string[];
+    readonly procedures: Readonly<Record<string, string>>;
+}
+export declare function contractNodeMetadataOf(contract: ContractDefinition): ContractNodeMetadata | undefined;
+export declare function contractRootOf(contract: ContractDefinition): ContractDefinition;
+export declare function contractProcedurePathOf(contract: ContractDefinition, procedure: string): string;
+export interface ContractProcedureIdentity {
+    readonly contract: ContractDefinition;
+    readonly procedure: string;
+}
+export declare function resolveContractProcedureIdentity(contract: ContractDefinition, procedure: string, applicationContract?: ContractDefinition): ContractProcedureIdentity;
+export declare function contractNodePathOf(contract: ContractDefinition): readonly string[] | undefined;
+export declare function contractOfBinding(value: unknown): ContractDefinition;

package/dist/core/contract-internal.js

@@ -0,0 +1,61 @@
+export const protocolNamespaceBuilder = Symbol('loutre.protocol-namespace-builder');
+export const protocolNamespaceType = Symbol('loutre.protocol-namespace-type');
+export const contractNodeBinding = Symbol.for('loutre.contract-node-binding');
+export const contractNodeKindType = Symbol('loutre.contract-node-kind-type');
+export const contractNodeMetadata = Symbol.for('loutre.contract-node-metadata');
+export function contractNodeMetadataOf(contract) {
+    return contractNodeMetadata in contract
+        ? contract[contractNodeMetadata]
+        : undefined;
+}
+export function contractRootOf(contract) {
+    return contractNodeMetadata in contract
+        ? contract[contractNodeMetadata].root
+        : contract;
+}
+export function contractProcedurePathOf(contract, procedure) {
+    if (!(contractNodeMetadata in contract))
+        return procedure;
+    return (contract[contractNodeMetadata].procedures[procedure] ?? procedure);
+}
+export function resolveContractProcedureIdentity(contract, procedure, applicationContract) {
+    if (applicationContract && contract === applicationContract) {
+        return { contract: applicationContract, procedure };
+    }
+    const canonicalProcedure = contractProcedurePathOf(contract, procedure);
+    if (applicationContract) {
+        const applicationNode = contractNodeMetadataOf(applicationContract);
+        const implementationNode = contractNodeMetadataOf(contract);
+        if (applicationNode &&
+            implementationNode &&
+            applicationNode.root === implementationNode.root &&
+            isContractNodePathPrefix(applicationNode.path, implementationNode.path)) {
+            const prefix = applicationNode.path.slice(1).join('.');
+            const relativeProcedure = canonicalProcedure.startsWith(`${prefix}.`)
+                ? canonicalProcedure.slice(prefix.length + 1)
+                : canonicalProcedure;
+            return { contract: applicationContract, procedure: relativeProcedure };
+        }
+    }
+    return {
+        contract: contractRootOf(contract),
+        procedure: canonicalProcedure,
+    };
+}
+function isContractNodePathPrefix(prefix, candidate) {
+    return (prefix.length <= candidate.length &&
+        prefix.every((segment, index) => candidate[index] === segment));
+}
+export function contractNodePathOf(contract) {
+    return contractNodeMetadata in contract
+        ? contract[contractNodeMetadata].path
+        : undefined;
+}
+export function contractOfBinding(value) {
+    if (typeof value === 'object' &&
+        value !== null &&
+        contractNodeBinding in value) {
+        return value[contractNodeBinding];
+    }
+    return value;
+}

package/dist/core/contract.d.ts

@@ -1,3 +1,4 @@
+import { contractNodeBinding, contractNodeKindType, protocolNamespaceType } from './contract-internal.js';
 export interface ProtocolDescriptor<TName extends string = string, TContext = unknown, TResult = unknown, TDispatchKey extends string | null = string | null, TCapabilities extends readonly string[] = readonly string[]> {
     readonly kind: 'protocol';
     readonly protocol: TName;
@@ -22,6 +23,12 @@ export interface ContractDefinition<TProcedures extends Record<string, Procedure
     readonly kind: 'contract';
     readonly procedures: TProcedures;
 }
+export interface ResolvedContractNode<TContract extends ContractDefinition = ContractDefinition, TKind extends 'leaf' | 'branch' = 'leaf' | 'branch'> {
+    readonly [contractNodeBinding]: TContract;
+    readonly [contractNodeKindType]: TKind;
+}
+export type ContractBinding = ContractDefinition | ResolvedContractNode;
+export type ContractOfBinding<TBinding extends ContractBinding> = TBinding extends ResolvedContractNode<infer TContract> ? TContract : TBinding extends ContractDefinition ? TBinding : never;
 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 ? {
@@ -30,39 +37,39 @@ type ProtocolOfGroupProcedure<TGroup, TProcedure extends string> = TGroup extend
 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 ProtocolNamespaceOfGroup<TGroup> = TGroup extends {
+    readonly protocol: infer TProtocol extends string;
+    readonly procedures: infer TProcedures;
+} ? TProcedures extends object ? TProcedures[keyof TProcedures] extends {
+    readonly [protocolNamespaceType]: infer TNamespace;
+} ? [TNamespace] extends [never] ? never : {
+    readonly [K in TProtocol]: TNamespace;
+} : never : never : never;
+type ProtocolNamespaceNodeKeysOfGroup<TGroup> = ProtocolNamespaceOfGroup<TGroup> extends infer TNamespaces ? TNamespaces extends Readonly<Record<string, unknown>> ? {
+    [TProtocol in keyof TNamespaces & string]: TNamespaces[TProtocol] extends object ? `${TProtocol}.${keyof TNamespaces[TProtocol] & string}` : never;
+}[keyof TNamespaces & string] : never : never;
+type DuplicateGroupProtocolNamespaceNodeKeys<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<ProtocolNamespaceNodeKeysOfGroup<THead>, TSeen> | DuplicateGroupProtocolNamespaceNodeKeys<TTail, TSeen | ProtocolNamespaceNodeKeysOfGroup<THead>> : never;
+type ProtocolNamespacesOfGroups<TGroups extends readonly ProtocolGroup[]> = [
+    ProtocolNamespaceOfGroup<TGroups[number]>
+] extends [never] ? unknown : UnionToIntersection<ProtocolNamespaceOfGroup<TGroups[number]>>;
+type ContractFromGroups<TGroups extends readonly ProtocolGroup[]> = ContractDefinition<ProceduresFromGroups<TGroups>> & ProtocolNamespacesOfGroups<TGroups>;
+type ContractGroupsOf<TGroups extends readonly unknown[]> = TGroups extends readonly ProtocolGroup[] ? TGroups : never;
+type ContractArgumentValidation<TGroups extends readonly unknown[]> = TGroups extends readonly [] ? readonly [error: 'contract requires at least one protocol group'] : TGroups extends readonly ProtocolGroup[] ? [DuplicateGroupProcedureProtocolKeys<TGroups>] extends [never] ? [DuplicateGroupProtocolNamespaceNodeKeys<TGroups>] extends [never] ? [
+    DuplicateDispatchKeys<ProtocolDispatchEntries<ProceduresFromGroups<TGroups>>>
+] extends [never] ? readonly [] : readonly [error: 'contract contains duplicate dispatch keys'] : readonly [
+    error: 'contract contains duplicate protocol namespace nodes'
+] : readonly [error: 'contract contains duplicate procedure protocols'] : readonly [error: 'contract entries must be protocol groups'];
+declare function defineContract<const TGroups extends readonly unknown[]>(groups: TGroups, ...validation: ContractArgumentValidation<TGroups>): ContractFromGroups<ContractGroupsOf<TGroups>>;
 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;
-};
+export declare const contract: typeof defineContract;
 type ProtocolDispatchEntries<TProcedures extends Record<string, ProcedureDefinition>> = {
     [TProcedure in keyof TProcedures & string]: {
         [TProtocol in keyof TProcedures[TProcedure]['protocols'] & string]: TProcedures[TProcedure]['protocols'][TProtocol] extends {
@@ -81,11 +88,6 @@ type DuplicateDispatchKeys<TEntries, TAllEntries = TEntries> = TEntries extends
 }> extends {
     readonly path: infer TPath;
 } ? TPath : never> extends true ? TKey : never : never;
-type DispatchKeyUniquenessConstraint<TProcedures extends Record<string, ProcedureDefinition>> = [DuplicateDispatchKeys<ProtocolDispatchEntries<TProcedures>>] extends [
-    never
-] ? unknown : {
-    readonly __duplicateProtocolDispatchKey__: DuplicateDispatchKeys<ProtocolDispatchEntries<TProcedures>>;
-};
 export type ContractProcedures<TContract extends ContractDefinition> = TContract['procedures'];
 export interface ProtocolFactory<TName extends string, TCapabilities extends readonly string[] = readonly string[]> {
     readonly protocol: TName;

package/dist/core/contract.js

@@ -1,3 +1,4 @@
+import { contractNodeBinding, contractNodeKindType, protocolNamespaceBuilder, protocolNamespaceType, } from './contract-internal.js';
 export function protocolGroup(protocol, procedures) {
     return Object.freeze({
         kind: 'protocol-group',
@@ -5,7 +6,7 @@ export function protocolGroup(protocol, procedures) {
         procedures: Object.freeze({ ...procedures }),
     });
 }
-function defineContract(groups) {
+function defineContract(groups, ..._validation) {
     if (groups.length === 0) {
         throw new Error('contract([]) requires at least one protocol group');
     }
@@ -26,38 +27,46 @@ function defineContract(groups) {
         }
     }
     assertUniqueDispatchKeys(procedures);
-    return Object.freeze({
+    const resolved = {
         kind: 'contract',
         procedures: Object.freeze(procedures),
-    });
-}
-function mergeContracts(contracts) {
-    if (contracts.length === 0) {
-        throw new Error('contract.merge([]) requires at least one Contract');
+    };
+    const namespaceBuilders = [];
+    for (const group of groups) {
+        const build = group[protocolNamespaceBuilder];
+        if (typeof build !== 'function')
+            continue;
+        namespaceBuilders.push({
+            protocol: group.protocol,
+            build: build,
+        });
     }
-    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;
+    applyProtocolNamespaces(resolved, namespaceBuilders);
+    return Object.freeze(resolved);
+}
+function applyProtocolNamespaces(resolved, builders) {
+    for (const { protocol, build } of builders) {
+        const namespace = build(resolved);
+        const current = resolved[protocol];
+        if (current === undefined) {
+            resolved[protocol] = namespace;
+            continue;
+        }
+        if (!isRecord(current) || !isRecord(namespace)) {
+            throw new Error(`Duplicate contract protocol namespace: ${protocol}`);
+        }
+        for (const name of Object.keys(namespace)) {
+            if (Object.hasOwn(current, name)) {
+                throw new Error(`Duplicate contract protocol namespace node: ${protocol}.${name}`);
             }
-            procedures[procedureName] = { kind: 'procedure', protocols };
         }
+        resolved[protocol] = Object.freeze({ ...current, ...namespace });
     }
-    assertUniqueDispatchKeys(procedures);
-    return Object.freeze({
-        kind: 'contract',
-        procedures: Object.freeze(procedures),
-    });
 }
-export const contract = Object.assign(defineContract, {
-    merge: mergeContracts,
-});
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export const contract = defineContract;
 function assertUniqueDispatchKeys(procedures) {
     const paths = new Map();
     for (const [procedureName, procedureDefinition] of Object.entries(procedures)) {

package/dist/core/implementation.d.ts

@@ -1,8 +1,9 @@
-import type { ContractDefinition, ContractProcedures, ProtocolDescriptor, ProtocolFactory } from './contract.js';
-type ProcedureNamesForProtocol<TContract extends ContractDefinition, TProtocol extends string> = {
+import type { ContractDefinition, ContractOfBinding, ResolvedContractNode, ContractProcedures, ProtocolDescriptor, ProtocolFactory } from './contract.js';
+type ImplementationBinding = ContractDefinition | ResolvedContractNode<ContractDefinition, 'leaf'>;
+type ProcedureNamesForProtocol<TBinding extends ImplementationBinding, TProtocol extends string, TContract extends ContractDefinition = ContractOfBinding<TBinding>> = {
     [K in keyof ContractProcedures<TContract>]: TProtocol extends keyof ContractProcedures<TContract>[K]['protocols'] ? K : never;
 }[keyof ContractProcedures<TContract>] & string;
-type ImplementationRuntimeShape<TContract extends ContractDefinition, TProtocol extends string, TProcedures extends string> = {
+type ImplementationRuntimeShape<TBinding extends ImplementationBinding, TProtocol extends string, TProcedures extends string, TContract extends ContractDefinition = ContractOfBinding<TBinding>> = {
     [K in TProcedures]: ContractProcedures<TContract>[K]['protocols'][TProtocol & keyof ContractProcedures<TContract>[K]['protocols']] extends ProtocolDescriptor<TProtocol, infer TContext, infer TResult, any, any> ? (context: TContext) => TResult | Promise<TResult> : never;
 };
 export interface ImplementationDescriptor<TContract extends ContractDefinition = ContractDefinition, TProtocol extends string = string, TProcedures extends readonly string[] = readonly string[], TRuntime extends object = object, TCapabilities extends readonly string[] = readonly string[]> {
@@ -14,21 +15,30 @@ export interface ImplementationDescriptor<TContract extends ContractDefinition =
     readonly procedures: TProcedures;
     readonly factory: () => TRuntime;
 }
-type AvailableProtocolConstraint<TContract extends ContractDefinition, TProtocol extends string, TCapabilities extends readonly string[]> = [ProcedureNamesForProtocol<TContract, TProtocol>] extends [never] ? never : ProtocolFactory<TProtocol, TCapabilities>;
-type FullImplementationDeclaration<TContract extends ContractDefinition, TProtocol extends string, TCapabilities extends readonly string[]> = {
+type AvailableProtocolConstraint<TBinding extends ImplementationBinding, TProtocol extends string, TCapabilities extends readonly string[]> = [ProcedureNamesForProtocol<TBinding, TProtocol>] extends [never] ? never : ProtocolFactory<TProtocol, TCapabilities>;
+type FullImplementationDeclaration<TBinding extends ImplementationBinding, TProtocol extends string, TCapabilities extends readonly string[]> = {
     readonly name: string;
-    readonly contract: TContract;
-    readonly protocol: AvailableProtocolConstraint<TContract, TProtocol, TCapabilities>;
+    readonly contract: TBinding;
+    readonly protocol: AvailableProtocolConstraint<TBinding, TProtocol, TCapabilities>;
     readonly procedures?: never;
-    readonly factory: () => ImplementationRuntimeShape<TContract, TProtocol, ProcedureNamesForProtocol<TContract, TProtocol>>;
+    readonly factory: () => ImplementationRuntimeShape<TBinding, TProtocol, ProcedureNamesForProtocol<TBinding, TProtocol>>;
+};
+type DuplicateProcedureNames<TProcedures extends readonly string[], TSeen extends string = never> = number extends TProcedures['length'] ? never : TProcedures extends readonly [
+    infer THead extends string,
+    ...infer TTail extends readonly string[]
+] ? THead extends TSeen ? THead | DuplicateProcedureNames<TTail, TSeen> : DuplicateProcedureNames<TTail, TSeen | THead> : never;
+type UniqueProcedureSelectionConstraint<TProcedures extends readonly string[]> = [
+    DuplicateProcedureNames<TProcedures>
+] extends [never] ? unknown : {
+    readonly __duplicateImplementationProcedure__: never;
 };
-type PartialImplementationDeclaration<TContract extends ContractDefinition, TProtocol extends string, TProcedures extends readonly ProcedureNamesForProtocol<TContract, TProtocol>[], TCapabilities extends readonly string[]> = {
+type PartialImplementationDeclaration<TBinding extends ImplementationBinding, TProtocol extends string, TProcedures extends readonly ProcedureNamesForProtocol<TBinding, TProtocol>[], TCapabilities extends readonly string[]> = {
     readonly name: string;
-    readonly contract: TContract;
-    readonly protocol: AvailableProtocolConstraint<TContract, TProtocol, TCapabilities>;
-    readonly procedures: TProcedures;
-    readonly factory: () => ImplementationRuntimeShape<TContract, TProtocol, TProcedures[number]>;
+    readonly contract: TBinding;
+    readonly protocol: AvailableProtocolConstraint<TBinding, TProtocol, TCapabilities>;
+    readonly procedures: TProcedures & UniqueProcedureSelectionConstraint<TProcedures>;
+    readonly factory: () => ImplementationRuntimeShape<TBinding, TProtocol, TProcedures[number]>;
 };
-export declare function implementation<const TContract extends ContractDefinition, const TProtocol extends string, const TCapabilities extends readonly string[]>(declaration: FullImplementationDeclaration<TContract, TProtocol, TCapabilities>): ImplementationDescriptor<TContract, TProtocol, readonly ProcedureNamesForProtocol<TContract, TProtocol>[], ImplementationRuntimeShape<TContract, TProtocol, ProcedureNamesForProtocol<TContract, TProtocol>>, TCapabilities>;
-export declare function implementation<const TContract extends ContractDefinition, const TProtocol extends string, const TProcedures extends readonly ProcedureNamesForProtocol<TContract, TProtocol>[], const TCapabilities extends readonly string[]>(declaration: PartialImplementationDeclaration<TContract, TProtocol, TProcedures, TCapabilities>): ImplementationDescriptor<TContract, TProtocol, TProcedures, ImplementationRuntimeShape<TContract, TProtocol, TProcedures[number]>, TCapabilities>;
+export declare function implementation<const TBinding extends ImplementationBinding, const TProtocol extends string, const TCapabilities extends readonly string[]>(declaration: FullImplementationDeclaration<TBinding, TProtocol, TCapabilities>): ImplementationDescriptor<ContractOfBinding<TBinding>, TProtocol, readonly ProcedureNamesForProtocol<TBinding, TProtocol>[], ImplementationRuntimeShape<TBinding, TProtocol, ProcedureNamesForProtocol<TBinding, TProtocol>>, TCapabilities>;
+export declare function implementation<const TBinding extends ImplementationBinding, const TProtocol extends string, const TProcedures extends readonly ProcedureNamesForProtocol<TBinding, TProtocol>[], const TCapabilities extends readonly string[]>(declaration: PartialImplementationDeclaration<TBinding, TProtocol, TProcedures, TCapabilities>): ImplementationDescriptor<ContractOfBinding<TBinding>, TProtocol, TProcedures, ImplementationRuntimeShape<TBinding, TProtocol, TProcedures[number]>, TCapabilities>;
 export {};

package/dist/core/implementation.js

@@ -1,6 +1,11 @@
+import { contractNodeMetadataOf, contractOfBinding, } from './contract-internal.js';
 export function implementation(declaration) {
     const protocol = declaration.protocol.protocol;
-    const available = Object.entries(declaration.contract.procedures)
+    const contract = contractOfBinding(declaration.contract);
+    if (contractNodeMetadataOf(contract)?.kind === 'branch') {
+        throw new Error('LUTRE_IMPL_003: Implementation must bind to a resolved leaf Contract node.');
+    }
+    const available = Object.entries(contract.procedures)
         .filter(([, procedure]) => protocol in procedure.protocols)
         .map(([name]) => name);
     if (available.length === 0) {
@@ -13,7 +18,7 @@ export function implementation(declaration) {
             throw new Error(`LUTRE_IMPL_003: Implementation ${declaration.name} selects procedure ${procedure} more than once.`);
         }
         selected.add(procedure);
-        const definition = declaration.contract.procedures[procedure];
+        const definition = contract.procedures[procedure];
         if (!definition || !(protocol in definition.protocols)) {
             throw new Error(`LUTRE_IMPL_003: ${procedure} is not declared for protocol ${protocol}.`);
         }
@@ -21,7 +26,7 @@ export function implementation(declaration) {
     return Object.freeze({
         kind: 'implementation',
         name: declaration.name,
-        contract: declaration.contract,
+        contract,
         protocol,
         capabilities: declaration.protocol.capabilities ?? [],
         procedures: Object.freeze(procedures),

package/dist/core/layer.d.ts

@@ -79,7 +79,26 @@ interface PipelineTerminalState<THasTerminal extends boolean, TValid extends boo
 type InvalidPipelineTerminalState = PipelineTerminalState<boolean, false>;
 type FoldPipelineTerminals<TPipeline extends readonly PipelineItem[], TProtocol extends string, TState extends PipelineTerminalState<boolean, boolean>> = TState['valid'] extends false ? TState : number extends TPipeline['length'] ? InvalidPipelineTerminalState : TPipeline extends readonly [infer THead, ...infer TTail] ? TState['hasTerminal'] extends true ? InvalidPipelineTerminalState : FoldPipelineTerminals<Extract<TTail, readonly PipelineItem[]>, TProtocol, FoldPipelineItemTerminals<THead, TProtocol, TState>> : TState;
 type FoldPipelineItemTerminals<TItem, TProtocol extends string, TState extends PipelineTerminalState<boolean, boolean>> = TItem extends TerminalLayerDescriptor<infer TItemProtocol> ? [TItemProtocol, TProtocol] extends [TProtocol, TItemProtocol] ? PipelineTerminalState<true, true> : InvalidPipelineTerminalState : TItem extends LayerOccurrenceDescriptor<any, any, any, any, any, any, any, any, infer TPipeline> ? FoldPipelineTerminals<TPipeline, TProtocol, TState> : TState;
-export type IsValidProtocolPipeline<TPipeline extends readonly PipelineItem[], TProtocol extends string> = FoldPipelineTerminals<TPipeline, TProtocol, PipelineTerminalState<false, true>> extends PipelineTerminalState<true, true> ? true : false;
+type ContextKeyNameOf<TKey> = TKey extends ContextKey<infer TName, any> ? TName : never;
+type ContextKeyNamesOf<TKeys extends readonly ContextKey[]> = ContextKeyNameOf<TKeys[number]>;
+type DuplicateContextKeyNames<TKeys extends readonly ContextKey[], TSeen extends string = never> = number extends TKeys['length'] ? never : TKeys extends readonly [
+    infer THead extends ContextKey,
+    ...infer TTail extends readonly ContextKey[]
+] ? ContextKeyNameOf<THead> extends infer TName extends string ? TName extends TSeen ? TName | DuplicateContextKeyNames<TTail, TSeen> : DuplicateContextKeyNames<TTail, TSeen | TName> : never : never;
+type AreRequiredContextKeysAvailable<TRequires extends readonly ContextKey[], TAvailable extends ContextKey> = [TRequires[number]] extends [never] ? true : false extends (TRequires[number] extends infer TRequired extends ContextKey ? TRequired extends TAvailable ? true : false : never) ? false : true;
+type AreRequiredValidatedPartsAvailable<TRequires extends readonly ValidatedInputPart[], TValidated extends ValidatedInputPart> = Exclude<TRequires[number], TValidated> extends never ? true : false;
+type HasProvidedContextCollision<TProvides extends readonly ContextKey[], TAvailable extends ContextKey> = DuplicateContextKeyNames<TProvides> | Extract<ContextKeyNamesOf<TProvides>, ContextKeyNameOf<TAvailable>> extends never ? false : true;
+interface PipelineRequirementState<TAvailable extends ContextKey, TValidated extends ValidatedInputPart, TValid extends boolean> {
+    readonly available: TAvailable;
+    readonly validated: TValidated;
+    readonly valid: TValid;
+}
+type InvalidPipelineRequirementState = PipelineRequirementState<ContextKey, ValidatedInputPart, false>;
+type FoldLayerRequirements<TRequires extends readonly ContextKey[], TProvides extends readonly ContextKey[], TRequiresValidated extends readonly ValidatedInputPart[], TState extends PipelineRequirementState<ContextKey, ValidatedInputPart, boolean>> = TState['valid'] extends false ? TState : AreRequiredContextKeysAvailable<TRequires, TState['available']> extends true ? AreRequiredValidatedPartsAvailable<TRequiresValidated, TState['validated']> extends true ? HasProvidedContextCollision<TProvides, TState['available']> extends false ? PipelineRequirementState<TState['available'] | TProvides[number], TState['validated'], true> : InvalidPipelineRequirementState : InvalidPipelineRequirementState : InvalidPipelineRequirementState;
+type FoldPipelineRequirements<TPipeline extends readonly PipelineItem[], TState extends PipelineRequirementState<ContextKey, ValidatedInputPart, boolean>> = TState['valid'] extends false ? TState : number extends TPipeline['length'] ? TState : TPipeline extends readonly [infer THead, ...infer TTail] ? FoldPipelineRequirements<Extract<TTail, readonly PipelineItem[]>, FoldPipelineItemRequirements<THead, TState>> : TState;
+type FoldPipelineItemRequirements<TItem, TState extends PipelineRequirementState<ContextKey, ValidatedInputPart, boolean>> = TItem extends ValidationLayerDescriptor ? PipelineRequirementState<TState['available'], TState['validated'] | TItem['part'], TState['valid']> : TItem extends LayerOccurrenceDescriptor<infer TRequires, infer TProvides, any, any, any, any, infer TRequiresValidated, any, infer TPipeline> ? FoldPipelineRequirements<TPipeline, FoldLayerRequirements<TRequires, TProvides, TRequiresValidated, TState>> : TItem extends LayerDescriptor<infer TRequires, infer TProvides, any, any, any, any, infer TRequiresValidated, any> ? FoldLayerRequirements<TRequires, TProvides, TRequiresValidated, TState> : TState;
+type IsPipelineRequirementsValid<TPipeline extends readonly PipelineItem[]> = FoldPipelineRequirements<TPipeline, PipelineRequirementState<never, never, true>>['valid'] extends true ? true : false;
+export type IsValidProtocolPipeline<TPipeline extends readonly PipelineItem[], TProtocol extends string> = FoldPipelineTerminals<TPipeline, TProtocol, PipelineTerminalState<false, true>> extends PipelineTerminalState<true, true> ? IsPipelineRequirementsValid<TPipeline> : false;
 export type ShortCircuitResultOf<TItem> = TItem extends LayerOccurrenceDescriptor<any, any, any, any, any, any, any, any, infer TPipeline> ? ShortCircuitResultOfPipeline<TPipeline> | ShortCircuitResultOfLayer<TItem> : ShortCircuitResultOfLayer<TItem>;
 type ShortCircuitResultOfLayer<TItem> = TItem extends {
     readonly [shortCircuitResultType]?: infer TResult;
@@ -105,5 +124,14 @@ type FoldPipeline<TPipeline extends readonly PipelineItem[], TState extends Pipe
 type FoldPipelineItem<TItem, TState extends PipelineTypeState<object, ValidatedInputPart, boolean>> = TItem extends TerminalLayerDescriptor ? PipelineTypeState<TState['context'], TState['validated'], true> : TItem extends ValidationLayerDescriptor ? PipelineTypeState<TState['context'], TState['validated'] | TItem['part'], false> : TItem extends LayerOccurrenceDescriptor<any, infer TProvides, any, any, any, any, any, any, infer TPipeline> ? FoldPipeline<TPipeline, PipelineTypeState<TState['context'] & ContextProperties<TProvides>, TState['validated'], false>> : TItem extends LayerDescriptor<any, infer TProvides, any, any, any, any, any, any> ? PipelineTypeState<TState['context'] & ContextProperties<TProvides>, TState['validated'], false> : TState;
 export type ContextProvidedBeforeTerminal<TPipeline extends readonly PipelineItem[], TContext extends object = {}> = number extends TPipeline['length'] ? TContext : FoldPipeline<TPipeline, PipelineTypeState<TContext, never, false>>['context'];
 export type HasValidationBeforeTerminal<TPipeline extends readonly PipelineItem[], TPart extends ValidatedInputPart> = number extends TPipeline['length'] ? false : TPart extends FoldPipeline<TPipeline, PipelineTypeState<{}, never, false>>['validated'] ? true : false;
-export declare function layer<const TRequires extends readonly ContextKey[] = readonly [], const TProvides extends readonly ContextKey[] = readonly [], TContext extends object = {}, TShortCircuitResult = never, const TShortCircuits extends readonly ShortCircuitDeclaration[] = readonly [], const TName extends string = string, const TRole extends Exclude<LayerRole, 'terminal' | 'validation'> = 'generic', const TRequiresValidated extends readonly ValidatedInputPart[] = readonly []>(definition: LayerDefinition<TRequires, TProvides, TContext, TShortCircuitResult, TShortCircuits, TName, TRole, TRequiresValidated>): LayerDescriptor<TRequires, TProvides, TShortCircuitResult, TShortCircuits, TName, TRole, TRequiresValidated, TContext>;
+type DuplicateValidatedInputParts<TParts extends readonly ValidatedInputPart[], TSeen extends ValidatedInputPart = never> = number extends TParts['length'] ? never : TParts extends readonly [
+    infer THead extends ValidatedInputPart,
+    ...infer TTail extends readonly ValidatedInputPart[]
+] ? THead extends TSeen ? THead | DuplicateValidatedInputParts<TTail, TSeen> : DuplicateValidatedInputParts<TTail, TSeen | THead> : never;
+type LayerDefinitionConstraint<TRequires extends readonly ContextKey[], TProvides extends readonly ContextKey[], TRequiresValidated extends readonly ValidatedInputPart[]> = [
+    DuplicateContextKeyNames<TRequires> | DuplicateContextKeyNames<TProvides> | Extract<ContextKeyNamesOf<TRequires>, ContextKeyNamesOf<TProvides>> | DuplicateValidatedInputParts<TRequiresValidated>
+] extends [never] ? unknown : {
+    readonly __invalidLayerDefinition__: never;
+};
+export declare function layer<const TRequires extends readonly ContextKey[] = readonly [], const TProvides extends readonly ContextKey[] = readonly [], TContext extends object = {}, TShortCircuitResult = never, const TShortCircuits extends readonly ShortCircuitDeclaration[] = readonly [], const TName extends string = string, const TRole extends Exclude<LayerRole, 'terminal' | 'validation'> = 'generic', const TRequiresValidated extends readonly ValidatedInputPart[] = readonly []>(definition: LayerDefinition<TRequires, TProvides, TContext, TShortCircuitResult, TShortCircuits, TName, TRole, TRequiresValidated> & LayerDefinitionConstraint<TRequires, TProvides, TRequiresValidated>): LayerDescriptor<TRequires, TProvides, TShortCircuitResult, TShortCircuits, TName, TRole, TRequiresValidated, TContext>;
 export {};

package/dist/core/layer.js

@@ -21,7 +21,36 @@ export function layerDefinitionOf(item) {
 export function childPipelineOf(item) {
     return isLayerOccurrence(item) ? item.pipeline : undefined;
 }
+function assertUniqueContextKeyNames(keys, label) {
+    const names = new Set();
+    for (const key of keys) {
+        if (names.has(key.name)) {
+            throw new Error(`Layer ${label} contains duplicate Context property ${key.name}`);
+        }
+        names.add(key.name);
+    }
+}
+function assertLayerDefinition(definition) {
+    const requires = definition.requires ?? [];
+    const provides = definition.provides ?? [];
+    assertUniqueContextKeyNames(requires, 'requires');
+    assertUniqueContextKeyNames(provides, 'provides');
+    const requiredNames = new Set(requires.map((key) => key.name));
+    for (const key of provides) {
+        if (requiredNames.has(key.name)) {
+            throw new Error(`Layer cannot require and provide the same Context property ${key.name}`);
+        }
+    }
+    const validated = new Set();
+    for (const part of definition.requiresValidated ?? []) {
+        if (validated.has(part)) {
+            throw new Error(`Layer requiresValidated contains duplicate part ${part}`);
+        }
+        validated.add(part);
+    }
+}
 export function layer(definition) {
+    assertLayerDefinition(definition);
     let descriptor;
     const callable = (pipeline) => Object.freeze({
         kind: 'layer',

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const LOUTRE_VERSION = "0.4.1";
+export declare const LOUTRE_VERSION = "0.5.0";

package/dist/generated/version.js

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

package/dist/graph/graph.d.ts

@@ -1,4 +1,4 @@
-import { type ArgsClass, type ModuleInstance, type ModuleTemplate, type TaskDescriptor, type TriggerDescriptor } from '../core/index.js';
+import { type ArgsClass, type ContractBinding, type ModuleInstance, type ModuleTemplate, type TaskDescriptor, type TriggerDescriptor } from '../core/index.js';
 import type { ApplicationGraphIR, CompilationResult, Diagnostic } from './ir.js';
 export declare class StaticValidationError extends Error {
     readonly diagnostics: readonly Diagnostic[];
@@ -6,6 +6,7 @@ export declare class StaticValidationError extends Error {
     constructor(diagnostics: readonly Diagnostic[], graph?: ApplicationGraphIR | undefined);
 }
 export interface ApplicationCompilationInput {
+    readonly contract?: ContractBinding;
     readonly modules: readonly (ModuleInstance | ModuleTemplate<void>)[];
     readonly arguments?: ArgsClass | undefined;
     readonly tasks?: readonly TaskDescriptor<any, any>[];