@loutrejs/loutre 0.5.0 → 0.7.0

package/dist/core/contract.d.ts

@@ -1,96 +0,0 @@
-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;
-    readonly interaction?: InteractionMode;
-    readonly dispatchKey: TDispatchKey;
-    readonly capabilities?: TCapabilities;
-    readonly '~context'?: TContext;
-    readonly '~result'?: TResult;
-}
-export type InteractionMode = 'unary' | 'server-stream' | 'client-stream' | 'duplex';
-export interface ProcedureDefinition<TProtocols extends Record<string, ProtocolDescriptor> = Record<string, ProtocolDescriptor>> {
-    readonly kind: 'procedure';
-    readonly protocols: 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 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 ? {
-    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 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 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;
-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 {
-            readonly dispatchKey: infer TDispatchKey extends string | null;
-        } ? TDispatchKey extends string ? {
-            readonly key: TDispatchKey;
-            readonly path: `${TProcedure}.${TProtocol}`;
-        } : never : never;
-    }[keyof TProcedures[TProcedure]['protocols'] & string];
-}[keyof TProcedures & string];
-type IsUnion<TValue, TCandidate = TValue> = TValue extends unknown ? [TCandidate] extends [TValue] ? false : true : never;
-type DuplicateDispatchKeys<TEntries, TAllEntries = TEntries> = TEntries extends {
-    readonly key: infer TKey extends string;
-} ? string extends TKey ? never : IsUnion<Extract<TAllEntries, {
-    readonly key: TKey;
-}> extends {
-    readonly path: infer TPath;
-} ? TPath : never> extends true ? TKey : never : never;
-export type ContractProcedures<TContract extends ContractDefinition> = TContract['procedures'];
-export interface ProtocolFactory<TName extends string, TCapabilities extends readonly string[] = readonly string[]> {
-    readonly protocol: TName;
-    readonly capabilities?: TCapabilities;
-}
-export {};

package/dist/core/contract.js

@@ -1,88 +0,0 @@
-import { contractNodeBinding, contractNodeKindType, protocolNamespaceBuilder, protocolNamespaceType, } from './contract-internal.js';
-export function protocolGroup(protocol, procedures) {
-    return Object.freeze({
-        kind: 'protocol-group',
-        protocol,
-        procedures: Object.freeze({ ...procedures }),
-    });
-}
-function defineContract(groups, ..._validation) {
-    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);
-    const resolved = {
-        kind: 'contract',
-        procedures: Object.freeze(procedures),
-    };
-    const namespaceBuilders = [];
-    for (const group of groups) {
-        const build = group[protocolNamespaceBuilder];
-        if (typeof build !== 'function')
-            continue;
-        namespaceBuilders.push({
-            protocol: group.protocol,
-            build: build,
-        });
-    }
-    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}`);
-            }
-        }
-        resolved[protocol] = Object.freeze({ ...current, ...namespace });
-    }
-}
-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)) {
-        for (const [protocolName, protocol] of Object.entries(procedureDefinition.protocols)) {
-            const dispatchKey = protocol.dispatchKey;
-            if (dispatchKey === null)
-                continue;
-            if (typeof dispatchKey !== 'string') {
-                throw new Error(`Protocol dispatchKey must be a string or null: ${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}`);
-            }
-            paths.set(dispatchKey, path);
-        }
-    }
-}

package/dist/core/execution.d.ts

@@ -1,78 +0,0 @@
-import { type SchemaOutput, type StandardSchemaV1 } from './schema.js';
-import { type Token } from './token.js';
-export type TaskRuntime<TInput, TOutput> = [TInput] extends [void] ? () => TOutput | Promise<TOutput> : (input: TInput) => TOutput | Promise<TOutput>;
-export interface TaskDescriptor<TInput = unknown, TOutput = unknown, TName extends string = string> {
-    readonly kind: 'task';
-    readonly name: TName;
-    readonly factory: () => TaskRuntime<TInput, TOutput>;
-}
-export type TaskInput<T> = T extends TaskDescriptor<infer TInput, any, any> ? TInput : never;
-export type TaskOutput<T> = T extends TaskDescriptor<any, infer TOutput, any> ? TOutput : never;
-export type TaskArguments<T> = [TaskInput<T>] extends [void] ? readonly [] : readonly [input: TaskInput<T>];
-export declare function task<TInput = void, TOutput = void, const TName extends string = string>(declaration: {
-    readonly name: TName;
-    readonly factory: () => TaskRuntime<TInput, TOutput>;
-}): TaskDescriptor<TInput, TOutput, TName>;
-type VoidTaskConstraint<TTask> = [TaskInput<TTask>] extends [void] ? unknown : never;
-export type CronOverlap = 'allow' | 'skip';
-export interface CronTriggerDescriptor<TTask extends TaskDescriptor<void, any> = TaskDescriptor<void, any>, TName extends string = string> {
-    readonly kind: 'trigger';
-    readonly trigger: 'cron';
-    readonly name: TName;
-    readonly expression: string;
-    readonly timezone: string;
-    readonly overlap: CronOverlap;
-    readonly task: TTask;
-}
-export declare function cron<const TTask extends TaskDescriptor<any, any>, const TName extends string>(declaration: {
-    readonly name: TName;
-    readonly expression: string;
-    readonly timezone: string;
-    readonly overlap?: CronOverlap;
-    readonly task: TTask;
-} & VoidTaskConstraint<TTask>): CronTriggerDescriptor<TTask & TaskDescriptor<void, any>, TName>;
-export interface FixedDelayTriggerDescriptor<TTask extends TaskDescriptor<void, any> = TaskDescriptor<void, any>, TName extends string = string> {
-    readonly kind: 'trigger';
-    readonly trigger: 'fixed-delay';
-    readonly name: TName;
-    readonly delay: number;
-    readonly immediate: boolean;
-    readonly task: TTask;
-}
-export declare function fixedDelay<const TTask extends TaskDescriptor<any, any>, const TName extends string>(declaration: {
-    readonly name: TName;
-    readonly delay: number;
-    readonly immediate?: boolean;
-    readonly task: TTask;
-} & VoidTaskConstraint<TTask>): FixedDelayTriggerDescriptor<TTask & TaskDescriptor<void, any>, TName>;
-declare const queueDriverToken: unique symbol;
-export interface QueueDescriptor<TSchema extends StandardSchemaV1 = StandardSchemaV1, TName extends string = string> {
-    readonly kind: 'queue';
-    readonly name: TName;
-    readonly payload: TSchema;
-    readonly [queueDriverToken]: Token<unknown>;
-}
-export type QueuePayload<T> = T extends QueueDescriptor<infer TSchema, any> ? SchemaOutput<TSchema> : never;
-export declare function queue<const TSchema extends StandardSchemaV1, const TName extends string = string>(declaration: {
-    readonly name: TName;
-    readonly payload: TSchema;
-}): QueueDescriptor<TSchema, TName>;
-export declare function queueRuntimeToken(descriptor: QueueDescriptor): Token<unknown>;
-export interface QueueConsumerTriggerDescriptor<TQueue extends QueueDescriptor<any> = QueueDescriptor<any>, TTask extends TaskDescriptor<any, any> = TaskDescriptor<any, any>, TName extends string = string> {
-    readonly kind: 'trigger';
-    readonly trigger: 'queue-consumer';
-    readonly name: TName;
-    readonly queue: TQueue;
-    readonly task: TTask;
-}
-type ConsumerTaskConstraint<TQueue, TTask> = [TaskInput<TTask>] extends [
-    QueuePayload<TQueue>
-] ? [QueuePayload<TQueue>] extends [TaskInput<TTask>] ? unknown : never : never;
-export declare function consume<const TQueue extends QueueDescriptor<any>, const TTask extends TaskDescriptor<any, any>, const TName extends string>(declaration: {
-    readonly name: TName;
-    readonly queue: TQueue;
-    readonly task: TTask;
-} & ConsumerTaskConstraint<TQueue, TTask>): QueueConsumerTriggerDescriptor<TQueue, TTask & TaskDescriptor<QueuePayload<TQueue>, any>, TName>;
-export type TriggerDescriptor = CronTriggerDescriptor<any, any> | FixedDelayTriggerDescriptor<any, any> | QueueConsumerTriggerDescriptor<any, any, any>;
-export type TriggerTask<TTrigger> = TTrigger extends TriggerDescriptor ? TTrigger['task'] : never;
-export {};

package/dist/core/execution.js

@@ -1,61 +0,0 @@
-import { token } from './token.js';
-export function task(declaration) {
-    return Object.freeze({
-        kind: 'task',
-        name: declaration.name,
-        factory: declaration.factory,
-    });
-}
-export function cron(declaration) {
-    return Object.freeze({
-        kind: 'trigger',
-        trigger: 'cron',
-        name: declaration.name,
-        expression: declaration.expression,
-        timezone: declaration.timezone,
-        overlap: declaration.overlap ?? 'skip',
-        task: declaration.task,
-    });
-}
-export function fixedDelay(declaration) {
-    if (!Number.isFinite(declaration.delay) ||
-        !Number.isInteger(declaration.delay) ||
-        declaration.delay < 0) {
-        throw new Error('LUTRE_TRIGGER_INVALID_FIXED_DELAY: fixedDelay.delay must be a non-negative finite integer.');
-    }
-    return Object.freeze({
-        kind: 'trigger',
-        trigger: 'fixed-delay',
-        name: declaration.name,
-        delay: declaration.delay,
-        immediate: declaration.immediate ?? false,
-        task: declaration.task,
-    });
-}
-const queueDriverToken = Symbol('loutre.queue-driver');
-export function queue(declaration) {
-    const payload = declaration.payload;
-    if (payload === null ||
-        (typeof payload !== 'object' && typeof payload !== 'function') ||
-        !('~standard' in payload)) {
-        throw new Error('LUTRE_QUEUE_PAYLOAD_SCHEMA: queue.payload must implement Standard Schema.');
-    }
-    return Object.freeze({
-        kind: 'queue',
-        name: declaration.name,
-        payload: declaration.payload,
-        [queueDriverToken]: token(`loutre.queue-driver.${declaration.name}`),
-    });
-}
-export function queueRuntimeToken(descriptor) {
-    return descriptor[queueDriverToken];
-}
-export function consume(declaration) {
-    return Object.freeze({
-        kind: 'trigger',
-        trigger: 'queue-consumer',
-        name: declaration.name,
-        queue: declaration.queue,
-        task: declaration.task,
-    });
-}

package/dist/core/implementation.d.ts

@@ -1,44 +0,0 @@
-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<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[]> {
-    readonly kind: 'implementation';
-    readonly name: string;
-    readonly contract: TContract;
-    readonly protocol: TProtocol;
-    readonly capabilities: TCapabilities;
-    readonly procedures: TProcedures;
-    readonly factory: () => TRuntime;
-}
-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: TBinding;
-    readonly protocol: AvailableProtocolConstraint<TBinding, TProtocol, TCapabilities>;
-    readonly procedures?: never;
-    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<TBinding extends ImplementationBinding, TProtocol extends string, TProcedures extends readonly ProcedureNamesForProtocol<TBinding, TProtocol>[], TCapabilities extends readonly string[]> = {
-    readonly name: string;
-    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 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,35 +0,0 @@
-import { contractNodeMetadataOf, contractOfBinding, } from './contract-internal.js';
-export function implementation(declaration) {
-    const protocol = declaration.protocol.protocol;
-    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) {
-        throw new Error(`LUTRE_IMPL_003: Contract does not declare any procedure for protocol ${protocol}.`);
-    }
-    const procedures = [...(declaration.procedures ?? available)];
-    const selected = new Set();
-    for (const procedure of procedures) {
-        if (selected.has(procedure)) {
-            throw new Error(`LUTRE_IMPL_003: Implementation ${declaration.name} selects procedure ${procedure} more than once.`);
-        }
-        selected.add(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}.`);
-        }
-    }
-    return Object.freeze({
-        kind: 'implementation',
-        name: declaration.name,
-        contract,
-        protocol,
-        capabilities: declaration.protocol.capabilities ?? [],
-        procedures: Object.freeze(procedures),
-        factory: declaration.factory,
-    });
-}

package/dist/core/layer.d.ts

@@ -1,137 +0,0 @@
-import type { ContextKey, ContextProperties } from './context-key.js';
-export type LayerRole = 'generic' | 'authentication' | 'guard' | 'validation' | 'framework' | 'terminal';
-export type ValidatedInputPart = 'params' | 'query' | 'headers' | 'body';
-declare const shortCircuitMarker: unique symbol;
-export interface ShortCircuit<TResult = unknown> {
-    readonly kind: 'short-circuit';
-    readonly result: TResult;
-    readonly [shortCircuitMarker]: true;
-}
-export declare function shortCircuit<const TResult>(result: TResult): ShortCircuit<TResult>;
-export declare function isShortCircuit(value: unknown): value is ShortCircuit;
-declare const shortCircuitResultType: unique symbol;
-export interface ShortCircuitDeclaration {
-    readonly protocol: string;
-    readonly variant: string;
-    readonly response?: Readonly<Record<string, unknown>>;
-}
-export type LayerNext<TProvides extends readonly ContextKey[]> = number extends TProvides['length'] ? (provided: ContextProperties<TProvides>) => Promise<void> : TProvides extends readonly [] ? () => Promise<void> : (provided: ContextProperties<TProvides>) => Promise<void>;
-export type LayerRuntime<TContext extends object, TProvides extends readonly ContextKey[], TShortCircuitResult> = (context: TContext, next: LayerNext<TProvides>) => Promise<void | ShortCircuit<TShortCircuitResult>>;
-export type LayerFactory<TContext extends object, TProvides extends readonly ContextKey[], TShortCircuitResult> = () => LayerRuntime<TContext, TProvides, TShortCircuitResult>;
-export interface LayerDefinition<TRequires extends readonly ContextKey[] = readonly [], TProvides extends readonly ContextKey[] = readonly [], TContext extends object = {}, TShortCircuitResult = never, TShortCircuits extends readonly ShortCircuitDeclaration[] = readonly [], TName extends string = string, TRole extends Exclude<LayerRole, 'terminal' | 'validation'> = 'generic', TRequiresValidated extends readonly ValidatedInputPart[] = readonly []> {
-    readonly name: TName;
-    readonly role?: TRole;
-    readonly requires?: TRequires;
-    readonly provides?: TProvides;
-    readonly requiresValidated?: TRequiresValidated;
-    readonly shortCircuits?: TShortCircuits;
-    readonly factory: LayerFactory<TContext & ContextProperties<TRequires>, TProvides, TShortCircuitResult>;
-}
-export interface LayerOccurrenceDescriptor<TRequires extends readonly ContextKey[] = readonly ContextKey[], TProvides extends readonly ContextKey[] = readonly ContextKey[], TShortCircuitResult = unknown, TShortCircuits extends readonly ShortCircuitDeclaration[] = readonly ShortCircuitDeclaration[], TName extends string = string, TRole extends Exclude<LayerRole, 'terminal' | 'validation'> = Exclude<LayerRole, 'terminal' | 'validation'>, TRequiresValidated extends readonly ValidatedInputPart[] = readonly ValidatedInputPart[], TContext extends object = object, TPipeline extends readonly PipelineItem[] = readonly PipelineItem[]> {
-    readonly kind: 'layer';
-    readonly name: TName;
-    readonly role: TRole;
-    readonly requires: TRequires;
-    readonly provides: TProvides;
-    readonly requiresValidated: TRequiresValidated;
-    readonly shortCircuits: TShortCircuits;
-    readonly definition: LayerDescriptor<TRequires, TProvides, TShortCircuitResult, TShortCircuits, TName, TRole, TRequiresValidated, TContext>;
-    readonly pipeline: TPipeline;
-    readonly factory?: never;
-    readonly [shortCircuitResultType]?: TShortCircuitResult;
-}
-export interface LayerDescriptor<TRequires extends readonly ContextKey[] = readonly ContextKey[], TProvides extends readonly ContextKey[] = readonly ContextKey[], TShortCircuitResult = unknown, TShortCircuits extends readonly ShortCircuitDeclaration[] = readonly ShortCircuitDeclaration[], TName extends string = string, TRole extends Exclude<LayerRole, 'terminal' | 'validation'> = Exclude<LayerRole, 'terminal' | 'validation'>, TRequiresValidated extends readonly ValidatedInputPart[] = readonly ValidatedInputPart[], TContext extends object = object> {
-    <const TPipeline extends readonly PipelineItem[]>(pipeline: TPipeline): LayerOccurrenceDescriptor<TRequires, TProvides, TShortCircuitResult, TShortCircuits, TName, TRole, TRequiresValidated, TContext, TPipeline>;
-    readonly kind: 'layer';
-    readonly name: TName;
-    readonly role: TRole;
-    readonly requires: TRequires;
-    readonly provides: TProvides;
-    readonly requiresValidated: TRequiresValidated;
-    readonly shortCircuits: TShortCircuits;
-    readonly factory: LayerFactory<TContext & ContextProperties<TRequires>, TProvides, TShortCircuitResult>;
-    readonly definition?: never;
-    readonly pipeline?: never;
-    readonly [shortCircuitResultType]?: TShortCircuitResult;
-}
-export interface ValidationLayerDescriptor {
-    readonly kind: 'validation';
-    readonly name: `validate.${'params' | 'query' | 'headers' | 'body'}`;
-    readonly role: 'validation';
-    readonly part: 'params' | 'query' | 'headers' | 'body';
-}
-export interface TerminalLayerDescriptor<TProtocol extends string = string> {
-    readonly kind: 'terminal';
-    readonly name: `${TProtocol}.${string}`;
-    readonly role: 'terminal';
-    readonly protocol: TProtocol;
-}
-type AnyLayerDescriptor = LayerDescriptor<any, any, any, any, any, any, any, any>;
-type AnyLayerOccurrence = LayerOccurrenceDescriptor<any, any, any, any, any, any, any, any, any>;
-export type PipelineItem = AnyLayerDescriptor | AnyLayerOccurrence | ValidationLayerDescriptor | TerminalLayerDescriptor;
-export declare function isLayerOccurrence(item: PipelineItem): item is AnyLayerOccurrence;
-export declare function layerDefinitionOf(item: AnyLayerDescriptor | AnyLayerOccurrence): AnyLayerDescriptor;
-export declare function childPipelineOf(item: AnyLayerDescriptor | AnyLayerOccurrence): readonly PipelineItem[] | undefined;
-interface PipelineTerminalState<THasTerminal extends boolean, TValid extends boolean> {
-    readonly hasTerminal: THasTerminal;
-    readonly valid: TValid;
-}
-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;
-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;
-} ? TResult : never;
-export type ShortCircuitDeclarationsOf<TItem> = TItem extends LayerOccurrenceDescriptor<any, any, any, any, any, any, any, any, infer TPipeline> ? readonly [
-    ...NormalizeDeclarations<TItem['shortCircuits']>,
-    ...ShortCircuitDeclarationsOfPipeline<TPipeline>
-] : TItem extends {
-    readonly shortCircuits: infer TShortCircuits;
-} ? TShortCircuits : never;
-type ShortCircuitResultOfPipeline<TPipeline extends readonly PipelineItem[]> = TPipeline[number] extends infer TItem ? ShortCircuitResultOf<TItem> : never;
-type ShortCircuitDeclarationsOfPipeline<TPipeline extends readonly PipelineItem[]> = TPipeline extends readonly [infer THead, ...infer TTail] ? readonly [
-    ...NormalizeDeclarations<ShortCircuitDeclarationsOf<THead>>,
-    ...ShortCircuitDeclarationsOfPipeline<Extract<TTail, readonly PipelineItem[]>>
-] : readonly [];
-type NormalizeDeclarations<TDeclarations> = TDeclarations extends readonly ShortCircuitDeclaration[] ? TDeclarations : readonly [];
-interface PipelineTypeState<TContext extends object, TValidated extends ValidatedInputPart, TDone extends boolean> {
-    readonly context: TContext;
-    readonly validated: TValidated;
-    readonly done: TDone;
-}
-type FoldPipeline<TPipeline extends readonly PipelineItem[], TState extends PipelineTypeState<object, ValidatedInputPart, boolean>> = TState['done'] extends true ? TState : number extends TPipeline['length'] ? TState : TPipeline extends readonly [infer THead, ...infer TTail] ? FoldPipeline<Extract<TTail, readonly PipelineItem[]>, FoldPipelineItem<THead, TState>> : TState;
-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;
-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

@@ -1,81 +0,0 @@
-const shortCircuitMarker = Symbol('loutre.short-circuit');
-export function shortCircuit(result) {
-    return {
-        kind: 'short-circuit',
-        result,
-        [shortCircuitMarker]: true,
-    };
-}
-export function isShortCircuit(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        shortCircuitMarker in value &&
-        value[shortCircuitMarker] === true);
-}
-export function isLayerOccurrence(item) {
-    return item.kind === 'layer' && item.definition !== undefined;
-}
-export function layerDefinitionOf(item) {
-    return isLayerOccurrence(item) ? item.definition : 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',
-        name: descriptor.name,
-        role: descriptor.role,
-        requires: descriptor.requires,
-        provides: descriptor.provides,
-        requiresValidated: descriptor.requiresValidated,
-        shortCircuits: descriptor.shortCircuits,
-        definition: descriptor,
-        pipeline,
-    });
-    Object.defineProperty(callable, 'name', {
-        value: definition.name,
-        enumerable: true,
-        configurable: true,
-    });
-    descriptor = Object.assign(callable, {
-        kind: 'layer',
-        role: definition.role ?? 'generic',
-        requires: definition.requires ?? [],
-        provides: definition.provides ?? [],
-        requiresValidated: definition.requiresValidated ?? [],
-        shortCircuits: definition.shortCircuits ?? [],
-        factory: definition.factory,
-    });
-    return Object.freeze(descriptor);
-}

package/dist/graph/compiler.d.ts

@@ -1,4 +0,0 @@
-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;